VirtualBox

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

Last change on this file since 2831 was 2771, checked in by bird, 10 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette