variable.c@ 1918

Last change on this file since 1918 was 1918, checked in by bird, 16 years ago
kmk: New switch --print-stats which will print variable, file, strcache, allocation and heap statistics.
Property svn:eol-style set to `native`
File size: 71.3 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	#ifdef KMK
34	# include "kbuild.h"
35	#endif
36	#ifdef CONFIG_WITH_STRCACHE2
37	# include <stddef.h>
38	#endif
39
40	/* Chain of all pattern-specific variables. */
41
42	static struct pattern_var *pattern_vars;
43
44	/* Pointer to last struct in the chain, so we can add onto the end. */
45
46	static struct pattern_var *last_pattern_var;
47
48	/* Create a new pattern-specific variable struct. */
49
50	struct pattern_var *
51	create_pattern_var (const char target, const char suffix)
52	{
53	register struct pattern_var *p = xmalloc (sizeof (struct pattern_var));
54
55	if (last_pattern_var != 0)
56	last_pattern_var->next = p;
57	else
58	pattern_vars = p;
59	last_pattern_var = p;
60	p->next = 0;
61
62	p->target = target;
63	p->len = strlen (target);
64	p->suffix = suffix + 1;
65
66	return p;
67	}
68
69	/* Look up a target in the pattern-specific variable list. */
70
71	static struct pattern_var *
72	lookup_pattern_var (struct pattern_var start, const char target)
73	{
74	struct pattern_var *p;
75	unsigned int targlen = strlen(target);
76
77	for (p = start ? start->next : pattern_vars; p != 0; p = p->next)
78	{
79	const char *stem;
80	unsigned int stemlen;
81
82	if (p->len > targlen)
83	/* It can't possibly match. */
84	continue;
85
86	/* From the lengths of the filename and the pattern parts,
87	find the stem: the part of the filename that matches the %. */
88	stem = target + (p->suffix - p->target - 1);
89	stemlen = targlen - p->len + 1;
90
91	/* Compare the text in the pattern before the stem, if any. */
92	if (stem > target && !strneq (p->target, target, stem - target))
93	continue;
94
95	/* Compare the text in the pattern after the stem, if any.
96	We could test simply using streq, but this way we compare the
97	first two characters immediately. This saves time in the very
98	common case where the first character matches because it is a
99	period. */
100	if (*p->suffix == stem[stemlen]
101	&& (*p->suffix == '\0' \|\| streq (&p->suffix[1], &stem[stemlen+1])))
102	break;
103	}
104
105	return p;
106	}
107
108
109	#ifdef CONFIG_WITH_STRCACHE2
110	static struct strcache2 variable_strcache;
111	#endif
112
113	/* Hash table of all global variable definitions. */
114
115	#ifndef CONFIG_WITH_STRCACHE2
116	static unsigned long
117	variable_hash_1 (const void *keyv)
118	{
119	struct variable const key = (struct variable const ) keyv;
120	return_STRING_N_HASH_1 (key->name, key->length);
121	}
122
123	static unsigned long
124	variable_hash_2 (const void *keyv)
125	{
126	struct variable const key = (struct variable const ) keyv;
127	return_STRING_N_HASH_2 (key->name, key->length);
128	}
129
130	static int
131	variable_hash_cmp (const void xv, const void yv)
132	{
133	struct variable const x = (struct variable const ) xv;
134	struct variable const y = (struct variable const ) yv;
135	int result = x->length - y->length;
136	if (result)
137	return result;
138
139	return_STRING_N_COMPARE (x->name, y->name, x->length);
140	}
141	#endif /* !CONFIG_WITH_STRCACHE2 */
142
143	#ifndef VARIABLE_BUCKETS
144	# ifdef KMK /* Move to Makefile.kmk? (insanely high, but wtf, it gets the collitions down) */
145	# define VARIABLE_BUCKETS 65535
146	# else /!KMK/
147	#define VARIABLE_BUCKETS 523
148	# endif /!KMK/
149	#endif
150	#ifndef PERFILE_VARIABLE_BUCKETS
151	# ifdef KMK /* Move to Makefile.kmk? */
152	# define PERFILE_VARIABLE_BUCKETS 127
153	# else
154	#define PERFILE_VARIABLE_BUCKETS 23
155	# endif
156	#endif
157	#ifndef SMALL_SCOPE_VARIABLE_BUCKETS
158	# ifdef KMK /* Move to Makefile.kmk? */
159	# define SMALL_SCOPE_VARIABLE_BUCKETS 63
160	# else
161	#define SMALL_SCOPE_VARIABLE_BUCKETS 13
162	# endif
163	#endif
164
165	static struct variable_set global_variable_set;
166	static struct variable_set_list global_setlist
167	= { 0, &global_variable_set };
168	struct variable_set_list *current_variable_set_list = &global_setlist;
169
170
171	/* Implement variables. */
172
173	void
174	init_hash_global_variable_set (void)
175	{
176	#ifndef CONFIG_WITH_STRCACHE2
177	hash_init (&global_variable_set.table, VARIABLE_BUCKETS,
178	variable_hash_1, variable_hash_2, variable_hash_cmp);
179	#else /* CONFIG_WITH_STRCACHE2 */
180	strcache2_init (&variable_strcache, "variable", 65536, 0, 0, 0);
181	hash_init_strcached (&global_variable_set.table, VARIABLE_BUCKETS,
182	&variable_strcache, offsetof (struct variable, name));
183	#endif /* CONFIG_WITH_STRCACHE2 */
184	}
185
186	/* Define variable named NAME with value VALUE in SET. VALUE is copied.
187	LENGTH is the length of NAME, which does not need to be null-terminated.
188	ORIGIN specifies the origin of the variable (makefile, command line
189	or environment).
190	If RECURSIVE is nonzero a flag is set in the variable saying
191	that it should be recursively re-expanded. */
192
193	#ifdef CONFIG_WITH_VALUE_LENGTH
194	struct variable *
195	define_variable_in_set (const char *name, unsigned int length,
196	const char *value, unsigned int value_len,
197	int duplicate_value, enum variable_origin origin,
198	int recursive, struct variable_set *set,
199	const struct floc *flocp)
200	#else
201	struct variable *
202	define_variable_in_set (const char *name, unsigned int length,
203	const char *value, enum variable_origin origin,
204	int recursive, struct variable_set *set,
205	const struct floc *flocp)
206	#endif
207	{
208	struct variable *v;
209	struct variable **var_slot;
210	struct variable var_key;
211
212	if (set == NULL)
213	set = &global_variable_set;
214
215	#ifndef CONFIG_WITH_STRCACHE2
216	var_key.name = (char *) name;
217	var_key.length = length;
218	var_slot = (struct variable **) hash_find_slot (&set->table, &var_key);
219
220	if (env_overrides && origin == o_env)
221	origin = o_env_override;
222
223	v = *var_slot;
224	#else /* CONFIG_WITH_STRCACHE2 */
225	var_key.name = name = strcache2_add (&variable_strcache, name, length);
226	var_key.length = length;
227	if ( set != &global_variable_set
228	\|\| !(v = strcache2_get_user_val (&variable_strcache, var_key.name)))
229	{
230	var_slot = (struct variable **) hash_find_slot_strcached (&set->table, &var_key);
231	v = *var_slot;
232	}
233	else
234	{
235	assert (!v \|\| (v->name == name && !HASH_VACANT (v)));
236	var_slot = 0;
237	}
238	#endif /* CONFIG_WITH_STRCACHE2 */
239	if (! HASH_VACANT (v))
240	{
241	if (env_overrides && v->origin == o_env)
242	/* V came from in the environment. Since it was defined
243	before the switches were parsed, it wasn't affected by -e. */
244	v->origin = o_env_override;
245
246	/* A variable of this name is already defined.
247	If the old definition is from a stronger source
248	than this one, don't redefine it. */
249	if ((int) origin >= (int) v->origin)
250	{
251	#ifdef CONFIG_WITH_VALUE_LENGTH
252	if (value_len == ~0U)
253	value_len = strlen (value);
254	else
255	assert (value_len == strlen (value));
256	if (!duplicate_value)
257	{
258	if (v->value != 0)
259	free (v->value);
260	v->value = (char *)value;
261	v->value_alloc_len = value_len + 1;
262	}
263	else
264	{
265	if ((unsigned int)v->value_alloc_len <= value_len)
266	{
267	free (v->value);
268	v->value_alloc_len = (value_len + 0x40) & ~0x3f;
269	v->value = xmalloc (v->value_alloc_len);
270	}
271	memcpy (v->value, value, value_len + 1);
272	}
273	v->value_length = value_len;
274	#else
275	if (v->value != 0)
276	free (v->value);
277	v->value = xstrdup (value);
278	#endif
279	if (flocp != 0)
280	v->fileinfo = *flocp;
281	else
282	v->fileinfo.filenm = 0;
283	v->origin = origin;
284	v->recursive = recursive;
285	}
286	return v;
287	}
288
289	/* Create a new variable definition and add it to the hash table. */
290
291	#ifndef CONFIG_WITH_ALLOC_CACHES
292	v = xmalloc (sizeof (struct variable));
293	#else
294	v = alloccache_alloc (&variable_cache);
295	#endif
296	#ifndef CONFIG_WITH_STRCACHE2
297	v->name = savestring (name, length);
298	#else
299	v->name = name; /* already cached. */
300	#endif
301	v->length = length;
302	hash_insert_at (&set->table, v, var_slot);
303	#ifdef CONFIG_WITH_VALUE_LENGTH
304	if (value_len == ~0U)
305	value_len = strlen (value);
306	else
307	assert (value_len == strlen (value));
308	v->value_length = value_len;
309	if (!duplicate_value)
310	{
311	v->value_alloc_len = value_len + 1;
312	v->value = (char *)value;
313	}
314	else
315	{
316	v->value_alloc_len = (value_len + 32) & ~31;
317	v->value = xmalloc (v->value_alloc_len);
318	memcpy (v->value, value, value_len + 1);
319	}
320	#else
321	v->value = xstrdup (value);
322	#endif
323	if (flocp != 0)
324	v->fileinfo = *flocp;
325	else
326	v->fileinfo.filenm = 0;
327	v->origin = origin;
328	v->recursive = recursive;
329	v->special = 0;
330	v->expanding = 0;
331	v->exp_count = 0;
332	v->per_target = 0;
333	v->append = 0;
334	v->export = v_default;
335
336	v->exportable = 1;
337	if (name != '_' && (name < 'A' \|\| *name > 'Z')
338	&& (name < 'a' \|\| name > 'z'))
339	v->exportable = 0;
340	else
341	{
342	for (++name; *name != '\0'; ++name)
343	if (name != '_' && (name < 'a' \|\| *name > 'z')
344	&& (name < 'A' \|\| name > 'Z') && !ISDIGIT(*name))
345	break;
346
347	if (*name != '\0')
348	v->exportable = 0;
349	}
350
351	#ifdef CONFIG_WITH_STRCACHE2
352	/* If it's the global set, remember the variable. */
353	if (set == &global_variable_set)
354	strcache2_set_user_val (&variable_strcache, v->name, v);
355	#endif
356	return v;
357	}
358
359
360	/* If the variable passed in is "special", handle its special nature.
361	Currently there are two such variables, both used for introspection:
362	.VARIABLES expands to a list of all the variables defined in this instance
363	of make.
364	.TARGETS expands to a list of all the targets defined in this
365	instance of make.
366	Returns the variable reference passed in. */
367
368	#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
369
370	static struct variable *
371	handle_special_var (struct variable *var)
372	{
373	static unsigned long last_var_count = 0;
374
375
376	/* This one actually turns out to be very hard, due to the way the parser
377	records targets. The way it works is that target information is collected
378	internally until make knows the target is completely specified. It unitl
379	it sees that some new construct (a new target or variable) is defined that
380	it knows the previous one is done. In short, this means that if you do
381	this:
382
383	all:
384
385	TARGS := $(.TARGETS)
386
387	then $(TARGS) won't contain "all", because it's not until after the
388	variable is created that the previous target is completed.
389
390	Changing this would be a major pain. I think a less complex way to do it
391	would be to pre-define the target files as soon as the first line is
392	parsed, then come back and do the rest of the definition as now. That
393	would allow $(.TARGETS) to be correct without a major change to the way
394	the parser works.
395
396	if (streq (var->name, ".TARGETS"))
397	var->value = build_target_list (var->value);
398	else
399	*/
400
401	if (streq (var->name, ".VARIABLES")
402	&& global_variable_set.table.ht_fill != last_var_count)
403	{
404	unsigned long max = EXPANSION_INCREMENT (strlen (var->value));
405	unsigned long len;
406	char *p;
407	struct variable vp = (struct variable ) global_variable_set.table.ht_vec;
408	struct variable **end = &vp[global_variable_set.table.ht_size];
409
410	/* Make sure we have at least MAX bytes in the allocated buffer. */
411	var->value = xrealloc (var->value, max);
412
413	/* Walk through the hash of variables, constructing a list of names. */
414	p = var->value;
415	len = 0;
416	for (; vp < end; ++vp)
417	if (!HASH_VACANT (*vp))
418	{
419	struct variable v = vp;
420	int l = v->length;
421
422	len += l + 1;
423	if (len > max)
424	{
425	unsigned long off = p - var->value;
426
427	max += EXPANSION_INCREMENT (l + 1);
428	var->value = xrealloc (var->value, max);
429	p = &var->value[off];
430	}
431
432	memcpy (p, v->name, l);
433	p += l;
434	*(p++) = ' ';
435	}
436	*(p-1) = '\0';
437
438	/* Remember how many variables are in our current count. Since we never
439	remove variables from the list, this is a reliable way to know whether
440	the list is up to date or needs to be recomputed. */
441
442	last_var_count = global_variable_set.table.ht_fill;
443	}
444
445	return var;
446	}
447
448
449
450	#ifdef KMK /* bird: speed */
451	MY_INLINE struct variable *
452	lookup_cached_variable (const char *name)
453	{
454	const struct variable_set_list *setlist = current_variable_set_list;
455	struct hash_table *ht;
456	unsigned int hash_1;
457	unsigned int hash_2;
458	unsigned int idx;
459	struct variable *v;
460
461	/* first set, first entry, both unrolled. */
462
463	if (setlist->set == &global_variable_set)
464	{
465	v = (struct variable *) strcache2_get_user_val (&variable_strcache, name);
466	if (MY_PREDICT_TRUE (v))
467	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
468	assert (setlist->next == 0);
469	return 0;
470	}
471
472	hash_1 = strcache2_calc_ptr_hash (&variable_strcache, name);
473	ht = &setlist->set->table;
474	MAKE_STATS (ht->ht_lookups++);
475	idx = hash_1 & (ht->ht_size - 1);
476	v = ht->ht_vec[idx];
477	if (v != 0)
478	{
479	if ( (void *)v != hash_deleted_item
480	&& v->name == name)
481	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
482
483	/* the rest of the loop */
484	hash_2 = strcache2_get_hash (&variable_strcache, name) \| 1;
485	for (;;)
486	{
487	idx += hash_2;
488	idx &= (ht->ht_size - 1);
489	v = (struct variable *) ht->ht_vec[idx];
490	MAKE_STATS (ht->ht_collisions++); /* there are hardly any deletions, so don't bother with not counting deleted clashes. */
491
492	if (v == 0)
493	break;
494	if ( (void *)v != hash_deleted_item
495	&& v->name == name)
496	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
497	} /* inner collision loop */
498	}
499	else
500	hash_2 = strcache2_get_hash (&variable_strcache, name) \| 1;
501
502
503	/* The other sets, if any. */
504
505	setlist = setlist->next;
506	while (setlist)
507	{
508	if (setlist->set == &global_variable_set)
509	{
510	v = (struct variable *) strcache2_get_user_val (&variable_strcache, name);
511	if (MY_PREDICT_TRUE (v))
512	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
513	assert (setlist->next == 0);
514	return 0;
515	}
516
517	/* first iteration unrolled */
518	ht = &setlist->set->table;
519	MAKE_STATS (ht->ht_lookups++);
520	idx = hash_1 & (ht->ht_size - 1);
521	v = ht->ht_vec[idx];
522	if (v != 0)
523	{
524	if ( (void *)v != hash_deleted_item
525	&& v->name == name)
526	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
527
528	/* the rest of the loop */
529	for (;;)
530	{
531	idx += hash_2;
532	idx &= (ht->ht_size - 1);
533	v = (struct variable *) ht->ht_vec[idx];
534	MAKE_STATS (ht->ht_collisions++); /* see reason above */
535
536	if (v == 0)
537	break;
538	if ( (void *)v != hash_deleted_item
539	&& v->name == name)
540	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
541	} /* inner collision loop */
542	}
543
544	/* next */
545	setlist = setlist->next;
546	}
547
548	return 0;
549	}
550
551	# ifndef NDEBUG
552	struct variable *
553	lookup_variable_for_assert (const char *name, unsigned int length)
554	{
555	const struct variable_set_list *setlist;
556	struct variable var_key;
557	var_key.name = name;
558	var_key.length = length;
559
560	for (setlist = current_variable_set_list;
561	setlist != 0; setlist = setlist->next)
562	{
563	struct variable *v;
564	v = (struct variable *) hash_find_item_strcached (&setlist->set->table, &var_key);
565	if (v)
566	return MY_PREDICT_FALSE (v->special) ? handle_special_var (v) : v;
567	}
568	return 0;
569	}
570	# endif /* !NDEBUG */
571	#endif /* KMK - need for speed */
572
573	/* Lookup a variable whose name is a string starting at NAME
574	and with LENGTH chars. NAME need not be null-terminated.
575	Returns address of the `struct variable' containing all info
576	on the variable, or nil if no such variable is defined. */
577
578	struct variable *
579	lookup_variable (const char *name, unsigned int length)
580	{
581	#ifndef KMK
582	const struct variable_set_list *setlist;
583	struct variable var_key;
584	#else /* KMK */
585	struct variable *v;
586	#endif /* KMK */
587	#ifdef CONFIG_WITH_STRCACHE2
588	const char *cached_name;
589
590	/* lookup the name in the string case, if it's not there it won't
591	be in any of the sets either. */
592	cached_name = strcache2_lookup(&variable_strcache, name, length);
593	if (!cached_name)
594	return NULL;
595	name = cached_name;
596	#endif /* CONFIG_WITH_STRCACHE2 */
597	#ifndef KMK
598
599	var_key.name = (char *) name;
600	var_key.length = length;
601
602	for (setlist = current_variable_set_list;
603	setlist != 0; setlist = setlist->next)
604	{
605	const struct variable_set *set = setlist->set;
606	struct variable *v;
607
608	# ifndef CONFIG_WITH_STRCACHE2
609	v = (struct variable ) hash_find_item ((struct hash_table ) &set->table, &var_key);
610	# else /* CONFIG_WITH_STRCACHE2 */
611	v = (struct variable ) hash_find_item_strcached ((struct hash_table ) &set->table, &var_key);
612	# endif /* CONFIG_WITH_STRCACHE2 */
613	if (v)
614	return v->special ? handle_special_var (v) : v;
615	}
616
617	#else /* KMK - need for speed */
618
619	v = lookup_cached_variable (name);
620	assert (lookup_variable_for_assert(name, length) == v);
621	#ifdef VMS
622	if (v)
623	#endif
624	return v;
625	#endif /* KMK - need for speed */
626	#ifdef VMS
627	/* since we don't read envp[] on startup, try to get the
628	variable via getenv() here. */
629	{
630	char *vname = alloca (length + 1);
631	char *value;
632	strncpy (vname, name, length);
633	vname[length] = 0;
634	value = getenv (vname);
635	if (value != 0)
636	{
637	char *sptr;
638	int scnt;
639
640	sptr = value;
641	scnt = 0;
642
643	while ((sptr = strchr (sptr, '$')))
644	{
645	scnt++;
646	sptr++;
647	}
648
649	if (scnt > 0)
650	{
651	char *nvalue;
652	char *nptr;
653
654	nvalue = alloca (strlen (value) + scnt + 1);
655	sptr = value;
656	nptr = nvalue;
657
658	while (*sptr)
659	{
660	if (*sptr == '$')
661	{
662	*nptr++ = '$';
663	*nptr++ = '$';
664	}
665	else
666	{
667	nptr++ = sptr;
668	}
669	sptr++;
670	}
671
672	*nptr = '\0';
673	return define_variable (vname, length, nvalue, o_env, 1);
674
675	}
676
677	return define_variable (vname, length, value, o_env, 1);
678	}
679	}
680	#endif /* VMS */
681
682	#if !defined (KMK) \|\| defined(VMS)
683	return 0;
684	#endif
685	}
686
687
688	/* Lookup a variable whose name is a string starting at NAME
689	and with LENGTH chars in set SET. NAME need not be null-terminated.
690	Returns address of the `struct variable' containing all info
691	on the variable, or nil if no such variable is defined. */
692
693	struct variable *
694	lookup_variable_in_set (const char *name, unsigned int length,
695	const struct variable_set *set)
696	{
697	struct variable var_key;
698	#ifndef CONFIG_WITH_STRCACHE2
699	var_key.name = (char *) name;
700	var_key.length = length;
701
702	return (struct variable ) hash_find_item ((struct hash_table ) &set->table, &var_key);
703	#else /* CONFIG_WITH_STRCACHE2 */
704	const char *cached_name;
705
706	/* lookup the name in the string case, if it's not there it won't
707	be in any of the sets either. Optimize lookups in the global set. */
708	cached_name = strcache2_lookup(&variable_strcache, name, length);
709	if (!cached_name)
710	return NULL;
711
712	if (set == &global_variable_set)
713	{
714	struct variable *v;
715	v = strcache2_get_user_val (&variable_strcache, cached_name);
716	assert (!v \|\| v->name == cached_name);
717	return v;
718	}
719
720	var_key.name = cached_name;
721	var_key.length = length;
722
723	return (struct variable *) hash_find_item_strcached (
724	(struct hash_table *) &set->table, &var_key);
725	#endif /* CONFIG_WITH_STRCACHE2 */
726	}
727
728
729	/* Initialize FILE's variable set list. If FILE already has a variable set
730	list, the topmost variable set is left intact, but the the rest of the
731	chain is replaced with FILE->parent's setlist. If FILE is a double-colon
732	rule, then we will use the "root" double-colon target's variable set as the
733	parent of FILE's variable set.
734
735	If we're READING a makefile, don't do the pattern variable search now,
736	since the pattern variable might not have been defined yet. */
737
738	void
739	initialize_file_variables (struct file *file, int reading)
740	{
741	struct variable_set_list *l = file->variables;
742
743	if (l == 0)
744	{
745	#ifndef CONFIG_WITH_ALLOC_CACHES
746	l = (struct variable_set_list *)
747	xmalloc (sizeof (struct variable_set_list));
748	l->set = xmalloc (sizeof (struct variable_set));
749	#else /* CONFIG_WITH_ALLOC_CACHES */
750	l = (struct variable_set_list *)
751	alloccache_alloc (&variable_set_list_cache);
752	l->set = (struct variable_set *)
753	alloccache_alloc (&variable_set_cache);
754	#endif /* CONFIG_WITH_ALLOC_CACHES */
755	#ifndef CONFIG_WITH_STRCACHE2
756	hash_init (&l->set->table, PERFILE_VARIABLE_BUCKETS,
757	variable_hash_1, variable_hash_2, variable_hash_cmp);
758	#else /* CONFIG_WITH_STRCACHE2 */
759	hash_init_strcached (&l->set->table, PERFILE_VARIABLE_BUCKETS,
760	&variable_strcache, offsetof (struct variable, name));
761	#endif /* CONFIG_WITH_STRCACHE2 */
762	file->variables = l;
763	}
764
765	/* If this is a double-colon, then our "parent" is the "root" target for
766	this double-colon rule. Since that rule has the same name, parent,
767	etc. we can just use its variables as the "next" for ours. */
768
769	if (file->double_colon && file->double_colon != file)
770	{
771	initialize_file_variables (file->double_colon, reading);
772	l->next = file->double_colon->variables;
773	return;
774	}
775
776	if (file->parent == 0)
777	l->next = &global_setlist;
778	else
779	{
780	initialize_file_variables (file->parent, reading);
781	l->next = file->parent->variables;
782	}
783
784	/* If we're not reading makefiles and we haven't looked yet, see if
785	we can find pattern variables for this target. */
786
787	if (!reading && !file->pat_searched)
788	{
789	struct pattern_var *p;
790
791	p = lookup_pattern_var (0, file->name);
792	if (p != 0)
793	{
794	struct variable_set_list *global = current_variable_set_list;
795
796	/* We found at least one. Set up a new variable set to accumulate
797	all the pattern variables that match this target. */
798
799	file->pat_variables = create_new_variable_set ();
800	current_variable_set_list = file->pat_variables;
801
802	do
803	{
804	/* We found one, so insert it into the set. */
805
806	struct variable *v;
807
808	if (p->variable.flavor == f_simple)
809	{
810	v = define_variable_loc (
811	p->variable.name, strlen (p->variable.name),
812	p->variable.value, p->variable.origin,
813	0, &p->variable.fileinfo);
814
815	v->flavor = f_simple;
816	}
817	else
818	{
819	#ifndef CONFIG_WITH_VALUE_LENGTH
820	v = do_variable_definition (
821	&p->variable.fileinfo, p->variable.name,
822	p->variable.value, p->variable.origin,
823	p->variable.flavor, 1);
824	#else
825	v = do_variable_definition_2 (
826	&p->variable.fileinfo, p->variable.name,
827	p->variable.value, p->variable.value_length, 0, 0,
828	p->variable.origin, p->variable.flavor, 1);
829	#endif
830	}
831
832	/* Also mark it as a per-target and copy export status. */
833	v->per_target = p->variable.per_target;
834	v->export = p->variable.export;
835	}
836	while ((p = lookup_pattern_var (p, file->name)) != 0);
837
838	current_variable_set_list = global;
839	}
840	file->pat_searched = 1;
841	}
842
843	/* If we have a pattern variable match, set it up. */
844
845	if (file->pat_variables != 0)
846	{
847	file->pat_variables->next = l->next;
848	l->next = file->pat_variables;
849	}
850	}
851
852
853	/* Pop the top set off the current variable set list,
854	and free all its storage. */
855
856	struct variable_set_list *
857	create_new_variable_set (void)
858	{
859	register struct variable_set_list *setlist;
860	register struct variable_set *set;
861
862	#ifndef CONFIG_WITH_ALLOC_CACHES
863	set = xmalloc (sizeof (struct variable_set));
864	#else
865	set = (struct variable_set *) alloccache_alloc (&variable_set_cache);
866	#endif
867	#ifndef CONFIG_WITH_STRCACHE2
868	hash_init (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
869	variable_hash_1, variable_hash_2, variable_hash_cmp);
870	#else /* CONFIG_WITH_STRCACHE2 */
871	hash_init_strcached (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
872	&variable_strcache, offsetof (struct variable, name));
873	#endif /* CONFIG_WITH_STRCACHE2 */
874
875	#ifndef CONFIG_WITH_ALLOC_CACHES
876	setlist = (struct variable_set_list *)
877	xmalloc (sizeof (struct variable_set_list));
878	#else
879	setlist = (struct variable_set_list *)
880	alloccache_alloc (&variable_set_list_cache);
881	#endif
882	setlist->set = set;
883	setlist->next = current_variable_set_list;
884
885	return setlist;
886	}
887
888	static void
889	free_variable_name_and_value (const void *item)
890	{
891	struct variable v = (struct variable ) item;
892	#ifndef CONFIG_WITH_STRCACHE2
893	free (v->name);
894	#endif
895	free (v->value);
896	}
897
898	void
899	free_variable_set (struct variable_set_list *list)
900	{
901	hash_map (&list->set->table, free_variable_name_and_value);
902	#ifndef CONFIG_WITH_ALLOC_CACHES
903	hash_free (&list->set->table, 1);
904	free (list->set);
905	free (list);
906	#else
907	hash_free_cached (&list->set->table, 1, &variable_cache);
908	alloccache_free (&variable_set_cache, list->set);
909	alloccache_free (&variable_set_list_cache, list);
910	#endif
911	}
912
913	/* Create a new variable set and push it on the current setlist.
914	If we're pushing a global scope (that is, the current scope is the global
915	scope) then we need to "push" it the other way: file variable sets point
916	directly to the global_setlist so we need to replace that with the new one.
917	*/
918
919	struct variable_set_list *
920	push_new_variable_scope (void)
921	{
922	current_variable_set_list = create_new_variable_set();
923	if (current_variable_set_list->next == &global_setlist)
924	{
925	/* It was the global, so instead of new -> &global we want to replace
926	&global with the new one and have &global -> new, with current still
927	pointing to &global */
928	struct variable_set *set = current_variable_set_list->set;
929	current_variable_set_list->set = global_setlist.set;
930	global_setlist.set = set;
931	current_variable_set_list->next = global_setlist.next;
932	global_setlist.next = current_variable_set_list;
933	current_variable_set_list = &global_setlist;
934	}
935	return (current_variable_set_list);
936	}
937
938	void
939	pop_variable_scope (void)
940	{
941	struct variable_set_list *setlist;
942	struct variable_set *set;
943
944	/* Can't call this if there's no scope to pop! */
945	assert(current_variable_set_list->next != NULL);
946
947	if (current_variable_set_list != &global_setlist)
948	{
949	/* We're not pointing to the global setlist, so pop this one. */
950	setlist = current_variable_set_list;
951	set = setlist->set;
952	current_variable_set_list = setlist->next;
953	}
954	else
955	{
956	/* This set is the one in the global_setlist, but there is another global
957	set beyond that. We want to copy that set to global_setlist, then
958	delete what used to be in global_setlist. */
959	setlist = global_setlist.next;
960	set = global_setlist.set;
961	global_setlist.set = setlist->set;
962	global_setlist.next = setlist->next;
963	}
964
965	/* Free the one we no longer need. */
966	#ifndef CONFIG_WITH_ALLOC_CACHES
967	free (setlist);
968	hash_map (&set->table, free_variable_name_and_value);
969	hash_free (&set->table, 1);
970	free (set);
971	#else
972	alloccache_free (&variable_set_list_cache, setlist);
973	hash_map (&set->table, free_variable_name_and_value);
974	hash_free_cached (&set->table, 1, &variable_cache);
975	alloccache_free (&variable_set_cache, set);
976	#endif
977	}
978
979
980	/* Merge FROM_SET into TO_SET, freeing unused storage in FROM_SET. */
981
982	static void
983	merge_variable_sets (struct variable_set *to_set,
984	struct variable_set *from_set)
985	{
986	struct variable from_var_slot = (struct variable ) from_set->table.ht_vec;
987	struct variable **from_var_end = from_var_slot + from_set->table.ht_size;
988
989	for ( ; from_var_slot < from_var_end; from_var_slot++)
990	if (! HASH_VACANT (*from_var_slot))
991	{
992	struct variable from_var = from_var_slot;
993	struct variable **to_var_slot
994	#ifndef CONFIG_WITH_STRCACHE2
995	= (struct variable *) hash_find_slot (&to_set->table, from_var_slot);
996	#else /* CONFIG_WITH_STRCACHE2 */
997	= (struct variable **) hash_find_slot_strcached (&to_set->table,
998	*from_var_slot);
999	#endif /* CONFIG_WITH_STRCACHE2 */
1000	if (HASH_VACANT (*to_var_slot))
1001	hash_insert_at (&to_set->table, from_var, to_var_slot);
1002	else
1003	{
1004	/* GKM FIXME: delete in from_set->table */
1005	free (from_var->value);
1006	free (from_var);
1007	}
1008	}
1009	}
1010
1011	/* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */
1012
1013	void
1014	merge_variable_set_lists (struct variable_set_list **setlist0,
1015	struct variable_set_list *setlist1)
1016	{
1017	struct variable_set_list to = setlist0;
1018	struct variable_set_list *last0 = 0;
1019
1020	/* If there's nothing to merge, stop now. */
1021	if (!setlist1)
1022	return;
1023
1024	/* This loop relies on the fact that all setlists terminate with the global
1025	setlist (before NULL). If that's not true, arguably we SHOULD die. */
1026	if (to)
1027	while (setlist1 != &global_setlist && to != &global_setlist)
1028	{
1029	struct variable_set_list *from = setlist1;
1030	setlist1 = setlist1->next;
1031
1032	merge_variable_sets (to->set, from->set);
1033
1034	last0 = to;
1035	to = to->next;
1036	}
1037
1038	if (setlist1 != &global_setlist)
1039	{
1040	if (last0 == 0)
1041	*setlist0 = setlist1;
1042	else
1043	last0->next = setlist1;
1044	}
1045	}
1046
1047
1048	/* Define the automatic variables, and record the addresses
1049	of their structures so we can change their values quickly. */
1050
1051	void
1052	define_automatic_variables (void)
1053	{
1054	#if defined(WINDOWS32) \|\| defined(__EMX__)
1055	extern char* default_shell;
1056	#else
1057	extern char default_shell[];
1058	#endif
1059	register struct variable *v;
1060	#ifndef KMK
1061	char buf[200];
1062	#else
1063	char buf[1024];
1064	const char *val;
1065	struct variable *envvar1;
1066	struct variable *envvar2;
1067	#endif
1068
1069	sprintf (buf, "%u", makelevel);
1070	(void) define_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH, buf, o_env, 0);
1071
1072	sprintf (buf, "%s%s%s",
1073	version_string,
1074	(remote_description == 0 \|\| remote_description[0] == '\0')
1075	? "" : "-",
1076	(remote_description == 0 \|\| remote_description[0] == '\0')
1077	? "" : remote_description);
1078	#ifndef KMK
1079	(void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0);
1080	#else /* KMK */
1081
1082	/* Define KMK_VERSION to indicate kMk. */
1083	(void) define_variable ("KMK_VERSION", 11, buf, o_default, 0);
1084
1085	/* Define KBUILD_VERSION* */
1086	sprintf (buf, "%d", KBUILD_VERSION_MAJOR);
1087	define_variable ("KBUILD_VERSION_MAJOR", sizeof ("KBUILD_VERSION_MAJOR") - 1,
1088	buf, o_default, 0);
1089	sprintf (buf, "%d", KBUILD_VERSION_MINOR);
1090	define_variable ("KBUILD_VERSION_MINOR", sizeof("KBUILD_VERSION_MINOR") - 1,
1091	buf, o_default, 0);
1092	sprintf (buf, "%d", KBUILD_VERSION_PATCH);
1093	define_variable ("KBUILD_VERSION_PATCH", sizeof ("KBUILD_VERSION_PATCH") - 1,
1094	buf, o_default, 0);
1095	sprintf (buf, "%d", KBUILD_SVN_REV);
1096	define_variable ("KBUILD_KMK_REVISION", sizeof ("KBUILD_KMK_REVISION") - 1,
1097	buf, o_default, 0);
1098
1099	sprintf (buf, "%d.%d.%d-r%d", KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR,
1100	KBUILD_VERSION_PATCH, KBUILD_SVN_REV);
1101	define_variable ("KBUILD_VERSION", sizeof ("KBUILD_VERSION") - 1,
1102	buf, o_default, 0);
1103
1104	/* The host defaults. The BUILD_* stuff will be replaced by KBUILD_* soon. */
1105	envvar1 = lookup_variable (STRING_SIZE_TUPLE ("KBUILD_HOST"));
1106	envvar2 = lookup_variable (STRING_SIZE_TUPLE ("BUILD_PLATFORM"));
1107	val = envvar1 ? envvar1->value : envvar2 ? envvar2->value : KBUILD_HOST;
1108	if (envvar1 && envvar2 && strcmp (envvar1->value, envvar2->value))
1109	error (NULL, _("KBUILD_HOST and BUILD_PLATFORM differs, using KBUILD_HOST=%s."), val);
1110	if (!envvar1)
1111	define_variable ("KBUILD_HOST", sizeof ("KBUILD_HOST") - 1,
1112	val, o_default, 0);
1113	if (!envvar2)
1114	define_variable ("BUILD_PLATFORM", sizeof ("BUILD_PLATFORM") - 1,
1115	val, o_default, 0);
1116
1117	envvar1 = lookup_variable (STRING_SIZE_TUPLE ("KBUILD_HOST_ARCH"));
1118	envvar2 = lookup_variable (STRING_SIZE_TUPLE ("BUILD_PLATFORM_ARCH"));
1119	val = envvar1 ? envvar1->value : envvar2 ? envvar2->value : KBUILD_HOST_ARCH;
1120	if (envvar1 && envvar2 && strcmp (envvar1->value, envvar2->value))
1121	error (NULL, _("KBUILD_HOST_ARCH and BUILD_PLATFORM_ARCH differs, using KBUILD_HOST_ARCH=%s."), val);
1122	if (!envvar1)
1123	define_variable ("KBUILD_HOST_ARCH", sizeof ("KBUILD_HOST_ARCH") - 1,
1124	val, o_default, 0);
1125	if (!envvar2)
1126	define_variable ("BUILD_PLATFORM_ARCH", sizeof ("BUILD_PLATFORM_ARCH") - 1,
1127	val, o_default, 0);
1128
1129	envvar1 = lookup_variable (STRING_SIZE_TUPLE ("KBUILD_HOST_CPU"));
1130	envvar2 = lookup_variable (STRING_SIZE_TUPLE ("BUILD_PLATFORM_CPU"));
1131	val = envvar1 ? envvar1->value : envvar2 ? envvar2->value : KBUILD_HOST_CPU;
1132	if (envvar1 && envvar2 && strcmp (envvar1->value, envvar2->value))
1133	error (NULL, _("KBUILD_HOST_CPU and BUILD_PLATFORM_CPU differs, using KBUILD_HOST_CPU=%s."), val);
1134	if (!envvar1)
1135	define_variable ("KBUILD_HOST_CPU", sizeof ("KBUILD_HOST_CPU") - 1,
1136	val, o_default, 0);
1137	if (!envvar2)
1138	define_variable ("BUILD_PLATFORM_CPU", sizeof ("BUILD_PLATFORM_CPU") - 1,
1139	val, o_default, 0);
1140
1141	/* The kBuild locations. */
1142	define_variable ("KBUILD_PATH", sizeof ("KBUILD_PATH") - 1,
1143	get_kbuild_path (), o_default, 0);
1144	define_variable ("KBUILD_BIN_PATH", sizeof ("KBUILD_BIN_PATH") - 1,
1145	get_kbuild_bin_path (), o_default, 0);
1146
1147	define_variable ("PATH_KBUILD", sizeof ("PATH_KBUILD") - 1,
1148	get_kbuild_path (), o_default, 0);
1149	define_variable ("PATH_KBUILD_BIN", sizeof ("PATH_KBUILD_BIN") - 1,
1150	get_kbuild_bin_path (), o_default, 0);
1151
1152	/* Define KMK_FEATURES to indicate various working KMK features. */
1153	# if defined (CONFIG_WITH_RSORT) \
1154	&& defined (CONFIG_WITH_ABSPATHEX) \
1155	&& defined (CONFIG_WITH_TOUPPER_TOLOWER) \
1156	&& defined (CONFIG_WITH_DEFINED) \
1157	&& defined (CONFIG_WITH_VALUE_LENGTH) && defined (CONFIG_WITH_COMPARE) \
1158	&& defined (CONFIG_WITH_STACK) \
1159	&& defined (CONFIG_WITH_MATH) \
1160	&& defined (CONFIG_WITH_XARGS) \
1161	&& defined (CONFIG_WITH_EXPLICIT_MULTITARGET) \
1162	&& defined (CONFIG_WITH_PREPEND_ASSIGNMENT) \
1163	&& defined (CONFIG_WITH_SET_CONDITIONALS) \
1164	&& defined (CONFIG_WITH_DATE) \
1165	&& defined (CONFIG_WITH_FILE_SIZE) \
1166	&& defined (CONFIG_WITH_WHICH) \
1167	&& defined (CONFIG_WITH_EVALPLUS) \
1168	&& (defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)) \
1169	&& defined (CONFIG_WITH_COMMANDS_FUNC) \
1170	&& defined (KMK_HELPERS)
1171	(void) define_variable ("KMK_FEATURES", 12,
1172	"append-dash-n abspath includedep-queue"
1173	" rsort"
1174	" abspathex"
1175	" toupper tolower"
1176	" defined"
1177	" comp-vars comp-cmds comp-cmds-ex"
1178	" stack"
1179	" math-int"
1180	" xargs"
1181	" explicit-multitarget"
1182	" prepend-assignment"
1183	" set-conditionals"
1184	" date"
1185	" file-size"
1186	" expr if-expr"
1187	" which"
1188	" evalctx evalval evalvalctx evalcall evalcall2"
1189	" make-stats"
1190	" commands"
1191	" kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one "
1192	, o_default, 0);
1193	# else /* MSC can't deal with strings mixed with #if/#endif, thus the slow way. */
1194	# error "All features should be enabled by default!"
1195	strcpy (buf, "append-dash-n abspath includedep-queue");
1196	# if defined (CONFIG_WITH_RSORT)
1197	strcat (buf, " rsort");
1198	# endif
1199	# if defined (CONFIG_WITH_ABSPATHEX)
1200	strcat (buf, " abspathex");
1201	# endif
1202	# if defined (CONFIG_WITH_TOUPPER_TOLOWER)
1203	strcat (buf, " toupper tolower");
1204	# endif
1205	# if defined (CONFIG_WITH_DEFINED)
1206	strcat (buf, " defined");
1207	# endif
1208	# if defined (CONFIG_WITH_VALUE_LENGTH) && defined(CONFIG_WITH_COMPARE)
1209	strcat (buf, " comp-vars comp-cmds comp-cmds-ex");
1210	# endif
1211	# if defined (CONFIG_WITH_STACK)
1212	strcat (buf, " stack");
1213	# endif
1214	# if defined (CONFIG_WITH_MATH)
1215	strcat (buf, " math-int");
1216	# endif
1217	# if defined (CONFIG_WITH_XARGS)
1218	strcat (buf, " xargs");
1219	# endif
1220	# if defined (CONFIG_WITH_EXPLICIT_MULTITARGET)
1221	strcat (buf, " explicit-multitarget");
1222	# endif
1223	# if defined (CONFIG_WITH_PREPEND_ASSIGNMENT)
1224	strcat (buf, " prepend-assignment");
1225	# endif
1226	# if defined (CONFIG_WITH_SET_CONDITIONALS)
1227	strcat (buf, " set-conditionals");
1228	# endif
1229	# if defined (CONFIG_WITH_DATE)
1230	strcat (buf, " date");
1231	# endif
1232	# if defined (CONFIG_WITH_FILE_SIZE)
1233	strcat (buf, " file-size");
1234	# endif
1235	# if defined (CONFIG_WITH_IF_CONDITIONALS)
1236	strcat (buf, " expr if-expr");
1237	# endif
1238	# if defined (CONFIG_WITH_WHICH)
1239	strcat (buf, " which");
1240	# endif
1241	# if defined (CONFIG_WITH_EVALPLUS)
1242	strcat (buf, " evalctx evalval evalvalctx evalcall evalcall2");
1243	# endif
1244	# if defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)
1245	strcat (buf, " make-stats");
1246	# endif
1247	# if defined (CONFIG_WITH_COMMANDS_FUNC)
1248	strcat (buf, " commands");
1249	# endif
1250	# if defined (KMK_HELPERS)
1251	strcat (buf, " kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one");
1252	# endif
1253	(void) define_variable ("KMK_FEATURES", 12, buf, o_default, 0);
1254	# endif
1255
1256	#endif /* KMK */
1257
1258	#ifdef CONFIG_WITH_KMK_BUILTIN
1259	/* The supported kMk Builtin commands. */
1260	(void) define_variable ("KMK_BUILTIN", 11, "append cat chmod cp cmp echo expr install kDepIDB ln md5sum mkdir mv printf rm rmdir test", o_default, 0);
1261	#endif
1262
1263	#ifdef __MSDOS__
1264	/* Allow to specify a special shell just for Make,
1265	and use $COMSPEC as the default $SHELL when appropriate. */
1266	{
1267	static char shell_str[] = "SHELL";
1268	const int shlen = sizeof (shell_str) - 1;
1269	struct variable *mshp = lookup_variable ("MAKESHELL", 9);
1270	struct variable *comp = lookup_variable ("COMSPEC", 7);
1271
1272	/* Make $MAKESHELL override $SHELL even if -e is in effect. */
1273	if (mshp)
1274	(void) define_variable (shell_str, shlen,
1275	mshp->value, o_env_override, 0);
1276	else if (comp)
1277	{
1278	/* $COMSPEC shouldn't override $SHELL. */
1279	struct variable *shp = lookup_variable (shell_str, shlen);
1280
1281	if (!shp)
1282	(void) define_variable (shell_str, shlen, comp->value, o_env, 0);
1283	}
1284	}
1285	#elif defined(__EMX__)
1286	{
1287	static char shell_str[] = "SHELL";
1288	const int shlen = sizeof (shell_str) - 1;
1289	struct variable *shell = lookup_variable (shell_str, shlen);
1290	struct variable *replace = lookup_variable ("MAKESHELL", 9);
1291
1292	/* if $MAKESHELL is defined in the environment assume o_env_override */
1293	if (replace && *replace->value && replace->origin == o_env)
1294	replace->origin = o_env_override;
1295
1296	/* if $MAKESHELL is not defined use $SHELL but only if the variable
1297	did not come from the environment */
1298	if (!replace \|\| !*replace->value)
1299	if (shell && *shell->value && (shell->origin == o_env
1300	\|\| shell->origin == o_env_override))
1301	{
1302	/* overwrite whatever we got from the environment */
1303	free(shell->value);
1304	shell->value = xstrdup (default_shell);
1305	shell->origin = o_default;
1306	}
1307
1308	/* Some people do not like cmd to be used as the default
1309	if $SHELL is not defined in the Makefile.
1310	With -DNO_CMD_DEFAULT you can turn off this behaviour */
1311	# ifndef NO_CMD_DEFAULT
1312	/* otherwise use $COMSPEC */
1313	if (!replace \|\| !*replace->value)
1314	replace = lookup_variable ("COMSPEC", 7);
1315
1316	/* otherwise use $OS2_SHELL */
1317	if (!replace \|\| !*replace->value)
1318	replace = lookup_variable ("OS2_SHELL", 9);
1319	# else
1320	# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
1321	# endif
1322
1323	if (replace && *replace->value)
1324	/* overwrite $SHELL */
1325	(void) define_variable (shell_str, shlen, replace->value,
1326	replace->origin, 0);
1327	else
1328	/* provide a definition if there is none */
1329	(void) define_variable (shell_str, shlen, default_shell,
1330	o_default, 0);
1331	}
1332
1333	#endif
1334
1335	/* This won't override any definition, but it will provide one if there
1336	isn't one there. */
1337	v = define_variable ("SHELL", 5, default_shell, o_default, 0);
1338
1339	/* On MSDOS we do use SHELL from environment, since it isn't a standard
1340	environment variable on MSDOS, so whoever sets it, does that on purpose.
1341	On OS/2 we do not use SHELL from environment but we have already handled
1342	that problem above. */
1343	#if !defined(__MSDOS__) && !defined(__EMX__)
1344	/* Don't let SHELL come from the environment. */
1345	if (*v->value == '\0' \|\| v->origin == o_env \|\| v->origin == o_env_override)
1346	{
1347	free (v->value);
1348	v->origin = o_file;
1349	v->value = xstrdup (default_shell);
1350	#ifdef CONFIG_WITH_VALUE_LENGTH
1351	v->value_length = strlen (v->value);
1352	v->value_alloc_len = v->value_length + 1;
1353	#endif
1354	}
1355	#endif
1356
1357	/* Make sure MAKEFILES gets exported if it is set. */
1358	v = define_variable ("MAKEFILES", 9, "", o_default, 0);
1359	v->export = v_ifset;
1360
1361	/* Define the magic D and F variables in terms of
1362	the automatic variables they are variations of. */
1363
1364	#ifdef VMS
1365	define_variable ("@D", 2, "$(dir $@)", o_automatic, 1);
1366	define_variable ("%D", 2, "$(dir $%)", o_automatic, 1);
1367	define_variable ("D", 2, "$(dir $)", o_automatic, 1);
1368	define_variable ("<D", 2, "$(dir $<)", o_automatic, 1);
1369	define_variable ("?D", 2, "$(dir $?)", o_automatic, 1);
1370	define_variable ("^D", 2, "$(dir $^)", o_automatic, 1);
1371	define_variable ("+D", 2, "$(dir $+)", o_automatic, 1);
1372	#else
1373	define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
1374	define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
1375	define_variable ("D", 2, "$(patsubst %/,%,$(dir $))", o_automatic, 1);
1376	define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
1377	define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
1378	define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
1379	define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
1380	#endif
1381	define_variable ("@F", 2, "$(notdir $@)", o_automatic, 1);
1382	define_variable ("%F", 2, "$(notdir $%)", o_automatic, 1);
1383	define_variable ("F", 2, "$(notdir $)", o_automatic, 1);
1384	define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
1385	define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
1386	define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
1387	define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
1388	}
1389
1390
1391	int export_all_variables;
1392
1393	/* Create a new environment for FILE's commands.
1394	If FILE is nil, this is for the `shell' function.
1395	The child's MAKELEVEL variable is incremented. */
1396
1397	char **
1398	target_environment (struct file *file)
1399	{
1400	struct variable_set_list *set_list;
1401	register struct variable_set_list *s;
1402	struct hash_table table;
1403	struct variable **v_slot;
1404	struct variable **v_end;
1405	struct variable makelevel_key;
1406	char **result_0;
1407	char **result;
1408	#ifdef CONFIG_WITH_STRCACHE2
1409	const char *cached_name;
1410	#endif
1411
1412	if (file == 0)
1413	set_list = current_variable_set_list;
1414	else
1415	set_list = file->variables;
1416
1417	#ifndef CONFIG_WITH_STRCACHE2
1418	hash_init (&table, VARIABLE_BUCKETS,
1419	variable_hash_1, variable_hash_2, variable_hash_cmp);
1420	#else /* CONFIG_WITH_STRCACHE2 */
1421	hash_init_strcached (&table, VARIABLE_BUCKETS,
1422	&variable_strcache, offsetof (struct variable, name));
1423	#endif /* CONFIG_WITH_STRCACHE2 */
1424
1425	/* Run through all the variable sets in the list,
1426	accumulating variables in TABLE. */
1427	for (s = set_list; s != 0; s = s->next)
1428	{
1429	struct variable_set *set = s->set;
1430	v_slot = (struct variable **) set->table.ht_vec;
1431	v_end = v_slot + set->table.ht_size;
1432	for ( ; v_slot < v_end; v_slot++)
1433	if (! HASH_VACANT (*v_slot))
1434	{
1435	struct variable **new_slot;
1436	struct variable v = v_slot;
1437
1438	/* If this is a per-target variable and it hasn't been touched
1439	already then look up the global version and take its export
1440	value. */
1441	if (v->per_target && v->export == v_default)
1442	{
1443	struct variable *gv;
1444
1445	#ifndef CONFIG_WITH_VALUE_LENGTH
1446	gv = lookup_variable_in_set (v->name, strlen(v->name),
1447	&global_variable_set);
1448	#else
1449	assert ((int)strlen(v->name) == v->length);
1450	gv = lookup_variable_in_set (v->name, v->length,
1451	&global_variable_set);
1452	#endif
1453	if (gv)
1454	v->export = gv->export;
1455	}
1456
1457	switch (v->export)
1458	{
1459	case v_default:
1460	if (v->origin == o_default \|\| v->origin == o_automatic)
1461	/* Only export default variables by explicit request. */
1462	continue;
1463
1464	/* The variable doesn't have a name that can be exported. */
1465	if (! v->exportable)
1466	continue;
1467
1468	if (! export_all_variables
1469	&& v->origin != o_command
1470	&& v->origin != o_env && v->origin != o_env_override)
1471	continue;
1472	break;
1473
1474	case v_export:
1475	break;
1476
1477	case v_noexport:
1478	/* If this is the SHELL variable and it's not exported, then
1479	add the value from our original environment. */
1480	if (streq (v->name, "SHELL"))
1481	{
1482	extern struct variable shell_var;
1483	v = &shell_var;
1484	break;
1485	}
1486	continue;
1487
1488	case v_ifset:
1489	if (v->origin == o_default)
1490	continue;
1491	break;
1492	}
1493
1494	#ifndef CONFIG_WITH_STRCACHE2
1495	new_slot = (struct variable **) hash_find_slot (&table, v);
1496	#else /* CONFIG_WITH_STRCACHE2 */
1497	new_slot = (struct variable **) hash_find_slot_strcached (&table, v);
1498	#endif /* CONFIG_WITH_STRCACHE2 */
1499	if (HASH_VACANT (*new_slot))
1500	hash_insert_at (&table, v, new_slot);
1501	}
1502	}
1503
1504	#ifndef CONFIG_WITH_STRCACHE2
1505	makelevel_key.name = MAKELEVEL_NAME;
1506	makelevel_key.length = MAKELEVEL_LENGTH;
1507	hash_delete (&table, &makelevel_key);
1508	#else /* CONFIG_WITH_STRCACHE2 */
1509	/* lookup the name in the string case, if it's not there it won't
1510	be in any of the sets either. */
1511	cached_name = strcache2_lookup (&variable_strcache,
1512	MAKELEVEL_NAME, MAKELEVEL_LENGTH);
1513	if (cached_name)
1514	{
1515	makelevel_key.name = cached_name;
1516	makelevel_key.length = MAKELEVEL_LENGTH;
1517	hash_delete_strcached (&table, &makelevel_key);
1518	}
1519	#endif /* CONFIG_WITH_STRCACHE2 */
1520
1521	result = result_0 = xmalloc ((table.ht_fill + 2) * sizeof (char *));
1522
1523	v_slot = (struct variable **) table.ht_vec;
1524	v_end = v_slot + table.ht_size;
1525	for ( ; v_slot < v_end; v_slot++)
1526	if (! HASH_VACANT (*v_slot))
1527	{
1528	struct variable v = v_slot;
1529
1530	/* If V is recursively expanded and didn't come from the environment,
1531	expand its value. If it came from the environment, it should
1532	go back into the environment unchanged. */
1533	if (v->recursive
1534	&& v->origin != o_env && v->origin != o_env_override)
1535	{
1536	#ifndef CONFIG_WITH_VALUE_LENGTH
1537	char *value = recursively_expand_for_file (v, file);
1538	#else
1539	char *value = recursively_expand_for_file (v, file, NULL);
1540	#endif
1541	#ifdef WINDOWS32
1542	if (strcmp(v->name, "Path") == 0 \|\|
1543	strcmp(v->name, "PATH") == 0)
1544	convert_Path_to_windows32(value, ';');
1545	#endif
1546	*result++ = xstrdup (concat (v->name, "=", value));
1547	free (value);
1548	}
1549	else
1550	{
1551	#ifdef WINDOWS32
1552	if (strcmp(v->name, "Path") == 0 \|\|
1553	strcmp(v->name, "PATH") == 0)
1554	convert_Path_to_windows32(v->value, ';');
1555	#endif
1556	*result++ = xstrdup (concat (v->name, "=", v->value));
1557	}
1558	}
1559
1560	*result = xmalloc (100);
1561	sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
1562	*++result = 0;
1563
1564	hash_free (&table, 0);
1565
1566	return result_0;
1567	}
1568
1569
1570	#ifdef CONFIG_WITH_VALUE_LENGTH
1571	/* Worker function for do_variable_definition_append() and
1572	append_expanded_string_to_variable().
1573	The APPEND argument indicates whether it's an append or prepend operation. */
1574	void append_string_to_variable (struct variable v, const char value, unsigned int value_len, int append)
1575	{
1576	/* The previous definition of the variable was recursive.
1577	The new value is the unexpanded old and new values. */
1578	unsigned int new_value_len = value_len + (v->value_length != 0 ? 1 + v->value_length : 0);
1579	int done_1st_prepend_copy = 0;
1580
1581	/* Drop empty strings. Use $(NO_SUCH_VARIABLE) if a space is wanted. */
1582	if (!value_len)
1583	return;
1584
1585	/* adjust the size. */
1586	if ((unsigned)v->value_alloc_len <= new_value_len + 1)
1587	{
1588	v->value_alloc_len *= 2;
1589	if ((unsigned)v->value_alloc_len < new_value_len + 1)
1590	v->value_alloc_len = (new_value_len + 1 + value_len + 0x7f) + ~0x7fU;
1591	if (append \|\| !v->value_length)
1592	v->value = xrealloc (v->value, v->value_alloc_len);
1593	else
1594	{
1595	/* avoid the extra memcpy the xrealloc may have to do */
1596	char *new_buf = xmalloc (v->value_alloc_len);
1597	memcpy (&new_buf[value_len + 1], v->value, v->value_length + 1);
1598	done_1st_prepend_copy = 1;
1599	free (v->value);
1600	v->value = new_buf;
1601	}
1602	}
1603
1604	/* insert the new bits */
1605	if (v->value_length != 0)
1606	{
1607	if (append)
1608	{
1609	v->value[v->value_length] = ' ';
1610	memcpy (&v->value[v->value_length + 1], value, value_len + 1);
1611	}
1612	else
1613	{
1614	if (!done_1st_prepend_copy)
1615	memmove (&v->value[value_len + 1], v->value, v->value_length + 1);
1616	v->value[value_len] = ' ';
1617	memcpy (v->value, value, value_len);
1618	}
1619	}
1620	else
1621	memcpy (v->value, value, value_len + 1);
1622	v->value_length = new_value_len;
1623	}
1624
1625	static struct variable *
1626	do_variable_definition_append (const struct floc flocp, struct variable v,
1627	const char *value, unsigned int value_len,
1628	int simple_value, enum variable_origin origin,
1629	int append)
1630	{
1631	if (env_overrides && origin == o_env)
1632	origin = o_env_override;
1633
1634	if (env_overrides && v->origin == o_env)
1635	/* V came from in the environment. Since it was defined
1636	before the switches were parsed, it wasn't affected by -e. */
1637	v->origin = o_env_override;
1638
1639	/* A variable of this name is already defined.
1640	If the old definition is from a stronger source
1641	than this one, don't redefine it. */
1642	if ((int) origin < (int) v->origin)
1643	return v;
1644	v->origin = origin;
1645
1646	/* location */
1647	if (flocp != 0)
1648	v->fileinfo = *flocp;
1649
1650	/* The juicy bits, append the specified value to the variable
1651	This is a heavily exercised code path in kBuild. */
1652	if (value_len == ~0U)
1653	value_len = strlen (value);
1654	if (v->recursive \|\| simple_value)
1655	append_string_to_variable (v, value, value_len, append);
1656	else
1657	/* The previous definition of the variable was simple.
1658	The new value comes from the old value, which was expanded
1659	when it was set; and from the expanded new value. */
1660	append_expanded_string_to_variable (v, value, value_len, append);
1661
1662	/* update the variable */
1663	return v;
1664	}
1665	#endif /* CONFIG_WITH_VALUE_LENGTH */
1666
1667
1668	/* Given a variable, a value, and a flavor, define the variable.
1669	See the try_variable_definition() function for details on the parameters. */
1670
1671	struct variable *
1672	#ifndef CONFIG_WITH_VALUE_LENGTH
1673	do_variable_definition (const struct floc flocp, const char varname,
1674	const char *value, enum variable_origin origin,
1675	enum variable_flavor flavor, int target_var)
1676	#else /* CONFIG_WITH_VALUE_LENGTH */
1677	do_variable_definition_2 (const struct floc *flocp,
1678	const char varname, const char value,
1679	unsigned int value_len, int simple_value,
1680	char *free_value,
1681	enum variable_origin origin,
1682	enum variable_flavor flavor,
1683	int target_var)
1684	#endif /* CONFIG_WITH_VALUE_LENGTH */
1685	{
1686	const char *p;
1687	char *alloc_value = NULL;
1688	struct variable *v;
1689	int append = 0;
1690	int conditional = 0;
1691	const size_t varname_len = strlen (varname); /* bird */
1692	#ifdef CONFIG_WITH_VALUE_LENGTH
1693	assert (value_len == ~0U \|\| value_len == strlen (value));
1694	#endif
1695
1696	/* Calculate the variable's new value in VALUE. */
1697
1698	switch (flavor)
1699	{
1700	default:
1701	case f_bogus:
1702	/* Should not be possible. */
1703	abort ();
1704	case f_simple:
1705	/* A simple variable definition "var := value". Expand the value.
1706	We have to allocate memory since otherwise it'll clobber the
1707	variable buffer, and we may still need that if we're looking at a
1708	target-specific variable. */
1709	#ifndef CONFIG_WITH_VALUE_LENGTH
1710	p = alloc_value = allocated_variable_expand (value);
1711	#else /* CONFIG_WITH_VALUE_LENGTH */
1712	if (!simple_value)
1713	p = alloc_value = allocated_variable_expand_2 (value, value_len, &value_len);
1714	else
1715	{
1716	if (value_len == ~0U)
1717	value_len = strlen (value);
1718	if (!free_value)
1719	p = alloc_value = savestring (value, value_len);
1720	else
1721	{
1722	assert (value == free_value);
1723	p = alloc_value = free_value;
1724	free_value = 0;
1725	}
1726	}
1727	#endif /* CONFIG_WITH_VALUE_LENGTH */
1728	break;
1729	case f_conditional:
1730	/* A conditional variable definition "var ?= value".
1731	The value is set IFF the variable is not defined yet. */
1732	v = lookup_variable (varname, varname_len);
1733	if (v)
1734	return v;
1735
1736	conditional = 1;
1737	flavor = f_recursive;
1738	/* FALLTHROUGH */
1739	case f_recursive:
1740	/* A recursive variable definition "var = value".
1741	The value is used verbatim. */
1742	p = value;
1743	break;
1744	#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1745	case f_append:
1746	case f_prepend:
1747	{
1748	const enum variable_flavor org_flavor = flavor;
1749	#else
1750	case f_append:
1751	{
1752	#endif
1753
1754	#ifdef CONFIG_WITH_LOCAL_VARIABLES
1755	/* If we have += but we're in a target or local variable context,
1756	we want to append only with other variables in the context of
1757	this target. */
1758	if (target_var \|\| origin == o_local)
1759	#else
1760	/* If we have += but we're in a target variable context, we want to
1761	append only with other variables in the context of this target. */
1762	if (target_var)
1763	#endif
1764	{
1765	append = 1;
1766	v = lookup_variable_in_set (varname, varname_len,
1767	current_variable_set_list->set);
1768
1769	/* Don't append from the global set if a previous non-appending
1770	target-specific variable definition exists. */
1771	if (v && !v->append)
1772	append = 0;
1773	}
1774	else
1775	v = lookup_variable (varname, varname_len);
1776
1777	if (v == 0)
1778	{
1779	/* There was no old value.
1780	This becomes a normal recursive definition. */
1781	p = value;
1782	flavor = f_recursive;
1783	}
1784	else
1785	{
1786	#ifdef CONFIG_WITH_VALUE_LENGTH
1787	v->append = append;
1788	v = do_variable_definition_append (flocp, v, value, value_len,
1789	simple_value, origin,
1790	# ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1791	org_flavor == f_append);
1792	# else
1793	1);
1794	# endif
1795	if (free_value)
1796	free (free_value);
1797	return v;
1798	#else /* !CONFIG_WITH_VALUE_LENGTH */
1799
1800	/* Paste the old and new values together in VALUE. */
1801
1802	unsigned int oldlen, vallen;
1803	const char *val;
1804	char *tp;
1805
1806	val = value;
1807	if (v->recursive)
1808	/* The previous definition of the variable was recursive.
1809	The new value is the unexpanded old and new values. */
1810	flavor = f_recursive;
1811	else
1812	/* The previous definition of the variable was simple.
1813	The new value comes from the old value, which was expanded
1814	when it was set; and from the expanded new value. Allocate
1815	memory for the expansion as we may still need the rest of the
1816	buffer if we're looking at a target-specific variable. */
1817	val = alloc_value = allocated_variable_expand (val);
1818
1819	oldlen = strlen (v->value);
1820	vallen = strlen (val);
1821	tp = alloca (oldlen + 1 + vallen + 1);
1822	# ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1823	if (org_flavor == f_prepend)
1824	{
1825	memcpy (tp, val, vallen);
1826	tp[oldlen] = ' ';
1827	memcpy (&tp[oldlen + 1], v->value, oldlen + 1);
1828	}
1829	else
1830	# endif /* CONFIG_WITH_PREPEND_ASSIGNMENT */
1831	{
1832	memcpy (tp, v->value, oldlen);
1833	tp[oldlen] = ' ';
1834	memcpy (&tp[oldlen + 1], val, vallen + 1);
1835	}
1836	p = tp;
1837	#endif /* !CONFIG_WITH_VALUE_LENGTH */
1838	}
1839	}
1840	}
1841
1842	#ifdef __MSDOS__
1843	/* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1844	non-Unix systems don't conform to this default configuration (in
1845	fact, most of them don't even have `/bin'). On the other hand,
1846	$SHELL in the environment, if set, points to the real pathname of
1847	the shell.
1848	Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1849	the Makefile override $SHELL from the environment. But first, we
1850	look for the basename of the shell in the directory where SHELL=
1851	points, and along the $PATH; if it is found in any of these places,
1852	we define $SHELL to be the actual pathname of the shell. Thus, if
1853	you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1854	your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1855	defining SHELL to be "d:/unix/bash.exe". */
1856	if ((origin == o_file \|\| origin == o_override)
1857	&& strcmp (varname, "SHELL") == 0)
1858	{
1859	PATH_VAR (shellpath);
1860	extern char * __dosexec_find_on_path (const char , char [], char *);
1861
1862	/* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1863	if (__dosexec_find_on_path (p, NULL, shellpath))
1864	{
1865	char *tp;
1866
1867	for (tp = shellpath; *tp; tp++)
1868	if (*tp == '\\')
1869	*tp = '/';
1870
1871	v = define_variable_loc (varname, varname_len,
1872	shellpath, origin, flavor == f_recursive,
1873	flocp);
1874	}
1875	else
1876	{
1877	const char shellbase, bslash;
1878	struct variable *pathv = lookup_variable ("PATH", 4);
1879	char *path_string;
1880	char *fake_env[2];
1881	size_t pathlen = 0;
1882
1883	shellbase = strrchr (p, '/');
1884	bslash = strrchr (p, '\\');
1885	if (!shellbase \|\| bslash > shellbase)
1886	shellbase = bslash;
1887	if (!shellbase && p[1] == ':')
1888	shellbase = p + 1;
1889	if (shellbase)
1890	shellbase++;
1891	else
1892	shellbase = p;
1893
1894	/* Search for the basename of the shell (with standard
1895	executable extensions) along the $PATH. */
1896	if (pathv)
1897	pathlen = strlen (pathv->value);
1898	path_string = xmalloc (5 + pathlen + 2 + 1);
1899	/* On MSDOS, current directory is considered as part of $PATH. */
1900	sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
1901	fake_env[0] = path_string;
1902	fake_env[1] = 0;
1903	if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
1904	{
1905	char *tp;
1906
1907	for (tp = shellpath; *tp; tp++)
1908	if (*tp == '\\')
1909	*tp = '/';
1910
1911	v = define_variable_loc (varname, varname_len,
1912	shellpath, origin,
1913	flavor == f_recursive, flocp);
1914	}
1915	else
1916	v = lookup_variable (varname, varname_len);
1917
1918	free (path_string);
1919	}
1920	}
1921	else
1922	#endif /* __MSDOS__ */
1923	#ifdef WINDOWS32
1924	if ( varname_len == sizeof("SHELL") - 1 /* bird */
1925	&& (origin == o_file \|\| origin == o_override \|\| origin == o_command)
1926	&& streq (varname, "SHELL"))
1927	{
1928	extern char *default_shell;
1929
1930	/* Call shell locator function. If it returns TRUE, then
1931	set no_default_sh_exe to indicate sh was found and
1932	set new value for SHELL variable. */
1933
1934	if (find_and_set_default_shell (p))
1935	{
1936	v = define_variable_in_set (varname, varname_len, default_shell,
1937	# ifdef CONFIG_WITH_VALUE_LENGTH
1938	~0U, 1 /* duplicate_value */,
1939	# endif
1940	origin, flavor == f_recursive,
1941	(target_var
1942	? current_variable_set_list->set
1943	: NULL),
1944	flocp);
1945	no_default_sh_exe = 0;
1946	}
1947	else
1948	v = lookup_variable (varname, varname_len);
1949	}
1950	else
1951	#endif
1952
1953	/* If we are defining variables inside an $(eval ...), we might have a
1954	different variable context pushed, not the global context (maybe we're
1955	inside a $(call ...) or something. Since this function is only ever
1956	invoked in places where we want to define globally visible variables,
1957	make sure we define this variable in the global set. */
1958
1959	v = define_variable_in_set (varname, varname_len, p,
1960	#ifdef CONFIG_WITH_VALUE_LENGTH
1961	value_len, !alloc_value,
1962	#endif
1963	origin, flavor == f_recursive,
1964	#ifdef CONFIG_WITH_LOCAL_VARIABLES
1965	(target_var \|\| origin == o_local
1966	#else
1967	(target_var
1968	#endif
1969	? current_variable_set_list->set : NULL),
1970	flocp);
1971	v->append = append;
1972	v->conditional = conditional;
1973
1974	#ifndef CONFIG_WITH_VALUE_LENGTH
1975	if (alloc_value)
1976	free (alloc_value);
1977	#else
1978	if (free_value)
1979	free (free_value);
1980	#endif
1981
1982	return v;
1983	}
1984
1985
1986	/* Try to interpret LINE (a null-terminated string) as a variable definition.
1987
1988	ORIGIN may be o_file, o_override, o_env, o_env_override,
1989	or o_command specifying that the variable definition comes
1990	from a makefile, an override directive, the environment with
1991	or without the -e switch, or the command line.
1992
1993	See the comments for parse_variable_definition().
1994
1995	If LINE was recognized as a variable definition, a pointer to its `struct
1996	variable' is returned. If LINE is not a variable definition, NULL is
1997	returned. */
1998
1999	struct variable *
2000	#ifndef CONFIG_WITH_VALUE_LENGTH
2001	parse_variable_definition (struct variable v, char line)
2002	#else
2003	parse_variable_definition (struct variable v, char line, char *eos)
2004	#endif
2005	{
2006	register int c;
2007	register char *p = line;
2008	register char *beg;
2009	register char *end;
2010	enum variable_flavor flavor = f_bogus;
2011	#ifndef CONFIG_WITH_VALUE_LENGTH
2012	char *name;
2013	#endif
2014
2015	while (1)
2016	{
2017	c = *p++;
2018	if (c == '\0' \|\| c == '#')
2019	return 0;
2020	if (c == '=')
2021	{
2022	end = p - 1;
2023	flavor = f_recursive;
2024	break;
2025	}
2026	else if (c == ':')
2027	if (*p == '=')
2028	{
2029	end = p++ - 1;
2030	flavor = f_simple;
2031	break;
2032	}
2033	else
2034	/* A colon other than := is a rule line, not a variable defn. */
2035	return 0;
2036	else if (c == '+' && *p == '=')
2037	{
2038	end = p++ - 1;
2039	flavor = f_append;
2040	break;
2041	}
2042	#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
2043	else if (c == '<' && *p == '=')
2044	{
2045	end = p++ - 1;
2046	flavor = f_prepend;
2047	break;
2048	}
2049	#endif
2050	else if (c == '?' && *p == '=')
2051	{
2052	end = p++ - 1;
2053	flavor = f_conditional;
2054	break;
2055	}
2056	else if (c == '$')
2057	{
2058	/* This might begin a variable expansion reference. Make sure we
2059	don't misrecognize chars inside the reference as =, := or +=. */
2060	char closeparen;
2061	int count;
2062	c = *p++;
2063	if (c == '(')
2064	closeparen = ')';
2065	else if (c == '{')
2066	closeparen = '}';
2067	else
2068	continue; /* Nope. */
2069
2070	/* P now points past the opening paren or brace.
2071	Count parens or braces until it is matched. */
2072	count = 0;
2073	for (; *p != '\0'; ++p)
2074	{
2075	if (*p == c)
2076	++count;
2077	else if (*p == closeparen && --count < 0)
2078	{
2079	++p;
2080	break;
2081	}
2082	}
2083	}
2084	}
2085	v->flavor = flavor;
2086
2087	beg = next_token (line);
2088	while (end > beg && isblank ((unsigned char)end[-1]))
2089	--end;
2090	p = next_token (p);
2091	v->value = p;
2092	#ifdef CONFIG_WITH_VALUE_LENGTH
2093	v->value_alloc_len = -1;
2094	v->value_length = eos != NULL ? eos - p : -1;
2095	assert (eos == NULL \|\| strchr (p, '\0') == eos);
2096	#endif
2097
2098	/* Expand the name, so "$(foo)bar = baz" works. */
2099	#ifndef CONFIG_WITH_VALUE_LENGTH
2100	name = alloca (end - beg + 1);
2101	memcpy (name, beg, end - beg);
2102	name[end - beg] = '\0';
2103	v->name = allocated_variable_expand (name);
2104	#else /* CONFIG_WITH_VALUE_LENGTH */
2105	v->name = allocated_variable_expand_2 (beg, end - beg, NULL);
2106	#endif /* CONFIG_WITH_VALUE_LENGTH */
2107
2108	if (v->name[0] == '\0')
2109	fatal (&v->fileinfo, _("empty variable name"));
2110
2111	return v;
2112	}
2113
2114
2115	/* Try to interpret LINE (a null-terminated string) as a variable definition.
2116
2117	ORIGIN may be o_file, o_override, o_env, o_env_override, o_local,
2118	or o_command specifying that the variable definition comes
2119	from a makefile, an override directive, the environment with
2120	or without the -e switch, or the command line.
2121
2122	See the comments for parse_variable_definition().
2123
2124	If LINE was recognized as a variable definition, a pointer to its `struct
2125	variable' is returned. If LINE is not a variable definition, NULL is
2126	returned. */
2127
2128	struct variable *
2129	#ifndef CONFIG_WITH_VALUE_LENGTH
2130	try_variable_definition (const struct floc flocp, char line,
2131	enum variable_origin origin, int target_var)
2132	#else
2133	try_variable_definition (const struct floc flocp, char line, char *eos,
2134	enum variable_origin origin, int target_var)
2135	#endif
2136	{
2137	struct variable v;
2138	struct variable *vp;
2139
2140	if (flocp != 0)
2141	v.fileinfo = *flocp;
2142	else
2143	v.fileinfo.filenm = 0;
2144
2145	#ifndef CONFIG_WITH_VALUE_LENGTH
2146	if (!parse_variable_definition (&v, line))
2147	return 0;
2148
2149	vp = do_variable_definition (flocp, v.name, v.value,
2150	origin, v.flavor, target_var);
2151	#else
2152	if (!parse_variable_definition (&v, line, eos))
2153	return 0;
2154
2155	vp = do_variable_definition_2 (flocp, v.name, v.value,
2156	v.value_length != -1 ? (unsigned int)v.value_length : ~0U, /* FIXME */
2157	0, NULL, origin, v.flavor, target_var);
2158	#endif
2159
2160	#ifndef CONFIG_WITH_STRCACHE2
2161	free (v.name);
2162	#else
2163	free ((char *)v.name);
2164	#endif
2165
2166	return vp;
2167	}
2168
2169
2170	/* Print information for variable V, prefixing it with PREFIX. */
2171
2172	static void
2173	print_variable (const void item, void arg)
2174	{
2175	const struct variable *v = item;
2176	const char *prefix = arg;
2177	const char *origin;
2178
2179	switch (v->origin)
2180	{
2181	case o_default:
2182	origin = _("default");
2183	break;
2184	case o_env:
2185	origin = _("environment");
2186	break;
2187	case o_file:
2188	origin = _("makefile");
2189	break;
2190	case o_env_override:
2191	origin = _("environment under -e");
2192	break;
2193	case o_command:
2194	origin = _("command line");
2195	break;
2196	case o_override:
2197	origin = _("`override' directive");
2198	break;
2199	case o_automatic:
2200	origin = _("automatic");
2201	break;
2202	#ifdef CONFIG_WITH_LOCAL_VARIABLES
2203	case o_local:
2204	origin = _("`local' directive");
2205	break;
2206	#endif
2207	case o_invalid:
2208	default:
2209	abort ();
2210	}
2211	fputs ("# ", stdout);
2212	fputs (origin, stdout);
2213	if (v->fileinfo.filenm)
2214	printf (_(" (from `%s', line %lu)"),
2215	v->fileinfo.filenm, v->fileinfo.lineno);
2216	putchar ('\n');
2217	fputs (prefix, stdout);
2218
2219	/* Is this a `define'? */
2220	if (v->recursive && strchr (v->value, '\n') != 0)
2221	printf ("define %s\n%s\nendef\n", v->name, v->value);
2222	else
2223	{
2224	register char *p;
2225
2226	printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
2227
2228	/* Check if the value is just whitespace. */
2229	p = next_token (v->value);
2230	if (p != v->value && *p == '\0')
2231	/* All whitespace. */
2232	printf ("$(subst ,,%s)", v->value);
2233	else if (v->recursive)
2234	fputs (v->value, stdout);
2235	else
2236	/* Double up dollar signs. */
2237	for (p = v->value; *p != '\0'; ++p)
2238	{
2239	if (*p == '$')
2240	putchar ('$');
2241	putchar (*p);
2242	}
2243	putchar ('\n');
2244	}
2245	}
2246
2247
2248	/* Print all the variables in SET. PREFIX is printed before
2249	the actual variable definitions (everything else is comments). */
2250
2251	void
2252	print_variable_set (struct variable_set set, char prefix)
2253	{
2254	hash_map_arg (&set->table, print_variable, prefix);
2255
2256	fputs (_("# variable set hash-table stats:\n"), stdout);
2257	fputs ("# ", stdout);
2258	hash_print_stats (&set->table, stdout);
2259	putc ('\n', stdout);
2260	}
2261
2262	/* Print the data base of variables. */
2263
2264	void
2265	print_variable_data_base (void)
2266	{
2267	puts (_("\n# Variables\n"));
2268
2269	print_variable_set (&global_variable_set, "");
2270
2271	puts (_("\n# Pattern-specific Variable Values"));
2272
2273	{
2274	struct pattern_var *p;
2275	int rules = 0;
2276
2277	for (p = pattern_vars; p != 0; p = p->next)
2278	{
2279	++rules;
2280	printf ("\n%s :\n", p->target);
2281	print_variable (&p->variable, "# ");
2282	}
2283
2284	if (rules == 0)
2285	puts (_("\n# No pattern-specific variable values."));
2286	else
2287	printf (_("\n# %u pattern-specific variable values"), rules);
2288	}
2289
2290	#ifdef CONFIG_WITH_STRCACHE2
2291	strcache2_print_stats (&variable_strcache, "# ");
2292	#endif
2293	}
2294
2295	#ifdef CONFIG_WITH_PRINT_STATS_SWITCH
2296	void
2297	print_variable_stats (void)
2298	{
2299	fputs (_("\n# Global variable hash-table stats:\n# "), stdout);
2300	hash_print_stats (&global_variable_set.table, stdout);
2301	fputs ("\n", stdout);
2302	}
2303	#endif
2304
2305	/* Print all the local variables of FILE. */
2306
2307	void
2308	print_file_variables (const struct file *file)
2309	{
2310	if (file->variables != 0)
2311	print_variable_set (file->variables->set, "# ");
2312	}
2313
2314	#ifdef WINDOWS32
2315	void
2316	sync_Path_environment (void)
2317	{
2318	char *path = allocated_variable_expand ("$(PATH)");
2319	static char *environ_path = NULL;
2320
2321	if (!path)
2322	return;
2323
2324	/*
2325	* If done this before, don't leak memory unnecessarily.
2326	* Free the previous entry before allocating new one.
2327	*/
2328	if (environ_path)
2329	free (environ_path);
2330
2331	/*
2332	* Create something WINDOWS32 world can grok
2333	*/
2334	convert_Path_to_windows32 (path, ';');
2335	environ_path = xstrdup (concat ("PATH", "=", path));
2336	putenv (environ_path);
2337	free (path);
2338	}
2339	#endif

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

source: kBuild/trunk/src/kmk/variable.c@ 1918

Download in other formats: