1 /* Builtin function expansion for GNU Make.
2 Copyright (C) 1988, 1989, 1991-1997, 1999, 2002 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 function_table_entry_hash_1 (const void *keyv
)
46 struct function_table_entry
const *key
= (struct function_table_entry
const *) keyv
;
47 return_STRING_N_HASH_1 (key
->name
, key
->len
);
51 function_table_entry_hash_2 (const void *keyv
)
53 struct function_table_entry
const *key
= (struct function_table_entry
const *) keyv
;
54 return_STRING_N_HASH_2 (key
->name
, key
->len
);
58 function_table_entry_hash_cmp (const void *xv
, const void *yv
)
60 struct function_table_entry
const *x
= (struct function_table_entry
const *) xv
;
61 struct function_table_entry
const *y
= (struct function_table_entry
const *) yv
;
62 int result
= x
->len
- y
->len
;
65 return_STRING_N_COMPARE (x
->name
, y
->name
, x
->len
);
68 static struct hash_table function_table
;
71 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing
72 each occurrence of SUBST with REPLACE. TEXT is null-terminated. SLEN is
73 the length of SUBST and RLEN is the length of REPLACE. If BY_WORD is
74 nonzero, substitutions are done only on matches which are complete
75 whitespace-delimited words. */
78 subst_expand (char *o
, char *text
, char *subst
, char *replace
,
79 unsigned int slen
, unsigned int rlen
, int by_word
)
84 if (slen
== 0 && !by_word
)
86 /* The first occurrence of "" in any string is its end. */
87 o
= variable_buffer_output (o
, t
, strlen (t
));
89 o
= variable_buffer_output (o
, replace
, rlen
);
95 if (by_word
&& slen
== 0)
96 /* When matching by words, the empty string should match
97 the end of each word, rather than the end of the whole text. */
98 p
= end_of_token (next_token (t
));
101 p
= strstr (t
, subst
);
104 /* No more matches. Output everything left on the end. */
105 o
= variable_buffer_output (o
, t
, strlen (t
));
110 /* Output everything before this occurrence of the string to replace. */
112 o
= variable_buffer_output (o
, t
, p
- t
);
114 /* If we're substituting only by fully matched words,
115 or only at the ends of words, check that this case qualifies. */
117 && ((p
> text
&& !isblank ((unsigned char)p
[-1]))
118 || (p
[slen
] != '\0' && !isblank ((unsigned char)p
[slen
]))))
119 /* Struck out. Output the rest of the string that is
120 no longer to be replaced. */
121 o
= variable_buffer_output (o
, subst
, slen
);
123 /* Output the replacement string. */
124 o
= variable_buffer_output (o
, replace
, rlen
);
126 /* Advance T past the string to be replaced. */
131 } while (*t
!= '\0');
137 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT
138 and replacing strings matching PATTERN with REPLACE.
139 If PATTERN_PERCENT is not nil, PATTERN has already been
140 run through find_percent, and PATTERN_PERCENT is the result.
141 If REPLACE_PERCENT is not nil, REPLACE has already been
142 run through find_percent, and REPLACE_PERCENT is the result.
143 Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
144 character _AFTER_ the %, not to the % itself.
148 patsubst_expand (char *o
, char *text
, char *pattern
, char *replace
,
149 char *pattern_percent
, char *replace_percent
)
151 unsigned int pattern_prepercent_len
, pattern_postpercent_len
;
152 unsigned int replace_prepercent_len
, replace_postpercent_len
;
157 /* We call find_percent on REPLACE before checking PATTERN so that REPLACE
158 will be collapsed before we call subst_expand if PATTERN has no %. */
159 if (!replace_percent
)
161 replace_percent
= find_percent (replace
);
166 /* Record the length of REPLACE before and after the % so we don't have to
167 compute these lengths more than once. */
170 replace_prepercent_len
= replace_percent
- replace
- 1;
171 replace_postpercent_len
= strlen (replace_percent
);
175 replace_prepercent_len
= strlen (replace
);
176 replace_postpercent_len
= 0;
179 if (!pattern_percent
)
181 pattern_percent
= find_percent (pattern
);
185 if (!pattern_percent
)
186 /* With no % in the pattern, this is just a simple substitution. */
187 return subst_expand (o
, text
, pattern
, replace
,
188 strlen (pattern
), strlen (replace
), 1);
190 /* Record the length of PATTERN before and after the %
191 so we don't have to compute it more than once. */
192 pattern_prepercent_len
= pattern_percent
- pattern
- 1;
193 pattern_postpercent_len
= strlen (pattern_percent
);
195 while ((t
= find_next_token (&text
, &len
)) != 0)
199 /* Is it big enough to match? */
200 if (len
< pattern_prepercent_len
+ pattern_postpercent_len
)
203 /* Does the prefix match? */
204 if (!fail
&& pattern_prepercent_len
> 0
206 || t
[pattern_prepercent_len
- 1] != pattern_percent
[-2]
207 || !strneq (t
+ 1, pattern
+ 1, pattern_prepercent_len
- 1)))
210 /* Does the suffix match? */
211 if (!fail
&& pattern_postpercent_len
> 0
212 && (t
[len
- 1] != pattern_percent
[pattern_postpercent_len
- 1]
213 || t
[len
- pattern_postpercent_len
] != *pattern_percent
214 || !strneq (&t
[len
- pattern_postpercent_len
],
215 pattern_percent
, pattern_postpercent_len
- 1)))
219 /* It didn't match. Output the string. */
220 o
= variable_buffer_output (o
, t
, len
);
223 /* It matched. Output the replacement. */
225 /* Output the part of the replacement before the %. */
226 o
= variable_buffer_output (o
, replace
, replace_prepercent_len
);
228 if (replace_percent
!= 0)
230 /* Output the part of the matched string that
231 matched the % in the pattern. */
232 o
= variable_buffer_output (o
, t
+ pattern_prepercent_len
,
233 len
- (pattern_prepercent_len
234 + pattern_postpercent_len
));
235 /* Output the part of the replacement after the %. */
236 o
= variable_buffer_output (o
, replace_percent
,
237 replace_postpercent_len
);
241 /* Output a space, but not if the replacement is "". */
242 if (fail
|| replace_prepercent_len
> 0
243 || (replace_percent
!= 0 && len
+ replace_postpercent_len
> 0))
245 o
= variable_buffer_output (o
, " ", 1);
250 /* Kill the last space. */
257 /* Look up a function by name. */
259 static const struct function_table_entry
*
260 lookup_function (const char *s
)
264 while (*e
&& ( (*e
>= 'a' && *e
<= 'z') || *e
== '-'))
266 if (*e
== '\0' || isblank ((unsigned char) *e
))
268 struct function_table_entry function_table_entry_key
;
269 function_table_entry_key
.name
= s
;
270 function_table_entry_key
.len
= e
- s
;
272 return hash_find_item (&function_table
, &function_table_entry_key
);
278 /* Return 1 if PATTERN matches STR, 0 if not. */
281 pattern_matches (char *pattern
, char *percent
, char *str
)
283 unsigned int sfxlen
, strlength
;
287 unsigned int len
= strlen (pattern
) + 1;
288 char *new_chars
= (char *) alloca (len
);
289 bcopy (pattern
, new_chars
, len
);
291 percent
= find_percent (pattern
);
293 return streq (pattern
, str
);
296 sfxlen
= strlen (percent
+ 1);
297 strlength
= strlen (str
);
299 if (strlength
< (percent
- pattern
) + sfxlen
300 || !strneq (pattern
, str
, percent
- pattern
))
303 return !strcmp (percent
+ 1, str
+ (strlength
- sfxlen
));
307 /* Find the next comma or ENDPAREN (counting nested STARTPAREN and
308 ENDPARENtheses), starting at PTR before END. Return a pointer to
311 If no next argument is found, return NULL.
315 find_next_argument (char startparen
, char endparen
,
316 const char *ptr
, const char *end
)
320 for (; ptr
< end
; ++ptr
)
321 if (*ptr
== startparen
)
324 else if (*ptr
== endparen
)
331 else if (*ptr
== ',' && !count
)
334 /* We didn't find anything. */
339 /* Glob-expand LINE. The returned pointer is
340 only good until the next call to string_glob. */
343 string_glob (char *line
)
345 static char *result
= 0;
346 static unsigned int length
;
347 register struct nameseq
*chain
;
348 register unsigned int idx
;
350 chain
= multi_glob (parse_file_seq
351 (&line
, '\0', sizeof (struct nameseq
),
352 /* We do not want parse_file_seq to strip `./'s.
353 That would break examples like:
354 $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)). */
356 sizeof (struct nameseq
));
361 result
= (char *) xmalloc (100);
367 register char *name
= chain
->name
;
368 unsigned int len
= strlen (name
);
370 struct nameseq
*next
= chain
->next
;
371 free ((char *) chain
);
374 /* multi_glob will pass names without globbing metacharacters
375 through as is, but we want only files that actually exist. */
376 if (file_exists_p (name
))
378 if (idx
+ len
+ 1 > length
)
380 length
+= (len
+ 1) * 2;
381 result
= (char *) xrealloc (result
, length
);
383 bcopy (name
, &result
[idx
], len
);
391 /* Kill the last space and terminate the string. */
395 result
[idx
- 1] = '\0';
405 func_patsubst (char *o
, char **argv
, const char *funcname UNUSED
)
407 o
= patsubst_expand (o
, argv
[2], argv
[0], argv
[1], (char *) 0, (char *) 0);
413 func_join (char *o
, char **argv
, const char *funcname UNUSED
)
417 /* Write each word of the first argument directly followed
418 by the corresponding word of the second argument.
419 If the two arguments have a different number of words,
420 the excess words are just output separated by blanks. */
423 char *list1_iterator
= argv
[0];
424 char *list2_iterator
= argv
[1];
427 unsigned int len1
, len2
;
429 tp
= find_next_token (&list1_iterator
, &len1
);
431 o
= variable_buffer_output (o
, tp
, len1
);
433 pp
= find_next_token (&list2_iterator
, &len2
);
435 o
= variable_buffer_output (o
, pp
, len2
);
437 if (tp
!= 0 || pp
!= 0)
439 o
= variable_buffer_output (o
, " ", 1);
443 while (tp
!= 0 || pp
!= 0);
445 /* Kill the last blank. */
453 func_origin (char *o
, char **argv
, const char *funcname UNUSED
)
455 /* Expand the argument. */
456 register struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
458 o
= variable_buffer_output (o
, "undefined", 9);
467 o
= variable_buffer_output (o
, "default", 7);
470 o
= variable_buffer_output (o
, "environment", 11);
473 o
= variable_buffer_output (o
, "file", 4);
476 o
= variable_buffer_output (o
, "environment override", 20);
479 o
= variable_buffer_output (o
, "command line", 12);
482 o
= variable_buffer_output (o
, "override", 8);
485 o
= variable_buffer_output (o
, "automatic", 9);
493 func_flavor (char *o
, char **argv
, const char *funcname UNUSED
)
495 register struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
498 o
= variable_buffer_output (o
, "undefined", 9);
501 o
= variable_buffer_output (o
, "recursive", 9);
503 o
= variable_buffer_output (o
, "simple", 6);
509 # define IS_PATHSEP(c) ((c) == ']')
511 # ifdef HAVE_DOS_PATHS
512 # define IS_PATHSEP(c) ((c) == '/' || (c) == '\\')
514 # define IS_PATHSEP(c) ((c) == '/')
520 func_notdir_suffix (char *o
, char **argv
, const char *funcname
)
522 /* Expand the argument. */
523 char *list_iterator
= argv
[0];
528 int is_suffix
= streq (funcname
, "suffix");
529 int is_notdir
= !is_suffix
;
530 while ((p2
= find_next_token (&list_iterator
, &len
)) != 0)
535 while (p
>= p2
&& (!is_suffix
|| *p
!= '.'))
548 o
= variable_buffer_output (o
, p
, len
- (p
- p2
));
550 #ifdef HAVE_DOS_PATHS
551 /* Handle the case of "d:foo/bar". */
552 else if (streq (funcname
, "notdir") && p2
[0] && p2
[1] == ':')
555 o
= variable_buffer_output (o
, p
, len
- (p
- p2
));
559 o
= variable_buffer_output (o
, p2
, len
);
561 if (is_notdir
|| p
>= p2
)
563 o
= variable_buffer_output (o
, " ", 1);
568 /* Kill last space. */
578 func_basename_dir (char *o
, char **argv
, const char *funcname
)
580 /* Expand the argument. */
586 int is_basename
= streq (funcname
, "basename");
587 int is_dir
= !is_basename
;
589 while ((p2
= find_next_token (&p3
, &len
)) != 0)
592 while (p
>= p2
&& (!is_basename
|| *p
!= '.'))
599 if (p
>= p2
&& (is_dir
))
600 o
= variable_buffer_output (o
, p2
, ++p
- p2
);
601 else if (p
>= p2
&& (*p
== '.'))
602 o
= variable_buffer_output (o
, p2
, p
- p2
);
603 #ifdef HAVE_DOS_PATHS
604 /* Handle the "d:foobar" case */
605 else if (p2
[0] && p2
[1] == ':' && is_dir
)
606 o
= variable_buffer_output (o
, p2
, 2);
610 o
= variable_buffer_output (o
, "[]", 2);
613 o
= variable_buffer_output (o
, "./", 2);
615 ; /* Just a nop... */
619 /* The entire name is the basename. */
620 o
= variable_buffer_output (o
, p2
, len
);
622 o
= variable_buffer_output (o
, " ", 1);
626 /* Kill last space. */
634 func_addsuffix_addprefix (char *o
, char **argv
, const char *funcname
)
636 int fixlen
= strlen (argv
[0]);
637 char *list_iterator
= argv
[1];
638 int is_addprefix
= streq (funcname
, "addprefix");
639 int is_addsuffix
= !is_addprefix
;
645 while ((p
= find_next_token (&list_iterator
, &len
)) != 0)
648 o
= variable_buffer_output (o
, argv
[0], fixlen
);
649 o
= variable_buffer_output (o
, p
, len
);
651 o
= variable_buffer_output (o
, argv
[0], fixlen
);
652 o
= variable_buffer_output (o
, " ", 1);
657 /* Kill last space. */
664 func_subst (char *o
, char **argv
, const char *funcname UNUSED
)
666 o
= subst_expand (o
, argv
[2], argv
[0], argv
[1], strlen (argv
[0]),
667 strlen (argv
[1]), 0);
674 func_firstword (char *o
, char **argv
, const char *funcname UNUSED
)
677 char *words
= argv
[0]; /* Use a temp variable for find_next_token */
678 char *p
= find_next_token (&words
, &i
);
681 o
= variable_buffer_output (o
, p
, i
);
687 func_lastword (char *o
, char **argv
, const char *funcname UNUSED
)
690 char *words
= argv
[0]; /* Use a temp variable for find_next_token */
694 while ((t
= find_next_token (&words
, &i
)))
698 o
= variable_buffer_output (o
, p
, i
);
704 func_words (char *o
, char **argv
, const char *funcname UNUSED
)
707 char *word_iterator
= argv
[0];
710 while (find_next_token (&word_iterator
, (unsigned int *) 0) != 0)
713 sprintf (buf
, "%d", i
);
714 o
= variable_buffer_output (o
, buf
, strlen (buf
));
720 /* Set begpp to point to the first non-whitespace character of the string,
721 * and endpp to point to the last non-whitespace character of the string.
722 * If the string is empty or contains nothing but whitespace, endpp will be
726 strip_whitespace (const char **begpp
, const char **endpp
)
728 while (*begpp
<= *endpp
&& isspace ((unsigned char)**begpp
))
730 while (*endpp
>= *begpp
&& isspace ((unsigned char)**endpp
))
732 return (char *)*begpp
;
736 check_numeric (const char *s
, const char *message
)
738 const char *end
= s
+ strlen (s
) - 1;
740 strip_whitespace (&s
, &end
);
742 for (; s
<= end
; ++s
)
743 if (!ISDIGIT (*s
)) /* ISDIGIT only evals its arg once: see make.h. */
746 if (s
<= end
|| end
- beg
< 0)
747 fatal (reading_file
, "%s: '%s'", message
, beg
);
753 func_word (char *o
, char **argv
, const char *funcname UNUSED
)
759 /* Check the first argument. */
760 check_numeric (argv
[0], _("non-numeric first argument to `word' function"));
764 fatal (reading_file
, _("first argument to `word' function must be greater than 0"));
768 while ((p
= find_next_token (&end_p
, 0)) != 0)
773 o
= variable_buffer_output (o
, p
, end_p
- p
);
779 func_wordlist (char *o
, char **argv
, const char *funcname UNUSED
)
783 /* Check the arguments. */
784 check_numeric (argv
[0],
785 _("non-numeric first argument to `wordlist' function"));
786 check_numeric (argv
[1],
787 _("non-numeric second argument to `wordlist' function"));
789 start
= atoi (argv
[0]);
792 "invalid first argument to `wordlist' function: `%d'", start
);
794 count
= atoi (argv
[1]) - start
+ 1;
799 char *end_p
= argv
[2];
801 /* Find the beginning of the "start"th word. */
802 while (((p
= find_next_token (&end_p
, 0)) != 0) && --start
)
807 /* Find the end of the "count"th word from start. */
808 while (--count
&& (find_next_token (&end_p
, 0) != 0))
811 /* Return the stuff in the middle. */
812 o
= variable_buffer_output (o
, p
, end_p
- p
);
820 func_findstring (char *o
, char **argv
, const char *funcname UNUSED
)
822 /* Find the first occurrence of the first string in the second. */
823 if (strstr (argv
[1], argv
[0]) != 0)
824 o
= variable_buffer_output (o
, argv
[0], strlen (argv
[0]));
830 func_foreach (char *o
, char **argv
, const char *funcname UNUSED
)
832 /* expand only the first two. */
833 char *varname
= expand_argument (argv
[0], NULL
);
834 char *list
= expand_argument (argv
[1], NULL
);
835 char *body
= argv
[2];
838 char *list_iterator
= list
;
841 register struct variable
*var
;
843 push_new_variable_scope ();
844 var
= define_variable (varname
, strlen (varname
), "", o_automatic
, 0);
846 /* loop through LIST, put the value in VAR and expand BODY */
847 while ((p
= find_next_token (&list_iterator
, &len
)) != 0)
856 var
->value
= (char *) xstrdup ((char*) p
);
860 result
= allocated_variable_expand (body
);
862 o
= variable_buffer_output (o
, result
, strlen (result
));
863 o
= variable_buffer_output (o
, " ", 1);
869 /* Kill the last space. */
872 pop_variable_scope ();
882 struct a_word
*chain
;
889 a_word_hash_1 (const void *key
)
891 return_STRING_HASH_1 (((struct a_word
const *) key
)->str
);
895 a_word_hash_2 (const void *key
)
897 return_STRING_HASH_2 (((struct a_word
const *) key
)->str
);
901 a_word_hash_cmp (const void *x
, const void *y
)
903 int result
= ((struct a_word
const *) x
)->length
- ((struct a_word
const *) y
)->length
;
906 return_STRING_COMPARE (((struct a_word
const *) x
)->str
,
907 ((struct a_word
const *) y
)->str
);
912 struct a_pattern
*next
;
920 func_filter_filterout (char *o
, char **argv
, const char *funcname
)
922 struct a_word
*wordhead
;
923 struct a_word
**wordtail
;
925 struct a_pattern
*pathead
;
926 struct a_pattern
**pattail
;
927 struct a_pattern
*pp
;
929 struct hash_table a_word_table
;
930 int is_filter
= streq (funcname
, "filter");
931 char *pat_iterator
= argv
[0];
932 char *word_iterator
= argv
[1];
939 /* Chop ARGV[0] up into patterns to match against the words. */
942 while ((p
= find_next_token (&pat_iterator
, &len
)) != 0)
944 struct a_pattern
*pat
= (struct a_pattern
*) alloca (sizeof (struct a_pattern
));
947 pattail
= &pat
->next
;
949 if (*pat_iterator
!= '\0')
954 pat
->save_c
= p
[len
];
956 pat
->percent
= find_percent (p
);
957 if (pat
->percent
== 0)
962 /* Chop ARGV[1] up into words to match against the patterns. */
964 wordtail
= &wordhead
;
965 while ((p
= find_next_token (&word_iterator
, &len
)) != 0)
967 struct a_word
*word
= (struct a_word
*) alloca (sizeof (struct a_word
));
970 wordtail
= &word
->next
;
972 if (*word_iterator
!= '\0')
984 /* Only use a hash table if arg list lengths justifies the cost. */
985 hashing
= (literals
>= 2 && (literals
* words
) >= 10);
988 hash_init (&a_word_table
, words
, a_word_hash_1
, a_word_hash_2
, a_word_hash_cmp
);
989 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
991 struct a_word
*owp
= hash_insert (&a_word_table
, wp
);
1001 /* Run each pattern through the words, killing words. */
1002 for (pp
= pathead
; pp
!= 0; pp
= pp
->next
)
1005 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
1006 wp
->matched
|= pattern_matches (pp
->str
, pp
->percent
, wp
->str
);
1009 struct a_word a_word_key
;
1010 a_word_key
.str
= pp
->str
;
1011 a_word_key
.length
= pp
->length
;
1012 wp
= (struct a_word
*) hash_find_item (&a_word_table
, &a_word_key
);
1020 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
1021 wp
->matched
|= (wp
->length
== pp
->length
1022 && strneq (pp
->str
, wp
->str
, wp
->length
));
1025 /* Output the words that matched (or didn't, for filter-out). */
1026 for (wp
= wordhead
; wp
!= 0; wp
= wp
->next
)
1027 if (is_filter
? wp
->matched
: !wp
->matched
)
1029 o
= variable_buffer_output (o
, wp
->str
, strlen (wp
->str
));
1030 o
= variable_buffer_output (o
, " ", 1);
1035 /* Kill the last space. */
1039 for (pp
= pathead
; pp
!= 0; pp
= pp
->next
)
1040 pp
->str
[pp
->length
] = pp
->save_c
;
1043 hash_free (&a_word_table
, 0);
1050 func_strip (char *o
, char **argv
, const char *funcname UNUSED
)
1060 while (isspace ((unsigned char)*p
))
1063 for (i
=0; *p
!= '\0' && !isspace ((unsigned char)*p
); ++p
, ++i
)
1067 o
= variable_buffer_output (o
, word_start
, i
);
1068 o
= variable_buffer_output (o
, " ", 1);
1073 /* 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
= (char *) 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 (reading_file
, "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
)
1135 register int wordi
= 0;
1137 /* Chop ARGV[0] into words and put them in WORDS. */
1143 while ((p
= find_next_token (&t
, &len
)) != 0)
1145 if (wordi
>= nwords
- 1)
1147 nwords
= (2 * nwords
) + 5;
1148 words
= (char **) xrealloc ((char *) words
,
1149 nwords
* sizeof (char *));
1151 words
[wordi
++] = savestring (p
, len
);
1157 /* Now sort the list of words. */
1158 qsort ((char *) words
, wordi
, sizeof (char *), alpha_compare
);
1160 /* Now write the sorted list. */
1161 for (i
= 0; i
< wordi
; ++i
)
1163 len
= strlen (words
[i
]);
1164 if (i
== wordi
- 1 || strlen (words
[i
+ 1]) != len
1165 || strcmp (words
[i
], words
[i
+ 1]))
1167 o
= variable_buffer_output (o
, words
[i
], len
);
1168 o
= variable_buffer_output (o
, " ", 1);
1172 /* Kill the last space. */
1181 $(if condition,true-part[,false-part])
1183 CONDITION is false iff it evaluates to an empty string. White
1184 space before and after condition are stripped before evaluation.
1186 If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is
1187 evaluated (if it exists). Because only one of the two PARTs is evaluated,
1188 you can use $(if ...) to create side-effects (with $(shell ...), for
1193 func_if (char *o
, char **argv
, const char *funcname UNUSED
)
1195 const char *begp
= argv
[0];
1196 const char *endp
= begp
+ strlen (argv
[0]) - 1;
1199 /* Find the result of the condition: if we have a value, and it's not
1200 empty, the condition is true. If we don't have a value, or it's the
1201 empty string, then it's false. */
1203 strip_whitespace (&begp
, &endp
);
1207 char *expansion
= expand_argument (begp
, endp
+1);
1209 result
= strlen (expansion
);
1213 /* If the result is true (1) we want to eval the first argument, and if
1214 it's false (0) we want to eval the second. If the argument doesn't
1215 exist we do nothing, otherwise expand it and add to the buffer. */
1217 argv
+= 1 + !result
;
1223 expansion
= expand_argument (argv
[0], NULL
);
1225 o
= variable_buffer_output (o
, expansion
, strlen (expansion
));
1234 $(or condition1[,condition2[,condition3[...]]])
1236 A CONDITION is false iff it evaluates to an empty string. White
1237 space before and after CONDITION are stripped before evaluation.
1239 CONDITION1 is evaluated. If it's true, then this is the result of
1240 expansion. If it's false, CONDITION2 is evaluated, and so on. If none of
1241 the conditions are true, the expansion is the empty string.
1243 Once a CONDITION is true no further conditions are evaluated
1248 func_or (char *o
, char **argv
, const char *funcname UNUSED
)
1250 for ( ; *argv
; ++argv
)
1252 const char *begp
= *argv
;
1253 const char *endp
= begp
+ strlen (*argv
) - 1;
1257 /* Find the result of the condition: if it's false keep going. */
1259 strip_whitespace (&begp
, &endp
);
1264 expansion
= expand_argument (begp
, endp
+1);
1265 result
= strlen (expansion
);
1267 /* If the result is false keep going. */
1274 /* It's true! Keep this result and return. */
1275 o
= variable_buffer_output (o
, expansion
, result
);
1284 $(and condition1[,condition2[,condition3[...]]])
1286 A CONDITION is false iff it evaluates to an empty string. White
1287 space before and after CONDITION are stripped before evaluation.
1289 CONDITION1 is evaluated. If it's false, then this is the result of
1290 expansion. If it's true, CONDITION2 is evaluated, and so on. If all of
1291 the conditions are true, the expansion is the result of the last condition.
1293 Once a CONDITION is false no further conditions are evaluated
1298 func_and (char *o
, char **argv
, const char *funcname UNUSED
)
1305 const char *begp
= *argv
;
1306 const char *endp
= begp
+ strlen (*argv
) - 1;
1308 /* An empty condition is always false. */
1309 strip_whitespace (&begp
, &endp
);
1313 expansion
= expand_argument (begp
, endp
+1);
1314 result
= strlen (expansion
);
1316 /* If the result is false, stop here: we're done. */
1320 /* Otherwise the result is true. If this is the last one, keep this
1321 result and quit. Otherwise go on to the next one! */
1327 o
= variable_buffer_output (o
, expansion
, result
);
1338 func_wildcard (char *o
, char **argv
, const char *funcname UNUSED
)
1342 o
= wildcard_expansion (argv
[0], o
);
1344 char *p
= string_glob (argv
[0]);
1345 o
= variable_buffer_output (o
, p
, strlen (p
));
1351 $(eval <makefile string>)
1353 Always resolves to the empty string.
1355 Treat the arguments as a segment of makefile, and parse them.
1359 func_eval (char *o
, char **argv
, const char *funcname UNUSED
)
1364 /* Eval the buffer. Pop the current variable buffer setting so that the
1365 eval'd code can use its own without conflicting. */
1367 install_variable_buffer (&buf
, &len
);
1369 eval_buffer (argv
[0]);
1371 restore_variable_buffer (buf
, len
);
1378 func_value (char *o
, char **argv
, const char *funcname UNUSED
)
1380 /* Look up the variable. */
1381 struct variable
*v
= lookup_variable (argv
[0], strlen (argv
[0]));
1383 /* Copy its value into the output buffer without expanding it. */
1385 o
= variable_buffer_output (o
, v
->value
, strlen(v
->value
));
1391 \r is replaced on UNIX as well. Is this desirable?
1394 fold_newlines (char *buffer
, int *length
)
1398 char *last_nonnl
= buffer
-1;
1400 for (; *src
!= '\0'; ++src
)
1402 if (src
[0] == '\r' && src
[1] == '\n')
1414 *(++last_nonnl
) = '\0';
1415 *length
= last_nonnl
- buffer
;
1420 int shell_function_pid
= 0, shell_function_completed
;
1426 #include <windows.h>
1428 #include "sub_proc.h"
1432 windows32_openpipe (int *pipedes
, int *pid_p
, char **command_argv
, char **envp
)
1434 SECURITY_ATTRIBUTES saAttr
;
1442 saAttr
.nLength
= sizeof (SECURITY_ATTRIBUTES
);
1443 saAttr
.bInheritHandle
= TRUE
;
1444 saAttr
.lpSecurityDescriptor
= NULL
;
1446 if (DuplicateHandle (GetCurrentProcess(),
1447 GetStdHandle(STD_INPUT_HANDLE
),
1448 GetCurrentProcess(),
1452 DUPLICATE_SAME_ACCESS
) == FALSE
) {
1453 fatal (NILF
, _("create_child_process: DuplicateHandle(In) failed (e=%ld)\n"),
1457 if (DuplicateHandle(GetCurrentProcess(),
1458 GetStdHandle(STD_ERROR_HANDLE
),
1459 GetCurrentProcess(),
1463 DUPLICATE_SAME_ACCESS
) == FALSE
) {
1464 fatal (NILF
, _("create_child_process: DuplicateHandle(Err) failed (e=%ld)\n"),
1468 if (!CreatePipe(&hChildOutRd
, &hChildOutWr
, &saAttr
, 0))
1469 fatal (NILF
, _("CreatePipe() failed (e=%ld)\n"), GetLastError());
1471 hProcess
= process_init_fd(hIn
, hChildOutWr
, hErr
);
1474 fatal (NILF
, _("windows32_openpipe (): process_init_fd() failed\n"));
1476 /* make sure that CreateProcess() has Path it needs */
1477 sync_Path_environment();
1479 if (!process_begin(hProcess
, command_argv
, envp
, command_argv
[0], NULL
)) {
1480 /* register process for wait */
1481 process_register(hProcess
);
1483 /* set the pid for returning to caller */
1484 *pid_p
= (int) hProcess
;
1486 /* set up to read data from child */
1487 pipedes
[0] = _open_osfhandle((long) hChildOutRd
, O_RDONLY
);
1489 /* this will be closed almost right away */
1490 pipedes
[1] = _open_osfhandle((long) hChildOutWr
, O_APPEND
);
1492 /* reap/cleanup the failed process */
1493 process_cleanup(hProcess
);
1495 /* close handles which were duplicated, they weren't used */
1499 /* close pipe handles, they won't be used */
1500 CloseHandle(hChildOutRd
);
1501 CloseHandle(hChildOutWr
);
1503 /* set status for return */
1504 pipedes
[0] = pipedes
[1] = -1;
1513 msdos_openpipe (int* pipedes
, int *pidp
, char *text
)
1516 /* MSDOS can't fork, but it has `popen'. */
1517 struct variable
*sh
= lookup_variable ("SHELL", 5);
1519 extern int dos_command_running
, dos_status
;
1521 /* Make sure not to bother processing an empty line. */
1522 while (isblank ((unsigned char)*text
))
1529 char buf
[PATH_MAX
+ 7];
1530 /* This makes sure $SHELL value is used by $(shell), even
1531 though the target environment is not passed to it. */
1532 sprintf (buf
, "SHELL=%s", sh
->value
);
1538 dos_command_running
= 1;
1540 /* If dos_status becomes non-zero, it means the child process
1541 was interrupted by a signal, like SIGINT or SIGQUIT. See
1542 fatal_error_signal in commands.c. */
1543 fpipe
= popen (text
, "rt");
1544 dos_command_running
= 0;
1545 if (!fpipe
|| dos_status
)
1551 else if (errno
== 0)
1553 shell_function_completed
= -1;
1557 pipedes
[0] = fileno (fpipe
);
1558 *pidp
= 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
1560 shell_function_completed
= 1;
1567 Do shell spawning, with the naughty bits for different OSes.
1572 /* VMS can't do $(shell ...) */
1573 #define func_shell 0
1578 func_shell (char *o
, char **argv
, const char *funcname UNUSED
)
1580 char* batch_filename
= NULL
;
1586 char **command_argv
;
1593 /* Construct the argument list. */
1594 command_argv
= construct_command_argv (argv
[0],
1595 (char **) NULL
, (struct file
*) 0,
1597 if (command_argv
== 0)
1601 /* Using a target environment for `shell' loses in cases like:
1602 export var = $(shell echo foobie)
1603 because target_environment hits a loop trying to expand $(var)
1604 to put it in the environment. This is even more confusing when
1605 var was not explicitly exported, but just appeared in the
1606 calling environment.
1608 envp = target_environment (NILF);
1613 /* For error messages. */
1614 if (reading_file
&& reading_file
->filenm
)
1616 error_prefix
= (char *) alloca (strlen (reading_file
->filenm
)+11+4);
1617 sprintf (error_prefix
,
1618 "%s:%lu: ", reading_file
->filenm
, reading_file
->lineno
);
1625 windows32_openpipe (pipedes
, &pid
, command_argv
, envp
);
1627 if (pipedes
[0] < 0) {
1628 /* open of the pipe failed, mark as failed execution */
1629 shell_function_completed
= -1;
1634 #elif defined(__MSDOS__)
1636 fpipe
= msdos_openpipe (pipedes
, &pid
, argv
[0]);
1639 perror_with_name (error_prefix
, "pipe");
1645 if (pipe (pipedes
) < 0)
1647 perror_with_name (error_prefix
, "pipe");
1653 /* close some handles that are unnecessary for the child process */
1654 CLOSE_ON_EXEC(pipedes
[1]);
1655 CLOSE_ON_EXEC(pipedes
[0]);
1656 /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
1657 pid
= child_execute_job (0, pipedes
[1], command_argv
, envp
);
1659 perror_with_name (error_prefix
, "spawn");
1661 # else /* ! __EMX__ */
1665 perror_with_name (error_prefix
, "fork");
1667 child_execute_job (0, pipedes
[1], command_argv
, envp
);
1674 /* We are the parent. */
1677 unsigned int maxlen
;
1680 /* Record the PID for reap_children. */
1681 shell_function_pid
= pid
;
1683 shell_function_completed
= 0;
1685 /* Free the storage only the child needed. */
1686 free (command_argv
[0]);
1687 free ((char *) command_argv
);
1689 /* Close the write side of the pipe. */
1690 (void) close (pipedes
[1]);
1693 /* Set up and read from the pipe. */
1696 buffer
= (char *) xmalloc (maxlen
+ 1);
1698 /* Read from the pipe until it gets EOF. */
1699 for (i
= 0; ; i
+= cc
)
1704 buffer
= (char *) xrealloc (buffer
, maxlen
+ 1);
1707 EINTRLOOP (cc
, read (pipedes
[0], &buffer
[i
], maxlen
- i
));
1713 /* Close the read side of the pipe. */
1716 (void) pclose (fpipe
);
1718 (void) close (pipedes
[0]);
1721 /* Loop until child_handler or reap_children() sets
1722 shell_function_completed to the status of our child shell. */
1723 while (shell_function_completed
== 0)
1724 reap_children (1, 0);
1726 if (batch_filename
) {
1727 DB (DB_VERBOSE
, (_("Cleaning up temporary batch file %s\n"),
1729 remove (batch_filename
);
1730 free (batch_filename
);
1732 shell_function_pid
= 0;
1734 /* The child_handler function will set shell_function_completed
1735 to 1 when the child dies normally, or to -1 if it
1736 dies with status 127, which is most likely an exec fail. */
1738 if (shell_function_completed
== -1)
1740 /* This most likely means that the execvp failed,
1741 so we should just write out the error message
1742 that came in over the pipe from the child. */
1743 fputs (buffer
, stderr
);
1748 /* The child finished normally. Replace all
1749 newlines in its output with spaces, and put
1750 that in the variable output buffer. */
1751 fold_newlines (buffer
, &i
);
1752 o
= variable_buffer_output (o
, buffer
, i
);
1763 /* Do the Amiga version of func_shell. */
1766 func_shell (char *o
, char **argv
, const char *funcname
)
1768 /* Amiga can't fork nor spawn, but I can start a program with
1769 redirection of my choice. However, this means that we
1770 don't have an opportunity to reopen stdout to trap it. Thus,
1771 we save our own stdout onto a new descriptor and dup a temp
1772 file's descriptor onto our stdout temporarily. After we
1773 spawn the shell program, we dup our own stdout back to the
1774 stdout descriptor. The buffer reading is the same as above,
1775 except that we're now reading from a file. */
1777 #include <dos/dos.h>
1778 #include <proto/dos.h>
1781 char tmp_output
[FILENAME_MAX
];
1782 unsigned int maxlen
= 200;
1784 char * buffer
, * ptr
;
1787 char* batch_filename
= NULL
;
1789 /* Construct the argument list. */
1790 command_argv
= construct_command_argv (argv
[0], (char **) NULL
,
1791 (struct file
*) 0, &batch_filename
);
1792 if (command_argv
== 0)
1795 /* Note the mktemp() is a security hole, but this only runs on Amiga.
1796 Ideally we would use main.c:open_tmpfile(), but this uses a special
1797 Open(), not fopen(), and I'm not familiar enough with the code to mess
1799 strcpy (tmp_output
, "t:MakeshXXXXXXXX");
1800 mktemp (tmp_output
);
1801 child_stdout
= Open (tmp_output
, MODE_NEWFILE
);
1803 for (aptr
=command_argv
; *aptr
; aptr
++)
1804 len
+= strlen (*aptr
) + 1;
1806 buffer
= xmalloc (len
+ 1);
1809 for (aptr
=command_argv
; *aptr
; aptr
++)
1811 strcpy (ptr
, *aptr
);
1812 ptr
+= strlen (ptr
) + 1;
1819 Execute (buffer
, NULL
, child_stdout
);
1822 Close (child_stdout
);
1824 child_stdout
= Open (tmp_output
, MODE_OLDFILE
);
1826 buffer
= xmalloc (maxlen
);
1833 buffer
= (char *) xrealloc (buffer
, maxlen
+ 1);
1836 cc
= Read (child_stdout
, &buffer
[i
], maxlen
- i
);
1841 Close (child_stdout
);
1843 fold_newlines (buffer
, &i
);
1844 o
= variable_buffer_output (o
, buffer
, i
);
1854 equality. Return is string-boolean, ie, the empty string is false.
1857 func_eq (char *o
, char **argv
, char *funcname
)
1859 int result
= ! strcmp (argv
[0], argv
[1]);
1860 o
= variable_buffer_output (o
, result
? "1" : "", result
);
1866 string-boolean not operator.
1869 func_not (char *o
, char **argv
, char *funcname
)
1873 while (isspace ((unsigned char)*s
))
1876 o
= variable_buffer_output (o
, result
? "1" : "", result
);
1882 /* Return the absolute name of file NAME which does not contain any `.',
1883 `..' components nor any repeated path separators ('/'). */
1886 abspath (const char *name
, char *apath
)
1889 const char *start
, *end
, *apath_limit
;
1891 if (name
[0] == '\0' || apath
== NULL
)
1894 apath_limit
= apath
+ GET_PATH_MAX
;
1898 /* It is unlikely we would make it until here but just to make sure. */
1899 if (!starting_directory
)
1902 strcpy (apath
, starting_directory
);
1904 dest
= strchr (apath
, '\0');
1912 for (start
= end
= name
; *start
!= '\0'; start
= end
)
1916 /* Skip sequence of multiple path-separators. */
1917 while (*start
== '/')
1920 /* Find end of path component. */
1921 for (end
= start
; *end
!= '\0' && *end
!= '/'; ++end
)
1928 else if (len
== 1 && start
[0] == '.')
1930 else if (len
== 2 && start
[0] == '.' && start
[1] == '.')
1932 /* Back up to previous component, ignore if at root already. */
1933 if (dest
> apath
+ 1)
1934 while ((--dest
)[-1] != '/');
1938 if (dest
[-1] != '/')
1941 if (dest
+ len
>= apath_limit
)
1944 dest
= memcpy (dest
, start
, len
);
1950 /* Unless it is root strip trailing separator. */
1951 if (dest
> apath
+ 1 && dest
[-1] == '/')
1961 func_realpath (char *o
, char **argv
, const char *funcname UNUSED
)
1963 /* Expand the argument. */
1967 unsigned int len
= 0;
1971 while ((path
= find_next_token (&p
, &len
)) != 0)
1973 if (len
< GET_PATH_MAX
)
1975 strncpy (in
, path
, len
);
1980 #ifdef HAVE_REALPATH
1987 o
= variable_buffer_output (o
, out
, strlen (out
));
1988 o
= variable_buffer_output (o
, " ", 1);
1994 /* Kill last space. */
2002 func_abspath (char *o
, char **argv
, const char *funcname UNUSED
)
2004 /* Expand the argument. */
2008 unsigned int len
= 0;
2012 while ((path
= find_next_token (&p
, &len
)) != 0)
2014 if (len
< GET_PATH_MAX
)
2016 strncpy (in
, path
, len
);
2019 if (abspath (in
, out
))
2021 o
= variable_buffer_output (o
, out
, strlen (out
));
2022 o
= variable_buffer_output (o
, " ", 1);
2028 /* Kill last space. */
2035 /* Lookup table for builtin functions.
2037 This doesn't have to be sorted; we use a straight lookup. We might gain
2038 some efficiency by moving most often used functions to the start of the
2041 If MAXIMUM_ARGS is 0, that means there is no maximum and all
2042 comma-separated values are treated as arguments.
2044 EXPAND_ARGS means that all arguments should be expanded before invocation.
2045 Functions that do namespace tricks (foreach) don't automatically expand. */
2047 static char *func_call
PARAMS ((char *o
, char **argv
, const char *funcname
));
2050 static struct function_table_entry function_table_init
[] =
2052 /* Name/size */ /* MIN MAX EXP? Function */
2053 { STRING_SIZE_TUPLE("abspath"), 0, 1, 1, func_abspath
},
2054 { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix
},
2055 { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix
},
2056 { STRING_SIZE_TUPLE("basename"), 0, 1, 1, func_basename_dir
},
2057 { STRING_SIZE_TUPLE("dir"), 0, 1, 1, func_basename_dir
},
2058 { STRING_SIZE_TUPLE("notdir"), 0, 1, 1, func_notdir_suffix
},
2059 { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst
},
2060 { STRING_SIZE_TUPLE("suffix"), 0, 1, 1, func_notdir_suffix
},
2061 { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout
},
2062 { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout
},
2063 { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring
},
2064 { STRING_SIZE_TUPLE("firstword"), 0, 1, 1, func_firstword
},
2065 { STRING_SIZE_TUPLE("flavor"), 0, 1, 1, func_flavor
},
2066 { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join
},
2067 { STRING_SIZE_TUPLE("lastword"), 0, 1, 1, func_lastword
},
2068 { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst
},
2069 { STRING_SIZE_TUPLE("realpath"), 0, 1, 1, func_realpath
},
2070 { STRING_SIZE_TUPLE("shell"), 0, 1, 1, func_shell
},
2071 { STRING_SIZE_TUPLE("sort"), 0, 1, 1, func_sort
},
2072 { STRING_SIZE_TUPLE("strip"), 0, 1, 1, func_strip
},
2073 { STRING_SIZE_TUPLE("wildcard"), 0, 1, 1, func_wildcard
},
2074 { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word
},
2075 { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist
},
2076 { STRING_SIZE_TUPLE("words"), 0, 1, 1, func_words
},
2077 { STRING_SIZE_TUPLE("origin"), 0, 1, 1, func_origin
},
2078 { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach
},
2079 { STRING_SIZE_TUPLE("call"), 1, 0, 1, func_call
},
2080 { STRING_SIZE_TUPLE("info"), 0, 1, 1, func_error
},
2081 { STRING_SIZE_TUPLE("error"), 0, 1, 1, func_error
},
2082 { STRING_SIZE_TUPLE("warning"), 0, 1, 1, func_error
},
2083 { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if
},
2084 { STRING_SIZE_TUPLE("or"), 1, 0, 0, func_or
},
2085 { STRING_SIZE_TUPLE("and"), 1, 0, 0, func_and
},
2086 { STRING_SIZE_TUPLE("value"), 0, 1, 1, func_value
},
2087 { STRING_SIZE_TUPLE("eval"), 0, 1, 1, func_eval
},
2089 { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq
},
2090 { STRING_SIZE_TUPLE("not"), 0, 1, 1, func_not
},
2094 #define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry))
2097 /* These must come after the definition of function_table. */
2100 expand_builtin_function (char *o
, int argc
, char **argv
,
2101 const struct function_table_entry
*entry_p
)
2103 if (argc
< (int)entry_p
->minimum_args
)
2104 fatal (reading_file
,
2105 _("Insufficient number of arguments (%d) to function `%s'"),
2106 argc
, entry_p
->name
);
2108 /* I suppose technically some function could do something with no
2109 arguments, but so far none do, so just test it for all functions here
2110 rather than in each one. We can change it later if necessary. */
2115 if (!entry_p
->func_ptr
)
2116 fatal (reading_file
, _("Unimplemented on this platform: function `%s'"),
2119 return entry_p
->func_ptr (o
, argv
, entry_p
->name
);
2122 /* Check for a function invocation in *STRINGP. *STRINGP points at the
2123 opening ( or { and is not null-terminated. If a function invocation
2124 is found, expand it into the buffer at *OP, updating *OP, incrementing
2125 *STRINGP past the reference and returning nonzero. If not, return zero. */
2128 handle_function (char **op
, char **stringp
)
2130 const struct function_table_entry
*entry_p
;
2131 char openparen
= (*stringp
)[0];
2132 char closeparen
= openparen
== '(' ? ')' : '}';
2137 char **argv
, **argvp
;
2142 entry_p
= lookup_function (beg
);
2147 /* We found a builtin function. Find the beginning of its arguments (skip
2148 whitespace after the name). */
2150 beg
= next_token (beg
+ entry_p
->len
);
2152 /* Find the end of the function invocation, counting nested use of
2153 whichever kind of parens we use. Since we're looking, count commas
2154 to get a rough estimate of how many arguments we might have. The
2155 count might be high, but it'll never be low. */
2157 for (nargs
=1, end
=beg
; *end
!= '\0'; ++end
)
2160 else if (*end
== openparen
)
2162 else if (*end
== closeparen
&& --count
< 0)
2166 fatal (reading_file
,
2167 _("unterminated call to function `%s': missing `%c'"),
2168 entry_p
->name
, closeparen
);
2172 /* Get some memory to store the arg pointers. */
2173 argvp
= argv
= (char **) alloca (sizeof (char *) * (nargs
+ 2));
2175 /* Chop the string into arguments, then a nul. As soon as we hit
2176 MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
2179 If we're expanding, store pointers to the expansion of each one. If
2180 not, make a duplicate of the string and point into that, nul-terminating
2183 if (!entry_p
->expand_args
)
2185 int len
= end
- beg
;
2187 p
= xmalloc (len
+1);
2188 memcpy (p
, beg
, len
);
2194 for (p
=beg
, nargs
=0; p
<= end
; ++argvp
)
2200 if (nargs
== entry_p
->maximum_args
2201 || (! (next
= find_next_argument (openparen
, closeparen
, p
, end
))))
2204 if (entry_p
->expand_args
)
2205 *argvp
= expand_argument (p
, next
);
2216 /* Finally! Run the function... */
2217 *op
= expand_builtin_function (*op
, nargs
, argv
, entry_p
);
2220 if (entry_p
->expand_args
)
2221 for (argvp
=argv
; *argvp
!= 0; ++argvp
)
2230 /* User-defined functions. Expand the first argument as either a builtin
2231 function or a make variable, in the context of the rest of the arguments
2232 assigned to $1, $2, ... $N. $0 is the name of the function. */
2235 func_call (char *o
, char **argv
, const char *funcname UNUSED
)
2237 static int max_args
= 0;
2244 const struct function_table_entry
*entry_p
;
2247 /* There is no way to define a variable with a space in the name, so strip
2248 leading and trailing whitespace as a favor to the user. */
2250 while (*fname
!= '\0' && isspace ((unsigned char)*fname
))
2253 cp
= fname
+ strlen (fname
) - 1;
2254 while (cp
> fname
&& isspace ((unsigned char)*cp
))
2258 /* Calling nothing is a no-op */
2262 /* Are we invoking a builtin function? */
2264 entry_p
= lookup_function (fname
);
2268 /* How many arguments do we have? */
2269 for (i
=0; argv
[i
+1]; ++i
)
2272 return expand_builtin_function (o
, i
, argv
+1, entry_p
);
2275 /* Not a builtin, so the first argument is the name of a variable to be
2276 expanded and interpreted as a function. Find it. */
2277 flen
= strlen (fname
);
2279 v
= lookup_variable (fname
, flen
);
2282 warn_undefined (fname
, flen
);
2284 if (v
== 0 || *v
->value
== '\0')
2287 body
= (char *) alloca (flen
+ 4);
2290 memcpy (body
+ 2, fname
, flen
);
2292 body
[flen
+3] = '\0';
2294 /* Set up arguments $(1) .. $(N). $(0) is the function name. */
2296 push_new_variable_scope ();
2298 for (i
=0; *argv
; ++i
, ++argv
)
2302 sprintf (num
, "%d", i
);
2303 define_variable (num
, strlen (num
), *argv
, o_automatic
, 0);
2306 /* If the number of arguments we have is < max_args, it means we're inside
2307 a recursive invocation of $(call ...). Fill in the remaining arguments
2308 in the new scope with the empty value, to hide them from this
2311 for (; i
< max_args
; ++i
)
2315 sprintf (num
, "%d", i
);
2316 define_variable (num
, strlen (num
), "", o_automatic
, 0);
2319 /* Expand the body in the context of the arguments, adding the result to
2320 the variable buffer. */
2322 v
->exp_count
= EXP_COUNT_MAX
;
2324 saved_args
= max_args
;
2326 o
= variable_expand_string (o
, body
, flen
+3);
2327 max_args
= saved_args
;
2331 pop_variable_scope ();
2333 return o
+ strlen (o
);
2337 hash_init_function_table (void)
2339 hash_init (&function_table
, FUNCTION_TABLE_ENTRIES
* 2,
2340 function_table_entry_hash_1
, function_table_entry_hash_2
,
2341 function_table_entry_hash_cmp
);
2342 hash_load (&function_table
, function_table_init
,
2343 FUNCTION_TABLE_ENTRIES
, sizeof (struct function_table_entry
));