variable.c@ 2989

Last change on this file since 2989 was 2893, checked in by bird, 8 years ago
variables.c/target_environment: Cache the exported variables in the global_variable_set since there are likely to be very very many of them and they aren't usually changing when we've loaded the makefiles and start running make jobs. Also, use smaller hash tables for collecting exported variables (I've bumped VARIABLE_BUCKETS up a lot).
Property svn:eol-style set to `native`
File size: 101.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, 2007, 2008, 2009,
4	2010 Free Software 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 3 of the License, or (at your option) any later
10	version.
11
12	GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
15
16	You should have received a copy of the GNU General Public License along with
17	this program. If not, see <http://www.gnu.org/licenses/>. */
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	# ifdef WINDOWS32
36	# include <Windows.h>
37	# else
38	# include <sys/utsname.h>
39	# endif
40	#endif
41	#ifdef CONFIG_WITH_STRCACHE2
42	# include <stddef.h>
43	#endif
44	#ifdef CONFIG_WITH_COMPILER
45	# include "kmk_cc_exec.h"
46	#endif
47
48	#ifdef KMK
49	/** Gets the real variable if alias. For use when looking up variables. */
50	# define RESOLVE_ALIAS_VARIABLE(v) \
51	do { \
52	if ((v) != NULL && (v)->alias) \
53	{ \
54	(v) = (struct variable *)(v)->value; \
55	assert ((v)->aliased); \
56	assert (!(v)->alias); \
57	} \
58	} while (0)
59	#endif
60
61	#ifdef KMK
62	/* Incremented every time a variable is modified, so that target_environment
63	knows when to regenerate the table of exported global variables. */
64	static size_t global_variable_generation = 0;
65	#endif
66
67
68	/* Chain of all pattern-specific variables. */
69
70	static struct pattern_var *pattern_vars;
71
72	/* Pointer to the last struct in the pack of a specific size, from 1 to 255.*/
73
74	static struct pattern_var *last_pattern_vars[256];
75
76	/* Create a new pattern-specific variable struct. The new variable is
77	inserted into the PATTERN_VARS list in the shortest patterns first
78	order to support the shortest stem matching (the variables are
79	matched in the reverse order so the ones with the longest pattern
80	will be considered first). Variables with the same pattern length
81	are inserted in the definition order. */
82
83	struct pattern_var *
84	create_pattern_var (const char target, const char suffix)
85	{
86	register unsigned int len = strlen (target);
87	register struct pattern_var *p = xmalloc (sizeof (struct pattern_var));
88
89	if (pattern_vars != 0)
90	{
91	if (len < 256 && last_pattern_vars[len] != 0)
92	{
93	p->next = last_pattern_vars[len]->next;
94	last_pattern_vars[len]->next = p;
95	}
96	else
97	{
98	/* Find the position where we can insert this variable. */
99	register struct pattern_var **v;
100
101	for (v = &pattern_vars; ; v = &(*v)->next)
102	{
103	/* Insert at the end of the pack so that patterns with the
104	same length appear in the order they were defined .*/
105
106	if (v == 0 \|\| (v)->len > len)
107	{
108	p->next = *v;
109	*v = p;
110	break;
111	}
112	}
113	}
114	}
115	else
116	{
117	pattern_vars = p;
118	p->next = 0;
119	}
120
121	p->target = target;
122	p->len = len;
123	p->suffix = suffix + 1;
124
125	if (len < 256)
126	last_pattern_vars[len] = p;
127
128	return p;
129	}
130
131	/* Look up a target in the pattern-specific variable list. */
132
133	static struct pattern_var *
134	lookup_pattern_var (struct pattern_var start, const char target)
135	{
136	struct pattern_var *p;
137	unsigned int targlen = strlen(target);
138
139	for (p = start ? start->next : pattern_vars; p != 0; p = p->next)
140	{
141	const char *stem;
142	unsigned int stemlen;
143
144	if (p->len > targlen)
145	/* It can't possibly match. */
146	continue;
147
148	/* From the lengths of the filename and the pattern parts,
149	find the stem: the part of the filename that matches the %. */
150	stem = target + (p->suffix - p->target - 1);
151	stemlen = targlen - p->len + 1;
152
153	/* Compare the text in the pattern before the stem, if any. */
154	if (stem > target && !strneq (p->target, target, stem - target))
155	continue;
156
157	/* Compare the text in the pattern after the stem, if any.
158	We could test simply using streq, but this way we compare the
159	first two characters immediately. This saves time in the very
160	common case where the first character matches because it is a
161	period. */
162	if (*p->suffix == stem[stemlen]
163	&& (*p->suffix == '\0' \|\| streq (&p->suffix[1], &stem[stemlen+1])))
164	break;
165	}
166
167	return p;
168	}
169
170
171	#ifdef CONFIG_WITH_STRCACHE2
172	struct strcache2 variable_strcache;
173	#endif
174
175	/* Hash table of all global variable definitions. */
176
177	#ifndef CONFIG_WITH_STRCACHE2
178	static unsigned long
179	variable_hash_1 (const void *keyv)
180	{
181	struct variable const key = (struct variable const ) keyv;
182	return_STRING_N_HASH_1 (key->name, key->length);
183	}
184
185	static unsigned long
186	variable_hash_2 (const void *keyv)
187	{
188	struct variable const key = (struct variable const ) keyv;
189	return_STRING_N_HASH_2 (key->name, key->length);
190	}
191
192	static int
193	variable_hash_cmp (const void xv, const void yv)
194	{
195	struct variable const x = (struct variable const ) xv;
196	struct variable const y = (struct variable const ) yv;
197	int result = x->length - y->length;
198	if (result)
199	return result;
200
201	return_STRING_N_COMPARE (x->name, y->name, x->length);
202	}
203	#endif /* !CONFIG_WITH_STRCACHE2 */
204
205	#ifndef VARIABLE_BUCKETS
206	# ifdef KMK /* Move to Makefile.kmk? (insanely high, but wtf, it gets the collitions down) */
207	# define VARIABLE_BUCKETS 65535
208	# else /!KMK/
209	#define VARIABLE_BUCKETS 523
210	# endif /!KMK/
211	#endif
212	#ifndef PERFILE_VARIABLE_BUCKETS
213	# ifdef KMK /* Move to Makefile.kmk? */
214	# define PERFILE_VARIABLE_BUCKETS 127
215	# else
216	#define PERFILE_VARIABLE_BUCKETS 23
217	# endif
218	#endif
219	#ifndef SMALL_SCOPE_VARIABLE_BUCKETS
220	# ifdef KMK /* Move to Makefile.kmk? */
221	# define SMALL_SCOPE_VARIABLE_BUCKETS 63
222	# else
223	#define SMALL_SCOPE_VARIABLE_BUCKETS 13
224	# endif
225	#endif
226	#ifndef ENVIRONMENT_VARIABLE_BUCKETS /* added by bird. */
227	# define ENVIRONMENT_VARIABLE_BUCKETS 256
228	#endif
229
230
231	#ifdef KMK /* Drop the 'static' */
232	struct variable_set global_variable_set;
233	struct variable_set_list global_setlist
234	#else
235	static struct variable_set global_variable_set;
236	static struct variable_set_list global_setlist
237	#endif
238	= { 0, &global_variable_set, 0 };
239	struct variable_set_list *current_variable_set_list = &global_setlist;
240
241
242	/* Implement variables. */
243
244	void
245	init_hash_global_variable_set (void)
246	{
247	#ifndef CONFIG_WITH_STRCACHE2
248	hash_init (&global_variable_set.table, VARIABLE_BUCKETS,
249	variable_hash_1, variable_hash_2, variable_hash_cmp);
250	#else /* CONFIG_WITH_STRCACHE2 */
251	strcache2_init (&variable_strcache, "variable", 65536, 0, 0, 0);
252	hash_init_strcached (&global_variable_set.table, VARIABLE_BUCKETS,
253	&variable_strcache, offsetof (struct variable, name));
254	#endif /* CONFIG_WITH_STRCACHE2 */
255	}
256
257	/* Define variable named NAME with value VALUE in SET. VALUE is copied.
258	LENGTH is the length of NAME, which does not need to be null-terminated.
259	ORIGIN specifies the origin of the variable (makefile, command line
260	or environment).
261	If RECURSIVE is nonzero a flag is set in the variable saying
262	that it should be recursively re-expanded. */
263
264	#ifdef CONFIG_WITH_VALUE_LENGTH
265	struct variable *
266	define_variable_in_set (const char *name, unsigned int length,
267	const char *value, unsigned int value_len,
268	int duplicate_value, enum variable_origin origin,
269	int recursive, struct variable_set *set,
270	const struct floc *flocp)
271	#else
272	struct variable *
273	define_variable_in_set (const char *name, unsigned int length,
274	const char *value, enum variable_origin origin,
275	int recursive, struct variable_set *set,
276	const struct floc *flocp)
277	#endif
278	{
279	struct variable *v;
280	struct variable **var_slot;
281	struct variable var_key;
282
283	#ifdef KMK
284	if (set == NULL \|\| set == &global_variable_set)
285	global_variable_generation++;
286	#endif
287
288	if (env_overrides && origin == o_env)
289	origin = o_env_override;
290
291	#ifndef KMK
292	if (set == NULL)
293	set = &global_variable_set;
294	#else /* KMK */
295	/* Intercept kBuild object variable definitions. */
296	if (name[0] == '[' && length > 3)
297	{
298	v = try_define_kbuild_object_variable_via_accessor (name, length,
299	value, value_len, duplicate_value,
300	origin, recursive, flocp);
301	if (v != VAR_NOT_KBUILD_ACCESSOR)
302	return v;
303	}
304	if (set == NULL)
305	{
306	if (g_pTopKbEvalData)
307	return define_kbuild_object_variable_in_top_obj (name, length,
308	value, value_len, duplicate_value,
309	origin, recursive, flocp);
310	set = &global_variable_set;
311	}
312	#endif /* KMK */
313
314	#ifndef CONFIG_WITH_STRCACHE2
315	var_key.name = (char *) name;
316	var_key.length = length;
317	var_slot = (struct variable **) hash_find_slot (&set->table, &var_key);
318
319	/* if (env_overrides && origin == o_env)
320	origin = o_env_override; - bird moved this up */
321
322	v = *var_slot;
323	#else /* CONFIG_WITH_STRCACHE2 */
324	name = strcache2_add (&variable_strcache, name, length);
325	if ( set != &global_variable_set
326	\|\| !(v = strcache2_get_user_val (&variable_strcache, name)))
327	{
328	var_key.name = name;
329	var_key.length = length;
330	var_slot = (struct variable **) hash_find_slot_strcached (&set->table, &var_key);
331	v = *var_slot;
332	}
333	else
334	{
335	assert (!v \|\| (v->name == name && !HASH_VACANT (v)));
336	var_slot = 0;
337	}
338	#endif /* CONFIG_WITH_STRCACHE2 */
339	if (! HASH_VACANT (v))
340	{
341	#ifdef KMK
342	RESOLVE_ALIAS_VARIABLE(v);
343	#endif
344	if (env_overrides && v->origin == o_env)
345	/* V came from in the environment. Since it was defined
346	before the switches were parsed, it wasn't affected by -e. */
347	v->origin = o_env_override;
348
349	/* A variable of this name is already defined.
350	If the old definition is from a stronger source
351	than this one, don't redefine it. */
352	if ((int) origin >= (int) v->origin)
353	{
354	#ifdef CONFIG_WITH_VALUE_LENGTH
355	if (value_len == ~0U)
356	value_len = strlen (value);
357	else
358	assert (value_len == strlen (value));
359	if (!duplicate_value \|\| duplicate_value == -1)
360	{
361	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
362	if (v->value != 0 && !v->rdonly_val)
363	free (v->value);
364	v->rdonly_val = duplicate_value == -1;
365	v->value = (char *) value;
366	v->value_alloc_len = 0;
367	# else
368	if (v->value != 0)
369	free (v->value);
370	v->value = (char *) value;
371	v->value_alloc_len = value_len + 1;
372	# endif
373	}
374	else
375	{
376	if (v->value_alloc_len <= value_len)
377	{
378	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
379	if (v->rdonly_val)
380	v->rdonly_val = 0;
381	else
382	# endif
383	free (v->value);
384	v->value_alloc_len = VAR_ALIGN_VALUE_ALLOC (value_len + 1);
385	v->value = xmalloc (v->value_alloc_len);
386	MAKE_STATS_2(v->reallocs++);
387	}
388	memcpy (v->value, value, value_len + 1);
389	}
390	v->value_length = value_len;
391	#else /* !CONFIG_WITH_VALUE_LENGTH */
392	if (v->value != 0)
393	free (v->value);
394	v->value = xstrdup (value);
395	#endif /* !CONFIG_WITH_VALUE_LENGTH */
396	if (flocp != 0)
397	v->fileinfo = *flocp;
398	else
399	v->fileinfo.filenm = 0;
400	v->origin = origin;
401	v->recursive = recursive;
402	VARIABLE_CHANGED (v);
403	}
404	return v;
405	}
406
407	/* Create a new variable definition and add it to the hash table. */
408
409	#ifndef CONFIG_WITH_ALLOC_CACHES
410	v = xmalloc (sizeof (struct variable));
411	#else
412	v = alloccache_alloc (&variable_cache);
413	#endif
414	#ifndef CONFIG_WITH_STRCACHE2
415	v->name = xstrndup (name, length);
416	#else
417	v->name = name; /* already cached. */
418	#endif
419	v->length = length;
420	hash_insert_at (&set->table, v, var_slot);
421	#ifdef CONFIG_WITH_VALUE_LENGTH
422	if (value_len == ~0U)
423	value_len = strlen (value);
424	else
425	assert (value_len == strlen (value));
426	v->value_length = value_len;
427	if (!duplicate_value \|\| duplicate_value == -1)
428	{
429	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
430	v->rdonly_val = duplicate_value == -1;
431	v->value_alloc_len = v->rdonly_val ? 0 : value_len + 1;
432	# endif
433	v->value = (char *)value;
434	}
435	else
436	{
437	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
438	v->rdonly_val = 0;
439	# endif
440	v->value_alloc_len = VAR_ALIGN_VALUE_ALLOC (value_len + 1);
441	v->value = xmalloc (v->value_alloc_len);
442	memcpy (v->value, value, value_len + 1);
443	}
444	#else /* !CONFIG_WITH_VALUE_LENGTH */
445	v->value = xstrdup (value);
446	#endif /* !CONFIG_WITH_VALUE_LENGTH */
447	if (flocp != 0)
448	v->fileinfo = *flocp;
449	else
450	v->fileinfo.filenm = 0;
451	v->origin = origin;
452	v->recursive = recursive;
453	v->special = 0;
454	v->expanding = 0;
455	v->exp_count = 0;
456	v->per_target = 0;
457	v->append = 0;
458	v->private_var = 0;
459	#ifdef KMK
460	v->alias = 0;
461	v->aliased = 0;
462	#endif
463	v->export = v_default;
464	#ifdef CONFIG_WITH_COMPILER
465	v->recursive_without_dollar = 0;
466	v->evalprog = 0;
467	v->expandprog = 0;
468	v->evalval_count = 0;
469	v->expand_count = 0;
470	#else
471	MAKE_STATS_2(v->expand_count = 0);
472	MAKE_STATS_2(v->evalval_count = 0);
473	#endif
474	MAKE_STATS_2(v->changes = 0);
475	MAKE_STATS_2(v->reallocs = 0);
476	MAKE_STATS_2(v->references = 0);
477	MAKE_STATS_2(v->cTicksEvalVal = 0);
478
479	v->exportable = 1;
480	if (name != '_' && (name < 'A' \|\| *name > 'Z')
481	&& (name < 'a' \|\| name > 'z'))
482	v->exportable = 0;
483	else
484	{
485	for (++name; *name != '\0'; ++name)
486	if (name != '_' && (name < 'a' \|\| *name > 'z')
487	&& (name < 'A' \|\| name > 'Z') && !ISDIGIT(*name))
488	break;
489
490	if (*name != '\0')
491	v->exportable = 0;
492	}
493
494	#ifdef CONFIG_WITH_STRCACHE2
495	/* If it's the global set, remember the variable. */
496	if (set == &global_variable_set)
497	strcache2_set_user_val (&variable_strcache, v->name, v);
498	#endif
499	return v;
500	}
501
502
503
504	/* Undefine variable named NAME in SET. LENGTH is the length of NAME, which
505	does not need to be null-terminated. ORIGIN specifies the origin of the
506	variable (makefile, command line or environment). */
507
508	static void
509	free_variable_name_and_value (const void *item);
510
511	void
512	undefine_variable_in_set (const char *name, unsigned int length,
513	enum variable_origin origin,
514	struct variable_set *set)
515	{
516	struct variable *v;
517	struct variable **var_slot;
518	struct variable var_key;
519
520	if (set == NULL)
521	set = &global_variable_set;
522
523	#ifndef CONFIG_WITH_STRCACHE2
524	var_key.name = (char *) name;
525	var_key.length = length;
526	var_slot = (struct variable **) hash_find_slot (&set->table, &var_key);
527	#else
528	var_key.name = strcache2_lookup(&variable_strcache, name, length);
529	if (!var_key.name)
530	return;
531	var_key.length = length;
532	var_slot = (struct variable **) hash_find_slot_strcached (&set->table, &var_key);
533	#endif
534	#ifdef KMK
535	if (set == &global_variable_set)
536	global_variable_generation++;
537	#endif
538
539	if (env_overrides && origin == o_env)
540	origin = o_env_override;
541
542	v = *var_slot;
543	if (! HASH_VACANT (v))
544	{
545	#ifdef KMK
546	if (v->aliased \|\| v->alias)
547	{
548	if (v->aliased)
549	error (NULL, _("Cannot undefine the aliased variable '%s'"), v->name);
550	else
551	error (NULL, _("Cannot undefine the variable alias '%s'"), v->name);
552	return;
553	}
554	#endif
555
556	if (env_overrides && v->origin == o_env)
557	/* V came from in the environment. Since it was defined
558	before the switches were parsed, it wasn't affected by -e. */
559	v->origin = o_env_override;
560
561	/* If the definition is from a stronger source than this one, don't
562	undefine it. */
563	if ((int) origin >= (int) v->origin)
564	{
565	hash_delete_at (&set->table, var_slot);
566	#ifdef CONFIG_WITH_STRCACHE2
567	if (set == &global_variable_set)
568	strcache2_set_user_val (&variable_strcache, v->name, NULL);
569	#endif
570	free_variable_name_and_value (v);
571	}
572	}
573	}
574
575	#ifdef KMK
576	/* Define variable named NAME as an alias of the variable TARGET.
577	SET defaults to the global set if NULL. FLOCP is just for completeness. */
578
579	struct variable *
580	define_variable_alias_in_set (const char *name, unsigned int length,
581	struct variable *target, enum variable_origin origin,
582	struct variable_set set, const struct floc flocp)
583	{
584	struct variable *v;
585	struct variable **var_slot;
586
587	#ifdef KMK
588	if (set == NULL \|\| set == &global_variable_set)
589	global_variable_generation++;
590	#endif
591
592	/* Look it up the hash table slot for it. */
593	name = strcache2_add (&variable_strcache, name, length);
594	if ( set != &global_variable_set
595	\|\| !(v = strcache2_get_user_val (&variable_strcache, name)))
596	{
597	struct variable var_key;
598
599	var_key.name = name;
600	var_key.length = length;
601	var_slot = (struct variable **) hash_find_slot_strcached (&set->table, &var_key);
602	v = *var_slot;
603	}
604	else
605	{
606	assert (!v \|\| (v->name == name && !HASH_VACANT (v)));
607	var_slot = 0;
608	}
609	if (! HASH_VACANT (v))
610	{
611	/* A variable of this name is already defined.
612	If the old definition is from a stronger source
613	than this one, don't redefine it. */
614
615	if (env_overrides && v->origin == o_env)
616	/* V came from in the environment. Since it was defined
617	before the switches were parsed, it wasn't affected by -e. */
618	v->origin = o_env_override;
619
620	if ((int) origin < (int) v->origin)
621	return v;
622
623	if (v->value != 0 && !v->rdonly_val)
624	free (v->value);
625	VARIABLE_CHANGED (v);
626	}
627	else
628	{
629	/* Create a new variable definition and add it to the hash table. */
630	v = alloccache_alloc (&variable_cache);
631	v->name = name; /* already cached. */
632	v->length = length;
633	hash_insert_at (&set->table, v, var_slot);
634	v->special = 0;
635	v->expanding = 0;
636	v->exp_count = 0;
637	v->per_target = 0;
638	v->append = 0;
639	v->private_var = 0;
640	v->aliased = 0;
641	v->export = v_default;
642	#ifdef CONFIG_WITH_COMPILER
643	v->recursive_without_dollar = 0;
644	v->evalprog = 0;
645	v->expandprog = 0;
646	v->evalval_count = 0;
647	v->expand_count = 0;
648	#else
649	MAKE_STATS_2(v->expand_count = 0);
650	MAKE_STATS_2(v->evalval_count = 0);
651	#endif
652	MAKE_STATS_2(v->changes = 0);
653	MAKE_STATS_2(v->reallocs = 0);
654	MAKE_STATS_2(v->references = 0);
655	MAKE_STATS_2(v->cTicksEvalVal = 0);
656	v->exportable = 1;
657	if (name != '_' && (name < 'A' \|\| *name > 'Z')
658	&& (name < 'a' \|\| name > 'z'))
659	v->exportable = 0;
660	else
661	{
662	for (++name; *name != '\0'; ++name)
663	if (name != '_' && (name < 'a' \|\| *name > 'z')
664	&& (name < 'A' \|\| name > 'Z') && !ISDIGIT(*name))
665	break;
666
667	if (*name != '\0')
668	v->exportable = 0;
669	}
670
671	/* If it's the global set, remember the variable. */
672	if (set == &global_variable_set)
673	strcache2_set_user_val (&variable_strcache, v->name, v);
674	}
675
676	/* Common variable setup. */
677	v->alias = 1;
678	v->rdonly_val = 1;
679	v->value = (char *)target;
680	v->value_length = sizeof(target); / Non-zero to provoke trouble. */
681	v->value_alloc_len = sizeof(*target);
682	if (flocp != 0)
683	v->fileinfo = *flocp;
684	else
685	v->fileinfo.filenm = 0;
686	v->origin = origin;
687	v->recursive = 0;
688
689	/* Mark the target as aliased. */
690	target->aliased = 1;
691
692	return v;
693	}
694	#endif /* KMK */
695
696	/* If the variable passed in is "special", handle its special nature.
697	Currently there are two such variables, both used for introspection:
698	.VARIABLES expands to a list of all the variables defined in this instance
699	of make.
700	.TARGETS expands to a list of all the targets defined in this
701	instance of make.
702	Returns the variable reference passed in. */
703
704	#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
705
706	static struct variable *
707	lookup_special_var (struct variable *var)
708	{
709	static unsigned long last_var_count = 0;
710
711
712	/* This one actually turns out to be very hard, due to the way the parser
713	records targets. The way it works is that target information is collected
714	internally until make knows the target is completely specified. It unitl
715	it sees that some new construct (a new target or variable) is defined that
716	it knows the previous one is done. In short, this means that if you do
717	this:
718
719	all:
720
721	TARGS := $(.TARGETS)
722
723	then $(TARGS) won't contain "all", because it's not until after the
724	variable is created that the previous target is completed.
725
726	Changing this would be a major pain. I think a less complex way to do it
727	would be to pre-define the target files as soon as the first line is
728	parsed, then come back and do the rest of the definition as now. That
729	would allow $(.TARGETS) to be correct without a major change to the way
730	the parser works.
731
732	if (streq (var->name, ".TARGETS"))
733	var->value = build_target_list (var->value);
734	else
735	*/
736
737	if (streq (var->name, ".VARIABLES")
738	&& global_variable_set.table.ht_fill != last_var_count)
739	{
740	#ifndef CONFIG_WITH_VALUE_LENGTH
741	unsigned long max = EXPANSION_INCREMENT (strlen (var->value));
742	#else
743	unsigned long max = EXPANSION_INCREMENT (var->value_length);
744	#endif
745	unsigned long len;
746	char *p;
747	struct variable vp = (struct variable ) global_variable_set.table.ht_vec;
748	struct variable **end = &vp[global_variable_set.table.ht_size];
749
750	/* Make sure we have at least MAX bytes in the allocated buffer. */
751	var->value = xrealloc (var->value, max);
752	MAKE_STATS_2(var->reallocs++);
753
754	/* Walk through the hash of variables, constructing a list of names. */
755	p = var->value;
756	len = 0;
757	for (; vp < end; ++vp)
758	if (!HASH_VACANT (*vp))
759	{
760	struct variable v = vp;
761	int l = v->length;
762
763	len += l + 1;
764	if (len > max)
765	{
766	unsigned long off = p - var->value;
767
768	max += EXPANSION_INCREMENT (l + 1);
769	var->value = xrealloc (var->value, max);
770	p = &var->value[off];
771	MAKE_STATS_2(var->reallocs++);
772	}
773
774	memcpy (p, v->name, l);
775	p += l;
776	*(p++) = ' ';
777	}
778	*(p-1) = '\0';
779	#ifdef CONFIG_WITH_VALUE_LENGTH
780	var->value_length = p - var->value - 1;
781	var->value_alloc_len = max;
782	#endif
783	VARIABLE_CHANGED (var);
784
785	/* Remember how many variables are in our current count. Since we never
786	remove variables from the list, this is a reliable way to know whether
787	the list is up to date or needs to be recomputed. */
788
789	last_var_count = global_variable_set.table.ht_fill;
790	}
791
792	return var;
793	}
794
795
796
797	#if 0 /FIX THIS - def KMK/ /* bird: speed */
798	MY_INLINE struct variable *
799	lookup_cached_variable (const char *name)
800	{
801	const struct variable_set_list *setlist = current_variable_set_list;
802	struct hash_table *ht;
803	unsigned int hash_1;
804	unsigned int hash_2;
805	unsigned int idx;
806	struct variable *v;
807
808	/* first set, first entry, both unrolled. */
809
810	if (setlist->set == &global_variable_set)
811	{
812	v = (struct variable *) strcache2_get_user_val (&variable_strcache, name);
813	if (MY_PREDICT_TRUE (v))
814	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
815	assert (setlist->next == 0);
816	return 0;
817	}
818
819	hash_1 = strcache2_calc_ptr_hash (&variable_strcache, name);
820	ht = &setlist->set->table;
821	MAKE_STATS (ht->ht_lookups++);
822	idx = hash_1 & (ht->ht_size - 1);
823	v = ht->ht_vec[idx];
824	if (v != 0)
825	{
826	if ( (void *)v != hash_deleted_item
827	&& v->name == name)
828	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
829
830	/* the rest of the loop */
831	hash_2 = strcache2_get_hash (&variable_strcache, name) \| 1;
832	for (;;)
833	{
834	idx += hash_2;
835	idx &= (ht->ht_size - 1);
836	v = (struct variable *) ht->ht_vec[idx];
837	MAKE_STATS (ht->ht_collisions++); /* there are hardly any deletions, so don't bother with not counting deleted clashes. */
838
839	if (v == 0)
840	break;
841	if ( (void *)v != hash_deleted_item
842	&& v->name == name)
843	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
844	} /* inner collision loop */
845	}
846	else
847	hash_2 = strcache2_get_hash (&variable_strcache, name) \| 1;
848
849
850	/* The other sets, if any. */
851
852	setlist = setlist->next;
853	while (setlist)
854	{
855	if (setlist->set == &global_variable_set)
856	{
857	v = (struct variable *) strcache2_get_user_val (&variable_strcache, name);
858	if (MY_PREDICT_TRUE (v))
859	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
860	assert (setlist->next == 0);
861	return 0;
862	}
863
864	/* first iteration unrolled */
865	ht = &setlist->set->table;
866	MAKE_STATS (ht->ht_lookups++);
867	idx = hash_1 & (ht->ht_size - 1);
868	v = ht->ht_vec[idx];
869	if (v != 0)
870	{
871	if ( (void *)v != hash_deleted_item
872	&& v->name == name)
873	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
874
875	/* the rest of the loop */
876	for (;;)
877	{
878	idx += hash_2;
879	idx &= (ht->ht_size - 1);
880	v = (struct variable *) ht->ht_vec[idx];
881	MAKE_STATS (ht->ht_collisions++); /* see reason above */
882
883	if (v == 0)
884	break;
885	if ( (void *)v != hash_deleted_item
886	&& v->name == name)
887	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
888	} /* inner collision loop */
889	}
890
891	/* next */
892	setlist = setlist->next;
893	}
894
895	return 0;
896	}
897
898	# ifndef NDEBUG
899	struct variable *
900	lookup_variable_for_assert (const char *name, unsigned int length)
901	{
902	const struct variable_set_list *setlist;
903	struct variable var_key;
904	var_key.name = name;
905	var_key.length = length;
906
907	for (setlist = current_variable_set_list;
908	setlist != 0; setlist = setlist->next)
909	{
910	struct variable *v;
911	v = (struct variable *) hash_find_item_strcached (&setlist->set->table, &var_key);
912	if (v)
913	return MY_PREDICT_FALSE (v->special) ? lookup_special_var (v) : v;
914	}
915	return 0;
916	}
917	# endif /* !NDEBUG */
918	#endif /* KMK - need for speed */
919
920	/* Lookup a variable whose name is a string starting at NAME
921	and with LENGTH chars. NAME need not be null-terminated.
922	Returns address of the `struct variable' containing all info
923	on the variable, or nil if no such variable is defined. */
924
925	struct variable *
926	lookup_variable (const char *name, unsigned int length)
927	{
928	#if 1 /FIX THIS - ndef KMK/
929	const struct variable_set_list *setlist;
930	struct variable var_key;
931	#else /* KMK */
932	struct variable *v;
933	#endif /* KMK */
934	int is_parent = 0;
935	#ifdef CONFIG_WITH_STRCACHE2
936	const char *cached_name;
937	#endif
938
939	# ifdef KMK
940	/* Check for kBuild-define- local variable accesses and handle these first. */
941	if (length > 3 && name[0] == '[')
942	{
943	struct variable *v = lookup_kbuild_object_variable_accessor(name, length);
944	if (v != VAR_NOT_KBUILD_ACCESSOR)
945	{
946	MAKE_STATS_2 (v->references++);
947	return v;
948	}
949	}
950	# endif
951
952	#ifdef CONFIG_WITH_STRCACHE2
953	/* lookup the name in the string case, if it's not there it won't
954	be in any of the sets either. */
955	cached_name = strcache2_lookup (&variable_strcache, name, length);
956	if (!cached_name)
957	return NULL;
958	name = cached_name;
959	#endif /* CONFIG_WITH_STRCACHE2 */
960	#if 1 /FIX THIS - ndef KMK /
961
962	var_key.name = (char *) name;
963	var_key.length = length;
964
965	for (setlist = current_variable_set_list;
966	setlist != 0; setlist = setlist->next)
967	{
968	const struct variable_set *set = setlist->set;
969	struct variable *v;
970
971	# ifndef CONFIG_WITH_STRCACHE2
972	v = (struct variable ) hash_find_item ((struct hash_table ) &set->table, &var_key);
973	# else /* CONFIG_WITH_STRCACHE2 */
974	v = (struct variable ) hash_find_item_strcached ((struct hash_table ) &set->table, &var_key);
975	# endif /* CONFIG_WITH_STRCACHE2 */
976	if (v && (!is_parent \|\| !v->private_var))
977	{
978	# ifdef KMK
979	RESOLVE_ALIAS_VARIABLE(v);
980	# endif
981	MAKE_STATS_2 (v->references++);
982	return v->special ? lookup_special_var (v) : v;
983	}
984
985	is_parent \|= setlist->next_is_parent;
986	}
987
988	#else /* KMK - need for speed */
989
990	v = lookup_cached_variable (name);
991	assert (lookup_variable_for_assert(name, length) == v);
992	#ifdef VMS
993	if (v)
994	#endif
995	return v;
996	#endif /* KMK - need for speed */
997	#ifdef VMS
998	/* since we don't read envp[] on startup, try to get the
999	variable via getenv() here. */
1000	{
1001	char *vname = alloca (length + 1);
1002	char *value;
1003	strncpy (vname, name, length);
1004	vname[length] = 0;
1005	value = getenv (vname);
1006	if (value != 0)
1007	{
1008	char *sptr;
1009	int scnt;
1010
1011	sptr = value;
1012	scnt = 0;
1013
1014	while ((sptr = strchr (sptr, '$')))
1015	{
1016	scnt++;
1017	sptr++;
1018	}
1019
1020	if (scnt > 0)
1021	{
1022	char *nvalue;
1023	char *nptr;
1024
1025	nvalue = alloca (strlen (value) + scnt + 1);
1026	sptr = value;
1027	nptr = nvalue;
1028
1029	while (*sptr)
1030	{
1031	if (*sptr == '$')
1032	{
1033	*nptr++ = '$';
1034	*nptr++ = '$';
1035	}
1036	else
1037	{
1038	nptr++ = sptr;
1039	}
1040	sptr++;
1041	}
1042
1043	*nptr = '\0';
1044	return define_variable (vname, length, nvalue, o_env, 1);
1045
1046	}
1047
1048	return define_variable (vname, length, value, o_env, 1);
1049	}
1050	}
1051	#endif /* VMS */
1052
1053	return 0;
1054	}
1055
1056	#ifdef CONFIG_WITH_STRCACHE2
1057	/* Alternative version of lookup_variable that takes a name that's already in
1058	the variable string cache. */
1059	struct variable *
1060	lookup_variable_strcached (const char *name)
1061	{
1062	struct variable *v;
1063	#if 1 /FIX THIS - ndef KMK/
1064	const struct variable_set_list *setlist;
1065	struct variable var_key;
1066	#endif /* KMK */
1067	int is_parent = 0;
1068
1069	#ifndef NDEBUG
1070	strcache2_verify_entry (&variable_strcache, name);
1071	#endif
1072
1073	#ifdef KMK
1074	/* Check for kBuild-define- local variable accesses and handle these first. */
1075	if (strcache2_get_len(&variable_strcache, name) > 3 && name[0] == '[')
1076	{
1077	v = lookup_kbuild_object_variable_accessor(name, strcache2_get_len(&variable_strcache, name));
1078	if (v != VAR_NOT_KBUILD_ACCESSOR)
1079	{
1080	MAKE_STATS_2 (v->references++);
1081	return v;
1082	}
1083	}
1084	#endif
1085
1086	#if 1 /FIX THIS - ndef KMK /
1087
1088	var_key.name = (char *) name;
1089	var_key.length = strcache2_get_len(&variable_strcache, name);
1090
1091	for (setlist = current_variable_set_list;
1092	setlist != 0; setlist = setlist->next)
1093	{
1094	const struct variable_set *set = setlist->set;
1095
1096	v = (struct variable ) hash_find_item_strcached ((struct hash_table ) &set->table, &var_key);
1097	if (v && (!is_parent \|\| !v->private_var))
1098	{
1099	# ifdef KMK
1100	RESOLVE_ALIAS_VARIABLE(v);
1101	# endif
1102	MAKE_STATS_2 (v->references++);
1103	return v->special ? lookup_special_var (v) : v;
1104	}
1105
1106	is_parent \|= setlist->next_is_parent;
1107	}
1108
1109	#else /* KMK - need for speed */
1110
1111	v = lookup_cached_variable (name);
1112	assert (lookup_variable_for_assert(name, length) == v);
1113	#ifdef VMS
1114	if (v)
1115	#endif
1116	return v;
1117	#endif /* KMK - need for speed */
1118	#ifdef VMS
1119	# error "Port me (split out the relevant code from lookup_varaible and call it)"
1120	#endif
1121	return 0;
1122	}
1123	#endif
1124
1125
1126
1127	/* Lookup a variable whose name is a string starting at NAME
1128	and with LENGTH chars in set SET. NAME need not be null-terminated.
1129	Returns address of the `struct variable' containing all info
1130	on the variable, or nil if no such variable is defined. */
1131
1132	struct variable *
1133	lookup_variable_in_set (const char *name, unsigned int length,
1134	const struct variable_set *set)
1135	{
1136	struct variable var_key;
1137	#ifndef CONFIG_WITH_STRCACHE2
1138	var_key.name = (char *) name;
1139	var_key.length = length;
1140
1141	return (struct variable ) hash_find_item ((struct hash_table ) &set->table, &var_key);
1142	#else /* CONFIG_WITH_STRCACHE2 */
1143	const char *cached_name;
1144	struct variable *v;
1145
1146	# ifdef KMK
1147	/* Check for kBuild-define- local variable accesses and handle these first. */
1148	if (length > 3 && name[0] == '[' && set == &global_variable_set)
1149	{
1150	v = lookup_kbuild_object_variable_accessor(name, length);
1151	if (v != VAR_NOT_KBUILD_ACCESSOR)
1152	{
1153	RESOLVE_ALIAS_VARIABLE(v);
1154	MAKE_STATS_2 (v->references++);
1155	return v;
1156	}
1157	}
1158	# endif
1159
1160	/* lookup the name in the string case, if it's not there it won't
1161	be in any of the sets either. Optimize lookups in the global set. */
1162	cached_name = strcache2_lookup(&variable_strcache, name, length);
1163	if (!cached_name)
1164	return NULL;
1165
1166	if (set == &global_variable_set)
1167	{
1168	v = strcache2_get_user_val (&variable_strcache, cached_name);
1169	assert (!v \|\| v->name == cached_name);
1170	}
1171	else
1172	{
1173	var_key.name = cached_name;
1174	var_key.length = length;
1175
1176	v = (struct variable *) hash_find_item_strcached (
1177	(struct hash_table *) &set->table, &var_key);
1178	}
1179	# ifdef KMK
1180	RESOLVE_ALIAS_VARIABLE(v);
1181	# endif
1182	MAKE_STATS_2 (if (v) v->references++);
1183	return v;
1184	#endif /* CONFIG_WITH_STRCACHE2 */
1185	}
1186
1187
1188	/* Initialize FILE's variable set list. If FILE already has a variable set
1189	list, the topmost variable set is left intact, but the the rest of the
1190	chain is replaced with FILE->parent's setlist. If FILE is a double-colon
1191	rule, then we will use the "root" double-colon target's variable set as the
1192	parent of FILE's variable set.
1193
1194	If we're READING a makefile, don't do the pattern variable search now,
1195	since the pattern variable might not have been defined yet. */
1196
1197	void
1198	initialize_file_variables (struct file *file, int reading)
1199	{
1200	struct variable_set_list *l = file->variables;
1201
1202	if (l == 0)
1203	{
1204	#ifndef CONFIG_WITH_ALLOC_CACHES
1205	l = (struct variable_set_list *)
1206	xmalloc (sizeof (struct variable_set_list));
1207	l->set = xmalloc (sizeof (struct variable_set));
1208	#else /* CONFIG_WITH_ALLOC_CACHES */
1209	l = (struct variable_set_list *)
1210	alloccache_alloc (&variable_set_list_cache);
1211	l->set = (struct variable_set *)
1212	alloccache_alloc (&variable_set_cache);
1213	#endif /* CONFIG_WITH_ALLOC_CACHES */
1214	#ifndef CONFIG_WITH_STRCACHE2
1215	hash_init (&l->set->table, PERFILE_VARIABLE_BUCKETS,
1216	variable_hash_1, variable_hash_2, variable_hash_cmp);
1217	#else /* CONFIG_WITH_STRCACHE2 */
1218	hash_init_strcached (&l->set->table, PERFILE_VARIABLE_BUCKETS,
1219	&variable_strcache, offsetof (struct variable, name));
1220	#endif /* CONFIG_WITH_STRCACHE2 */
1221	file->variables = l;
1222	}
1223
1224	/* If this is a double-colon, then our "parent" is the "root" target for
1225	this double-colon rule. Since that rule has the same name, parent,
1226	etc. we can just use its variables as the "next" for ours. */
1227
1228	if (file->double_colon && file->double_colon != file)
1229	{
1230	initialize_file_variables (file->double_colon, reading);
1231	l->next = file->double_colon->variables;
1232	l->next_is_parent = 0;
1233	return;
1234	}
1235
1236	if (file->parent == 0)
1237	l->next = &global_setlist;
1238	else
1239	{
1240	initialize_file_variables (file->parent, reading);
1241	l->next = file->parent->variables;
1242	}
1243	l->next_is_parent = 1;
1244
1245	/* If we're not reading makefiles and we haven't looked yet, see if
1246	we can find pattern variables for this target. */
1247
1248	if (!reading && !file->pat_searched)
1249	{
1250	struct pattern_var *p;
1251
1252	p = lookup_pattern_var (0, file->name);
1253	if (p != 0)
1254	{
1255	struct variable_set_list *global = current_variable_set_list;
1256
1257	/* We found at least one. Set up a new variable set to accumulate
1258	all the pattern variables that match this target. */
1259
1260	file->pat_variables = create_new_variable_set ();
1261	current_variable_set_list = file->pat_variables;
1262
1263	do
1264	{
1265	/* We found one, so insert it into the set. */
1266
1267	struct variable *v;
1268
1269	if (p->variable.flavor == f_simple)
1270	{
1271	v = define_variable_loc (
1272	p->variable.name, strlen (p->variable.name),
1273	p->variable.value, p->variable.origin,
1274	0, &p->variable.fileinfo);
1275
1276	v->flavor = f_simple;
1277	}
1278	else
1279	{
1280	#ifndef CONFIG_WITH_VALUE_LENGTH
1281	v = do_variable_definition (
1282	&p->variable.fileinfo, p->variable.name,
1283	p->variable.value, p->variable.origin,
1284	p->variable.flavor, 1);
1285	#else
1286	v = do_variable_definition_2 (
1287	&p->variable.fileinfo, p->variable.name,
1288	p->variable.value, p->variable.value_length, 0, 0,
1289	p->variable.origin, p->variable.flavor, 1);
1290	#endif
1291	}
1292
1293	/* Also mark it as a per-target and copy export status. */
1294	v->per_target = p->variable.per_target;
1295	v->export = p->variable.export;
1296	v->private_var = p->variable.private_var;
1297	}
1298	while ((p = lookup_pattern_var (p, file->name)) != 0);
1299
1300	current_variable_set_list = global;
1301	}
1302	file->pat_searched = 1;
1303	}
1304
1305	/* If we have a pattern variable match, set it up. */
1306
1307	if (file->pat_variables != 0)
1308	{
1309	file->pat_variables->next = l->next;
1310	file->pat_variables->next_is_parent = l->next_is_parent;
1311	l->next = file->pat_variables;
1312	l->next_is_parent = 0;
1313	}
1314	}
1315
1316
1317	/* Pop the top set off the current variable set list,
1318	and free all its storage. */
1319
1320	struct variable_set_list *
1321	create_new_variable_set (void)
1322	{
1323	register struct variable_set_list *setlist;
1324	register struct variable_set *set;
1325
1326	#ifndef CONFIG_WITH_ALLOC_CACHES
1327	set = xmalloc (sizeof (struct variable_set));
1328	#else
1329	set = (struct variable_set *) alloccache_alloc (&variable_set_cache);
1330	#endif
1331	#ifndef CONFIG_WITH_STRCACHE2
1332	hash_init (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
1333	variable_hash_1, variable_hash_2, variable_hash_cmp);
1334	#else /* CONFIG_WITH_STRCACHE2 */
1335	hash_init_strcached (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
1336	&variable_strcache, offsetof (struct variable, name));
1337	#endif /* CONFIG_WITH_STRCACHE2 */
1338
1339	#ifndef CONFIG_WITH_ALLOC_CACHES
1340	setlist = (struct variable_set_list *)
1341	xmalloc (sizeof (struct variable_set_list));
1342	#else
1343	setlist = (struct variable_set_list *)
1344	alloccache_alloc (&variable_set_list_cache);
1345	#endif
1346	setlist->set = set;
1347	setlist->next = current_variable_set_list;
1348	setlist->next_is_parent = 0;
1349
1350	return setlist;
1351	}
1352
1353	static void
1354	free_variable_name_and_value (const void *item)
1355	{
1356	struct variable v = (struct variable ) item;
1357	#ifndef CONFIG_WITH_STRCACHE2
1358	free (v->name);
1359	#endif
1360	#ifdef CONFIG_WITH_COMPILER
1361	if (v->evalprog \|\| v->expandprog)
1362	kmk_cc_variable_deleted (v);
1363	#endif
1364	#ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
1365	if (!v->rdonly_val)
1366	#endif
1367	free (v->value);
1368	}
1369
1370	void
1371	free_variable_set (struct variable_set_list *list)
1372	{
1373	hash_map (&list->set->table, free_variable_name_and_value);
1374	#ifndef CONFIG_WITH_ALLOC_CACHES
1375	hash_free (&list->set->table, 1);
1376	free (list->set);
1377	free (list);
1378	#else
1379	hash_free_cached (&list->set->table, 1, &variable_cache);
1380	alloccache_free (&variable_set_cache, list->set);
1381	alloccache_free (&variable_set_list_cache, list);
1382	#endif
1383	}
1384
1385	/* Create a new variable set and push it on the current setlist.
1386	If we're pushing a global scope (that is, the current scope is the global
1387	scope) then we need to "push" it the other way: file variable sets point
1388	directly to the global_setlist so we need to replace that with the new one.
1389	*/
1390
1391	struct variable_set_list *
1392	push_new_variable_scope (void)
1393	{
1394	current_variable_set_list = create_new_variable_set();
1395	if (current_variable_set_list->next == &global_setlist)
1396	{
1397	/* It was the global, so instead of new -> &global we want to replace
1398	&global with the new one and have &global -> new, with current still
1399	pointing to &global */
1400	struct variable_set *set = current_variable_set_list->set;
1401	current_variable_set_list->set = global_setlist.set;
1402	global_setlist.set = set;
1403	current_variable_set_list->next = global_setlist.next;
1404	global_setlist.next = current_variable_set_list;
1405	current_variable_set_list = &global_setlist;
1406	}
1407	return (current_variable_set_list);
1408	}
1409
1410	void
1411	pop_variable_scope (void)
1412	{
1413	struct variable_set_list *setlist;
1414	struct variable_set *set;
1415
1416	/* Can't call this if there's no scope to pop! */
1417	assert(current_variable_set_list->next != NULL);
1418
1419	if (current_variable_set_list != &global_setlist)
1420	{
1421	/* We're not pointing to the global setlist, so pop this one. */
1422	setlist = current_variable_set_list;
1423	set = setlist->set;
1424	current_variable_set_list = setlist->next;
1425	}
1426	else
1427	{
1428	/* This set is the one in the global_setlist, but there is another global
1429	set beyond that. We want to copy that set to global_setlist, then
1430	delete what used to be in global_setlist. */
1431	setlist = global_setlist.next;
1432	set = global_setlist.set;
1433	global_setlist.set = setlist->set;
1434	global_setlist.next = setlist->next;
1435	global_setlist.next_is_parent = setlist->next_is_parent;
1436	}
1437
1438	/* Free the one we no longer need. */
1439	#ifndef CONFIG_WITH_ALLOC_CACHES
1440	free (setlist);
1441	hash_map (&set->table, free_variable_name_and_value);
1442	hash_free (&set->table, 1);
1443	free (set);
1444	#else
1445	alloccache_free (&variable_set_list_cache, setlist);
1446	hash_map (&set->table, free_variable_name_and_value);
1447	hash_free_cached (&set->table, 1, &variable_cache);
1448	alloccache_free (&variable_set_cache, set);
1449	#endif
1450	}
1451
1452
1453	/* Merge FROM_SET into TO_SET, freeing unused storage in FROM_SET. */
1454
1455	static void
1456	merge_variable_sets (struct variable_set *to_set,
1457	struct variable_set *from_set)
1458	{
1459	struct variable from_var_slot = (struct variable ) from_set->table.ht_vec;
1460	struct variable **from_var_end = from_var_slot + from_set->table.ht_size;
1461
1462	for ( ; from_var_slot < from_var_end; from_var_slot++)
1463	if (! HASH_VACANT (*from_var_slot))
1464	{
1465	struct variable from_var = from_var_slot;
1466	struct variable **to_var_slot
1467	#ifndef CONFIG_WITH_STRCACHE2
1468	= (struct variable *) hash_find_slot (&to_set->table, from_var_slot);
1469	#else /* CONFIG_WITH_STRCACHE2 */
1470	= (struct variable **) hash_find_slot_strcached (&to_set->table,
1471	*from_var_slot);
1472	#endif /* CONFIG_WITH_STRCACHE2 */
1473	if (HASH_VACANT (*to_var_slot))
1474	hash_insert_at (&to_set->table, from_var, to_var_slot);
1475	else
1476	{
1477	/* GKM FIXME: delete in from_set->table */
1478	#ifdef KMK
1479	if (from_var->aliased)
1480	fatal(NULL, ("Attempting to delete aliased variable '%s'"), from_var->name);
1481	if (from_var->alias)
1482	fatal(NULL, ("Attempting to delete variable aliased '%s'"), from_var->name);
1483	#endif
1484	#ifdef CONFIG_WITH_COMPILER
1485	if (from_var->evalprog \|\| from_var->expandprog)
1486	kmk_cc_variable_deleted (from_var);
1487	#endif
1488	#ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
1489	if (!from_var->rdonly_val)
1490	#endif
1491	free (from_var->value);
1492	free (from_var);
1493	}
1494	}
1495	}
1496
1497	/* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */
1498
1499	void
1500	merge_variable_set_lists (struct variable_set_list **setlist0,
1501	struct variable_set_list *setlist1)
1502	{
1503	struct variable_set_list to = setlist0;
1504	struct variable_set_list *last0 = 0;
1505
1506	/* If there's nothing to merge, stop now. */
1507	if (!setlist1)
1508	return;
1509
1510	/* This loop relies on the fact that all setlists terminate with the global
1511	setlist (before NULL). If that's not true, arguably we SHOULD die. */
1512	if (to)
1513	while (setlist1 != &global_setlist && to != &global_setlist)
1514	{
1515	struct variable_set_list *from = setlist1;
1516	setlist1 = setlist1->next;
1517
1518	merge_variable_sets (to->set, from->set);
1519
1520	last0 = to;
1521	to = to->next;
1522	}
1523
1524	if (setlist1 != &global_setlist)
1525	{
1526	if (last0 == 0)
1527	*setlist0 = setlist1;
1528	else
1529	last0->next = setlist1;
1530	}
1531	}
1532
1533
1534	#if defined(KMK) && !defined(WINDOWS32)
1535	/* Parses out the next number from the uname release level string. Fast
1536	forwards to the end of the string when encountering some non-conforming
1537	chars. */
1538
1539	static unsigned long parse_release_number (const char **ppsz)
1540	{
1541	unsigned long ul;
1542	char psz = (char )*ppsz;
1543	if (ISDIGIT (*psz))
1544	{
1545	ul = strtoul (psz, &psz, 10);
1546	if (psz != NULL && *psz == '.')
1547	psz++;
1548	else
1549	psz = strchr (*ppsz, '\0');
1550	*ppsz = psz;
1551	}
1552	else
1553	ul = 0;
1554	return ul;
1555	}
1556	#endif
1557
1558
1559	/* Define the automatic variables, and record the addresses
1560	of their structures so we can change their values quickly. */
1561
1562	void
1563	define_automatic_variables (void)
1564	{
1565	#if defined(WINDOWS32) \|\| defined(__EMX__)
1566	extern char* default_shell;
1567	#else
1568	extern char default_shell[];
1569	#endif
1570	register struct variable *v;
1571	#ifndef KMK
1572	char buf[200];
1573	#else
1574	char buf[1024];
1575	const char *val;
1576	struct variable *envvar1;
1577	struct variable *envvar2;
1578	# ifdef WINDOWS32
1579	OSVERSIONINFOEX oix;
1580	# else
1581	struct utsname uts;
1582	# endif
1583	unsigned long ulMajor = 0, ulMinor = 0, ulPatch = 0, ul4th = 0;
1584	#endif
1585
1586	sprintf (buf, "%u", makelevel);
1587	define_variable_cname (MAKELEVEL_NAME, buf, o_env, 0);
1588
1589	sprintf (buf, "%s%s%s",
1590	version_string,
1591	(remote_description == 0 \|\| remote_description[0] == '\0')
1592	? "" : "-",
1593	(remote_description == 0 \|\| remote_description[0] == '\0')
1594	? "" : remote_description);
1595	#ifndef KMK
1596	define_variable_cname ("MAKE_VERSION", buf, o_default, 0);
1597	#else /* KMK */
1598
1599	/* Define KMK_VERSION to indicate kMk. */
1600	define_variable_cname ("KMK_VERSION", buf, o_default, 0);
1601
1602	/* Define KBUILD_VERSION* */
1603	sprintf (buf, "%d", KBUILD_VERSION_MAJOR);
1604	define_variable_cname ("KBUILD_VERSION_MAJOR", buf, o_default, 0);
1605	sprintf (buf, "%d", KBUILD_VERSION_MINOR);
1606	define_variable_cname ("KBUILD_VERSION_MINOR", buf, o_default, 0);
1607	sprintf (buf, "%d", KBUILD_VERSION_PATCH);
1608	define_variable_cname ("KBUILD_VERSION_PATCH", buf, o_default, 0);
1609	sprintf (buf, "%d", KBUILD_SVN_REV);
1610	define_variable_cname ("KBUILD_KMK_REVISION", buf, o_default, 0);
1611
1612	sprintf (buf, "%d.%d.%d-r%d", KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR,
1613	KBUILD_VERSION_PATCH, KBUILD_SVN_REV);
1614	define_variable_cname ("KBUILD_VERSION", buf, o_default, 0);
1615
1616	/* The host defaults. The BUILD_* stuff will be replaced by KBUILD_* soon. */
1617	envvar1 = lookup_variable (STRING_SIZE_TUPLE ("KBUILD_HOST"));
1618	envvar2 = lookup_variable (STRING_SIZE_TUPLE ("BUILD_PLATFORM"));
1619	val = envvar1 ? envvar1->value : envvar2 ? envvar2->value : KBUILD_HOST;
1620	if (envvar1 && envvar2 && strcmp (envvar1->value, envvar2->value))
1621	error (NULL, _("KBUILD_HOST and BUILD_PLATFORM differs, using KBUILD_HOST=%s."), val);
1622	if (!envvar1)
1623	define_variable_cname ("KBUILD_HOST", val, o_default, 0);
1624	if (!envvar2)
1625	define_variable_cname ("BUILD_PLATFORM", val, o_default, 0);
1626
1627	envvar1 = lookup_variable (STRING_SIZE_TUPLE ("KBUILD_HOST_ARCH"));
1628	envvar2 = lookup_variable (STRING_SIZE_TUPLE ("BUILD_PLATFORM_ARCH"));
1629	val = envvar1 ? envvar1->value : envvar2 ? envvar2->value : KBUILD_HOST_ARCH;
1630	if (envvar1 && envvar2 && strcmp (envvar1->value, envvar2->value))
1631	error (NULL, _("KBUILD_HOST_ARCH and BUILD_PLATFORM_ARCH differs, using KBUILD_HOST_ARCH=%s."), val);
1632	if (!envvar1)
1633	define_variable_cname ("KBUILD_HOST_ARCH", val, o_default, 0);
1634	if (!envvar2)
1635	define_variable_cname ("BUILD_PLATFORM_ARCH", val, o_default, 0);
1636
1637	envvar1 = lookup_variable (STRING_SIZE_TUPLE ("KBUILD_HOST_CPU"));
1638	envvar2 = lookup_variable (STRING_SIZE_TUPLE ("BUILD_PLATFORM_CPU"));
1639	val = envvar1 ? envvar1->value : envvar2 ? envvar2->value : KBUILD_HOST_CPU;
1640	if (envvar1 && envvar2 && strcmp (envvar1->value, envvar2->value))
1641	error (NULL, _("KBUILD_HOST_CPU and BUILD_PLATFORM_CPU differs, using KBUILD_HOST_CPU=%s."), val);
1642	if (!envvar1)
1643	define_variable_cname ("KBUILD_HOST_CPU", val, o_default, 0);
1644	if (!envvar2)
1645	define_variable_cname ("BUILD_PLATFORM_CPU", val, o_default, 0);
1646
1647	/* The host kernel version. */
1648	#if defined(WINDOWS32)
1649	memset (&oix, '\0', sizeof (oix));
1650	oix.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1651	if (!GetVersionEx ((LPOSVERSIONINFO)&oix))
1652	{
1653	memset (&oix, '\0', sizeof (oix));
1654	oix.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
1655	GetVersionEx ((LPOSVERSIONINFO)&oix);
1656	}
1657	if (oix.dwPlatformId == VER_PLATFORM_WIN32_NT)
1658	{
1659	ulMajor = oix.dwMajorVersion;
1660	ulMinor = oix.dwMinorVersion;
1661	ulPatch = oix.wServicePackMajor;
1662	ul4th = oix.wServicePackMinor;
1663	}
1664	else
1665	{
1666	ulMajor = oix.dwPlatformId == 1 ? 0 /Win95/98/ME/
1667	: oix.dwPlatformId == 3 ? 1 /WinCE/
1668	: 2; /??/
1669	ulMinor = oix.dwMajorVersion;
1670	ulPatch = oix.dwMinorVersion;
1671	ul4th = oix.wServicePackMajor;
1672	}
1673	#else
1674	memset (&uts, 0, sizeof(uts));
1675	uname (&uts);
1676	val = uts.release;
1677	ulMajor = parse_release_number (&val);
1678	ulMinor = parse_release_number (&val);
1679	ulPatch = parse_release_number (&val);
1680	ul4th = parse_release_number (&val);
1681	#endif
1682
1683	sprintf (buf, "%lu.%lu.%lu.%lu", ulMajor, ulMinor, ulPatch, ul4th);
1684	define_variable_cname ("KBUILD_HOST_VERSION", buf, o_default, 0);
1685
1686	sprintf (buf, "%lu", ulMajor);
1687	define_variable_cname ("KBUILD_HOST_VERSION_MAJOR", buf, o_default, 0);
1688
1689	sprintf (buf, "%lu", ulMinor);
1690	define_variable_cname ("KBUILD_HOST_VERSION_MINOR", buf, o_default, 0);
1691
1692	sprintf (buf, "%lu", ulPatch);
1693	define_variable_cname ("KBUILD_HOST_VERSION_PATCH", buf, o_default, 0);
1694
1695	/* The kBuild locations. */
1696	define_variable_cname ("KBUILD_PATH", get_kbuild_path (), o_default, 0);
1697	define_variable_cname ("KBUILD_BIN_PATH", get_kbuild_bin_path (), o_default, 0);
1698
1699	define_variable_cname ("PATH_KBUILD", get_kbuild_path (), o_default, 0);
1700	define_variable_cname ("PATH_KBUILD_BIN", get_kbuild_bin_path (), o_default, 0);
1701
1702	/* Define KMK_FEATURES to indicate various working KMK features. */
1703	# if defined (CONFIG_WITH_RSORT) \
1704	&& defined (CONFIG_WITH_ABSPATHEX) \
1705	&& defined (CONFIG_WITH_TOUPPER_TOLOWER) \
1706	&& defined (CONFIG_WITH_DEFINED) \
1707	&& defined (CONFIG_WITH_VALUE_LENGTH) \
1708	&& defined (CONFIG_WITH_COMPARE) \
1709	&& defined (CONFIG_WITH_STACK) \
1710	&& defined (CONFIG_WITH_MATH) \
1711	&& defined (CONFIG_WITH_XARGS) \
1712	&& defined (CONFIG_WITH_EXPLICIT_MULTITARGET) \
1713	&& defined (CONFIG_WITH_DOT_MUST_MAKE) \
1714	&& defined (CONFIG_WITH_PREPEND_ASSIGNMENT) \
1715	&& defined (CONFIG_WITH_SET_CONDITIONALS) \
1716	&& defined (CONFIG_WITH_DATE) \
1717	&& defined (CONFIG_WITH_FILE_SIZE) \
1718	&& defined (CONFIG_WITH_WHERE_FUNCTION) \
1719	&& defined (CONFIG_WITH_WHICH) \
1720	&& defined (CONFIG_WITH_EVALPLUS) \
1721	&& (defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)) \
1722	&& defined (CONFIG_WITH_COMMANDS_FUNC) \
1723	&& defined (CONFIG_WITH_PRINTF) \
1724	&& defined (CONFIG_WITH_LOOP_FUNCTIONS) \
1725	&& defined (CONFIG_WITH_ROOT_FUNC) \
1726	&& defined (CONFIG_WITH_STRING_FUNCTIONS) \
1727	&& defined (CONFIG_WITH_DEFINED_FUNCTIONS) \
1728	&& defined (KMK_HELPERS)
1729	define_variable_cname ("KMK_FEATURES",
1730	"append-dash-n abspath includedep-queue install-hard-linking umask"
1731	" kBuild-define"
1732	" rsort"
1733	" abspathex"
1734	" toupper tolower"
1735	" defined"
1736	" comp-vars comp-cmds comp-cmds-ex"
1737	" stack"
1738	" math-int"
1739	" xargs"
1740	" explicit-multitarget"
1741	" dot-must-make"
1742	" prepend-assignment"
1743	" set-conditionals intersects"
1744	" date"
1745	" file-size"
1746	" expr if-expr select"
1747	" where"
1748	" which"
1749	" evalctx evalval evalvalctx evalcall evalcall2 eval-opt-var"
1750	" make-stats"
1751	" commands"
1752	" printf"
1753	" for while"
1754	" root"
1755	" length insert pos lastpos substr translate"
1756	" kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one kb-exp-tmpl"
1757	" firstdefined lastdefined"
1758	, o_default, 0);
1759	# else /* MSC can't deal with strings mixed with #if/#endif, thus the slow way. */
1760	# error "All features should be enabled by default!"
1761	strcpy (buf, "append-dash-n abspath includedep-queue install-hard-linking umask"
1762	" kBuild-define");
1763	# if defined (CONFIG_WITH_RSORT)
1764	strcat (buf, " rsort");
1765	# endif
1766	# if defined (CONFIG_WITH_ABSPATHEX)
1767	strcat (buf, " abspathex");
1768	# endif
1769	# if defined (CONFIG_WITH_TOUPPER_TOLOWER)
1770	strcat (buf, " toupper tolower");
1771	# endif
1772	# if defined (CONFIG_WITH_DEFINED)
1773	strcat (buf, " defined");
1774	# endif
1775	# if defined (CONFIG_WITH_VALUE_LENGTH) && defined(CONFIG_WITH_COMPARE)
1776	strcat (buf, " comp-vars comp-cmds comp-cmds-ex");
1777	# endif
1778	# if defined (CONFIG_WITH_STACK)
1779	strcat (buf, " stack");
1780	# endif
1781	# if defined (CONFIG_WITH_MATH)
1782	strcat (buf, " math-int");
1783	# endif
1784	# if defined (CONFIG_WITH_XARGS)
1785	strcat (buf, " xargs");
1786	# endif
1787	# if defined (CONFIG_WITH_EXPLICIT_MULTITARGET)
1788	strcat (buf, " explicit-multitarget");
1789	# endif
1790	# if defined (CONFIG_WITH_DOT_MUST_MAKE)
1791	strcat (buf, " dot-must-make");
1792	# endif
1793	# if defined (CONFIG_WITH_PREPEND_ASSIGNMENT)
1794	strcat (buf, " prepend-assignment");
1795	# endif
1796	# if defined (CONFIG_WITH_SET_CONDITIONALS)
1797	strcat (buf, " set-conditionals intersects");
1798	# endif
1799	# if defined (CONFIG_WITH_DATE)
1800	strcat (buf, " date");
1801	# endif
1802	# if defined (CONFIG_WITH_FILE_SIZE)
1803	strcat (buf, " file-size");
1804	# endif
1805	# if defined (CONFIG_WITH_IF_CONDITIONALS)
1806	strcat (buf, " expr if-expr select");
1807	# endif
1808	# if defined (CONFIG_WITH_WHERE_FUNCTION)
1809	strcat (buf, " where");
1810	# endif
1811	# if defined (CONFIG_WITH_WHICH)
1812	strcat (buf, " which");
1813	# endif
1814	# if defined (CONFIG_WITH_EVALPLUS)
1815	strcat (buf, " evalctx evalval evalvalctx evalcall evalcall2 eval-opt-var");
1816	# endif
1817	# if defined (CONFIG_WITH_MAKE_STATS) \|\| defined (CONFIG_WITH_MINIMAL_STATS)
1818	strcat (buf, " make-stats");
1819	# endif
1820	# if defined (CONFIG_WITH_COMMANDS_FUNC)
1821	strcat (buf, " commands");
1822	# endif
1823	# if defined (CONFIG_WITH_PRINTF)
1824	strcat (buf, " printf");
1825	# endif
1826	# if defined (CONFIG_WITH_LOOP_FUNCTIONS)
1827	strcat (buf, " for while");
1828	# endif
1829	# if defined (CONFIG_WITH_ROOT_FUNC)
1830	strcat (buf, " root");
1831	# endif
1832	# if defined (CONFIG_WITH_STRING_FUNCTIONS)
1833	strcat (buf, " length insert pos lastpos substr translate");
1834	# endif
1835	# if defined (CONFIG_WITH_DEFINED_FUNCTIONS)
1836	strcat (buf, " firstdefined lastdefined");
1837	# endif
1838	# if defined (KMK_HELPERS)
1839	strcat (buf, " kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one kb-exp-tmpl");
1840	# endif
1841	define_variable_cname ("KMK_FEATURES", buf, o_default, 0);
1842	# endif
1843
1844	#endif /* KMK */
1845
1846	#ifdef CONFIG_WITH_KMK_BUILTIN
1847	/* The supported kMk Builtin commands. */
1848	define_variable_cname ("KMK_BUILTIN", "append cat chmod cp cmp echo expr install kDepIDB ln md5sum mkdir mv printf rm rmdir sleep test", o_default, 0);
1849	#endif
1850
1851	#ifdef __MSDOS__
1852	/* Allow to specify a special shell just for Make,
1853	and use $COMSPEC as the default $SHELL when appropriate. */
1854	{
1855	static char shell_str[] = "SHELL";
1856	const int shlen = sizeof (shell_str) - 1;
1857	struct variable *mshp = lookup_variable ("MAKESHELL", 9);
1858	struct variable *comp = lookup_variable ("COMSPEC", 7);
1859
1860	/* $(MAKESHELL) overrides $(SHELL) even if -e is in effect. */
1861	if (mshp)
1862	(void) define_variable (shell_str, shlen,
1863	mshp->value, o_env_override, 0);
1864	else if (comp)
1865	{
1866	/* $(COMSPEC) shouldn't override $(SHELL). */
1867	struct variable *shp = lookup_variable (shell_str, shlen);
1868
1869	if (!shp)
1870	(void) define_variable (shell_str, shlen, comp->value, o_env, 0);
1871	}
1872	}
1873	#elif defined(__EMX__)
1874	{
1875	static char shell_str[] = "SHELL";
1876	const int shlen = sizeof (shell_str) - 1;
1877	struct variable *shell = lookup_variable (shell_str, shlen);
1878	struct variable *replace = lookup_variable ("MAKESHELL", 9);
1879
1880	/* if $MAKESHELL is defined in the environment assume o_env_override */
1881	if (replace && *replace->value && replace->origin == o_env)
1882	replace->origin = o_env_override;
1883
1884	/* if $MAKESHELL is not defined use $SHELL but only if the variable
1885	did not come from the environment */
1886	if (!replace \|\| !*replace->value)
1887	if (shell && *shell->value && (shell->origin == o_env
1888	\|\| shell->origin == o_env_override))
1889	{
1890	/* overwrite whatever we got from the environment */
1891	free(shell->value);
1892	shell->value = xstrdup (default_shell);
1893	shell->origin = o_default;
1894	}
1895
1896	/* Some people do not like cmd to be used as the default
1897	if $SHELL is not defined in the Makefile.
1898	With -DNO_CMD_DEFAULT you can turn off this behaviour */
1899	# ifndef NO_CMD_DEFAULT
1900	/* otherwise use $COMSPEC */
1901	if (!replace \|\| !*replace->value)
1902	replace = lookup_variable ("COMSPEC", 7);
1903
1904	/* otherwise use $OS2_SHELL */
1905	if (!replace \|\| !*replace->value)
1906	replace = lookup_variable ("OS2_SHELL", 9);
1907	# else
1908	# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
1909	# endif
1910
1911	if (replace && *replace->value)
1912	/* overwrite $SHELL */
1913	(void) define_variable (shell_str, shlen, replace->value,
1914	replace->origin, 0);
1915	else
1916	/* provide a definition if there is none */
1917	(void) define_variable (shell_str, shlen, default_shell,
1918	o_default, 0);
1919	}
1920
1921	#endif
1922
1923	/* This won't override any definition, but it will provide one if there
1924	isn't one there. */
1925	v = define_variable_cname ("SHELL", default_shell, o_default, 0);
1926	#ifdef __MSDOS__
1927	v->export = v_export; /* Export always SHELL. */
1928	#endif
1929
1930	/* On MSDOS we do use SHELL from environment, since it isn't a standard
1931	environment variable on MSDOS, so whoever sets it, does that on purpose.
1932	On OS/2 we do not use SHELL from environment but we have already handled
1933	that problem above. */
1934	#if !defined(__MSDOS__) && !defined(__EMX__)
1935	/* Don't let SHELL come from the environment. */
1936	if (*v->value == '\0' \|\| v->origin == o_env \|\| v->origin == o_env_override)
1937	{
1938	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
1939	if (v->rdonly_val)
1940	v->rdonly_val = 0;
1941	else
1942	# endif
1943	free (v->value);
1944	v->origin = o_file;
1945	v->value = xstrdup (default_shell);
1946	# ifdef CONFIG_WITH_VALUE_LENGTH
1947	v->value_length = strlen (v->value);
1948	v->value_alloc_len = v->value_length + 1;
1949	# endif
1950	}
1951	#endif
1952
1953	/* Make sure MAKEFILES gets exported if it is set. */
1954	v = define_variable_cname ("MAKEFILES", "", o_default, 0);
1955	v->export = v_ifset;
1956
1957	/* Define the magic D and F variables in terms of
1958	the automatic variables they are variations of. */
1959
1960	#ifdef VMS
1961	define_variable_cname ("@D", "$(dir $@)", o_automatic, 1);
1962	define_variable_cname ("%D", "$(dir $%)", o_automatic, 1);
1963	define_variable_cname ("D", "$(dir $)", o_automatic, 1);
1964	define_variable_cname ("<D", "$(dir $<)", o_automatic, 1);
1965	define_variable_cname ("?D", "$(dir $?)", o_automatic, 1);
1966	define_variable_cname ("^D", "$(dir $^)", o_automatic, 1);
1967	define_variable_cname ("+D", "$(dir $+)", o_automatic, 1);
1968	#else
1969	define_variable_cname ("@D", "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
1970	define_variable_cname ("%D", "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
1971	define_variable_cname ("D", "$(patsubst %/,%,$(dir $))", o_automatic, 1);
1972	define_variable_cname ("<D", "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
1973	define_variable_cname ("?D", "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
1974	define_variable_cname ("^D", "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
1975	define_variable_cname ("+D", "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
1976	#endif
1977	define_variable_cname ("@F", "$(notdir $@)", o_automatic, 1);
1978	define_variable_cname ("%F", "$(notdir $%)", o_automatic, 1);
1979	define_variable_cname ("F", "$(notdir $)", o_automatic, 1);
1980	define_variable_cname ("<F", "$(notdir $<)", o_automatic, 1);
1981	define_variable_cname ("?F", "$(notdir $?)", o_automatic, 1);
1982	define_variable_cname ("^F", "$(notdir $^)", o_automatic, 1);
1983	define_variable_cname ("+F", "$(notdir $+)", o_automatic, 1);
1984	#ifdef CONFIG_WITH_LAZY_DEPS_VARS
1985	define_variable ("^", 1, "$(deps $@)", o_automatic, 1);
1986	define_variable ("+", 1, "$(deps-all $@)", o_automatic, 1);
1987	define_variable ("?", 1, "$(deps-newer $@)", o_automatic, 1);
1988	define_variable ("\|", 1, "$(deps-oo $@)", o_automatic, 1);
1989	#endif /* CONFIG_WITH_LAZY_DEPS_VARS */
1990	}
1991
1992
1993	int export_all_variables;
1994
1995	#ifdef KMK
1996	/* Cached table containing the exports of the global_variable_set. When
1997	there are many global variables, it can be so expensive to construct the
1998	child environment that we have a majority of job slot idle. */
1999	static size_t global_variable_set_exports_generation = ~(size_t)0;
2000	static struct hash_table global_variable_set_exports;
2001
2002	static void update_global_variable_set_exports(void)
2003	{
2004	struct variable **v_slot;
2005	struct variable **v_end;
2006
2007	/* Re-initialize the table. */
2008	if (global_variable_set_exports_generation != ~(size_t)0)
2009	hash_free (&global_variable_set_exports, 0);
2010	hash_init_strcached (&global_variable_set_exports, ENVIRONMENT_VARIABLE_BUCKETS,
2011	&variable_strcache, offsetof (struct variable, name));
2012
2013	/* do pretty much the same as target_environment. */
2014	v_slot = (struct variable **) global_variable_set.table.ht_vec;
2015	v_end = v_slot + global_variable_set.table.ht_size;
2016	for ( ; v_slot < v_end; v_slot++)
2017	if (! HASH_VACANT (*v_slot))
2018	{
2019	struct variable **new_slot;
2020	struct variable v = v_slot;
2021
2022	switch (v->export)
2023	{
2024	case v_default:
2025	if (v->origin == o_default \|\| v->origin == o_automatic)
2026	/* Only export default variables by explicit request. */
2027	continue;
2028
2029	/* The variable doesn't have a name that can be exported. */
2030	if (! v->exportable)
2031	continue;
2032
2033	if (! export_all_variables
2034	&& v->origin != o_command
2035	&& v->origin != o_env && v->origin != o_env_override)
2036	continue;
2037	break;
2038
2039	case v_export:
2040	break;
2041
2042	case v_noexport:
2043	{
2044	/* If this is the SHELL variable and it's not exported,
2045	then add the value from our original environment, if
2046	the original environment defined a value for SHELL. */
2047	extern struct variable shell_var;
2048	if (streq (v->name, "SHELL") && shell_var.value)
2049	{
2050	v = &shell_var;
2051	break;
2052	}
2053	continue;
2054	}
2055
2056	case v_ifset:
2057	if (v->origin == o_default)
2058	continue;
2059	break;
2060	}
2061
2062	assert (strcache2_is_cached (&variable_strcache, v->name));
2063	new_slot = (struct variable **) hash_find_slot_strcached (&global_variable_set_exports, v);
2064	if (HASH_VACANT (*new_slot))
2065	hash_insert_at (&global_variable_set_exports, v, new_slot);
2066	}
2067
2068	/* done */
2069	global_variable_set_exports_generation = global_variable_generation;
2070	}
2071
2072	#endif
2073
2074	/* Create a new environment for FILE's commands.
2075	If FILE is nil, this is for the `shell' function.
2076	The child's MAKELEVEL variable is incremented. */
2077
2078	char **
2079	target_environment (struct file *file)
2080	{
2081	struct variable_set_list *set_list;
2082	register struct variable_set_list *s;
2083	struct hash_table table;
2084	struct variable **v_slot;
2085	struct variable **v_end;
2086	struct variable makelevel_key;
2087	char **result_0;
2088	char **result;
2089	#ifdef CONFIG_WITH_STRCACHE2
2090	const char *cached_name;
2091	#endif
2092
2093	#ifdef KMK
2094	if (global_variable_set_exports_generation != global_variable_generation)
2095	update_global_variable_set_exports();
2096	#endif
2097
2098	if (file == 0)
2099	set_list = current_variable_set_list;
2100	else
2101	set_list = file->variables;
2102
2103	#ifndef CONFIG_WITH_STRCACHE2
2104	hash_init (&table, ENVIRONMENT_VARIABLE_BUCKETS,
2105	variable_hash_1, variable_hash_2, variable_hash_cmp);
2106	#else /* CONFIG_WITH_STRCACHE2 */
2107	hash_init_strcached (&table, ENVIRONMENT_VARIABLE_BUCKETS,
2108	&variable_strcache, offsetof (struct variable, name));
2109	#endif /* CONFIG_WITH_STRCACHE2 */
2110
2111	/* Run through all the variable sets in the list,
2112	accumulating variables in TABLE. */
2113	for (s = set_list; s != 0; s = s->next)
2114	{
2115	struct variable_set *set = s->set;
2116	#ifdef KMK
2117	if (set == &global_variable_set)
2118	{
2119	assert(s->next == NULL);
2120	break;
2121	}
2122	#endif
2123	v_slot = (struct variable **) set->table.ht_vec;
2124	v_end = v_slot + set->table.ht_size;
2125	for ( ; v_slot < v_end; v_slot++)
2126	if (! HASH_VACANT (*v_slot))
2127	{
2128	struct variable **new_slot;
2129	struct variable v = v_slot;
2130
2131	/* If this is a per-target variable and it hasn't been touched
2132	already then look up the global version and take its export
2133	value. */
2134	if (v->per_target && v->export == v_default)
2135	{
2136	struct variable *gv;
2137
2138	#ifndef CONFIG_WITH_VALUE_LENGTH
2139	gv = lookup_variable_in_set (v->name, strlen(v->name),
2140	&global_variable_set);
2141	#else
2142	assert ((int)strlen(v->name) == v->length);
2143	gv = lookup_variable_in_set (v->name, v->length,
2144	&global_variable_set);
2145	#endif
2146	if (gv)
2147	v->export = gv->export;
2148	}
2149
2150	switch (v->export)
2151	{
2152	case v_default:
2153	if (v->origin == o_default \|\| v->origin == o_automatic)
2154	/* Only export default variables by explicit request. */
2155	continue;
2156
2157	/* The variable doesn't have a name that can be exported. */
2158	if (! v->exportable)
2159	continue;
2160
2161	if (! export_all_variables
2162	&& v->origin != o_command
2163	&& v->origin != o_env && v->origin != o_env_override)
2164	continue;
2165	break;
2166
2167	case v_export:
2168	break;
2169
2170	case v_noexport:
2171	{
2172	/* If this is the SHELL variable and it's not exported,
2173	then add the value from our original environment, if
2174	the original environment defined a value for SHELL. */
2175	extern struct variable shell_var;
2176	if (streq (v->name, "SHELL") && shell_var.value)
2177	{
2178	v = &shell_var;
2179	break;
2180	}
2181	continue;
2182	}
2183
2184	case v_ifset:
2185	if (v->origin == o_default)
2186	continue;
2187	break;
2188	}
2189
2190	#ifndef CONFIG_WITH_STRCACHE2
2191	new_slot = (struct variable **) hash_find_slot (&table, v);
2192	#else /* CONFIG_WITH_STRCACHE2 */
2193	assert (strcache2_is_cached (&variable_strcache, v->name));
2194	new_slot = (struct variable **) hash_find_slot_strcached (&table, v);
2195	#endif /* CONFIG_WITH_STRCACHE2 */
2196	if (HASH_VACANT (*new_slot))
2197	hash_insert_at (&table, v, new_slot);
2198	}
2199	}
2200
2201	#ifdef KMK
2202	/* Add the global exports to table. */
2203	v_slot = (struct variable **) global_variable_set_exports.ht_vec;
2204	v_end = v_slot + global_variable_set_exports.ht_size;
2205	for ( ; v_slot < v_end; v_slot++)
2206	if (! HASH_VACANT (*v_slot))
2207	{
2208	struct variable **new_slot;
2209	struct variable v = v_slot;
2210	assert (strcache2_is_cached (&variable_strcache, v->name));
2211	new_slot = (struct variable **) hash_find_slot_strcached (&table, v);
2212	if (HASH_VACANT (*new_slot))
2213	hash_insert_at (&table, v, new_slot);
2214	}
2215	#endif
2216
2217	#ifndef CONFIG_WITH_STRCACHE2
2218	makelevel_key.name = MAKELEVEL_NAME;
2219	makelevel_key.length = MAKELEVEL_LENGTH;
2220	hash_delete (&table, &makelevel_key);
2221	#else /* CONFIG_WITH_STRCACHE2 */
2222	/* lookup the name in the string case, if it's not there it won't
2223	be in any of the sets either. */
2224	cached_name = strcache2_lookup (&variable_strcache,
2225	MAKELEVEL_NAME, MAKELEVEL_LENGTH);
2226	if (cached_name)
2227	{
2228	makelevel_key.name = cached_name;
2229	makelevel_key.length = MAKELEVEL_LENGTH;
2230	hash_delete_strcached (&table, &makelevel_key);
2231	}
2232	#endif /* CONFIG_WITH_STRCACHE2 */
2233
2234	result = result_0 = xmalloc ((table.ht_fill + 2) * sizeof (char *));
2235
2236	v_slot = (struct variable **) table.ht_vec;
2237	v_end = v_slot + table.ht_size;
2238	for ( ; v_slot < v_end; v_slot++)
2239	if (! HASH_VACANT (*v_slot))
2240	{
2241	struct variable v = v_slot;
2242
2243	/* If V is recursively expanded and didn't come from the environment,
2244	expand its value. If it came from the environment, it should
2245	go back into the environment unchanged. */
2246	if (v->recursive
2247	&& v->origin != o_env && v->origin != o_env_override)
2248	{
2249	#ifndef CONFIG_WITH_VALUE_LENGTH
2250	char *value = recursively_expand_for_file (v, file);
2251	#else
2252	char *value = recursively_expand_for_file (v, file, NULL);
2253	#endif
2254	#ifdef WINDOWS32
2255	if (strcmp(v->name, "Path") == 0 \|\|
2256	strcmp(v->name, "PATH") == 0)
2257	convert_Path_to_windows32(value, ';');
2258	#endif
2259	*result++ = xstrdup (concat (3, v->name, "=", value));
2260	free (value);
2261	}
2262	else
2263	{
2264	#ifdef WINDOWS32
2265	if (strcmp(v->name, "Path") == 0 \|\|
2266	strcmp(v->name, "PATH") == 0)
2267	convert_Path_to_windows32(v->value, ';');
2268	#endif
2269	*result++ = xstrdup (concat (3, v->name, "=", v->value));
2270	}
2271	}
2272
2273	*result = xmalloc (100);
2274	sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
2275	*++result = 0;
2276
2277	hash_free (&table, 0);
2278
2279	return result_0;
2280	}
2281
2282
2283	#ifdef CONFIG_WITH_VALUE_LENGTH
2284	/* Worker function for do_variable_definition_append() and
2285	append_expanded_string_to_variable().
2286	The APPEND argument indicates whether it's an append or prepend operation. */
2287	void append_string_to_variable (struct variable v, const char value, unsigned int value_len, int append)
2288	{
2289	/* The previous definition of the variable was recursive.
2290	The new value is the unexpanded old and new values. */
2291	unsigned int new_value_len = value_len + (v->value_length != 0 ? 1 + v->value_length : 0);
2292	int done_1st_prepend_copy = 0;
2293	#ifdef KMK
2294	assert (!v->alias);
2295	#endif
2296
2297	/* Drop empty strings. Use $(NO_SUCH_VARIABLE) if a space is wanted. */
2298	if (!value_len)
2299	return;
2300
2301	/* adjust the size. */
2302	if (v->value_alloc_len <= new_value_len + 1)
2303	{
2304	if (v->value_alloc_len < 256)
2305	v->value_alloc_len = 256;
2306	else
2307	v->value_alloc_len *= 2;
2308	if (v->value_alloc_len < new_value_len + 1)
2309	v->value_alloc_len = VAR_ALIGN_VALUE_ALLOC (new_value_len + 1 + value_len /future/ );
2310	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
2311	if ((append \|\| !v->value_length) && !v->rdonly_val)
2312	# else
2313	if (append \|\| !v->value_length)
2314	# endif
2315	v->value = xrealloc (v->value, v->value_alloc_len);
2316	else
2317	{
2318	/* avoid the extra memcpy the xrealloc may have to do */
2319	char *new_buf = xmalloc (v->value_alloc_len);
2320	memcpy (&new_buf[value_len + 1], v->value, v->value_length + 1);
2321	done_1st_prepend_copy = 1;
2322	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
2323	if (v->rdonly_val)
2324	v->rdonly_val = 0;
2325	else
2326	# endif
2327	free (v->value);
2328	v->value = new_buf;
2329	}
2330	MAKE_STATS_2(v->reallocs++);
2331	}
2332
2333	/* insert the new bits */
2334	if (v->value_length != 0)
2335	{
2336	if (append)
2337	{
2338	v->value[v->value_length] = ' ';
2339	memcpy (&v->value[v->value_length + 1], value, value_len + 1);
2340	}
2341	else
2342	{
2343	if (!done_1st_prepend_copy)
2344	memmove (&v->value[value_len + 1], v->value, v->value_length + 1);
2345	v->value[value_len] = ' ';
2346	memcpy (v->value, value, value_len);
2347	}
2348	}
2349	else
2350	memcpy (v->value, value, value_len + 1);
2351	v->value_length = new_value_len;
2352	VARIABLE_CHANGED (v);
2353	}
2354
2355	struct variable *
2356	do_variable_definition_append (const struct floc flocp, struct variable v,
2357	const char *value, unsigned int value_len,
2358	int simple_value, enum variable_origin origin,
2359	int append)
2360	{
2361	if (env_overrides && origin == o_env)
2362	origin = o_env_override;
2363
2364	if (env_overrides && v->origin == o_env)
2365	/* V came from in the environment. Since it was defined
2366	before the switches were parsed, it wasn't affected by -e. */
2367	v->origin = o_env_override;
2368
2369	/* A variable of this name is already defined.
2370	If the old definition is from a stronger source
2371	than this one, don't redefine it. */
2372	if ((int) origin < (int) v->origin)
2373	return v;
2374	v->origin = origin;
2375
2376	/* location */
2377	if (flocp != 0)
2378	v->fileinfo = *flocp;
2379
2380	/* The juicy bits, append the specified value to the variable
2381	This is a heavily exercised code path in kBuild. */
2382	if (value_len == ~0U)
2383	value_len = strlen (value);
2384	if (v->recursive \|\| simple_value)
2385	append_string_to_variable (v, value, value_len, append);
2386	else
2387	/* The previous definition of the variable was simple.
2388	The new value comes from the old value, which was expanded
2389	when it was set; and from the expanded new value. */
2390	append_expanded_string_to_variable (v, value, value_len, append);
2391
2392	/* update the variable */
2393	return v;
2394	}
2395	#endif /* CONFIG_WITH_VALUE_LENGTH */
2396
2397
2398	static struct variable *
2399	set_special_var (struct variable *var)
2400	{
2401	if (streq (var->name, RECIPEPREFIX_NAME))
2402	{
2403	/* The user is resetting the command introduction prefix. This has to
2404	happen immediately, so that subsequent rules are interpreted
2405	properly. */
2406	cmd_prefix = var->value[0]=='\0' ? RECIPEPREFIX_DEFAULT : var->value[0];
2407	}
2408
2409	return var;
2410	}
2411
2412
2413	/* Given a variable, a value, and a flavor, define the variable.
2414	See the try_variable_definition() function for details on the parameters. */
2415
2416	struct variable *
2417	#ifndef CONFIG_WITH_VALUE_LENGTH
2418	do_variable_definition (const struct floc flocp, const char varname,
2419	const char *value, enum variable_origin origin,
2420	enum variable_flavor flavor, int target_var)
2421	#else /* CONFIG_WITH_VALUE_LENGTH */
2422	do_variable_definition_2 (const struct floc *flocp,
2423	const char varname, const char value,
2424	unsigned int value_len, int simple_value,
2425	char *free_value,
2426	enum variable_origin origin,
2427	enum variable_flavor flavor,
2428	int target_var)
2429	#endif /* CONFIG_WITH_VALUE_LENGTH */
2430	{
2431	const char *p;
2432	char *alloc_value = NULL;
2433	struct variable *v;
2434	int append = 0;
2435	int conditional = 0;
2436	const size_t varname_len = strlen (varname); /* bird */
2437
2438	#ifdef CONFIG_WITH_VALUE_LENGTH
2439	if (value_len == ~0U)
2440	value_len = strlen (value);
2441	else
2442	assert (value_len == strlen (value));
2443	#endif
2444
2445	/* Calculate the variable's new value in VALUE. */
2446
2447	switch (flavor)
2448	{
2449	default:
2450	case f_bogus:
2451	/* Should not be possible. */
2452	abort ();
2453	case f_simple:
2454	/* A simple variable definition "var := value". Expand the value.
2455	We have to allocate memory since otherwise it'll clobber the
2456	variable buffer, and we may still need that if we're looking at a
2457	target-specific variable. */
2458	#ifndef CONFIG_WITH_VALUE_LENGTH
2459	p = alloc_value = allocated_variable_expand (value);
2460	#else /* CONFIG_WITH_VALUE_LENGTH */
2461	if (!simple_value)
2462	p = alloc_value = allocated_variable_expand_2 (value, value_len, &value_len);
2463	else
2464	{
2465	if (value_len == ~0U)
2466	value_len = strlen (value);
2467	if (!free_value)
2468	p = alloc_value = xstrndup (value, value_len);
2469	else
2470	{
2471	assert (value == free_value);
2472	p = alloc_value = free_value;
2473	free_value = 0;
2474	}
2475	}
2476	#endif /* CONFIG_WITH_VALUE_LENGTH */
2477	break;
2478	case f_conditional:
2479	/* A conditional variable definition "var ?= value".
2480	The value is set IFF the variable is not defined yet. */
2481	v = lookup_variable (varname, varname_len);
2482	if (v)
2483	#ifndef CONFIG_WITH_VALUE_LENGTH
2484	return v->special ? set_special_var (v) : v;
2485	#else /* CONFIG_WITH_VALUE_LENGTH */
2486	{
2487	if (free_value)
2488	free (free_value);
2489	return v->special ? set_special_var (v) : v;
2490	}
2491	#endif /* CONFIG_WITH_VALUE_LENGTH */
2492
2493	conditional = 1;
2494	flavor = f_recursive;
2495	/* FALLTHROUGH */
2496	case f_recursive:
2497	/* A recursive variable definition "var = value".
2498	The value is used verbatim. */
2499	p = value;
2500	break;
2501	#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
2502	case f_append:
2503	case f_prepend:
2504	{
2505	const enum variable_flavor org_flavor = flavor;
2506	#else
2507	case f_append:
2508	{
2509	#endif
2510
2511	/* If we have += but we're in a target variable context, we want to
2512	append only with other variables in the context of this target. */
2513	if (target_var)
2514	{
2515	append = 1;
2516	v = lookup_variable_in_set (varname, varname_len,
2517	current_variable_set_list->set);
2518
2519	/* Don't append from the global set if a previous non-appending
2520	target-specific variable definition exists. */
2521	if (v && !v->append)
2522	append = 0;
2523	}
2524	#ifdef KMK
2525	else if ( g_pTopKbEvalData
2526	\|\| ( varname_len > 3
2527	&& varname[0] == '['
2528	&& is_kbuild_object_variable_accessor (varname, varname_len)) )
2529	{
2530	v = kbuild_object_variable_pre_append (varname, varname_len,
2531	value, value_len, simple_value,
2532	origin, org_flavor == f_append, flocp);
2533	if (free_value)
2534	free (free_value);
2535	return v;
2536	}
2537	#endif
2538	#ifdef CONFIG_WITH_LOCAL_VARIABLES
2539	/* If 'local', restrict it to the current variable context. */
2540	else if (origin == o_local)
2541	v = lookup_variable_in_set (varname, varname_len,
2542	current_variable_set_list->set);
2543	#endif
2544	else
2545	v = lookup_variable (varname, varname_len);
2546
2547	if (v == 0)
2548	{
2549	/* There was no old value.
2550	This becomes a normal recursive definition. */
2551	p = value;
2552	flavor = f_recursive;
2553	}
2554	else
2555	{
2556	#ifdef CONFIG_WITH_VALUE_LENGTH
2557	v->append = append;
2558	v = do_variable_definition_append (flocp, v, value, value_len,
2559	simple_value, origin,
2560	# ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
2561	org_flavor == f_append);
2562	# else
2563	1);
2564	# endif
2565	if (free_value)
2566	free (free_value);
2567	return v;
2568	#else /* !CONFIG_WITH_VALUE_LENGTH */
2569
2570	/* Paste the old and new values together in VALUE. */
2571
2572	unsigned int oldlen, vallen;
2573	const char *val;
2574	char *tp = NULL;
2575
2576	val = value;
2577	if (v->recursive)
2578	/* The previous definition of the variable was recursive.
2579	The new value is the unexpanded old and new values. */
2580	flavor = f_recursive;
2581	else
2582	/* The previous definition of the variable was simple.
2583	The new value comes from the old value, which was expanded
2584	when it was set; and from the expanded new value. Allocate
2585	memory for the expansion as we may still need the rest of the
2586	buffer if we're looking at a target-specific variable. */
2587	val = tp = allocated_variable_expand (val);
2588
2589	oldlen = strlen (v->value);
2590	vallen = strlen (val);
2591	p = alloc_value = xmalloc (oldlen + 1 + vallen + 1);
2592	# ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
2593	if (org_flavor == f_prepend)
2594	{
2595	memcpy (alloc_value, val, vallen);
2596	alloc_value[oldlen] = ' ';
2597	memcpy (&alloc_value[oldlen + 1], v->value, oldlen + 1);
2598	}
2599	else
2600	# endif /* CONFIG_WITH_PREPEND_ASSIGNMENT */
2601	{
2602	memcpy (alloc_value, v->value, oldlen);
2603	alloc_value[oldlen] = ' ';
2604	memcpy (&alloc_value[oldlen + 1], val, vallen + 1);
2605	}
2606
2607	if (tp)
2608	free (tp);
2609	#endif /* !CONFIG_WITH_VALUE_LENGTH */
2610	}
2611	}
2612	}
2613
2614	#ifdef __MSDOS__
2615	/* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
2616	non-Unix systems don't conform to this default configuration (in
2617	fact, most of them don't even have `/bin'). On the other hand,
2618	$SHELL in the environment, if set, points to the real pathname of
2619	the shell.
2620	Therefore, we generally won't let lines like "SHELL=/bin/sh" from
2621	the Makefile override $SHELL from the environment. But first, we
2622	look for the basename of the shell in the directory where SHELL=
2623	points, and along the $PATH; if it is found in any of these places,
2624	we define $SHELL to be the actual pathname of the shell. Thus, if
2625	you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
2626	your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
2627	defining SHELL to be "d:/unix/bash.exe". */
2628	if ((origin == o_file \|\| origin == o_override)
2629	&& strcmp (varname, "SHELL") == 0)
2630	{
2631	PATH_VAR (shellpath);
2632	extern char * __dosexec_find_on_path (const char , char [], char *);
2633
2634	/* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
2635	if (__dosexec_find_on_path (p, NULL, shellpath))
2636	{
2637	char *tp;
2638
2639	for (tp = shellpath; *tp; tp++)
2640	if (*tp == '\\')
2641	*tp = '/';
2642
2643	v = define_variable_loc (varname, varname_len,
2644	shellpath, origin, flavor == f_recursive,
2645	flocp);
2646	}
2647	else
2648	{
2649	const char shellbase, bslash;
2650	struct variable *pathv = lookup_variable ("PATH", 4);
2651	char *path_string;
2652	char *fake_env[2];
2653	size_t pathlen = 0;
2654
2655	shellbase = strrchr (p, '/');
2656	bslash = strrchr (p, '\\');
2657	if (!shellbase \|\| bslash > shellbase)
2658	shellbase = bslash;
2659	if (!shellbase && p[1] == ':')
2660	shellbase = p + 1;
2661	if (shellbase)
2662	shellbase++;
2663	else
2664	shellbase = p;
2665
2666	/* Search for the basename of the shell (with standard
2667	executable extensions) along the $PATH. */
2668	if (pathv)
2669	pathlen = strlen (pathv->value);
2670	path_string = xmalloc (5 + pathlen + 2 + 1);
2671	/* On MSDOS, current directory is considered as part of $PATH. */
2672	sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
2673	fake_env[0] = path_string;
2674	fake_env[1] = 0;
2675	if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
2676	{
2677	char *tp;
2678
2679	for (tp = shellpath; *tp; tp++)
2680	if (*tp == '\\')
2681	*tp = '/';
2682
2683	v = define_variable_loc (varname, varname_len,
2684	shellpath, origin,
2685	flavor == f_recursive, flocp);
2686	}
2687	else
2688	v = lookup_variable (varname, varname_len);
2689
2690	free (path_string);
2691	}
2692	}
2693	else
2694	#endif /* __MSDOS__ */
2695	#ifdef WINDOWS32
2696	if ( varname_len == sizeof("SHELL") - 1 /* bird */
2697	&& (origin == o_file \|\| origin == o_override \|\| origin == o_command)
2698	&& streq (varname, "SHELL"))
2699	{
2700	extern char *default_shell;
2701
2702	/* Call shell locator function. If it returns TRUE, then
2703	set no_default_sh_exe to indicate sh was found and
2704	set new value for SHELL variable. */
2705
2706	if (find_and_set_default_shell (p))
2707	{
2708	v = define_variable_in_set (varname, varname_len, default_shell,
2709	# ifdef CONFIG_WITH_VALUE_LENGTH
2710	~0U, 1 /* duplicate_value */,
2711	# endif
2712	origin, flavor == f_recursive,
2713	(target_var
2714	? current_variable_set_list->set
2715	: NULL),
2716	flocp);
2717	no_default_sh_exe = 0;
2718	}
2719	else
2720	{
2721	char *tp = alloc_value;
2722
2723	alloc_value = allocated_variable_expand (p);
2724
2725	if (find_and_set_default_shell (alloc_value))
2726	{
2727	v = define_variable_in_set (varname, varname_len, p,
2728	#ifdef CONFIG_WITH_VALUE_LENGTH
2729	~0U, 1 /* duplicate_value */,
2730	#endif
2731	origin, flavor == f_recursive,
2732	(target_var
2733	? current_variable_set_list->set
2734	: NULL),
2735	flocp);
2736	no_default_sh_exe = 0;
2737	}
2738	else
2739	v = lookup_variable (varname, varname_len);
2740
2741	if (tp)
2742	free (tp);
2743	}
2744	}
2745	else
2746	#endif
2747
2748	/* If we are defining variables inside an $(eval ...), we might have a
2749	different variable context pushed, not the global context (maybe we're
2750	inside a $(call ...) or something. Since this function is only ever
2751	invoked in places where we want to define globally visible variables,
2752	make sure we define this variable in the global set. */
2753
2754	v = define_variable_in_set (varname, varname_len, p,
2755	#ifdef CONFIG_WITH_VALUE_LENGTH
2756	value_len, !alloc_value,
2757	#endif
2758	origin, flavor == f_recursive,
2759	#ifdef CONFIG_WITH_LOCAL_VARIABLES
2760	(target_var \|\| origin == o_local
2761	#else
2762	(target_var
2763	#endif
2764	? current_variable_set_list->set : NULL),
2765	flocp);
2766	v->append = append;
2767	v->conditional = conditional;
2768
2769	#ifndef CONFIG_WITH_VALUE_LENGTH
2770	if (alloc_value)
2771	free (alloc_value);
2772	#else
2773	if (free_value)
2774	free (free_value);
2775	#endif
2776
2777	return v->special ? set_special_var (v) : v;
2778	}
2779
2780
2781	/* Parse P (a null-terminated string) as a variable definition.
2782
2783	If it is not a variable definition, return NULL.
2784
2785	If it is a variable definition, return a pointer to the char after the
2786	assignment token and set FLAVOR to the type of variable assignment. /
2787
2788	char *
2789	parse_variable_definition (const char p, enum variable_flavor flavor)
2790	{
2791	int wspace = 0;
2792
2793	p = next_token (p);
2794
2795	while (1)
2796	{
2797	int c = *p++;
2798
2799	/* If we find a comment or EOS, it's not a variable definition. */
2800	if (c == '\0' \|\| c == '#')
2801	return NULL;
2802
2803	if (c == '$')
2804	{
2805	/* This begins a variable expansion reference. Make sure we don't
2806	treat chars inside the reference as assignment tokens. */
2807	char closeparen;
2808	int count;
2809	c = *p++;
2810	if (c == '(')
2811	closeparen = ')';
2812	else if (c == '{')
2813	closeparen = '}';
2814	else
2815	/* '$$' or '$X'. Either way, nothing special to do here. */
2816	continue;
2817
2818	/* P now points past the opening paren or brace.
2819	Count parens or braces until it is matched. */
2820	count = 0;
2821	for (; *p != '\0'; ++p)
2822	{
2823	if (*p == c)
2824	++count;
2825	else if (*p == closeparen && --count < 0)
2826	{
2827	++p;
2828	break;
2829	}
2830	}
2831	continue;
2832	}
2833
2834	/* If we find whitespace skip it, and remember we found it. */
2835	if (isblank ((unsigned char)c))
2836	{
2837	wspace = 1;
2838	p = next_token (p);
2839	c = *p;
2840	if (c == '\0')
2841	return NULL;
2842	++p;
2843	}
2844
2845
2846	if (c == '=')
2847	{
2848	*flavor = f_recursive;
2849	return (char *)p;
2850	}
2851
2852	/* Match assignment variants (:=, +=, ?=) */
2853	if (*p == '=')
2854	{
2855	switch (c)
2856	{
2857	case ':':
2858	*flavor = f_simple;
2859	break;
2860	case '+':
2861	*flavor = f_append;
2862	break;
2863	#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
2864	case '<':
2865	*flavor = f_prepend;
2866	break;
2867	#endif
2868	case '?':
2869	*flavor = f_conditional;
2870	break;
2871	default:
2872	/* If we skipped whitespace, non-assignments means no var. */
2873	if (wspace)
2874	return NULL;
2875
2876	/* Might be assignment, or might be $= or #=. Check. */
2877	continue;
2878	}
2879	return (char *)++p;
2880	}
2881	else if (c == ':')
2882	/* A colon other than := is a rule line, not a variable defn. */
2883	return NULL;
2884
2885	/* If we skipped whitespace, non-assignments means no var. */
2886	if (wspace)
2887	return NULL;
2888	}
2889
2890	return (char *)p;
2891	}
2892
2893
2894	/* Try to interpret LINE (a null-terminated string) as a variable definition.
2895
2896	If LINE was recognized as a variable definition, a pointer to its `struct
2897	variable' is returned. If LINE is not a variable definition, NULL is
2898	returned. */
2899
2900	struct variable *
2901	assign_variable_definition (struct variable v, char line IF_WITH_VALUE_LENGTH_PARAM(char *eos))
2902	{
2903	char *beg;
2904	char *end;
2905	enum variable_flavor flavor;
2906	#ifndef CONFIG_WITH_VALUE_LENGTH
2907	char *name;
2908	#endif
2909
2910	beg = next_token (line);
2911	line = parse_variable_definition (beg, &flavor);
2912	if (!line)
2913	return NULL;
2914
2915	end = line - (flavor == f_recursive ? 1 : 2);
2916	while (end > beg && isblank ((unsigned char)end[-1]))
2917	--end;
2918	line = next_token (line);
2919	v->value = line;
2920	v->flavor = flavor;
2921	#ifdef CONFIG_WITH_VALUE_LENGTH
2922	v->value_alloc_len = ~(unsigned int)0;
2923	v->value_length = eos != NULL ? eos - line : -1;
2924	assert (eos == NULL \|\| strchr (line, '\0') == eos);
2925	# ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
2926	v->rdonly_val = 0;
2927	# endif
2928	#endif
2929
2930	/* Expand the name, so "$(foo)bar = baz" works. */
2931	#ifndef CONFIG_WITH_VALUE_LENGTH
2932	name = alloca (end - beg + 1);
2933	memcpy (name, beg, end - beg);
2934	name[end - beg] = '\0';
2935	v->name = allocated_variable_expand (name);
2936	#else /* CONFIG_WITH_VALUE_LENGTH */
2937	v->name = allocated_variable_expand_2 (beg, end - beg, NULL);
2938	#endif /* CONFIG_WITH_VALUE_LENGTH */
2939
2940	if (v->name[0] == '\0')
2941	fatal (&v->fileinfo, _("empty variable name"));
2942
2943	return v;
2944	}
2945
2946
2947	/* Try to interpret LINE (a null-terminated string) as a variable definition.
2948
2949	ORIGIN may be o_file, o_override, o_env, o_env_override, o_local,
2950	or o_command specifying that the variable definition comes
2951	from a makefile, an override directive, the environment with
2952	or without the -e switch, or the command line.
2953
2954	See the comments for assign_variable_definition().
2955
2956	If LINE was recognized as a variable definition, a pointer to its `struct
2957	variable' is returned. If LINE is not a variable definition, NULL is
2958	returned. */
2959
2960	struct variable *
2961	try_variable_definition (const struct floc flocp, char line
2962	IF_WITH_VALUE_LENGTH_PARAM(char *eos),
2963	enum variable_origin origin, int target_var)
2964	{
2965	struct variable v;
2966	struct variable *vp;
2967
2968	if (flocp != 0)
2969	v.fileinfo = *flocp;
2970	else
2971	v.fileinfo.filenm = 0;
2972
2973	#ifndef CONFIG_WITH_VALUE_LENGTH
2974	if (!assign_variable_definition (&v, line))
2975	return 0;
2976
2977	vp = do_variable_definition (flocp, v.name, v.value,
2978	origin, v.flavor, target_var);
2979	#else
2980	if (!assign_variable_definition (&v, line, eos))
2981	return 0;
2982
2983	vp = do_variable_definition_2 (flocp, v.name, v.value, v.value_length,
2984	0, NULL, origin, v.flavor, target_var);
2985	#endif
2986
2987	#ifndef CONFIG_WITH_STRCACHE2
2988	free (v.name);
2989	#else
2990	free ((char *)v.name);
2991	#endif
2992
2993	return vp;
2994	}
2995
2996
2997	#if defined (CONFIG_WITH_COMPILER) \|\| defined (CONFIG_WITH_MAKE_STATS)
2998	static unsigned long var_stats_evalvals, var_stats_evalvaled;
2999	static unsigned long var_stats_expands, var_stats_expanded;
3000	#endif
3001	#ifdef CONFIG_WITH_COMPILER
3002	static unsigned long var_stats_expandprogs, var_stats_evalprogs;
3003	#endif
3004	#ifdef CONFIG_WITH_MAKE_STATS
3005	static unsigned long var_stats_changes, var_stats_changed;
3006	static unsigned long var_stats_reallocs, var_stats_realloced;
3007	static unsigned long var_stats_references, var_stats_referenced;
3008	static unsigned long var_stats_val_len, var_stats_val_alloc_len;
3009	static unsigned long var_stats_val_rdonly_len;
3010	#endif
3011
3012	/* Print information for variable V, prefixing it with PREFIX. */
3013
3014	static void
3015	print_variable (const void item, void arg)
3016	{
3017	const struct variable *v = item;
3018	const char *prefix = arg;
3019	const char *origin;
3020	#ifdef KMK
3021	const struct variable *alias = v;
3022	RESOLVE_ALIAS_VARIABLE(v);
3023	#endif
3024
3025	switch (v->origin)
3026	{
3027	case o_default:
3028	origin = _("default");
3029	break;
3030	case o_env:
3031	origin = _("environment");
3032	break;
3033	case o_file:
3034	origin = _("makefile");
3035	break;
3036	case o_env_override:
3037	origin = _("environment under -e");
3038	break;
3039	case o_command:
3040	origin = _("command line");
3041	break;
3042	case o_override:
3043	origin = _("`override' directive");
3044	break;
3045	case o_automatic:
3046	origin = _("automatic");
3047	break;
3048	#ifdef CONFIG_WITH_LOCAL_VARIABLES
3049	case o_local:
3050	origin = _("`local' directive");
3051	break;
3052	#endif
3053	case o_invalid:
3054	default:
3055	abort ();
3056	}
3057	fputs ("# ", stdout);
3058	fputs (origin, stdout);
3059	if (v->private_var)
3060	fputs (" private", stdout);
3061	#ifndef KMK
3062	if (v->fileinfo.filenm)
3063	printf (_(" (from `%s', line %lu)"),
3064	v->fileinfo.filenm, v->fileinfo.lineno);
3065	#else /* KMK */
3066	if (alias->fileinfo.filenm)
3067	printf (_(" (from '%s', line %lu)"),
3068	alias->fileinfo.filenm, alias->fileinfo.lineno);
3069	if (alias->aliased)
3070	fputs (" aliased", stdout);
3071	if (alias->alias)
3072	printf (_(", alias for '%s'"), v->name);
3073	#endif /* KMK */
3074
3075	#if defined (CONFIG_WITH_COMPILER) \|\| defined (CONFIG_WITH_MAKE_STATS)
3076	if (v->evalval_count != 0)
3077	{
3078	# ifdef CONFIG_WITH_MAKE_STATS
3079	printf (_(", %u evalvals (%llu ticks)"), v->evalval_count, v->cTicksEvalVal);
3080	# else
3081	printf (_(", %u evalvals"), v->evalval_count);
3082	# endif
3083	var_stats_evalvaled++;
3084	}
3085	var_stats_evalvals += v->evalval_count;
3086
3087	if (v->expand_count != 0)
3088	{
3089	printf (_(", %u expands"), v->expand_count);
3090	var_stats_expanded++;
3091	}
3092	var_stats_expands += v->expand_count;
3093
3094	# ifdef CONFIG_WITH_COMPILER
3095	if (v->evalprog != 0)
3096	{
3097	printf (_(", evalprog"));
3098	var_stats_evalprogs++;
3099	}
3100	if (v->expandprog != 0)
3101	{
3102	printf (_(", expandprog"));
3103	var_stats_expandprogs++;
3104	}
3105	# endif
3106	#endif
3107
3108	#ifdef CONFIG_WITH_MAKE_STATS
3109	if (v->changes != 0)
3110	{
3111	printf (_(", %u changes"), v->changes);
3112	var_stats_changed++;
3113	}
3114	var_stats_changes += v->changes;
3115
3116	if (v->reallocs != 0)
3117	{
3118	printf (_(", %u reallocs"), v->reallocs);
3119	var_stats_realloced++;
3120	}
3121	var_stats_reallocs += v->reallocs;
3122
3123	if (v->references != 0)
3124	{
3125	printf (_(", %u references"), v->references);
3126	var_stats_referenced++;
3127	}
3128	var_stats_references += v->references;
3129
3130	var_stats_val_len += v->value_length;
3131	if (v->value_alloc_len)
3132	var_stats_val_alloc_len += v->value_alloc_len;
3133	else
3134	var_stats_val_rdonly_len += v->value_length;
3135	assert (v->value_length == strlen (v->value));
3136	/assert (v->rdonly_val ? !v->value_alloc_len : v->value_alloc_len > v->value_length); - FIXME /
3137	#endif /* CONFIG_WITH_MAKE_STATS */
3138	putchar ('\n');
3139	fputs (prefix, stdout);
3140
3141	/* Is this a `define'? */
3142	if (v->recursive && strchr (v->value, '\n') != 0)
3143	#ifndef KMK /** @todo language feature for aliases */
3144	printf ("define %s\n%s\nendef\n", v->name, v->value);
3145	#else
3146	printf ("define %s\n%s\nendef\n", alias->name, v->value);
3147	#endif
3148	else
3149	{
3150	char *p;
3151
3152	#ifndef KMK /** @todo language feature for aliases */
3153	printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
3154	#else
3155	printf ("%s %s= ", alias->name, v->recursive ? v->append ? "+" : "" : ":");
3156	#endif
3157
3158	/* Check if the value is just whitespace. */
3159	p = next_token (v->value);
3160	if (p != v->value && *p == '\0')
3161	/* All whitespace. */
3162	printf ("$(subst ,,%s)", v->value);
3163	else if (v->recursive)
3164	fputs (v->value, stdout);
3165	else
3166	/* Double up dollar signs. */
3167	for (p = v->value; *p != '\0'; ++p)
3168	{
3169	if (*p == '$')
3170	putchar ('$');
3171	putchar (*p);
3172	}
3173	putchar ('\n');
3174	}
3175	}
3176
3177
3178	/* Print all the variables in SET. PREFIX is printed before
3179	the actual variable definitions (everything else is comments). */
3180
3181	void
3182	print_variable_set (struct variable_set set, char prefix)
3183	{
3184	#if defined (CONFIG_WITH_COMPILER) \|\| defined (CONFIG_WITH_MAKE_STATS)
3185	var_stats_expands = var_stats_expanded = var_stats_evalvals
3186	= var_stats_evalvaled = 0;
3187	#endif
3188	#ifdef CONFIG_WITH_COMPILER
3189	var_stats_expandprogs = var_stats_evalprogs = 0;
3190	#endif
3191	#ifdef CONFIG_WITH_MAKE_STATS
3192	var_stats_changes = var_stats_changed = var_stats_reallocs
3193	= var_stats_realloced = var_stats_references = var_stats_referenced
3194	= var_stats_val_len = var_stats_val_alloc_len
3195	= var_stats_val_rdonly_len = 0;
3196	#endif
3197
3198	hash_map_arg (&set->table, print_variable, prefix);
3199
3200	if (set->table.ht_fill)
3201	{
3202	#ifdef CONFIG_WITH_MAKE_STATS
3203	unsigned long fragmentation;
3204
3205	fragmentation = var_stats_val_alloc_len - (var_stats_val_len - var_stats_val_rdonly_len);
3206	printf(_("# variable set value stats:\n\
3207	# strings %7lu bytes, readonly %6lu bytes\n"),
3208	var_stats_val_len, var_stats_val_rdonly_len);
3209
3210	if (var_stats_val_alloc_len)
3211	printf(_("# allocated %7lu bytes, fragmentation %6lu bytes (%u%%)\n"),
3212	var_stats_val_alloc_len, fragmentation,
3213	(unsigned int)((100.0 * fragmentation) / var_stats_val_alloc_len));
3214
3215	if (var_stats_changed)
3216	printf(_("# changed %5lu (%2u%%), changes %6lu\n"),
3217	var_stats_changed,
3218	(unsigned int)((100.0 * var_stats_changed) / set->table.ht_fill),
3219	var_stats_changes);
3220
3221	if (var_stats_realloced)
3222	printf(_("# reallocated %5lu (%2u%%), reallocations %6lu\n"),
3223	var_stats_realloced,
3224	(unsigned int)((100.0 * var_stats_realloced) / set->table.ht_fill),
3225	var_stats_reallocs);
3226
3227	if (var_stats_referenced)
3228	printf(_("# referenced %5lu (%2u%%), references %6lu\n"),
3229	var_stats_referenced,
3230	(unsigned int)((100.0 * var_stats_referenced) / set->table.ht_fill),
3231	var_stats_references);
3232	#endif
3233	#if defined (CONFIG_WITH_COMPILER) \|\| defined (CONFIG_WITH_MAKE_STATS)
3234	if (var_stats_evalvals)
3235	printf(_("# evalvaled %5lu (%2u%%), evalval calls %6lu\n"),
3236	var_stats_evalvaled,
3237	(unsigned int)((100.0 * var_stats_evalvaled) / set->table.ht_fill),
3238	var_stats_evalvals);
3239	if (var_stats_expands)
3240	printf(_("# expanded %5lu (%2u%%), expands %6lu\n"),
3241	var_stats_expanded,
3242	(unsigned int)((100.0 * var_stats_expanded) / set->table.ht_fill),
3243	var_stats_expands);
3244	#endif
3245	#ifdef CONFIG_WITH_COMPILER
3246	if (var_stats_expandprogs \|\| var_stats_evalprogs)
3247	printf(_("# eval progs %5lu (%2u%%), expand progs %6lu (%2u%%)\n"),
3248	var_stats_evalprogs,
3249	(unsigned int)((100.0 * var_stats_evalprogs) / set->table.ht_fill),
3250	var_stats_expandprogs,
3251	(unsigned int)((100.0 * var_stats_expandprogs) / set->table.ht_fill));
3252	#endif
3253	}
3254
3255	fputs (_("# variable set hash-table stats:\n"), stdout);
3256	fputs ("# ", stdout);
3257	hash_print_stats (&set->table, stdout);
3258	putc ('\n', stdout);
3259	}
3260
3261	/* Print the data base of variables. */
3262
3263	void
3264	print_variable_data_base (void)
3265	{
3266	puts (_("\n# Variables\n"));
3267
3268	print_variable_set (&global_variable_set, "");
3269
3270	puts (_("\n# Pattern-specific Variable Values"));
3271
3272	{
3273	struct pattern_var *p;
3274	int rules = 0;
3275
3276	for (p = pattern_vars; p != 0; p = p->next)
3277	{
3278	++rules;
3279	printf ("\n%s :\n", p->target);
3280	print_variable (&p->variable, "# ");
3281	}
3282
3283	if (rules == 0)
3284	puts (_("\n# No pattern-specific variable values."));
3285	else
3286	printf (_("\n# %u pattern-specific variable values"), rules);
3287	}
3288
3289	#ifdef CONFIG_WITH_STRCACHE2
3290	strcache2_print_stats (&variable_strcache, "# ");
3291	#endif
3292	}
3293
3294	#ifdef CONFIG_WITH_PRINT_STATS_SWITCH
3295	void
3296	print_variable_stats (void)
3297	{
3298	fputs (_("\n# Global variable hash-table stats:\n# "), stdout);
3299	hash_print_stats (&global_variable_set.table, stdout);
3300	fputs ("\n", stdout);
3301	}
3302	#endif
3303
3304	/* Print all the local variables of FILE. */
3305
3306	void
3307	print_file_variables (const struct file *file)
3308	{
3309	if (file->variables != 0)
3310	print_variable_set (file->variables->set, "# ");
3311	}
3312
3313	#ifdef WINDOWS32
3314	void
3315	sync_Path_environment (void)
3316	{
3317	char *path = allocated_variable_expand ("$(PATH)");
3318	static char *environ_path = NULL;
3319
3320	if (!path)
3321	return;
3322
3323	/*
3324	* If done this before, don't leak memory unnecessarily.
3325	* Free the previous entry before allocating new one.
3326	*/
3327	if (environ_path)
3328	free (environ_path);
3329
3330	/*
3331	* Create something WINDOWS32 world can grok
3332	*/
3333	convert_Path_to_windows32 (path, ';');
3334	environ_path = xstrdup (concat (3, "PATH", "=", path));
3335	putenv (environ_path);
3336	free (path);
3337	}
3338	#endif

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

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

Download in other formats: