VirtualBox

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

Last change on this file since 1805 was 1805, checked in by bird, 16 years ago

kmk: Some minor optimizations.

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

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