variable.c@ 1752

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

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

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

Download in other formats: