Create a new internal interface for defining new make functions.
[make.git] / function.c
blobc387b351dcc09cee209f695459c50ae27715c038
1 /* Builtin function expansion for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
10 version.
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/>. */
19 #include "make.h"
20 #include "filedef.h"
21 #include "variable.h"
22 #include "dep.h"
23 #include "job.h"
24 #include "commands.h"
25 #include "debug.h"
27 #ifdef _AMIGA
28 #include "amiga.h"
29 #endif
32 struct function_table_entry
34 const char *name;
35 unsigned char len;
36 unsigned char minimum_args;
37 unsigned char maximum_args;
38 char expand_args;
39 char *(*func_ptr) (char *output, char **argv, const char *fname);
42 static unsigned long
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);
49 static unsigned long
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);
56 static int
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;
62 if (result)
63 return result;
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. */
76 char *
77 subst_expand (char *o, const char *text, const char *subst, const char *replace,
78 unsigned int slen, unsigned int rlen, int by_word)
80 const char *t = text;
81 const char *p;
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));
87 if (rlen > 0)
88 o = variable_buffer_output (o, replace, rlen);
89 return o;
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));
98 else
100 p = strstr (t, subst);
101 if (p == 0)
103 /* No more matches. Output everything left on the end. */
104 o = variable_buffer_output (o, t, strlen (t));
105 return o;
109 /* Output everything before this occurrence of the string to replace. */
110 if (p > t)
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. */
115 if (by_word
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);
121 else if (rlen > 0)
122 /* Output the replacement string. */
123 o = variable_buffer_output (o, replace, rlen);
125 /* Advance T past the string to be replaced. */
126 t = p + slen;
127 } while (*t != '\0');
129 return o;
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.
143 char *
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;
150 const char *t;
151 unsigned int len;
152 int doneany = 0;
154 /* Record the length of REPLACE before and after the % so we don't have to
155 compute these lengths more than once. */
156 if (replace_percent)
158 replace_prepercent_len = replace_percent - replace - 1;
159 replace_postpercent_len = strlen (replace_percent);
161 else
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)
179 int fail = 0;
181 /* Is it big enough to match? */
182 if (len < pattern_prepercent_len + pattern_postpercent_len)
183 fail = 1;
185 /* Does the prefix match? */
186 if (!fail && pattern_prepercent_len > 0
187 && (*t != *pattern
188 || t[pattern_prepercent_len - 1] != pattern_percent[-2]
189 || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1)))
190 fail = 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)))
198 fail = 1;
200 if (fail)
201 /* It didn't match. Output the string. */
202 o = variable_buffer_output (o, t, len);
203 else
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);
228 doneany = 1;
231 if (doneany)
232 /* Kill the last space. */
233 --o;
235 return o;
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.
248 char *
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. */
255 if (replace_percent)
256 ++replace_percent;
257 if (pattern_percent)
258 ++pattern_percent;
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)
270 const char *e = s;
272 while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-'))
273 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);
282 return 0;
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;
293 if (percent == 0)
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);
299 if (percent == 0)
300 return streq (new_chars, str);
301 pattern = new_chars;
304 sfxlen = strlen (percent + 1);
305 strlength = strlen (str);
307 if (strlength < (percent - pattern) + sfxlen
308 || !strneq (pattern, str, percent - pattern))
309 return 0;
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
317 next character.
319 If no next argument is found, return NULL.
322 static char *
323 find_next_argument (char startparen, char endparen,
324 const char *ptr, const char *end)
326 int count = 0;
328 for (; ptr < end; ++ptr)
329 if (*ptr == startparen)
330 ++count;
332 else if (*ptr == endparen)
334 --count;
335 if (count < 0)
336 return NULL;
339 else if (*ptr == ',' && !count)
340 return (char *)ptr;
342 /* We didn't find anything. */
343 return NULL;
347 /* Glob-expand LINE. The returned pointer is
348 only good until the next call to string_glob. */
350 static char *
351 string_glob (char *line)
353 static char *result = 0;
354 static unsigned int length;
355 struct nameseq *chain;
356 unsigned int idx;
358 chain = PARSE_FILE_SEQ (&line, struct nameseq, '\0', NULL,
359 /* We do not want parse_file_seq to strip `./'s.
360 That would break examples like:
361 $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)). */
362 PARSEFS_NOSTRIP|PARSEFS_NOCACHE|PARSEFS_EXISTS);
364 if (result == 0)
366 length = 100;
367 result = xmalloc (100);
370 idx = 0;
371 while (chain != 0)
373 struct nameseq *next = chain->next;
374 unsigned int len = strlen (chain->name);
376 if (idx + len + 1 > length)
378 length += (len + 1) * 2;
379 result = xrealloc (result, length);
381 memcpy (&result[idx], chain->name, len);
382 idx += len;
383 result[idx++] = ' ';
385 /* Because we used PARSEFS_NOCACHE above, we have to free() NAME. */
386 free ((char *)chain->name);
387 free (chain);
388 chain = next;
391 /* Kill the last space and terminate the string. */
392 if (idx == 0)
393 result[0] = '\0';
394 else
395 result[idx - 1] = '\0';
397 return result;
401 Builtin functions
404 static char *
405 func_patsubst (char *o, char **argv, const char *funcname UNUSED)
407 o = patsubst_expand (o, argv[2], argv[0], argv[1]);
408 return o;
412 static char *
413 func_join (char *o, char **argv, const char *funcname UNUSED)
415 int doneany = 0;
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. */
421 const char *tp;
422 const char *pp;
423 const char *list1_iterator = argv[0];
424 const char *list2_iterator = argv[1];
427 unsigned int len1, len2;
429 tp = find_next_token (&list1_iterator, &len1);
430 if (tp != 0)
431 o = variable_buffer_output (o, tp, len1);
433 pp = find_next_token (&list2_iterator, &len2);
434 if (pp != 0)
435 o = variable_buffer_output (o, pp, len2);
437 if (tp != 0 || pp != 0)
439 o = variable_buffer_output (o, " ", 1);
440 doneany = 1;
443 while (tp != 0 || pp != 0);
444 if (doneany)
445 /* Kill the last blank. */
446 --o;
448 return o;
452 static char *
453 func_origin (char *o, char **argv, const char *funcname UNUSED)
455 /* Expand the argument. */
456 struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
457 if (v == 0)
458 o = variable_buffer_output (o, "undefined", 9);
459 else
460 switch (v->origin)
462 default:
463 case o_invalid:
464 abort ();
465 break;
466 case o_default:
467 o = variable_buffer_output (o, "default", 7);
468 break;
469 case o_env:
470 o = variable_buffer_output (o, "environment", 11);
471 break;
472 case o_file:
473 o = variable_buffer_output (o, "file", 4);
474 break;
475 case o_env_override:
476 o = variable_buffer_output (o, "environment override", 20);
477 break;
478 case o_command:
479 o = variable_buffer_output (o, "command line", 12);
480 break;
481 case o_override:
482 o = variable_buffer_output (o, "override", 8);
483 break;
484 case o_automatic:
485 o = variable_buffer_output (o, "automatic", 9);
486 break;
489 return o;
492 static char *
493 func_flavor (char *o, char **argv, const char *funcname UNUSED)
495 struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
497 if (v == 0)
498 o = variable_buffer_output (o, "undefined", 9);
499 else
500 if (v->recursive)
501 o = variable_buffer_output (o, "recursive", 9);
502 else
503 o = variable_buffer_output (o, "simple", 6);
505 return o;
508 #ifdef VMS
509 # define IS_PATHSEP(c) ((c) == ']')
510 #else
511 # ifdef HAVE_DOS_PATHS
512 # define IS_PATHSEP(c) ((c) == '/' || (c) == '\\')
513 # else
514 # define IS_PATHSEP(c) ((c) == '/')
515 # endif
516 #endif
519 static char *
520 func_notdir_suffix (char *o, char **argv, const char *funcname)
522 /* Expand the argument. */
523 const char *list_iterator = argv[0];
524 const char *p2;
525 int doneany =0;
526 unsigned int len=0;
528 int is_suffix = streq (funcname, "suffix");
529 int is_notdir = !is_suffix;
530 while ((p2 = find_next_token (&list_iterator, &len)) != 0)
532 const char *p = p2 + len;
535 while (p >= p2 && (!is_suffix || *p != '.'))
537 if (IS_PATHSEP (*p))
538 break;
539 --p;
542 if (p >= p2)
544 if (is_notdir)
545 ++p;
546 else if (*p != '.')
547 continue;
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] == ':')
554 p = p2 + 2;
555 o = variable_buffer_output (o, p, len - (p - p2));
557 #endif
558 else if (is_notdir)
559 o = variable_buffer_output (o, p2, len);
561 if (is_notdir || p >= p2)
563 o = variable_buffer_output (o, " ", 1);
564 doneany = 1;
568 if (doneany)
569 /* Kill last space. */
570 --o;
572 return o;
576 static char *
577 func_basename_dir (char *o, char **argv, const char *funcname)
579 /* Expand the argument. */
580 const char *p3 = argv[0];
581 const char *p2;
582 int doneany=0;
583 unsigned int len=0;
585 int is_basename= streq (funcname, "basename");
586 int is_dir= !is_basename;
588 while ((p2 = find_next_token (&p3, &len)) != 0)
590 const char *p = p2 + len;
591 while (p >= p2 && (!is_basename || *p != '.'))
593 if (IS_PATHSEP (*p))
594 break;
595 --p;
598 if (p >= p2 && (is_dir))
599 o = variable_buffer_output (o, p2, ++p - p2);
600 else if (p >= p2 && (*p == '.'))
601 o = variable_buffer_output (o, p2, p - p2);
602 #ifdef HAVE_DOS_PATHS
603 /* Handle the "d:foobar" case */
604 else if (p2[0] && p2[1] == ':' && is_dir)
605 o = variable_buffer_output (o, p2, 2);
606 #endif
607 else if (is_dir)
608 #ifdef VMS
609 o = variable_buffer_output (o, "[]", 2);
610 #else
611 #ifndef _AMIGA
612 o = variable_buffer_output (o, "./", 2);
613 #else
614 ; /* Just a nop... */
615 #endif /* AMIGA */
616 #endif /* !VMS */
617 else
618 /* The entire name is the basename. */
619 o = variable_buffer_output (o, p2, len);
621 o = variable_buffer_output (o, " ", 1);
622 doneany = 1;
625 if (doneany)
626 /* Kill last space. */
627 --o;
629 return o;
632 static char *
633 func_addsuffix_addprefix (char *o, char **argv, const char *funcname)
635 int fixlen = strlen (argv[0]);
636 const char *list_iterator = argv[1];
637 int is_addprefix = streq (funcname, "addprefix");
638 int is_addsuffix = !is_addprefix;
640 int doneany = 0;
641 const char *p;
642 unsigned int len;
644 while ((p = find_next_token (&list_iterator, &len)) != 0)
646 if (is_addprefix)
647 o = variable_buffer_output (o, argv[0], fixlen);
648 o = variable_buffer_output (o, p, len);
649 if (is_addsuffix)
650 o = variable_buffer_output (o, argv[0], fixlen);
651 o = variable_buffer_output (o, " ", 1);
652 doneany = 1;
655 if (doneany)
656 /* Kill last space. */
657 --o;
659 return o;
662 static char *
663 func_subst (char *o, char **argv, const char *funcname UNUSED)
665 o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]),
666 strlen (argv[1]), 0);
668 return o;
672 static char *
673 func_firstword (char *o, char **argv, const char *funcname UNUSED)
675 unsigned int i;
676 const char *words = argv[0]; /* Use a temp variable for find_next_token */
677 const char *p = find_next_token (&words, &i);
679 if (p != 0)
680 o = variable_buffer_output (o, p, i);
682 return o;
685 static char *
686 func_lastword (char *o, char **argv, const char *funcname UNUSED)
688 unsigned int i;
689 const char *words = argv[0]; /* Use a temp variable for find_next_token */
690 const char *p = NULL;
691 const char *t;
693 while ((t = find_next_token (&words, &i)))
694 p = t;
696 if (p != 0)
697 o = variable_buffer_output (o, p, i);
699 return o;
702 static char *
703 func_words (char *o, char **argv, const char *funcname UNUSED)
705 int i = 0;
706 const char *word_iterator = argv[0];
707 char buf[20];
709 while (find_next_token (&word_iterator, NULL) != 0)
710 ++i;
712 sprintf (buf, "%d", i);
713 o = variable_buffer_output (o, buf, strlen (buf));
715 return o;
718 /* Set begpp to point to the first non-whitespace character of the string,
719 * and endpp to point to the last non-whitespace character of the string.
720 * If the string is empty or contains nothing but whitespace, endpp will be
721 * begpp-1.
723 char *
724 strip_whitespace (const char **begpp, const char **endpp)
726 while (*begpp <= *endpp && isspace ((unsigned char)**begpp))
727 (*begpp) ++;
728 while (*endpp >= *begpp && isspace ((unsigned char)**endpp))
729 (*endpp) --;
730 return (char *)*begpp;
733 static void
734 check_numeric (const char *s, const char *msg)
736 const char *end = s + strlen (s) - 1;
737 const char *beg = s;
738 strip_whitespace (&s, &end);
740 for (; s <= end; ++s)
741 if (!ISDIGIT (*s)) /* ISDIGIT only evals its arg once: see make.h. */
742 break;
744 if (s <= end || end - beg < 0)
745 fatal (*expanding_var, "%s: '%s'", msg, beg);
750 static char *
751 func_word (char *o, char **argv, const char *funcname UNUSED)
753 const char *end_p;
754 const char *p;
755 int i;
757 /* Check the first argument. */
758 check_numeric (argv[0], _("non-numeric first argument to `word' function"));
759 i = atoi (argv[0]);
761 if (i == 0)
762 fatal (*expanding_var,
763 _("first argument to `word' function must be greater than 0"));
765 end_p = argv[1];
766 while ((p = find_next_token (&end_p, 0)) != 0)
767 if (--i == 0)
768 break;
770 if (i == 0)
771 o = variable_buffer_output (o, p, end_p - p);
773 return o;
776 static char *
777 func_wordlist (char *o, char **argv, const char *funcname UNUSED)
779 int start, count;
781 /* Check the arguments. */
782 check_numeric (argv[0],
783 _("non-numeric first argument to `wordlist' function"));
784 check_numeric (argv[1],
785 _("non-numeric second argument to `wordlist' function"));
787 start = atoi (argv[0]);
788 if (start < 1)
789 fatal (*expanding_var,
790 "invalid first argument to `wordlist' function: `%d'", start);
792 count = atoi (argv[1]) - start + 1;
794 if (count > 0)
796 const char *p;
797 const char *end_p = argv[2];
799 /* Find the beginning of the "start"th word. */
800 while (((p = find_next_token (&end_p, 0)) != 0) && --start)
803 if (p)
805 /* Find the end of the "count"th word from start. */
806 while (--count && (find_next_token (&end_p, 0) != 0))
809 /* Return the stuff in the middle. */
810 o = variable_buffer_output (o, p, end_p - p);
814 return o;
817 static char *
818 func_findstring (char *o, char **argv, const char *funcname UNUSED)
820 /* Find the first occurrence of the first string in the second. */
821 if (strstr (argv[1], argv[0]) != 0)
822 o = variable_buffer_output (o, argv[0], strlen (argv[0]));
824 return o;
827 static char *
828 func_foreach (char *o, char **argv, const char *funcname UNUSED)
830 /* expand only the first two. */
831 char *varname = expand_argument (argv[0], NULL);
832 char *list = expand_argument (argv[1], NULL);
833 const char *body = argv[2];
835 int doneany = 0;
836 const char *list_iterator = list;
837 const char *p;
838 unsigned int len;
839 struct variable *var;
841 push_new_variable_scope ();
842 var = define_variable (varname, strlen (varname), "", o_automatic, 0);
844 /* loop through LIST, put the value in VAR and expand BODY */
845 while ((p = find_next_token (&list_iterator, &len)) != 0)
847 char *result = 0;
849 free (var->value);
850 var->value = xstrndup (p, len);
852 result = allocated_variable_expand (body);
854 o = variable_buffer_output (o, result, strlen (result));
855 o = variable_buffer_output (o, " ", 1);
856 doneany = 1;
857 free (result);
860 if (doneany)
861 /* Kill the last space. */
862 --o;
864 pop_variable_scope ();
865 free (varname);
866 free (list);
868 return o;
871 struct a_word
873 struct a_word *next;
874 struct a_word *chain;
875 char *str;
876 int length;
877 int matched;
880 static unsigned long
881 a_word_hash_1 (const void *key)
883 return_STRING_HASH_1 (((struct a_word const *) key)->str);
886 static unsigned long
887 a_word_hash_2 (const void *key)
889 return_STRING_HASH_2 (((struct a_word const *) key)->str);
892 static int
893 a_word_hash_cmp (const void *x, const void *y)
895 int result = ((struct a_word const *) x)->length - ((struct a_word const *) y)->length;
896 if (result)
897 return result;
898 return_STRING_COMPARE (((struct a_word const *) x)->str,
899 ((struct a_word const *) y)->str);
902 struct a_pattern
904 struct a_pattern *next;
905 char *str;
906 char *percent;
907 int length;
908 int save_c;
911 static char *
912 func_filter_filterout (char *o, char **argv, const char *funcname)
914 struct a_word *wordhead;
915 struct a_word **wordtail;
916 struct a_word *wp;
917 struct a_pattern *pathead;
918 struct a_pattern **pattail;
919 struct a_pattern *pp;
921 struct hash_table a_word_table;
922 int is_filter = streq (funcname, "filter");
923 const char *pat_iterator = argv[0];
924 const char *word_iterator = argv[1];
925 int literals = 0;
926 int words = 0;
927 int hashing = 0;
928 char *p;
929 unsigned int len;
931 /* Chop ARGV[0] up into patterns to match against the words. */
933 pattail = &pathead;
934 while ((p = find_next_token (&pat_iterator, &len)) != 0)
936 struct a_pattern *pat = alloca (sizeof (struct a_pattern));
938 *pattail = pat;
939 pattail = &pat->next;
941 if (*pat_iterator != '\0')
942 ++pat_iterator;
944 pat->str = p;
945 pat->length = len;
946 pat->save_c = p[len];
947 p[len] = '\0';
948 pat->percent = find_percent (p);
949 if (pat->percent == 0)
950 literals++;
952 *pattail = 0;
954 /* Chop ARGV[1] up into words to match against the patterns. */
956 wordtail = &wordhead;
957 while ((p = find_next_token (&word_iterator, &len)) != 0)
959 struct a_word *word = alloca (sizeof (struct a_word));
961 *wordtail = word;
962 wordtail = &word->next;
964 if (*word_iterator != '\0')
965 ++word_iterator;
967 p[len] = '\0';
968 word->str = p;
969 word->length = len;
970 word->matched = 0;
971 word->chain = 0;
972 words++;
974 *wordtail = 0;
976 /* Only use a hash table if arg list lengths justifies the cost. */
977 hashing = (literals >= 2 && (literals * words) >= 10);
978 if (hashing)
980 hash_init (&a_word_table, words, a_word_hash_1, a_word_hash_2,
981 a_word_hash_cmp);
982 for (wp = wordhead; wp != 0; wp = wp->next)
984 struct a_word *owp = hash_insert (&a_word_table, wp);
985 if (owp)
986 wp->chain = owp;
990 if (words)
992 int doneany = 0;
994 /* Run each pattern through the words, killing words. */
995 for (pp = pathead; pp != 0; pp = pp->next)
997 if (pp->percent)
998 for (wp = wordhead; wp != 0; wp = wp->next)
999 wp->matched |= pattern_matches (pp->str, pp->percent, wp->str);
1000 else if (hashing)
1002 struct a_word a_word_key;
1003 a_word_key.str = pp->str;
1004 a_word_key.length = pp->length;
1005 wp = hash_find_item (&a_word_table, &a_word_key);
1006 while (wp)
1008 wp->matched |= 1;
1009 wp = wp->chain;
1012 else
1013 for (wp = wordhead; wp != 0; wp = wp->next)
1014 wp->matched |= (wp->length == pp->length
1015 && strneq (pp->str, wp->str, wp->length));
1018 /* Output the words that matched (or didn't, for filter-out). */
1019 for (wp = wordhead; wp != 0; wp = wp->next)
1020 if (is_filter ? wp->matched : !wp->matched)
1022 o = variable_buffer_output (o, wp->str, strlen (wp->str));
1023 o = variable_buffer_output (o, " ", 1);
1024 doneany = 1;
1027 if (doneany)
1028 /* Kill the last space. */
1029 --o;
1032 for (pp = pathead; pp != 0; pp = pp->next)
1033 pp->str[pp->length] = pp->save_c;
1035 if (hashing)
1036 hash_free (&a_word_table, 0);
1038 return o;
1042 static char *
1043 func_strip (char *o, char **argv, const char *funcname UNUSED)
1045 const char *p = argv[0];
1046 int doneany = 0;
1048 while (*p != '\0')
1050 int i=0;
1051 const char *word_start;
1053 while (isspace ((unsigned char)*p))
1054 ++p;
1055 word_start = p;
1056 for (i=0; *p != '\0' && !isspace ((unsigned char)*p); ++p, ++i)
1058 if (!i)
1059 break;
1060 o = variable_buffer_output (o, word_start, i);
1061 o = variable_buffer_output (o, " ", 1);
1062 doneany = 1;
1065 if (doneany)
1066 /* Kill the last space. */
1067 --o;
1069 return o;
1073 Print a warning or fatal message.
1075 static char *
1076 func_error (char *o, char **argv, const char *funcname)
1078 char **argvp;
1079 char *msg, *p;
1080 int len;
1082 /* The arguments will be broken on commas. Rather than create yet
1083 another special case where function arguments aren't broken up,
1084 just create a format string that puts them back together. */
1085 for (len=0, argvp=argv; *argvp != 0; ++argvp)
1086 len += strlen (*argvp) + 2;
1088 p = msg = alloca (len + 1);
1090 for (argvp=argv; argvp[1] != 0; ++argvp)
1092 strcpy (p, *argvp);
1093 p += strlen (*argvp);
1094 *(p++) = ',';
1095 *(p++) = ' ';
1097 strcpy (p, *argvp);
1099 switch (*funcname) {
1100 case 'e':
1101 fatal (reading_file, "%s", msg);
1103 case 'w':
1104 error (reading_file, "%s", msg);
1105 break;
1107 case 'i':
1108 printf ("%s\n", msg);
1109 fflush(stdout);
1110 break;
1112 default:
1113 fatal (*expanding_var, "Internal error: func_error: '%s'", funcname);
1116 /* The warning function expands to the empty string. */
1117 return o;
1122 chop argv[0] into words, and sort them.
1124 static char *
1125 func_sort (char *o, char **argv, const char *funcname UNUSED)
1127 const char *t;
1128 char **words;
1129 int wordi;
1130 char *p;
1131 unsigned int len;
1132 int i;
1134 /* Find the maximum number of words we'll have. */
1135 t = argv[0];
1136 wordi = 0;
1137 while ((p = find_next_token (&t, NULL)) != 0)
1139 ++t;
1140 ++wordi;
1143 words = xmalloc ((wordi == 0 ? 1 : wordi) * sizeof (char *));
1145 /* Now assign pointers to each string in the array. */
1146 t = argv[0];
1147 wordi = 0;
1148 while ((p = find_next_token (&t, &len)) != 0)
1150 ++t;
1151 p[len] = '\0';
1152 words[wordi++] = p;
1155 if (wordi)
1157 /* Now sort the list of words. */
1158 qsort (words, wordi, sizeof (char *), alpha_compare);
1160 /* Now write the sorted list, uniquified. */
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. */
1173 --o;
1176 free (words);
1178 return o;
1182 $(if condition,true-part[,false-part])
1184 CONDITION is false iff it evaluates to an empty string. White
1185 space before and after condition are stripped before evaluation.
1187 If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is
1188 evaluated (if it exists). Because only one of the two PARTs is evaluated,
1189 you can use $(if ...) to create side-effects (with $(shell ...), for
1190 example).
1193 static char *
1194 func_if (char *o, char **argv, const char *funcname UNUSED)
1196 const char *begp = argv[0];
1197 const char *endp = begp + strlen (argv[0]) - 1;
1198 int result = 0;
1200 /* Find the result of the condition: if we have a value, and it's not
1201 empty, the condition is true. If we don't have a value, or it's the
1202 empty string, then it's false. */
1204 strip_whitespace (&begp, &endp);
1206 if (begp <= endp)
1208 char *expansion = expand_argument (begp, endp+1);
1210 result = strlen (expansion);
1211 free (expansion);
1214 /* If the result is true (1) we want to eval the first argument, and if
1215 it's false (0) we want to eval the second. If the argument doesn't
1216 exist we do nothing, otherwise expand it and add to the buffer. */
1218 argv += 1 + !result;
1220 if (*argv)
1222 char *expansion = expand_argument (*argv, NULL);
1224 o = variable_buffer_output (o, expansion, strlen (expansion));
1226 free (expansion);
1229 return o;
1233 $(or condition1[,condition2[,condition3[...]]])
1235 A CONDITION is false iff it evaluates to an empty string. White
1236 space before and after CONDITION are stripped before evaluation.
1238 CONDITION1 is evaluated. If it's true, then this is the result of
1239 expansion. If it's false, CONDITION2 is evaluated, and so on. If none of
1240 the conditions are true, the expansion is the empty string.
1242 Once a CONDITION is true no further conditions are evaluated
1243 (short-circuiting).
1246 static char *
1247 func_or (char *o, char **argv, const char *funcname UNUSED)
1249 for ( ; *argv ; ++argv)
1251 const char *begp = *argv;
1252 const char *endp = begp + strlen (*argv) - 1;
1253 char *expansion;
1254 int result = 0;
1256 /* Find the result of the condition: if it's false keep going. */
1258 strip_whitespace (&begp, &endp);
1260 if (begp > endp)
1261 continue;
1263 expansion = expand_argument (begp, endp+1);
1264 result = strlen (expansion);
1266 /* If the result is false keep going. */
1267 if (!result)
1269 free (expansion);
1270 continue;
1273 /* It's true! Keep this result and return. */
1274 o = variable_buffer_output (o, expansion, result);
1275 free (expansion);
1276 break;
1279 return o;
1283 $(and condition1[,condition2[,condition3[...]]])
1285 A CONDITION is false iff it evaluates to an empty string. White
1286 space before and after CONDITION are stripped before evaluation.
1288 CONDITION1 is evaluated. If it's false, then this is the result of
1289 expansion. If it's true, CONDITION2 is evaluated, and so on. If all of
1290 the conditions are true, the expansion is the result of the last condition.
1292 Once a CONDITION is false no further conditions are evaluated
1293 (short-circuiting).
1296 static char *
1297 func_and (char *o, char **argv, const char *funcname UNUSED)
1299 char *expansion;
1300 int result;
1302 while (1)
1304 const char *begp = *argv;
1305 const char *endp = begp + strlen (*argv) - 1;
1307 /* An empty condition is always false. */
1308 strip_whitespace (&begp, &endp);
1309 if (begp > endp)
1310 return o;
1312 expansion = expand_argument (begp, endp+1);
1313 result = strlen (expansion);
1315 /* If the result is false, stop here: we're done. */
1316 if (!result)
1317 break;
1319 /* Otherwise the result is true. If this is the last one, keep this
1320 result and quit. Otherwise go on to the next one! */
1322 if (*(++argv))
1323 free (expansion);
1324 else
1326 o = variable_buffer_output (o, expansion, result);
1327 break;
1331 free (expansion);
1333 return o;
1336 static char *
1337 func_wildcard (char *o, char **argv, const char *funcname UNUSED)
1339 #ifdef _AMIGA
1340 o = wildcard_expansion (argv[0], o);
1341 #else
1342 char *p = string_glob (argv[0]);
1343 o = variable_buffer_output (o, p, strlen (p));
1344 #endif
1345 return o;
1349 $(eval <makefile string>)
1351 Always resolves to the empty string.
1353 Treat the arguments as a segment of makefile, and parse them.
1356 static char *
1357 func_eval (char *o, char **argv, const char *funcname UNUSED)
1359 char *buf;
1360 unsigned int len;
1362 /* Eval the buffer. Pop the current variable buffer setting so that the
1363 eval'd code can use its own without conflicting. */
1365 install_variable_buffer (&buf, &len);
1367 eval_buffer (argv[0]);
1369 restore_variable_buffer (buf, len);
1371 return o;
1375 static char *
1376 func_value (char *o, char **argv, const char *funcname UNUSED)
1378 /* Look up the variable. */
1379 struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
1381 /* Copy its value into the output buffer without expanding it. */
1382 if (v)
1383 o = variable_buffer_output (o, v->value, strlen(v->value));
1385 return o;
1389 \r is replaced on UNIX as well. Is this desirable?
1391 static void
1392 fold_newlines (char *buffer, unsigned int *length, int trim_newlines)
1394 char *dst = buffer;
1395 char *src = buffer;
1396 char *last_nonnl = buffer - 1;
1397 src[*length] = 0;
1398 for (; *src != '\0'; ++src)
1400 if (src[0] == '\r' && src[1] == '\n')
1401 continue;
1402 if (*src == '\n')
1404 *dst++ = ' ';
1406 else
1408 last_nonnl = dst;
1409 *dst++ = *src;
1413 if (!trim_newlines && (last_nonnl < (dst - 2)))
1414 last_nonnl = dst - 2;
1416 *(++last_nonnl) = '\0';
1417 *length = last_nonnl - buffer;
1422 int shell_function_pid = 0, shell_function_completed;
1425 #ifdef WINDOWS32
1426 /*untested*/
1428 #include <windows.h>
1429 #include <io.h>
1430 #include "sub_proc.h"
1433 void
1434 windows32_openpipe (int *pipedes, pid_t *pid_p, char **command_argv, char **envp)
1436 SECURITY_ATTRIBUTES saAttr;
1437 HANDLE hIn;
1438 HANDLE hErr;
1439 HANDLE hChildOutRd;
1440 HANDLE hChildOutWr;
1441 HANDLE hProcess;
1444 saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
1445 saAttr.bInheritHandle = TRUE;
1446 saAttr.lpSecurityDescriptor = NULL;
1448 if (DuplicateHandle (GetCurrentProcess(),
1449 GetStdHandle(STD_INPUT_HANDLE),
1450 GetCurrentProcess(),
1451 &hIn,
1453 TRUE,
1454 DUPLICATE_SAME_ACCESS) == FALSE) {
1455 fatal (NILF, _("windows32_openpipe(): DuplicateHandle(In) failed (e=%ld)\n"),
1456 GetLastError());
1459 if (DuplicateHandle(GetCurrentProcess(),
1460 GetStdHandle(STD_ERROR_HANDLE),
1461 GetCurrentProcess(),
1462 &hErr,
1464 TRUE,
1465 DUPLICATE_SAME_ACCESS) == FALSE) {
1466 fatal (NILF, _("windows32_open_pipe(): DuplicateHandle(Err) failed (e=%ld)\n"),
1467 GetLastError());
1470 if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0))
1471 fatal (NILF, _("CreatePipe() failed (e=%ld)\n"), GetLastError());
1473 hProcess = process_init_fd(hIn, hChildOutWr, hErr);
1475 if (!hProcess)
1476 fatal (NILF, _("windows32_openpipe(): process_init_fd() failed\n"));
1478 /* make sure that CreateProcess() has Path it needs */
1479 sync_Path_environment();
1480 /* `sync_Path_environment' may realloc `environ', so take note of
1481 the new value. */
1482 envp = environ;
1484 if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL)) {
1485 /* register process for wait */
1486 process_register(hProcess);
1488 /* set the pid for returning to caller */
1489 *pid_p = (pid_t) hProcess;
1491 /* set up to read data from child */
1492 pipedes[0] = _open_osfhandle((intptr_t) hChildOutRd, O_RDONLY);
1494 /* this will be closed almost right away */
1495 pipedes[1] = _open_osfhandle((intptr_t) hChildOutWr, O_APPEND);
1496 } else {
1497 /* reap/cleanup the failed process */
1498 process_cleanup(hProcess);
1500 /* close handles which were duplicated, they weren't used */
1501 CloseHandle(hIn);
1502 CloseHandle(hErr);
1504 /* close pipe handles, they won't be used */
1505 CloseHandle(hChildOutRd);
1506 CloseHandle(hChildOutWr);
1508 /* set status for return */
1509 pipedes[0] = pipedes[1] = -1;
1510 *pid_p = (pid_t)-1;
1513 #endif
1516 #ifdef __MSDOS__
1517 FILE *
1518 msdos_openpipe (int* pipedes, int *pidp, char *text)
1520 FILE *fpipe=0;
1521 /* MSDOS can't fork, but it has `popen'. */
1522 struct variable *sh = lookup_variable ("SHELL", 5);
1523 int e;
1524 extern int dos_command_running, dos_status;
1526 /* Make sure not to bother processing an empty line. */
1527 while (isblank ((unsigned char)*text))
1528 ++text;
1529 if (*text == '\0')
1530 return 0;
1532 if (sh)
1534 char buf[PATH_MAX + 7];
1535 /* This makes sure $SHELL value is used by $(shell), even
1536 though the target environment is not passed to it. */
1537 sprintf (buf, "SHELL=%s", sh->value);
1538 putenv (buf);
1541 e = errno;
1542 errno = 0;
1543 dos_command_running = 1;
1544 dos_status = 0;
1545 /* If dos_status becomes non-zero, it means the child process
1546 was interrupted by a signal, like SIGINT or SIGQUIT. See
1547 fatal_error_signal in commands.c. */
1548 fpipe = popen (text, "rt");
1549 dos_command_running = 0;
1550 if (!fpipe || dos_status)
1552 pipedes[0] = -1;
1553 *pidp = -1;
1554 if (dos_status)
1555 errno = EINTR;
1556 else if (errno == 0)
1557 errno = ENOMEM;
1558 shell_function_completed = -1;
1560 else
1562 pipedes[0] = fileno (fpipe);
1563 *pidp = 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
1564 errno = e;
1565 shell_function_completed = 1;
1567 return fpipe;
1569 #endif
1572 Do shell spawning, with the naughty bits for different OSes.
1575 #ifdef VMS
1577 /* VMS can't do $(shell ...) */
1579 char *
1580 func_shell_base (char *o, char **argv, int trim_newlines)
1582 fprintf (stderr, "This platform does not support shell\n");
1583 die (EXIT_FAILURE);
1586 #define func_shell 0
1588 #else
1589 #ifndef _AMIGA
1590 char *
1591 func_shell_base (char *o, char **argv, int trim_newlines)
1593 char *batch_filename = NULL;
1595 #ifdef __MSDOS__
1596 FILE *fpipe;
1597 #endif
1598 char **command_argv;
1599 const char *error_prefix;
1600 char **envp;
1601 int pipedes[2];
1602 pid_t pid;
1604 #ifndef __MSDOS__
1605 #ifdef WINDOWS32
1606 /* Reset just_print_flag. This is needed on Windows when batch files
1607 are used to run the commands, because we normally refrain from
1608 creating batch files under -n. */
1609 int j_p_f = just_print_flag;
1611 just_print_flag = 0;
1612 #endif
1613 /* Construct the argument list. */
1614 command_argv = construct_command_argv (argv[0], NULL, NULL, 0,
1615 &batch_filename);
1616 if (command_argv == 0)
1618 #ifdef WINDOWS32
1619 just_print_flag = j_p_f;
1620 #endif
1621 return o;
1623 #endif
1625 /* Using a target environment for `shell' loses in cases like:
1626 export var = $(shell echo foobie)
1627 because target_environment hits a loop trying to expand $(var)
1628 to put it in the environment. This is even more confusing when
1629 var was not explicitly exported, but just appeared in the
1630 calling environment.
1632 See Savannah bug #10593.
1634 envp = target_environment (NILF);
1637 envp = environ;
1639 /* For error messages. */
1640 if (reading_file && reading_file->filenm)
1642 char *p = alloca (strlen (reading_file->filenm)+11+4);
1643 sprintf (p, "%s:%lu: ", reading_file->filenm, reading_file->lineno);
1644 error_prefix = p;
1646 else
1647 error_prefix = "";
1649 #if defined(__MSDOS__)
1650 fpipe = msdos_openpipe (pipedes, &pid, argv[0]);
1651 if (pipedes[0] < 0)
1653 perror_with_name (error_prefix, "pipe");
1654 return o;
1656 #elif defined(WINDOWS32)
1657 windows32_openpipe (pipedes, &pid, command_argv, envp);
1658 /* Restore the value of just_print_flag. */
1659 just_print_flag = j_p_f;
1661 if (pipedes[0] < 0)
1663 /* Open of the pipe failed, mark as failed execution. */
1664 shell_function_completed = -1;
1665 return o;
1667 else
1668 #else
1669 if (pipe (pipedes) < 0)
1671 perror_with_name (error_prefix, "pipe");
1672 return o;
1675 # ifdef __EMX__
1676 /* close some handles that are unnecessary for the child process */
1677 CLOSE_ON_EXEC(pipedes[1]);
1678 CLOSE_ON_EXEC(pipedes[0]);
1679 /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
1680 pid = child_execute_job (0, pipedes[1], command_argv, envp);
1681 if (pid < 0)
1682 perror_with_name (error_prefix, "spawn");
1683 # else /* ! __EMX__ */
1684 pid = fork ();
1685 if (pid < 0)
1686 perror_with_name (error_prefix, "fork");
1687 else if (pid == 0)
1688 child_execute_job (0, pipedes[1], command_argv, envp);
1689 else
1690 # endif
1691 #endif
1693 /* We are the parent. */
1694 char *buffer;
1695 unsigned int maxlen, i;
1696 int cc;
1698 /* Record the PID for reap_children. */
1699 shell_function_pid = pid;
1700 #ifndef __MSDOS__
1701 shell_function_completed = 0;
1703 /* Free the storage only the child needed. */
1704 free (command_argv[0]);
1705 free (command_argv);
1707 /* Close the write side of the pipe. We test for -1, since
1708 pipedes[1] is -1 on MS-Windows, and some versions of MS
1709 libraries barf when `close' is called with -1. */
1710 if (pipedes[1] >= 0)
1711 close (pipedes[1]);
1712 #endif
1714 /* Set up and read from the pipe. */
1716 maxlen = 200;
1717 buffer = xmalloc (maxlen + 1);
1719 /* Read from the pipe until it gets EOF. */
1720 for (i = 0; ; i += cc)
1722 if (i == maxlen)
1724 maxlen += 512;
1725 buffer = xrealloc (buffer, maxlen + 1);
1728 EINTRLOOP (cc, read (pipedes[0], &buffer[i], maxlen - i));
1729 if (cc <= 0)
1730 break;
1732 buffer[i] = '\0';
1734 /* Close the read side of the pipe. */
1735 #ifdef __MSDOS__
1736 if (fpipe)
1737 (void) pclose (fpipe);
1738 #else
1739 (void) close (pipedes[0]);
1740 #endif
1742 /* Loop until child_handler or reap_children() sets
1743 shell_function_completed to the status of our child shell. */
1744 while (shell_function_completed == 0)
1745 reap_children (1, 0);
1747 if (batch_filename) {
1748 DB (DB_VERBOSE, (_("Cleaning up temporary batch file %s\n"),
1749 batch_filename));
1750 remove (batch_filename);
1751 free (batch_filename);
1753 shell_function_pid = 0;
1755 /* The child_handler function will set shell_function_completed
1756 to 1 when the child dies normally, or to -1 if it
1757 dies with status 127, which is most likely an exec fail. */
1759 if (shell_function_completed == -1)
1761 /* This likely means that the execvp failed, so we should just
1762 write the error message in the pipe from the child. */
1763 fputs (buffer, stderr);
1764 fflush (stderr);
1766 else
1768 /* The child finished normally. Replace all newlines in its output
1769 with spaces, and put that in the variable output buffer. */
1770 fold_newlines (buffer, &i, trim_newlines);
1771 o = variable_buffer_output (o, buffer, i);
1774 free (buffer);
1777 return o;
1780 #else /* _AMIGA */
1782 /* Do the Amiga version of func_shell. */
1784 char *
1785 func_shell_base (char *o, char **argv, int trim_newlines)
1787 /* Amiga can't fork nor spawn, but I can start a program with
1788 redirection of my choice. However, this means that we
1789 don't have an opportunity to reopen stdout to trap it. Thus,
1790 we save our own stdout onto a new descriptor and dup a temp
1791 file's descriptor onto our stdout temporarily. After we
1792 spawn the shell program, we dup our own stdout back to the
1793 stdout descriptor. The buffer reading is the same as above,
1794 except that we're now reading from a file. */
1796 #include <dos/dos.h>
1797 #include <proto/dos.h>
1799 BPTR child_stdout;
1800 char tmp_output[FILENAME_MAX];
1801 unsigned int maxlen = 200, i;
1802 int cc;
1803 char * buffer, * ptr;
1804 char ** aptr;
1805 int len = 0;
1806 char* batch_filename = NULL;
1808 /* Construct the argument list. */
1809 command_argv = construct_command_argv (argv[0], NULL, NULL, 0,
1810 &batch_filename);
1811 if (command_argv == 0)
1812 return o;
1814 /* Note the mktemp() is a security hole, but this only runs on Amiga.
1815 Ideally we would use main.c:open_tmpfile(), but this uses a special
1816 Open(), not fopen(), and I'm not familiar enough with the code to mess
1817 with it. */
1818 strcpy (tmp_output, "t:MakeshXXXXXXXX");
1819 mktemp (tmp_output);
1820 child_stdout = Open (tmp_output, MODE_NEWFILE);
1822 for (aptr=command_argv; *aptr; aptr++)
1823 len += strlen (*aptr) + 1;
1825 buffer = xmalloc (len + 1);
1826 ptr = buffer;
1828 for (aptr=command_argv; *aptr; aptr++)
1830 strcpy (ptr, *aptr);
1831 ptr += strlen (ptr) + 1;
1832 *ptr ++ = ' ';
1833 *ptr = 0;
1836 ptr[-1] = '\n';
1838 Execute (buffer, NULL, child_stdout);
1839 free (buffer);
1841 Close (child_stdout);
1843 child_stdout = Open (tmp_output, MODE_OLDFILE);
1845 buffer = xmalloc (maxlen);
1846 i = 0;
1849 if (i == maxlen)
1851 maxlen += 512;
1852 buffer = xrealloc (buffer, maxlen + 1);
1855 cc = Read (child_stdout, &buffer[i], maxlen - i);
1856 if (cc > 0)
1857 i += cc;
1858 } while (cc > 0);
1860 Close (child_stdout);
1862 fold_newlines (buffer, &i, trim_newlines);
1863 o = variable_buffer_output (o, buffer, i);
1864 free (buffer);
1865 return o;
1867 #endif /* _AMIGA */
1869 char *
1870 func_shell (char *o, char **argv, const char *funcname UNUSED)
1872 return func_shell_base (o, argv, 1);
1874 #endif /* !VMS */
1876 #ifdef EXPERIMENTAL
1879 equality. Return is string-boolean, ie, the empty string is false.
1881 static char *
1882 func_eq (char *o, char **argv, char *funcname)
1884 int result = ! strcmp (argv[0], argv[1]);
1885 o = variable_buffer_output (o, result ? "1" : "", result);
1886 return o;
1891 string-boolean not operator.
1893 static char *
1894 func_not (char *o, char **argv, char *funcname)
1896 const char *s = argv[0];
1897 int result = 0;
1898 while (isspace ((unsigned char)*s))
1899 s++;
1900 result = ! (*s);
1901 o = variable_buffer_output (o, result ? "1" : "", result);
1902 return o;
1904 #endif
1907 #ifdef HAVE_DOS_PATHS
1908 #define IS_ABSOLUTE(n) (n[0] && n[1] == ':')
1909 #define ROOT_LEN 3
1910 #else
1911 #define IS_ABSOLUTE(n) (n[0] == '/')
1912 #define ROOT_LEN 1
1913 #endif
1915 /* Return the absolute name of file NAME which does not contain any `.',
1916 `..' components nor any repeated path separators ('/'). */
1918 static char *
1919 abspath (const char *name, char *apath)
1921 char *dest;
1922 const char *start, *end, *apath_limit;
1923 unsigned long root_len = ROOT_LEN;
1925 if (name[0] == '\0' || apath == NULL)
1926 return NULL;
1928 apath_limit = apath + GET_PATH_MAX;
1930 if (!IS_ABSOLUTE(name))
1932 /* It is unlikely we would make it until here but just to make sure. */
1933 if (!starting_directory)
1934 return NULL;
1936 strcpy (apath, starting_directory);
1938 #ifdef HAVE_DOS_PATHS
1939 if (IS_PATHSEP(name[0]))
1941 if (IS_PATHSEP(name[1]))
1943 /* A UNC. Don't prepend a drive letter. */
1944 apath[0] = name[0];
1945 apath[1] = name[1];
1946 root_len = 2;
1948 /* We have /foo, an absolute file name except for the drive
1949 letter. Assume the missing drive letter is the current
1950 drive, which we can get if we remove from starting_directory
1951 everything past the root directory. */
1952 apath[root_len] = '\0';
1954 #endif
1956 dest = strchr (apath, '\0');
1958 else
1960 strncpy (apath, name, root_len);
1961 apath[root_len] = '\0';
1962 dest = apath + root_len;
1963 /* Get past the root, since we already copied it. */
1964 name += root_len;
1965 #ifdef HAVE_DOS_PATHS
1966 if (!IS_PATHSEP(apath[2]))
1968 /* Convert d:foo into d:./foo and increase root_len. */
1969 apath[2] = '.';
1970 apath[3] = '/';
1971 dest++;
1972 root_len++;
1973 /* strncpy above copied one character too many. */
1974 name--;
1976 else
1977 apath[2] = '/'; /* make sure it's a forward slash */
1978 #endif
1981 for (start = end = name; *start != '\0'; start = end)
1983 unsigned long len;
1985 /* Skip sequence of multiple path-separators. */
1986 while (IS_PATHSEP(*start))
1987 ++start;
1989 /* Find end of path component. */
1990 for (end = start; *end != '\0' && !IS_PATHSEP(*end); ++end)
1993 len = end - start;
1995 if (len == 0)
1996 break;
1997 else if (len == 1 && start[0] == '.')
1998 /* nothing */;
1999 else if (len == 2 && start[0] == '.' && start[1] == '.')
2001 /* Back up to previous component, ignore if at root already. */
2002 if (dest > apath + root_len)
2003 for (--dest; !IS_PATHSEP(dest[-1]); --dest);
2005 else
2007 if (!IS_PATHSEP(dest[-1]))
2008 *dest++ = '/';
2010 if (dest + len >= apath_limit)
2011 return NULL;
2013 dest = memcpy (dest, start, len);
2014 dest += len;
2015 *dest = '\0';
2019 /* Unless it is root strip trailing separator. */
2020 if (dest > apath + root_len && IS_PATHSEP(dest[-1]))
2021 --dest;
2023 *dest = '\0';
2025 return apath;
2029 static char *
2030 func_realpath (char *o, char **argv, const char *funcname UNUSED)
2032 /* Expand the argument. */
2033 const char *p = argv[0];
2034 const char *path = 0;
2035 int doneany = 0;
2036 unsigned int len = 0;
2037 #ifndef HAVE_REALPATH
2038 struct stat st;
2039 #endif
2040 PATH_VAR (in);
2041 PATH_VAR (out);
2043 while ((path = find_next_token (&p, &len)) != 0)
2045 if (len < GET_PATH_MAX)
2047 strncpy (in, path, len);
2048 in[len] = '\0';
2050 if (
2051 #ifdef HAVE_REALPATH
2052 realpath (in, out)
2053 #else
2054 abspath (in, out) && stat (out, &st) == 0
2055 #endif
2058 o = variable_buffer_output (o, out, strlen (out));
2059 o = variable_buffer_output (o, " ", 1);
2060 doneany = 1;
2065 /* Kill last space. */
2066 if (doneany)
2067 --o;
2069 return o;
2072 static char *
2073 func_abspath (char *o, char **argv, const char *funcname UNUSED)
2075 /* Expand the argument. */
2076 const char *p = argv[0];
2077 const char *path = 0;
2078 int doneany = 0;
2079 unsigned int len = 0;
2080 PATH_VAR (in);
2081 PATH_VAR (out);
2083 while ((path = find_next_token (&p, &len)) != 0)
2085 if (len < GET_PATH_MAX)
2087 strncpy (in, path, len);
2088 in[len] = '\0';
2090 if (abspath (in, out))
2092 o = variable_buffer_output (o, out, strlen (out));
2093 o = variable_buffer_output (o, " ", 1);
2094 doneany = 1;
2099 /* Kill last space. */
2100 if (doneany)
2101 --o;
2103 return o;
2106 /* Lookup table for builtin functions.
2108 This doesn't have to be sorted; we use a straight lookup. We might gain
2109 some efficiency by moving most often used functions to the start of the
2110 table.
2112 If MAXIMUM_ARGS is 0, that means there is no maximum and all
2113 comma-separated values are treated as arguments.
2115 EXPAND_ARGS means that all arguments should be expanded before invocation.
2116 Functions that do namespace tricks (foreach) don't automatically expand. */
2118 static char *func_call (char *o, char **argv, const char *funcname);
2121 static struct function_table_entry function_table_init[] =
2123 /* Name/size */ /* MIN MAX EXP? Function */
2124 { STRING_SIZE_TUPLE("abspath"), 0, 1, 1, func_abspath},
2125 { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix},
2126 { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix},
2127 { STRING_SIZE_TUPLE("basename"), 0, 1, 1, func_basename_dir},
2128 { STRING_SIZE_TUPLE("dir"), 0, 1, 1, func_basename_dir},
2129 { STRING_SIZE_TUPLE("notdir"), 0, 1, 1, func_notdir_suffix},
2130 { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst},
2131 { STRING_SIZE_TUPLE("suffix"), 0, 1, 1, func_notdir_suffix},
2132 { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout},
2133 { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout},
2134 { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring},
2135 { STRING_SIZE_TUPLE("firstword"), 0, 1, 1, func_firstword},
2136 { STRING_SIZE_TUPLE("flavor"), 0, 1, 1, func_flavor},
2137 { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join},
2138 { STRING_SIZE_TUPLE("lastword"), 0, 1, 1, func_lastword},
2139 { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst},
2140 { STRING_SIZE_TUPLE("realpath"), 0, 1, 1, func_realpath},
2141 { STRING_SIZE_TUPLE("shell"), 0, 1, 1, func_shell},
2142 { STRING_SIZE_TUPLE("sort"), 0, 1, 1, func_sort},
2143 { STRING_SIZE_TUPLE("strip"), 0, 1, 1, func_strip},
2144 { STRING_SIZE_TUPLE("wildcard"), 0, 1, 1, func_wildcard},
2145 { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word},
2146 { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist},
2147 { STRING_SIZE_TUPLE("words"), 0, 1, 1, func_words},
2148 { STRING_SIZE_TUPLE("origin"), 0, 1, 1, func_origin},
2149 { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach},
2150 { STRING_SIZE_TUPLE("call"), 1, 0, 1, func_call},
2151 { STRING_SIZE_TUPLE("info"), 0, 1, 1, func_error},
2152 { STRING_SIZE_TUPLE("error"), 0, 1, 1, func_error},
2153 { STRING_SIZE_TUPLE("warning"), 0, 1, 1, func_error},
2154 { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if},
2155 { STRING_SIZE_TUPLE("or"), 1, 0, 0, func_or},
2156 { STRING_SIZE_TUPLE("and"), 1, 0, 0, func_and},
2157 { STRING_SIZE_TUPLE("value"), 0, 1, 1, func_value},
2158 { STRING_SIZE_TUPLE("eval"), 0, 1, 1, func_eval},
2159 #ifdef EXPERIMENTAL
2160 { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq},
2161 { STRING_SIZE_TUPLE("not"), 0, 1, 1, func_not},
2162 #endif
2165 #define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry))
2168 /* These must come after the definition of function_table. */
2170 static char *
2171 expand_builtin_function (char *o, int argc, char **argv,
2172 const struct function_table_entry *entry_p)
2174 if (argc < (int)entry_p->minimum_args)
2175 fatal (*expanding_var,
2176 _("insufficient number of arguments (%d) to function `%s'"),
2177 argc, entry_p->name);
2179 /* I suppose technically some function could do something with no
2180 arguments, but so far none do, so just test it for all functions here
2181 rather than in each one. We can change it later if necessary. */
2183 if (!argc)
2184 return o;
2186 if (!entry_p->func_ptr)
2187 fatal (*expanding_var,
2188 _("unimplemented on this platform: function `%s'"), entry_p->name);
2190 return entry_p->func_ptr (o, argv, entry_p->name);
2193 /* Check for a function invocation in *STRINGP. *STRINGP points at the
2194 opening ( or { and is not null-terminated. If a function invocation
2195 is found, expand it into the buffer at *OP, updating *OP, incrementing
2196 *STRINGP past the reference and returning nonzero. If not, return zero. */
2199 handle_function (char **op, const char **stringp)
2201 const struct function_table_entry *entry_p;
2202 char openparen = (*stringp)[0];
2203 char closeparen = openparen == '(' ? ')' : '}';
2204 const char *beg;
2205 const char *end;
2206 int count = 0;
2207 char *abeg = NULL;
2208 char **argv, **argvp;
2209 int nargs;
2211 beg = *stringp + 1;
2213 entry_p = lookup_function (beg);
2215 if (!entry_p)
2216 return 0;
2218 /* We found a builtin function. Find the beginning of its arguments (skip
2219 whitespace after the name). */
2221 beg = next_token (beg + entry_p->len);
2223 /* Find the end of the function invocation, counting nested use of
2224 whichever kind of parens we use. Since we're looking, count commas
2225 to get a rough estimate of how many arguments we might have. The
2226 count might be high, but it'll never be low. */
2228 for (nargs=1, end=beg; *end != '\0'; ++end)
2229 if (*end == ',')
2230 ++nargs;
2231 else if (*end == openparen)
2232 ++count;
2233 else if (*end == closeparen && --count < 0)
2234 break;
2236 if (count >= 0)
2237 fatal (*expanding_var,
2238 _("unterminated call to function `%s': missing `%c'"),
2239 entry_p->name, closeparen);
2241 *stringp = end;
2243 /* Get some memory to store the arg pointers. */
2244 argvp = argv = alloca (sizeof (char *) * (nargs + 2));
2246 /* Chop the string into arguments, then a nul. As soon as we hit
2247 MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
2248 last argument.
2250 If we're expanding, store pointers to the expansion of each one. If
2251 not, make a duplicate of the string and point into that, nul-terminating
2252 each argument. */
2254 if (entry_p->expand_args)
2256 const char *p;
2257 for (p=beg, nargs=0; p <= end; ++argvp)
2259 const char *next;
2261 ++nargs;
2263 if (nargs == entry_p->maximum_args
2264 || (! (next = find_next_argument (openparen, closeparen, p, end))))
2265 next = end;
2267 *argvp = expand_argument (p, next);
2268 p = next + 1;
2271 else
2273 int len = end - beg;
2274 char *p, *aend;
2276 abeg = xmalloc (len+1);
2277 memcpy (abeg, beg, len);
2278 abeg[len] = '\0';
2279 aend = abeg + len;
2281 for (p=abeg, nargs=0; p <= aend; ++argvp)
2283 char *next;
2285 ++nargs;
2287 if (nargs == entry_p->maximum_args
2288 || (! (next = find_next_argument (openparen, closeparen, p, aend))))
2289 next = aend;
2291 *argvp = p;
2292 *next = '\0';
2293 p = next + 1;
2296 *argvp = NULL;
2298 /* Finally! Run the function... */
2299 *op = expand_builtin_function (*op, nargs, argv, entry_p);
2301 /* Free memory. */
2302 if (entry_p->expand_args)
2303 for (argvp=argv; *argvp != 0; ++argvp)
2304 free (*argvp);
2305 if (abeg)
2306 free (abeg);
2308 return 1;
2312 /* User-defined functions. Expand the first argument as either a builtin
2313 function or a make variable, in the context of the rest of the arguments
2314 assigned to $1, $2, ... $N. $0 is the name of the function. */
2316 static char *
2317 func_call (char *o, char **argv, const char *funcname UNUSED)
2319 static int max_args = 0;
2320 char *fname;
2321 char *cp;
2322 char *body;
2323 int flen;
2324 int i;
2325 int saved_args;
2326 const struct function_table_entry *entry_p;
2327 struct variable *v;
2329 /* There is no way to define a variable with a space in the name, so strip
2330 leading and trailing whitespace as a favor to the user. */
2331 fname = argv[0];
2332 while (*fname != '\0' && isspace ((unsigned char)*fname))
2333 ++fname;
2335 cp = fname + strlen (fname) - 1;
2336 while (cp > fname && isspace ((unsigned char)*cp))
2337 --cp;
2338 cp[1] = '\0';
2340 /* Calling nothing is a no-op */
2341 if (*fname == '\0')
2342 return o;
2344 /* Are we invoking a builtin function? */
2346 entry_p = lookup_function (fname);
2347 if (entry_p)
2349 /* How many arguments do we have? */
2350 for (i=0; argv[i+1]; ++i)
2352 return expand_builtin_function (o, i, argv+1, entry_p);
2355 /* Not a builtin, so the first argument is the name of a variable to be
2356 expanded and interpreted as a function. Find it. */
2357 flen = strlen (fname);
2359 v = lookup_variable (fname, flen);
2361 if (v == 0)
2362 warn_undefined (fname, flen);
2364 if (v == 0 || *v->value == '\0')
2365 return o;
2367 body = alloca (flen + 4);
2368 body[0] = '$';
2369 body[1] = '(';
2370 memcpy (body + 2, fname, flen);
2371 body[flen+2] = ')';
2372 body[flen+3] = '\0';
2374 /* Set up arguments $(1) .. $(N). $(0) is the function name. */
2376 push_new_variable_scope ();
2378 for (i=0; *argv; ++i, ++argv)
2380 char num[11];
2382 sprintf (num, "%d", i);
2383 define_variable (num, strlen (num), *argv, o_automatic, 0);
2386 /* If the number of arguments we have is < max_args, it means we're inside
2387 a recursive invocation of $(call ...). Fill in the remaining arguments
2388 in the new scope with the empty value, to hide them from this
2389 invocation. */
2391 for (; i < max_args; ++i)
2393 char num[11];
2395 sprintf (num, "%d", i);
2396 define_variable (num, strlen (num), "", o_automatic, 0);
2399 /* Expand the body in the context of the arguments, adding the result to
2400 the variable buffer. */
2402 v->exp_count = EXP_COUNT_MAX;
2404 saved_args = max_args;
2405 max_args = i;
2406 o = variable_expand_string (o, body, flen+3);
2407 max_args = saved_args;
2409 v->exp_count = 0;
2411 pop_variable_scope ();
2413 return o + strlen (o);
2416 void
2417 define_new_function(const struct floc *flocp,
2418 const char *name, int min, int max, int expand,
2419 char *(*func)(char *, char **, const char *))
2421 size_t len = strlen (name);
2422 struct function_table_entry *ent = xmalloc (sizeof (struct function_table_entry));
2424 if (len > 255)
2425 fatal (flocp, _("Function name too long: %s\n"), name);
2426 if (min < 0 || min > 255)
2427 fatal (flocp, _("Invalid minimum argument count (%d) for function %s%s\n"),
2428 min, name);
2429 if (max < 0 || max > 255 || max < min)
2430 fatal (flocp, _("Invalid maximum argument count (%d) for function %s%s\n"),
2431 max, name);
2433 ent->name = name;
2434 ent->len = len;
2435 ent->minimum_args = min;
2436 ent->maximum_args = max;
2437 ent->expand_args = expand ? 1 : 0;
2438 ent->func_ptr = func;
2440 hash_insert (&function_table, ent);
2443 void
2444 hash_init_function_table (void)
2446 hash_init (&function_table, FUNCTION_TABLE_ENTRIES * 2,
2447 function_table_entry_hash_1, function_table_entry_hash_2,
2448 function_table_entry_hash_cmp);
2449 hash_load (&function_table, function_table_init,
2450 FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));