variable.c@ 902

Last change on this file since 902 was 821, checked in by bird, 18 years ago
New function: $(xargs)
Property svn:eol-style set to `native`
File size: 58.7 KB

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

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

source: kBuild/trunk/src/gmakenew/variable.c@ 902

Download in other formats: