1 /* Internals of variables for GNU Make.
2 Copyright (C) 1988,89,90,91,92,93,94,96,97 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
28 #include "pathstuff.h"
31 /* Hash table of all global variable definitions. */
33 #ifndef VARIABLE_BUCKETS
34 #define VARIABLE_BUCKETS 523
36 #ifndef PERFILE_VARIABLE_BUCKETS
37 #define PERFILE_VARIABLE_BUCKETS 23
39 #ifndef SMALL_SCOPE_VARIABLE_BUCKETS
40 #define SMALL_SCOPE_VARIABLE_BUCKETS 13
42 static struct variable
*variable_table
[VARIABLE_BUCKETS
];
43 static struct variable_set global_variable_set
44 = { variable_table
, VARIABLE_BUCKETS
};
45 static struct variable_set_list global_setlist
46 = { 0, &global_variable_set
};
47 struct variable_set_list
*current_variable_set_list
= &global_setlist
;
49 static struct variable
*lookup_variable_in_set
PARAMS ((char *name
,
50 unsigned int length
, struct variable_set
*set
));
52 /* Implement variables. */
54 /* Define variable named NAME with value VALUE in SET. VALUE is copied.
55 LENGTH is the length of NAME, which does not need to be null-terminated.
56 ORIGIN specifies the origin of the variable (makefile, command line
58 If RECURSIVE is nonzero a flag is set in the variable saying
59 that it should be recursively re-expanded. */
62 define_variable_in_set (name
, length
, value
, origin
, recursive
, set
, flocp
)
66 enum variable_origin origin
;
68 struct variable_set
*set
;
69 const struct floc
*flocp
;
71 register unsigned int i
;
72 register unsigned int hashval
;
73 register struct variable
*v
;
76 for (i
= 0; i
< length
; ++i
)
77 HASH (hashval
, name
[i
]);
78 hashval
%= set
->buckets
;
80 for (v
= set
->table
[hashval
]; v
!= 0; v
= v
->next
)
82 && strneq (v
->name
+ 1, name
+ 1, length
- 1)
83 && v
->name
[length
] == '\0')
86 if (env_overrides
&& origin
== o_env
)
87 origin
= o_env_override
;
91 if (env_overrides
&& v
->origin
== o_env
)
92 /* V came from in the environment. Since it was defined
93 before the switches were parsed, it wasn't affected by -e. */
94 v
->origin
= o_env_override
;
96 /* A variable of this name is already defined.
97 If the old definition is from a stronger source
98 than this one, don't redefine it. */
99 if ((int) origin
>= (int) v
->origin
)
103 v
->value
= xstrdup (value
);
105 v
->fileinfo
= *flocp
;
107 v
->fileinfo
.filenm
= 0;
109 v
->recursive
= recursive
;
114 /* Create a new variable definition and add it to the hash table. */
116 v
= (struct variable
*) xmalloc (sizeof (struct variable
));
117 v
->name
= savestring (name
, length
);
118 v
->value
= xstrdup (value
);
120 v
->fileinfo
= *flocp
;
122 v
->fileinfo
.filenm
= 0;
124 v
->recursive
= recursive
;
128 v
->export
= v_default
;
129 v
->next
= set
->table
[hashval
];
130 set
->table
[hashval
] = v
;
134 /* Lookup a variable whose name is a string starting at NAME
135 and with LENGTH chars. NAME need not be null-terminated.
136 Returns address of the `struct variable' containing all info
137 on the variable, or nil if no such variable is defined.
139 If we find a variable which is in the process of being expanded,
140 try to find one further up the set_list chain. If we don't find
141 one that isn't being expanded, return a pointer to whatever we
145 lookup_variable (name
, length
)
149 register struct variable_set_list
*setlist
;
150 struct variable
*firstv
= 0;
152 register unsigned int i
;
153 register unsigned int rawhash
= 0;
155 for (i
= 0; i
< length
; ++i
)
156 HASH (rawhash
, name
[i
]);
158 for (setlist
= current_variable_set_list
;
159 setlist
!= 0; setlist
= setlist
->next
)
161 register struct variable_set
*set
= setlist
->set
;
162 register unsigned int hashval
= rawhash
% set
->buckets
;
163 register struct variable
*v
;
165 /* Look through this set list. */
166 for (v
= set
->table
[hashval
]; v
!= 0; v
= v
->next
)
167 if (*v
->name
== *name
168 && strneq (v
->name
+ 1, name
+ 1, length
- 1)
169 && v
->name
[length
] == '\0')
172 /* If we didn't find anything, go to the next set list. */
176 /* If it's not being expanded already, we're done. */
180 /* It is, so try to find another one. If this is the first one we've
181 seen, keep a pointer in case we don't find anything else. */
187 /* since we don't read envp[] on startup, try to get the
188 variable via getenv() here. */
191 char *vname
= alloca (length
+ 1);
193 strncpy (vname
, name
, length
);
195 value
= getenv (vname
);
205 *listp
= current_variable_set_list
;
207 while ((sptr
= strchr (sptr
, '$')))
218 nvalue
= alloca (length
+ scnt
+ 1);
236 return define_variable (vname
, length
, nvalue
, o_env
, 1);
240 return define_variable (vname
, length
, value
, o_env
, 1);
248 /* Lookup a variable whose name is a string starting at NAME
249 and with LENGTH chars in set SET. NAME need not be null-terminated.
250 Returns address of the `struct variable' containing all info
251 on the variable, or nil if no such variable is defined. */
253 static struct variable
*
254 lookup_variable_in_set (name
, length
, set
)
257 struct variable_set
*set
;
259 register unsigned int i
;
260 register unsigned int hash
= 0;
261 register struct variable
*v
;
263 for (i
= 0; i
< length
; ++i
)
264 HASH (hash
, name
[i
]);
265 hash
%= set
->buckets
;
267 for (v
= set
->table
[hash
]; v
!= 0; v
= v
->next
)
268 if (*v
->name
== *name
269 && strneq (v
->name
+ 1, name
+ 1, length
- 1)
270 && v
->name
[length
] == 0)
276 /* Initialize FILE's variable set list. If FILE already has a variable set
277 list, the topmost variable set is left intact, but the the rest of the
278 chain is replaced with FILE->parent's setlist. If we're READing a
279 makefile, don't do the pattern variable search now, since the pattern
280 variable might not have been defined yet. */
283 initialize_file_variables (file
, reading
)
287 register struct variable_set_list
*l
= file
->variables
;
291 l
= (struct variable_set_list
*)
292 xmalloc (sizeof (struct variable_set_list
));
293 l
->set
= (struct variable_set
*) xmalloc (sizeof (struct variable_set
));
294 l
->set
->buckets
= PERFILE_VARIABLE_BUCKETS
;
295 l
->set
->table
= (struct variable
**)
296 xmalloc (l
->set
->buckets
* sizeof (struct variable
*));
297 bzero ((char *) l
->set
->table
,
298 l
->set
->buckets
* sizeof (struct variable
*));
302 if (file
->parent
== 0)
303 l
->next
= &global_setlist
;
306 initialize_file_variables (file
->parent
, reading
);
307 l
->next
= file
->parent
->variables
;
310 /* If we're not reading makefiles and we haven't looked yet, see if
311 we can find a pattern variable. */
313 if (!reading
&& !file
->pat_searched
)
315 struct pattern_var
*p
= lookup_pattern_var (file
->name
);
317 file
->pat_searched
= 1;
320 /* If we found one, insert it between the current target's
321 variables and the next set, whatever it is. */
322 file
->pat_variables
= (struct variable_set_list
*)
323 xmalloc (sizeof (struct variable_set_list
));
324 file
->pat_variables
->set
= p
->vars
->set
;
328 /* If we have a pattern variable match, set it up. */
330 if (file
->pat_variables
!= 0)
332 file
->pat_variables
->next
= l
->next
;
333 l
->next
= file
->pat_variables
;
337 /* Pop the top set off the current variable set list,
338 and free all its storage. */
341 pop_variable_scope ()
343 register struct variable_set_list
*setlist
= current_variable_set_list
;
344 register struct variable_set
*set
= setlist
->set
;
345 register unsigned int i
;
347 current_variable_set_list
= setlist
->next
;
348 free ((char *) setlist
);
350 for (i
= 0; i
< set
->buckets
; ++i
)
352 register struct variable
*next
= set
->table
[i
];
355 register struct variable
*v
= next
;
364 free ((char *) set
->table
);
368 struct variable_set_list
*
369 create_new_variable_set ()
371 register struct variable_set_list
*setlist
;
372 register struct variable_set
*set
;
374 set
= (struct variable_set
*) xmalloc (sizeof (struct variable_set
));
375 set
->buckets
= SMALL_SCOPE_VARIABLE_BUCKETS
;
376 set
->table
= (struct variable
**)
377 xmalloc (set
->buckets
* sizeof (struct variable
*));
378 bzero ((char *) set
->table
, set
->buckets
* sizeof (struct variable
*));
380 setlist
= (struct variable_set_list
*)
381 xmalloc (sizeof (struct variable_set_list
));
383 setlist
->next
= current_variable_set_list
;
388 /* Create a new variable set and push it on the current setlist. */
390 struct variable_set_list
*
391 push_new_variable_scope ()
393 return (current_variable_set_list
= create_new_variable_set());
396 /* Merge SET1 into SET0, freeing unused storage in SET1. */
399 merge_variable_sets (set0
, set1
)
400 struct variable_set
*set0
, *set1
;
402 register unsigned int bucket1
;
404 for (bucket1
= 0; bucket1
< set1
->buckets
; ++bucket1
)
406 register struct variable
*v1
= set1
->table
[bucket1
];
409 struct variable
*next
= v1
->next
;
410 unsigned int bucket0
;
411 register struct variable
*v0
;
413 if (set1
->buckets
>= set0
->buckets
)
419 for (n
= v1
->name
; *n
!= '\0'; ++n
)
422 bucket0
%= set0
->buckets
;
424 for (v0
= set0
->table
[bucket0
]; v0
!= 0; v0
= v0
->next
)
425 if (streq (v0
->name
, v1
->name
))
430 /* There is no variable in SET0 with the same name. */
431 v1
->next
= set0
->table
[bucket0
];
432 set0
->table
[bucket0
] = v1
;
436 /* The same variable exists in both sets.
437 SET0 takes precedence. */
447 /* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */
450 merge_variable_set_lists (setlist0
, setlist1
)
451 struct variable_set_list
**setlist0
, *setlist1
;
453 register struct variable_set_list
*list0
= *setlist0
;
454 struct variable_set_list
*last0
= 0;
456 while (setlist1
!= 0 && list0
!= 0)
458 struct variable_set_list
*next
= setlist1
;
459 setlist1
= setlist1
->next
;
461 merge_variable_sets (list0
->set
, next
->set
);
470 *setlist0
= setlist1
;
472 last0
->next
= setlist1
;
476 /* Define the automatic variables, and record the addresses
477 of their structures so we can change their values quickly. */
480 define_automatic_variables ()
483 extern char* default_shell
;
485 extern char default_shell
[];
487 register struct variable
*v
;
490 sprintf (buf
, "%u", makelevel
);
491 (void) define_variable ("MAKELEVEL", 9, buf
, o_env
, 0);
493 sprintf (buf
, "%s%s%s",
495 (remote_description
== 0 || remote_description
[0] == '\0')
497 (remote_description
== 0 || remote_description
[0] == '\0')
498 ? "" : remote_description
);
499 (void) define_variable ("MAKE_VERSION", 12, buf
, o_default
, 0);
502 /* Allow to specify a special shell just for Make,
503 and use $COMSPEC as the default $SHELL when appropriate. */
505 static char shell_str
[] = "SHELL";
506 const int shlen
= sizeof (shell_str
) - 1;
507 struct variable
*mshp
= lookup_variable ("MAKESHELL", 9);
508 struct variable
*comp
= lookup_variable ("COMSPEC", 7);
510 /* Make $MAKESHELL override $SHELL even if -e is in effect. */
512 (void) define_variable (shell_str
, shlen
,
513 mshp
->value
, o_env_override
, 0);
516 /* $COMSPEC shouldn't override $SHELL. */
517 struct variable
*shp
= lookup_variable (shell_str
, shlen
);
520 (void) define_variable (shell_str
, shlen
, comp
->value
, o_env
, 0);
525 /* This won't override any definition, but it
526 will provide one if there isn't one there. */
527 v
= define_variable ("SHELL", 5, default_shell
, o_default
, 0);
528 v
->export
= v_export
; /* Always export SHELL. */
530 /* On MSDOS we do use SHELL from environment, since
531 it isn't a standard environment variable on MSDOS,
532 so whoever sets it, does that on purpose. */
534 /* Don't let SHELL come from the environment. */
535 if (*v
->value
== '\0' || v
->origin
== o_env
|| v
->origin
== o_env_override
)
539 v
->value
= xstrdup (default_shell
);
543 /* Make sure MAKEFILES gets exported if it is set. */
544 v
= define_variable ("MAKEFILES", 9, "", o_default
, 0);
547 /* Define the magic D and F variables in terms of
548 the automatic variables they are variations of. */
551 define_variable ("@D", 2, "$(dir $@)", o_automatic
, 1);
552 define_variable ("%D", 2, "$(dir $%)", o_automatic
, 1);
553 define_variable ("*D", 2, "$(dir $*)", o_automatic
, 1);
554 define_variable ("<D", 2, "$(dir $<)", o_automatic
, 1);
555 define_variable ("?D", 2, "$(dir $?)", o_automatic
, 1);
556 define_variable ("^D", 2, "$(dir $^)", o_automatic
, 1);
557 define_variable ("+D", 2, "$(dir $+)", o_automatic
, 1);
559 define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic
, 1);
560 define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic
, 1);
561 define_variable ("*D", 2, "$(patsubst %/,%,$(dir $*))", o_automatic
, 1);
562 define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic
, 1);
563 define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic
, 1);
564 define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic
, 1);
565 define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic
, 1);
567 define_variable ("@F", 2, "$(notdir $@)", o_automatic
, 1);
568 define_variable ("%F", 2, "$(notdir $%)", o_automatic
, 1);
569 define_variable ("*F", 2, "$(notdir $*)", o_automatic
, 1);
570 define_variable ("<F", 2, "$(notdir $<)", o_automatic
, 1);
571 define_variable ("?F", 2, "$(notdir $?)", o_automatic
, 1);
572 define_variable ("^F", 2, "$(notdir $^)", o_automatic
, 1);
573 define_variable ("+F", 2, "$(notdir $+)", o_automatic
, 1);
576 int export_all_variables
;
578 /* Create a new environment for FILE's commands.
579 If FILE is nil, this is for the `shell' function.
580 The child's MAKELEVEL variable is incremented. */
583 target_environment (file
)
586 struct variable_set_list
*set_list
;
587 register struct variable_set_list
*s
;
588 struct variable_bucket
590 struct variable_bucket
*next
;
591 struct variable
*variable
;
593 struct variable_bucket
**table
;
594 unsigned int buckets
;
595 register unsigned int i
;
596 register unsigned nvariables
;
598 unsigned int mklev_hash
;
601 set_list
= current_variable_set_list
;
603 set_list
= file
->variables
;
605 /* Find the lowest number of buckets in any set in the list. */
607 buckets
= s
->set
->buckets
;
608 for (s
= s
->next
; s
!= 0; s
= s
->next
)
609 if (s
->set
->buckets
< buckets
)
610 buckets
= s
->set
->buckets
;
612 /* Find the hash value of the bucket `MAKELEVEL' will fall into. */
614 char *p
= "MAKELEVEL";
617 HASH (mklev_hash
, *p
++);
620 /* Temporarily allocate a table with that many buckets. */
621 table
= (struct variable_bucket
**)
622 alloca (buckets
* sizeof (struct variable_bucket
*));
623 bzero ((char *) table
, buckets
* sizeof (struct variable_bucket
*));
625 /* Run through all the variable sets in the list,
626 accumulating variables in TABLE. */
628 for (s
= set_list
; s
!= 0; s
= s
->next
)
630 register struct variable_set
*set
= s
->set
;
631 for (i
= 0; i
< set
->buckets
; ++i
)
633 register struct variable
*v
;
634 for (v
= set
->table
[i
]; v
!= 0; v
= v
->next
)
636 unsigned int j
= i
% buckets
;
637 register struct variable_bucket
*ov
;
638 register char *p
= v
->name
;
640 if (i
== mklev_hash
% set
->buckets
641 && streq (v
->name
, "MAKELEVEL"))
642 /* Don't include MAKELEVEL because it will be
643 added specially at the end. */
646 /* If this is a per-target variable and it hasn't been touched
647 already then look up the global version and take its export
649 if (v
->per_target
&& v
->export
== v_default
)
653 gv
= lookup_variable_in_set(v
->name
, strlen(v
->name
),
654 &global_variable_set
);
656 v
->export
= gv
->export
;
662 if (v
->origin
== o_default
|| v
->origin
== o_automatic
)
663 /* Only export default variables by explicit request. */
666 if (! export_all_variables
667 && v
->origin
!= o_command
668 && v
->origin
!= o_env
&& v
->origin
!= o_env_override
)
671 if (*p
!= '_' && (*p
< 'A' || *p
> 'Z')
672 && (*p
< 'a' || *p
> 'z'))
674 for (++p
; *p
!= '\0'; ++p
)
675 if (*p
!= '_' && (*p
< 'a' || *p
> 'z')
676 && (*p
< 'A' || *p
> 'Z') && (*p
< '0' || *p
> '9'))
689 if (v
->origin
== o_default
)
694 /* If this was from a different-sized hash table, then
695 recalculate the bucket it goes in. */
696 if (set
->buckets
!= buckets
)
701 for (np
= v
->name
; *np
!= '\0'; ++np
)
706 for (ov
= table
[j
]; ov
!= 0; ov
= ov
->next
)
707 if (streq (v
->name
, ov
->variable
->name
))
712 register struct variable_bucket
*entry
;
713 entry
= (struct variable_bucket
*)
714 alloca (sizeof (struct variable_bucket
));
715 entry
->next
= table
[j
];
724 result
= (char **) xmalloc ((nvariables
+ 2) * sizeof (char *));
726 for (i
= 0; i
< buckets
; ++i
)
728 register struct variable_bucket
*b
;
729 for (b
= table
[i
]; b
!= 0; b
= b
->next
)
731 register struct variable
*v
= b
->variable
;
733 /* If V is recursively expanded and didn't come from the environment,
734 expand its value. If it came from the environment, it should
735 go back into the environment unchanged. */
737 && v
->origin
!= o_env
&& v
->origin
!= o_env_override
)
739 char *value
= recursively_expand (v
);
741 if (strcmp(v
->name
, "Path") == 0 ||
742 strcmp(v
->name
, "PATH") == 0)
743 convert_Path_to_windows32(value
, ';');
745 result
[nvariables
++] = concat (v
->name
, "=", value
);
751 if (strcmp(v
->name
, "Path") == 0 ||
752 strcmp(v
->name
, "PATH") == 0)
753 convert_Path_to_windows32(v
->value
, ';');
754 result
[nvariables
++] = concat (v
->name
, "=", v
->value
);
757 result
[nvariables
++] = concat (v
->name
, "=", v
->value
);
761 result
[nvariables
] = (char *) xmalloc (100);
762 (void) sprintf (result
[nvariables
], "MAKELEVEL=%u", makelevel
+ 1);
763 result
[++nvariables
] = 0;
768 /* Try to interpret LINE (a null-terminated string) as a variable definition.
770 ORIGIN may be o_file, o_override, o_env, o_env_override,
771 or o_command specifying that the variable definition comes
772 from a makefile, an override directive, the environment with
773 or without the -e switch, or the command line.
775 See the comments for parse_variable_definition().
777 If LINE was recognized as a variable definition, a pointer to its `struct
778 variable' is returned. If LINE is not a variable definition, NULL is
782 try_variable_definition (flocp
, line
, origin
, target_var
)
783 const struct floc
*flocp
;
785 enum variable_origin origin
;
789 register char *p
= line
;
793 f_simple
, f_recursive
, f_append
, f_conditional
} flavor
= f_bogus
;
794 char *name
, *expanded_name
, *value
, *alloc_value
=NULL
;
801 if (c
== '\0' || c
== '#')
806 flavor
= f_recursive
;
817 /* A colon other than := is a rule line, not a variable defn. */
819 else if (c
== '+' && *p
== '=')
825 else if (c
== '?' && *p
== '=')
828 flavor
= f_conditional
;
833 /* This might begin a variable expansion reference. Make sure we
834 don't misrecognize chars inside the reference as =, := or +=. */
843 continue; /* Nope. */
845 /* P now points past the opening paren or brace.
846 Count parens or braces until it is matched. */
848 for (; *p
!= '\0'; ++p
)
852 else if (*p
== closeparen
&& --count
< 0)
861 beg
= next_token (line
);
862 while (end
> beg
&& isblank (end
[-1]))
866 /* Expand the name, so "$(foo)bar = baz" works. */
867 name
= (char *) alloca (end
- beg
+ 1);
868 bcopy (beg
, name
, end
- beg
);
869 name
[end
- beg
] = '\0';
870 expanded_name
= allocated_variable_expand (name
);
872 if (expanded_name
[0] == '\0')
873 fatal (flocp
, _("empty variable name"));
875 /* Calculate the variable's new value in VALUE. */
880 /* Should not be possible. */
883 /* A simple variable definition "var := value". Expand the value.
884 We have to allocate memory since otherwise it'll clobber the
885 variable buffer, and we may still need that if we're looking at a
886 target-specific variable. */
887 value
= alloc_value
= allocated_variable_expand (p
);
890 /* A conditional variable definition "var ?= value".
891 The value is set IFF the variable is not defined yet. */
892 v
= lookup_variable(expanded_name
, strlen(expanded_name
));
898 flavor
= f_recursive
;
901 /* A recursive variable definition "var = value".
902 The value is used verbatim. */
906 /* If we have += but we're in a target variable context, defer the
907 append until the context expansion. */
911 flavor
= f_recursive
;
916 /* An appending variable definition "var += value".
917 Extract the old value and append the new one. */
918 v
= lookup_variable (expanded_name
, strlen (expanded_name
));
921 /* There was no old value.
922 This becomes a normal recursive definition. */
924 flavor
= f_recursive
;
928 /* Paste the old and new values together in VALUE. */
930 unsigned int oldlen
, newlen
;
933 /* The previous definition of the variable was recursive.
934 The new value comes from the unexpanded old and new values. */
935 flavor
= f_recursive
;
937 /* The previous definition of the variable was simple.
938 The new value comes from the old value, which was expanded
939 when it was set; and from the expanded new value. Allocate
940 memory for the expansion as we may still need the rest of the
941 buffer if we're looking at a target-specific variable. */
942 p
= alloc_value
= allocated_variable_expand (p
);
944 oldlen
= strlen (v
->value
);
946 value
= (char *) alloca (oldlen
+ 1 + newlen
+ 1);
947 bcopy (v
->value
, value
, oldlen
);
949 bcopy (p
, &value
[oldlen
+ 1], newlen
+ 1);
954 /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
955 non-Unix systems don't conform to this default configuration (in
956 fact, most of them don't even have `/bin'). On the other hand,
957 $SHELL in the environment, if set, points to the real pathname of
959 Therefore, we generally won't let lines like "SHELL=/bin/sh" from
960 the Makefile override $SHELL from the environment. But first, we
961 look for the basename of the shell in the directory where SHELL=
962 points, and along the $PATH; if it is found in any of these places,
963 we define $SHELL to be the actual pathname of the shell. Thus, if
964 you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on
965 your $PATH, then SHELL=/usr/local/bin/bash will have the effect of
966 defining SHELL to be "d:/unix/bash.exe". */
967 if ((origin
== o_file
|| origin
== o_override
)
968 && strcmp (expanded_name
, "SHELL") == 0)
970 char shellpath
[PATH_MAX
];
971 extern char * __dosexec_find_on_path (const char *, char *[], char *);
973 /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */
974 if (__dosexec_find_on_path (value
, (char **)0, shellpath
))
978 for (p
= shellpath
; *p
; p
++)
983 v
= define_variable_loc (expanded_name
, strlen (expanded_name
),
984 shellpath
, origin
, flavor
== f_recursive
,
989 char *shellbase
, *bslash
;
990 struct variable
*pathv
= lookup_variable ("PATH", 4);
995 shellbase
= strrchr (value
, '/');
996 bslash
= strrchr (value
, '\\');
997 if (!shellbase
|| bslash
> shellbase
)
999 if (!shellbase
&& value
[1] == ':')
1000 shellbase
= value
+ 1;
1006 /* Search for the basename of the shell (with standard
1007 executable extensions) along the $PATH. */
1009 pathlen
= strlen (pathv
->value
);
1010 path_string
= (char *)xmalloc (5 + pathlen
+ 2 + 1);
1011 /* On MSDOS, current directory is considered as part of $PATH. */
1012 sprintf (path_string
, "PATH=.;%s", pathv
? pathv
->value
: "");
1013 fake_env
[0] = path_string
;
1014 fake_env
[1] = (char *)0;
1015 if (__dosexec_find_on_path (shellbase
, fake_env
, shellpath
))
1019 for (p
= shellpath
; *p
; p
++)
1024 v
= define_variable_loc (expanded_name
, strlen (expanded_name
),
1026 flavor
== f_recursive
, flocp
);
1029 v
= lookup_variable (expanded_name
, strlen (expanded_name
));
1035 #endif /* __MSDOS__ */
1037 if ((origin
== o_file
|| origin
== o_override
)
1038 && strcmp (expanded_name
, "SHELL") == 0) {
1039 extern char* default_shell
;
1042 * Call shell locator function. If it returns TRUE, then
1043 * set no_default_sh_exe to indicate sh was found and
1044 * set new value for SHELL variable.
1046 if (find_and_set_default_shell(value
)) {
1047 v
= define_variable_loc (expanded_name
, strlen (expanded_name
),
1048 default_shell
, origin
, flavor
== f_recursive
,
1050 no_default_sh_exe
= 0;
1055 v
= define_variable_loc (expanded_name
, strlen (expanded_name
), value
,
1056 origin
, flavor
== f_recursive
, flocp
);
1062 free (expanded_name
);
1067 /* Print information for variable V, prefixing it with PREFIX. */
1070 print_variable (v
, prefix
)
1071 register struct variable
*v
;
1079 origin
= _("default");
1082 origin
= _("environment");
1085 origin
= _("makefile");
1087 case o_env_override
:
1088 origin
= _("environment under -e");
1091 origin
= _("command line");
1094 origin
= _("`override' directive");
1097 origin
= _("automatic");
1103 fputs ("# ", stdout
);
1104 fputs (origin
, stdout
);
1105 if (v
->fileinfo
.filenm
)
1106 printf (" (from `%s', line %lu)", v
->fileinfo
.filenm
, v
->fileinfo
.lineno
);
1108 fputs (prefix
, stdout
);
1110 /* Is this a `define'? */
1111 if (v
->recursive
&& strchr (v
->value
, '\n') != 0)
1112 printf ("define %s\n%s\nendef\n", v
->name
, v
->value
);
1117 printf ("%s %s= ", v
->name
, v
->recursive
? v
->append
? "+" : "" : ":");
1119 /* Check if the value is just whitespace. */
1120 p
= next_token (v
->value
);
1121 if (p
!= v
->value
&& *p
== '\0')
1122 /* All whitespace. */
1123 printf ("$(subst ,,%s)", v
->value
);
1124 else if (v
->recursive
)
1125 fputs (v
->value
, stdout
);
1127 /* Double up dollar signs. */
1128 for (p
= v
->value
; *p
!= '\0'; ++p
)
1139 /* Print all the variables in SET. PREFIX is printed before
1140 the actual variable definitions (everything else is comments). */
1143 print_variable_set (set
, prefix
)
1144 register struct variable_set
*set
;
1147 register unsigned int i
, nvariables
, per_bucket
;
1148 register struct variable
*v
;
1150 per_bucket
= nvariables
= 0;
1151 for (i
= 0; i
< set
->buckets
; ++i
)
1153 register unsigned int this_bucket
= 0;
1155 for (v
= set
->table
[i
]; v
!= 0; v
= v
->next
)
1158 print_variable (v
, prefix
);
1161 nvariables
+= this_bucket
;
1162 if (this_bucket
> per_bucket
)
1163 per_bucket
= this_bucket
;
1166 if (nvariables
== 0)
1167 puts (_("# No variables."));
1170 printf (_("# %u variables in %u hash buckets.\n"),
1171 nvariables
, set
->buckets
);
1173 printf (_("# average of %.1f variables per bucket, \
1174 max %u in one bucket.\n"),
1175 (double) nvariables
/ (double) set
->buckets
,
1179 int f
= (nvariables
* 1000 + 5) / set
->buckets
;
1180 printf (_("# average of %d.%d variables per bucket, \
1181 max %u in one bucket.\n"),
1190 /* Print the data base of variables. */
1193 print_variable_data_base ()
1195 puts (_("\n# Variables\n"));
1197 print_variable_set (&global_variable_set
, "");
1201 /* Print all the local variables of FILE. */
1204 print_file_variables (file
)
1207 if (file
->variables
!= 0)
1208 print_variable_set (file
->variables
->set
, "# ");
1213 sync_Path_environment(void)
1215 char* path
= allocated_variable_expand("$(Path)");
1216 static char* environ_path
= NULL
;
1222 * If done this before, don't leak memory unnecessarily.
1223 * Free the previous entry before allocating new one.
1229 * Create something WINDOWS32 world can grok
1231 convert_Path_to_windows32(path
, ';');
1232 environ_path
= concat("Path", "=", path
);
1233 putenv(environ_path
);