1 /* Internals of variables for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along with
17 this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include "pathstuff.h"
34 /* Chain of all pattern-specific variables. */
36 static struct pattern_var
*pattern_vars
;
38 /* Pointer to the last struct in the pack of a specific size, from 1 to 255.*/
40 static struct pattern_var
*last_pattern_vars
[256];
42 /* Create a new pattern-specific variable struct. The new variable is
43 inserted into the PATTERN_VARS list in the shortest patterns first
44 order to support the shortest stem matching (the variables are
45 matched in the reverse order so the ones with the longest pattern
46 will be considered first). Variables with the same pattern length
47 are inserted in the definition order. */
50 create_pattern_var (const char *target
, const char *suffix
)
52 register unsigned int len
= strlen (target
);
53 register struct pattern_var
*p
= xmalloc (sizeof (struct pattern_var
));
55 if (pattern_vars
!= 0)
57 if (len
< 256 && last_pattern_vars
[len
] != 0)
59 p
->next
= last_pattern_vars
[len
]->next
;
60 last_pattern_vars
[len
]->next
= p
;
64 /* Find the position where we can insert this variable. */
65 register struct pattern_var
**v
;
67 for (v
= &pattern_vars
; ; v
= &(*v
)->next
)
69 /* Insert at the end of the pack so that patterns with the
70 same length appear in the order they were defined .*/
72 if (*v
== 0 || (*v
)->len
> len
)
89 p
->suffix
= suffix
+ 1;
92 last_pattern_vars
[len
] = p
;
97 /* Look up a target in the pattern-specific variable list. */
99 static struct pattern_var
*
100 lookup_pattern_var (struct pattern_var
*start
, const char *target
)
102 struct pattern_var
*p
;
103 unsigned int targlen
= strlen(target
);
105 for (p
= start
? start
->next
: pattern_vars
; p
!= 0; p
= p
->next
)
108 unsigned int stemlen
;
110 if (p
->len
> targlen
)
111 /* It can't possibly match. */
114 /* From the lengths of the filename and the pattern parts,
115 find the stem: the part of the filename that matches the %. */
116 stem
= target
+ (p
->suffix
- p
->target
- 1);
117 stemlen
= targlen
- p
->len
+ 1;
119 /* Compare the text in the pattern before the stem, if any. */
120 if (stem
> target
&& !strneq (p
->target
, target
, stem
- target
))
123 /* Compare the text in the pattern after the stem, if any.
124 We could test simply using streq, but this way we compare the
125 first two characters immediately. This saves time in the very
126 common case where the first character matches because it is a
128 if (*p
->suffix
== stem
[stemlen
]
129 && (*p
->suffix
== '\0' || streq (&p
->suffix
[1], &stem
[stemlen
+1])))
136 /* Hash table of all global variable definitions. */
139 variable_hash_1 (const void *keyv
)
141 struct variable
const *key
= (struct variable
const *) keyv
;
142 return_STRING_N_HASH_1 (key
->name
, key
->length
);
146 variable_hash_2 (const void *keyv
)
148 struct variable
const *key
= (struct variable
const *) keyv
;
149 return_STRING_N_HASH_2 (key
->name
, key
->length
);
153 variable_hash_cmp (const void *xv
, const void *yv
)
155 struct variable
const *x
= (struct variable
const *) xv
;
156 struct variable
const *y
= (struct variable
const *) yv
;
157 int result
= x
->length
- y
->length
;
160 return_STRING_N_COMPARE (x
->name
, y
->name
, x
->length
);
163 #ifndef VARIABLE_BUCKETS
164 #define VARIABLE_BUCKETS 523
166 #ifndef PERFILE_VARIABLE_BUCKETS
167 #define PERFILE_VARIABLE_BUCKETS 23
169 #ifndef SMALL_SCOPE_VARIABLE_BUCKETS
170 #define SMALL_SCOPE_VARIABLE_BUCKETS 13
173 static struct variable_set global_variable_set
;
174 static struct variable_set_list global_setlist
175 = { 0, &global_variable_set
, 0 };
176 struct variable_set_list
*current_variable_set_list
= &global_setlist
;
178 /* Implement variables. */
181 init_hash_global_variable_set (void)
183 hash_init (&global_variable_set
.table
, VARIABLE_BUCKETS
,
184 variable_hash_1
, variable_hash_2
, variable_hash_cmp
);
187 /* Define variable named NAME with value VALUE in SET. VALUE is copied.
188 LENGTH is the length of NAME, which does not need to be null-terminated.
189 ORIGIN specifies the origin of the variable (makefile, command line
191 If RECURSIVE is nonzero a flag is set in the variable saying
192 that it should be recursively re-expanded. */
195 define_variable_in_set (const char *name
, unsigned int length
,
196 const char *value
, enum variable_origin origin
,
197 int recursive
, struct variable_set
*set
,
198 const struct floc
*flocp
)
201 struct variable
**var_slot
;
202 struct variable var_key
;
205 set
= &global_variable_set
;
207 var_key
.name
= (char *) name
;
208 var_key
.length
= length
;
209 var_slot
= (struct variable
**) hash_find_slot (&set
->table
, &var_key
);
211 if (env_overrides
&& origin
== o_env
)
212 origin
= o_env_override
;
215 if (! HASH_VACANT (v
))
217 if (env_overrides
&& v
->origin
== o_env
)
218 /* V came from in the environment. Since it was defined
219 before the switches were parsed, it wasn't affected by -e. */
220 v
->origin
= o_env_override
;
222 /* A variable of this name is already defined.
223 If the old definition is from a stronger source
224 than this one, don't redefine it. */
225 if ((int) origin
>= (int) v
->origin
)
229 v
->value
= xstrdup (value
);
231 v
->fileinfo
= *flocp
;
233 v
->fileinfo
.filenm
= 0;
235 v
->recursive
= recursive
;
240 /* Create a new variable definition and add it to the hash table. */
242 v
= xmalloc (sizeof (struct variable
));
243 v
->name
= xstrndup (name
, length
);
245 hash_insert_at (&set
->table
, v
, var_slot
);
246 v
->value
= xstrdup (value
);
248 v
->fileinfo
= *flocp
;
250 v
->fileinfo
.filenm
= 0;
252 v
->recursive
= recursive
;
259 v
->export
= v_default
;
262 if (*name
!= '_' && (*name
< 'A' || *name
> 'Z')
263 && (*name
< 'a' || *name
> 'z'))
267 for (++name
; *name
!= '\0'; ++name
)
268 if (*name
!= '_' && (*name
< 'a' || *name
> 'z')
269 && (*name
< 'A' || *name
> 'Z') && !ISDIGIT(*name
))
280 /* Undefine variable named NAME in SET. LENGTH is the length of NAME, which
281 does not need to be null-terminated. ORIGIN specifies the origin of the
282 variable (makefile, command line or environment). */
285 free_variable_name_and_value (const void *item
);
288 undefine_variable_in_set (const char *name
, unsigned int length
,
289 enum variable_origin origin
,
290 struct variable_set
*set
)
293 struct variable
**var_slot
;
294 struct variable var_key
;
297 set
= &global_variable_set
;
299 var_key
.name
= (char *) name
;
300 var_key
.length
= length
;
301 var_slot
= (struct variable
**) hash_find_slot (&set
->table
, &var_key
);
303 if (env_overrides
&& origin
== o_env
)
304 origin
= o_env_override
;
307 if (! HASH_VACANT (v
))
309 if (env_overrides
&& v
->origin
== o_env
)
310 /* V came from in the environment. Since it was defined
311 before the switches were parsed, it wasn't affected by -e. */
312 v
->origin
= o_env_override
;
314 /* If the definition is from a stronger source than this one, don't
316 if ((int) origin
>= (int) v
->origin
)
318 hash_delete_at (&set
->table
, var_slot
);
319 free_variable_name_and_value (v
);
324 /* If the variable passed in is "special", handle its special nature.
325 Currently there are two such variables, both used for introspection:
326 .VARIABLES expands to a list of all the variables defined in this instance
328 .TARGETS expands to a list of all the targets defined in this
330 Returns the variable reference passed in. */
332 #define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
334 static struct variable
*
335 lookup_special_var (struct variable
*var
)
337 static unsigned long last_var_count
= 0;
340 /* This one actually turns out to be very hard, due to the way the parser
341 records targets. The way it works is that target information is collected
342 internally until make knows the target is completely specified. It unitl
343 it sees that some new construct (a new target or variable) is defined that
344 it knows the previous one is done. In short, this means that if you do
351 then $(TARGS) won't contain "all", because it's not until after the
352 variable is created that the previous target is completed.
354 Changing this would be a major pain. I think a less complex way to do it
355 would be to pre-define the target files as soon as the first line is
356 parsed, then come back and do the rest of the definition as now. That
357 would allow $(.TARGETS) to be correct without a major change to the way
360 if (streq (var->name, ".TARGETS"))
361 var->value = build_target_list (var->value);
365 if (streq (var
->name
, ".VARIABLES")
366 && global_variable_set
.table
.ht_fill
!= last_var_count
)
368 unsigned long max
= EXPANSION_INCREMENT (strlen (var
->value
));
371 struct variable
**vp
= (struct variable
**) global_variable_set
.table
.ht_vec
;
372 struct variable
**end
= &vp
[global_variable_set
.table
.ht_size
];
374 /* Make sure we have at least MAX bytes in the allocated buffer. */
375 var
->value
= xrealloc (var
->value
, max
);
377 /* Walk through the hash of variables, constructing a list of names. */
380 for (; vp
< end
; ++vp
)
381 if (!HASH_VACANT (*vp
))
383 struct variable
*v
= *vp
;
389 unsigned long off
= p
- var
->value
;
391 max
+= EXPANSION_INCREMENT (l
+ 1);
392 var
->value
= xrealloc (var
->value
, max
);
393 p
= &var
->value
[off
];
396 memcpy (p
, v
->name
, l
);
402 /* Remember how many variables are in our current count. Since we never
403 remove variables from the list, this is a reliable way to know whether
404 the list is up to date or needs to be recomputed. */
406 last_var_count
= global_variable_set
.table
.ht_fill
;
413 /* Lookup a variable whose name is a string starting at NAME
414 and with LENGTH chars. NAME need not be null-terminated.
415 Returns address of the 'struct variable' containing all info
416 on the variable, or nil if no such variable is defined. */
419 lookup_variable (const char *name
, unsigned int length
)
421 const struct variable_set_list
*setlist
;
422 struct variable var_key
;
425 var_key
.name
= (char *) name
;
426 var_key
.length
= length
;
428 for (setlist
= current_variable_set_list
;
429 setlist
!= 0; setlist
= setlist
->next
)
431 const struct variable_set
*set
= setlist
->set
;
434 v
= (struct variable
*) hash_find_item ((struct hash_table
*) &set
->table
, &var_key
);
435 if (v
&& (!is_parent
|| !v
->private_var
))
436 return v
->special
? lookup_special_var (v
) : v
;
438 is_parent
|= setlist
->next_is_parent
;
442 /* since we don't read envp[] on startup, try to get the
443 variable via getenv() here. */
445 char *vname
= alloca (length
+ 1);
447 strncpy (vname
, name
, length
);
449 value
= getenv (vname
);
458 while ((sptr
= strchr (sptr
, '$')))
469 nvalue
= alloca (strlen (value
) + scnt
+ 1);
488 return define_variable (vname
, length
, nvalue
, o_env
, 1);
492 return define_variable (vname
, length
, value
, o_env
, 1);
500 /* Lookup a variable whose name is a string starting at NAME
501 and with LENGTH chars in set SET. NAME need not be null-terminated.
502 Returns address of the 'struct variable' containing all info
503 on the variable, or nil if no such variable is defined. */
506 lookup_variable_in_set (const char *name
, unsigned int length
,
507 const struct variable_set
*set
)
509 struct variable var_key
;
511 var_key
.name
= (char *) name
;
512 var_key
.length
= length
;
514 return (struct variable
*) hash_find_item ((struct hash_table
*) &set
->table
, &var_key
);
517 /* Initialize FILE's variable set list. If FILE already has a variable set
518 list, the topmost variable set is left intact, but the the rest of the
519 chain is replaced with FILE->parent's setlist. If FILE is a double-colon
520 rule, then we will use the "root" double-colon target's variable set as the
521 parent of FILE's variable set.
523 If we're READING a makefile, don't do the pattern variable search now,
524 since the pattern variable might not have been defined yet. */
527 initialize_file_variables (struct file
*file
, int reading
)
529 struct variable_set_list
*l
= file
->variables
;
533 l
= (struct variable_set_list
*)
534 xmalloc (sizeof (struct variable_set_list
));
535 l
->set
= xmalloc (sizeof (struct variable_set
));
536 hash_init (&l
->set
->table
, PERFILE_VARIABLE_BUCKETS
,
537 variable_hash_1
, variable_hash_2
, variable_hash_cmp
);
541 /* If this is a double-colon, then our "parent" is the "root" target for
542 this double-colon rule. Since that rule has the same name, parent,
543 etc. we can just use its variables as the "next" for ours. */
545 if (file
->double_colon
&& file
->double_colon
!= file
)
547 initialize_file_variables (file
->double_colon
, reading
);
548 l
->next
= file
->double_colon
->variables
;
549 l
->next_is_parent
= 0;
553 if (file
->parent
== 0)
554 l
->next
= &global_setlist
;
557 initialize_file_variables (file
->parent
, reading
);
558 l
->next
= file
->parent
->variables
;
560 l
->next_is_parent
= 1;
562 /* If we're not reading makefiles and we haven't looked yet, see if
563 we can find pattern variables for this target. */
565 if (!reading
&& !file
->pat_searched
)
567 struct pattern_var
*p
;
569 p
= lookup_pattern_var (0, file
->name
);
572 struct variable_set_list
*global
= current_variable_set_list
;
574 /* We found at least one. Set up a new variable set to accumulate
575 all the pattern variables that match this target. */
577 file
->pat_variables
= create_new_variable_set ();
578 current_variable_set_list
= file
->pat_variables
;
582 /* We found one, so insert it into the set. */
586 if (p
->variable
.flavor
== f_simple
)
588 v
= define_variable_loc (
589 p
->variable
.name
, strlen (p
->variable
.name
),
590 p
->variable
.value
, p
->variable
.origin
,
591 0, &p
->variable
.fileinfo
);
593 v
->flavor
= f_simple
;
597 v
= do_variable_definition (
598 &p
->variable
.fileinfo
, p
->variable
.name
,
599 p
->variable
.value
, p
->variable
.origin
,
600 p
->variable
.flavor
, 1);
603 /* Also mark it as a per-target and copy export status. */
604 v
->per_target
= p
->variable
.per_target
;
605 v
->export
= p
->variable
.export
;
606 v
->private_var
= p
->variable
.private_var
;
608 while ((p
= lookup_pattern_var (p
, file
->name
)) != 0);
610 current_variable_set_list
= global
;
612 file
->pat_searched
= 1;
615 /* If we have a pattern variable match, set it up. */
617 if (file
->pat_variables
!= 0)
619 file
->pat_variables
->next
= l
->next
;
620 file
->pat_variables
->next_is_parent
= l
->next_is_parent
;
621 l
->next
= file
->pat_variables
;
622 l
->next_is_parent
= 0;
626 /* Pop the top set off the current variable set list,
627 and free all its storage. */
629 struct variable_set_list
*
630 create_new_variable_set (void)
632 register struct variable_set_list
*setlist
;
633 register struct variable_set
*set
;
635 set
= xmalloc (sizeof (struct variable_set
));
636 hash_init (&set
->table
, SMALL_SCOPE_VARIABLE_BUCKETS
,
637 variable_hash_1
, variable_hash_2
, variable_hash_cmp
);
639 setlist
= (struct variable_set_list
*)
640 xmalloc (sizeof (struct variable_set_list
));
642 setlist
->next
= current_variable_set_list
;
643 setlist
->next_is_parent
= 0;
649 free_variable_name_and_value (const void *item
)
651 struct variable
*v
= (struct variable
*) item
;
657 free_variable_set (struct variable_set_list
*list
)
659 hash_map (&list
->set
->table
, free_variable_name_and_value
);
660 hash_free (&list
->set
->table
, 1);
665 /* Create a new variable set and push it on the current setlist.
666 If we're pushing a global scope (that is, the current scope is the global
667 scope) then we need to "push" it the other way: file variable sets point
668 directly to the global_setlist so we need to replace that with the new one.
671 struct variable_set_list
*
672 push_new_variable_scope (void)
674 current_variable_set_list
= create_new_variable_set();
675 if (current_variable_set_list
->next
== &global_setlist
)
677 /* It was the global, so instead of new -> &global we want to replace
678 &global with the new one and have &global -> new, with current still
679 pointing to &global */
680 struct variable_set
*set
= current_variable_set_list
->set
;
681 current_variable_set_list
->set
= global_setlist
.set
;
682 global_setlist
.set
= set
;
683 current_variable_set_list
->next
= global_setlist
.next
;
684 global_setlist
.next
= current_variable_set_list
;
685 current_variable_set_list
= &global_setlist
;
687 return (current_variable_set_list
);
691 pop_variable_scope (void)
693 struct variable_set_list
*setlist
;
694 struct variable_set
*set
;
696 /* Can't call this if there's no scope to pop! */
697 assert(current_variable_set_list
->next
!= NULL
);
699 if (current_variable_set_list
!= &global_setlist
)
701 /* We're not pointing to the global setlist, so pop this one. */
702 setlist
= current_variable_set_list
;
704 current_variable_set_list
= setlist
->next
;
708 /* This set is the one in the global_setlist, but there is another global
709 set beyond that. We want to copy that set to global_setlist, then
710 delete what used to be in global_setlist. */
711 setlist
= global_setlist
.next
;
712 set
= global_setlist
.set
;
713 global_setlist
.set
= setlist
->set
;
714 global_setlist
.next
= setlist
->next
;
715 global_setlist
.next_is_parent
= setlist
->next_is_parent
;
718 /* Free the one we no longer need. */
720 hash_map (&set
->table
, free_variable_name_and_value
);
721 hash_free (&set
->table
, 1);
725 /* Merge FROM_SET into TO_SET, freeing unused storage in FROM_SET. */
728 merge_variable_sets (struct variable_set
*to_set
,
729 struct variable_set
*from_set
)
731 struct variable
**from_var_slot
= (struct variable
**) from_set
->table
.ht_vec
;
732 struct variable
**from_var_end
= from_var_slot
+ from_set
->table
.ht_size
;
734 for ( ; from_var_slot
< from_var_end
; from_var_slot
++)
735 if (! HASH_VACANT (*from_var_slot
))
737 struct variable
*from_var
= *from_var_slot
;
738 struct variable
**to_var_slot
739 = (struct variable
**) hash_find_slot (&to_set
->table
, *from_var_slot
);
740 if (HASH_VACANT (*to_var_slot
))
741 hash_insert_at (&to_set
->table
, from_var
, to_var_slot
);
744 /* GKM FIXME: delete in from_set->table */
745 free (from_var
->value
);
751 /* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */
754 merge_variable_set_lists (struct variable_set_list
**setlist0
,
755 struct variable_set_list
*setlist1
)
757 struct variable_set_list
*to
= *setlist0
;
758 struct variable_set_list
*last0
= 0;
760 /* If there's nothing to merge, stop now. */
764 /* This loop relies on the fact that all setlists terminate with the global
765 setlist (before NULL). If that's not true, arguably we SHOULD die. */
767 while (setlist1
!= &global_setlist
&& to
!= &global_setlist
)
769 struct variable_set_list
*from
= setlist1
;
770 setlist1
= setlist1
->next
;
772 merge_variable_sets (to
->set
, from
->set
);
778 if (setlist1
!= &global_setlist
)
781 *setlist0
= setlist1
;
783 last0
->next
= setlist1
;
787 /* Define the automatic variables, and record the addresses
788 of their structures so we can change their values quickly. */
791 define_automatic_variables (void)
793 #if defined(WINDOWS32) || defined(__EMX__)
794 extern char* default_shell
;
796 extern char default_shell
[];
798 register struct variable
*v
;
801 sprintf (buf
, "%u", makelevel
);
802 define_variable_cname (MAKELEVEL_NAME
, buf
, o_env
, 0);
804 sprintf (buf
, "%s%s%s",
806 (remote_description
== 0 || remote_description
[0] == '\0')
808 (remote_description
== 0 || remote_description
[0] == '\0')
809 ? "" : remote_description
);
810 define_variable_cname ("MAKE_VERSION", buf
, o_default
, 0);
813 /* Allow to specify a special shell just for Make,
814 and use $COMSPEC as the default $SHELL when appropriate. */
816 static char shell_str
[] = "SHELL";
817 const int shlen
= sizeof (shell_str
) - 1;
818 struct variable
*mshp
= lookup_variable ("MAKESHELL", 9);
819 struct variable
*comp
= lookup_variable ("COMSPEC", 7);
821 /* $(MAKESHELL) overrides $(SHELL) even if -e is in effect. */
823 (void) define_variable (shell_str
, shlen
,
824 mshp
->value
, o_env_override
, 0);
827 /* $(COMSPEC) shouldn't override $(SHELL). */
828 struct variable
*shp
= lookup_variable (shell_str
, shlen
);
831 (void) define_variable (shell_str
, shlen
, comp
->value
, o_env
, 0);
834 #elif defined(__EMX__)
836 static char shell_str
[] = "SHELL";
837 const int shlen
= sizeof (shell_str
) - 1;
838 struct variable
*shell
= lookup_variable (shell_str
, shlen
);
839 struct variable
*replace
= lookup_variable ("MAKESHELL", 9);
841 /* if $MAKESHELL is defined in the environment assume o_env_override */
842 if (replace
&& *replace
->value
&& replace
->origin
== o_env
)
843 replace
->origin
= o_env_override
;
845 /* if $MAKESHELL is not defined use $SHELL but only if the variable
846 did not come from the environment */
847 if (!replace
|| !*replace
->value
)
848 if (shell
&& *shell
->value
&& (shell
->origin
== o_env
849 || shell
->origin
== o_env_override
))
851 /* overwrite whatever we got from the environment */
853 shell
->value
= xstrdup (default_shell
);
854 shell
->origin
= o_default
;
857 /* Some people do not like cmd to be used as the default
858 if $SHELL is not defined in the Makefile.
859 With -DNO_CMD_DEFAULT you can turn off this behaviour */
860 # ifndef NO_CMD_DEFAULT
861 /* otherwise use $COMSPEC */
862 if (!replace
|| !*replace
->value
)
863 replace
= lookup_variable ("COMSPEC", 7);
865 /* otherwise use $OS2_SHELL */
866 if (!replace
|| !*replace
->value
)
867 replace
= lookup_variable ("OS2_SHELL", 9);
869 # warning NO_CMD_DEFAULT: GNU make will not use CMD.EXE as default shell
872 if (replace
&& *replace
->value
)
873 /* overwrite $SHELL */
874 (void) define_variable (shell_str
, shlen
, replace
->value
,
877 /* provide a definition if there is none */
878 (void) define_variable (shell_str
, shlen
, default_shell
,
884 /* This won't override any definition, but it will provide one if there
886 v
= define_variable_cname ("SHELL", default_shell
, o_default
, 0);
888 v
->export
= v_export
; /* Export always SHELL. */
891 /* On MSDOS we do use SHELL from environment, since it isn't a standard
892 environment variable on MSDOS, so whoever sets it, does that on purpose.
893 On OS/2 we do not use SHELL from environment but we have already handled
894 that problem above. */
895 #if !defined(__MSDOS__) && !defined(__EMX__)
896 /* Don't let SHELL come from the environment. */
897 if (*v
->value
== '\0' || v
->origin
== o_env
|| v
->origin
== o_env_override
)
901 v
->value
= xstrdup (default_shell
);
905 /* Make sure MAKEFILES gets exported if it is set. */
906 v
= define_variable_cname ("MAKEFILES", "", o_default
, 0);
909 /* Define the magic D and F variables in terms of
910 the automatic variables they are variations of. */
913 define_variable_cname ("@D", "$(dir $@)", o_automatic
, 1);
914 define_variable_cname ("%D", "$(dir $%)", o_automatic
, 1);
915 define_variable_cname ("*D", "$(dir $*)", o_automatic
, 1);
916 define_variable_cname ("<D", "$(dir $<)", o_automatic
, 1);
917 define_variable_cname ("?D", "$(dir $?)", o_automatic
, 1);
918 define_variable_cname ("^D", "$(dir $^)", o_automatic
, 1);
919 define_variable_cname ("+D", "$(dir $+)", o_automatic
, 1);
920 #elif defined(__MSDOS__) || defined(WINDOWS32)
921 /* For consistency, remove the trailing backslash as well as slash. */
922 define_variable_cname ("@D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $@)))",
924 define_variable_cname ("%D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $%)))",
926 define_variable_cname ("*D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $*)))",
928 define_variable_cname ("<D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $<)))",
930 define_variable_cname ("?D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $?)))",
932 define_variable_cname ("^D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $^)))",
934 define_variable_cname ("+D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $+)))",
936 #else /* not __MSDOS__, not WINDOWS32 */
937 define_variable_cname ("@D", "$(patsubst %/,%,$(dir $@))", o_automatic
, 1);
938 define_variable_cname ("%D", "$(patsubst %/,%,$(dir $%))", o_automatic
, 1);
939 define_variable_cname ("*D", "$(patsubst %/,%,$(dir $*))", o_automatic
, 1);
940 define_variable_cname ("<D", "$(patsubst %/,%,$(dir $<))", o_automatic
, 1);
941 define_variable_cname ("?D", "$(patsubst %/,%,$(dir $?))", o_automatic
, 1);
942 define_variable_cname ("^D", "$(patsubst %/,%,$(dir $^))", o_automatic
, 1);
943 define_variable_cname ("+D", "$(patsubst %/,%,$(dir $+))", o_automatic
, 1);
945 define_variable_cname ("@F", "$(notdir $@)", o_automatic
, 1);
946 define_variable_cname ("%F", "$(notdir $%)", o_automatic
, 1);
947 define_variable_cname ("*F", "$(notdir $*)", o_automatic
, 1);
948 define_variable_cname ("<F", "$(notdir $<)", o_automatic
, 1);
949 define_variable_cname ("?F", "$(notdir $?)", o_automatic
, 1);
950 define_variable_cname ("^F", "$(notdir $^)", o_automatic
, 1);
951 define_variable_cname ("+F", "$(notdir $+)", o_automatic
, 1);
954 int export_all_variables
;
956 /* Create a new environment for FILE's commands.
957 If FILE is nil, this is for the 'shell' function.
958 The child's MAKELEVEL variable is incremented. */
961 target_environment (struct file
*file
)
963 struct variable_set_list
*set_list
;
964 register struct variable_set_list
*s
;
965 struct hash_table table
;
966 struct variable
**v_slot
;
967 struct variable
**v_end
;
968 struct variable makelevel_key
;
973 set_list
= current_variable_set_list
;
975 set_list
= file
->variables
;
977 hash_init (&table
, VARIABLE_BUCKETS
,
978 variable_hash_1
, variable_hash_2
, variable_hash_cmp
);
980 /* Run through all the variable sets in the list,
981 accumulating variables in TABLE. */
982 for (s
= set_list
; s
!= 0; s
= s
->next
)
984 struct variable_set
*set
= s
->set
;
985 v_slot
= (struct variable
**) set
->table
.ht_vec
;
986 v_end
= v_slot
+ set
->table
.ht_size
;
987 for ( ; v_slot
< v_end
; v_slot
++)
988 if (! HASH_VACANT (*v_slot
))
990 struct variable
**new_slot
;
991 struct variable
*v
= *v_slot
;
993 /* If this is a per-target variable and it hasn't been touched
994 already then look up the global version and take its export
996 if (v
->per_target
&& v
->export
== v_default
)
1000 gv
= lookup_variable_in_set (v
->name
, strlen(v
->name
),
1001 &global_variable_set
);
1003 v
->export
= gv
->export
;
1009 if (v
->origin
== o_default
|| v
->origin
== o_automatic
)
1010 /* Only export default variables by explicit request. */
1013 /* The variable doesn't have a name that can be exported. */
1014 if (! v
->exportable
)
1017 if (! export_all_variables
1018 && v
->origin
!= o_command
1019 && v
->origin
!= o_env
&& v
->origin
!= o_env_override
)
1028 /* If this is the SHELL variable and it's not exported,
1029 then add the value from our original environment, if
1030 the original environment defined a value for SHELL. */
1031 extern struct variable shell_var
;
1032 if (streq (v
->name
, "SHELL") && shell_var
.value
)
1041 if (v
->origin
== o_default
)
1046 new_slot
= (struct variable
**) hash_find_slot (&table
, v
);
1047 if (HASH_VACANT (*new_slot
))
1048 hash_insert_at (&table
, v
, new_slot
);
1052 makelevel_key
.name
= MAKELEVEL_NAME
;
1053 makelevel_key
.length
= MAKELEVEL_LENGTH
;
1054 hash_delete (&table
, &makelevel_key
);
1056 result
= result_0
= xmalloc ((table
.ht_fill
+ 2) * sizeof (char *));
1058 v_slot
= (struct variable
**) table
.ht_vec
;
1059 v_end
= v_slot
+ table
.ht_size
;
1060 for ( ; v_slot
< v_end
; v_slot
++)
1061 if (! HASH_VACANT (*v_slot
))
1063 struct variable
*v
= *v_slot
;
1065 /* If V is recursively expanded and didn't come from the environment,
1066 expand its value. If it came from the environment, it should
1067 go back into the environment unchanged. */
1069 && v
->origin
!= o_env
&& v
->origin
!= o_env_override
)
1071 char *value
= recursively_expand_for_file (v
, file
);
1073 if (strcmp(v
->name
, "Path") == 0 ||
1074 strcmp(v
->name
, "PATH") == 0)
1075 convert_Path_to_windows32(value
, ';');
1077 *result
++ = xstrdup (concat (3, v
->name
, "=", value
));
1083 if (strcmp(v
->name
, "Path") == 0 ||
1084 strcmp(v
->name
, "PATH") == 0)
1085 convert_Path_to_windows32(v
->value
, ';');
1087 *result
++ = xstrdup (concat (3, v
->name
, "=", v
->value
));
1091 *result
= xmalloc (100);
1092 sprintf (*result
, "%s=%u", MAKELEVEL_NAME
, makelevel
+ 1);
1095 hash_free (&table
, 0);
1100 static struct variable
*
1101 set_special_var (struct variable
*var
)
1103 if (streq (var
->name
, RECIPEPREFIX_NAME
))
1105 /* The user is resetting the command introduction prefix. This has to
1106 happen immediately, so that subsequent rules are interpreted
1108 cmd_prefix
= var
->value
[0]=='\0' ? RECIPEPREFIX_DEFAULT
: var
->value
[0];
1114 /* Given a string, shell-execute it and return a malloc'ed string of the
1115 * result. This removes only ONE newline (if any) at the end, for maximum
1116 * compatibility with the *BSD makes. If it fails, returns NULL. */
1119 shell_result (const char *p
)
1126 install_variable_buffer (&buf
, &len
);
1128 args
[0] = (char *) p
;
1130 variable_buffer_output (func_shell_base (variable_buffer
, args
, 0), "\0", 1);
1131 result
= strdup (variable_buffer
);
1133 restore_variable_buffer (buf
, len
);
1137 /* Given a variable, a value, and a flavor, define the variable.
1138 See the try_variable_definition() function for details on the parameters. */
1141 do_variable_definition (const struct floc
*flocp
, const char *varname
,
1142 const char *value
, enum variable_origin origin
,
1143 enum variable_flavor flavor
, int target_var
)
1146 char *alloc_value
= NULL
;
1149 int conditional
= 0;
1151 /* Calculate the variable's new value in VALUE. */
1157 /* Should not be possible. */
1160 /* A simple variable definition "var := value". Expand the value.
1161 We have to allocate memory since otherwise it'll clobber the
1162 variable buffer, and we may still need that if we're looking at a
1163 target-specific variable. */
1164 p
= alloc_value
= allocated_variable_expand (value
);
1168 /* A shell definition "var != value". Expand value, pass it to
1169 the shell, and store the result in recursively-expanded var. */
1170 char *q
= allocated_variable_expand (value
);
1171 p
= alloc_value
= shell_result (q
);
1173 flavor
= f_recursive
;
1177 /* A conditional variable definition "var ?= value".
1178 The value is set IFF the variable is not defined yet. */
1179 v
= lookup_variable (varname
, strlen (varname
));
1181 return v
->special
? set_special_var (v
) : v
;
1184 flavor
= f_recursive
;
1187 /* A recursive variable definition "var = value".
1188 The value is used verbatim. */
1193 /* If we have += but we're in a target variable context, we want to
1194 append only with other variables in the context of this target. */
1198 v
= lookup_variable_in_set (varname
, strlen (varname
),
1199 current_variable_set_list
->set
);
1201 /* Don't append from the global set if a previous non-appending
1202 target-specific variable definition exists. */
1203 if (v
&& !v
->append
)
1207 v
= lookup_variable (varname
, strlen (varname
));
1211 /* There was no old value.
1212 This becomes a normal recursive definition. */
1214 flavor
= f_recursive
;
1218 /* Paste the old and new values together in VALUE. */
1220 unsigned int oldlen
, vallen
;
1226 /* The previous definition of the variable was recursive.
1227 The new value is the unexpanded old and new values. */
1228 flavor
= f_recursive
;
1230 /* The previous definition of the variable was simple.
1231 The new value comes from the old value, which was expanded
1232 when it was set; and from the expanded new value. Allocate
1233 memory for the expansion as we may still need the rest of the
1234 buffer if we're looking at a target-specific variable. */
1235 val
= tp
= allocated_variable_expand (val
);
1237 oldlen
= strlen (v
->value
);
1238 vallen
= strlen (val
);
1239 p
= alloc_value
= xmalloc (oldlen
+ 1 + vallen
+ 1);
1240 memcpy (alloc_value
, v
->value
, oldlen
);
1241 alloc_value
[oldlen
] = ' ';
1242 memcpy (&alloc_value
[oldlen
+ 1], val
, vallen
+ 1);
1251 /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
1252 non-Unix systems don't conform to this default configuration (in
1253 fact, most of them don't even have '/bin'). On the other hand,
1254 $SHELL in the environment, if set, points to the real pathname of
1256 Therefore, we generally won't let lines like "SHELL=/bin/sh" from
1257 the Makefile override $SHELL from the environment. But first, we
1258 look for the basename of the shell in the directory where SHELL=
1259 points, and along the $PATH; if it is found in any of these places,
1260 we define $SHELL to be the actual pathname of the shell. Thus, if
1261 you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
1262 your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
1263 defining SHELL to be "d:/unix/bash.exe". */
1264 if ((origin
== o_file
|| origin
== o_override
)
1265 && strcmp (varname
, "SHELL") == 0)
1267 PATH_VAR (shellpath
);
1268 extern char * __dosexec_find_on_path (const char *, char *[], char *);
1270 /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
1271 if (__dosexec_find_on_path (p
, NULL
, shellpath
))
1275 for (tp
= shellpath
; *tp
; tp
++)
1279 v
= define_variable_loc (varname
, strlen (varname
),
1280 shellpath
, origin
, flavor
== f_recursive
,
1285 const char *shellbase
, *bslash
;
1286 struct variable
*pathv
= lookup_variable ("PATH", 4);
1291 shellbase
= strrchr (p
, '/');
1292 bslash
= strrchr (p
, '\\');
1293 if (!shellbase
|| bslash
> shellbase
)
1295 if (!shellbase
&& p
[1] == ':')
1302 /* Search for the basename of the shell (with standard
1303 executable extensions) along the $PATH. */
1305 pathlen
= strlen (pathv
->value
);
1306 path_string
= xmalloc (5 + pathlen
+ 2 + 1);
1307 /* On MSDOS, current directory is considered as part of $PATH. */
1308 sprintf (path_string
, "PATH=.;%s", pathv
? pathv
->value
: "");
1309 fake_env
[0] = path_string
;
1311 if (__dosexec_find_on_path (shellbase
, fake_env
, shellpath
))
1315 for (tp
= shellpath
; *tp
; tp
++)
1319 v
= define_variable_loc (varname
, strlen (varname
),
1321 flavor
== f_recursive
, flocp
);
1324 v
= lookup_variable (varname
, strlen (varname
));
1330 #endif /* __MSDOS__ */
1332 if ((origin
== o_file
|| origin
== o_override
|| origin
== o_command
)
1333 && streq (varname
, "SHELL"))
1335 extern char *default_shell
;
1337 /* Call shell locator function. If it returns TRUE, then
1338 set no_default_sh_exe to indicate sh was found and
1339 set new value for SHELL variable. */
1341 if (find_and_set_default_shell (p
))
1343 v
= define_variable_in_set (varname
, strlen (varname
), default_shell
,
1344 origin
, flavor
== f_recursive
,
1346 ? current_variable_set_list
->set
1349 no_default_sh_exe
= 0;
1353 char *tp
= alloc_value
;
1355 alloc_value
= allocated_variable_expand (p
);
1357 if (find_and_set_default_shell (alloc_value
))
1359 v
= define_variable_in_set (varname
, strlen (varname
), p
,
1360 origin
, flavor
== f_recursive
,
1362 ? current_variable_set_list
->set
1365 no_default_sh_exe
= 0;
1368 v
= lookup_variable (varname
, strlen (varname
));
1377 /* If we are defining variables inside an $(eval ...), we might have a
1378 different variable context pushed, not the global context (maybe we're
1379 inside a $(call ...) or something. Since this function is only ever
1380 invoked in places where we want to define globally visible variables,
1381 make sure we define this variable in the global set. */
1383 v
= define_variable_in_set (varname
, strlen (varname
), p
,
1384 origin
, flavor
== f_recursive
,
1386 ? current_variable_set_list
->set
: NULL
),
1389 v
->conditional
= conditional
;
1394 return v
->special
? set_special_var (v
) : v
;
1397 /* Parse P (a null-terminated string) as a variable definition.
1399 If it is not a variable definition, return NULL and the contents of *VAR
1400 are undefined, except NAME is set to the first non-space character or NIL.
1402 If it is a variable definition, return a pointer to the char after the
1403 assignment token and set the following fields (only) of *VAR:
1404 name : name of the variable (ALWAYS SET) (NOT NUL-TERMINATED!)
1405 length : length of the variable name
1406 value : value of the variable (nul-terminated)
1407 flavor : flavor of the variable
1408 Other values in *VAR are unchanged.
1412 parse_variable_definition (const char *p
, struct variable
*var
)
1415 const char *e
= NULL
;
1418 var
->name
= (char *)p
;
1425 /* If we find a comment or EOS, it's not a variable definition. */
1426 if (c
== '\0' || c
== '#')
1431 /* This begins a variable expansion reference. Make sure we don't
1432 treat chars inside the reference as assignment tokens. */
1441 /* '$$' or '$X'. Either way, nothing special to do here. */
1444 /* P now points past the opening paren or brace.
1445 Count parens or braces until it is matched. */
1447 for (; *p
!= '\0'; ++p
)
1451 else if (*p
== closeparen
&& --count
< 0)
1460 /* If we find whitespace skip it, and remember we found it. */
1461 if (isblank ((unsigned char)c
))
1475 var
->flavor
= f_recursive
;
1481 /* Match assignment variants (:=, +=, ?=, !=) */
1487 var
->flavor
= f_simple
;
1490 var
->flavor
= f_append
;
1493 var
->flavor
= f_conditional
;
1496 var
->flavor
= f_shell
;
1499 /* If we skipped whitespace, non-assignments means no var. */
1503 /* Might be assignment, or might be $= or #=. Check. */
1512 /* Check for POSIX ::= syntax */
1515 /* A colon other than :=/::= is not a variable defn. */
1516 if (*p
!= ':' || p
[1] != '=')
1519 /* POSIX allows ::= to be the same as GNU make's := */
1520 var
->flavor
= f_simple
;
1527 /* If we skipped whitespace, non-assignments means no var. */
1532 var
->length
= e
- var
->name
;
1533 var
->value
= next_token (p
);
1537 /* Try to interpret LINE (a null-terminated string) as a variable definition.
1539 If LINE was recognized as a variable definition, a pointer to its 'struct
1540 variable' is returned. If LINE is not a variable definition, NULL is
1544 assign_variable_definition (struct variable
*v
, char *line
)
1548 if (!parse_variable_definition (line
, v
))
1551 /* Expand the name, so "$(foo)bar = baz" works. */
1552 name
= alloca (v
->length
+ 1);
1553 memcpy (name
, v
->name
, v
->length
);
1554 name
[v
->length
] = '\0';
1555 v
->name
= allocated_variable_expand (name
);
1557 if (v
->name
[0] == '\0')
1558 fatal (&v
->fileinfo
, _("empty variable name"));
1563 /* Try to interpret LINE (a null-terminated string) as a variable definition.
1565 ORIGIN may be o_file, o_override, o_env, o_env_override,
1566 or o_command specifying that the variable definition comes
1567 from a makefile, an override directive, the environment with
1568 or without the -e switch, or the command line.
1570 See the comments for assign_variable_definition().
1572 If LINE was recognized as a variable definition, a pointer to its 'struct
1573 variable' is returned. If LINE is not a variable definition, NULL is
1577 try_variable_definition (const struct floc
*flocp
, char *line
,
1578 enum variable_origin origin
, int target_var
)
1581 struct variable
*vp
;
1584 v
.fileinfo
= *flocp
;
1586 v
.fileinfo
.filenm
= 0;
1588 if (!assign_variable_definition (&v
, line
))
1591 vp
= do_variable_definition (flocp
, v
.name
, v
.value
,
1592 origin
, v
.flavor
, target_var
);
1599 /* Print information for variable V, prefixing it with PREFIX. */
1602 print_variable (const void *item
, void *arg
)
1604 const struct variable
*v
= item
;
1605 const char *prefix
= arg
;
1611 origin
= _("automatic");
1614 origin
= _("default");
1617 origin
= _("environment");
1620 origin
= _("makefile");
1622 case o_env_override
:
1623 origin
= _("environment under -e");
1626 origin
= _("command line");
1629 origin
= _("'override' directive");
1635 fputs ("# ", stdout
);
1636 fputs (origin
, stdout
);
1638 fputs (" private", stdout
);
1639 if (v
->fileinfo
.filenm
)
1640 printf (_(" (from '%s', line %lu)"),
1641 v
->fileinfo
.filenm
, v
->fileinfo
.lineno
);
1643 fputs (prefix
, stdout
);
1645 /* Is this a 'define'? */
1646 if (v
->recursive
&& strchr (v
->value
, '\n') != 0)
1647 printf ("define %s\n%s\nendef\n", v
->name
, v
->value
);
1652 printf ("%s %s= ", v
->name
, v
->recursive
? v
->append
? "+" : "" : ":");
1654 /* Check if the value is just whitespace. */
1655 p
= next_token (v
->value
);
1656 if (p
!= v
->value
&& *p
== '\0')
1657 /* All whitespace. */
1658 printf ("$(subst ,,%s)", v
->value
);
1659 else if (v
->recursive
)
1660 fputs (v
->value
, stdout
);
1662 /* Double up dollar signs. */
1663 for (p
= v
->value
; *p
!= '\0'; ++p
)
1675 print_auto_variable (const void *item
, void *arg
)
1677 const struct variable
*v
= item
;
1679 if (v
->origin
== o_automatic
)
1680 print_variable (item
, arg
);
1685 print_noauto_variable (const void *item
, void *arg
)
1687 const struct variable
*v
= item
;
1689 if (v
->origin
!= o_automatic
)
1690 print_variable (item
, arg
);
1694 /* Print all the variables in SET. PREFIX is printed before
1695 the actual variable definitions (everything else is comments). */
1698 print_variable_set (struct variable_set
*set
, char *prefix
, int pauto
)
1700 hash_map_arg (&set
->table
, (pauto
? print_auto_variable
: print_variable
),
1703 fputs (_("# variable set hash-table stats:\n"), stdout
);
1704 fputs ("# ", stdout
);
1705 hash_print_stats (&set
->table
, stdout
);
1706 putc ('\n', stdout
);
1709 /* Print the data base of variables. */
1712 print_variable_data_base (void)
1714 puts (_("\n# Variables\n"));
1716 print_variable_set (&global_variable_set
, "", 0);
1718 puts (_("\n# Pattern-specific Variable Values"));
1721 struct pattern_var
*p
;
1724 for (p
= pattern_vars
; p
!= 0; p
= p
->next
)
1727 printf ("\n%s :\n", p
->target
);
1728 print_variable (&p
->variable
, "# ");
1732 puts (_("\n# No pattern-specific variable values."));
1734 printf (_("\n# %u pattern-specific variable values"), rules
);
1739 /* Print all the local variables of FILE. */
1742 print_file_variables (const struct file
*file
)
1744 if (file
->variables
!= 0)
1745 print_variable_set (file
->variables
->set
, "# ", 1);
1749 print_target_variables (const struct file
*file
)
1751 if (file
->variables
!= 0)
1753 int l
= strlen (file
->name
);
1754 char *t
= alloca (l
+ 3);
1756 strcpy (t
, file
->name
);
1761 hash_map_arg (&file
->variables
->set
->table
, print_noauto_variable
, t
);
1767 sync_Path_environment (void)
1769 char *path
= allocated_variable_expand ("$(PATH)");
1770 static char *environ_path
= NULL
;
1776 * If done this before, don't leak memory unnecessarily.
1777 * Free the previous entry before allocating new one.
1780 free (environ_path
);
1783 * Create something WINDOWS32 world can grok
1785 convert_Path_to_windows32 (path
, ';');
1786 environ_path
= xstrdup (concat (3, "PATH", "=", path
));
1787 putenv (environ_path
);