VirtualBox

source: kBuild/trunk/src/gmake/variable.c@ 348

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

Added kmk_builtin_append.

  • Property svn:eol-style set to native
File size: 42.2 KB
Line 
1/* Internals of variables for GNU Make.
2Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997,
32002 Free Software Foundation, Inc.
4This file is part of GNU Make.
5
6GNU Make is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU Make is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Make; see the file COPYING. If not, write to
18the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21#include "make.h"
22#include "dep.h"
23#include "filedef.h"
24#include "job.h"
25#include "commands.h"
26#include "variable.h"
27#include "rule.h"
28#ifdef WINDOWS32
29#include "pathstuff.h"
30#endif
31#include "hash.h"
32
33/* Chain of all pattern-specific variables. */
34
35static struct pattern_var *pattern_vars;
36
37/* Pointer to last struct in the chain, so we can add onto the end. */
38
39static struct pattern_var *last_pattern_var;
40
41/* Create a new pattern-specific variable struct. */
42
43struct pattern_var *
44create_pattern_var (char *target, char *suffix)
45{
46 register struct pattern_var *p
47 = (struct pattern_var *) xmalloc (sizeof (struct pattern_var));
48
49 if (last_pattern_var != 0)
50 last_pattern_var->next = p;
51 else
52 pattern_vars = p;
53 last_pattern_var = p;
54 p->next = 0;
55
56 p->target = target;
57 p->len = strlen (target);
58 p->suffix = suffix + 1;
59
60 return p;
61}
62
63/* Look up a target in the pattern-specific variable list. */
64
65static struct pattern_var *
66lookup_pattern_var (struct pattern_var *start, char *target)
67{
68 struct pattern_var *p;
69 unsigned int targlen = strlen(target);
70
71 for (p = start ? start->next : pattern_vars; p != 0; p = p->next)
72 {
73 char *stem;
74 unsigned int stemlen;
75
76 if (p->len > targlen)
77 /* It can't possibly match. */
78 continue;
79
80 /* From the lengths of the filename and the pattern parts,
81 find the stem: the part of the filename that matches the %. */
82 stem = target + (p->suffix - p->target - 1);
83 stemlen = targlen - p->len + 1;
84
85 /* Compare the text in the pattern before the stem, if any. */
86 if (stem > target && !strneq (p->target, target, stem - target))
87 continue;
88
89 /* Compare the text in the pattern after the stem, if any.
90 We could test simply using streq, but this way we compare the
91 first two characters immediately. This saves time in the very
92 common case where the first character matches because it is a
93 period. */
94 if (*p->suffix == stem[stemlen]
95 && (*p->suffix == '\0' || streq (&p->suffix[1], &stem[stemlen+1])))
96 break;
97 }
98
99 return p;
100}
101
102
103/* Hash table of all global variable definitions. */
104
105static unsigned long
106variable_hash_1 (const void *keyv)
107{
108 struct variable const *key = (struct variable const *) keyv;
109 return_STRING_N_HASH_1 (key->name, key->length);
110}
111
112static unsigned long
113variable_hash_2 (const void *keyv)
114{
115 struct variable const *key = (struct variable const *) keyv;
116 return_STRING_N_HASH_2 (key->name, key->length);
117}
118
119static int
120variable_hash_cmp (const void *xv, const void *yv)
121{
122 struct variable const *x = (struct variable const *) xv;
123 struct variable const *y = (struct variable const *) yv;
124 int result = x->length - y->length;
125 if (result)
126 return result;
127 return_STRING_N_COMPARE (x->name, y->name, x->length);
128}
129
130#ifndef VARIABLE_BUCKETS
131#define VARIABLE_BUCKETS 523
132#endif
133#ifndef PERFILE_VARIABLE_BUCKETS
134#define PERFILE_VARIABLE_BUCKETS 23
135#endif
136#ifndef SMALL_SCOPE_VARIABLE_BUCKETS
137#define SMALL_SCOPE_VARIABLE_BUCKETS 13
138#endif
139
140static struct variable_set global_variable_set;
141static struct variable_set_list global_setlist
142 = { 0, &global_variable_set };
143struct variable_set_list *current_variable_set_list = &global_setlist;
144
145
146/* Implement variables. */
147
148void
149init_hash_global_variable_set (void)
150{
151 hash_init (&global_variable_set.table, VARIABLE_BUCKETS,
152 variable_hash_1, variable_hash_2, variable_hash_cmp);
153}
154
155/* Define variable named NAME with value VALUE in SET. VALUE is copied.
156 LENGTH is the length of NAME, which does not need to be null-terminated.
157 ORIGIN specifies the origin of the variable (makefile, command line
158 or environment).
159 If RECURSIVE is nonzero a flag is set in the variable saying
160 that it should be recursively re-expanded. */
161
162struct variable *
163define_variable_in_set (const char *name, unsigned int length,
164 char *value, enum variable_origin origin,
165 int recursive, struct variable_set *set,
166 const struct floc *flocp)
167{
168 struct variable *v;
169 struct variable **var_slot;
170 struct variable var_key;
171
172 if (set == NULL)
173 set = &global_variable_set;
174
175 var_key.name = (char *) name;
176 var_key.length = length;
177 var_slot = (struct variable **) hash_find_slot (&set->table, &var_key);
178
179 if (env_overrides && origin == o_env)
180 origin = o_env_override;
181
182 v = *var_slot;
183 if (! HASH_VACANT (v))
184 {
185 if (env_overrides && v->origin == o_env)
186 /* V came from in the environment. Since it was defined
187 before the switches were parsed, it wasn't affected by -e. */
188 v->origin = o_env_override;
189
190 /* A variable of this name is already defined.
191 If the old definition is from a stronger source
192 than this one, don't redefine it. */
193 if ((int) origin >= (int) v->origin)
194 {
195 if (v->value != 0)
196 free (v->value);
197 v->value = xstrdup (value);
198 if (flocp != 0)
199 v->fileinfo = *flocp;
200 else
201 v->fileinfo.filenm = 0;
202 v->origin = origin;
203 v->recursive = recursive;
204 }
205 return v;
206 }
207
208 /* Create a new variable definition and add it to the hash table. */
209
210 v = (struct variable *) xmalloc (sizeof (struct variable));
211 v->name = savestring (name, length);
212 v->length = length;
213 hash_insert_at (&set->table, v, var_slot);
214 v->value = xstrdup (value);
215 if (flocp != 0)
216 v->fileinfo = *flocp;
217 else
218 v->fileinfo.filenm = 0;
219 v->origin = origin;
220 v->recursive = recursive;
221 v->special = 0;
222 v->expanding = 0;
223 v->exp_count = 0;
224 v->per_target = 0;
225 v->append = 0;
226 v->export = v_default;
227
228 v->exportable = 1;
229 if (*name != '_' && (*name < 'A' || *name > 'Z')
230 && (*name < 'a' || *name > 'z'))
231 v->exportable = 0;
232 else
233 {
234 for (++name; *name != '\0'; ++name)
235 if (*name != '_' && (*name < 'a' || *name > 'z')
236 && (*name < 'A' || *name > 'Z') && !ISDIGIT(*name))
237 break;
238
239 if (*name != '\0')
240 v->exportable = 0;
241 }
242
243 return v;
244}
245
246
247/* If the variable passed in is "special", handle its special nature.
248 Currently there are two such variables, both used for introspection:
249 .VARIABLES expands to a list of all the variables defined in this instance
250 of make.
251 .TARGETS expands to a list of all the targets defined in this
252 instance of make.
253 Returns the variable reference passed in. */
254
255#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
256
257static struct variable *
258handle_special_var (struct variable *var)
259{
260 static unsigned long last_var_count = 0;
261
262
263 /* This one actually turns out to be very hard, due to the way the parser
264 records targets. The way it works is that target information is collected
265 internally until make knows the target is completely specified. It unitl
266 it sees that some new construct (a new target or variable) is defined that
267 it knows the previous one is done. In short, this means that if you do
268 this:
269
270 all:
271
272 TARGS := $(.TARGETS)
273
274 then $(TARGS) won't contain "all", because it's not until after the
275 variable is created that the previous target is completed.
276
277 Changing this would be a major pain. I think a less complex way to do it
278 would be to pre-define the target files as soon as the first line is
279 parsed, then come back and do the rest of the definition as now. That
280 would allow $(.TARGETS) to be correct without a major change to the way
281 the parser works.
282
283 if (streq (var->name, ".TARGETS"))
284 var->value = build_target_list (var->value);
285 else
286 */
287
288 if (streq (var->name, ".VARIABLES")
289 && global_variable_set.table.ht_fill != last_var_count)
290 {
291 unsigned long max = EXPANSION_INCREMENT (strlen (var->value));
292 unsigned long len;
293 char *p;
294 struct variable **vp = (struct variable **) global_variable_set.table.ht_vec;
295 struct variable **end = &vp[global_variable_set.table.ht_size];
296
297 /* Make sure we have at least MAX bytes in the allocated buffer. */
298 var->value = xrealloc (var->value, max);
299
300 /* Walk through the hash of variables, constructing a list of names. */
301 p = var->value;
302 len = 0;
303 for (; vp < end; ++vp)
304 if (!HASH_VACANT (*vp))
305 {
306 struct variable *v = *vp;
307 int l = v->length;
308
309 len += l + 1;
310 if (len > max)
311 {
312 unsigned long off = p - var->value;
313
314 max += EXPANSION_INCREMENT (l + 1);
315 var->value = xrealloc (var->value, max);
316 p = &var->value[off];
317 }
318
319 bcopy (v->name, p, l);
320 p += l;
321 *(p++) = ' ';
322 }
323 *(p-1) = '\0';
324
325 /* Remember how many variables are in our current count. Since we never
326 remove variables from the list, this is a reliable way to know whether
327 the list is up to date or needs to be recomputed. */
328
329 last_var_count = global_variable_set.table.ht_fill;
330 }
331
332 return var;
333}
334
335
336
337/* Lookup a variable whose name is a string starting at NAME
338 and with LENGTH chars. NAME need not be null-terminated.
339 Returns address of the `struct variable' containing all info
340 on the variable, or nil if no such variable is defined. */
341
342struct variable *
343lookup_variable (const char *name, unsigned int length)
344{
345 const struct variable_set_list *setlist;
346 struct variable var_key;
347
348 var_key.name = (char *) name;
349 var_key.length = length;
350
351 for (setlist = current_variable_set_list;
352 setlist != 0; setlist = setlist->next)
353 {
354 const struct variable_set *set = setlist->set;
355 struct variable *v;
356
357 v = (struct variable *) hash_find_item ((struct hash_table *) &set->table, &var_key);
358 if (v)
359 return v->special ? handle_special_var (v) : v;
360 }
361
362#ifdef VMS
363 /* since we don't read envp[] on startup, try to get the
364 variable via getenv() here. */
365 {
366 char *vname = alloca (length + 1);
367 char *value;
368 strncpy (vname, name, length);
369 vname[length] = 0;
370 value = getenv (vname);
371 if (value != 0)
372 {
373 char *sptr;
374 int scnt;
375
376 sptr = value;
377 scnt = 0;
378
379 while ((sptr = strchr (sptr, '$')))
380 {
381 scnt++;
382 sptr++;
383 }
384
385 if (scnt > 0)
386 {
387 char *nvalue;
388 char *nptr;
389
390 nvalue = alloca (strlen (value) + scnt + 1);
391 sptr = value;
392 nptr = nvalue;
393
394 while (*sptr)
395 {
396 if (*sptr == '$')
397 {
398 *nptr++ = '$';
399 *nptr++ = '$';
400 }
401 else
402 {
403 *nptr++ = *sptr;
404 }
405 sptr++;
406 }
407
408 *nptr = '\0';
409 return define_variable (vname, length, nvalue, o_env, 1);
410
411 }
412
413 return define_variable (vname, length, value, o_env, 1);
414 }
415 }
416#endif /* VMS */
417
418 return 0;
419}
420
421
422/* Lookup a variable whose name is a string starting at NAME
423 and with LENGTH chars in set SET. NAME need not be null-terminated.
424 Returns address of the `struct variable' containing all info
425 on the variable, or nil if no such variable is defined. */
426
427struct variable *
428lookup_variable_in_set (const char *name, unsigned int length,
429 const struct variable_set *set)
430{
431 struct variable var_key;
432
433 var_key.name = (char *) name;
434 var_key.length = length;
435
436 return (struct variable *) hash_find_item ((struct hash_table *) &set->table, &var_key);
437}
438
439
440/* Initialize FILE's variable set list. If FILE already has a variable set
441 list, the topmost variable set is left intact, but the the rest of the
442 chain is replaced with FILE->parent's setlist. If FILE is a double-colon
443 rule, then we will use the "root" double-colon target's variable set as the
444 parent of FILE's variable set.
445
446 If we're READing a makefile, don't do the pattern variable search now,
447 since the pattern variable might not have been defined yet. */
448
449void
450initialize_file_variables (struct file *file, int reading)
451{
452 register struct variable_set_list *l = file->variables;
453
454 if (l == 0)
455 {
456 l = (struct variable_set_list *)
457 xmalloc (sizeof (struct variable_set_list));
458 l->set = (struct variable_set *) xmalloc (sizeof (struct variable_set));
459 hash_init (&l->set->table, PERFILE_VARIABLE_BUCKETS,
460 variable_hash_1, variable_hash_2, variable_hash_cmp);
461 file->variables = l;
462 }
463
464 /* If this is a double-colon, then our "parent" is the "root" target for
465 this double-colon rule. Since that rule has the same name, parent,
466 etc. we can just use its variables as the "next" for ours. */
467
468 if (file->double_colon && file->double_colon != file)
469 {
470 initialize_file_variables (file->double_colon, reading);
471 l->next = file->double_colon->variables;
472 return;
473 }
474
475 if (file->parent == 0)
476 l->next = &global_setlist;
477 else
478 {
479 initialize_file_variables (file->parent, reading);
480 l->next = file->parent->variables;
481 }
482
483 /* If we're not reading makefiles and we haven't looked yet, see if
484 we can find pattern variables for this target. */
485
486 if (!reading && !file->pat_searched)
487 {
488 struct pattern_var *p;
489
490 p = lookup_pattern_var (0, file->name);
491 if (p != 0)
492 {
493 struct variable_set_list *global = current_variable_set_list;
494
495 /* We found at least one. Set up a new variable set to accumulate
496 all the pattern variables that match this target. */
497
498 file->pat_variables = create_new_variable_set ();
499 current_variable_set_list = file->pat_variables;
500
501 do
502 {
503 /* We found one, so insert it into the set. */
504
505 struct variable *v;
506
507 if (p->variable.flavor == f_simple)
508 {
509 v = define_variable_loc (
510 p->variable.name, strlen (p->variable.name),
511 p->variable.value, p->variable.origin,
512 0, &p->variable.fileinfo);
513
514 v->flavor = f_simple;
515 }
516 else
517 {
518 v = do_variable_definition (
519 &p->variable.fileinfo, p->variable.name,
520 p->variable.value, p->variable.origin,
521 p->variable.flavor, 1);
522 }
523
524 /* Also mark it as a per-target and copy export status. */
525 v->per_target = p->variable.per_target;
526 v->export = p->variable.export;
527 }
528 while ((p = lookup_pattern_var (p, file->name)) != 0);
529
530 current_variable_set_list = global;
531 }
532 file->pat_searched = 1;
533 }
534
535 /* If we have a pattern variable match, set it up. */
536
537 if (file->pat_variables != 0)
538 {
539 file->pat_variables->next = l->next;
540 l->next = file->pat_variables;
541 }
542}
543
544
545/* Pop the top set off the current variable set list,
546 and free all its storage. */
547
548static void
549free_variable_name_and_value (const void *item)
550{
551 struct variable *v = (struct variable *) item;
552 free (v->name);
553 free (v->value);
554}
555
556void
557pop_variable_scope (void)
558{
559 struct variable_set_list *setlist = current_variable_set_list;
560 struct variable_set *set = setlist->set;
561
562 current_variable_set_list = setlist->next;
563 free ((char *) setlist);
564
565 hash_map (&set->table, free_variable_name_and_value);
566 hash_free (&set->table, 1);
567
568 free ((char *) set);
569}
570
571struct variable_set_list *
572create_new_variable_set (void)
573{
574 register struct variable_set_list *setlist;
575 register struct variable_set *set;
576
577 set = (struct variable_set *) xmalloc (sizeof (struct variable_set));
578 hash_init (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
579 variable_hash_1, variable_hash_2, variable_hash_cmp);
580
581 setlist = (struct variable_set_list *)
582 xmalloc (sizeof (struct variable_set_list));
583 setlist->set = set;
584 setlist->next = current_variable_set_list;
585
586 return setlist;
587}
588
589/* Create a new variable set and push it on the current setlist. */
590
591struct variable_set_list *
592push_new_variable_scope (void)
593{
594 return (current_variable_set_list = create_new_variable_set());
595}
596
597
598/* Merge FROM_SET into TO_SET, freeing unused storage in FROM_SET. */
599
600static void
601merge_variable_sets (struct variable_set *to_set,
602 struct variable_set *from_set)
603{
604 struct variable **from_var_slot = (struct variable **) from_set->table.ht_vec;
605 struct variable **from_var_end = from_var_slot + from_set->table.ht_size;
606
607 for ( ; from_var_slot < from_var_end; from_var_slot++)
608 if (! HASH_VACANT (*from_var_slot))
609 {
610 struct variable *from_var = *from_var_slot;
611 struct variable **to_var_slot
612 = (struct variable **) hash_find_slot (&to_set->table, *from_var_slot);
613 if (HASH_VACANT (*to_var_slot))
614 hash_insert_at (&to_set->table, from_var, to_var_slot);
615 else
616 {
617 /* GKM FIXME: delete in from_set->table */
618 free (from_var->value);
619 free (from_var);
620 }
621 }
622}
623
624/* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */
625
626void
627merge_variable_set_lists (struct variable_set_list **setlist0,
628 struct variable_set_list *setlist1)
629{
630 register struct variable_set_list *list0 = *setlist0;
631 struct variable_set_list *last0 = 0;
632
633 while (setlist1 != 0 && list0 != 0)
634 {
635 struct variable_set_list *next = setlist1;
636 setlist1 = setlist1->next;
637
638 merge_variable_sets (list0->set, next->set);
639
640 last0 = list0;
641 list0 = list0->next;
642 }
643
644 if (setlist1 != 0)
645 {
646 if (last0 == 0)
647 *setlist0 = setlist1;
648 else
649 last0->next = setlist1;
650 }
651}
652
653
654/* Define the automatic variables, and record the addresses
655 of their structures so we can change their values quickly. */
656
657void
658define_automatic_variables (void)
659{
660#if defined(WINDOWS32) || defined(__EMX__)
661 extern char* default_shell;
662#else
663 extern char default_shell[];
664#endif
665 register struct variable *v;
666 char buf[200];
667
668 sprintf (buf, "%u", makelevel);
669 (void) define_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH, buf, o_env, 0);
670
671 sprintf (buf, "%s%s%s",
672 version_string,
673 (remote_description == 0 || remote_description[0] == '\0')
674 ? "" : "-",
675 (remote_description == 0 || remote_description[0] == '\0')
676 ? "" : remote_description);
677 (void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0);
678
679 /* Define KMK_VERSION to indicate kMk. */
680 (void) define_variable ("KMK_VERSION", 11, buf, o_default, 0);
681
682 /* Define KMK_FEATURES to indicate various working KMK features. */
683 (void) define_variable ("KMK_FEATURES", 12, "abspath toupper tolower", o_default, 0);
684
685#ifdef CONFIG_WITH_KMK_BUILTIN
686 /* The kMk Builtin Level. */
687 (void) define_variable ("KMK_BUILTIN", 11, "2", o_default, 0);
688#endif
689
690#ifdef __MSDOS__
691 /* Allow to specify a special shell just for Make,
692 and use $COMSPEC as the default $SHELL when appropriate. */
693 {
694 static char shell_str[] = "SHELL";
695 const int shlen = sizeof (shell_str) - 1;
696 struct variable *mshp = lookup_variable ("MAKESHELL", 9);
697 struct variable *comp = lookup_variable ("COMSPEC", 7);
698
699 /* Make $MAKESHELL override $SHELL even if -e is in effect. */
700 if (mshp)
701 (void) define_variable (shell_str, shlen,
702 mshp->value, o_env_override, 0);
703 else if (comp)
704 {
705 /* $COMSPEC shouldn't override $SHELL. */
706 struct variable *shp = lookup_variable (shell_str, shlen);
707
708 if (!shp)
709 (void) define_variable (shell_str, shlen, comp->value, o_env, 0);
710 }
711 }
712#elif defined(__EMX__)
713 {
714 static char shell_str[] = "SHELL";
715 const int shlen = sizeof (shell_str) - 1;
716 struct variable *shell = lookup_variable (shell_str, shlen);
717 struct variable *replace = lookup_variable ("MAKESHELL", 9);
718
719 /* if $MAKESHELL is defined in the environment assume o_env_override */
720 if (replace && *replace->value && replace->origin == o_env)
721 replace->origin = o_env_override;
722
723 /* if $MAKESHELL is not defined use $SHELL but only if the variable
724 did not come from the environment */
725 if (!replace || !*replace->value)
726 if (shell && *shell->value && (shell->origin == o_env
727 || shell->origin == o_env_override))
728 {
729 /* overwrite whatever we got from the environment */
730 free(shell->value);
731 shell->value = xstrdup (default_shell);
732 shell->origin = o_default;
733 }
734
735 /* Some people do not like cmd to be used as the default
736 if $SHELL is not defined in the Makefile.
737 With -DNO_CMD_DEFAULT you can turn off this behaviour */
738# ifndef NO_CMD_DEFAULT
739 /* otherwise use $COMSPEC */
740 if (!replace || !*replace->value)
741 replace = lookup_variable ("COMSPEC", 7);
742
743 /* otherwise use $OS2_SHELL */
744 if (!replace || !*replace->value)
745 replace = lookup_variable ("OS2_SHELL", 9);
746# else
747# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
748# endif
749
750 if (replace && *replace->value)
751 /* overwrite $SHELL */
752 (void) define_variable (shell_str, shlen, replace->value,
753 replace->origin, 0);
754 else
755 /* provide a definition if there is none */
756 (void) define_variable (shell_str, shlen, default_shell,
757 o_default, 0);
758 }
759
760#endif
761
762 /* This won't override any definition, but it will provide one if there
763 isn't one there. */
764 v = define_variable ("SHELL", 5, default_shell, o_default, 0);
765
766 /* On MSDOS we do use SHELL from environment, since it isn't a standard
767 environment variable on MSDOS, so whoever sets it, does that on purpose.
768 On OS/2 we do not use SHELL from environment but we have already handled
769 that problem above. */
770#if !defined(__MSDOS__) && !defined(__EMX__)
771 /* Don't let SHELL come from the environment. */
772 if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override)
773 {
774 free (v->value);
775 v->origin = o_file;
776 v->value = xstrdup (default_shell);
777 }
778#endif
779
780 /* Make sure MAKEFILES gets exported if it is set. */
781 v = define_variable ("MAKEFILES", 9, "", o_default, 0);
782 v->export = v_ifset;
783
784 /* Define the magic D and F variables in terms of
785 the automatic variables they are variations of. */
786
787#ifdef VMS
788 define_variable ("@D", 2, "$(dir $@)", o_automatic, 1);
789 define_variable ("%D", 2, "$(dir $%)", o_automatic, 1);
790 define_variable ("*D", 2, "$(dir $*)", o_automatic, 1);
791 define_variable ("<D", 2, "$(dir $<)", o_automatic, 1);
792 define_variable ("?D", 2, "$(dir $?)", o_automatic, 1);
793 define_variable ("^D", 2, "$(dir $^)", o_automatic, 1);
794 define_variable ("+D", 2, "$(dir $+)", o_automatic, 1);
795#else
796 define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
797 define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
798 define_variable ("*D", 2, "$(patsubst %/,%,$(dir $*))", o_automatic, 1);
799 define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
800 define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
801 define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
802 define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
803#endif
804 define_variable ("@F", 2, "$(notdir $@)", o_automatic, 1);
805 define_variable ("%F", 2, "$(notdir $%)", o_automatic, 1);
806 define_variable ("*F", 2, "$(notdir $*)", o_automatic, 1);
807 define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
808 define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
809 define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
810 define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
811}
812
813
814int export_all_variables;
815
816/* Create a new environment for FILE's commands.
817 If FILE is nil, this is for the `shell' function.
818 The child's MAKELEVEL variable is incremented. */
819
820char **
821target_environment (struct file *file)
822{
823 struct variable_set_list *set_list;
824 register struct variable_set_list *s;
825 struct hash_table table;
826 struct variable **v_slot;
827 struct variable **v_end;
828 struct variable makelevel_key;
829 char **result_0;
830 char **result;
831
832 if (file == 0)
833 set_list = current_variable_set_list;
834 else
835 set_list = file->variables;
836
837 hash_init (&table, VARIABLE_BUCKETS,
838 variable_hash_1, variable_hash_2, variable_hash_cmp);
839
840 /* Run through all the variable sets in the list,
841 accumulating variables in TABLE. */
842 for (s = set_list; s != 0; s = s->next)
843 {
844 struct variable_set *set = s->set;
845 v_slot = (struct variable **) set->table.ht_vec;
846 v_end = v_slot + set->table.ht_size;
847 for ( ; v_slot < v_end; v_slot++)
848 if (! HASH_VACANT (*v_slot))
849 {
850 struct variable **new_slot;
851 struct variable *v = *v_slot;
852
853 /* If this is a per-target variable and it hasn't been touched
854 already then look up the global version and take its export
855 value. */
856 if (v->per_target && v->export == v_default)
857 {
858 struct variable *gv;
859
860 gv = lookup_variable_in_set (v->name, strlen(v->name),
861 &global_variable_set);
862 if (gv)
863 v->export = gv->export;
864 }
865
866 switch (v->export)
867 {
868 case v_default:
869 if (v->origin == o_default || v->origin == o_automatic)
870 /* Only export default variables by explicit request. */
871 continue;
872
873 /* The variable doesn't have a name that can be exported. */
874 if (! v->exportable)
875 continue;
876
877 if (! export_all_variables
878 && v->origin != o_command
879 && v->origin != o_env && v->origin != o_env_override)
880 continue;
881 break;
882
883 case v_export:
884 break;
885
886 case v_noexport:
887 /* If this is the SHELL variable and it's not exported, then
888 add the value from our original environment. */
889 if (streq (v->name, "SHELL"))
890 {
891 extern struct variable shell_var;
892 v = &shell_var;
893 break;
894 }
895 continue;
896
897 case v_ifset:
898 if (v->origin == o_default)
899 continue;
900 break;
901 }
902
903 new_slot = (struct variable **) hash_find_slot (&table, v);
904 if (HASH_VACANT (*new_slot))
905 hash_insert_at (&table, v, new_slot);
906 }
907 }
908
909 makelevel_key.name = MAKELEVEL_NAME;
910 makelevel_key.length = MAKELEVEL_LENGTH;
911 hash_delete (&table, &makelevel_key);
912
913 result = result_0 = (char **) xmalloc ((table.ht_fill + 2) * sizeof (char *));
914
915 v_slot = (struct variable **) table.ht_vec;
916 v_end = v_slot + table.ht_size;
917 for ( ; v_slot < v_end; v_slot++)
918 if (! HASH_VACANT (*v_slot))
919 {
920 struct variable *v = *v_slot;
921
922 /* If V is recursively expanded and didn't come from the environment,
923 expand its value. If it came from the environment, it should
924 go back into the environment unchanged. */
925 if (v->recursive
926 && v->origin != o_env && v->origin != o_env_override)
927 {
928 char *value = recursively_expand_for_file (v, file);
929#ifdef WINDOWS32
930 if (strcmp(v->name, "Path") == 0 ||
931 strcmp(v->name, "PATH") == 0)
932 convert_Path_to_windows32(value, ';');
933#endif
934 *result++ = concat (v->name, "=", value);
935 free (value);
936 }
937 else
938 {
939#ifdef WINDOWS32
940 if (strcmp(v->name, "Path") == 0 ||
941 strcmp(v->name, "PATH") == 0)
942 convert_Path_to_windows32(v->value, ';');
943#endif
944 *result++ = concat (v->name, "=", v->value);
945 }
946 }
947
948 *result = (char *) xmalloc (100);
949 (void) sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
950 *++result = 0;
951
952 hash_free (&table, 0);
953
954 return result_0;
955}
956
957
958/* Given a variable, a value, and a flavor, define the variable.
959 See the try_variable_definition() function for details on the parameters. */
960
961struct variable *
962do_variable_definition (const struct floc *flocp, const char *varname,
963 char *value, enum variable_origin origin,
964 enum variable_flavor flavor, int target_var)
965{
966 char *p, *alloc_value = NULL;
967 struct variable *v;
968 int append = 0;
969 int conditional = 0;
970
971 /* Calculate the variable's new value in VALUE. */
972
973 switch (flavor)
974 {
975 default:
976 case f_bogus:
977 /* Should not be possible. */
978 abort ();
979 case f_simple:
980 /* A simple variable definition "var := value". Expand the value.
981 We have to allocate memory since otherwise it'll clobber the
982 variable buffer, and we may still need that if we're looking at a
983 target-specific variable. */
984 p = alloc_value = allocated_variable_expand (value);
985 break;
986 case f_conditional:
987 /* A conditional variable definition "var ?= value".
988 The value is set IFF the variable is not defined yet. */
989 v = lookup_variable (varname, strlen (varname));
990 if (v)
991 return v;
992
993 conditional = 1;
994 flavor = f_recursive;
995 /* FALLTHROUGH */
996 case f_recursive:
997 /* A recursive variable definition "var = value".
998 The value is used verbatim. */
999 p = value;
1000 break;
1001 case f_append:
1002 {
1003 /* If we have += but we're in a target variable context, we want to
1004 append only with other variables in the context of this target. */
1005 if (target_var)
1006 {
1007 append = 1;
1008 v = lookup_variable_in_set (varname, strlen (varname),
1009 current_variable_set_list->set);
1010
1011 /* Don't append from the global set if a previous non-appending
1012 target-specific variable definition exists. */
1013 if (v && !v->append)
1014 append = 0;
1015 }
1016 else
1017 v = lookup_variable (varname, strlen (varname));
1018
1019 if (v == 0)
1020 {
1021 /* There was no old value.
1022 This becomes a normal recursive definition. */
1023 p = value;
1024 flavor = f_recursive;
1025 }
1026 else
1027 {
1028 /* Paste the old and new values together in VALUE. */
1029
1030 unsigned int oldlen, vallen;
1031 char *val;
1032
1033 val = value;
1034 if (v->recursive)
1035 /* The previous definition of the variable was recursive.
1036 The new value is the unexpanded old and new values. */
1037 flavor = f_recursive;
1038 else
1039 /* The previous definition of the variable was simple.
1040 The new value comes from the old value, which was expanded
1041 when it was set; and from the expanded new value. Allocate
1042 memory for the expansion as we may still need the rest of the
1043 buffer if we're looking at a target-specific variable. */
1044 val = alloc_value = allocated_variable_expand (val);
1045
1046 oldlen = strlen (v->value);
1047 vallen = strlen (val);
1048 p = (char *) alloca (oldlen + 1 + vallen + 1);
1049 bcopy (v->value, p, oldlen);
1050 p[oldlen] = ' ';
1051 bcopy (val, &p[oldlen + 1], vallen + 1);
1052 }
1053 }
1054 }
1055
1056#ifdef __MSDOS__
1057 /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1058 non-Unix systems don't conform to this default configuration (in
1059 fact, most of them don't even have `/bin'). On the other hand,
1060 $SHELL in the environment, if set, points to the real pathname of
1061 the shell.
1062 Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1063 the Makefile override $SHELL from the environment. But first, we
1064 look for the basename of the shell in the directory where SHELL=
1065 points, and along the $PATH; if it is found in any of these places,
1066 we define $SHELL to be the actual pathname of the shell. Thus, if
1067 you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1068 your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1069 defining SHELL to be "d:/unix/bash.exe". */
1070 if ((origin == o_file || origin == o_override)
1071 && strcmp (varname, "SHELL") == 0)
1072 {
1073 PATH_VAR (shellpath);
1074 extern char * __dosexec_find_on_path (const char *, char *[], char *);
1075
1076 /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1077 if (__dosexec_find_on_path (p, (char **)0, shellpath))
1078 {
1079 char *p;
1080
1081 for (p = shellpath; *p; p++)
1082 {
1083 if (*p == '\\')
1084 *p = '/';
1085 }
1086 v = define_variable_loc (varname, strlen (varname),
1087 shellpath, origin, flavor == f_recursive,
1088 flocp);
1089 }
1090 else
1091 {
1092 char *shellbase, *bslash;
1093 struct variable *pathv = lookup_variable ("PATH", 4);
1094 char *path_string;
1095 char *fake_env[2];
1096 size_t pathlen = 0;
1097
1098 shellbase = strrchr (p, '/');
1099 bslash = strrchr (p, '\\');
1100 if (!shellbase || bslash > shellbase)
1101 shellbase = bslash;
1102 if (!shellbase && p[1] == ':')
1103 shellbase = p + 1;
1104 if (shellbase)
1105 shellbase++;
1106 else
1107 shellbase = p;
1108
1109 /* Search for the basename of the shell (with standard
1110 executable extensions) along the $PATH. */
1111 if (pathv)
1112 pathlen = strlen (pathv->value);
1113 path_string = (char *)xmalloc (5 + pathlen + 2 + 1);
1114 /* On MSDOS, current directory is considered as part of $PATH. */
1115 sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
1116 fake_env[0] = path_string;
1117 fake_env[1] = (char *)0;
1118 if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
1119 {
1120 char *p;
1121
1122 for (p = shellpath; *p; p++)
1123 {
1124 if (*p == '\\')
1125 *p = '/';
1126 }
1127 v = define_variable_loc (varname, strlen (varname),
1128 shellpath, origin,
1129 flavor == f_recursive, flocp);
1130 }
1131 else
1132 v = lookup_variable (varname, strlen (varname));
1133
1134 free (path_string);
1135 }
1136 }
1137 else
1138#endif /* __MSDOS__ */
1139#ifdef WINDOWS32
1140 if ((origin == o_file || origin == o_override) && streq (varname, "SHELL"))
1141 {
1142 extern char *default_shell;
1143
1144 /* Call shell locator function. If it returns TRUE, then
1145 set no_default_sh_exe to indicate sh was found and
1146 set new value for SHELL variable. */
1147
1148 if (find_and_set_default_shell (p))
1149 {
1150 v = define_variable_in_set (varname, strlen (varname), default_shell,
1151 origin, flavor == f_recursive,
1152 (target_var
1153 ? current_variable_set_list->set
1154 : NULL),
1155 flocp);
1156 no_default_sh_exe = 0;
1157 }
1158 else
1159 v = lookup_variable (varname, strlen (varname));
1160 }
1161 else
1162#endif
1163
1164 /* If we are defining variables inside an $(eval ...), we might have a
1165 different variable context pushed, not the global context (maybe we're
1166 inside a $(call ...) or something. Since this function is only ever
1167 invoked in places where we want to define globally visible variables,
1168 make sure we define this variable in the global set. */
1169
1170 v = define_variable_in_set (varname, strlen (varname), p,
1171 origin, flavor == f_recursive,
1172 (target_var
1173 ? current_variable_set_list->set : NULL),
1174 flocp);
1175 v->append = append;
1176 v->conditional = conditional;
1177
1178 if (alloc_value)
1179 free (alloc_value);
1180
1181 return v;
1182}
1183
1184
1185/* Try to interpret LINE (a null-terminated string) as a variable definition.
1186
1187 ORIGIN may be o_file, o_override, o_env, o_env_override,
1188 or o_command specifying that the variable definition comes
1189 from a makefile, an override directive, the environment with
1190 or without the -e switch, or the command line.
1191
1192 See the comments for parse_variable_definition().
1193
1194 If LINE was recognized as a variable definition, a pointer to its `struct
1195 variable' is returned. If LINE is not a variable definition, NULL is
1196 returned. */
1197
1198struct variable *
1199parse_variable_definition (struct variable *v, char *line)
1200{
1201 register int c;
1202 register char *p = line;
1203 register char *beg;
1204 register char *end;
1205 enum variable_flavor flavor = f_bogus;
1206 char *name;
1207
1208 while (1)
1209 {
1210 c = *p++;
1211 if (c == '\0' || c == '#')
1212 return 0;
1213 if (c == '=')
1214 {
1215 end = p - 1;
1216 flavor = f_recursive;
1217 break;
1218 }
1219 else if (c == ':')
1220 if (*p == '=')
1221 {
1222 end = p++ - 1;
1223 flavor = f_simple;
1224 break;
1225 }
1226 else
1227 /* A colon other than := is a rule line, not a variable defn. */
1228 return 0;
1229 else if (c == '+' && *p == '=')
1230 {
1231 end = p++ - 1;
1232 flavor = f_append;
1233 break;
1234 }
1235 else if (c == '?' && *p == '=')
1236 {
1237 end = p++ - 1;
1238 flavor = f_conditional;
1239 break;
1240 }
1241 else if (c == '$')
1242 {
1243 /* This might begin a variable expansion reference. Make sure we
1244 don't misrecognize chars inside the reference as =, := or +=. */
1245 char closeparen;
1246 int count;
1247 c = *p++;
1248 if (c == '(')
1249 closeparen = ')';
1250 else if (c == '{')
1251 closeparen = '}';
1252 else
1253 continue; /* Nope. */
1254
1255 /* P now points past the opening paren or brace.
1256 Count parens or braces until it is matched. */
1257 count = 0;
1258 for (; *p != '\0'; ++p)
1259 {
1260 if (*p == c)
1261 ++count;
1262 else if (*p == closeparen && --count < 0)
1263 {
1264 ++p;
1265 break;
1266 }
1267 }
1268 }
1269 }
1270 v->flavor = flavor;
1271
1272 beg = next_token (line);
1273 while (end > beg && isblank ((unsigned char)end[-1]))
1274 --end;
1275 p = next_token (p);
1276 v->value = p;
1277
1278 /* Expand the name, so "$(foo)bar = baz" works. */
1279 name = (char *) alloca (end - beg + 1);
1280 bcopy (beg, name, end - beg);
1281 name[end - beg] = '\0';
1282 v->name = allocated_variable_expand (name);
1283
1284 if (v->name[0] == '\0')
1285 fatal (&v->fileinfo, _("empty variable name"));
1286
1287 return v;
1288}
1289
1290
1291/* Try to interpret LINE (a null-terminated string) as a variable definition.
1292
1293 ORIGIN may be o_file, o_override, o_env, o_env_override,
1294 or o_command specifying that the variable definition comes
1295 from a makefile, an override directive, the environment with
1296 or without the -e switch, or the command line.
1297
1298 See the comments for parse_variable_definition().
1299
1300 If LINE was recognized as a variable definition, a pointer to its `struct
1301 variable' is returned. If LINE is not a variable definition, NULL is
1302 returned. */
1303
1304struct variable *
1305try_variable_definition (const struct floc *flocp, char *line,
1306 enum variable_origin origin, int target_var)
1307{
1308 struct variable v;
1309 struct variable *vp;
1310
1311 if (flocp != 0)
1312 v.fileinfo = *flocp;
1313 else
1314 v.fileinfo.filenm = 0;
1315
1316 if (!parse_variable_definition (&v, line))
1317 return 0;
1318
1319 vp = do_variable_definition (flocp, v.name, v.value,
1320 origin, v.flavor, target_var);
1321
1322 free (v.name);
1323
1324 return vp;
1325}
1326
1327
1328/* Print information for variable V, prefixing it with PREFIX. */
1329
1330static void
1331print_variable (const void *item, void *arg)
1332{
1333 const struct variable *v = (struct variable *) item;
1334 const char *prefix = (char *) arg;
1335 const char *origin;
1336
1337 switch (v->origin)
1338 {
1339 case o_default:
1340 origin = _("default");
1341 break;
1342 case o_env:
1343 origin = _("environment");
1344 break;
1345 case o_file:
1346 origin = _("makefile");
1347 break;
1348 case o_env_override:
1349 origin = _("environment under -e");
1350 break;
1351 case o_command:
1352 origin = _("command line");
1353 break;
1354 case o_override:
1355 origin = _("`override' directive");
1356 break;
1357 case o_automatic:
1358 origin = _("automatic");
1359 break;
1360 case o_invalid:
1361 default:
1362 abort ();
1363 }
1364 fputs ("# ", stdout);
1365 fputs (origin, stdout);
1366 if (v->fileinfo.filenm)
1367 printf (_(" (from `%s', line %lu)"),
1368 v->fileinfo.filenm, v->fileinfo.lineno);
1369 putchar ('\n');
1370 fputs (prefix, stdout);
1371
1372 /* Is this a `define'? */
1373 if (v->recursive && strchr (v->value, '\n') != 0)
1374 printf ("define %s\n%s\nendef\n", v->name, v->value);
1375 else
1376 {
1377 register char *p;
1378
1379 printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
1380
1381 /* Check if the value is just whitespace. */
1382 p = next_token (v->value);
1383 if (p != v->value && *p == '\0')
1384 /* All whitespace. */
1385 printf ("$(subst ,,%s)", v->value);
1386 else if (v->recursive)
1387 fputs (v->value, stdout);
1388 else
1389 /* Double up dollar signs. */
1390 for (p = v->value; *p != '\0'; ++p)
1391 {
1392 if (*p == '$')
1393 putchar ('$');
1394 putchar (*p);
1395 }
1396 putchar ('\n');
1397 }
1398}
1399
1400
1401/* Print all the variables in SET. PREFIX is printed before
1402 the actual variable definitions (everything else is comments). */
1403
1404void
1405print_variable_set (struct variable_set *set, char *prefix)
1406{
1407 hash_map_arg (&set->table, print_variable, prefix);
1408
1409 fputs (_("# variable set hash-table stats:\n"), stdout);
1410 fputs ("# ", stdout);
1411 hash_print_stats (&set->table, stdout);
1412 putc ('\n', stdout);
1413}
1414
1415/* Print the data base of variables. */
1416
1417void
1418print_variable_data_base (void)
1419{
1420 puts (_("\n# Variables\n"));
1421
1422 print_variable_set (&global_variable_set, "");
1423
1424 puts (_("\n# Pattern-specific Variable Values"));
1425
1426 {
1427 struct pattern_var *p;
1428 int rules = 0;
1429
1430 for (p = pattern_vars; p != 0; p = p->next)
1431 {
1432 ++rules;
1433 printf ("\n%s :\n", p->target);
1434 print_variable (&p->variable, "# ");
1435 }
1436
1437 if (rules == 0)
1438 puts (_("\n# No pattern-specific variable values."));
1439 else
1440 printf (_("\n# %u pattern-specific variable values"), rules);
1441 }
1442}
1443
1444
1445/* Print all the local variables of FILE. */
1446
1447void
1448print_file_variables (struct file *file)
1449{
1450 if (file->variables != 0)
1451 print_variable_set (file->variables->set, "# ");
1452}
1453
1454#ifdef WINDOWS32
1455void
1456sync_Path_environment (void)
1457{
1458 char *path = allocated_variable_expand ("$(PATH)");
1459 static char *environ_path = NULL;
1460
1461 if (!path)
1462 return;
1463
1464 /*
1465 * If done this before, don't leak memory unnecessarily.
1466 * Free the previous entry before allocating new one.
1467 */
1468 if (environ_path)
1469 free (environ_path);
1470
1471 /*
1472 * Create something WINDOWS32 world can grok
1473 */
1474 convert_Path_to_windows32 (path, ';');
1475 environ_path = concat ("PATH", "=", path);
1476 putenv (environ_path);
1477 free (path);
1478}
1479#endif
Note: See TracBrowser for help on using the repository browser.

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