VirtualBox

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

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

ln and install builtins (from BSD as usual).

  • Property svn:eol-style set to native
File size: 42.4 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 supported kMk Builtin commands. */
687#ifdef _MSC_VER
688 (void) define_variable ("KMK_BUILTIN", 11, "append echo mkdir", o_default, 0);
689#else
690 (void) define_variable ("KMK_BUILTIN", 11, "append cp echo install ln mkdir rm", o_default, 0);
691#endif
692#endif
693
694#ifdef __MSDOS__
695 /* Allow to specify a special shell just for Make,
696 and use $COMSPEC as the default $SHELL when appropriate. */
697 {
698 static char shell_str[] = "SHELL";
699 const int shlen = sizeof (shell_str) - 1;
700 struct variable *mshp = lookup_variable ("MAKESHELL", 9);
701 struct variable *comp = lookup_variable ("COMSPEC", 7);
702
703 /* Make $MAKESHELL override $SHELL even if -e is in effect. */
704 if (mshp)
705 (void) define_variable (shell_str, shlen,
706 mshp->value, o_env_override, 0);
707 else if (comp)
708 {
709 /* $COMSPEC shouldn't override $SHELL. */
710 struct variable *shp = lookup_variable (shell_str, shlen);
711
712 if (!shp)
713 (void) define_variable (shell_str, shlen, comp->value, o_env, 0);
714 }
715 }
716#elif defined(__EMX__)
717 {
718 static char shell_str[] = "SHELL";
719 const int shlen = sizeof (shell_str) - 1;
720 struct variable *shell = lookup_variable (shell_str, shlen);
721 struct variable *replace = lookup_variable ("MAKESHELL", 9);
722
723 /* if $MAKESHELL is defined in the environment assume o_env_override */
724 if (replace && *replace->value && replace->origin == o_env)
725 replace->origin = o_env_override;
726
727 /* if $MAKESHELL is not defined use $SHELL but only if the variable
728 did not come from the environment */
729 if (!replace || !*replace->value)
730 if (shell && *shell->value && (shell->origin == o_env
731 || shell->origin == o_env_override))
732 {
733 /* overwrite whatever we got from the environment */
734 free(shell->value);
735 shell->value = xstrdup (default_shell);
736 shell->origin = o_default;
737 }
738
739 /* Some people do not like cmd to be used as the default
740 if $SHELL is not defined in the Makefile.
741 With -DNO_CMD_DEFAULT you can turn off this behaviour */
742# ifndef NO_CMD_DEFAULT
743 /* otherwise use $COMSPEC */
744 if (!replace || !*replace->value)
745 replace = lookup_variable ("COMSPEC", 7);
746
747 /* otherwise use $OS2_SHELL */
748 if (!replace || !*replace->value)
749 replace = lookup_variable ("OS2_SHELL", 9);
750# else
751# warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
752# endif
753
754 if (replace && *replace->value)
755 /* overwrite $SHELL */
756 (void) define_variable (shell_str, shlen, replace->value,
757 replace->origin, 0);
758 else
759 /* provide a definition if there is none */
760 (void) define_variable (shell_str, shlen, default_shell,
761 o_default, 0);
762 }
763
764#endif
765
766 /* This won't override any definition, but it will provide one if there
767 isn't one there. */
768 v = define_variable ("SHELL", 5, default_shell, o_default, 0);
769
770 /* On MSDOS we do use SHELL from environment, since it isn't a standard
771 environment variable on MSDOS, so whoever sets it, does that on purpose.
772 On OS/2 we do not use SHELL from environment but we have already handled
773 that problem above. */
774#if !defined(__MSDOS__) && !defined(__EMX__)
775 /* Don't let SHELL come from the environment. */
776 if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override)
777 {
778 free (v->value);
779 v->origin = o_file;
780 v->value = xstrdup (default_shell);
781 }
782#endif
783
784 /* Make sure MAKEFILES gets exported if it is set. */
785 v = define_variable ("MAKEFILES", 9, "", o_default, 0);
786 v->export = v_ifset;
787
788 /* Define the magic D and F variables in terms of
789 the automatic variables they are variations of. */
790
791#ifdef VMS
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 define_variable ("<D", 2, "$(dir $<)", o_automatic, 1);
796 define_variable ("?D", 2, "$(dir $?)", o_automatic, 1);
797 define_variable ("^D", 2, "$(dir $^)", o_automatic, 1);
798 define_variable ("+D", 2, "$(dir $+)", o_automatic, 1);
799#else
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 define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
804 define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
805 define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
806 define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
807#endif
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 define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
812 define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
813 define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
814 define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
815}
816
817
818int export_all_variables;
819
820/* Create a new environment for FILE's commands.
821 If FILE is nil, this is for the `shell' function.
822 The child's MAKELEVEL variable is incremented. */
823
824char **
825target_environment (struct file *file)
826{
827 struct variable_set_list *set_list;
828 register struct variable_set_list *s;
829 struct hash_table table;
830 struct variable **v_slot;
831 struct variable **v_end;
832 struct variable makelevel_key;
833 char **result_0;
834 char **result;
835
836 if (file == 0)
837 set_list = current_variable_set_list;
838 else
839 set_list = file->variables;
840
841 hash_init (&table, VARIABLE_BUCKETS,
842 variable_hash_1, variable_hash_2, variable_hash_cmp);
843
844 /* Run through all the variable sets in the list,
845 accumulating variables in TABLE. */
846 for (s = set_list; s != 0; s = s->next)
847 {
848 struct variable_set *set = s->set;
849 v_slot = (struct variable **) set->table.ht_vec;
850 v_end = v_slot + set->table.ht_size;
851 for ( ; v_slot < v_end; v_slot++)
852 if (! HASH_VACANT (*v_slot))
853 {
854 struct variable **new_slot;
855 struct variable *v = *v_slot;
856
857 /* If this is a per-target variable and it hasn't been touched
858 already then look up the global version and take its export
859 value. */
860 if (v->per_target && v->export == v_default)
861 {
862 struct variable *gv;
863
864 gv = lookup_variable_in_set (v->name, strlen(v->name),
865 &global_variable_set);
866 if (gv)
867 v->export = gv->export;
868 }
869
870 switch (v->export)
871 {
872 case v_default:
873 if (v->origin == o_default || v->origin == o_automatic)
874 /* Only export default variables by explicit request. */
875 continue;
876
877 /* The variable doesn't have a name that can be exported. */
878 if (! v->exportable)
879 continue;
880
881 if (! export_all_variables
882 && v->origin != o_command
883 && v->origin != o_env && v->origin != o_env_override)
884 continue;
885 break;
886
887 case v_export:
888 break;
889
890 case v_noexport:
891 /* If this is the SHELL variable and it's not exported, then
892 add the value from our original environment. */
893 if (streq (v->name, "SHELL"))
894 {
895 extern struct variable shell_var;
896 v = &shell_var;
897 break;
898 }
899 continue;
900
901 case v_ifset:
902 if (v->origin == o_default)
903 continue;
904 break;
905 }
906
907 new_slot = (struct variable **) hash_find_slot (&table, v);
908 if (HASH_VACANT (*new_slot))
909 hash_insert_at (&table, v, new_slot);
910 }
911 }
912
913 makelevel_key.name = MAKELEVEL_NAME;
914 makelevel_key.length = MAKELEVEL_LENGTH;
915 hash_delete (&table, &makelevel_key);
916
917 result = result_0 = (char **) xmalloc ((table.ht_fill + 2) * sizeof (char *));
918
919 v_slot = (struct variable **) table.ht_vec;
920 v_end = v_slot + table.ht_size;
921 for ( ; v_slot < v_end; v_slot++)
922 if (! HASH_VACANT (*v_slot))
923 {
924 struct variable *v = *v_slot;
925
926 /* If V is recursively expanded and didn't come from the environment,
927 expand its value. If it came from the environment, it should
928 go back into the environment unchanged. */
929 if (v->recursive
930 && v->origin != o_env && v->origin != o_env_override)
931 {
932 char *value = recursively_expand_for_file (v, file);
933#ifdef WINDOWS32
934 if (strcmp(v->name, "Path") == 0 ||
935 strcmp(v->name, "PATH") == 0)
936 convert_Path_to_windows32(value, ';');
937#endif
938 *result++ = concat (v->name, "=", value);
939 free (value);
940 }
941 else
942 {
943#ifdef WINDOWS32
944 if (strcmp(v->name, "Path") == 0 ||
945 strcmp(v->name, "PATH") == 0)
946 convert_Path_to_windows32(v->value, ';');
947#endif
948 *result++ = concat (v->name, "=", v->value);
949 }
950 }
951
952 *result = (char *) xmalloc (100);
953 (void) sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1);
954 *++result = 0;
955
956 hash_free (&table, 0);
957
958 return result_0;
959}
960
961
962/* Given a variable, a value, and a flavor, define the variable.
963 See the try_variable_definition() function for details on the parameters. */
964
965struct variable *
966do_variable_definition (const struct floc *flocp, const char *varname,
967 char *value, enum variable_origin origin,
968 enum variable_flavor flavor, int target_var)
969{
970 char *p, *alloc_value = NULL;
971 struct variable *v;
972 int append = 0;
973 int conditional = 0;
974
975 /* Calculate the variable's new value in VALUE. */
976
977 switch (flavor)
978 {
979 default:
980 case f_bogus:
981 /* Should not be possible. */
982 abort ();
983 case f_simple:
984 /* A simple variable definition "var := value". Expand the value.
985 We have to allocate memory since otherwise it'll clobber the
986 variable buffer, and we may still need that if we're looking at a
987 target-specific variable. */
988 p = alloc_value = allocated_variable_expand (value);
989 break;
990 case f_conditional:
991 /* A conditional variable definition "var ?= value".
992 The value is set IFF the variable is not defined yet. */
993 v = lookup_variable (varname, strlen (varname));
994 if (v)
995 return v;
996
997 conditional = 1;
998 flavor = f_recursive;
999 /* FALLTHROUGH */
1000 case f_recursive:
1001 /* A recursive variable definition "var = value".
1002 The value is used verbatim. */
1003 p = value;
1004 break;
1005 case f_append:
1006 {
1007 /* If we have += but we're in a target variable context, we want to
1008 append only with other variables in the context of this target. */
1009 if (target_var)
1010 {
1011 append = 1;
1012 v = lookup_variable_in_set (varname, strlen (varname),
1013 current_variable_set_list->set);
1014
1015 /* Don't append from the global set if a previous non-appending
1016 target-specific variable definition exists. */
1017 if (v && !v->append)
1018 append = 0;
1019 }
1020 else
1021 v = lookup_variable (varname, strlen (varname));
1022
1023 if (v == 0)
1024 {
1025 /* There was no old value.
1026 This becomes a normal recursive definition. */
1027 p = value;
1028 flavor = f_recursive;
1029 }
1030 else
1031 {
1032 /* Paste the old and new values together in VALUE. */
1033
1034 unsigned int oldlen, vallen;
1035 char *val;
1036
1037 val = value;
1038 if (v->recursive)
1039 /* The previous definition of the variable was recursive.
1040 The new value is the unexpanded old and new values. */
1041 flavor = f_recursive;
1042 else
1043 /* The previous definition of the variable was simple.
1044 The new value comes from the old value, which was expanded
1045 when it was set; and from the expanded new value. Allocate
1046 memory for the expansion as we may still need the rest of the
1047 buffer if we're looking at a target-specific variable. */
1048 val = alloc_value = allocated_variable_expand (val);
1049
1050 oldlen = strlen (v->value);
1051 vallen = strlen (val);
1052 p = (char *) alloca (oldlen + 1 + vallen + 1);
1053 bcopy (v->value, p, oldlen);
1054 p[oldlen] = ' ';
1055 bcopy (val, &p[oldlen + 1], vallen + 1);
1056 }
1057 }
1058 }
1059
1060#ifdef __MSDOS__
1061 /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1062 non-Unix systems don't conform to this default configuration (in
1063 fact, most of them don't even have `/bin'). On the other hand,
1064 $SHELL in the environment, if set, points to the real pathname of
1065 the shell.
1066 Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1067 the Makefile override $SHELL from the environment. But first, we
1068 look for the basename of the shell in the directory where SHELL=
1069 points, and along the $PATH; if it is found in any of these places,
1070 we define $SHELL to be the actual pathname of the shell. Thus, if
1071 you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1072 your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1073 defining SHELL to be "d:/unix/bash.exe". */
1074 if ((origin == o_file || origin == o_override)
1075 && strcmp (varname, "SHELL") == 0)
1076 {
1077 PATH_VAR (shellpath);
1078 extern char * __dosexec_find_on_path (const char *, char *[], char *);
1079
1080 /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1081 if (__dosexec_find_on_path (p, (char **)0, shellpath))
1082 {
1083 char *p;
1084
1085 for (p = shellpath; *p; p++)
1086 {
1087 if (*p == '\\')
1088 *p = '/';
1089 }
1090 v = define_variable_loc (varname, strlen (varname),
1091 shellpath, origin, flavor == f_recursive,
1092 flocp);
1093 }
1094 else
1095 {
1096 char *shellbase, *bslash;
1097 struct variable *pathv = lookup_variable ("PATH", 4);
1098 char *path_string;
1099 char *fake_env[2];
1100 size_t pathlen = 0;
1101
1102 shellbase = strrchr (p, '/');
1103 bslash = strrchr (p, '\\');
1104 if (!shellbase || bslash > shellbase)
1105 shellbase = bslash;
1106 if (!shellbase && p[1] == ':')
1107 shellbase = p + 1;
1108 if (shellbase)
1109 shellbase++;
1110 else
1111 shellbase = p;
1112
1113 /* Search for the basename of the shell (with standard
1114 executable extensions) along the $PATH. */
1115 if (pathv)
1116 pathlen = strlen (pathv->value);
1117 path_string = (char *)xmalloc (5 + pathlen + 2 + 1);
1118 /* On MSDOS, current directory is considered as part of $PATH. */
1119 sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
1120 fake_env[0] = path_string;
1121 fake_env[1] = (char *)0;
1122 if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
1123 {
1124 char *p;
1125
1126 for (p = shellpath; *p; p++)
1127 {
1128 if (*p == '\\')
1129 *p = '/';
1130 }
1131 v = define_variable_loc (varname, strlen (varname),
1132 shellpath, origin,
1133 flavor == f_recursive, flocp);
1134 }
1135 else
1136 v = lookup_variable (varname, strlen (varname));
1137
1138 free (path_string);
1139 }
1140 }
1141 else
1142#endif /* __MSDOS__ */
1143#ifdef WINDOWS32
1144 if ((origin == o_file || origin == o_override) && streq (varname, "SHELL"))
1145 {
1146 extern char *default_shell;
1147
1148 /* Call shell locator function. If it returns TRUE, then
1149 set no_default_sh_exe to indicate sh was found and
1150 set new value for SHELL variable. */
1151
1152 if (find_and_set_default_shell (p))
1153 {
1154 v = define_variable_in_set (varname, strlen (varname), default_shell,
1155 origin, flavor == f_recursive,
1156 (target_var
1157 ? current_variable_set_list->set
1158 : NULL),
1159 flocp);
1160 no_default_sh_exe = 0;
1161 }
1162 else
1163 v = lookup_variable (varname, strlen (varname));
1164 }
1165 else
1166#endif
1167
1168 /* If we are defining variables inside an $(eval ...), we might have a
1169 different variable context pushed, not the global context (maybe we're
1170 inside a $(call ...) or something. Since this function is only ever
1171 invoked in places where we want to define globally visible variables,
1172 make sure we define this variable in the global set. */
1173
1174 v = define_variable_in_set (varname, strlen (varname), p,
1175 origin, flavor == f_recursive,
1176 (target_var
1177 ? current_variable_set_list->set : NULL),
1178 flocp);
1179 v->append = append;
1180 v->conditional = conditional;
1181
1182 if (alloc_value)
1183 free (alloc_value);
1184
1185 return v;
1186}
1187
1188
1189/* Try to interpret LINE (a null-terminated string) as a variable definition.
1190
1191 ORIGIN may be o_file, o_override, o_env, o_env_override,
1192 or o_command specifying that the variable definition comes
1193 from a makefile, an override directive, the environment with
1194 or without the -e switch, or the command line.
1195
1196 See the comments for parse_variable_definition().
1197
1198 If LINE was recognized as a variable definition, a pointer to its `struct
1199 variable' is returned. If LINE is not a variable definition, NULL is
1200 returned. */
1201
1202struct variable *
1203parse_variable_definition (struct variable *v, char *line)
1204{
1205 register int c;
1206 register char *p = line;
1207 register char *beg;
1208 register char *end;
1209 enum variable_flavor flavor = f_bogus;
1210 char *name;
1211
1212 while (1)
1213 {
1214 c = *p++;
1215 if (c == '\0' || c == '#')
1216 return 0;
1217 if (c == '=')
1218 {
1219 end = p - 1;
1220 flavor = f_recursive;
1221 break;
1222 }
1223 else if (c == ':')
1224 if (*p == '=')
1225 {
1226 end = p++ - 1;
1227 flavor = f_simple;
1228 break;
1229 }
1230 else
1231 /* A colon other than := is a rule line, not a variable defn. */
1232 return 0;
1233 else if (c == '+' && *p == '=')
1234 {
1235 end = p++ - 1;
1236 flavor = f_append;
1237 break;
1238 }
1239 else if (c == '?' && *p == '=')
1240 {
1241 end = p++ - 1;
1242 flavor = f_conditional;
1243 break;
1244 }
1245 else if (c == '$')
1246 {
1247 /* This might begin a variable expansion reference. Make sure we
1248 don't misrecognize chars inside the reference as =, := or +=. */
1249 char closeparen;
1250 int count;
1251 c = *p++;
1252 if (c == '(')
1253 closeparen = ')';
1254 else if (c == '{')
1255 closeparen = '}';
1256 else
1257 continue; /* Nope. */
1258
1259 /* P now points past the opening paren or brace.
1260 Count parens or braces until it is matched. */
1261 count = 0;
1262 for (; *p != '\0'; ++p)
1263 {
1264 if (*p == c)
1265 ++count;
1266 else if (*p == closeparen && --count < 0)
1267 {
1268 ++p;
1269 break;
1270 }
1271 }
1272 }
1273 }
1274 v->flavor = flavor;
1275
1276 beg = next_token (line);
1277 while (end > beg && isblank ((unsigned char)end[-1]))
1278 --end;
1279 p = next_token (p);
1280 v->value = p;
1281
1282 /* Expand the name, so "$(foo)bar = baz" works. */
1283 name = (char *) alloca (end - beg + 1);
1284 bcopy (beg, name, end - beg);
1285 name[end - beg] = '\0';
1286 v->name = allocated_variable_expand (name);
1287
1288 if (v->name[0] == '\0')
1289 fatal (&v->fileinfo, _("empty variable name"));
1290
1291 return v;
1292}
1293
1294
1295/* Try to interpret LINE (a null-terminated string) as a variable definition.
1296
1297 ORIGIN may be o_file, o_override, o_env, o_env_override,
1298 or o_command specifying that the variable definition comes
1299 from a makefile, an override directive, the environment with
1300 or without the -e switch, or the command line.
1301
1302 See the comments for parse_variable_definition().
1303
1304 If LINE was recognized as a variable definition, a pointer to its `struct
1305 variable' is returned. If LINE is not a variable definition, NULL is
1306 returned. */
1307
1308struct variable *
1309try_variable_definition (const struct floc *flocp, char *line,
1310 enum variable_origin origin, int target_var)
1311{
1312 struct variable v;
1313 struct variable *vp;
1314
1315 if (flocp != 0)
1316 v.fileinfo = *flocp;
1317 else
1318 v.fileinfo.filenm = 0;
1319
1320 if (!parse_variable_definition (&v, line))
1321 return 0;
1322
1323 vp = do_variable_definition (flocp, v.name, v.value,
1324 origin, v.flavor, target_var);
1325
1326 free (v.name);
1327
1328 return vp;
1329}
1330
1331
1332/* Print information for variable V, prefixing it with PREFIX. */
1333
1334static void
1335print_variable (const void *item, void *arg)
1336{
1337 const struct variable *v = (struct variable *) item;
1338 const char *prefix = (char *) arg;
1339 const char *origin;
1340
1341 switch (v->origin)
1342 {
1343 case o_default:
1344 origin = _("default");
1345 break;
1346 case o_env:
1347 origin = _("environment");
1348 break;
1349 case o_file:
1350 origin = _("makefile");
1351 break;
1352 case o_env_override:
1353 origin = _("environment under -e");
1354 break;
1355 case o_command:
1356 origin = _("command line");
1357 break;
1358 case o_override:
1359 origin = _("`override' directive");
1360 break;
1361 case o_automatic:
1362 origin = _("automatic");
1363 break;
1364 case o_invalid:
1365 default:
1366 abort ();
1367 }
1368 fputs ("# ", stdout);
1369 fputs (origin, stdout);
1370 if (v->fileinfo.filenm)
1371 printf (_(" (from `%s', line %lu)"),
1372 v->fileinfo.filenm, v->fileinfo.lineno);
1373 putchar ('\n');
1374 fputs (prefix, stdout);
1375
1376 /* Is this a `define'? */
1377 if (v->recursive && strchr (v->value, '\n') != 0)
1378 printf ("define %s\n%s\nendef\n", v->name, v->value);
1379 else
1380 {
1381 register char *p;
1382
1383 printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":");
1384
1385 /* Check if the value is just whitespace. */
1386 p = next_token (v->value);
1387 if (p != v->value && *p == '\0')
1388 /* All whitespace. */
1389 printf ("$(subst ,,%s)", v->value);
1390 else if (v->recursive)
1391 fputs (v->value, stdout);
1392 else
1393 /* Double up dollar signs. */
1394 for (p = v->value; *p != '\0'; ++p)
1395 {
1396 if (*p == '$')
1397 putchar ('$');
1398 putchar (*p);
1399 }
1400 putchar ('\n');
1401 }
1402}
1403
1404
1405/* Print all the variables in SET. PREFIX is printed before
1406 the actual variable definitions (everything else is comments). */
1407
1408void
1409print_variable_set (struct variable_set *set, char *prefix)
1410{
1411 hash_map_arg (&set->table, print_variable, prefix);
1412
1413 fputs (_("# variable set hash-table stats:\n"), stdout);
1414 fputs ("# ", stdout);
1415 hash_print_stats (&set->table, stdout);
1416 putc ('\n', stdout);
1417}
1418
1419/* Print the data base of variables. */
1420
1421void
1422print_variable_data_base (void)
1423{
1424 puts (_("\n# Variables\n"));
1425
1426 print_variable_set (&global_variable_set, "");
1427
1428 puts (_("\n# Pattern-specific Variable Values"));
1429
1430 {
1431 struct pattern_var *p;
1432 int rules = 0;
1433
1434 for (p = pattern_vars; p != 0; p = p->next)
1435 {
1436 ++rules;
1437 printf ("\n%s :\n", p->target);
1438 print_variable (&p->variable, "# ");
1439 }
1440
1441 if (rules == 0)
1442 puts (_("\n# No pattern-specific variable values."));
1443 else
1444 printf (_("\n# %u pattern-specific variable values"), rules);
1445 }
1446}
1447
1448
1449/* Print all the local variables of FILE. */
1450
1451void
1452print_file_variables (struct file *file)
1453{
1454 if (file->variables != 0)
1455 print_variable_set (file->variables->set, "# ");
1456}
1457
1458#ifdef WINDOWS32
1459void
1460sync_Path_environment (void)
1461{
1462 char *path = allocated_variable_expand ("$(PATH)");
1463 static char *environ_path = NULL;
1464
1465 if (!path)
1466 return;
1467
1468 /*
1469 * If done this before, don't leak memory unnecessarily.
1470 * Free the previous entry before allocating new one.
1471 */
1472 if (environ_path)
1473 free (environ_path);
1474
1475 /*
1476 * Create something WINDOWS32 world can grok
1477 */
1478 convert_Path_to_windows32 (path, ';');
1479 environ_path = concat ("PATH", "=", path);
1480 putenv (environ_path);
1481 free (path);
1482}
1483#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