variable.c@ 534

Last change on this file since 534 was 534, checked in by bird, 18 years ago
Made it build again on linux.
Property svn:eol-style set to `native`
File size: 55.4 KB

Line
1	/* Internals of variables for GNU Make.
2	Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3	1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4	Foundation, Inc.
5	This file is part of GNU Make.
6
7	GNU Make is free software; you can redistribute it and/or modify it under the
8	terms of the GNU General Public License as published by the Free Software
9	Foundation; either version 2, or (at your option) any later version.
10
11	GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License along with
16	GNU Make; see the file COPYING. If not, write to the Free Software
17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
18
19	#include "make.h"
20
21	#include <assert.h>
22
23	#include "dep.h"
24	#include "filedef.h"
25	#include "job.h"
26	#include "commands.h"
27	#include "variable.h"
28	#include "rule.h"
29	#ifdef WINDOWS32
30	#include "pathstuff.h"
31	#endif
32	#include "hash.h"
33
34	/* Chain of all pattern-specific variables. */
35
36	static struct pattern_var *pattern_vars;
37
38	/* Pointer to last struct in the chain, so we can add onto the end. */
39
40	static struct pattern_var *last_pattern_var;
41
42	/* Create a new pattern-specific variable struct. */
43
44	struct pattern_var *
45	create_pattern_var (char target, char suffix)
46	{
47	register struct pattern_var *p
48	= (struct pattern_var *) xmalloc (sizeof (struct pattern_var));
49
50	if (last_pattern_var != 0)
51	last_pattern_var->next = p;
52	else
53	pattern_vars = p;
54	last_pattern_var = p;
55	p->next = 0;
56
57	p->target = target;
58	p->len = strlen (target);
59	p->suffix = suffix + 1;
60
61	return p;
62	}
63
64	/* Look up a target in the pattern-specific variable list. */
65
66	static struct pattern_var *
67	lookup_pattern_var (struct pattern_var start, char target)
68	{
69	struct pattern_var *p;
70	unsigned int targlen = strlen(target);
71
72	for (p = start ? start->next : pattern_vars; p != 0; p = p->next)
73	{
74	char *stem;
75	unsigned int stemlen;
76
77	if (p->len > targlen)
78	/* It can't possibly match. */
79	continue;
80
81	/* From the lengths of the filename and the pattern parts,
82	find the stem: the part of the filename that matches the %. */
83	stem = target + (p->suffix - p->target - 1);
84	stemlen = targlen - p->len + 1;
85
86	/* Compare the text in the pattern before the stem, if any. */
87	if (stem > target && !strneq (p->target, target, stem - target))
88	continue;
89
90	/* Compare the text in the pattern after the stem, if any.
91	We could test simply using streq, but this way we compare the
92	first two characters immediately. This saves time in the very
93	common case where the first character matches because it is a
94	period. */
95	if (*p->suffix == stem[stemlen]
96	&& (*p->suffix == '\0' \|\| streq (&p->suffix[1], &stem[stemlen+1])))
97	break;
98	}
99
100	return p;
101	}
102
103
104	/* Hash table of all global variable definitions. */
105
106	#ifdef CONFIG_WITH_OPTIMIZATION_HACKS
107	# ifdef _MSC_VER
108	# define inline _inline
109	typedef signed int int32_t;
110	typedef signed short int int16_t;
111	# endif
112	static inline unsigned long variable_hash_2i(register const unsigned char *var, register int length)
113	{
114	register unsigned int hash = 0;
115	var += length;
116	switch (length)
117	{
118	default:
119	case 16: hash = *--var + (hash << 6) + (hash << 16) - hash;
120	case 15: hash = *--var + (hash << 6) + (hash << 16) - hash;
121	case 14: hash = *--var + (hash << 6) + (hash << 16) - hash;
122	case 13: hash = *--var + (hash << 6) + (hash << 16) - hash;
123	case 12: hash = *--var + (hash << 6) + (hash << 16) - hash;
124	case 11: hash = *--var + (hash << 6) + (hash << 16) - hash;
125	case 10: hash = *--var + (hash << 6) + (hash << 16) - hash;
126	case 9: hash = *--var + (hash << 6) + (hash << 16) - hash;
127	case 8: hash = *--var + (hash << 6) + (hash << 16) - hash;
128	case 7: hash = *--var + (hash << 6) + (hash << 16) - hash;
129	case 6: hash = *--var + (hash << 6) + (hash << 16) - hash;
130	case 5: hash = *--var + (hash << 6) + (hash << 16) - hash;
131	case 4: hash = *--var + (hash << 6) + (hash << 16) - hash;
132	case 3: hash = *--var + (hash << 6) + (hash << 16) - hash;
133	case 2: hash = *--var + (hash << 6) + (hash << 16) - hash;
134	case 1: hash = *--var + (hash << 6) + (hash << 16) - hash;
135	case 0:
136	break;
137	}
138	return hash;
139	}
140
141	static inline unsigned long variable_hash_1i(register const unsigned char *var, register int length)
142	{
143	register unsigned int hash = ((5381 << 5) + 5381) + *var;
144	switch (length)
145	{
146	default:
147	case 8: hash = ((hash << 5) + hash) + var[7];
148	case 7: hash = ((hash << 5) + hash) + var[6];
149	case 6: hash = ((hash << 5) + hash) + var[5];
150	case 5: hash = ((hash << 5) + hash) + var[4];
151	case 4: hash = ((hash << 5) + hash) + var[3];
152	case 3: hash = ((hash << 5) + hash) + var[2];
153	case 2: hash = ((hash << 5) + hash) + var[1];
154	case 1: return hash;
155	case 0: return 5381; /* shouldn't happen */
156	}
157	}
158	#endif /* CONFIG_WITH_OPTIMIZATION_HACKS */
159
160	static unsigned long
161	variable_hash_1 (const void *keyv)
162	{
163	struct variable const key = (struct variable const ) keyv;
164	#ifdef VARIABLE_HASH /* bird */
165	# ifdef VARIABLE_HASH_STRICT
166	if (key->hash1 != variable_hash_1i (key->name, key->length))
167	__asm__("int3");
168	if (key->hash2 && key->hash2 != variable_hash_2i (key->name, key->length))
169	__asm__("int3");
170	# endif
171	return key->hash1;
172	#else
173	# ifdef CONFIG_WITH_OPTIMIZATION_HACKS
174	return variable_hash_1i (key->name, key->length);
175	# else
176	return_STRING_N_HASH_1 (key->name, key->length);
177	# endif
178	#endif
179	}
180
181	static unsigned long
182	variable_hash_2 (const void *keyv)
183	{
184	#ifdef VARIABLE_HASH /* bird */
185	struct variable key = (struct variable ) keyv;
186	if (!key->hash2)
187	key->hash2 = variable_hash_2i (key->name, key->length);
188	return key->hash2;
189	#else
190	struct variable const key = (struct variable const ) keyv;
191	# ifdef CONFIG_WITH_OPTIMIZATION_HACKS
192	return variable_hash_2i (key->name, key->length);
193	# else
194	return_STRING_N_HASH_2 (key->name, key->length);
195	# endif
196	#endif
197	}
198
199	static int
200	variable_hash_cmp (const void xv, const void yv)
201	{
202	struct variable const x = (struct variable const ) xv;
203	struct variable const y = (struct variable const ) yv;
204	int result = x->length - y->length;
205	if (result)
206	return result;
207	#ifdef VARIABLE_HASH_STRICT /* bird */
208	if (x->hash1 != variable_hash_1i (x->name, x->length))
209	__asm__("int3");
210	if (x->hash2 && x->hash2 != variable_hash_2i (x->name, x->length))
211	__asm__("int3");
212	if (y->hash1 != variable_hash_1i (y->name, y->length))
213	__asm__("int3");
214	if (y->hash2 && y->hash2 != variable_hash_2i (y->name, y->length))
215	__asm__("int3");
216	#endif
217	#ifdef VARIABLE_HASH
218	/* hash 1 */
219	result = x->hash1 - y->hash1;
220	if (result)
221	return result;
222	#endif
223	#ifdef CONFIG_WITH_OPTIMIZATION_HACKS /* bird: speed */
224	{
225	const char *xs = x->name;
226	const char *ys = y->name;
227	switch (x->length)
228	{
229	case 8:
230	result = (int32_t)(xs + 4) - (int32_t)(ys + 4);
231	if (result)
232	return result;
233	return (int32_t)xs - (int32_t)ys;
234	case 7:
235	result = xs[6] - ys[6];
236	if (result)
237	return result;
238	case 6:
239	result = (int32_t)xs - (int32_t)ys;
240	if (result)
241	return result;
242	return (int16_t)(xs + 4) - (int16_t)(ys + 4);
243	case 5:
244	result = xs[4] - ys[4];
245	if (result)
246	return result;
247	case 4:
248	return (int32_t)xs - (int32_t)ys;
249	case 3:
250	result = xs[2] - ys[2];
251	if (result)
252	return result;
253	case 2:
254	return (int16_t)xs - (int16_t)ys;
255	case 1:
256	return xs - ys;
257	case 0:
258	return 0;
259	}
260	}
261	#endif /* CONFIG_WITH_OPTIMIZATION_HACKS */
262	#ifdef VARIABLE_HASH
263	/* hash 2 */
264	if (!x->hash2)
265	((struct variable *)x)->hash2 = variable_hash_2i (x->name, x->length);
266	if (!y->hash2)
267	((struct variable *)y)->hash2 = variable_hash_2i (y->name, y->length);
268	result = x->hash2 - y->hash2;
269	if (result)
270	return result;
271	#endif
272	#ifdef CONFIG_WITH_OPTIMIZATION_HACKS
273	return memcmp (x->name, y->name, x->length);
274	#else
275	return_STRING_N_COMPARE (x->name, y->name, x->length);
276	#endif
277	}
278
279	#ifndef VARIABLE_BUCKETS
280	#define VARIABLE_BUCKETS 523
281	#endif
282	#ifndef PERFILE_VARIABLE_BUCKETS
283	#define PERFILE_VARIABLE_BUCKETS 23
284	#endif
285	#ifndef SMALL_SCOPE_VARIABLE_BUCKETS
286	#define SMALL_SCOPE_VARIABLE_BUCKETS 13
287	#endif
288
289	static struct variable_set global_variable_set;
290	static struct variable_set_list global_setlist
291	= { 0, &global_variable_set };
292	struct variable_set_list *current_variable_set_list = &global_setlist;
293
294
295	/* Implement variables. */
296
297	void
298	init_hash_global_variable_set (void)
299	{
300	hash_init (&global_variable_set.table,
301	#ifdef KMK /* FIMXE: just redefine the bucket size! */
302	16384,
303	#else
304	VARIABLE_BUCKETS,
305	#endif
306	variable_hash_1, variable_hash_2, variable_hash_cmp);
307	}
308
309	/* Define variable named NAME with value VALUE in SET. VALUE is copied.
310	LENGTH is the length of NAME, which does not need to be null-terminated.
311	ORIGIN specifies the origin of the variable (makefile, command line
312	or environment).
313	If RECURSIVE is nonzero a flag is set in the variable saying
314	that it should be recursively re-expanded. */
315
316	#ifdef CONFIG_WITH_VALUE_LENGTH
317	struct variable *
318	define_variable_in_set (const char *name, unsigned int length,
319	char *value, unsigned int value_length, int duplicate_value,
320	enum variable_origin origin, int recursive,
321	struct variable_set set, const struct floc flocp)
322	#else
323	struct variable *
324	define_variable_in_set (const char *name, unsigned int length,
325	char *value, enum variable_origin origin,
326	int recursive, struct variable_set *set,
327	const struct floc *flocp)
328	#endif
329	{
330	struct variable *v;
331	struct variable **var_slot;
332	struct variable var_key;
333
334	if (set == NULL)
335	set = &global_variable_set;
336
337	var_key.name = (char *) name;
338	var_key.length = length;
339	#ifdef VARIABLE_HASH /* bird */
340	var_key.hash1 = variable_hash_1i (name, length);
341	var_key.hash2 = 0;
342	#endif
343	var_slot = (struct variable **) hash_find_slot (&set->table, &var_key);
344
345	if (env_overrides && origin == o_env)
346	origin = o_env_override;
347
348	v = *var_slot;
349	if (! HASH_VACANT (v))
350	{
351	if (env_overrides && v->origin == o_env)
352	/* V came from in the environment. Since it was defined
353	before the switches were parsed, it wasn't affected by -e. */
354	v->origin = o_env_override;
355
356	/* A variable of this name is already defined.
357	If the old definition is from a stronger source
358	than this one, don't redefine it. */
359	if ((int) origin >= (int) v->origin)
360	{
361	#ifdef CONFIG_WITH_VALUE_LENGTH
362	if (value_length == ~0U)
363	value_length = strlen (value);
364	else
365	assert (value_length == strlen (value));
366	if (!duplicate_value)
367	{
368	if (v->value != 0)
369	free (v->value);
370	v->value = value;
371	v->value_alloc_len = value_length + 1;
372	}
373	else
374	{
375	if ((unsigned int)v->value_alloc_len <= value_length)
376	{
377	free (v->value);
378	v->value_alloc_len = (value_length + 0x40) & ~0x3f;
379	v->value = xmalloc (v->value_alloc_len);
380	}
381	memcpy (v->value, value, value_length + 1);
382	}
383	v->value_length = value_length;
384	#else
385	if (v->value != 0)
386	free (v->value);
387	v->value = xstrdup (value);
388	#endif
389	if (flocp != 0)
390	v->fileinfo = *flocp;
391	else
392	v->fileinfo.filenm = 0;
393	v->origin = origin;
394	v->recursive = recursive;
395	}
396	return v;
397	}
398
399	/* Create a new variable definition and add it to the hash table. */
400
401	v = (struct variable *) xmalloc (sizeof (struct variable));
402	v->name = savestring (name, length);
403	v->length = length;
404	#ifdef VARIABLE_HASH /* bird */
405	v->hash1 = variable_hash_1i (name, length);
406	v->hash2 = 0;
407	#endif
408	hash_insert_at (&set->table, v, var_slot);
409	#ifdef CONFIG_WITH_VALUE_LENGTH
410	if (value_length == ~0U)
411	value_length = strlen (value);
412	else
413	assert (value_length == strlen (value));
414	v->value_length = value_length;
415	if (!duplicate_value)
416	{
417	v->value_alloc_len = value_length + 1;
418	v->value = value;
419	}
420	else
421	{
422	v->value_alloc_len = (value_length + 32) & ~31;
423	v->value = xmalloc (v->value_alloc_len);
424	memcpy (v->value, value, value_length + 1);
425	}
426	#else
427	v->value = xstrdup (value);
428	#endif
429	if (flocp != 0)
430	v->fileinfo = *flocp;
431	else
432	v->fileinfo.filenm = 0;
433	v->origin = origin;
434	v->recursive = recursive;
435	v->special = 0;
436	v->expanding = 0;
437	v->exp_count = 0;
438	v->per_target = 0;
439	v->append = 0;
440	v->export = v_default;
441
442	v->exportable = 1;
443	if (name != '_' && (name < 'A' \|\| *name > 'Z')
444	&& (name < 'a' \|\| name > 'z'))
445	v->exportable = 0;
446	else
447	{
448	for (++name; *name != '\0'; ++name)
449	if (name != '_' && (name < 'a' \|\| *name > 'z')
450	&& (name < 'A' \|\| name > 'Z') && !ISDIGIT(*name))
451	break;
452
453	if (*name != '\0')
454	v->exportable = 0;
455	}
456
457	return v;
458	}
459
460
461	/* If the variable passed in is "special", handle its special nature.
462	Currently there are two such variables, both used for introspection:
463	.VARIABLES expands to a list of all the variables defined in this instance
464	of make.
465	.TARGETS expands to a list of all the targets defined in this
466	instance of make.
467	Returns the variable reference passed in. */
468
469	#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
470
471	static struct variable *
472	handle_special_var (struct variable *var)
473	{
474	static unsigned long last_var_count = 0;
475
476
477	/* This one actually turns out to be very hard, due to the way the parser
478	records targets. The way it works is that target information is collected
479	internally until make knows the target is completely specified. It unitl
480	it sees that some new construct (a new target or variable) is defined that
481	it knows the previous one is done. In short, this means that if you do
482	this:
483
484	all:
485
486	TARGS := $(.TARGETS)
487
488	then $(TARGS) won't contain "all", because it's not until after the
489	variable is created that the previous target is completed.
490
491	Changing this would be a major pain. I think a less complex way to do it
492	would be to pre-define the target files as soon as the first line is
493	parsed, then come back and do the rest of the definition as now. That
494	would allow $(.TARGETS) to be correct without a major change to the way
495	the parser works.
496
497	if (streq (var->name, ".TARGETS"))
498	var->value = build_target_list (var->value);
499	else
500	*/
501
502	if (streq (var->name, ".VARIABLES")
503	&& global_variable_set.table.ht_fill != last_var_count)
504	{
505	unsigned long max = EXPANSION_INCREMENT (strlen (var->value));
506	unsigned long len;
507	char *p;
508	struct variable vp = (struct variable ) global_variable_set.table.ht_vec;
509	struct variable **end = &vp[global_variable_set.table.ht_size];
510
511	/* Make sure we have at least MAX bytes in the allocated buffer. */
512	var->value = xrealloc (var->value, max);
513
514	/* Walk through the hash of variables, constructing a list of names. */
515	p = var->value;
516	len = 0;
517	for (; vp < end; ++vp)
518	if (!HASH_VACANT (*vp))
519	{
520	struct variable v = vp;
521	int l = v->length;
522
523	len += l + 1;
524	if (len > max)
525	{
526	unsigned long off = p - var->value;
527
528	max += EXPANSION_INCREMENT (l + 1);
529	var->value = xrealloc (var->value, max);
530	p = &var->value[off];
531	}
532
533	bcopy (v->name, p, l);
534	p += l;
535	*(p++) = ' ';
536	}
537	*(p-1) = '\0';
538
539	/* Remember how many variables are in our current count. Since we never
540	remove variables from the list, this is a reliable way to know whether
541	the list is up to date or needs to be recomputed. */
542
543	last_var_count = global_variable_set.table.ht_fill;
544	}
545
546	return var;
547	}
548
549
550
551	/* Lookup a variable whose name is a string starting at NAME
552	and with LENGTH chars. NAME need not be null-terminated.
553	Returns address of the `struct variable' containing all info
554	on the variable, or nil if no such variable is defined. */
555
556	struct variable *
557	lookup_variable (const char *name, unsigned int length)
558	{
559	const struct variable_set_list *setlist;
560	struct variable var_key;
561
562	var_key.name = (char *) name;
563	var_key.length = length;
564	#ifdef VARIABLE_HASH /* bird */
565	var_key.hash1 = variable_hash_1i (name, length);
566	var_key.hash2 = 0;
567	#endif
568
569	for (setlist = current_variable_set_list;
570	setlist != 0; setlist = setlist->next)
571	{
572	#ifdef VARIABLE_HASH /* bird: speed */
573	struct hash_table *ht = &setlist->set->table;
574	unsigned int hash_1 = var_key.hash1;
575	struct variable *v;
576
577	ht->ht_lookups++;
578	for (;;)
579	{
580	hash_1 &= (ht->ht_size - 1);
581	v = (struct variable *)ht->ht_vec[hash_1];
582
583	if (v == 0)
584	break;
585	if ((void *)v != hash_deleted_item)
586	{
587	if (variable_hash_cmp(&var_key, v) == 0)
588	{
589	# ifdef VARIABLE_HASH_STRICT /* bird */
590	struct variable v2 = (struct variable ) hash_find_item ((struct hash_table *) &setlist->set->table, &var_key);
591	assert(v2 == v);
592	# endif
593	return v->special ? handle_special_var (v) : v;
594	}
595	ht->ht_collisions++;
596	}
597	if (!var_key.hash2)
598	var_key.hash2 = variable_hash_2i(name, length);
599	hash_1 += (var_key.hash2 \| 1);
600	}
601
602	#else /* !VARIABLE_HASH */
603	const struct variable_set *set = setlist->set;
604	struct variable *v;
605
606	v = (struct variable ) hash_find_item ((struct hash_table ) &set->table, &var_key);
607	if (v)
608	return v->special ? handle_special_var (v) : v;
609	#endif /* !VARIABLE_HASH */
610	}
611
612	#ifdef VMS
613	/* since we don't read envp[] on startup, try to get the
614	variable via getenv() here. */
615	{
616	char *vname = alloca (length + 1);
617	char *value;
618	strncpy (vname, name, length);
619	vname[length] = 0;
620	value = getenv (vname);
621	if (value != 0)
622	{
623	char *sptr;
624	int scnt;
625
626	sptr = value;
627	scnt = 0;
628
629	while ((sptr = strchr (sptr, '$')))
630	{
631	scnt++;
632	sptr++;
633	}
634
635	if (scnt > 0)
636	{
637	char *nvalue;
638	char *nptr;
639
640	nvalue = alloca (strlen (value) + scnt + 1);
641	sptr = value;
642	nptr = nvalue;
643
644	while (*sptr)
645	{
646	if (*sptr == '$')
647	{
648	*nptr++ = '$';
649	*nptr++ = '$';
650	}
651	else
652	{
653	nptr++ = sptr;
654	}
655	sptr++;
656	}
657
658	*nptr = '\0';
659	return define_variable (vname, length, nvalue, o_env, 1);
660
661	}
662
663	return define_variable (vname, length, value, o_env, 1);
664	}
665	}
666	#endif /* VMS */
667
668	return 0;
669	}
670
671
672	/* Lookup a variable whose name is a string starting at NAME
673	and with LENGTH chars in set SET. NAME need not be null-terminated.
674	Returns address of the `struct variable' containing all info
675	on the variable, or nil if no such variable is defined. */
676
677	struct variable *
678	lookup_variable_in_set (const char *name, unsigned int length,
679	const struct variable_set *set)
680	{
681	struct variable var_key;
682
683	var_key.name = (char *) name;
684	var_key.length = length;
685	#ifdef VARIABLE_HASH /* bird */
686	var_key.hash1 = variable_hash_1i (name, length);
687	var_key.hash2 = 0;
688	#endif
689
690	return (struct variable ) hash_find_item ((struct hash_table ) &set->table, &var_key);
691	}
692
693
694	/* Initialize FILE's variable set list. If FILE already has a variable set
695	list, the topmost variable set is left intact, but the the rest of the
696	chain is replaced with FILE->parent's setlist. If FILE is a double-colon
697	rule, then we will use the "root" double-colon target's variable set as the
698	parent of FILE's variable set.
699
700	If we're READing a makefile, don't do the pattern variable search now,
701	since the pattern variable might not have been defined yet. */
702
703	void
704	initialize_file_variables (struct file *file, int reading)
705	{
706	struct variable_set_list *l = file->variables;
707
708	if (l == 0)
709	{
710	l = (struct variable_set_list *)
711	xmalloc (sizeof (struct variable_set_list));
712	l->set = (struct variable_set *) xmalloc (sizeof (struct variable_set));
713	hash_init (&l->set->table, PERFILE_VARIABLE_BUCKETS,
714	variable_hash_1, variable_hash_2, variable_hash_cmp);
715	file->variables = l;
716	}
717
718	/* If this is a double-colon, then our "parent" is the "root" target for
719	this double-colon rule. Since that rule has the same name, parent,
720	etc. we can just use its variables as the "next" for ours. */
721
722	if (file->double_colon && file->double_colon != file)
723	{
724	initialize_file_variables (file->double_colon, reading);
725	l->next = file->double_colon->variables;
726	return;
727	}
728
729	if (file->parent == 0)
730	l->next = &global_setlist;
731	else
732	{
733	initialize_file_variables (file->parent, reading);
734	l->next = file->parent->variables;
735	}
736
737	/* If we're not reading makefiles and we haven't looked yet, see if
738	we can find pattern variables for this target. */
739
740	if (!reading && !file->pat_searched)
741	{
742	struct pattern_var *p;
743
744	p = lookup_pattern_var (0, file->name);
745	if (p != 0)
746	{
747	struct variable_set_list *global = current_variable_set_list;
748
749	/* We found at least one. Set up a new variable set to accumulate
750	all the pattern variables that match this target. */
751
752	file->pat_variables = create_new_variable_set ();
753	current_variable_set_list = file->pat_variables;
754
755	do
756	{
757	/* We found one, so insert it into the set. */
758
759	struct variable *v;
760
761	if (p->variable.flavor == f_simple)
762	{
763	v = define_variable_loc (
764	p->variable.name, strlen (p->variable.name),
765	p->variable.value, p->variable.origin,
766	0, &p->variable.fileinfo);
767
768	v->flavor = f_simple;
769	}
770	else
771	{
772	v = do_variable_definition (
773	&p->variable.fileinfo, p->variable.name,
774	p->variable.value, p->variable.origin,
775	p->variable.flavor, 1);
776	}
777
778	/* Also mark it as a per-target and copy export status. */
779	v->per_target = p->variable.per_target;
780	v->export = p->variable.export;
781	}
782	while ((p = lookup_pattern_var (p, file->name)) != 0);
783
784	current_variable_set_list = global;
785	}
786	file->pat_searched = 1;
787	}
788
789	/* If we have a pattern variable match, set it up. */
790
791	if (file->pat_variables != 0)
792	{
793	file->pat_variables->next = l->next;
794	l->next = file->pat_variables;
795	}
796	}
797
798
799	/* Pop the top set off the current variable set list,
800	and free all its storage. */
801
802	struct variable_set_list *
803	create_new_variable_set (void)
804	{
805	register struct variable_set_list *setlist;
806	register struct variable_set *set;
807
808	set = (struct variable_set *) xmalloc (sizeof (struct variable_set));
809	hash_init (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
810	variable_hash_1, variable_hash_2, variable_hash_cmp);
811
812	setlist = (struct variable_set_list *)
813	xmalloc (sizeof (struct variable_set_list));
814	setlist->set = set;
815	setlist->next = current_variable_set_list;
816
817	return setlist;
818	}
819
820	static void
821	free_variable_name_and_value (const void *item)
822	{
823	struct variable v = (struct variable ) item;
824	free (v->name);
825	free (v->value);
826	}
827
828	void
829	free_variable_set (struct variable_set_list *list)
830	{
831	hash_map (&list->set->table, free_variable_name_and_value);
832	hash_free (&list->set->table, 1);
833	free ((char *) list->set);
834	free ((char *) list);
835	}
836
837	/* Create a new variable set and push it on the current setlist.
838	If we're pushing a global scope (that is, the current scope is the global
839	scope) then we need to "push" it the other way: file variable sets point
840	directly to the global_setlist so we need to replace that with the new one.
841	*/
842
843	struct variable_set_list *
844	push_new_variable_scope (void)
845	{
846	current_variable_set_list = create_new_variable_set();
847	if (current_variable_set_list->next == &global_setlist)
848	{
849	/* It was the global, so instead of new -> &global we want to replace
850	&global with the new one and have &global -> new, with current still
851	pointing to &global */
852	struct variable_set *set = current_variable_set_list->set;
853	current_variable_set_list->set = global_setlist.set;
854	global_setlist.set = set;
855	current_variable_set_list->next = global_setlist.next;
856	global_setlist.next = current_variable_set_list;
857	current_variable_set_list = &global_setlist;
858	}
859	return (current_variable_set_list);
860	}
861
862	void
863	pop_variable_scope (void)
864	{
865	struct variable_set_list *setlist;
866	struct variable_set *set;
867
868	/* Can't call this if there's no scope to pop! */
869	assert(current_variable_set_list->next != NULL);
870
871	if (current_variable_set_list != &global_setlist)
872	{
873	/* We're not pointing to the global setlist, so pop this one. */
874	setlist = current_variable_set_list;
875	set = setlist->set;
876	current_variable_set_list = setlist->next;
877	}
878	else
879	{
880	/* This set is the one in the global_setlist, but there is another global
881	set beyond that. We want to copy that set to global_setlist, then
882	delete what used to be in global_setlist. */
883	setlist = global_setlist.next;
884	set = global_setlist.set;
885	global_setlist.set = setlist->set;
886	global_setlist.next = setlist->next;
887	}
888
889	/* Free the one we no longer need. */
890	free ((char *) setlist);
891	hash_map (&set->table, free_variable_name_and_value);
892	hash_free (&set->table, 1);
893	free ((char *) set);
894	}
895
896
897	/* Merge FROM_SET into TO_SET, freeing unused storage in FROM_SET. */
898
899	static void
900	merge_variable_sets (struct variable_set *to_set,
901	struct variable_set *from_set)
902	{
903	struct variable from_var_slot = (struct variable ) from_set->table.ht_vec;
904	struct variable **from_var_end = from_var_slot + from_set->table.ht_size;
905
906	for ( ; from_var_slot < from_var_end; from_var_slot++)
907	if (! HASH_VACANT (*from_var_slot))
908	{
909	struct variable from_var = from_var_slot;
910	struct variable **to_var_slot
911	= (struct variable *) hash_find_slot (&to_set->table, from_var_slot);
912	if (HASH_VACANT (*to_var_slot))
913	hash_insert_at (&to_set->table, from_var, to_var_slot);
914	else
915	{
916	/* GKM FIXME: delete in from_set->table */
917	free (from_var->value);
918	free (from_var);
919	}
920	}
921	}
922
923	/* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */
924
925	void
926	merge_variable_set_lists (struct variable_set_list **setlist0,
927	struct variable_set_list *setlist1)
928	{
929	struct variable_set_list to = setlist0;
930	struct variable_set_list *last0 = 0;
931
932	/* If there's nothing to merge, stop now. */
933	if (!setlist1)
934	return;
935
936	/* This loop relies on the fact that all setlists terminate with the global
937	setlist (before NULL). If that's not true, arguably we SHOULD die. */
938	if (to)
939	while (setlist1 != &global_setlist && to != &global_setlist)
940	{
941	struct variable_set_list *from = setlist1;
942	setlist1 = setlist1->next;
943
944	merge_variable_sets (to->set, from->set);
945
946	last0 = to;
947	to = to->next;
948	}
949
950	if (setlist1 != &global_setlist)
951	{
952	if (last0 == 0)
953	*setlist0 = setlist1;
954	else
955	last0->next = setlist1;
956	}
957	}
958
959
960	/* Define the automatic variables, and record the addresses
961	of their structures so we can change their values quickly. */
962
963	void
964	define_automatic_variables (void)
965	{
966	#if defined(WINDOWS32) \|\| defined(__EMX__)
967	extern char* default_shell;
968	#else
969	extern char default_shell[];
970	#endif
971	register struct variable *v;
972	char buf[200];
973
974	sprintf (buf, "%u", makelevel);
975	(void) define_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH, buf, o_env, 0);
976
977	sprintf (buf, "%s%s%s",
978	version_string,
979	(remote_description == 0 \|\| remote_description[0] == '\0')
980	? "" : "-",
981	(remote_description == 0 \|\| remote_description[0] == '\0')
982	? "" : remote_description);
983	(void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0);
984
985	#ifdef KMK
986	/* Define KMK_VERSION to indicate kMk. */
987	(void) define_variable ("KMK_VERSION", 11, buf, o_default, 0);
988
989	/* Define KMK_FEATURES to indicate various working KMK features. */
990	(void) define_variable ("KMK_FEATURES", 12, "abspath toupper tolower", o_default, 0);
991	#endif
992
993	#ifdef CONFIG_WITH_KMK_BUILTIN
994	/* The supported kMk Builtin commands. */
995	(void) define_variable ("KMK_BUILTIN", 11, "append cp echo install ln mkdir rm", o_default, 0);
996	#endif
997
998	#ifdef __MSDOS__
999	/* Allow to specify a special shell just for Make,
1000	and use $COMSPEC as the default $SHELL when appropriate. */
1001	{
1002	static char shell_str[] = "SHELL";
1003	const int shlen = sizeof (shell_str) - 1;
1004	struct variable *mshp = lookup_variable ("MAKESHELL", 9);
1005	struct variable *comp = lookup_variable ("COMSPEC", 7);
1006
1007	/* Make $MAKESHELL override $SHELL even if -e is in effect. */
1008	if (mshp)
1009	(void) define_variable (shell_str, shlen,
1010	mshp->value, o_env_override, 0);
1011	else if (comp)
1012	{
1013	/* $COMSPEC shouldn't override $SHELL. */
1014	struct variable *shp = lookup_variable (shell_str, shlen);
1015
1016	if (!shp)
1017	(void) define_variable (shell_str, shlen, comp->value, o_env, 0);
1018	}
1019	}
1020	#elif defined(__EMX__)
1021	{
1022	static char shell_str[] = "SHELL";
1023	const int shlen = sizeof (shell_str) - 1;
1024	struct variable *shell = lookup_variable (shell_str, shlen);
1025	struct variable *replace = lookup_variable ("MAKESHELL", 9);
1026
1027	/* if $MAKESHELL is defined in the environment assume o_env_override */
1028	if (replace && *replace->value && replace->origin == o_env)
1029	replace->origin = o_env_override;
1030
1031	/* if $MAKESHELL is not defined use $SHELL but only if the variable
1032	did not come from the environment */
1033	if (!replace \|\| !*replace->value)
1034	if (shell && *shell->value && (shell->origin == o_env
1035	\|\| shell->origin == o_env_override))
1036	{
1037	/* overwrite whatever we got from the environment */
1038	free(shell->value);
1039	shell->value = xstrdup (default_shell);
1040	shell->origin = o_default;
1041	}
1042
1043	/* Some people do not like cmd to be used as the default
1044	if $SHELL is not defined in the Makefile.
1045	With -DNO_CMD_DEFAULT you can turn off this behaviour */
1046	# ifndef NO_CMD_DEFAULT
1047	/* otherwise use $COMSPEC */
1048	if (!replace \|\| !*replace->value)
1049	replace = lookup_variable ("COMSPEC", 7);
1050
1051	/* otherwise use $OS2_SHELL */
1052	if (!replace \|\| !*replace->value)
1053	replace = lookup_variable ("OS2_SHELL", 9);
1054	# else
1055	# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
1056	# endif
1057
1058	if (replace && *replace->value)
1059	/* overwrite $SHELL */
1060	(void) define_variable (shell_str, shlen, replace->value,
1061	replace->origin, 0);
1062	else
1063	/* provide a definition if there is none */
1064	(void) define_variable (shell_str, shlen, default_shell,
1065	o_default, 0);
1066	}
1067
1068	#endif
1069
1070	/* This won't override any definition, but it will provide one if there
1071	isn't one there. */
1072	v = define_variable ("SHELL", 5, default_shell, o_default, 0);
1073
1074	/* On MSDOS we do use SHELL from environment, since it isn't a standard
1075	environment variable on MSDOS, so whoever sets it, does that on purpose.
1076	On OS/2 we do not use SHELL from environment but we have already handled
1077	that problem above. */
1078	#if !defined(__MSDOS__) && !defined(__EMX__)
1079	/* Don't let SHELL come from the environment. */
1080	if (*v->value == '\0' \|\| v->origin == o_env \|\| v->origin == o_env_override)
1081	{
1082	free (v->value);
1083	v->origin = o_file;
1084	v->value = xstrdup (default_shell);
1085	#ifdef CONFIG_WITH_VALUE_LENGTH
1086	v->value_length = strlen (v->value);
1087	v->value_alloc_len = v->value_length + 1;
1088	#endif
1089	}
1090	#endif
1091
1092	/* Make sure MAKEFILES gets exported if it is set. */
1093	v = define_variable ("MAKEFILES", 9, "", o_default, 0);
1094	v->export = v_ifset;
1095
1096	/* Define the magic D and F variables in terms of
1097	the automatic variables they are variations of. */
1098
1099	#ifdef VMS
1100	define_variable ("@D", 2, "$(dir $@)", o_automatic, 1);
1101	define_variable ("%D", 2, "$(dir $%)", o_automatic, 1);
1102	define_variable ("D", 2, "$(dir $)", o_automatic, 1);
1103	define_variable ("<D", 2, "$(dir $<)", o_automatic, 1);
1104	define_variable ("?D", 2, "$(dir $?)", o_automatic, 1);
1105	define_variable ("^D", 2, "$(dir $^)", o_automatic, 1);
1106	define_variable ("+D", 2, "$(dir $+)", o_automatic, 1);
1107	#else
1108	define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
1109	define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
1110	define_variable ("D", 2, "$(patsubst %/,%,$(dir $))", o_automatic, 1);
1111	define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
1112	define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
1113	define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
1114	define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
1115	#endif
1116	define_variable ("@F", 2, "$(notdir $@)", o_automatic, 1);
1117	define_variable ("%F", 2, "$(notdir $%)", o_automatic, 1);
1118	define_variable ("F", 2, "$(notdir $)", o_automatic, 1);
1119	define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
1120	define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
1121	define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
1122	define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
1123	}
1124
1125
1126	int export_all_variables;
1127
1128	/* Create a new environment for FILE's commands.
1129	If FILE is nil, this is for the `shell' function.
1130	The child's MAKELEVEL variable is incremented. */
1131
1132	char **
1133	target_environment (struct file *file)
1134	{
1135	struct variable_set_list *set_list;
1136	register struct variable_set_list *s;
1137	struct hash_table table;
1138	struct variable **v_slot;
1139	struct variable **v_end;
1140	struct variable makelevel_key;
1141	char **result_0;
1142	char **result;
1143
1144	if (file == 0)
1145	set_list = current_variable_set_list;
1146	else
1147	set_list = file->variables;
1148
1149	hash_init (&table, VARIABLE_BUCKETS,
1150	variable_hash_1, variable_hash_2, variable_hash_cmp);
1151
1152	/* Run through all the variable sets in the list,
1153	accumulating variables in TABLE. */
1154	for (s = set_list; s != 0; s = s->next)
1155	{
1156	struct variable_set *set = s->set;
1157	v_slot = (struct variable **) set->table.ht_vec;
1158	v_end = v_slot + set->table.ht_size;
1159	for ( ; v_slot < v_end; v_slot++)
1160	if (! HASH_VACANT (*v_slot))
1161	{
1162	struct variable **new_slot;
1163	struct variable v = v_slot;
1164
1165	/* If this is a per-target variable and it hasn't been touched
1166	already then look up the global version and take its export
1167	value. */
1168	if (v->per_target && v->export == v_default)
1169	{
1170	struct variable *gv;
1171
1172	gv = lookup_variable_in_set (v->name, strlen(v->name),
1173	&global_variable_set);
1174	if (gv)
1175	v->export = gv->export;
1176	}
1177
1178	switch (v->export)
1179	{
1180	case v_default:
1181	if (v->origin == o_default \|\| v->origin == o_automatic)
1182	/* Only export default variables by explicit request. */
1183	continue;
1184
1185	/* The variable doesn't have a name that can be exported. */
1186	if (! v->exportable)
1187	continue;
1188
1189	if (! export_all_variables
1190	&& v->origin != o_command
1191	&& v->origin != o_env && v->origin != o_env_override)
1192	continue;
1193	break;
1194
1195	case v_export:
1196	break;
1197
1198	case v_noexport:
1199	/* If this is the SHELL variable and it's not exported, then
1200	add the value from our original environment. */
1201	if (streq (v->name, "SHELL"))
1202	{
1203	extern struct variable shell_var;
1204	v = &shell_var;
1205	break;
1206	}
1207	continue;
1208
1209	case v_ifset:
1210	if (v->origin == o_default)
1211	continue;
1212	break;
1213	}
1214
1215	new_slot = (struct variable **) hash_find_slot (&table, v);
1216	if (HASH_VACANT (*new_slot))
1217	hash_insert_at (&table, v, new_slot);
1218	}
1219	}
1220
1221	makelevel_key.name = MAKELEVEL_NAME;
1222	makelevel_key.length = MAKELEVEL_LENGTH;
1223	#ifdef VARIABLE_HASH /* bird */
1224	makelevel_key.hash1 = variable_hash_1i (MAKELEVEL_NAME, MAKELEVEL_LENGTH);
1225	makelevel_key.hash2 = 0;
1226	#endif
1227	hash_delete (&table, &makelevel_key);
1228
1229	result = result_0 = (char *) xmalloc ((table.ht_fill + 2) sizeof (char *));
1230
1231	v_slot = (struct variable **) table.ht_vec;
1232	v_end = v_slot + table.ht_size;
1233	for ( ; v_slot < v_end; v_slot++)
1234	if (! HASH_VACANT (*v_slot))
1235	{
1236	struct variable v = v_slot;
1237
1238	/* If V is recursively expanded and didn't come from the environment,
1239	expand its value. If it came from the environment, it should
1240	go back into the environment unchanged. */
1241	if (v->recursive
1242	&& v->origin != o_env && v->origin != o_env_override)
1243	{
1244	char *value = recursively_expand_for_file (v, file);
1245	#ifdef WINDOWS32
1246	if (strcmp(v->name, "Path") == 0 \|\|
1247	strcmp(v->name, "PATH") == 0)
1248	convert_Path_to_windows32(value, ';');
1249	#endif
1250	*result++ = concat (v->name, "=", value);
1251	free (value);
1252	}
1253	else
1254	{
1255	#ifdef WINDOWS32
1256	if (strcmp(v->name, "Path") == 0 \|\|
1257	strcmp(v->name, "PATH") == 0)
1258	convert_Path_to_windows32(v->value, ';');
1259	#endif
1260	*result++ = concat (v->name, "=", v->value);
1261	}
1262	}
1263
1264	result = (char ) xmalloc (100);
1265	(void) sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
1266	*++result = 0;
1267
1268	hash_free (&table, 0);
1269
1270	return result_0;
1271	}
1272
1273
1274	#ifdef CONFIG_WITH_VALUE_LENGTH
1275	static struct variable *
1276	do_variable_definition_append (const struct floc flocp, struct variable v, char *value,
1277	enum variable_origin origin)
1278	{
1279	if (env_overrides && origin == o_env)
1280	origin = o_env_override;
1281
1282	if (env_overrides && v->origin == o_env)
1283	/* V came from in the environment. Since it was defined
1284	before the switches were parsed, it wasn't affected by -e. */
1285	v->origin = o_env_override;
1286
1287	/* A variable of this name is already defined.
1288	If the old definition is from a stronger source
1289	than this one, don't redefine it. */
1290	if ((int) origin < (int) v->origin)
1291	return v;
1292	v->origin = origin;
1293
1294	/* location */
1295	if (flocp != 0)
1296	v->fileinfo = *flocp;
1297
1298	/* The juicy bits, append the specified value to the variable
1299	This is a heavily exercied code path in kBuild. */
1300	if (v->recursive)
1301	{
1302	/* The previous definition of the variable was recursive.
1303	The new value is the unexpanded old and new values. */
1304	unsigned int value_len = strlen (value);
1305	unsigned int new_value_len = value_len + (v->value_length != 0 ? 1 + v->value_length : 0);
1306
1307	/* adjust the size. */
1308	if ((unsigned)v->value_alloc_len <= new_value_len)
1309	{
1310	v->value_alloc_len = (new_value_len + 0x80) + 0x7f;
1311	v->value = xrealloc (v->value, v->value_alloc_len);
1312	}
1313
1314	/* insert the new bits */
1315	if (v->value_length != 0)
1316	{
1317	v->value[v->value_length] = ' ';
1318	memcpy (&v->value[v->value_length + 1], value, value_len + 1);
1319	}
1320	else
1321	memcpy (v->value, value, value_len + 1);
1322	v->value_length = new_value_len;
1323	}
1324	else
1325	{
1326	/* The previous definition of the variable was simple.
1327	The new value comes from the old value, which was expanded
1328	when it was set; and from the expanded new value. */
1329	append_expanded_string_to_variable(v, value);
1330	}
1331
1332	/* update the variable */
1333	return v;
1334	}
1335	#endif /* CONFIG_WITH_VALUE_LENGTH */
1336
1337
1338	/* Given a variable, a value, and a flavor, define the variable.
1339	See the try_variable_definition() function for details on the parameters. */
1340
1341	struct variable *
1342	do_variable_definition (const struct floc flocp, const char varname,
1343	char *value, enum variable_origin origin,
1344	enum variable_flavor flavor, int target_var)
1345	{
1346	char p, alloc_value = NULL;
1347	struct variable *v;
1348	int append = 0;
1349	int conditional = 0;
1350	const size_t varname_len = strlen (varname); /* bird */
1351	# ifdef CONFIG_WITH_VALUE_LENGTH
1352	unsigned int value_len = ~0U;
1353	# endif
1354
1355	/* Calculate the variable's new value in VALUE. */
1356
1357	switch (flavor)
1358	{
1359	default:
1360	case f_bogus:
1361	/* Should not be possible. */
1362	abort ();
1363	case f_simple:
1364	/* A simple variable definition "var := value". Expand the value.
1365	We have to allocate memory since otherwise it'll clobber the
1366	variable buffer, and we may still need that if we're looking at a
1367	target-specific variable. */
1368	p = alloc_value = allocated_variable_expand (value);
1369	break;
1370	case f_conditional:
1371	/* A conditional variable definition "var ?= value".
1372	The value is set IFF the variable is not defined yet. */
1373	v = lookup_variable (varname, varname_len);
1374	if (v)
1375	return v;
1376
1377	conditional = 1;
1378	flavor = f_recursive;
1379	/* FALLTHROUGH */
1380	case f_recursive:
1381	/* A recursive variable definition "var = value".
1382	The value is used verbatim. */
1383	p = value;
1384	break;
1385	case f_append:
1386	{
1387	/* If we have += but we're in a target variable context, we want to
1388	append only with other variables in the context of this target. */
1389	if (target_var)
1390	{
1391	append = 1;
1392	v = lookup_variable_in_set (varname, varname_len,
1393	current_variable_set_list->set);
1394
1395	/* Don't append from the global set if a previous non-appending
1396	target-specific variable definition exists. */
1397	if (v && !v->append)
1398	append = 0;
1399	}
1400	else
1401	v = lookup_variable (varname, varname_len);
1402
1403	if (v == 0)
1404	{
1405	/* There was no old value.
1406	This becomes a normal recursive definition. */
1407	p = value;
1408	flavor = f_recursive;
1409	}
1410	else
1411	{
1412	#ifdef CONFIG_WITH_VALUE_LENGTH
1413	v->append = append;
1414	return do_variable_definition_append (flocp, v, value, origin);
1415	#else /* !CONFIG_WITH_VALUE_LENGTH */
1416
1417	/* Paste the old and new values together in VALUE. */
1418
1419	unsigned int oldlen, vallen;
1420	char *val;
1421
1422	val = value;
1423	if (v->recursive)
1424	/* The previous definition of the variable was recursive.
1425	The new value is the unexpanded old and new values. */
1426	flavor = f_recursive;
1427	else
1428	/* The previous definition of the variable was simple.
1429	The new value comes from the old value, which was expanded
1430	when it was set; and from the expanded new value. Allocate
1431	memory for the expansion as we may still need the rest of the
1432	buffer if we're looking at a target-specific variable. */
1433	val = alloc_value = allocated_variable_expand (val);
1434
1435	oldlen = strlen (v->value);
1436	vallen = strlen (val);
1437	p = (char *) alloca (oldlen + 1 + vallen + 1);
1438	bcopy (v->value, p, oldlen);
1439	p[oldlen] = ' ';
1440	bcopy (val, &p[oldlen + 1], vallen + 1);
1441	#endif /* !CONFIG_WITH_VALUE_LENGTH */
1442	}
1443	}
1444	}
1445
1446	#ifdef __MSDOS__
1447	/* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1448	non-Unix systems don't conform to this default configuration (in
1449	fact, most of them don't even have `/bin'). On the other hand,
1450	$SHELL in the environment, if set, points to the real pathname of
1451	the shell.
1452	Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1453	the Makefile override $SHELL from the environment. But first, we
1454	look for the basename of the shell in the directory where SHELL=
1455	points, and along the $PATH; if it is found in any of these places,
1456	we define $SHELL to be the actual pathname of the shell. Thus, if
1457	you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1458	your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1459	defining SHELL to be "d:/unix/bash.exe". */
1460	if ((origin == o_file \|\| origin == o_override)
1461	&& strcmp (varname, "SHELL") == 0)
1462	{
1463	PATH_VAR (shellpath);
1464	extern char * __dosexec_find_on_path (const char , char [], char *);
1465
1466	/* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1467	if (__dosexec_find_on_path (p, (char **)0, shellpath))
1468	{
1469	char *p;
1470
1471	for (p = shellpath; *p; p++)
1472	{
1473	if (*p == '\\')
1474	*p = '/';
1475	}
1476	v = define_variable_loc (varname, varname_len,
1477	shellpath, origin, flavor == f_recursive,
1478	flocp);
1479	}
1480	else
1481	{
1482	char shellbase, bslash;
1483	struct variable *pathv = lookup_variable ("PATH", 4);
1484	char *path_string;
1485	char *fake_env[2];
1486	size_t pathlen = 0;
1487
1488	shellbase = strrchr (p, '/');
1489	bslash = strrchr (p, '\\');
1490	if (!shellbase \|\| bslash > shellbase)
1491	shellbase = bslash;
1492	if (!shellbase && p[1] == ':')
1493	shellbase = p + 1;
1494	if (shellbase)
1495	shellbase++;
1496	else
1497	shellbase = p;
1498
1499	/* Search for the basename of the shell (with standard
1500	executable extensions) along the $PATH. */
1501	if (pathv)
1502	pathlen = strlen (pathv->value);
1503	path_string = (char *)xmalloc (5 + pathlen + 2 + 1);
1504	/* On MSDOS, current directory is considered as part of $PATH. */
1505	sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
1506	fake_env[0] = path_string;
1507	fake_env[1] = (char *)0;
1508	if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
1509	{
1510	char *p;
1511
1512	for (p = shellpath; *p; p++)
1513	{
1514	if (*p == '\\')
1515	*p = '/';
1516	}
1517	v = define_variable_loc (varname, varname_len,
1518	shellpath, origin,
1519	flavor == f_recursive, flocp);
1520	}
1521	else
1522	v = lookup_variable (varname, varname_len);
1523
1524	free (path_string);
1525	}
1526	}
1527	else
1528	#endif /* __MSDOS__ */
1529	#ifdef WINDOWS32
1530	if ( varname_len == sizeof("SHELL") - 1 /* bird */
1531	&& (origin == o_file \|\| origin == o_override \|\| origin == o_command)
1532	&& streq (varname, "SHELL"))
1533	{
1534	extern char *default_shell;
1535
1536	/* Call shell locator function. If it returns TRUE, then
1537	set no_default_sh_exe to indicate sh was found and
1538	set new value for SHELL variable. */
1539
1540	if (find_and_set_default_shell (p))
1541	{
1542	v = define_variable_in_set (varname, varname_len, default_shell,
1543	# ifdef CONFIG_WITH_VALUE_LENGTH
1544	~0U, 1 /* duplicate_value */,
1545	# endif
1546	origin, flavor == f_recursive,
1547	(target_var
1548	? current_variable_set_list->set
1549	: NULL),
1550	flocp);
1551	no_default_sh_exe = 0;
1552	}
1553	else
1554	v = lookup_variable (varname, varname_len);
1555	# ifdef CONFIG_WITH_VALUE_LENGTH
1556	if (alloc_value)
1557	free (alloc_value);
1558	# endif
1559	}
1560	else
1561	#endif
1562
1563	/* If we are defining variables inside an $(eval ...), we might have a
1564	different variable context pushed, not the global context (maybe we're
1565	inside a $(call ...) or something. Since this function is only ever
1566	invoked in places where we want to define globally visible variables,
1567	make sure we define this variable in the global set. */
1568
1569	v = define_variable_in_set (varname, varname_len, p,
1570	#ifdef CONFIG_WITH_VALUE_LENGTH
1571	value_len, !alloc_value,
1572	#endif
1573	origin, flavor == f_recursive,
1574	(target_var
1575	? current_variable_set_list->set : NULL),
1576	flocp);
1577	v->append = append;
1578	v->conditional = conditional;
1579
1580	#ifndef CONFIG_WITH_VALUE_LENGTH
1581	if (alloc_value)
1582	free (alloc_value);
1583	#endif
1584
1585	return v;
1586	}
1587
1588
1589	/* Try to interpret LINE (a null-terminated string) as a variable definition.
1590
1591	ORIGIN may be o_file, o_override, o_env, o_env_override,
1592	or o_command specifying that the variable definition comes
1593	from a makefile, an override directive, the environment with
1594	or without the -e switch, or the command line.
1595
1596	See the comments for parse_variable_definition().
1597
1598	If LINE was recognized as a variable definition, a pointer to its `struct
1599	variable' is returned. If LINE is not a variable definition, NULL is
1600	returned. */
1601
1602	struct variable *
1603	parse_variable_definition (struct variable v, char line)
1604	{
1605	register int c;
1606	register char *p = line;
1607	register char *beg;
1608	register char *end;
1609	enum variable_flavor flavor = f_bogus;
1610	char *name;
1611
1612	while (1)
1613	{
1614	c = *p++;
1615	if (c == '\0' \|\| c == '#')
1616	return 0;
1617	if (c == '=')
1618	{
1619	end = p - 1;
1620	flavor = f_recursive;
1621	break;
1622	}
1623	else if (c == ':')
1624	if (*p == '=')
1625	{
1626	end = p++ - 1;
1627	flavor = f_simple;
1628	break;
1629	}
1630	else
1631	/* A colon other than := is a rule line, not a variable defn. */
1632	return 0;
1633	else if (c == '+' && *p == '=')
1634	{
1635	end = p++ - 1;
1636	flavor = f_append;
1637	break;
1638	}
1639	else if (c == '?' && *p == '=')
1640	{
1641	end = p++ - 1;
1642	flavor = f_conditional;
1643	break;
1644	}
1645	else if (c == '$')
1646	{
1647	/* This might begin a variable expansion reference. Make sure we
1648	don't misrecognize chars inside the reference as =, := or +=. */
1649	char closeparen;
1650	int count;
1651	c = *p++;
1652	if (c == '(')
1653	closeparen = ')';
1654	else if (c == '{')
1655	closeparen = '}';
1656	else
1657	continue; /* Nope. */
1658
1659	/* P now points past the opening paren or brace.
1660	Count parens or braces until it is matched. */
1661	count = 0;
1662	for (; *p != '\0'; ++p)
1663	{
1664	if (*p == c)
1665	++count;
1666	else if (*p == closeparen && --count < 0)
1667	{
1668	++p;
1669	break;
1670	}
1671	}
1672	}
1673	}
1674	v->flavor = flavor;
1675
1676	beg = next_token (line);
1677	while (end > beg && isblank ((unsigned char)end[-1]))
1678	--end;
1679	p = next_token (p);
1680	v->value = p;
1681	#ifdef CONFIG_WITH_VALUE_LENGTH
1682	v->value_length = v->value_alloc_len = -1;
1683	#endif
1684
1685	/* Expand the name, so "$(foo)bar = baz" works. */
1686	name = (char *) alloca (end - beg + 1);
1687	bcopy (beg, name, end - beg);
1688	name[end - beg] = '\0';
1689	v->name = allocated_variable_expand (name);
1690
1691	if (v->name[0] == '\0')
1692	fatal (&v->fileinfo, _("empty variable name"));
1693
1694	return v;
1695	}
1696
1697
1698	/* Try to interpret LINE (a null-terminated string) as a variable definition.
1699
1700	ORIGIN may be o_file, o_override, o_env, o_env_override,
1701	or o_command specifying that the variable definition comes
1702	from a makefile, an override directive, the environment with
1703	or without the -e switch, or the command line.
1704
1705	See the comments for parse_variable_definition().
1706
1707	If LINE was recognized as a variable definition, a pointer to its `struct
1708	variable' is returned. If LINE is not a variable definition, NULL is
1709	returned. */
1710
1711	struct variable *
1712	try_variable_definition (const struct floc flocp, char line,
1713	enum variable_origin origin, int target_var)
1714	{
1715	struct variable v;
1716	struct variable *vp;
1717
1718	if (flocp != 0)
1719	v.fileinfo = *flocp;
1720	else
1721	v.fileinfo.filenm = 0;
1722
1723	if (!parse_variable_definition (&v, line))
1724	return 0;
1725
1726	vp = do_variable_definition (flocp, v.name, v.value,
1727	origin, v.flavor, target_var);
1728
1729	free (v.name);
1730
1731	return vp;
1732	}
1733
1734
1735	/* Print information for variable V, prefixing it with PREFIX. */
1736
1737	static void
1738	print_variable (const void item, void arg)
1739	{
1740	const struct variable v = (struct variable ) item;
1741	const char prefix = (char ) arg;
1742	const char *origin;
1743
1744	switch (v->origin)
1745	{
1746	case o_default:
1747	origin = _("default");
1748	break;
1749	case o_env:
1750	origin = _("environment");
1751	break;
1752	case o_file:
1753	origin = _("makefile");
1754	break;
1755	case o_env_override:
1756	origin = _("environment under -e");
1757	break;
1758	case o_command:
1759	origin = _("command line");
1760	break;
1761	case o_override:
1762	origin = _("`override' directive");
1763	break;
1764	case o_automatic:
1765	origin = _("automatic");
1766	break;
1767	case o_invalid:
1768	default:
1769	abort ();
1770	}
1771	fputs ("# ", stdout);
1772	fputs (origin, stdout);
1773	if (v->fileinfo.filenm)
1774	printf (_(" (from `%s', line %lu)"),
1775	v->fileinfo.filenm, v->fileinfo.lineno);
1776	putchar ('\n');
1777	fputs (prefix, stdout);
1778
1779	/* Is this a `define'? */
1780	if (v->recursive && strchr (v->value, '\n') != 0)
1781	printf ("define %s\n%s\nendef\n", v->name, v->value);
1782	else
1783	{
1784	register char *p;
1785
1786	printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
1787
1788	/* Check if the value is just whitespace. */
1789	p = next_token (v->value);
1790	if (p != v->value && *p == '\0')
1791	/* All whitespace. */
1792	printf ("$(subst ,,%s)", v->value);
1793	else if (v->recursive)
1794	fputs (v->value, stdout);
1795	else
1796	/* Double up dollar signs. */
1797	for (p = v->value; *p != '\0'; ++p)
1798	{
1799	if (*p == '$')
1800	putchar ('$');
1801	putchar (*p);
1802	}
1803	putchar ('\n');
1804	}
1805	}
1806
1807
1808	/* Print all the variables in SET. PREFIX is printed before
1809	the actual variable definitions (everything else is comments). */
1810
1811	void
1812	print_variable_set (struct variable_set set, char prefix)
1813	{
1814	hash_map_arg (&set->table, print_variable, prefix);
1815
1816	fputs (_("# variable set hash-table stats:\n"), stdout);
1817	fputs ("# ", stdout);
1818	hash_print_stats (&set->table, stdout);
1819	putc ('\n', stdout);
1820	}
1821
1822	/* Print the data base of variables. */
1823
1824	void
1825	print_variable_data_base (void)
1826	{
1827	puts (_("\n# Variables\n"));
1828
1829	print_variable_set (&global_variable_set, "");
1830
1831	puts (_("\n# Pattern-specific Variable Values"));
1832
1833	{
1834	struct pattern_var *p;
1835	int rules = 0;
1836
1837	for (p = pattern_vars; p != 0; p = p->next)
1838	{
1839	++rules;
1840	printf ("\n%s :\n", p->target);
1841	print_variable (&p->variable, "# ");
1842	}
1843
1844	if (rules == 0)
1845	puts (_("\n# No pattern-specific variable values."));
1846	else
1847	printf (_("\n# %u pattern-specific variable values"), rules);
1848	}
1849	}
1850
1851
1852	/* Print all the local variables of FILE. */
1853
1854	void
1855	print_file_variables (struct file *file)
1856	{
1857	if (file->variables != 0)
1858	print_variable_set (file->variables->set, "# ");
1859	}
1860
1861	#ifdef WINDOWS32
1862	void
1863	sync_Path_environment (void)
1864	{
1865	char *path = allocated_variable_expand ("$(PATH)");
1866	static char *environ_path = NULL;
1867
1868	if (!path)
1869	return;
1870
1871	/*
1872	* If done this before, don't leak memory unnecessarily.
1873	* Free the previous entry before allocating new one.
1874	*/
1875	if (environ_path)
1876	free (environ_path);
1877
1878	/*
1879	* Create something WINDOWS32 world can grok
1880	*/
1881	convert_Path_to_windows32 (path, ';');
1882	environ_path = concat ("PATH", "=", path);
1883	putenv (environ_path);
1884	free (path);
1885	}
1886	#endif

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/gmake/variable.c@ 534

Download in other formats: