1 /* Builtin function expansion for GNU Make.
2 Copyright (C) 1988,1989,1991-1997,1999 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. */
33 struct function_table_entry
37 unsigned char minimum_args
;
38 unsigned char maximum_args
;
40 char *(*func_ptr
) PARAMS ((char *output
, char **argv
, const char *fname
));
44 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing
45 each occurrence of SUBST with REPLACE. TEXT is null-terminated. SLEN is
46 the length of SUBST and RLEN is the length of REPLACE. If BY_WORD is
47 nonzero, substitutions are done only on matches which are complete
48 whitespace-delimited words. If SUFFIX_ONLY is nonzero, substitutions are
49 done only at the ends of whitespace-delimited words. */
52 subst_expand (o
, text
, subst
, replace
, slen
, rlen
, by_word
, suffix_only
)
55 char *subst
, *replace
;
56 unsigned int slen
, rlen
;
57 int by_word
, suffix_only
;
59 register char *t
= text
;
62 if (slen
== 0 && !by_word
&& !suffix_only
)
64 /* The first occurrence of "" in any string is its end. */
65 o
= variable_buffer_output (o
, t
, strlen (t
));
67 o
= variable_buffer_output (o
, replace
, rlen
);
73 if ((by_word
| suffix_only
) && slen
== 0)
74 /* When matching by words, the empty string should match
75 the end of each word, rather than the end of the whole text. */
76 p
= end_of_token (next_token (t
));
79 p
= sindex (t
, 0, subst
, slen
);
82 /* No more matches. Output everything left on the end. */
83 o
= variable_buffer_output (o
, t
, strlen (t
));
88 /* Output everything before this occurrence of the string to replace. */
90 o
= variable_buffer_output (o
, t
, p
- t
);
92 /* If we're substituting only by fully matched words,
93 or only at the ends of words, check that this case qualifies. */
95 && ((p
> t
&& !isblank ((unsigned char)p
[-1]))
96 || (p
[slen
] != '\0' && !isblank ((unsigned char)p
[slen
]))))
98 && (p
[slen
] != '\0' && !isblank ((unsigned char)p
[slen
]))))
99 /* Struck out. Output the rest of the string that is
100 no longer to be replaced. */
101 o
= variable_buffer_output (o
, subst
, slen
);
103 /* Output the replacement string. */
104 o
= variable_buffer_output (o
, replace
, rlen
);
106 /* Advance T past the string to be replaced. */
108 } while (*t
!= '\0');
114 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT
115 and replacing strings matching PATTERN with REPLACE.
116 If PATTERN_PERCENT is not nil, PATTERN has already been
117 run through find_percent, and PATTERN_PERCENT is the result.
118 If REPLACE_PERCENT is not nil, REPLACE has already been
119 run through find_percent, and REPLACE_PERCENT is the result. */
122 patsubst_expand (o
, text
, pattern
, replace
, pattern_percent
, replace_percent
)
125 register char *pattern
, *replace
;
126 register char *pattern_percent
, *replace_percent
;
128 unsigned int pattern_prepercent_len
, pattern_postpercent_len
;
129 unsigned int replace_prepercent_len
, replace_postpercent_len
= 0;
134 /* We call find_percent on REPLACE before checking PATTERN so that REPLACE
135 will be collapsed before we call subst_expand if PATTERN has no %. */
136 if (replace_percent
== 0)
137 replace_percent
= find_percent (replace
);
138 if (replace_percent
!= 0)
140 /* Record the length of REPLACE before and after the % so
141 we don't have to compute these lengths more than once. */
142 replace_prepercent_len
= replace_percent
- replace
;
143 replace_postpercent_len
= strlen (replace_percent
+ 1);
146 /* We store the length of the replacement
147 so we only need to compute it once. */
148 replace_prepercent_len
= strlen (replace
);
150 if (pattern_percent
== 0)
151 pattern_percent
= find_percent (pattern
);
152 if (pattern_percent
== 0)
153 /* With no % in the pattern, this is just a simple substitution. */
154 return subst_expand (o
, text
, pattern
, replace
,
155 strlen (pattern
), strlen (replace
), 1, 0);
157 /* Record the length of PATTERN before and after the %
158 so we don't have to compute it more than once. */
159 pattern_prepercent_len
= pattern_percent
- pattern
;
160 pattern_postpercent_len
= strlen (pattern_percent
+ 1);
162 while ((t
= find_next_token (&text
, &len
)) != 0)
166 /* Is it big enough to match? */
167 if (len
< pattern_prepercent_len
+ pattern_postpercent_len
)
170 /* Does the prefix match? */
171 if (!fail
&& pattern_prepercent_len
> 0
173 || t
[pattern_prepercent_len
- 1] != pattern_percent
[-1]
174 || !strneq (t
+ 1, pattern
+ 1, pattern_prepercent_len
- 1)))
177 /* Does the suffix match? */
178 if (!fail
&& pattern_postpercent_len
> 0
179 && (t
[len
- 1] != pattern_percent
[pattern_postpercent_len
]
180 || t
[len
- pattern_postpercent_len
] != pattern_percent
[1]
181 || !strneq (&t
[len
- pattern_postpercent_len
],
182 &pattern_percent
[1], pattern_postpercent_len
- 1)))
186 /* It didn't match. Output the string. */
187 o
= variable_buffer_output (o
, t
, len
);
190 /* It matched. Output the replacement. */
192 /* Output the part of the replacement before the %. */
193 o
= variable_buffer_output (o
, replace
, replace_prepercent_len
);
195 if (replace_percent
!= 0)
197 /* Output the part of the matched string that
198 matched the % in the pattern. */
199 o
= variable_buffer_output (o
, t
+ pattern_prepercent_len
,
200 len
- (pattern_prepercent_len
201 + pattern_postpercent_len
));
202 /* Output the part of the replacement after the %. */
203 o
= variable_buffer_output (o
, replace_percent
+ 1,
204 replace_postpercent_len
);
208 /* Output a space, but not if the replacement is "". */
209 if (fail
|| replace_prepercent_len
> 0
210 || (replace_percent
!= 0 && len
+ replace_postpercent_len
> 0))
212 o
= variable_buffer_output (o
, " ", 1);
217 /* Kill the last space. */
224 /* Look up a function by name.
225 The table is currently small enough that it's not really worthwhile to use
226 a fancier lookup algorithm. If it gets larger, maybe...
229 static const struct function_table_entry
*
230 lookup_function (table
, s
)
231 const struct function_table_entry
*table
;
234 int len
= strlen (s
);
236 for (; table
->name
!= NULL
; ++table
)
237 if (table
->len
<= len
238 && (isblank ((unsigned char)s
[table
->len
]) || s
[table
->len
] == '\0')
239 && strneq (s
, table
->name
, table
->len
))
246 /* Return 1 if PATTERN matches STR, 0 if not. */
249 pattern_matches (pattern
, percent
, str
)
250 register char *pattern
, *percent
, *str
;
252 unsigned int sfxlen
, strlength
;
256 unsigned int len
= strlen (pattern
) + 1;
257 char *new_chars
= (char *) alloca (len
);
258 bcopy (pattern
, new_chars
, len
);
260 percent
= find_percent (pattern
);
262 return streq (pattern
, str
);
265 sfxlen
= strlen (percent
+ 1);
266 strlength
= strlen (str
);
268 if (strlength
< (percent
- pattern
) + sfxlen
269 || !strneq (pattern
, str
, percent
- pattern
))
272 return !strcmp (percent
+ 1, str
+ (strlength
- sfxlen
));
276 /* Find the next comma or ENDPAREN (counting nested STARTPAREN and
277 ENDPARENtheses), starting at PTR before END. Return a pointer to
280 If no next argument is found, return NULL.
284 find_next_argument (startparen
, endparen
, ptr
, end
)
292 for (; ptr
< end
; ++ptr
)
293 if (*ptr
== startparen
)
296 else if (*ptr
== endparen
)
303 else if (*ptr
== ',' && !count
)
306 /* We didn't find anything. */
311 /* Glob-expand LINE. The returned pointer is
312 only good until the next call to string_glob. */
318 static char *result
= 0;
319 static unsigned int length
;
320 register struct nameseq
*chain
;
321 register unsigned int idx
;
323 chain
= multi_glob (parse_file_seq
324 (&line
, '\0', sizeof (struct nameseq
),
325 /* We do not want parse_file_seq to strip `./'s.
326 That would break examples like:
327 $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)). */
329 sizeof (struct nameseq
));
334 result
= (char *) xmalloc (100);
340 register char *name
= chain
->name
;
341 unsigned int len
= strlen (name
);
343 struct nameseq
*next
= chain
->next
;
344 free ((char *) chain
);
347 /* multi_glob will pass names without globbing metacharacters
348 through as is, but we want only files that actually exist. */
349 if (file_exists_p (name
))
351 if (idx
+ len
+ 1 > length
)
353 length
+= (len
+ 1) * 2;
354 result
= (char *) xrealloc (result
, length
);
356 bcopy (name
, &result
[idx
], len
);
364 /* Kill the last space and terminate the string. */
368 result
[idx
- 1] = '\0';
378 func_patsubst (o
, argv
, funcname
)
381 const char *funcname
;
383 o
= patsubst_expand (o
, argv
[2], argv
[0], argv
[1], (char *) 0, (char *) 0);
389 func_join (o
, argv
, funcname
)
392 const char *funcname
;
396 /* Write each word of the first argument directly followed
397 by the corresponding word of the second argument.
398 If the two arguments have a different number of words,
399 the excess words are just output separated by blanks. */
402 char *list1_iterator
= argv
[0];
403 char *list2_iterator
= argv
[1];
406 unsigned int len1
, len2
;
408 tp
= find_next_token (&list1_iterator
, &len1
);
410 o
= variable_buffer_output (o
, tp
, len1
);
412 pp
= find_next_token (&list2_iterator
, &len2
);
414 o
= variable_buffer_output (o
, pp
, len2
);
416 if (tp
!= 0 || pp
!= 0)
418 o
= variable_buffer_output (o
, " ", 1);
422 while (tp
!= 0 || pp
!= 0);
424 /* Kill the last blank. */
432 func_origin (o
, argv
, funcname
)
435 const char *funcname
;
437 /* Expand the argument. */
438 register struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
440 o
= variable_buffer_output (o
, "undefined", 9);
449 o
= variable_buffer_output (o
, "default", 7);
452 o
= variable_buffer_output (o
, "environment", 11);
455 o
= variable_buffer_output (o
, "file", 4);
458 o
= variable_buffer_output (o
, "environment override", 20);
461 o
= variable_buffer_output (o
, "command line", 12);
464 o
= variable_buffer_output (o
, "override", 8);
467 o
= variable_buffer_output (o
, "automatic", 9);
475 #define IS_PATHSEP(c) ((c) == ']')
477 #if defined(__MSDOS__) || defined(WINDOWS32)
478 #define IS_PATHSEP(c) ((c) == '/' || (c) == '\\')
480 #define IS_PATHSEP(c) ((c) == '/')
486 func_notdir_suffix (o
, argv
, funcname
)
489 const char *funcname
;
491 /* Expand the argument. */
492 char *list_iterator
= argv
[0];
497 int is_suffix
= streq (funcname
, "suffix");
498 int is_notdir
= !is_suffix
;
499 while ((p2
= find_next_token (&list_iterator
, &len
)) != 0)
504 while (p
>= p2
&& (!is_suffix
|| *p
!= '.'))
517 o
= variable_buffer_output (o
, p
, len
- (p
- p2
));
519 #if defined(WINDOWS32) || defined(__MSDOS__)
520 /* Handle the case of "d:foo/bar". */
521 else if (streq (funcname
, "notdir") && p2
[0] && p2
[1] == ':')
524 o
= variable_buffer_output (o
, p
, len
- (p
- p2
));
528 o
= variable_buffer_output (o
, p2
, len
);
530 if (is_notdir
|| p
>= p2
)
532 o
= variable_buffer_output (o
, " ", 1);
537 /* Kill last space. */
547 func_basename_dir (o
, argv
, funcname
)
550 const char *funcname
;
552 /* Expand the argument. */
558 int is_basename
= streq (funcname
, "basename");
559 int is_dir
= !is_basename
;
561 while ((p2
= find_next_token (&p3
, &len
)) != 0)
564 while (p
>= p2
&& (!is_basename
|| *p
!= '.'))
571 if (p
>= p2
&& (is_dir
))
572 o
= variable_buffer_output (o
, p2
, ++p
- p2
);
573 else if (p
>= p2
&& (*p
== '.'))
574 o
= variable_buffer_output (o
, p2
, p
- p2
);
575 #if defined(WINDOWS32) || defined(__MSDOS__)
576 /* Handle the "d:foobar" case */
577 else if (p2
[0] && p2
[1] == ':' && is_dir
)
578 o
= variable_buffer_output (o
, p2
, 2);
582 o
= variable_buffer_output (o
, "[]", 2);
585 o
= variable_buffer_output (o
, "./", 2);
587 ; /* Just a nop... */
591 /* The entire name is the basename. */
592 o
= variable_buffer_output (o
, p2
, len
);
594 o
= variable_buffer_output (o
, " ", 1);
598 /* Kill last space. */
606 func_addsuffix_addprefix (o
, argv
, funcname
)
609 const char *funcname
;
611 int fixlen
= strlen (argv
[0]);
612 char *list_iterator
= argv
[1];
613 int is_addprefix
= streq (funcname
, "addprefix");
614 int is_addsuffix
= !is_addprefix
;
620 while ((p
= find_next_token (&list_iterator
, &len
)) != 0)
623 o
= variable_buffer_output (o
, argv
[0], fixlen
);
624 o
= variable_buffer_output (o
, p
, len
);
626 o
= variable_buffer_output (o
, argv
[0], fixlen
);
627 o
= variable_buffer_output (o
, " ", 1);
632 /* Kill last space. */
639 func_subst (o
, argv
, funcname
)
642 const char *funcname
;
644 o
= subst_expand (o
, argv
[2], argv
[0], argv
[1], strlen (argv
[0]),
645 strlen (argv
[1]), 0, 0);
652 func_firstword (o
, argv
, funcname
)
655 const char *funcname
;
658 char *words
= argv
[0]; /* Use a temp variable for find_next_token */
659 char *p
= find_next_token (&words
, &i
);
662 o
= variable_buffer_output (o
, p
, i
);
669 func_words (o
, argv
, funcname
)
672 const char *funcname
;
675 char *word_iterator
= argv
[0];
678 while (find_next_token (&word_iterator
, (unsigned int *) 0) != 0)
681 sprintf (buf
, "%d", i
);
682 o
= variable_buffer_output (o
, buf
, strlen (buf
));
689 strip_whitespace (begpp
, endpp
)
693 while (isspace ((unsigned char)**begpp
) && *begpp
<= *endpp
)
695 while (isspace ((unsigned char)**endpp
) && *endpp
>= *begpp
)
704 char *end
= p
+ strlen (p
) - 1;
706 strip_whitespace (&p
, &end
);
709 if (!ISDIGIT (*(p
++))) /* ISDIGIT only evals its arg once: see make.h. */
712 return (end
- beg
>= 0);
716 check_numeric (s
, message
)
721 fatal (reading_file
, message
);
727 func_word (o
, argv
, funcname
)
730 const char *funcname
;
736 /* Check the first argument. */
737 check_numeric (argv
[0], _("non-numeric first argument to `word' function"));
741 fatal (reading_file
, _("first argument to `word' function must be greater than 0"));
745 while ((p
= find_next_token (&end_p
, 0)) != 0)
750 o
= variable_buffer_output (o
, p
, end_p
- p
);
756 func_wordlist (o
, argv
, funcname
)
759 const char *funcname
;
763 /* Check the arguments. */
764 check_numeric (argv
[0],
765 _("non-numeric first argument to `wordlist' function"));
766 check_numeric (argv
[1],
767 _("non-numeric second argument to `wordlist' function"));
769 start
= atoi (argv
[0]);
770 count
= atoi (argv
[1]) - start
+ 1;
775 char *end_p
= argv
[2];
777 /* Find the beginning of the "start"th word. */
778 while (((p
= find_next_token (&end_p
, 0)) != 0) && --start
)
783 /* Find the end of the "count"th word from start. */
784 while (--count
&& (find_next_token (&end_p
, 0) != 0))
787 /* Return the stuff in the middle. */
788 o
= variable_buffer_output (o
, p
, end_p
- p
);
796 func_findstring (o
, argv
, funcname
)
799 const char *funcname
;
801 /* Find the first occurrence of the first string in the second. */
802 int i
= strlen (argv
[0]);
803 if (sindex (argv
[1], 0, argv
[0], i
) != 0)
804 o
= variable_buffer_output (o
, argv
[0], i
);
810 func_foreach (o
, argv
, funcname
)
813 const char *funcname
;
815 /* expand only the first two. */
816 char *varname
= expand_argument (argv
[0], NULL
);
817 char *list
= expand_argument (argv
[1], NULL
);
818 char *body
= argv
[2];
821 char *list_iterator
= list
;
824 register struct variable
*var
;
826 push_new_variable_scope ();
827 var
= define_variable (varname
, strlen (varname
), "", o_automatic
, 0);
829 /* loop through LIST, put the value in VAR and expand BODY */
830 while ((p
= find_next_token (&list_iterator
, &len
)) != 0)
839 var
->value
= (char *) xstrdup ((char*) p
);
843 result
= allocated_variable_expand (body
);
845 o
= variable_buffer_output (o
, result
, strlen (result
));
846 o
= variable_buffer_output (o
, " ", 1);
852 /* Kill the last space. */
855 pop_variable_scope ();
870 func_filter_filterout (o
, argv
, funcname
)
873 const char *funcname
;
875 struct a_word
*wordhead
= 0;
876 struct a_word
*wordtail
= 0;
878 int is_filter
= streq (funcname
, "filter");
879 char *patterns
= argv
[0];
880 char *word_iterator
= argv
[1];
885 /* Chop ARGV[1] up into words and then run each pattern through. */
886 while ((p
= find_next_token (&word_iterator
, &len
)) != 0)
888 struct a_word
*w
= (struct a_word
*)alloca (sizeof (struct a_word
));
895 if (*word_iterator
!= '\0')
904 char *pat_iterator
= patterns
;
910 /* Run each pattern through the words, killing words. */
911 while ((p
= find_next_token (&pat_iterator
, &len
)) != 0)
917 percent
= find_percent (p
);
918 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
919 wp
->matched
|= (percent
== 0 ? streq (p
, wp
->str
)
920 : pattern_matches (p
, percent
, wp
->str
));
925 /* Output the words that matched (or didn't, for filter-out). */
926 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
927 if (is_filter
? wp
->matched
: !wp
->matched
)
929 o
= variable_buffer_output (o
, wp
->str
, strlen (wp
->str
));
930 o
= variable_buffer_output (o
, " ", 1);
935 /* Kill the last space. */
944 func_strip (o
, argv
, funcname
)
947 const char *funcname
;
957 while (isspace ((unsigned char)*p
))
960 for (i
=0; *p
!= '\0' && !isspace ((unsigned char)*p
); ++p
, ++i
)
964 o
= variable_buffer_output (o
, word_start
, i
);
965 o
= variable_buffer_output (o
, " ", 1);
970 /* Kill the last space. */
976 Print a warning or fatal message.
979 func_error (o
, argv
, funcname
)
982 const char *funcname
;
988 /* The arguments will be broken on commas. Rather than create yet
989 another special case where function arguments aren't broken up,
990 just create a format string that puts them back together. */
991 for (len
=0, argvp
=argv
; *argvp
!= 0; ++argvp
)
992 len
+= strlen (*argvp
) + 2;
994 p
= msg
= (char *) alloca (len
+ 1);
996 for (argvp
=argv
; argvp
[1] != 0; ++argvp
)
999 p
+= strlen (*argvp
);
1005 if (*funcname
== 'e')
1006 fatal (reading_file
, "%s", msg
);
1008 /* The warning function expands to the empty string. */
1009 error (reading_file
, "%s", msg
);
1016 chop argv[0] into words, and sort them.
1019 func_sort (o
, argv
, funcname
)
1022 const char *funcname
;
1026 register int wordi
= 0;
1028 /* Chop ARGV[0] into words and put them in WORDS. */
1034 while ((p
= find_next_token (&t
, &len
)) != 0)
1036 if (wordi
>= nwords
- 1)
1038 nwords
= (2 * nwords
) + 5;
1039 words
= (char **) xrealloc ((char *) words
,
1040 nwords
* sizeof (char *));
1042 words
[wordi
++] = savestring (p
, len
);
1048 /* Now sort the list of words. */
1049 qsort ((char *) words
, wordi
, sizeof (char *), alpha_compare
);
1051 /* Now write the sorted list. */
1052 for (i
= 0; i
< wordi
; ++i
)
1054 len
= strlen (words
[i
]);
1055 if (i
== wordi
- 1 || strlen (words
[i
+ 1]) != len
1056 || strcmp (words
[i
], words
[i
+ 1]))
1058 o
= variable_buffer_output (o
, words
[i
], len
);
1059 o
= variable_buffer_output (o
, " ", 1);
1063 /* Kill the last space. */
1072 $(if condition,true-part[,false-part])
1074 CONDITION is false iff it evaluates to an empty string. White
1075 space before and after condition are stripped before evaluation.
1077 If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is
1078 evaluated (if it exists). Because only one of the two PARTs is evaluated,
1079 you can use $(if ...) to create side-effects (with $(shell ...), for
1084 func_if (o
, argv
, funcname
)
1087 const char *funcname
;
1089 char *begp
= argv
[0];
1090 char *endp
= begp
+ strlen (argv
[0]);
1093 /* Find the result of the condition: if we have a value, and it's not
1094 empty, the condition is true. If we don't have a value, or it's the
1095 empty string, then it's false. */
1097 strip_whitespace (&begp
, &endp
);
1101 char *expansion
= expand_argument (begp
, NULL
);
1103 result
= strlen (expansion
);
1107 /* If the result is true (1) we want to eval the first argument, and if
1108 it's false (0) we want to eval the second. If the argument doesn't
1109 exist we do nothing, otherwise expand it and add to the buffer. */
1111 argv
+= 1 + !result
;
1117 expansion
= expand_argument (argv
[0], NULL
);
1119 o
= variable_buffer_output (o
, expansion
, strlen (expansion
));
1128 func_wildcard (o
, argv
, funcname
)
1131 const char *funcname
;
1135 o
= wildcard_expansion (argv
[0], o
);
1137 char *p
= string_glob (argv
[0]);
1138 o
= variable_buffer_output (o
, p
, strlen (p
));
1144 $(eval <makefile string>)
1146 Always resolves to the empty string.
1148 Treat the arguments as a segment of makefile, and parse them.
1152 func_eval (o
, argv
, funcname
)
1155 const char *funcname
;
1157 eval_buffer (argv
[0]);
1164 func_value (o
, argv
, funcname
)
1167 const char *funcname
;
1169 /* Look up the variable. */
1170 struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
1172 /* Copy its value into the output buffer without expanding it. */
1174 o
= variable_buffer_output (o
, v
->value
, strlen(v
->value
));
1180 \r is replaced on UNIX as well. Is this desirable?
1183 fold_newlines (buffer
, length
)
1189 char *last_nonnl
= buffer
-1;
1191 for (; *src
!= '\0'; ++src
)
1193 if (src
[0] == '\r' && src
[1] == '\n')
1205 *(++last_nonnl
) = '\0';
1206 *length
= last_nonnl
- buffer
;
1211 int shell_function_pid
= 0, shell_function_completed
;
1217 #include <windows.h>
1219 #include "sub_proc.h"
1223 windows32_openpipe (int *pipedes
, int *pid_p
, char **command_argv
, char **envp
)
1225 SECURITY_ATTRIBUTES saAttr
;
1233 saAttr
.nLength
= sizeof (SECURITY_ATTRIBUTES
);
1234 saAttr
.bInheritHandle
= TRUE
;
1235 saAttr
.lpSecurityDescriptor
= NULL
;
1237 if (DuplicateHandle (GetCurrentProcess(),
1238 GetStdHandle(STD_INPUT_HANDLE
),
1239 GetCurrentProcess(),
1243 DUPLICATE_SAME_ACCESS
) == FALSE
) {
1244 fatal (NILF
, _("create_child_process: DuplicateHandle(In) failed (e=%d)\n"),
1248 if (DuplicateHandle(GetCurrentProcess(),
1249 GetStdHandle(STD_ERROR_HANDLE
),
1250 GetCurrentProcess(),
1254 DUPLICATE_SAME_ACCESS
) == FALSE
) {
1255 fatal (NILF
, _("create_child_process: DuplicateHandle(Err) failed (e=%d)\n"),
1259 if (!CreatePipe(&hChildOutRd
, &hChildOutWr
, &saAttr
, 0))
1260 fatal (NILF
, _("CreatePipe() failed (e=%d)\n"), GetLastError());
1262 hProcess
= process_init_fd(hIn
, hChildOutWr
, hErr
);
1265 fatal (NILF
, _("windows32_openpipe (): process_init_fd() failed\n"));
1267 /* make sure that CreateProcess() has Path it needs */
1268 sync_Path_environment();
1270 if (!process_begin(hProcess
, command_argv
, envp
, command_argv
[0], NULL
)) {
1271 /* register process for wait */
1272 process_register(hProcess
);
1274 /* set the pid for returning to caller */
1275 *pid_p
= (int) hProcess
;
1277 /* set up to read data from child */
1278 pipedes
[0] = _open_osfhandle((long) hChildOutRd
, O_RDONLY
);
1280 /* this will be closed almost right away */
1281 pipedes
[1] = _open_osfhandle((long) hChildOutWr
, O_APPEND
);
1283 /* reap/cleanup the failed process */
1284 process_cleanup(hProcess
);
1286 /* close handles which were duplicated, they weren't used */
1290 /* close pipe handles, they won't be used */
1291 CloseHandle(hChildOutRd
);
1292 CloseHandle(hChildOutWr
);
1294 /* set status for return */
1295 pipedes
[0] = pipedes
[1] = -1;
1304 msdos_openpipe (int* pipedes
, int *pidp
, char *text
)
1307 /* MSDOS can't fork, but it has `popen'. */
1308 struct variable
*sh
= lookup_variable ("SHELL", 5);
1310 extern int dos_command_running
, dos_status
;
1312 /* Make sure not to bother processing an empty line. */
1313 while (isblank ((unsigned char)*text
))
1320 char buf
[PATH_MAX
+ 7];
1321 /* This makes sure $SHELL value is used by $(shell), even
1322 though the target environment is not passed to it. */
1323 sprintf (buf
, "SHELL=%s", sh
->value
);
1329 dos_command_running
= 1;
1331 /* If dos_status becomes non-zero, it means the child process
1332 was interrupted by a signal, like SIGINT or SIGQUIT. See
1333 fatal_error_signal in commands.c. */
1334 fpipe
= popen (text
, "rt");
1335 dos_command_running
= 0;
1336 if (!fpipe
|| dos_status
)
1342 else if (errno
== 0)
1344 shell_function_completed
= -1;
1348 pipedes
[0] = fileno (fpipe
);
1349 *pidp
= 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
1351 shell_function_completed
= 1;
1358 Do shell spawning, with the naughty bits for different OSes.
1363 /* VMS can't do $(shell ...) */
1364 #define func_shell 0
1369 func_shell (o
, argv
, funcname
)
1372 const char *funcname
;
1374 char* batch_filename
= NULL
;
1380 char **command_argv
;
1387 /* Construct the argument list. */
1388 command_argv
= construct_command_argv (argv
[0],
1389 (char **) NULL
, (struct file
*) 0,
1391 if (command_argv
== 0)
1395 /* Using a target environment for `shell' loses in cases like:
1396 export var = $(shell echo foobie)
1397 because target_environment hits a loop trying to expand $(var)
1398 to put it in the environment. This is even more confusing when
1399 var was not explicitly exported, but just appeared in the
1400 calling environment. */
1404 /* For error messages. */
1405 if (reading_file
!= 0)
1407 error_prefix
= (char *) alloca (strlen (reading_file
->filenm
)+11+4);
1408 sprintf (error_prefix
,
1409 "%s:%lu: ", reading_file
->filenm
, reading_file
->lineno
);
1415 windows32_openpipe (pipedes
, &pid
, command_argv
, envp
);
1417 if (pipedes
[0] < 0) {
1418 /* open of the pipe failed, mark as failed execution */
1419 shell_function_completed
= -1;
1423 #else /* WINDOWS32 */
1426 fpipe
= msdos_openpipe (pipedes
, &pid
, argv
[0]);
1429 perror_with_name (error_prefix
, "pipe");
1433 if (pipe (pipedes
) < 0)
1435 perror_with_name (error_prefix
, "pipe");
1441 perror_with_name (error_prefix
, "fork");
1443 child_execute_job (0, pipedes
[1], command_argv
, envp
);
1445 # endif /* ! __MSDOS__ */
1447 #endif /* WINDOWS32 */
1449 /* We are the parent. */
1452 unsigned int maxlen
;
1455 /* Record the PID for reap_children. */
1456 shell_function_pid
= pid
;
1458 shell_function_completed
= 0;
1460 /* Free the storage only the child needed. */
1461 free (command_argv
[0]);
1462 free ((char *) command_argv
);
1464 /* Close the write side of the pipe. */
1465 (void) close (pipedes
[1]);
1468 /* Set up and read from the pipe. */
1471 buffer
= (char *) xmalloc (maxlen
+ 1);
1473 /* Read from the pipe until it gets EOF. */
1474 for (i
= 0; ; i
+= cc
)
1479 buffer
= (char *) xrealloc (buffer
, maxlen
+ 1);
1482 cc
= read (pipedes
[0], &buffer
[i
], maxlen
- i
);
1488 /* Close the read side of the pipe. */
1491 (void) pclose (fpipe
);
1493 (void) close (pipedes
[0]);
1496 /* Loop until child_handler sets shell_function_completed
1497 to the status of our child shell. */
1498 while (shell_function_completed
== 0)
1499 reap_children (1, 0);
1501 if (batch_filename
) {
1502 DB (DB_VERBOSE
, (_("Cleaning up temporary batch file %s\n"),
1504 remove (batch_filename
);
1505 free (batch_filename
);
1507 shell_function_pid
= 0;
1509 /* The child_handler function will set shell_function_completed
1510 to 1 when the child dies normally, or to -1 if it
1511 dies with status 127, which is most likely an exec fail. */
1513 if (shell_function_completed
== -1)
1515 /* This most likely means that the execvp failed,
1516 so we should just write out the error message
1517 that came in over the pipe from the child. */
1518 fputs (buffer
, stderr
);
1523 /* The child finished normally. Replace all
1524 newlines in its output with spaces, and put
1525 that in the variable output buffer. */
1526 fold_newlines (buffer
, &i
);
1527 o
= variable_buffer_output (o
, buffer
, i
);
1538 /* Do the Amiga version of func_shell. */
1541 func_shell (char *o
, char **argv
, const char *funcname
)
1543 /* Amiga can't fork nor spawn, but I can start a program with
1544 redirection of my choice. However, this means that we
1545 don't have an opportunity to reopen stdout to trap it. Thus,
1546 we save our own stdout onto a new descriptor and dup a temp
1547 file's descriptor onto our stdout temporarily. After we
1548 spawn the shell program, we dup our own stdout back to the
1549 stdout descriptor. The buffer reading is the same as above,
1550 except that we're now reading from a file. */
1552 #include <dos/dos.h>
1553 #include <proto/dos.h>
1556 char tmp_output
[FILENAME_MAX
];
1557 unsigned int maxlen
= 200;
1559 char * buffer
, * ptr
;
1562 char* batch_filename
= NULL
;
1564 /* Construct the argument list. */
1565 command_argv
= construct_command_argv (argv
[0], (char **) NULL
,
1566 (struct file
*) 0, &batch_filename
);
1567 if (command_argv
== 0)
1570 /* Note the mktemp() is a security hole, but this only runs on Amiga.
1571 Ideally we would use main.c:open_tmpfile(), but this uses a special
1572 Open(), not fopen(), and I'm not familiar enough with the code to mess
1574 strcpy (tmp_output
, "t:MakeshXXXXXXXX");
1575 mktemp (tmp_output
);
1576 child_stdout
= Open (tmp_output
, MODE_NEWFILE
);
1578 for (aptr
=command_argv
; *aptr
; aptr
++)
1579 len
+= strlen (*aptr
) + 1;
1581 buffer
= xmalloc (len
+ 1);
1584 for (aptr
=command_argv
; *aptr
; aptr
++)
1586 strcpy (ptr
, *aptr
);
1587 ptr
+= strlen (ptr
) + 1;
1594 Execute (buffer
, NULL
, child_stdout
);
1597 Close (child_stdout
);
1599 child_stdout
= Open (tmp_output
, MODE_OLDFILE
);
1601 buffer
= xmalloc (maxlen
);
1608 buffer
= (char *) xrealloc (buffer
, maxlen
+ 1);
1611 cc
= Read (child_stdout
, &buffer
[i
], maxlen
- i
);
1616 Close (child_stdout
);
1618 fold_newlines (buffer
, &i
);
1619 o
= variable_buffer_output (o
, buffer
, i
);
1629 equality. Return is string-boolean, ie, the empty string is false.
1632 func_eq (char* o
, char **argv
, char *funcname
)
1634 int result
= ! strcmp (argv
[0], argv
[1]);
1635 o
= variable_buffer_output (o
, result
? "1" : "", result
);
1641 string-boolean not operator.
1644 func_not (char* o
, char **argv
, char *funcname
)
1648 while (isspace ((unsigned char)*s
))
1651 o
= variable_buffer_output (o
, result
? "1" : "", result
);
1657 /* Lookup table for builtin functions.
1659 This doesn't have to be sorted; we use a straight lookup. We might gain
1660 some efficiency by moving most often used functions to the start of the
1663 If MAXIMUM_ARGS is 0, that means there is no maximum and all
1664 comma-separated values are treated as arguments.
1666 EXPAND_ARGS means that all arguments should be expanded before invocation.
1667 Functions that do namespace tricks (foreach) don't automatically expand. */
1669 static char *func_call
PARAMS ((char *o
, char **argv
, const char *funcname
));
1672 static struct function_table_entry function_table
[] =
1674 /* Name/size */ /* MIN MAX EXP? Function */
1675 { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix
},
1676 { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix
},
1677 { STRING_SIZE_TUPLE("basename"), 0, 1, 1, func_basename_dir
},
1678 { STRING_SIZE_TUPLE("dir"), 0, 1, 1, func_basename_dir
},
1679 { STRING_SIZE_TUPLE("notdir"), 0, 1, 1, func_notdir_suffix
},
1680 { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst
},
1681 { STRING_SIZE_TUPLE("suffix"), 0, 1, 1, func_notdir_suffix
},
1682 { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout
},
1683 { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout
},
1684 { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring
},
1685 { STRING_SIZE_TUPLE("firstword"), 0, 1, 1, func_firstword
},
1686 { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join
},
1687 { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst
},
1688 { STRING_SIZE_TUPLE("shell"), 0, 1, 1, func_shell
},
1689 { STRING_SIZE_TUPLE("sort"), 0, 1, 1, func_sort
},
1690 { STRING_SIZE_TUPLE("strip"), 0, 1, 1, func_strip
},
1691 { STRING_SIZE_TUPLE("wildcard"), 0, 1, 1, func_wildcard
},
1692 { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word
},
1693 { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist
},
1694 { STRING_SIZE_TUPLE("words"), 0, 1, 1, func_words
},
1695 { STRING_SIZE_TUPLE("origin"), 0, 1, 1, func_origin
},
1696 { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach
},
1697 { STRING_SIZE_TUPLE("call"), 1, 0, 1, func_call
},
1698 { STRING_SIZE_TUPLE("error"), 0, 1, 1, func_error
},
1699 { STRING_SIZE_TUPLE("warning"), 0, 1, 1, func_error
},
1700 { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if
},
1701 { STRING_SIZE_TUPLE("value"), 0, 1, 1, func_value
},
1702 { STRING_SIZE_TUPLE("eval"), 0, 1, 1, func_eval
},
1704 { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq
},
1705 { STRING_SIZE_TUPLE("not"), 0, 1, 1, func_not
},
1711 /* These must come after the definition of function_table[]. */
1714 expand_builtin_function (o
, argc
, argv
, entry_p
)
1718 struct function_table_entry
*entry_p
;
1720 if (argc
< entry_p
->minimum_args
)
1721 fatal (reading_file
,
1722 _("Insufficient number of arguments (%d) to function `%s'"),
1723 argc
, entry_p
->name
);
1725 /* I suppose technically some function could do something with no
1726 arguments, but so far none do, so just test it for all functions here
1727 rather than in each one. We can change it later if necessary. */
1732 if (!entry_p
->func_ptr
)
1733 fatal (reading_file
, _("Unimplemented on this platform: function `%s'"),
1736 return entry_p
->func_ptr (o
, argv
, entry_p
->name
);
1739 /* Check for a function invocation in *STRINGP. *STRINGP points at the
1740 opening ( or { and is not null-terminated. If a function invocation
1741 is found, expand it into the buffer at *OP, updating *OP, incrementing
1742 *STRINGP past the reference and returning nonzero. If not, return zero. */
1745 handle_function (op
, stringp
)
1749 const struct function_table_entry
*entry_p
;
1750 char openparen
= (*stringp
)[0];
1751 char closeparen
= openparen
== '(' ? ')' : '}';
1756 char **argv
, **argvp
;
1761 entry_p
= lookup_function (function_table
, beg
);
1766 /* We found a builtin function. Find the beginning of its arguments (skip
1767 whitespace after the name). */
1769 beg
= next_token (beg
+ entry_p
->len
);
1771 /* Find the end of the function invocation, counting nested use of
1772 whichever kind of parens we use. Since we're looking, count commas
1773 to get a rough estimate of how many arguments we might have. The
1774 count might be high, but it'll never be low. */
1776 for (nargs
=1, end
=beg
; *end
!= '\0'; ++end
)
1779 else if (*end
== openparen
)
1781 else if (*end
== closeparen
&& --count
< 0)
1785 fatal (reading_file
,
1786 _("unterminated call to function `%s': missing `%c'"),
1787 entry_p
->name
, closeparen
);
1791 /* Get some memory to store the arg pointers. */
1792 argvp
= argv
= (char **) alloca (sizeof (char *) * (nargs
+ 2));
1794 /* Chop the string into arguments, then a nul. As soon as we hit
1795 MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
1798 If we're expanding, store pointers to the expansion of each one. If
1799 not, make a duplicate of the string and point into that, nul-terminating
1802 if (!entry_p
->expand_args
)
1804 int len
= end
- beg
;
1806 p
= xmalloc (len
+1);
1807 memcpy (p
, beg
, len
);
1813 for (p
=beg
, nargs
=0; p
<= end
; ++argvp
)
1819 if (nargs
== entry_p
->maximum_args
1820 || (! (next
= find_next_argument (openparen
, closeparen
, p
, end
))))
1823 if (entry_p
->expand_args
)
1824 *argvp
= expand_argument (p
, next
);
1835 /* Finally! Run the function... */
1836 *op
= expand_builtin_function (*op
, nargs
, argv
, entry_p
);
1839 if (entry_p
->expand_args
)
1840 for (argvp
=argv
; *argvp
!= 0; ++argvp
)
1849 /* User-defined functions. Expand the first argument as either a builtin
1850 function or a make variable, in the context of the rest of the arguments
1851 assigned to $1, $2, ... $N. $0 is the name of the function. */
1854 func_call (o
, argv
, funcname
)
1857 const char *funcname
;
1864 const struct function_table_entry
*entry_p
;
1867 /* There is no way to define a variable with a space in the name, so strip
1868 leading and trailing whitespace as a favor to the user. */
1870 while (*fname
!= '\0' && isspace ((unsigned char)*fname
))
1873 cp
= fname
+ strlen (fname
) - 1;
1874 while (cp
> fname
&& isspace ((unsigned char)*cp
))
1878 /* Calling nothing is a no-op */
1882 /* Are we invoking a builtin function? */
1884 entry_p
= lookup_function (function_table
, fname
);
1888 /* How many arguments do we have? */
1889 for (i
=0; argv
[i
+1]; ++i
)
1892 return expand_builtin_function (o
, i
, argv
+1, entry_p
);
1895 /* Not a builtin, so the first argument is the name of a variable to be
1896 expanded and interpreted as a function. Find it. */
1897 flen
= strlen (fname
);
1899 v
= lookup_variable (fname
, flen
);
1902 warn_undefined (fname
, flen
);
1904 if (v
== 0 || *v
->value
== '\0')
1907 body
= (char *) alloca (flen
+ 4);
1910 memcpy (body
+ 2, fname
, flen
);
1912 body
[flen
+3] = '\0';
1914 /* Set up arguments $(1) .. $(N). $(0) is the function name. */
1916 push_new_variable_scope ();
1918 for (i
=0; *argv
; ++i
, ++argv
)
1922 sprintf (num
, "%d", i
);
1923 define_variable (num
, strlen (num
), *argv
, o_automatic
, 0);
1926 /* Expand the body in the context of the arguments, adding the result to
1927 the variable buffer. */
1929 v
->exp_count
= EXP_COUNT_MAX
;
1931 o
= variable_expand_string (o
, body
, flen
+3);
1935 pop_variable_scope ();
1937 return o
+ strlen (o
);