source: trunk/src/kmk/variable.c@ 1453

Last change on this file since 1453 was 1451, checked in by bird, 17 years ago

Made it build without VARIABLE_HASH defined.
  • Property svn:eol-style set to native
File size: 67.9 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? */
424# define VARIABLE_BUCKETS 16384
425# else /*!KMK*/
426#define VARIABLE_BUCKETS 523
427# endif /*!KMK*/
428#endif
429#ifndef PERFILE_VARIABLE_BUCKETS
430# ifdef KMK /* Move to Makefile.kmk? */
431# define PERFILE_VARIABLE_BUCKETS 64
432# else
433#define PERFILE_VARIABLE_BUCKETS 23
434# endif
435#endif
436#ifndef SMALL_SCOPE_VARIABLE_BUCKETS
437# ifdef KMK /* Move to Makefile.kmk? */
438# define SMALL_SCOPE_VARIABLE_BUCKETS 32
439# else
440#define SMALL_SCOPE_VARIABLE_BUCKETS 13
441# endif
442#endif
443
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 *envvar;
1127#endif
1128
1129 sprintf (buf, "%u", makelevel);
1130 (void) define_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH, buf, o_env, 0);
1131
1132 sprintf (buf, "%s%s%s",
1133 version_string,
1134 (remote_description == 0 || remote_description[0] == '\0')
1135 ? "" : "-",
1136 (remote_description == 0 || remote_description[0] == '\0')
1137 ? "" : remote_description);
1138 (void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0);
1139
1140#ifdef KMK
1141 /* Define KMK_VERSION to indicate kMk. */
1142 (void) define_variable ("KMK_VERSION", 11, buf, o_default, 0);
1143
1144 /* Define KBUILD_VERSION* */
1145 sprintf (buf, "%d", KBUILD_VERSION_MAJOR);
1146 define_variable ("KBUILD_VERSION_MAJOR", sizeof ("KBUILD_VERSION_MAJOR") - 1,
1147 buf, o_default, 0);
1148 sprintf (buf, "%d", KBUILD_VERSION_MINOR);
1149 define_variable ("KBUILD_VERSION_MINOR", sizeof("KBUILD_VERSION_MINOR") - 1,
1150 buf, o_default, 0);
1151 sprintf (buf, "%d", KBUILD_VERSION_PATCH);
1152 define_variable ("KBUILD_VERSION_PATCH", sizeof ("KBUILD_VERSION_PATCH") - 1,
1153 buf, o_default, 0);
1154
1155 sprintf (buf, "%d.%d.%d", KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR, KBUILD_VERSION_PATCH);
1156 define_variable ("KBUILD_VERSION", sizeof ("KBUILD_VERSION") - 1,
1157 buf, o_default, 0);
1158
1159 /* The build platform defaults. */
1160 envvar = getenv ("BUILD_PLATFORM");
1161 if (!envvar)
1162 define_variable ("BUILD_PLATFORM", sizeof ("BUILD_PLATFORM") - 1,
1163 BUILD_PLATFORM, o_default, 0);
1164 envvar = getenv ("BUILD_PLATFORM_ARCH");
1165 if (!envvar)
1166 define_variable ("BUILD_PLATFORM_ARCH", sizeof ("BUILD_PLATFORM_ARCH") - 1,
1167 BUILD_PLATFORM_ARCH, o_default, 0);
1168 envvar = getenv ("BUILD_PLATFORM_CPU");
1169 if (!envvar)
1170 define_variable ("BUILD_PLATFORM_CPU", sizeof ("BUILD_PLATFORM_CPU") - 1,
1171 BUILD_PLATFORM_CPU, o_default, 0);
1172
1173 /* The kBuild locations. */
1174 define_variable ("PATH_KBUILD", sizeof ("PATH_KBUILD") - 1,
1175 get_path_kbuild (), o_default, 0);
1176 define_variable ("PATH_KBUILD_BIN", sizeof ("PATH_KBUILD_BIN") - 1,
1177 get_path_kbuild_bin (), o_default, 0);
1178
1179 /* Define KMK_FEATURES to indicate various working KMK features. */
1180# if defined (CONFIG_WITH_RSORT) \
1181 && defined (CONFIG_WITH_ABSPATHEX) \
1182 && defined (CONFIG_WITH_TOUPPER_TOLOWER) \
1183 && defined (CONFIG_WITH_VALUE_LENGTH) && defined (CONFIG_WITH_COMPARE) \
1184 && defined (CONFIG_WITH_STACK) \
1185 && defined (CONFIG_WITH_MATH) \
1186 && defined (CONFIG_WITH_XARGS) \
1187 && defined (CONFIG_WITH_EXPLICIT_MULTITARGET) \
1188 && defined (CONFIG_WITH_PREPEND_ASSIGNMENT) \
1189 && defined (CONFIG_WITH_SET_CONDITIONALS) \
1190 && defined (CONFIG_WITH_DATE) \
1191 && defined (CONFIG_WITH_FILE_SIZE) \
1192 && defined (CONFIG_WITH_WHICH) \
1193 && defined (CONFIG_WITH_EVALPLUS) \
1194 && defined (CONFIG_WITH_MAKE_STATS) \
1195 && defined (CONFIG_WITH_COMMANDS_FUNC) \
1196 && defined (KMK_HELPERS)
1197 (void) define_variable ("KMK_FEATURES", 12,
1198 "append-dash-n abspath"
1199 " rsort"
1200 " abspathex"
1201 " toupper tolower"
1202 " comp-vars comp-cmds comp-cmds-ex"
1203 " stack"
1204 " math-int"
1205 " xargs"
1206 " explicit-multitarget"
1207 " prepend-assignment"
1208 " set-conditionals"
1209 " date"
1210 " file-size"
1211 " which"
1212 " evalctx evalval evalvalctx evalcall evalcall2"
1213 " make-stats"
1214 " commands"
1215 " kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one "
1216 , o_default, 0);
1217# else /* MSC can't deal with strings mixed with #if/#endif, thus the slow way. */
1218# error "All features should be enabled by default!"
1219 strcpy (buf, "append-dash-n abspath");
1220# if defined (CONFIG_WITH_RSORT)
1221 strcat (buf, " rsort");
1222# endif
1223# if defined (CONFIG_WITH_ABSPATHEX)
1224 strcat (buf, " abspathex");
1225# endif
1226# if defined (CONFIG_WITH_TOUPPER_TOLOWER)
1227 strcat (buf, " toupper tolower");
1228# endif
1229# if defined (CONFIG_WITH_VALUE_LENGTH) && defined(CONFIG_WITH_COMPARE)
1230 strcat (buf, " comp-vars comp-cmds comp-cmds-ex");
1231# endif
1232# if defined (CONFIG_WITH_STACK)
1233 strcat (buf, " stack");
1234# endif
1235# if defined (CONFIG_WITH_MATH)
1236 strcat (buf, " math-int");
1237# endif
1238# if defined (CONFIG_WITH_XARGS)
1239 strcat (buf, " xargs");
1240# endif
1241# if defined (CONFIG_WITH_EXPLICIT_MULTITARGET)
1242 strcat (buf, " explicit-multitarget");
1243# endif
1244# if defined (CONFIG_WITH_PREPEND_ASSIGNMENT)
1245 strcat (buf, " prepend-assignment");
1246# endif
1247# if defined (CONFIG_WITH_SET_CONDITIONALS)
1248 strcat (buf, " set-conditionals");
1249# endif
1250# if defined (CONFIG_WITH_DATE)
1251 strcat (buf, " date");
1252# endif
1253# if defined (CONFIG_WITH_FILE_SIZE)
1254 strcat (buf, " file-size");
1255# endif
1256# if defined (CONFIG_WITH_WHICH)
1257 strcat (buf, " which");
1258# endif
1259# if defined (CONFIG_WITH_EVALPLUS)
1260 strcat (buf, " evalctx evalval evalvalctx evalcall evalcall2");
1261# endif
1262# if defined (CONFIG_WITH_MAKE_STATS)
1263 strcat (buf, " make-stats");
1264# endif
1265# if defined (CONFIG_WITH_COMMANDS_FUNC)
1266 strcat (buf, " commands");
1267# endif
1268# if defined (KMK_HELPERS)
1269 strcat (buf, " kb-src-tool kb-obj-base kb-obj-suff kb-src-prop kb-src-one");
1270# endif
1271 (void) define_variable ("KMK_FEATURES", 12, buf, o_default, 0);
1272# endif
1273
1274#endif /* KMK */
1275
1276#ifdef CONFIG_WITH_KMK_BUILTIN
1277 /* The supported kMk Builtin commands. */
1278 (void) define_variable ("KMK_BUILTIN", 11, "append cat cp cmp echo install kDepIDB ln md5sum mkdir mv printf rm rmdir test", o_default, 0);
1279#endif
1280
1281#ifdef __MSDOS__
1282 /* Allow to specify a special shell just for Make,
1283 and use $COMSPEC as the default $SHELL when appropriate. */
1284 {
1285 static char shell_str[] = "SHELL";
1286 const int shlen = sizeof (shell_str) - 1;
1287 struct variable *mshp = lookup_variable ("MAKESHELL", 9);
1288 struct variable *comp = lookup_variable ("COMSPEC", 7);
1289
1290 /* Make $MAKESHELL override $SHELL even if -e is in effect. */
1291 if (mshp)
1292 (void) define_variable (shell_str, shlen,
1293 mshp->value, o_env_override, 0);
1294 else if (comp)
1295 {
1296 /* $COMSPEC shouldn't override $SHELL. */
1297 struct variable *shp = lookup_variable (shell_str, shlen);
1298
1299 if (!shp)
1300 (void) define_variable (shell_str, shlen, comp->value, o_env, 0);
1301 }
1302 }
1303#elif defined(__EMX__)
1304 {
1305 static char shell_str[] = "SHELL";
1306 const int shlen = sizeof (shell_str) - 1;
1307 struct variable *shell = lookup_variable (shell_str, shlen);
1308 struct variable *replace = lookup_variable ("MAKESHELL", 9);
1309
1310 /* if $MAKESHELL is defined in the environment assume o_env_override */
1311 if (replace && *replace->value && replace->origin == o_env)
1312 replace->origin = o_env_override;
1313
1314 /* if $MAKESHELL is not defined use $SHELL but only if the variable
1315 did not come from the environment */
1316 if (!replace || !*replace->value)
1317 if (shell && *shell->value && (shell->origin == o_env
1318 || shell->origin == o_env_override))
1319 {
1320 /* overwrite whatever we got from the environment */
1321 free(shell->value);
1322 shell->value = xstrdup (default_shell);
1323 shell->origin = o_default;
1324 }
1325
1326 /* Some people do not like cmd to be used as the default
1327 if $SHELL is not defined in the Makefile.
1328 With -DNO_CMD_DEFAULT you can turn off this behaviour */
1329# ifndef NO_CMD_DEFAULT
1330 /* otherwise use $COMSPEC */
1331 if (!replace || !*replace->value)
1332 replace = lookup_variable ("COMSPEC", 7);
1333
1334 /* otherwise use $OS2_SHELL */
1335 if (!replace || !*replace->value)
1336 replace = lookup_variable ("OS2_SHELL", 9);
1337# else
1338# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
1339# endif
1340
1341 if (replace && *replace->value)
1342 /* overwrite $SHELL */
1343 (void) define_variable (shell_str, shlen, replace->value,
1344 replace->origin, 0);
1345 else
1346 /* provide a definition if there is none */
1347 (void) define_variable (shell_str, shlen, default_shell,
1348 o_default, 0);
1349 }
1350
1351#endif
1352
1353 /* This won't override any definition, but it will provide one if there
1354 isn't one there. */
1355 v = define_variable ("SHELL", 5, default_shell, o_default, 0);
1356
1357 /* On MSDOS we do use SHELL from environment, since it isn't a standard
1358 environment variable on MSDOS, so whoever sets it, does that on purpose.
1359 On OS/2 we do not use SHELL from environment but we have already handled
1360 that problem above. */
1361#if !defined(__MSDOS__) && !defined(__EMX__)
1362 /* Don't let SHELL come from the environment. */
1363 if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override)
1364 {
1365 free (v->value);
1366 v->origin = o_file;
1367 v->value = xstrdup (default_shell);
1368#ifdef CONFIG_WITH_VALUE_LENGTH
1369 v->value_length = strlen (v->value);
1370 v->value_alloc_len = v->value_length + 1;
1371#endif
1372 }
1373#endif
1374
1375 /* Make sure MAKEFILES gets exported if it is set. */
1376 v = define_variable ("MAKEFILES", 9, "", o_default, 0);
1377 v->export = v_ifset;
1378
1379 /* Define the magic D and F variables in terms of
1380 the automatic variables they are variations of. */
1381
1382#ifdef VMS
1383 define_variable ("@D", 2, "$(dir $@)", o_automatic, 1);
1384 define_variable ("%D", 2, "$(dir $%)", o_automatic, 1);
1385 define_variable ("*D", 2, "$(dir $*)", o_automatic, 1);
1386 define_variable ("<D", 2, "$(dir $<)", o_automatic, 1);
1387 define_variable ("?D", 2, "$(dir $?)", o_automatic, 1);
1388 define_variable ("^D", 2, "$(dir $^)", o_automatic, 1);
1389 define_variable ("+D", 2, "$(dir $+)", o_automatic, 1);
1390#else
1391 define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
1392 define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
1393 define_variable ("*D", 2, "$(patsubst %/,%,$(dir $*))", o_automatic, 1);
1394 define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
1395 define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
1396 define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
1397 define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
1398#endif
1399 define_variable ("@F", 2, "$(notdir $@)", o_automatic, 1);
1400 define_variable ("%F", 2, "$(notdir $%)", o_automatic, 1);
1401 define_variable ("*F", 2, "$(notdir $*)", o_automatic, 1);
1402 define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
1403 define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
1404 define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
1405 define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
1406}
1407
1408
1409int export_all_variables;
1410
1411/* Create a new environment for FILE's commands.
1412 If FILE is nil, this is for the `shell' function.
1413 The child's MAKELEVEL variable is incremented. */
1414
1415char **
1416target_environment (struct file *file)
1417{
1418 struct variable_set_list *set_list;
1419 register struct variable_set_list *s;
1420 struct hash_table table;
1421 struct variable **v_slot;
1422 struct variable **v_end;
1423 struct variable makelevel_key;
1424 char **result_0;
1425 char **result;
1426
1427 if (file == 0)
1428 set_list = current_variable_set_list;
1429 else
1430 set_list = file->variables;
1431
1432 hash_init (&table, VARIABLE_BUCKETS,
1433 variable_hash_1, variable_hash_2, variable_hash_cmp);
1434
1435 /* Run through all the variable sets in the list,
1436 accumulating variables in TABLE. */
1437 for (s = set_list; s != 0; s = s->next)
1438 {
1439 struct variable_set *set = s->set;
1440 v_slot = (struct variable **) set->table.ht_vec;
1441 v_end = v_slot + set->table.ht_size;
1442 for ( ; v_slot < v_end; v_slot++)
1443 if (! HASH_VACANT (*v_slot))
1444 {
1445 struct variable **new_slot;
1446 struct variable *v = *v_slot;
1447
1448 /* If this is a per-target variable and it hasn't been touched
1449 already then look up the global version and take its export
1450 value. */
1451 if (v->per_target && v->export == v_default)
1452 {
1453 struct variable *gv;
1454
1455 gv = lookup_variable_in_set (v->name, strlen(v->name),
1456 &global_variable_set);
1457 if (gv)
1458 v->export = gv->export;
1459 }
1460
1461 switch (v->export)
1462 {
1463 case v_default:
1464 if (v->origin == o_default || v->origin == o_automatic)
1465 /* Only export default variables by explicit request. */
1466 continue;
1467
1468 /* The variable doesn't have a name that can be exported. */
1469 if (! v->exportable)
1470 continue;
1471
1472 if (! export_all_variables
1473 && v->origin != o_command
1474 && v->origin != o_env && v->origin != o_env_override)
1475 continue;
1476 break;
1477
1478 case v_export:
1479 break;
1480
1481 case v_noexport:
1482 /* If this is the SHELL variable and it's not exported, then
1483 add the value from our original environment. */
1484 if (streq (v->name, "SHELL"))
1485 {
1486 extern struct variable shell_var;
1487 v = &shell_var;
1488 break;
1489 }
1490 continue;
1491
1492 case v_ifset:
1493 if (v->origin == o_default)
1494 continue;
1495 break;
1496 }
1497
1498 new_slot = (struct variable **) hash_find_slot (&table, v);
1499 if (HASH_VACANT (*new_slot))
1500 hash_insert_at (&table, v, new_slot);
1501 }
1502 }
1503
1504 makelevel_key.name = MAKELEVEL_NAME;
1505 makelevel_key.length = MAKELEVEL_LENGTH;
1506#ifdef VARIABLE_HASH /* bird */
1507 makelevel_key.hash1 = variable_hash_1i (MAKELEVEL_NAME, MAKELEVEL_LENGTH);
1508 makelevel_key.hash2 = 0;
1509#endif
1510 hash_delete (&table, &makelevel_key);
1511
1512 result = result_0 = xmalloc ((table.ht_fill + 2) * sizeof (char *));
1513
1514 v_slot = (struct variable **) table.ht_vec;
1515 v_end = v_slot + table.ht_size;
1516 for ( ; v_slot < v_end; v_slot++)
1517 if (! HASH_VACANT (*v_slot))
1518 {
1519 struct variable *v = *v_slot;
1520
1521 /* If V is recursively expanded and didn't come from the environment,
1522 expand its value. If it came from the environment, it should
1523 go back into the environment unchanged. */
1524 if (v->recursive
1525 && v->origin != o_env && v->origin != o_env_override)
1526 {
1527 char *value = recursively_expand_for_file (v, file);
1528#ifdef WINDOWS32
1529 if (strcmp(v->name, "Path") == 0 ||
1530 strcmp(v->name, "PATH") == 0)
1531 convert_Path_to_windows32(value, ';');
1532#endif
1533 *result++ = xstrdup (concat (v->name, "=", value));
1534 free (value);
1535 }
1536 else
1537 {
1538#ifdef WINDOWS32
1539 if (strcmp(v->name, "Path") == 0 ||
1540 strcmp(v->name, "PATH") == 0)
1541 convert_Path_to_windows32(v->value, ';');
1542#endif
1543 *result++ = xstrdup (concat (v->name, "=", v->value));
1544 }
1545 }
1546
1547 *result = xmalloc (100);
1548 sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
1549 *++result = 0;
1550
1551 hash_free (&table, 0);
1552
1553 return result_0;
1554}
1555
1556
1557#ifdef CONFIG_WITH_VALUE_LENGTH
1558static struct variable *
1559do_variable_definition_append (const struct floc *flocp, struct variable *v, const char *value,
1560 enum variable_origin origin, int append)
1561{
1562 if (env_overrides && origin == o_env)
1563 origin = o_env_override;
1564
1565 if (env_overrides && v->origin == o_env)
1566 /* V came from in the environment. Since it was defined
1567 before the switches were parsed, it wasn't affected by -e. */
1568 v->origin = o_env_override;
1569
1570 /* A variable of this name is already defined.
1571 If the old definition is from a stronger source
1572 than this one, don't redefine it. */
1573 if ((int) origin < (int) v->origin)
1574 return v;
1575 v->origin = origin;
1576
1577 /* location */
1578 if (flocp != 0)
1579 v->fileinfo = *flocp;
1580
1581 /* The juicy bits, append the specified value to the variable
1582 This is a heavily exercised code path in kBuild. */
1583 if (v->recursive)
1584 {
1585 /* The previous definition of the variable was recursive.
1586 The new value is the unexpanded old and new values. */
1587 unsigned int value_len = strlen (value);
1588 unsigned int new_value_len = value_len + (v->value_length != 0 ? 1 + v->value_length : 0);
1589 int done_1st_prepend_copy = 0;
1590
1591 /* adjust the size. */
1592 if ((unsigned)v->value_alloc_len <= new_value_len + 1)
1593 {
1594 v->value_alloc_len *= 2;
1595 if (v->value_alloc_len < new_value_len + 1)
1596 v->value_alloc_len = (new_value_len + 1 + value_len + 0x7f) + ~0x7fU;
1597 if (append || !v->value_length)
1598 v->value = xrealloc (v->value, v->value_alloc_len);
1599 else
1600 {
1601 /* avoid the extra memcpy the xrealloc may have to do */
1602 char *new_buf = xmalloc (v->value_alloc_len);
1603 memcpy (&new_buf[value_len + 1], v->value, v->value_length + 1);
1604 done_1st_prepend_copy = 1;
1605 free (v->value);
1606 v->value = new_buf;
1607 }
1608 }
1609
1610 /* insert the new bits */
1611 if (v->value_length != 0)
1612 {
1613 if (append)
1614 {
1615 v->value[v->value_length] = ' ';
1616 memcpy (&v->value[v->value_length + 1], value, value_len + 1);
1617 }
1618 else
1619 {
1620 if (!done_1st_prepend_copy)
1621 memmove (&v->value[value_len + 1], v->value, v->value_length + 1);
1622 v->value[value_len] = ' ';
1623 memcpy (v->value, value, value_len);
1624 }
1625 }
1626 else
1627 memcpy (v->value, value, value_len + 1);
1628 v->value_length = new_value_len;
1629 }
1630 else
1631 {
1632 /* The previous definition of the variable was simple.
1633 The new value comes from the old value, which was expanded
1634 when it was set; and from the expanded new value. */
1635 append_expanded_string_to_variable(v, value);
1636 }
1637
1638 /* update the variable */
1639 return v;
1640}
1641#endif /* CONFIG_WITH_VALUE_LENGTH */
1642
1643
1644/* Given a variable, a value, and a flavor, define the variable.
1645 See the try_variable_definition() function for details on the parameters. */
1646
1647struct variable *
1648do_variable_definition (const struct floc *flocp, const char *varname,
1649 const char *value, enum variable_origin origin,
1650 enum variable_flavor flavor, int target_var)
1651{
1652 const char *p;
1653 char *alloc_value = NULL;
1654 struct variable *v;
1655 int append = 0;
1656 int conditional = 0;
1657 const size_t varname_len = strlen (varname); /* bird */
1658#ifdef CONFIG_WITH_VALUE_LENGTH
1659 unsigned int value_len = ~0U;
1660#endif
1661
1662 /* Calculate the variable's new value in VALUE. */
1663
1664 switch (flavor)
1665 {
1666 default:
1667 case f_bogus:
1668 /* Should not be possible. */
1669 abort ();
1670 case f_simple:
1671 /* A simple variable definition "var := value". Expand the value.
1672 We have to allocate memory since otherwise it'll clobber the
1673 variable buffer, and we may still need that if we're looking at a
1674 target-specific variable. */
1675 p = alloc_value = allocated_variable_expand (value);
1676 break;
1677 case f_conditional:
1678 /* A conditional variable definition "var ?= value".
1679 The value is set IFF the variable is not defined yet. */
1680 v = lookup_variable (varname, varname_len);
1681 if (v)
1682 return v;
1683
1684 conditional = 1;
1685 flavor = f_recursive;
1686 /* FALLTHROUGH */
1687 case f_recursive:
1688 /* A recursive variable definition "var = value".
1689 The value is used verbatim. */
1690 p = value;
1691 break;
1692#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1693 case f_append:
1694 case f_prepend:
1695 {
1696 const enum variable_flavor org_flavor = flavor;
1697#else
1698 case f_append:
1699 {
1700#endif
1701
1702#ifdef CONFIG_WITH_LOCAL_VARIABLES
1703 /* If we have += but we're in a target or local variable context,
1704 we want to append only with other variables in the context of
1705 this target. */
1706 if (target_var || origin == o_local)
1707#else
1708 /* If we have += but we're in a target variable context, we want to
1709 append only with other variables in the context of this target. */
1710 if (target_var)
1711#endif
1712 {
1713 append = 1;
1714 v = lookup_variable_in_set (varname, varname_len,
1715 current_variable_set_list->set);
1716
1717 /* Don't append from the global set if a previous non-appending
1718 target-specific variable definition exists. */
1719 if (v && !v->append)
1720 append = 0;
1721 }
1722 else
1723 v = lookup_variable (varname, varname_len);
1724
1725 if (v == 0)
1726 {
1727 /* There was no old value.
1728 This becomes a normal recursive definition. */
1729 p = value;
1730 flavor = f_recursive;
1731 }
1732 else
1733 {
1734#ifdef CONFIG_WITH_VALUE_LENGTH
1735 v->append = append;
1736# ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1737 return do_variable_definition_append (flocp, v, value, origin, org_flavor == f_append);
1738# else
1739 return do_variable_definition_append (flocp, v, value, origin, 1);
1740# endif
1741#else /* !CONFIG_WITH_VALUE_LENGTH */
1742
1743 /* Paste the old and new values together in VALUE. */
1744
1745 unsigned int oldlen, vallen;
1746 const char *val;
1747 char *tp;
1748
1749 val = value;
1750 if (v->recursive)
1751 /* The previous definition of the variable was recursive.
1752 The new value is the unexpanded old and new values. */
1753 flavor = f_recursive;
1754 else
1755 /* The previous definition of the variable was simple.
1756 The new value comes from the old value, which was expanded
1757 when it was set; and from the expanded new value. Allocate
1758 memory for the expansion as we may still need the rest of the
1759 buffer if we're looking at a target-specific variable. */
1760 val = alloc_value = allocated_variable_expand (val);
1761
1762 oldlen = strlen (v->value);
1763 vallen = strlen (val);
1764 tp = alloca (oldlen + 1 + vallen + 1);
1765# ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1766 if (org_flavor == f_prepend)
1767 {
1768 memcpy (tp, val, vallen);
1769 tp[oldlen] = ' ';
1770 memcpy (&tp[oldlen + 1], v->value, oldlen + 1);
1771 }
1772 else
1773# endif /* CONFIG_WITH_PREPEND_ASSIGNMENT */
1774 {
1775 memcpy (tp, v->value, oldlen);
1776 tp[oldlen] = ' ';
1777 memcpy (&tp[oldlen + 1], val, vallen + 1);
1778 }
1779 p = tp;
1780#endif /* !CONFIG_WITH_VALUE_LENGTH */
1781 }
1782 }
1783 }
1784
1785#ifdef __MSDOS__
1786 /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1787 non-Unix systems don't conform to this default configuration (in
1788 fact, most of them don't even have `/bin'). On the other hand,
1789 $SHELL in the environment, if set, points to the real pathname of
1790 the shell.
1791 Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1792 the Makefile override $SHELL from the environment. But first, we
1793 look for the basename of the shell in the directory where SHELL=
1794 points, and along the $PATH; if it is found in any of these places,
1795 we define $SHELL to be the actual pathname of the shell. Thus, if
1796 you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1797 your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1798 defining SHELL to be "d:/unix/bash.exe". */
1799 if ((origin == o_file || origin == o_override)
1800 && strcmp (varname, "SHELL") == 0)
1801 {
1802 PATH_VAR (shellpath);
1803 extern char * __dosexec_find_on_path (const char *, char *[], char *);
1804
1805 /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1806 if (__dosexec_find_on_path (p, NULL, shellpath))
1807 {
1808 char *tp;
1809
1810 for (tp = shellpath; *tp; tp++)
1811 if (*tp == '\\')
1812 *tp = '/';
1813
1814 v = define_variable_loc (varname, varname_len,
1815 shellpath, origin, flavor == f_recursive,
1816 flocp);
1817 }
1818 else
1819 {
1820 const char *shellbase, *bslash;
1821 struct variable *pathv = lookup_variable ("PATH", 4);
1822 char *path_string;
1823 char *fake_env[2];
1824 size_t pathlen = 0;
1825
1826 shellbase = strrchr (p, '/');
1827 bslash = strrchr (p, '\\');
1828 if (!shellbase || bslash > shellbase)
1829 shellbase = bslash;
1830 if (!shellbase && p[1] == ':')
1831 shellbase = p + 1;
1832 if (shellbase)
1833 shellbase++;
1834 else
1835 shellbase = p;
1836
1837 /* Search for the basename of the shell (with standard
1838 executable extensions) along the $PATH. */
1839 if (pathv)
1840 pathlen = strlen (pathv->value);
1841 path_string = xmalloc (5 + pathlen + 2 + 1);
1842 /* On MSDOS, current directory is considered as part of $PATH. */
1843 sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
1844 fake_env[0] = path_string;
1845 fake_env[1] = 0;
1846 if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
1847 {
1848 char *tp;
1849
1850 for (tp = shellpath; *tp; tp++)
1851 if (*tp == '\\')
1852 *tp = '/';
1853
1854 v = define_variable_loc (varname, varname_len,
1855 shellpath, origin,
1856 flavor == f_recursive, flocp);
1857 }
1858 else
1859 v = lookup_variable (varname, varname_len);
1860
1861 free (path_string);
1862 }
1863 }
1864 else
1865#endif /* __MSDOS__ */
1866#ifdef WINDOWS32
1867 if ( varname_len == sizeof("SHELL") - 1 /* bird */
1868 && (origin == o_file || origin == o_override || origin == o_command)
1869 && streq (varname, "SHELL"))
1870 {
1871 extern char *default_shell;
1872
1873 /* Call shell locator function. If it returns TRUE, then
1874 set no_default_sh_exe to indicate sh was found and
1875 set new value for SHELL variable. */
1876
1877 if (find_and_set_default_shell (p))
1878 {
1879 v = define_variable_in_set (varname, varname_len, default_shell,
1880# ifdef CONFIG_WITH_VALUE_LENGTH
1881 ~0U, 1 /* duplicate_value */,
1882# endif
1883 origin, flavor == f_recursive,
1884 (target_var
1885 ? current_variable_set_list->set
1886 : NULL),
1887 flocp);
1888 no_default_sh_exe = 0;
1889 }
1890 else
1891 v = lookup_variable (varname, varname_len);
1892 }
1893 else
1894#endif
1895
1896 /* If we are defining variables inside an $(eval ...), we might have a
1897 different variable context pushed, not the global context (maybe we're
1898 inside a $(call ...) or something. Since this function is only ever
1899 invoked in places where we want to define globally visible variables,
1900 make sure we define this variable in the global set. */
1901
1902 v = define_variable_in_set (varname, varname_len, p,
1903#ifdef CONFIG_WITH_VALUE_LENGTH
1904 value_len, !alloc_value,
1905#endif
1906 origin, flavor == f_recursive,
1907#ifdef CONFIG_WITH_LOCAL_VARIABLES
1908 (target_var || origin == o_local
1909#else
1910 (target_var
1911#endif
1912 ? current_variable_set_list->set : NULL),
1913 flocp);
1914 v->append = append;
1915 v->conditional = conditional;
1916
1917#ifndef CONFIG_WITH_VALUE_LENGTH
1918 if (alloc_value)
1919 free (alloc_value);
1920#endif
1921
1922 return v;
1923}
1924
1925
1926/* Try to interpret LINE (a null-terminated string) as a variable definition.
1927
1928 ORIGIN may be o_file, o_override, o_env, o_env_override,
1929 or o_command specifying that the variable definition comes
1930 from a makefile, an override directive, the environment with
1931 or without the -e switch, or the command line.
1932
1933 See the comments for parse_variable_definition().
1934
1935 If LINE was recognized as a variable definition, a pointer to its `struct
1936 variable' is returned. If LINE is not a variable definition, NULL is
1937 returned. */
1938
1939struct variable *
1940parse_variable_definition (struct variable *v, char *line)
1941{
1942 register int c;
1943 register char *p = line;
1944 register char *beg;
1945 register char *end;
1946 enum variable_flavor flavor = f_bogus;
1947 char *name;
1948
1949 while (1)
1950 {
1951 c = *p++;
1952 if (c == '\0' || c == '#')
1953 return 0;
1954 if (c == '=')
1955 {
1956 end = p - 1;
1957 flavor = f_recursive;
1958 break;
1959 }
1960 else if (c == ':')
1961 if (*p == '=')
1962 {
1963 end = p++ - 1;
1964 flavor = f_simple;
1965 break;
1966 }
1967 else
1968 /* A colon other than := is a rule line, not a variable defn. */
1969 return 0;
1970 else if (c == '+' && *p == '=')
1971 {
1972 end = p++ - 1;
1973 flavor = f_append;
1974 break;
1975 }
1976#ifdef CONFIG_WITH_PREPEND_ASSIGNMENT
1977 else if (c == '<' && *p == '=')
1978 {
1979 end = p++ - 1;
1980 flavor = f_prepend;
1981 break;
1982 }
1983#endif
1984 else if (c == '?' && *p == '=')
1985 {
1986 end = p++ - 1;
1987 flavor = f_conditional;
1988 break;
1989 }
1990 else if (c == '$')
1991 {
1992 /* This might begin a variable expansion reference. Make sure we
1993 don't misrecognize chars inside the reference as =, := or +=. */
1994 char closeparen;
1995 int count;
1996 c = *p++;
1997 if (c == '(')
1998 closeparen = ')';
1999 else if (c == '{')
2000 closeparen = '}';
2001 else
2002 continue; /* Nope. */
2003
2004 /* P now points past the opening paren or brace.
2005 Count parens or braces until it is matched. */
2006 count = 0;
2007 for (; *p != '\0'; ++p)
2008 {
2009 if (*p == c)
2010 ++count;
2011 else if (*p == closeparen && --count < 0)
2012 {
2013 ++p;
2014 break;
2015 }
2016 }
2017 }
2018 }
2019 v->flavor = flavor;
2020
2021 beg = next_token (line);
2022 while (end > beg && isblank ((unsigned char)end[-1]))
2023 --end;
2024 p = next_token (p);
2025 v->value = p;
2026#ifdef CONFIG_WITH_VALUE_LENGTH
2027 v->value_length = v->value_alloc_len = -1;
2028#endif
2029
2030 /* Expand the name, so "$(foo)bar = baz" works. */
2031 name = alloca (end - beg + 1);
2032 memcpy (name, beg, end - beg);
2033 name[end - beg] = '\0';
2034 v->name = allocated_variable_expand (name);
2035
2036 if (v->name[0] == '\0')
2037 fatal (&v->fileinfo, _("empty variable name"));
2038
2039 return v;
2040}
2041
2042
2043/* Try to interpret LINE (a null-terminated string) as a variable definition.
2044
2045 ORIGIN may be o_file, o_override, o_env, o_env_override, o_local,
2046 or o_command specifying that the variable definition comes
2047 from a makefile, an override directive, the environment with
2048 or without the -e switch, or the command line.
2049
2050 See the comments for parse_variable_definition().
2051
2052 If LINE was recognized as a variable definition, a pointer to its `struct
2053 variable' is returned. If LINE is not a variable definition, NULL is
2054 returned. */
2055
2056struct variable *
2057try_variable_definition (const struct floc *flocp, char *line,
2058 enum variable_origin origin, int target_var)
2059{
2060 struct variable v;
2061 struct variable *vp;
2062
2063 if (flocp != 0)
2064 v.fileinfo = *flocp;
2065 else
2066 v.fileinfo.filenm = 0;
2067
2068 if (!parse_variable_definition (&v, line))
2069 return 0;
2070
2071 vp = do_variable_definition (flocp, v.name, v.value,
2072 origin, v.flavor, target_var);
2073
2074 free (v.name);
2075
2076 return vp;
2077}
2078
2079
2080/* Print information for variable V, prefixing it with PREFIX. */
2081
2082static void
2083print_variable (const void *item, void *arg)
2084{
2085 const struct variable *v = item;
2086 const char *prefix = arg;
2087 const char *origin;
2088
2089 switch (v->origin)
2090 {
2091 case o_default:
2092 origin = _("default");
2093 break;
2094 case o_env:
2095 origin = _("environment");
2096 break;
2097 case o_file:
2098 origin = _("makefile");
2099 break;
2100 case o_env_override:
2101 origin = _("environment under -e");
2102 break;
2103 case o_command:
2104 origin = _("command line");
2105 break;
2106 case o_override:
2107 origin = _("`override' directive");
2108 break;
2109 case o_automatic:
2110 origin = _("automatic");
2111 break;
2112#ifdef CONFIG_WITH_LOCAL_VARIABLES
2113 case o_local:
2114 origin = _("`local' directive");
2115 break;
2116#endif
2117 case o_invalid:
2118 default:
2119 abort ();
2120 }
2121 fputs ("# ", stdout);
2122 fputs (origin, stdout);
2123 if (v->fileinfo.filenm)
2124 printf (_(" (from `%s', line %lu)"),
2125 v->fileinfo.filenm, v->fileinfo.lineno);
2126 putchar ('\n');
2127 fputs (prefix, stdout);
2128
2129 /* Is this a `define'? */
2130 if (v->recursive && strchr (v->value, '\n') != 0)
2131 printf ("define %s\n%s\nendef\n", v->name, v->value);
2132 else
2133 {
2134 register char *p;
2135
2136 printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
2137
2138 /* Check if the value is just whitespace. */
2139 p = next_token (v->value);
2140 if (p != v->value && *p == '\0')
2141 /* All whitespace. */
2142 printf ("$(subst ,,%s)", v->value);
2143 else if (v->recursive)
2144 fputs (v->value, stdout);
2145 else
2146 /* Double up dollar signs. */
2147 for (p = v->value; *p != '\0'; ++p)
2148 {
2149 if (*p == '$')
2150 putchar ('$');
2151 putchar (*p);
2152 }
2153 putchar ('\n');
2154 }
2155}
2156
2157
2158/* Print all the variables in SET. PREFIX is printed before
2159 the actual variable definitions (everything else is comments). */
2160
2161void
2162print_variable_set (struct variable_set *set, char *prefix)
2163{
2164 hash_map_arg (&set->table, print_variable, prefix);
2165
2166 fputs (_("# variable set hash-table stats:\n"), stdout);
2167 fputs ("# ", stdout);
2168 hash_print_stats (&set->table, stdout);
2169 putc ('\n', stdout);
2170}
2171
2172/* Print the data base of variables. */
2173
2174void
2175print_variable_data_base (void)
2176{
2177 puts (_("\n# Variables\n"));
2178
2179 print_variable_set (&global_variable_set, "");
2180
2181 puts (_("\n# Pattern-specific Variable Values"));
2182
2183 {
2184 struct pattern_var *p;
2185 int rules = 0;
2186
2187 for (p = pattern_vars; p != 0; p = p->next)
2188 {
2189 ++rules;
2190 printf ("\n%s :\n", p->target);
2191 print_variable (&p->variable, "# ");
2192 }
2193
2194 if (rules == 0)
2195 puts (_("\n# No pattern-specific variable values."));
2196 else
2197 printf (_("\n# %u pattern-specific variable values"), rules);
2198 }
2199}
2200
2201
2202/* Print all the local variables of FILE. */
2203
2204void
2205print_file_variables (const struct file *file)
2206{
2207 if (file->variables != 0)
2208 print_variable_set (file->variables->set, "# ");
2209}
2210
2211#ifdef WINDOWS32
2212void
2213sync_Path_environment (void)
2214{
2215 char *path = allocated_variable_expand ("$(PATH)");
2216 static char *environ_path = NULL;
2217
2218 if (!path)
2219 return;
2220
2221 /*
2222 * If done this before, don't leak memory unnecessarily.
2223 * Free the previous entry before allocating new one.
2224 */
2225 if (environ_path)
2226 free (environ_path);
2227
2228 /*
2229 * Create something WINDOWS32 world can grok
2230 */
2231 convert_Path_to_windows32 (path, ';');
2232 environ_path = xstrdup (concat ("PATH", "=", path));
2233 putenv (environ_path);
2234 free (path);
2235}
2236#endif
Note: See TracBrowser for help on using the repository browser.