variable.c@ 1810

Last change on this file since 1810 was 1809, checked in by bird, 16 years ago
kmk: More length and alloc optimizations. Made all the length optimizations from yesterday CONFIG_WITH_VALUE_LENGTH instead of KMK.
Property svn:eol-style set to `native`
File size: 71.9 KB

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

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

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

Download in other formats: