source: trunk/src/gmake/variable.c@ 730

Last change on this file since 730 was 730, checked in by bird, 19 years ago

Added a variation on the $(comp-vars) function called $(comp-cmds) which compares command by command instead of the string as a whole ignoring spaces and job control chars.
  • Property svn:eol-style set to native
File size: 58.4 KB
Line 
1/* Internals of variables for GNU Make.
2Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
31998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4Foundation, Inc.
5This file is part of GNU Make.
6
7GNU Make is free software; you can redistribute it and/or modify it under the
8terms of the GNU General Public License as published by the Free Software
9Foundation; either version 2, or (at your option) any later version.
10
11GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License along with
16GNU Make; see the file COPYING. If not, write to the Free Software
17Foundation, 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
36static struct pattern_var *pattern_vars;
37
38/* Pointer to last struct in the chain, so we can add onto the end. */
39
40static struct pattern_var *last_pattern_var;
41
42/* Create a new pattern-specific variable struct. */
43
44struct pattern_var *
45create_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
66static struct pattern_var *
67lookup_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
109typedef signed int int32_t;
110typedef signed short int int16_t;
111# endif
112static 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
141static 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
160static unsigned long
161variable_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
181static unsigned long
182variable_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
199static int
200variable_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
289static struct variable_set global_variable_set;
290static struct variable_set_list global_setlist
291 = { 0, &global_variable_set };
292struct variable_set_list *current_variable_set_list = &global_setlist;
293
294
295/* Implement variables. */
296
297void
298init_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
317struct variable *
318define_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
323struct variable *
324define_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
471static struct variable *
472handle_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
556struct variable *
557lookup_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
677struct variable *
678lookup_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
703void
704initialize_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
802struct variable_set_list *
803create_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
820static void
821free_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
828void
829free_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
843struct variable_set_list *
844push_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
862void
863pop_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
899static void
900merge_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
925void
926merge_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
963void
964define_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(KMK_HELPERS)
1042 (void) define_variable ("KMK_FEATURES", 12,
1043 "abspath abspathex"
1044 " toupper tolower"
1045 " comp-vars comp-cmds"
1046 " stack "
1047 " kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one"
1048 , o_default, 0);
1049# else /* MSC can't deal with strings mixed with #if/#endif, thus the slow way. */
1050 strcpy(buf, "abspath");
1051# if defined(CONFIG_WITH_ABSPATHEX)
1052 strcat(buf, " abspathex");
1053# endif
1054# if defined(CONFIG_WITH_TOUPPER_TOLOWER)
1055 strcat(buf, " toupper tolower");
1056# endif
1057# if defined(CONFIG_WITH_VALUE_LENGTH) && defined(CONFIG_WITH_COMPARE)
1058 strcat(buf, " comp-vars comp-cmds");
1059# endif
1060# if defined(CONFIG_WITH_STACK)
1061 strcat(buf, " stack");
1062# endif
1063# ifdef KMK_HELPERS
1064 strcat(buf, " kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one");
1065# endif
1066 (void) define_variable ("KMK_FEATURES", 12, buf, o_default, 0);
1067# endif
1068
1069#endif /* KMK */
1070
1071#ifdef CONFIG_WITH_KMK_BUILTIN
1072 /* The supported kMk Builtin commands. */
1073 (void) define_variable ("KMK_BUILTIN", 11, "append cp cat echo install ln mkdir rm rmdir", o_default, 0);
1074#endif
1075
1076#ifdef __MSDOS__
1077 /* Allow to specify a special shell just for Make,
1078 and use $COMSPEC as the default $SHELL when appropriate. */
1079 {
1080 static char shell_str[] = "SHELL";
1081 const int shlen = sizeof (shell_str) - 1;
1082 struct variable *mshp = lookup_variable ("MAKESHELL", 9);
1083 struct variable *comp = lookup_variable ("COMSPEC", 7);
1084
1085 /* Make $MAKESHELL override $SHELL even if -e is in effect. */
1086 if (mshp)
1087 (void) define_variable (shell_str, shlen,
1088 mshp->value, o_env_override, 0);
1089 else if (comp)
1090 {
1091 /* $COMSPEC shouldn't override $SHELL. */
1092 struct variable *shp = lookup_variable (shell_str, shlen);
1093
1094 if (!shp)
1095 (void) define_variable (shell_str, shlen, comp->value, o_env, 0);
1096 }
1097 }
1098#elif defined(__EMX__)
1099 {
1100 static char shell_str[] = "SHELL";
1101 const int shlen = sizeof (shell_str) - 1;
1102 struct variable *shell = lookup_variable (shell_str, shlen);
1103 struct variable *replace = lookup_variable ("MAKESHELL", 9);
1104
1105 /* if $MAKESHELL is defined in the environment assume o_env_override */
1106 if (replace && *replace->value && replace->origin == o_env)
1107 replace->origin = o_env_override;
1108
1109 /* if $MAKESHELL is not defined use $SHELL but only if the variable
1110 did not come from the environment */
1111 if (!replace || !*replace->value)
1112 if (shell && *shell->value && (shell->origin == o_env
1113 || shell->origin == o_env_override))
1114 {
1115 /* overwrite whatever we got from the environment */
1116 free(shell->value);
1117 shell->value = xstrdup (default_shell);
1118 shell->origin = o_default;
1119 }
1120
1121 /* Some people do not like cmd to be used as the default
1122 if $SHELL is not defined in the Makefile.
1123 With -DNO_CMD_DEFAULT you can turn off this behaviour */
1124# ifndef NO_CMD_DEFAULT
1125 /* otherwise use $COMSPEC */
1126 if (!replace || !*replace->value)
1127 replace = lookup_variable ("COMSPEC", 7);
1128
1129 /* otherwise use $OS2_SHELL */
1130 if (!replace || !*replace->value)
1131 replace = lookup_variable ("OS2_SHELL", 9);
1132# else
1133# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
1134# endif
1135
1136 if (replace && *replace->value)
1137 /* overwrite $SHELL */
1138 (void) define_variable (shell_str, shlen, replace->value,
1139 replace->origin, 0);
1140 else
1141 /* provide a definition if there is none */
1142 (void) define_variable (shell_str, shlen, default_shell,
1143 o_default, 0);
1144 }
1145
1146#endif
1147
1148 /* This won't override any definition, but it will provide one if there
1149 isn't one there. */
1150 v = define_variable ("SHELL", 5, default_shell, o_default, 0);
1151
1152 /* On MSDOS we do use SHELL from environment, since it isn't a standard
1153 environment variable on MSDOS, so whoever sets it, does that on purpose.
1154 On OS/2 we do not use SHELL from environment but we have already handled
1155 that problem above. */
1156#if !defined(__MSDOS__) && !defined(__EMX__)
1157 /* Don't let SHELL come from the environment. */
1158 if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override)
1159 {
1160 free (v->value);
1161 v->origin = o_file;
1162 v->value = xstrdup (default_shell);
1163#ifdef CONFIG_WITH_VALUE_LENGTH
1164 v->value_length = strlen (v->value);
1165 v->value_alloc_len = v->value_length + 1;
1166#endif
1167 }
1168#endif
1169
1170 /* Make sure MAKEFILES gets exported if it is set. */
1171 v = define_variable ("MAKEFILES", 9, "", o_default, 0);
1172 v->export = v_ifset;
1173
1174 /* Define the magic D and F variables in terms of
1175 the automatic variables they are variations of. */
1176
1177#ifdef VMS
1178 define_variable ("@D", 2, "$(dir $@)", o_automatic, 1);
1179 define_variable ("%D", 2, "$(dir $%)", o_automatic, 1);
1180 define_variable ("*D", 2, "$(dir $*)", o_automatic, 1);
1181 define_variable ("<D", 2, "$(dir $<)", o_automatic, 1);
1182 define_variable ("?D", 2, "$(dir $?)", o_automatic, 1);
1183 define_variable ("^D", 2, "$(dir $^)", o_automatic, 1);
1184 define_variable ("+D", 2, "$(dir $+)", o_automatic, 1);
1185#else
1186 define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
1187 define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
1188 define_variable ("*D", 2, "$(patsubst %/,%,$(dir $*))", o_automatic, 1);
1189 define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
1190 define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
1191 define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
1192 define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
1193#endif
1194 define_variable ("@F", 2, "$(notdir $@)", o_automatic, 1);
1195 define_variable ("%F", 2, "$(notdir $%)", o_automatic, 1);
1196 define_variable ("*F", 2, "$(notdir $*)", o_automatic, 1);
1197 define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
1198 define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
1199 define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
1200 define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
1201}
1202
1203
1204int export_all_variables;
1205
1206/* Create a new environment for FILE's commands.
1207 If FILE is nil, this is for the `shell' function.
1208 The child's MAKELEVEL variable is incremented. */
1209
1210char **
1211target_environment (struct file *file)
1212{
1213 struct variable_set_list *set_list;
1214 register struct variable_set_list *s;
1215 struct hash_table table;
1216 struct variable **v_slot;
1217 struct variable **v_end;
1218 struct variable makelevel_key;
1219 char **result_0;
1220 char **result;
1221
1222 if (file == 0)
1223 set_list = current_variable_set_list;
1224 else
1225 set_list = file->variables;
1226
1227 hash_init (&table, VARIABLE_BUCKETS,
1228 variable_hash_1, variable_hash_2, variable_hash_cmp);
1229
1230 /* Run through all the variable sets in the list,
1231 accumulating variables in TABLE. */
1232 for (s = set_list; s != 0; s = s->next)
1233 {
1234 struct variable_set *set = s->set;
1235 v_slot = (struct variable **) set->table.ht_vec;
1236 v_end = v_slot + set->table.ht_size;
1237 for ( ; v_slot < v_end; v_slot++)
1238 if (! HASH_VACANT (*v_slot))
1239 {
1240 struct variable **new_slot;
1241 struct variable *v = *v_slot;
1242
1243 /* If this is a per-target variable and it hasn't been touched
1244 already then look up the global version and take its export
1245 value. */
1246 if (v->per_target && v->export == v_default)
1247 {
1248 struct variable *gv;
1249
1250 gv = lookup_variable_in_set (v->name, strlen(v->name),
1251 &global_variable_set);
1252 if (gv)
1253 v->export = gv->export;
1254 }
1255
1256 switch (v->export)
1257 {
1258 case v_default:
1259 if (v->origin == o_default || v->origin == o_automatic)
1260 /* Only export default variables by explicit request. */
1261 continue;
1262
1263 /* The variable doesn't have a name that can be exported. */
1264 if (! v->exportable)
1265 continue;
1266
1267 if (! export_all_variables
1268 && v->origin != o_command
1269 && v->origin != o_env && v->origin != o_env_override)
1270 continue;
1271 break;
1272
1273 case v_export:
1274 break;
1275
1276 case v_noexport:
1277 /* If this is the SHELL variable and it's not exported, then
1278 add the value from our original environment. */
1279 if (streq (v->name, "SHELL"))
1280 {
1281 extern struct variable shell_var;
1282 v = &shell_var;
1283 break;
1284 }
1285 continue;
1286
1287 case v_ifset:
1288 if (v->origin == o_default)
1289 continue;
1290 break;
1291 }
1292
1293 new_slot = (struct variable **) hash_find_slot (&table, v);
1294 if (HASH_VACANT (*new_slot))
1295 hash_insert_at (&table, v, new_slot);
1296 }
1297 }
1298
1299 makelevel_key.name = MAKELEVEL_NAME;
1300 makelevel_key.length = MAKELEVEL_LENGTH;
1301#ifdef VARIABLE_HASH /* bird */
1302 makelevel_key.hash1 = variable_hash_1i (MAKELEVEL_NAME, MAKELEVEL_LENGTH);
1303 makelevel_key.hash2 = 0;
1304#endif
1305 hash_delete (&table, &makelevel_key);
1306
1307 result = result_0 = (char **) xmalloc ((table.ht_fill + 2) * sizeof (char *));
1308
1309 v_slot = (struct variable **) table.ht_vec;
1310 v_end = v_slot + table.ht_size;
1311 for ( ; v_slot < v_end; v_slot++)
1312 if (! HASH_VACANT (*v_slot))
1313 {
1314 struct variable *v = *v_slot;
1315
1316 /* If V is recursively expanded and didn't come from the environment,
1317 expand its value. If it came from the environment, it should
1318 go back into the environment unchanged. */
1319 if (v->recursive
1320 && v->origin != o_env && v->origin != o_env_override)
1321 {
1322 char *value = recursively_expand_for_file (v, file);
1323#ifdef WINDOWS32
1324 if (strcmp(v->name, "Path") == 0 ||
1325 strcmp(v->name, "PATH") == 0)
1326 convert_Path_to_windows32(value, ';');
1327#endif
1328 *result++ = concat (v->name, "=", value);
1329 free (value);
1330 }
1331 else
1332 {
1333#ifdef WINDOWS32
1334 if (strcmp(v->name, "Path") == 0 ||
1335 strcmp(v->name, "PATH") == 0)
1336 convert_Path_to_windows32(v->value, ';');
1337#endif
1338 *result++ = concat (v->name, "=", v->value);
1339 }
1340 }
1341
1342 *result = (char *) xmalloc (100);
1343 (void) sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
1344 *++result = 0;
1345
1346 hash_free (&table, 0);
1347
1348 return result_0;
1349}
1350
1351
1352#ifdef CONFIG_WITH_VALUE_LENGTH
1353static struct variable *
1354do_variable_definition_append (const struct floc *flocp, struct variable *v, char *value,
1355 enum variable_origin origin)
1356{
1357 if (env_overrides && origin == o_env)
1358 origin = o_env_override;
1359
1360 if (env_overrides && v->origin == o_env)
1361 /* V came from in the environment. Since it was defined
1362 before the switches were parsed, it wasn't affected by -e. */
1363 v->origin = o_env_override;
1364
1365 /* A variable of this name is already defined.
1366 If the old definition is from a stronger source
1367 than this one, don't redefine it. */
1368 if ((int) origin < (int) v->origin)
1369 return v;
1370 v->origin = origin;
1371
1372 /* location */
1373 if (flocp != 0)
1374 v->fileinfo = *flocp;
1375
1376 /* The juicy bits, append the specified value to the variable
1377 This is a heavily exercied code path in kBuild. */
1378 if (v->recursive)
1379 {
1380 /* The previous definition of the variable was recursive.
1381 The new value is the unexpanded old and new values. */
1382 unsigned int value_len = strlen (value);
1383 unsigned int new_value_len = value_len + (v->value_length != 0 ? 1 + v->value_length : 0);
1384
1385 /* adjust the size. */
1386 if ((unsigned)v->value_alloc_len <= new_value_len)
1387 {
1388 v->value_alloc_len = (new_value_len + 0x80) + 0x7f;
1389 v->value = xrealloc (v->value, v->value_alloc_len);
1390 }
1391
1392 /* insert the new bits */
1393 if (v->value_length != 0)
1394 {
1395 v->value[v->value_length] = ' ';
1396 memcpy (&v->value[v->value_length + 1], value, value_len + 1);
1397 }
1398 else
1399 memcpy (v->value, value, value_len + 1);
1400 v->value_length = new_value_len;
1401 }
1402 else
1403 {
1404 /* The previous definition of the variable was simple.
1405 The new value comes from the old value, which was expanded
1406 when it was set; and from the expanded new value. */
1407 append_expanded_string_to_variable(v, value);
1408 }
1409
1410 /* update the variable */
1411 return v;
1412}
1413#endif /* CONFIG_WITH_VALUE_LENGTH */
1414
1415
1416/* Given a variable, a value, and a flavor, define the variable.
1417 See the try_variable_definition() function for details on the parameters. */
1418
1419struct variable *
1420do_variable_definition (const struct floc *flocp, const char *varname,
1421 char *value, enum variable_origin origin,
1422 enum variable_flavor flavor, int target_var)
1423{
1424 char *p, *alloc_value = NULL;
1425 struct variable *v;
1426 int append = 0;
1427 int conditional = 0;
1428 const size_t varname_len = strlen (varname); /* bird */
1429# ifdef CONFIG_WITH_VALUE_LENGTH
1430 unsigned int value_len = ~0U;
1431# endif
1432
1433 /* Calculate the variable's new value in VALUE. */
1434
1435 switch (flavor)
1436 {
1437 default:
1438 case f_bogus:
1439 /* Should not be possible. */
1440 abort ();
1441 case f_simple:
1442 /* A simple variable definition "var := value". Expand the value.
1443 We have to allocate memory since otherwise it'll clobber the
1444 variable buffer, and we may still need that if we're looking at a
1445 target-specific variable. */
1446 p = alloc_value = allocated_variable_expand (value);
1447 break;
1448 case f_conditional:
1449 /* A conditional variable definition "var ?= value".
1450 The value is set IFF the variable is not defined yet. */
1451 v = lookup_variable (varname, varname_len);
1452 if (v)
1453 return v;
1454
1455 conditional = 1;
1456 flavor = f_recursive;
1457 /* FALLTHROUGH */
1458 case f_recursive:
1459 /* A recursive variable definition "var = value".
1460 The value is used verbatim. */
1461 p = value;
1462 break;
1463 case f_append:
1464 {
1465 /* If we have += but we're in a target variable context, we want to
1466 append only with other variables in the context of this target. */
1467 if (target_var)
1468 {
1469 append = 1;
1470 v = lookup_variable_in_set (varname, varname_len,
1471 current_variable_set_list->set);
1472
1473 /* Don't append from the global set if a previous non-appending
1474 target-specific variable definition exists. */
1475 if (v && !v->append)
1476 append = 0;
1477 }
1478 else
1479 v = lookup_variable (varname, varname_len);
1480
1481 if (v == 0)
1482 {
1483 /* There was no old value.
1484 This becomes a normal recursive definition. */
1485 p = value;
1486 flavor = f_recursive;
1487 }
1488 else
1489 {
1490#ifdef CONFIG_WITH_VALUE_LENGTH
1491 v->append = append;
1492 return do_variable_definition_append (flocp, v, value, origin);
1493#else /* !CONFIG_WITH_VALUE_LENGTH */
1494
1495 /* Paste the old and new values together in VALUE. */
1496
1497 unsigned int oldlen, vallen;
1498 char *val;
1499
1500 val = value;
1501 if (v->recursive)
1502 /* The previous definition of the variable was recursive.
1503 The new value is the unexpanded old and new values. */
1504 flavor = f_recursive;
1505 else
1506 /* The previous definition of the variable was simple.
1507 The new value comes from the old value, which was expanded
1508 when it was set; and from the expanded new value. Allocate
1509 memory for the expansion as we may still need the rest of the
1510 buffer if we're looking at a target-specific variable. */
1511 val = alloc_value = allocated_variable_expand (val);
1512
1513 oldlen = strlen (v->value);
1514 vallen = strlen (val);
1515 p = (char *) alloca (oldlen + 1 + vallen + 1);
1516 bcopy (v->value, p, oldlen);
1517 p[oldlen] = ' ';
1518 bcopy (val, &p[oldlen + 1], vallen + 1);
1519#endif /* !CONFIG_WITH_VALUE_LENGTH */
1520 }
1521 }
1522 }
1523
1524#ifdef __MSDOS__
1525 /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1526 non-Unix systems don't conform to this default configuration (in
1527 fact, most of them don't even have `/bin'). On the other hand,
1528 $SHELL in the environment, if set, points to the real pathname of
1529 the shell.
1530 Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1531 the Makefile override $SHELL from the environment. But first, we
1532 look for the basename of the shell in the directory where SHELL=
1533 points, and along the $PATH; if it is found in any of these places,
1534 we define $SHELL to be the actual pathname of the shell. Thus, if
1535 you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1536 your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1537 defining SHELL to be "d:/unix/bash.exe". */
1538 if ((origin == o_file || origin == o_override)
1539 && strcmp (varname, "SHELL") == 0)
1540 {
1541 PATH_VAR (shellpath);
1542 extern char * __dosexec_find_on_path (const char *, char *[], char *);
1543
1544 /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1545 if (__dosexec_find_on_path (p, (char **)0, shellpath))
1546 {
1547 char *p;
1548
1549 for (p = shellpath; *p; p++)
1550 {
1551 if (*p == '\\')
1552 *p = '/';
1553 }
1554 v = define_variable_loc (varname, varname_len,
1555 shellpath, origin, flavor == f_recursive,
1556 flocp);
1557 }
1558 else
1559 {
1560 char *shellbase, *bslash;
1561 struct variable *pathv = lookup_variable ("PATH", 4);
1562 char *path_string;
1563 char *fake_env[2];
1564 size_t pathlen = 0;
1565
1566 shellbase = strrchr (p, '/');
1567 bslash = strrchr (p, '\\');
1568 if (!shellbase || bslash > shellbase)
1569 shellbase = bslash;
1570 if (!shellbase && p[1] == ':')
1571 shellbase = p + 1;
1572 if (shellbase)
1573 shellbase++;
1574 else
1575 shellbase = p;
1576
1577 /* Search for the basename of the shell (with standard
1578 executable extensions) along the $PATH. */
1579 if (pathv)
1580 pathlen = strlen (pathv->value);
1581 path_string = (char *)xmalloc (5 + pathlen + 2 + 1);
1582 /* On MSDOS, current directory is considered as part of $PATH. */
1583 sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
1584 fake_env[0] = path_string;
1585 fake_env[1] = (char *)0;
1586 if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
1587 {
1588 char *p;
1589
1590 for (p = shellpath; *p; p++)
1591 {
1592 if (*p == '\\')
1593 *p = '/';
1594 }
1595 v = define_variable_loc (varname, varname_len,
1596 shellpath, origin,
1597 flavor == f_recursive, flocp);
1598 }
1599 else
1600 v = lookup_variable (varname, varname_len);
1601
1602 free (path_string);
1603 }
1604 }
1605 else
1606#endif /* __MSDOS__ */
1607#ifdef WINDOWS32
1608 if ( varname_len == sizeof("SHELL") - 1 /* bird */
1609 && (origin == o_file || origin == o_override || origin == o_command)
1610 && streq (varname, "SHELL"))
1611 {
1612 extern char *default_shell;
1613
1614 /* Call shell locator function. If it returns TRUE, then
1615 set no_default_sh_exe to indicate sh was found and
1616 set new value for SHELL variable. */
1617
1618 if (find_and_set_default_shell (p))
1619 {
1620 v = define_variable_in_set (varname, varname_len, default_shell,
1621# ifdef CONFIG_WITH_VALUE_LENGTH
1622 ~0U, 1 /* duplicate_value */,
1623# endif
1624 origin, flavor == f_recursive,
1625 (target_var
1626 ? current_variable_set_list->set
1627 : NULL),
1628 flocp);
1629 no_default_sh_exe = 0;
1630 }
1631 else
1632 v = lookup_variable (varname, varname_len);
1633# ifdef CONFIG_WITH_VALUE_LENGTH
1634 if (alloc_value)
1635 free (alloc_value);
1636# endif
1637 }
1638 else
1639#endif
1640
1641 /* If we are defining variables inside an $(eval ...), we might have a
1642 different variable context pushed, not the global context (maybe we're
1643 inside a $(call ...) or something. Since this function is only ever
1644 invoked in places where we want to define globally visible variables,
1645 make sure we define this variable in the global set. */
1646
1647 v = define_variable_in_set (varname, varname_len, p,
1648#ifdef CONFIG_WITH_VALUE_LENGTH
1649 value_len, !alloc_value,
1650#endif
1651 origin, flavor == f_recursive,
1652 (target_var
1653 ? current_variable_set_list->set : NULL),
1654 flocp);
1655 v->append = append;
1656 v->conditional = conditional;
1657
1658#ifndef CONFIG_WITH_VALUE_LENGTH
1659 if (alloc_value)
1660 free (alloc_value);
1661#endif
1662
1663 return v;
1664}
1665
1666
1667/* Try to interpret LINE (a null-terminated string) as a variable definition.
1668
1669 ORIGIN may be o_file, o_override, o_env, o_env_override,
1670 or o_command specifying that the variable definition comes
1671 from a makefile, an override directive, the environment with
1672 or without the -e switch, or the command line.
1673
1674 See the comments for parse_variable_definition().
1675
1676 If LINE was recognized as a variable definition, a pointer to its `struct
1677 variable' is returned. If LINE is not a variable definition, NULL is
1678 returned. */
1679
1680struct variable *
1681parse_variable_definition (struct variable *v, char *line)
1682{
1683 register int c;
1684 register char *p = line;
1685 register char *beg;
1686 register char *end;
1687 enum variable_flavor flavor = f_bogus;
1688 char *name;
1689
1690 while (1)
1691 {
1692 c = *p++;
1693 if (c == '\0' || c == '#')
1694 return 0;
1695 if (c == '=')
1696 {
1697 end = p - 1;
1698 flavor = f_recursive;
1699 break;
1700 }
1701 else if (c == ':')
1702 if (*p == '=')
1703 {
1704 end = p++ - 1;
1705 flavor = f_simple;
1706 break;
1707 }
1708 else
1709 /* A colon other than := is a rule line, not a variable defn. */
1710 return 0;
1711 else if (c == '+' && *p == '=')
1712 {
1713 end = p++ - 1;
1714 flavor = f_append;
1715 break;
1716 }
1717 else if (c == '?' && *p == '=')
1718 {
1719 end = p++ - 1;
1720 flavor = f_conditional;
1721 break;
1722 }
1723 else if (c == '$')
1724 {
1725 /* This might begin a variable expansion reference. Make sure we
1726 don't misrecognize chars inside the reference as =, := or +=. */
1727 char closeparen;
1728 int count;
1729 c = *p++;
1730 if (c == '(')
1731 closeparen = ')';
1732 else if (c == '{')
1733 closeparen = '}';
1734 else
1735 continue; /* Nope. */
1736
1737 /* P now points past the opening paren or brace.
1738 Count parens or braces until it is matched. */
1739 count = 0;
1740 for (; *p != '\0'; ++p)
1741 {
1742 if (*p == c)
1743 ++count;
1744 else if (*p == closeparen && --count < 0)
1745 {
1746 ++p;
1747 break;
1748 }
1749 }
1750 }
1751 }
1752 v->flavor = flavor;
1753
1754 beg = next_token (line);
1755 while (end > beg && isblank ((unsigned char)end[-1]))
1756 --end;
1757 p = next_token (p);
1758 v->value = p;
1759#ifdef CONFIG_WITH_VALUE_LENGTH
1760 v->value_length = v->value_alloc_len = -1;
1761#endif
1762
1763 /* Expand the name, so "$(foo)bar = baz" works. */
1764 name = (char *) alloca (end - beg + 1);
1765 bcopy (beg, name, end - beg);
1766 name[end - beg] = '\0';
1767 v->name = allocated_variable_expand (name);
1768
1769 if (v->name[0] == '\0')
1770 fatal (&v->fileinfo, _("empty variable name"));
1771
1772 return v;
1773}
1774
1775
1776/* Try to interpret LINE (a null-terminated string) as a variable definition.
1777
1778 ORIGIN may be o_file, o_override, o_env, o_env_override,
1779 or o_command specifying that the variable definition comes
1780 from a makefile, an override directive, the environment with
1781 or without the -e switch, or the command line.
1782
1783 See the comments for parse_variable_definition().
1784
1785 If LINE was recognized as a variable definition, a pointer to its `struct
1786 variable' is returned. If LINE is not a variable definition, NULL is
1787 returned. */
1788
1789struct variable *
1790try_variable_definition (const struct floc *flocp, char *line,
1791 enum variable_origin origin, int target_var)
1792{
1793 struct variable v;
1794 struct variable *vp;
1795
1796 if (flocp != 0)
1797 v.fileinfo = *flocp;
1798 else
1799 v.fileinfo.filenm = 0;
1800
1801 if (!parse_variable_definition (&v, line))
1802 return 0;
1803
1804 vp = do_variable_definition (flocp, v.name, v.value,
1805 origin, v.flavor, target_var);
1806
1807 free (v.name);
1808
1809 return vp;
1810}
1811
1812
1813/* Print information for variable V, prefixing it with PREFIX. */
1814
1815static void
1816print_variable (const void *item, void *arg)
1817{
1818 const struct variable *v = (struct variable *) item;
1819 const char *prefix = (char *) arg;
1820 const char *origin;
1821
1822 switch (v->origin)
1823 {
1824 case o_default:
1825 origin = _("default");
1826 break;
1827 case o_env:
1828 origin = _("environment");
1829 break;
1830 case o_file:
1831 origin = _("makefile");
1832 break;
1833 case o_env_override:
1834 origin = _("environment under -e");
1835 break;
1836 case o_command:
1837 origin = _("command line");
1838 break;
1839 case o_override:
1840 origin = _("`override' directive");
1841 break;
1842 case o_automatic:
1843 origin = _("automatic");
1844 break;
1845 case o_invalid:
1846 default:
1847 abort ();
1848 }
1849 fputs ("# ", stdout);
1850 fputs (origin, stdout);
1851 if (v->fileinfo.filenm)
1852 printf (_(" (from `%s', line %lu)"),
1853 v->fileinfo.filenm, v->fileinfo.lineno);
1854 putchar ('\n');
1855 fputs (prefix, stdout);
1856
1857 /* Is this a `define'? */
1858 if (v->recursive && strchr (v->value, '\n') != 0)
1859 printf ("define %s\n%s\nendef\n", v->name, v->value);
1860 else
1861 {
1862 register char *p;
1863
1864 printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
1865
1866 /* Check if the value is just whitespace. */
1867 p = next_token (v->value);
1868 if (p != v->value && *p == '\0')
1869 /* All whitespace. */
1870 printf ("$(subst ,,%s)", v->value);
1871 else if (v->recursive)
1872 fputs (v->value, stdout);
1873 else
1874 /* Double up dollar signs. */
1875 for (p = v->value; *p != '\0'; ++p)
1876 {
1877 if (*p == '$')
1878 putchar ('$');
1879 putchar (*p);
1880 }
1881 putchar ('\n');
1882 }
1883}
1884
1885
1886/* Print all the variables in SET. PREFIX is printed before
1887 the actual variable definitions (everything else is comments). */
1888
1889void
1890print_variable_set (struct variable_set *set, char *prefix)
1891{
1892 hash_map_arg (&set->table, print_variable, prefix);
1893
1894 fputs (_("# variable set hash-table stats:\n"), stdout);
1895 fputs ("# ", stdout);
1896 hash_print_stats (&set->table, stdout);
1897 putc ('\n', stdout);
1898}
1899
1900/* Print the data base of variables. */
1901
1902void
1903print_variable_data_base (void)
1904{
1905 puts (_("\n# Variables\n"));
1906
1907 print_variable_set (&global_variable_set, "");
1908
1909 puts (_("\n# Pattern-specific Variable Values"));
1910
1911 {
1912 struct pattern_var *p;
1913 int rules = 0;
1914
1915 for (p = pattern_vars; p != 0; p = p->next)
1916 {
1917 ++rules;
1918 printf ("\n%s :\n", p->target);
1919 print_variable (&p->variable, "# ");
1920 }
1921
1922 if (rules == 0)
1923 puts (_("\n# No pattern-specific variable values."));
1924 else
1925 printf (_("\n# %u pattern-specific variable values"), rules);
1926 }
1927}
1928
1929
1930/* Print all the local variables of FILE. */
1931
1932void
1933print_file_variables (struct file *file)
1934{
1935 if (file->variables != 0)
1936 print_variable_set (file->variables->set, "# ");
1937}
1938
1939#ifdef WINDOWS32
1940void
1941sync_Path_environment (void)
1942{
1943 char *path = allocated_variable_expand ("$(PATH)");
1944 static char *environ_path = NULL;
1945
1946 if (!path)
1947 return;
1948
1949 /*
1950 * If done this before, don't leak memory unnecessarily.
1951 * Free the previous entry before allocating new one.
1952 */
1953 if (environ_path)
1954 free (environ_path);
1955
1956 /*
1957 * Create something WINDOWS32 world can grok
1958 */
1959 convert_Path_to_windows32 (path, ';');
1960 environ_path = concat ("PATH", "=", path);
1961 putenv (environ_path);
1962 free (path);
1963}
1964#endif
Note: See TracBrowser for help on using the repository browser.