1 /* Builtin function expansion for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
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/>. */
32 struct function_table_entry
36 unsigned char minimum_args
;
37 unsigned char maximum_args
;
39 char *(*func_ptr
) (char *output
, char **argv
, const char *fname
);
43 function_table_entry_hash_1 (const void *keyv
)
45 const struct function_table_entry
*key
= keyv
;
46 return_STRING_N_HASH_1 (key
->name
, key
->len
);
50 function_table_entry_hash_2 (const void *keyv
)
52 const struct function_table_entry
*key
= keyv
;
53 return_STRING_N_HASH_2 (key
->name
, key
->len
);
57 function_table_entry_hash_cmp (const void *xv
, const void *yv
)
59 const struct function_table_entry
*x
= xv
;
60 const struct function_table_entry
*y
= yv
;
61 int result
= x
->len
- y
->len
;
64 return_STRING_N_COMPARE (x
->name
, y
->name
, x
->len
);
67 static struct hash_table function_table
;
70 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing
71 each occurrence of SUBST with REPLACE. TEXT is null-terminated. SLEN is
72 the length of SUBST and RLEN is the length of REPLACE. If BY_WORD is
73 nonzero, substitutions are done only on matches which are complete
74 whitespace-delimited words. */
77 subst_expand (char *o
, const char *text
, const char *subst
, const char *replace
,
78 unsigned int slen
, unsigned int rlen
, int by_word
)
83 if (slen
== 0 && !by_word
)
85 /* The first occurrence of "" in any string is its end. */
86 o
= variable_buffer_output (o
, t
, strlen (t
));
88 o
= variable_buffer_output (o
, replace
, rlen
);
94 if (by_word
&& slen
== 0)
95 /* When matching by words, the empty string should match
96 the end of each word, rather than the end of the whole text. */
97 p
= end_of_token (next_token (t
));
100 p
= strstr (t
, subst
);
103 /* No more matches. Output everything left on the end. */
104 o
= variable_buffer_output (o
, t
, strlen (t
));
109 /* Output everything before this occurrence of the string to replace. */
111 o
= variable_buffer_output (o
, t
, p
- t
);
113 /* If we're substituting only by fully matched words,
114 or only at the ends of words, check that this case qualifies. */
116 && ((p
> text
&& !isblank ((unsigned char)p
[-1]))
117 || (p
[slen
] != '\0' && !isblank ((unsigned char)p
[slen
]))))
118 /* Struck out. Output the rest of the string that is
119 no longer to be replaced. */
120 o
= variable_buffer_output (o
, subst
, slen
);
122 /* Output the replacement string. */
123 o
= variable_buffer_output (o
, replace
, rlen
);
125 /* Advance T past the string to be replaced. */
127 } while (*t
!= '\0');
133 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT
134 and replacing strings matching PATTERN with REPLACE.
135 If PATTERN_PERCENT is not nil, PATTERN has already been
136 run through find_percent, and PATTERN_PERCENT is the result.
137 If REPLACE_PERCENT is not nil, REPLACE has already been
138 run through find_percent, and REPLACE_PERCENT is the result.
139 Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
140 character _AFTER_ the %, not to the % itself.
144 patsubst_expand_pat (char *o
, const char *text
,
145 const char *pattern
, const char *replace
,
146 const char *pattern_percent
, const char *replace_percent
)
148 unsigned int pattern_prepercent_len
, pattern_postpercent_len
;
149 unsigned int replace_prepercent_len
, replace_postpercent_len
;
154 /* Record the length of REPLACE before and after the % so we don't have to
155 compute these lengths more than once. */
158 replace_prepercent_len
= replace_percent
- replace
- 1;
159 replace_postpercent_len
= strlen (replace_percent
);
163 replace_prepercent_len
= strlen (replace
);
164 replace_postpercent_len
= 0;
167 if (!pattern_percent
)
168 /* With no % in the pattern, this is just a simple substitution. */
169 return subst_expand (o
, text
, pattern
, replace
,
170 strlen (pattern
), strlen (replace
), 1);
172 /* Record the length of PATTERN before and after the %
173 so we don't have to compute it more than once. */
174 pattern_prepercent_len
= pattern_percent
- pattern
- 1;
175 pattern_postpercent_len
= strlen (pattern_percent
);
177 while ((t
= find_next_token (&text
, &len
)) != 0)
181 /* Is it big enough to match? */
182 if (len
< pattern_prepercent_len
+ pattern_postpercent_len
)
185 /* Does the prefix match? */
186 if (!fail
&& pattern_prepercent_len
> 0
188 || t
[pattern_prepercent_len
- 1] != pattern_percent
[-2]
189 || !strneq (t
+ 1, pattern
+ 1, pattern_prepercent_len
- 1)))
192 /* Does the suffix match? */
193 if (!fail
&& pattern_postpercent_len
> 0
194 && (t
[len
- 1] != pattern_percent
[pattern_postpercent_len
- 1]
195 || t
[len
- pattern_postpercent_len
] != *pattern_percent
196 || !strneq (&t
[len
- pattern_postpercent_len
],
197 pattern_percent
, pattern_postpercent_len
- 1)))
201 /* It didn't match. Output the string. */
202 o
= variable_buffer_output (o
, t
, len
);
205 /* It matched. Output the replacement. */
207 /* Output the part of the replacement before the %. */
208 o
= variable_buffer_output (o
, replace
, replace_prepercent_len
);
210 if (replace_percent
!= 0)
212 /* Output the part of the matched string that
213 matched the % in the pattern. */
214 o
= variable_buffer_output (o
, t
+ pattern_prepercent_len
,
215 len
- (pattern_prepercent_len
216 + pattern_postpercent_len
));
217 /* Output the part of the replacement after the %. */
218 o
= variable_buffer_output (o
, replace_percent
,
219 replace_postpercent_len
);
223 /* Output a space, but not if the replacement is "". */
224 if (fail
|| replace_prepercent_len
> 0
225 || (replace_percent
!= 0 && len
+ replace_postpercent_len
> 0))
227 o
= variable_buffer_output (o
, " ", 1);
232 /* Kill the last space. */
238 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT
239 and replacing strings matching PATTERN with REPLACE.
240 If PATTERN_PERCENT is not nil, PATTERN has already been
241 run through find_percent, and PATTERN_PERCENT is the result.
242 If REPLACE_PERCENT is not nil, REPLACE has already been
243 run through find_percent, and REPLACE_PERCENT is the result.
244 Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
245 character _AFTER_ the %, not to the % itself.
249 patsubst_expand (char *o
, const char *text
, char *pattern
, char *replace
)
251 const char *pattern_percent
= find_percent (pattern
);
252 const char *replace_percent
= find_percent (replace
);
254 /* If there's a percent in the pattern or replacement skip it. */
260 return patsubst_expand_pat (o
, text
, pattern
, replace
,
261 pattern_percent
, replace_percent
);
265 /* Look up a function by name. */
267 static const struct function_table_entry
*
268 lookup_function (const char *s
)
272 while (*e
&& ( (*e
>= 'a' && *e
<= 'z') || *e
== '-'))
274 if (*e
== '\0' || isblank ((unsigned char) *e
))
276 struct function_table_entry function_table_entry_key
;
277 function_table_entry_key
.name
= s
;
278 function_table_entry_key
.len
= e
- s
;
280 return hash_find_item (&function_table
, &function_table_entry_key
);
286 /* Return 1 if PATTERN matches STR, 0 if not. */
289 pattern_matches (const char *pattern
, const char *percent
, const char *str
)
291 unsigned int sfxlen
, strlength
;
295 unsigned int len
= strlen (pattern
) + 1;
296 char *new_chars
= alloca (len
);
297 memcpy (new_chars
, pattern
, len
);
298 percent
= find_percent (new_chars
);
300 return streq (new_chars
, str
);
304 sfxlen
= strlen (percent
+ 1);
305 strlength
= strlen (str
);
307 if (strlength
< (percent
- pattern
) + sfxlen
308 || !strneq (pattern
, str
, percent
- pattern
))
311 return !strcmp (percent
+ 1, str
+ (strlength
- sfxlen
));
315 /* Find the next comma or ENDPAREN (counting nested STARTPAREN and
316 ENDPARENtheses), starting at PTR before END. Return a pointer to
319 If no next argument is found, return NULL.
323 find_next_argument (char startparen
, char endparen
,
324 const char *ptr
, const char *end
)
328 for (; ptr
< end
; ++ptr
)
329 if (*ptr
== startparen
)
332 else if (*ptr
== endparen
)
339 else if (*ptr
== ',' && !count
)
342 /* We didn't find anything. */
347 /* Glob-expand LINE. The returned pointer is
348 only good until the next call to string_glob. */
351 string_glob (char *line
)
353 static char *result
= 0;
354 static unsigned int length
;
355 struct nameseq
*chain
;
358 chain
= multi_glob (parse_file_seq
359 (&line
, '\0', sizeof (struct nameseq
),
360 /* We do not want parse_file_seq to strip `./'s.
361 That would break examples like:
362 $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)). */
364 sizeof (struct nameseq
));
369 result
= xmalloc (100);
375 const char *name
= chain
->name
;
376 unsigned int len
= strlen (name
);
378 struct nameseq
*next
= chain
->next
;
382 /* multi_glob will pass names without globbing metacharacters
383 through as is, but we want only files that actually exist. */
384 if (file_exists_p (name
))
386 if (idx
+ len
+ 1 > length
)
388 length
+= (len
+ 1) * 2;
389 result
= xrealloc (result
, length
);
391 memcpy (&result
[idx
], name
, len
);
397 /* Kill the last space and terminate the string. */
401 result
[idx
- 1] = '\0';
411 func_patsubst (char *o
, char **argv
, const char *funcname UNUSED
)
413 o
= patsubst_expand (o
, argv
[2], argv
[0], argv
[1]);
419 func_join (char *o
, char **argv
, const char *funcname UNUSED
)
423 /* Write each word of the first argument directly followed
424 by the corresponding word of the second argument.
425 If the two arguments have a different number of words,
426 the excess words are just output separated by blanks. */
429 const char *list1_iterator
= argv
[0];
430 const char *list2_iterator
= argv
[1];
433 unsigned int len1
, len2
;
435 tp
= find_next_token (&list1_iterator
, &len1
);
437 o
= variable_buffer_output (o
, tp
, len1
);
439 pp
= find_next_token (&list2_iterator
, &len2
);
441 o
= variable_buffer_output (o
, pp
, len2
);
443 if (tp
!= 0 || pp
!= 0)
445 o
= variable_buffer_output (o
, " ", 1);
449 while (tp
!= 0 || pp
!= 0);
451 /* Kill the last blank. */
459 func_origin (char *o
, char **argv
, const char *funcname UNUSED
)
461 /* Expand the argument. */
462 struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
464 o
= variable_buffer_output (o
, "undefined", 9);
473 o
= variable_buffer_output (o
, "default", 7);
476 o
= variable_buffer_output (o
, "environment", 11);
479 o
= variable_buffer_output (o
, "file", 4);
482 o
= variable_buffer_output (o
, "environment override", 20);
485 o
= variable_buffer_output (o
, "command line", 12);
488 o
= variable_buffer_output (o
, "override", 8);
491 o
= variable_buffer_output (o
, "automatic", 9);
499 func_flavor (char *o
, char **argv
, const char *funcname UNUSED
)
501 struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
504 o
= variable_buffer_output (o
, "undefined", 9);
507 o
= variable_buffer_output (o
, "recursive", 9);
509 o
= variable_buffer_output (o
, "simple", 6);
515 # define IS_PATHSEP(c) ((c) == ']')
517 # ifdef HAVE_DOS_PATHS
518 # define IS_PATHSEP(c) ((c) == '/' || (c) == '\\')
520 # define IS_PATHSEP(c) ((c) == '/')
526 func_notdir_suffix (char *o
, char **argv
, const char *funcname
)
528 /* Expand the argument. */
529 const char *list_iterator
= argv
[0];
534 int is_suffix
= streq (funcname
, "suffix");
535 int is_notdir
= !is_suffix
;
536 while ((p2
= find_next_token (&list_iterator
, &len
)) != 0)
538 const char *p
= p2
+ len
;
541 while (p
>= p2
&& (!is_suffix
|| *p
!= '.'))
554 o
= variable_buffer_output (o
, p
, len
- (p
- p2
));
556 #ifdef HAVE_DOS_PATHS
557 /* Handle the case of "d:foo/bar". */
558 else if (streq (funcname
, "notdir") && p2
[0] && p2
[1] == ':')
561 o
= variable_buffer_output (o
, p
, len
- (p
- p2
));
565 o
= variable_buffer_output (o
, p2
, len
);
567 if (is_notdir
|| p
>= p2
)
569 o
= variable_buffer_output (o
, " ", 1);
575 /* Kill last space. */
583 func_basename_dir (char *o
, char **argv
, const char *funcname
)
585 /* Expand the argument. */
586 const char *p3
= argv
[0];
591 int is_basename
= streq (funcname
, "basename");
592 int is_dir
= !is_basename
;
594 while ((p2
= find_next_token (&p3
, &len
)) != 0)
596 const char *p
= p2
+ len
;
597 while (p
>= p2
&& (!is_basename
|| *p
!= '.'))
604 if (p
>= p2
&& (is_dir
))
605 o
= variable_buffer_output (o
, p2
, ++p
- p2
);
606 else if (p
>= p2
&& (*p
== '.'))
607 o
= variable_buffer_output (o
, p2
, p
- p2
);
608 #ifdef HAVE_DOS_PATHS
609 /* Handle the "d:foobar" case */
610 else if (p2
[0] && p2
[1] == ':' && is_dir
)
611 o
= variable_buffer_output (o
, p2
, 2);
615 o
= variable_buffer_output (o
, "[]", 2);
618 o
= variable_buffer_output (o
, "./", 2);
620 ; /* Just a nop... */
624 /* The entire name is the basename. */
625 o
= variable_buffer_output (o
, p2
, len
);
627 o
= variable_buffer_output (o
, " ", 1);
632 /* Kill last space. */
639 func_addsuffix_addprefix (char *o
, char **argv
, const char *funcname
)
641 int fixlen
= strlen (argv
[0]);
642 const char *list_iterator
= argv
[1];
643 int is_addprefix
= streq (funcname
, "addprefix");
644 int is_addsuffix
= !is_addprefix
;
650 while ((p
= find_next_token (&list_iterator
, &len
)) != 0)
653 o
= variable_buffer_output (o
, argv
[0], fixlen
);
654 o
= variable_buffer_output (o
, p
, len
);
656 o
= variable_buffer_output (o
, argv
[0], fixlen
);
657 o
= variable_buffer_output (o
, " ", 1);
662 /* Kill last space. */
669 func_subst (char *o
, char **argv
, const char *funcname UNUSED
)
671 o
= subst_expand (o
, argv
[2], argv
[0], argv
[1], strlen (argv
[0]),
672 strlen (argv
[1]), 0);
679 func_firstword (char *o
, char **argv
, const char *funcname UNUSED
)
682 const char *words
= argv
[0]; /* Use a temp variable for find_next_token */
683 const char *p
= find_next_token (&words
, &i
);
686 o
= variable_buffer_output (o
, p
, i
);
692 func_lastword (char *o
, char **argv
, const char *funcname UNUSED
)
695 const char *words
= argv
[0]; /* Use a temp variable for find_next_token */
696 const char *p
= NULL
;
699 while ((t
= find_next_token (&words
, &i
)))
703 o
= variable_buffer_output (o
, p
, i
);
709 func_words (char *o
, char **argv
, const char *funcname UNUSED
)
712 const char *word_iterator
= argv
[0];
715 while (find_next_token (&word_iterator
, (unsigned int *) 0) != 0)
718 sprintf (buf
, "%d", i
);
719 o
= variable_buffer_output (o
, buf
, strlen (buf
));
724 /* Set begpp to point to the first non-whitespace character of the string,
725 * and endpp to point to the last non-whitespace character of the string.
726 * If the string is empty or contains nothing but whitespace, endpp will be
730 strip_whitespace (const char **begpp
, const char **endpp
)
732 while (*begpp
<= *endpp
&& isspace ((unsigned char)**begpp
))
734 while (*endpp
>= *begpp
&& isspace ((unsigned char)**endpp
))
736 return (char *)*begpp
;
740 check_numeric (const char *s
, const char *msg
)
742 const char *end
= s
+ strlen (s
) - 1;
744 strip_whitespace (&s
, &end
);
746 for (; s
<= end
; ++s
)
747 if (!ISDIGIT (*s
)) /* ISDIGIT only evals its arg once: see make.h. */
750 if (s
<= end
|| end
- beg
< 0)
751 fatal (*expanding_var
, "%s: '%s'", msg
, beg
);
757 func_word (char *o
, char **argv
, const char *funcname UNUSED
)
763 /* Check the first argument. */
764 check_numeric (argv
[0], _("non-numeric first argument to `word' function"));
768 fatal (*expanding_var
,
769 _("first argument to `word' function must be greater than 0"));
772 while ((p
= find_next_token (&end_p
, 0)) != 0)
777 o
= variable_buffer_output (o
, p
, end_p
- p
);
783 func_wordlist (char *o
, char **argv
, const char *funcname UNUSED
)
787 /* Check the arguments. */
788 check_numeric (argv
[0],
789 _("non-numeric first argument to `wordlist' function"));
790 check_numeric (argv
[1],
791 _("non-numeric second argument to `wordlist' function"));
793 start
= atoi (argv
[0]);
795 fatal (*expanding_var
,
796 "invalid first argument to `wordlist' function: `%d'", start
);
798 count
= atoi (argv
[1]) - start
+ 1;
803 const char *end_p
= argv
[2];
805 /* Find the beginning of the "start"th word. */
806 while (((p
= find_next_token (&end_p
, 0)) != 0) && --start
)
811 /* Find the end of the "count"th word from start. */
812 while (--count
&& (find_next_token (&end_p
, 0) != 0))
815 /* Return the stuff in the middle. */
816 o
= variable_buffer_output (o
, p
, end_p
- p
);
824 func_findstring (char *o
, char **argv
, const char *funcname UNUSED
)
826 /* Find the first occurrence of the first string in the second. */
827 if (strstr (argv
[1], argv
[0]) != 0)
828 o
= variable_buffer_output (o
, argv
[0], strlen (argv
[0]));
834 func_foreach (char *o
, char **argv
, const char *funcname UNUSED
)
836 /* expand only the first two. */
837 char *varname
= expand_argument (argv
[0], NULL
);
838 char *list
= expand_argument (argv
[1], NULL
);
839 const char *body
= argv
[2];
842 const char *list_iterator
= list
;
845 struct variable
*var
;
847 push_new_variable_scope ();
848 var
= define_variable (varname
, strlen (varname
), "", o_automatic
, 0);
850 /* loop through LIST, put the value in VAR and expand BODY */
851 while ((p
= find_next_token (&list_iterator
, &len
)) != 0)
856 var
->value
= savestring (p
, len
);
858 result
= allocated_variable_expand (body
);
860 o
= variable_buffer_output (o
, result
, strlen (result
));
861 o
= variable_buffer_output (o
, " ", 1);
867 /* Kill the last space. */
870 pop_variable_scope ();
880 struct a_word
*chain
;
887 a_word_hash_1 (const void *key
)
889 return_STRING_HASH_1 (((struct a_word
const *) key
)->str
);
893 a_word_hash_2 (const void *key
)
895 return_STRING_HASH_2 (((struct a_word
const *) key
)->str
);
899 a_word_hash_cmp (const void *x
, const void *y
)
901 int result
= ((struct a_word
const *) x
)->length
- ((struct a_word
const *) y
)->length
;
904 return_STRING_COMPARE (((struct a_word
const *) x
)->str
,
905 ((struct a_word
const *) y
)->str
);
910 struct a_pattern
*next
;
918 func_filter_filterout (char *o
, char **argv
, const char *funcname
)
920 struct a_word
*wordhead
;
921 struct a_word
**wordtail
;
923 struct a_pattern
*pathead
;
924 struct a_pattern
**pattail
;
925 struct a_pattern
*pp
;
927 struct hash_table a_word_table
;
928 int is_filter
= streq (funcname
, "filter");
929 const char *pat_iterator
= argv
[0];
930 const char *word_iterator
= argv
[1];
937 /* Chop ARGV[0] up into patterns to match against the words. */
940 while ((p
= find_next_token (&pat_iterator
, &len
)) != 0)
942 struct a_pattern
*pat
= alloca (sizeof (struct a_pattern
));
945 pattail
= &pat
->next
;
947 if (*pat_iterator
!= '\0')
952 pat
->save_c
= p
[len
];
954 pat
->percent
= find_percent (p
);
955 if (pat
->percent
== 0)
960 /* Chop ARGV[1] up into words to match against the patterns. */
962 wordtail
= &wordhead
;
963 while ((p
= find_next_token (&word_iterator
, &len
)) != 0)
965 struct a_word
*word
= alloca (sizeof (struct a_word
));
968 wordtail
= &word
->next
;
970 if (*word_iterator
!= '\0')
982 /* Only use a hash table if arg list lengths justifies the cost. */
983 hashing
= (literals
>= 2 && (literals
* words
) >= 10);
986 hash_init (&a_word_table
, words
, a_word_hash_1
, a_word_hash_2
,
988 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
990 struct a_word
*owp
= hash_insert (&a_word_table
, wp
);
1000 /* Run each pattern through the words, killing words. */
1001 for (pp
= pathead
; pp
!= 0; pp
= pp
->next
)
1004 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
1005 wp
->matched
|= pattern_matches (pp
->str
, pp
->percent
, wp
->str
);
1008 struct a_word a_word_key
;
1009 a_word_key
.str
= pp
->str
;
1010 a_word_key
.length
= pp
->length
;
1011 wp
= hash_find_item (&a_word_table
, &a_word_key
);
1019 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
1020 wp
->matched
|= (wp
->length
== pp
->length
1021 && strneq (pp
->str
, wp
->str
, wp
->length
));
1024 /* Output the words that matched (or didn't, for filter-out). */
1025 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
1026 if (is_filter
? wp
->matched
: !wp
->matched
)
1028 o
= variable_buffer_output (o
, wp
->str
, strlen (wp
->str
));
1029 o
= variable_buffer_output (o
, " ", 1);
1034 /* Kill the last space. */
1038 for (pp
= pathead
; pp
!= 0; pp
= pp
->next
)
1039 pp
->str
[pp
->length
] = pp
->save_c
;
1042 hash_free (&a_word_table
, 0);
1049 func_strip (char *o
, char **argv
, const char *funcname UNUSED
)
1051 const char *p
= argv
[0];
1057 const char *word_start
;
1059 while (isspace ((unsigned char)*p
))
1062 for (i
=0; *p
!= '\0' && !isspace ((unsigned char)*p
); ++p
, ++i
)
1066 o
= variable_buffer_output (o
, word_start
, i
);
1067 o
= variable_buffer_output (o
, " ", 1);
1072 /* Kill the last space. */
1079 Print a warning or fatal message.
1082 func_error (char *o
, char **argv
, const char *funcname
)
1088 /* The arguments will be broken on commas. Rather than create yet
1089 another special case where function arguments aren't broken up,
1090 just create a format string that puts them back together. */
1091 for (len
=0, argvp
=argv
; *argvp
!= 0; ++argvp
)
1092 len
+= strlen (*argvp
) + 2;
1094 p
= msg
= alloca (len
+ 1);
1096 for (argvp
=argv
; argvp
[1] != 0; ++argvp
)
1099 p
+= strlen (*argvp
);
1105 switch (*funcname
) {
1107 fatal (reading_file
, "%s", msg
);
1110 error (reading_file
, "%s", msg
);
1114 printf ("%s\n", msg
);
1119 fatal (*expanding_var
, "Internal error: func_error: '%s'", funcname
);
1122 /* The warning function expands to the empty string. */
1128 chop argv[0] into words, and sort them.
1131 func_sort (char *o
, char **argv
, const char *funcname UNUSED
)
1140 /* Find the maximum number of words we'll have. */
1147 if (! isspace ((unsigned char)c
))
1152 while (isspace ((unsigned char)*t
))
1156 words
= xmalloc (wordi
* sizeof (char *));
1158 /* Now assign pointers to each string in the array. */
1161 while ((p
= find_next_token (&t
, &len
)) != 0)
1170 /* Now sort the list of words. */
1171 qsort (words
, wordi
, sizeof (char *), alpha_compare
);
1173 /* Now write the sorted list, uniquified. */
1174 for (i
= 0; i
< wordi
; ++i
)
1176 len
= strlen (words
[i
]);
1177 if (i
== wordi
- 1 || strlen (words
[i
+ 1]) != len
1178 || strcmp (words
[i
], words
[i
+ 1]))
1180 o
= variable_buffer_output (o
, words
[i
], len
);
1181 o
= variable_buffer_output (o
, " ", 1);
1185 /* Kill the last space. */
1195 $(if condition,true-part[,false-part])
1197 CONDITION is false iff it evaluates to an empty string. White
1198 space before and after condition are stripped before evaluation.
1200 If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is
1201 evaluated (if it exists). Because only one of the two PARTs is evaluated,
1202 you can use $(if ...) to create side-effects (with $(shell ...), for
1207 func_if (char *o
, char **argv
, const char *funcname UNUSED
)
1209 const char *begp
= argv
[0];
1210 const char *endp
= begp
+ strlen (argv
[0]) - 1;
1213 /* Find the result of the condition: if we have a value, and it's not
1214 empty, the condition is true. If we don't have a value, or it's the
1215 empty string, then it's false. */
1217 strip_whitespace (&begp
, &endp
);
1221 char *expansion
= expand_argument (begp
, endp
+1);
1223 result
= strlen (expansion
);
1227 /* If the result is true (1) we want to eval the first argument, and if
1228 it's false (0) we want to eval the second. If the argument doesn't
1229 exist we do nothing, otherwise expand it and add to the buffer. */
1231 argv
+= 1 + !result
;
1235 char *expansion
= expand_argument (*argv
, NULL
);
1237 o
= variable_buffer_output (o
, expansion
, strlen (expansion
));
1246 $(or condition1[,condition2[,condition3[...]]])
1248 A CONDITION is false iff it evaluates to an empty string. White
1249 space before and after CONDITION are stripped before evaluation.
1251 CONDITION1 is evaluated. If it's true, then this is the result of
1252 expansion. If it's false, CONDITION2 is evaluated, and so on. If none of
1253 the conditions are true, the expansion is the empty string.
1255 Once a CONDITION is true no further conditions are evaluated
1260 func_or (char *o
, char **argv
, const char *funcname UNUSED
)
1262 for ( ; *argv
; ++argv
)
1264 const char *begp
= *argv
;
1265 const char *endp
= begp
+ strlen (*argv
) - 1;
1269 /* Find the result of the condition: if it's false keep going. */
1271 strip_whitespace (&begp
, &endp
);
1276 expansion
= expand_argument (begp
, endp
+1);
1277 result
= strlen (expansion
);
1279 /* If the result is false keep going. */
1286 /* It's true! Keep this result and return. */
1287 o
= variable_buffer_output (o
, expansion
, result
);
1296 $(and condition1[,condition2[,condition3[...]]])
1298 A CONDITION is false iff it evaluates to an empty string. White
1299 space before and after CONDITION are stripped before evaluation.
1301 CONDITION1 is evaluated. If it's false, then this is the result of
1302 expansion. If it's true, CONDITION2 is evaluated, and so on. If all of
1303 the conditions are true, the expansion is the result of the last condition.
1305 Once a CONDITION is false no further conditions are evaluated
1310 func_and (char *o
, char **argv
, const char *funcname UNUSED
)
1317 const char *begp
= *argv
;
1318 const char *endp
= begp
+ strlen (*argv
) - 1;
1320 /* An empty condition is always false. */
1321 strip_whitespace (&begp
, &endp
);
1325 expansion
= expand_argument (begp
, endp
+1);
1326 result
= strlen (expansion
);
1328 /* If the result is false, stop here: we're done. */
1332 /* Otherwise the result is true. If this is the last one, keep this
1333 result and quit. Otherwise go on to the next one! */
1339 o
= variable_buffer_output (o
, expansion
, result
);
1350 func_wildcard (char *o
, char **argv
, const char *funcname UNUSED
)
1353 o
= wildcard_expansion (argv
[0], o
);
1355 char *p
= string_glob (argv
[0]);
1356 o
= variable_buffer_output (o
, p
, strlen (p
));
1362 $(eval <makefile string>)
1364 Always resolves to the empty string.
1366 Treat the arguments as a segment of makefile, and parse them.
1370 func_eval (char *o
, char **argv
, const char *funcname UNUSED
)
1375 /* Eval the buffer. Pop the current variable buffer setting so that the
1376 eval'd code can use its own without conflicting. */
1378 install_variable_buffer (&buf
, &len
);
1380 eval_buffer (argv
[0]);
1382 restore_variable_buffer (buf
, len
);
1389 func_value (char *o
, char **argv
, const char *funcname UNUSED
)
1391 /* Look up the variable. */
1392 struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
1394 /* Copy its value into the output buffer without expanding it. */
1396 o
= variable_buffer_output (o
, v
->value
, strlen(v
->value
));
1402 \r is replaced on UNIX as well. Is this desirable?
1405 fold_newlines (char *buffer
, unsigned int *length
)
1409 char *last_nonnl
= buffer
-1;
1411 for (; *src
!= '\0'; ++src
)
1413 if (src
[0] == '\r' && src
[1] == '\n')
1425 *(++last_nonnl
) = '\0';
1426 *length
= last_nonnl
- buffer
;
1431 int shell_function_pid
= 0, shell_function_completed
;
1437 #include <windows.h>
1439 #include "sub_proc.h"
1443 windows32_openpipe (int *pipedes
, int *pid_p
, char **command_argv
, char **envp
)
1445 SECURITY_ATTRIBUTES saAttr
;
1453 saAttr
.nLength
= sizeof (SECURITY_ATTRIBUTES
);
1454 saAttr
.bInheritHandle
= TRUE
;
1455 saAttr
.lpSecurityDescriptor
= NULL
;
1457 if (DuplicateHandle (GetCurrentProcess(),
1458 GetStdHandle(STD_INPUT_HANDLE
),
1459 GetCurrentProcess(),
1463 DUPLICATE_SAME_ACCESS
) == FALSE
) {
1464 fatal (NILF
, _("create_child_process: DuplicateHandle(In) failed (e=%ld)\n"),
1468 if (DuplicateHandle(GetCurrentProcess(),
1469 GetStdHandle(STD_ERROR_HANDLE
),
1470 GetCurrentProcess(),
1474 DUPLICATE_SAME_ACCESS
) == FALSE
) {
1475 fatal (NILF
, _("create_child_process: DuplicateHandle(Err) failed (e=%ld)\n"),
1479 if (!CreatePipe(&hChildOutRd
, &hChildOutWr
, &saAttr
, 0))
1480 fatal (NILF
, _("CreatePipe() failed (e=%ld)\n"), GetLastError());
1482 hProcess
= process_init_fd(hIn
, hChildOutWr
, hErr
);
1485 fatal (NILF
, _("windows32_openpipe (): process_init_fd() failed\n"));
1487 /* make sure that CreateProcess() has Path it needs */
1488 sync_Path_environment();
1490 if (!process_begin(hProcess
, command_argv
, envp
, command_argv
[0], NULL
)) {
1491 /* register process for wait */
1492 process_register(hProcess
);
1494 /* set the pid for returning to caller */
1495 *pid_p
= (int) hProcess
;
1497 /* set up to read data from child */
1498 pipedes
[0] = _open_osfhandle((long) hChildOutRd
, O_RDONLY
);
1500 /* this will be closed almost right away */
1501 pipedes
[1] = _open_osfhandle((long) hChildOutWr
, O_APPEND
);
1503 /* reap/cleanup the failed process */
1504 process_cleanup(hProcess
);
1506 /* close handles which were duplicated, they weren't used */
1510 /* close pipe handles, they won't be used */
1511 CloseHandle(hChildOutRd
);
1512 CloseHandle(hChildOutWr
);
1514 /* set status for return */
1515 pipedes
[0] = pipedes
[1] = -1;
1524 msdos_openpipe (int* pipedes
, int *pidp
, char *text
)
1527 /* MSDOS can't fork, but it has `popen'. */
1528 struct variable
*sh
= lookup_variable ("SHELL", 5);
1530 extern int dos_command_running
, dos_status
;
1532 /* Make sure not to bother processing an empty line. */
1533 while (isblank ((unsigned char)*text
))
1540 char buf
[PATH_MAX
+ 7];
1541 /* This makes sure $SHELL value is used by $(shell), even
1542 though the target environment is not passed to it. */
1543 sprintf (buf
, "SHELL=%s", sh
->value
);
1549 dos_command_running
= 1;
1551 /* If dos_status becomes non-zero, it means the child process
1552 was interrupted by a signal, like SIGINT or SIGQUIT. See
1553 fatal_error_signal in commands.c. */
1554 fpipe
= popen (text
, "rt");
1555 dos_command_running
= 0;
1556 if (!fpipe
|| dos_status
)
1562 else if (errno
== 0)
1564 shell_function_completed
= -1;
1568 pipedes
[0] = fileno (fpipe
);
1569 *pidp
= 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
1571 shell_function_completed
= 1;
1578 Do shell spawning, with the naughty bits for different OSes.
1583 /* VMS can't do $(shell ...) */
1584 #define func_shell 0
1589 func_shell (char *o
, char **argv
, const char *funcname UNUSED
)
1591 char *batch_filename
= NULL
;
1596 char **command_argv
;
1597 const char *error_prefix
;
1603 /* Construct the argument list. */
1604 command_argv
= construct_command_argv (argv
[0], NULL
, NULL
, 0,
1606 if (command_argv
== 0)
1610 /* Using a target environment for `shell' loses in cases like:
1611 export var = $(shell echo foobie)
1612 because target_environment hits a loop trying to expand $(var)
1613 to put it in the environment. This is even more confusing when
1614 var was not explicitly exported, but just appeared in the
1615 calling environment.
1617 See Savannah bug #10593.
1619 envp = target_environment (NILF);
1624 /* For error messages. */
1625 if (reading_file
&& reading_file
->filenm
)
1627 char *p
= alloca (strlen (reading_file
->filenm
)+11+4);
1628 sprintf (p
, "%s:%lu: ", reading_file
->filenm
, reading_file
->lineno
);
1634 #if defined(__MSDOS__)
1635 fpipe
= msdos_openpipe (pipedes
, &pid
, argv
[0]);
1638 perror_with_name (error_prefix
, "pipe");
1641 #elif defined(WINDOWS32)
1642 windows32_openpipe (pipedes
, &pid
, command_argv
, envp
);
1645 /* open of the pipe failed, mark as failed execution */
1646 shell_function_completed
= -1;
1652 if (pipe (pipedes
) < 0)
1654 perror_with_name (error_prefix
, "pipe");
1659 /* close some handles that are unnecessary for the child process */
1660 CLOSE_ON_EXEC(pipedes
[1]);
1661 CLOSE_ON_EXEC(pipedes
[0]);
1662 /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
1663 pid
= child_execute_job (0, pipedes
[1], command_argv
, envp
);
1665 perror_with_name (error_prefix
, "spawn");
1666 # else /* ! __EMX__ */
1669 perror_with_name (error_prefix
, "fork");
1671 child_execute_job (0, pipedes
[1], command_argv
, envp
);
1676 /* We are the parent. */
1678 unsigned int maxlen
, i
;
1681 /* Record the PID for reap_children. */
1682 shell_function_pid
= pid
;
1684 shell_function_completed
= 0;
1686 /* Free the storage only the child needed. */
1687 free (command_argv
[0]);
1688 free (command_argv
);
1690 /* Close the write side of the pipe. */
1694 /* Set up and read from the pipe. */
1697 buffer
= xmalloc (maxlen
+ 1);
1699 /* Read from the pipe until it gets EOF. */
1700 for (i
= 0; ; i
+= cc
)
1705 buffer
= xrealloc (buffer
, maxlen
+ 1);
1708 EINTRLOOP (cc
, read (pipedes
[0], &buffer
[i
], maxlen
- i
));
1714 /* Close the read side of the pipe. */
1717 (void) pclose (fpipe
);
1719 (void) close (pipedes
[0]);
1722 /* Loop until child_handler or reap_children() sets
1723 shell_function_completed to the status of our child shell. */
1724 while (shell_function_completed
== 0)
1725 reap_children (1, 0);
1727 if (batch_filename
) {
1728 DB (DB_VERBOSE
, (_("Cleaning up temporary batch file %s\n"),
1730 remove (batch_filename
);
1731 free (batch_filename
);
1733 shell_function_pid
= 0;
1735 /* The child_handler function will set shell_function_completed
1736 to 1 when the child dies normally, or to -1 if it
1737 dies with status 127, which is most likely an exec fail. */
1739 if (shell_function_completed
== -1)
1741 /* This likely means that the execvp failed, so we should just
1742 write the error message in the pipe from the child. */
1743 fputs (buffer
, stderr
);
1748 /* The child finished normally. Replace all newlines in its output
1749 with spaces, and put that in the variable output buffer. */
1750 fold_newlines (buffer
, &i
);
1751 o
= variable_buffer_output (o
, buffer
, i
);
1762 /* Do the Amiga version of func_shell. */
1765 func_shell (char *o
, char **argv
, const char *funcname
)
1767 /* Amiga can't fork nor spawn, but I can start a program with
1768 redirection of my choice. However, this means that we
1769 don't have an opportunity to reopen stdout to trap it. Thus,
1770 we save our own stdout onto a new descriptor and dup a temp
1771 file's descriptor onto our stdout temporarily. After we
1772 spawn the shell program, we dup our own stdout back to the
1773 stdout descriptor. The buffer reading is the same as above,
1774 except that we're now reading from a file. */
1776 #include <dos/dos.h>
1777 #include <proto/dos.h>
1780 char tmp_output
[FILENAME_MAX
];
1781 unsigned int maxlen
= 200, i
;
1783 char * buffer
, * ptr
;
1786 char* batch_filename
= NULL
;
1788 /* Construct the argument list. */
1789 command_argv
= construct_command_argv (argv
[0], NULL
, NULL
, 0,
1791 if (command_argv
== 0)
1794 /* Note the mktemp() is a security hole, but this only runs on Amiga.
1795 Ideally we would use main.c:open_tmpfile(), but this uses a special
1796 Open(), not fopen(), and I'm not familiar enough with the code to mess
1798 strcpy (tmp_output
, "t:MakeshXXXXXXXX");
1799 mktemp (tmp_output
);
1800 child_stdout
= Open (tmp_output
, MODE_NEWFILE
);
1802 for (aptr
=command_argv
; *aptr
; aptr
++)
1803 len
+= strlen (*aptr
) + 1;
1805 buffer
= xmalloc (len
+ 1);
1808 for (aptr
=command_argv
; *aptr
; aptr
++)
1810 strcpy (ptr
, *aptr
);
1811 ptr
+= strlen (ptr
) + 1;
1818 Execute (buffer
, NULL
, child_stdout
);
1821 Close (child_stdout
);
1823 child_stdout
= Open (tmp_output
, MODE_OLDFILE
);
1825 buffer
= xmalloc (maxlen
);
1832 buffer
= xrealloc (buffer
, maxlen
+ 1);
1835 cc
= Read (child_stdout
, &buffer
[i
], maxlen
- i
);
1840 Close (child_stdout
);
1842 fold_newlines (buffer
, &i
);
1843 o
= variable_buffer_output (o
, buffer
, i
);
1853 equality. Return is string-boolean, ie, the empty string is false.
1856 func_eq (char *o
, char **argv
, char *funcname
)
1858 int result
= ! strcmp (argv
[0], argv
[1]);
1859 o
= variable_buffer_output (o
, result
? "1" : "", result
);
1865 string-boolean not operator.
1868 func_not (char *o
, char **argv
, char *funcname
)
1870 const char *s
= argv
[0];
1872 while (isspace ((unsigned char)*s
))
1875 o
= variable_buffer_output (o
, result
? "1" : "", result
);
1881 /* Return the absolute name of file NAME which does not contain any `.',
1882 `..' components nor any repeated path separators ('/'). */
1885 abspath (const char *name
, char *apath
)
1888 const char *start
, *end
, *apath_limit
;
1890 if (name
[0] == '\0' || apath
== NULL
)
1893 apath_limit
= apath
+ GET_PATH_MAX
;
1897 /* It is unlikely we would make it until here but just to make sure. */
1898 if (!starting_directory
)
1901 strcpy (apath
, starting_directory
);
1903 dest
= strchr (apath
, '\0');
1911 for (start
= end
= name
; *start
!= '\0'; start
= end
)
1915 /* Skip sequence of multiple path-separators. */
1916 while (*start
== '/')
1919 /* Find end of path component. */
1920 for (end
= start
; *end
!= '\0' && *end
!= '/'; ++end
)
1927 else if (len
== 1 && start
[0] == '.')
1929 else if (len
== 2 && start
[0] == '.' && start
[1] == '.')
1931 /* Back up to previous component, ignore if at root already. */
1932 if (dest
> apath
+ 1)
1933 while ((--dest
)[-1] != '/');
1937 if (dest
[-1] != '/')
1940 if (dest
+ len
>= apath_limit
)
1943 dest
= memcpy (dest
, start
, len
);
1949 /* Unless it is root strip trailing separator. */
1950 if (dest
> apath
+ 1 && dest
[-1] == '/')
1960 func_realpath (char *o
, char **argv
, const char *funcname UNUSED
)
1962 /* Expand the argument. */
1963 const char *p
= argv
[0];
1964 const char *path
= 0;
1966 unsigned int len
= 0;
1970 while ((path
= find_next_token (&p
, &len
)) != 0)
1972 if (len
< GET_PATH_MAX
)
1974 strncpy (in
, path
, len
);
1978 #ifdef HAVE_REALPATH
1985 o
= variable_buffer_output (o
, out
, strlen (out
));
1986 o
= variable_buffer_output (o
, " ", 1);
1992 /* Kill last space. */
2000 func_abspath (char *o
, char **argv
, const char *funcname UNUSED
)
2002 /* Expand the argument. */
2003 const char *p
= argv
[0];
2004 const char *path
= 0;
2006 unsigned int len
= 0;
2010 while ((path
= find_next_token (&p
, &len
)) != 0)
2012 if (len
< GET_PATH_MAX
)
2014 strncpy (in
, path
, len
);
2017 if (abspath (in
, out
))
2019 o
= variable_buffer_output (o
, out
, strlen (out
));
2020 o
= variable_buffer_output (o
, " ", 1);
2026 /* Kill last space. */
2033 /* Lookup table for builtin functions.
2035 This doesn't have to be sorted; we use a straight lookup. We might gain
2036 some efficiency by moving most often used functions to the start of the
2039 If MAXIMUM_ARGS is 0, that means there is no maximum and all
2040 comma-separated values are treated as arguments.
2042 EXPAND_ARGS means that all arguments should be expanded before invocation.
2043 Functions that do namespace tricks (foreach) don't automatically expand. */
2045 static char *func_call (char *o
, char **argv
, const char *funcname
);
2048 static struct function_table_entry function_table_init
[] =
2050 /* Name/size */ /* MIN MAX EXP? Function */
2051 { STRING_SIZE_TUPLE("abspath"), 0, 1, 1, func_abspath
},
2052 { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix
},
2053 { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix
},
2054 { STRING_SIZE_TUPLE("basename"), 0, 1, 1, func_basename_dir
},
2055 { STRING_SIZE_TUPLE("dir"), 0, 1, 1, func_basename_dir
},
2056 { STRING_SIZE_TUPLE("notdir"), 0, 1, 1, func_notdir_suffix
},
2057 { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst
},
2058 { STRING_SIZE_TUPLE("suffix"), 0, 1, 1, func_notdir_suffix
},
2059 { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout
},
2060 { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout
},
2061 { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring
},
2062 { STRING_SIZE_TUPLE("firstword"), 0, 1, 1, func_firstword
},
2063 { STRING_SIZE_TUPLE("flavor"), 0, 1, 1, func_flavor
},
2064 { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join
},
2065 { STRING_SIZE_TUPLE("lastword"), 0, 1, 1, func_lastword
},
2066 { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst
},
2067 { STRING_SIZE_TUPLE("realpath"), 0, 1, 1, func_realpath
},
2068 { STRING_SIZE_TUPLE("shell"), 0, 1, 1, func_shell
},
2069 { STRING_SIZE_TUPLE("sort"), 0, 1, 1, func_sort
},
2070 { STRING_SIZE_TUPLE("strip"), 0, 1, 1, func_strip
},
2071 { STRING_SIZE_TUPLE("wildcard"), 0, 1, 1, func_wildcard
},
2072 { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word
},
2073 { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist
},
2074 { STRING_SIZE_TUPLE("words"), 0, 1, 1, func_words
},
2075 { STRING_SIZE_TUPLE("origin"), 0, 1, 1, func_origin
},
2076 { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach
},
2077 { STRING_SIZE_TUPLE("call"), 1, 0, 1, func_call
},
2078 { STRING_SIZE_TUPLE("info"), 0, 1, 1, func_error
},
2079 { STRING_SIZE_TUPLE("error"), 0, 1, 1, func_error
},
2080 { STRING_SIZE_TUPLE("warning"), 0, 1, 1, func_error
},
2081 { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if
},
2082 { STRING_SIZE_TUPLE("or"), 1, 0, 0, func_or
},
2083 { STRING_SIZE_TUPLE("and"), 1, 0, 0, func_and
},
2084 { STRING_SIZE_TUPLE("value"), 0, 1, 1, func_value
},
2085 { STRING_SIZE_TUPLE("eval"), 0, 1, 1, func_eval
},
2087 { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq
},
2088 { STRING_SIZE_TUPLE("not"), 0, 1, 1, func_not
},
2092 #define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry))
2095 /* These must come after the definition of function_table. */
2098 expand_builtin_function (char *o
, int argc
, char **argv
,
2099 const struct function_table_entry
*entry_p
)
2101 if (argc
< (int)entry_p
->minimum_args
)
2102 fatal (*expanding_var
,
2103 _("insufficient number of arguments (%d) to function `%s'"),
2104 argc
, entry_p
->name
);
2106 /* I suppose technically some function could do something with no
2107 arguments, but so far none do, so just test it for all functions here
2108 rather than in each one. We can change it later if necessary. */
2113 if (!entry_p
->func_ptr
)
2114 fatal (*expanding_var
,
2115 _("unimplemented on this platform: function `%s'"), entry_p
->name
);
2117 return entry_p
->func_ptr (o
, argv
, entry_p
->name
);
2120 /* Check for a function invocation in *STRINGP. *STRINGP points at the
2121 opening ( or { and is not null-terminated. If a function invocation
2122 is found, expand it into the buffer at *OP, updating *OP, incrementing
2123 *STRINGP past the reference and returning nonzero. If not, return zero. */
2126 handle_function (char **op
, const char **stringp
)
2128 const struct function_table_entry
*entry_p
;
2129 char openparen
= (*stringp
)[0];
2130 char closeparen
= openparen
== '(' ? ')' : '}';
2135 char **argv
, **argvp
;
2140 entry_p
= lookup_function (beg
);
2145 /* We found a builtin function. Find the beginning of its arguments (skip
2146 whitespace after the name). */
2148 beg
= next_token (beg
+ entry_p
->len
);
2150 /* Find the end of the function invocation, counting nested use of
2151 whichever kind of parens we use. Since we're looking, count commas
2152 to get a rough estimate of how many arguments we might have. The
2153 count might be high, but it'll never be low. */
2155 for (nargs
=1, end
=beg
; *end
!= '\0'; ++end
)
2158 else if (*end
== openparen
)
2160 else if (*end
== closeparen
&& --count
< 0)
2164 fatal (*expanding_var
,
2165 _("unterminated call to function `%s': missing `%c'"),
2166 entry_p
->name
, closeparen
);
2170 /* Get some memory to store the arg pointers. */
2171 argvp
= argv
= alloca (sizeof (char *) * (nargs
+ 2));
2173 /* Chop the string into arguments, then a nul. As soon as we hit
2174 MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
2177 If we're expanding, store pointers to the expansion of each one. If
2178 not, make a duplicate of the string and point into that, nul-terminating
2181 if (entry_p
->expand_args
)
2184 for (p
=beg
, nargs
=0; p
<= end
; ++argvp
)
2190 if (nargs
== entry_p
->maximum_args
2191 || (! (next
= find_next_argument (openparen
, closeparen
, p
, end
))))
2194 *argvp
= expand_argument (p
, next
);
2200 int len
= end
- beg
;
2203 abeg
= xmalloc (len
+1);
2204 memcpy (abeg
, beg
, len
);
2208 for (p
=abeg
, nargs
=0; p
<= aend
; ++argvp
)
2214 if (nargs
== entry_p
->maximum_args
2215 || (! (next
= find_next_argument (openparen
, closeparen
, p
, aend
))))
2225 /* Finally! Run the function... */
2226 *op
= expand_builtin_function (*op
, nargs
, argv
, entry_p
);
2229 if (entry_p
->expand_args
)
2230 for (argvp
=argv
; *argvp
!= 0; ++argvp
)
2239 /* User-defined functions. Expand the first argument as either a builtin
2240 function or a make variable, in the context of the rest of the arguments
2241 assigned to $1, $2, ... $N. $0 is the name of the function. */
2244 func_call (char *o
, char **argv
, const char *funcname UNUSED
)
2246 static int max_args
= 0;
2253 const struct function_table_entry
*entry_p
;
2256 /* There is no way to define a variable with a space in the name, so strip
2257 leading and trailing whitespace as a favor to the user. */
2259 while (*fname
!= '\0' && isspace ((unsigned char)*fname
))
2262 cp
= fname
+ strlen (fname
) - 1;
2263 while (cp
> fname
&& isspace ((unsigned char)*cp
))
2267 /* Calling nothing is a no-op */
2271 /* Are we invoking a builtin function? */
2273 entry_p
= lookup_function (fname
);
2276 /* How many arguments do we have? */
2277 for (i
=0; argv
[i
+1]; ++i
)
2279 return expand_builtin_function (o
, i
, argv
+1, entry_p
);
2282 /* Not a builtin, so the first argument is the name of a variable to be
2283 expanded and interpreted as a function. Find it. */
2284 flen
= strlen (fname
);
2286 v
= lookup_variable (fname
, flen
);
2289 warn_undefined (fname
, flen
);
2291 if (v
== 0 || *v
->value
== '\0')
2294 body
= alloca (flen
+ 4);
2297 memcpy (body
+ 2, fname
, flen
);
2299 body
[flen
+3] = '\0';
2301 /* Set up arguments $(1) .. $(N). $(0) is the function name. */
2303 push_new_variable_scope ();
2305 for (i
=0; *argv
; ++i
, ++argv
)
2309 sprintf (num
, "%d", i
);
2310 define_variable (num
, strlen (num
), *argv
, o_automatic
, 0);
2313 /* If the number of arguments we have is < max_args, it means we're inside
2314 a recursive invocation of $(call ...). Fill in the remaining arguments
2315 in the new scope with the empty value, to hide them from this
2318 for (; i
< max_args
; ++i
)
2322 sprintf (num
, "%d", i
);
2323 define_variable (num
, strlen (num
), "", o_automatic
, 0);
2326 /* Expand the body in the context of the arguments, adding the result to
2327 the variable buffer. */
2329 v
->exp_count
= EXP_COUNT_MAX
;
2331 saved_args
= max_args
;
2333 o
= variable_expand_string (o
, body
, flen
+3);
2334 max_args
= saved_args
;
2338 pop_variable_scope ();
2340 return o
+ strlen (o
);
2344 hash_init_function_table (void)
2346 hash_init (&function_table
, FUNCTION_TABLE_ENTRIES
* 2,
2347 function_table_entry_hash_1
, function_table_entry_hash_2
,
2348 function_table_entry_hash_cmp
);
2349 hash_load (&function_table
, function_table_init
,
2350 FUNCTION_TABLE_ENTRIES
, sizeof (struct function_table_entry
));