Update copyright notices.
[libreoffice:gnu-make-lo.git] / function.c
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.
6
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.
11
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.
15
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/>.  */
18
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"
26
27 #ifdef _AMIGA
28 #include "amiga.h"
29 #endif
30
31
32 struct function_table_entry
33   {
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);
40   };
41
42 static unsigned long
43 function_table_entry_hash_1 (const void *keyv)
44 {
45   const struct function_table_entry *key = keyv;
46   return_STRING_N_HASH_1 (key->name, key->len);
47 }
48
49 static unsigned long
50 function_table_entry_hash_2 (const void *keyv)
51 {
52   const struct function_table_entry *key = keyv;
53   return_STRING_N_HASH_2 (key->name, key->len);
54 }
55
56 static int
57 function_table_entry_hash_cmp (const void *xv, const void *yv)
58 {
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);
65 }
66
67 static struct hash_table function_table;
68 \f
69
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.  */
75
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)
79 {
80   const char *t = text;
81   const char *p;
82
83   if (slen == 0 && !by_word)
84     {
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;
90     }
91
92   do
93     {
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
99         {
100           p = strstr (t, subst);
101           if (p == 0)
102             {
103               /* No more matches.  Output everything left on the end.  */
104               o = variable_buffer_output (o, t, strlen (t));
105               return o;
106             }
107         }
108
109       /* Output everything before this occurrence of the string to replace.  */
110       if (p > t)
111         o = variable_buffer_output (o, t, p - t);
112
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);
124
125       /* Advance T past the string to be replaced.  */
126       t = p + slen;
127     } while (*t != '\0');
128
129   return o;
130 }
131 \f
132
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.
141 */
142
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)
147 {
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;
153
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)
157     {
158       replace_prepercent_len = replace_percent - replace - 1;
159       replace_postpercent_len = strlen (replace_percent);
160     }
161   else
162     {
163       replace_prepercent_len = strlen (replace);
164       replace_postpercent_len = 0;
165     }
166
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);
171
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);
176
177   while ((t = find_next_token (&text, &len)) != 0)
178     {
179       int fail = 0;
180
181       /* Is it big enough to match?  */
182       if (len < pattern_prepercent_len + pattern_postpercent_len)
183         fail = 1;
184
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;
191
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;
199
200       if (fail)
201         /* It didn't match.  Output the string.  */
202         o = variable_buffer_output (o, t, len);
203       else
204         {
205           /* It matched.  Output the replacement.  */
206
207           /* Output the part of the replacement before the %.  */
208           o = variable_buffer_output (o, replace, replace_prepercent_len);
209
210           if (replace_percent != 0)
211             {
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);
220             }
221         }
222
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))
226         {
227           o = variable_buffer_output (o, " ", 1);
228           doneany = 1;
229         }
230     }
231   if (doneany)
232     /* Kill the last space.  */
233     --o;
234
235   return o;
236 }
237
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.
246 */
247
248 char *
249 patsubst_expand (char *o, const char *text, char *pattern, char *replace)
250 {
251   const char *pattern_percent = find_percent (pattern);
252   const char *replace_percent = find_percent (replace);
253
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;
259
260   return patsubst_expand_pat (o, text, pattern, replace,
261                               pattern_percent, replace_percent);
262 }
263 \f
264
265 /* Look up a function by name.  */
266
267 static const struct function_table_entry *
268 lookup_function (const char *s)
269 {
270   const char *e = s;
271
272   while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-'))
273     e++;
274   if (*e == '\0' || isblank ((unsigned char) *e))
275     {
276       struct function_table_entry function_table_entry_key;
277       function_table_entry_key.name = s;
278       function_table_entry_key.len = e - s;
279
280       return hash_find_item (&function_table, &function_table_entry_key);
281     }
282   return 0;
283 }
284 \f
285
286 /* Return 1 if PATTERN matches STR, 0 if not.  */
287
288 int
289 pattern_matches (const char *pattern, const char *percent, const char *str)
290 {
291   unsigned int sfxlen, strlength;
292
293   if (percent == 0)
294     {
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;
302     }
303
304   sfxlen = strlen (percent + 1);
305   strlength = strlen (str);
306
307   if (strlength < (percent - pattern) + sfxlen
308       || !strneq (pattern, str, percent - pattern))
309     return 0;
310
311   return !strcmp (percent + 1, str + (strlength - sfxlen));
312 }
313 \f
314
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.
318
319    If no next argument is found, return NULL.
320 */
321
322 static char *
323 find_next_argument (char startparen, char endparen,
324                     const char *ptr, const char *end)
325 {
326   int count = 0;
327
328   for (; ptr < end; ++ptr)
329     if (*ptr == startparen)
330       ++count;
331
332     else if (*ptr == endparen)
333       {
334         --count;
335         if (count < 0)
336           return NULL;
337       }
338
339     else if (*ptr == ',' && !count)
340       return (char *)ptr;
341
342   /* We didn't find anything.  */
343   return NULL;
344 }
345 \f
346
347 /* Glob-expand LINE.  The returned pointer is
348    only good until the next call to string_glob.  */
349
350 static char *
351 string_glob (char *line)
352 {
353   static char *result = 0;
354   static unsigned int length;
355   struct nameseq *chain;
356   unsigned int idx;
357
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);
363
364   if (result == 0)
365     {
366       length = 100;
367       result = xmalloc (100);
368     }
369
370   idx = 0;
371   while (chain != 0)
372     {
373       struct nameseq *next = chain->next;
374       unsigned int len = strlen (chain->name);
375
376       if (idx + len + 1 > length)
377         {
378           length += (len + 1) * 2;
379           result = xrealloc (result, length);
380         }
381       memcpy (&result[idx], chain->name, len);
382       idx += len;
383       result[idx++] = ' ';
384
385       /* Because we used PARSEFS_NOCACHE above, we have to free() NAME.  */
386       free ((char *)chain->name);
387       free (chain);
388       chain = next;
389     }
390
391   /* Kill the last space and terminate the string.  */
392   if (idx == 0)
393     result[0] = '\0';
394   else
395     result[idx - 1] = '\0';
396
397   return result;
398 }
399 \f
400 /*
401   Builtin functions
402  */
403
404 static char *
405 func_patsubst (char *o, char **argv, const char *funcname UNUSED)
406 {
407   o = patsubst_expand (o, argv[2], argv[0], argv[1]);
408   return o;
409 }
410
411
412 static char *
413 func_join (char *o, char **argv, const char *funcname UNUSED)
414 {
415   int doneany = 0;
416
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];
425   do
426     {
427       unsigned int len1, len2;
428
429       tp = find_next_token (&list1_iterator, &len1);
430       if (tp != 0)
431         o = variable_buffer_output (o, tp, len1);
432
433       pp = find_next_token (&list2_iterator, &len2);
434       if (pp != 0)
435         o = variable_buffer_output (o, pp, len2);
436
437       if (tp != 0 || pp != 0)
438         {
439           o = variable_buffer_output (o, " ", 1);
440           doneany = 1;
441         }
442     }
443   while (tp != 0 || pp != 0);
444   if (doneany)
445     /* Kill the last blank.  */
446     --o;
447
448   return o;
449 }
450
451
452 static char *
453 func_origin (char *o, char **argv, const char *funcname UNUSED)
454 {
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)
461       {
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;
487       }
488
489   return o;
490 }
491
492 static char *
493 func_flavor (char *o, char **argv, const char *funcname UNUSED)
494 {
495   struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
496
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);
504
505   return o;
506 }
507
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
517
518
519 static char *
520 func_notdir_suffix (char *o, char **argv, const char *funcname)
521 {
522   /* Expand the argument.  */
523   const char *list_iterator = argv[0];
524   const char *p2;
525   int doneany =0;
526   unsigned int len=0;
527
528   int is_suffix = streq (funcname, "suffix");
529   int is_notdir = !is_suffix;
530   while ((p2 = find_next_token (&list_iterator, &len)) != 0)
531     {
532       const char *p = p2 + len;
533
534
535       while (p >= p2 && (!is_suffix || *p != '.'))
536         {
537           if (IS_PATHSEP (*p))
538             break;
539           --p;
540         }
541
542       if (p >= p2)
543         {
544           if (is_notdir)
545             ++p;
546           else if (*p != '.')
547             continue;
548           o = variable_buffer_output (o, p, len - (p - p2));
549         }
550 #ifdef HAVE_DOS_PATHS
551       /* Handle the case of "d:foo/bar".  */
552       else if (streq (funcname, "notdir") && p2[0] && p2[1] == ':')
553         {
554           p = p2 + 2;
555           o = variable_buffer_output (o, p, len - (p - p2));
556         }
557 #endif
558       else if (is_notdir)
559         o = variable_buffer_output (o, p2, len);
560
561       if (is_notdir || p >= p2)
562         {
563           o = variable_buffer_output (o, " ", 1);
564           doneany = 1;
565         }
566     }
567
568   if (doneany)
569     /* Kill last space.  */
570     --o;
571
572   return o;
573 }
574
575
576 static char *
577 func_basename_dir (char *o, char **argv, const char *funcname)
578 {
579   /* Expand the argument.  */
580   const char *p3 = argv[0];
581   const char *p2;
582   int doneany=0;
583   unsigned int len=0;
584
585   int is_basename= streq (funcname, "basename");
586   int is_dir= !is_basename;
587
588   while ((p2 = find_next_token (&p3, &len)) != 0)
589     {
590       const char *p = p2 + len;
591       while (p >= p2 && (!is_basename  || *p != '.'))
592         {
593           if (IS_PATHSEP (*p))
594             break;
595           --p;
596         }
597
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);
620
621       o = variable_buffer_output (o, " ", 1);
622       doneany = 1;
623     }
624
625   if (doneany)
626     /* Kill last space.  */
627     --o;
628
629   return o;
630 }
631
632 static char *
633 func_addsuffix_addprefix (char *o, char **argv, const char *funcname)
634 {
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;
639
640   int doneany = 0;
641   const char *p;
642   unsigned int len;
643
644   while ((p = find_next_token (&list_iterator, &len)) != 0)
645     {
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;
653     }
654
655   if (doneany)
656     /* Kill last space.  */
657     --o;
658
659   return o;
660 }
661
662 static char *
663 func_subst (char *o, char **argv, const char *funcname UNUSED)
664 {
665   o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]),
666                     strlen (argv[1]), 0);
667
668   return o;
669 }
670
671
672 static char *
673 func_firstword (char *o, char **argv, const char *funcname UNUSED)
674 {
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);
678
679   if (p != 0)
680     o = variable_buffer_output (o, p, i);
681
682   return o;
683 }
684
685 static char *
686 func_lastword (char *o, char **argv, const char *funcname UNUSED)
687 {
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;
692
693   while ((t = find_next_token (&words, &i)))
694     p = t;
695
696   if (p != 0)
697     o = variable_buffer_output (o, p, i);
698
699   return o;
700 }
701
702 static char *
703 func_words (char *o, char **argv, const char *funcname UNUSED)
704 {
705   int i = 0;
706   const char *word_iterator = argv[0];
707   char buf[20];
708
709   while (find_next_token (&word_iterator, NULL) != 0)
710     ++i;
711
712   sprintf (buf, "%d", i);
713   o = variable_buffer_output (o, buf, strlen (buf));
714
715   return o;
716 }
717
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.
722  */
723 char *
724 strip_whitespace (const char **begpp, const char **endpp)
725 {
726   while (*begpp <= *endpp && isspace ((unsigned char)**begpp))
727     (*begpp) ++;
728   while (*endpp >= *begpp && isspace ((unsigned char)**endpp))
729     (*endpp) --;
730   return (char *)*begpp;
731 }
732
733 static void
734 check_numeric (const char *s, const char *msg)
735 {
736   const char *end = s + strlen (s) - 1;
737   const char *beg = s;
738   strip_whitespace (&s, &end);
739
740   for (; s <= end; ++s)
741     if (!ISDIGIT (*s))  /* ISDIGIT only evals its arg once: see make.h.  */
742       break;
743
744   if (s <= end || end - beg < 0)
745     fatal (*expanding_var, "%s: '%s'", msg, beg);
746 }
747
748
749
750 static char *
751 func_word (char *o, char **argv, const char *funcname UNUSED)
752 {
753   const char *end_p;
754   const char *p;
755   int i;
756
757   /* Check the first argument.  */
758   check_numeric (argv[0], _("non-numeric first argument to `word' function"));
759   i = atoi (argv[0]);
760
761   if (i == 0)
762     fatal (*expanding_var,
763            _("first argument to `word' function must be greater than 0"));
764
765   end_p = argv[1];
766   while ((p = find_next_token (&end_p, 0)) != 0)
767     if (--i == 0)
768       break;
769
770   if (i == 0)
771     o = variable_buffer_output (o, p, end_p - p);
772
773   return o;
774 }
775
776 static char *
777 func_wordlist (char *o, char **argv, const char *funcname UNUSED)
778 {
779   int start, count;
780
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"));
786
787   start = atoi (argv[0]);
788   if (start < 1)
789     fatal (*expanding_var,
790            "invalid first argument to `wordlist' function: `%d'", start);
791
792   count = atoi (argv[1]) - start + 1;
793
794   if (count > 0)
795     {
796       const char *p;
797       const char *end_p = argv[2];
798
799       /* Find the beginning of the "start"th word.  */
800       while (((p = find_next_token (&end_p, 0)) != 0) && --start)
801         ;
802
803       if (p)
804         {
805           /* Find the end of the "count"th word from start.  */
806           while (--count && (find_next_token (&end_p, 0) != 0))
807             ;
808
809           /* Return the stuff in the middle.  */
810           o = variable_buffer_output (o, p, end_p - p);
811         }
812     }
813
814   return o;
815 }
816
817 static char *
818 func_findstring (char *o, char **argv, const char *funcname UNUSED)
819 {
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]));
823
824   return o;
825 }
826
827 static char *
828 func_foreach (char *o, char **argv, const char *funcname UNUSED)
829 {
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];
834
835   int doneany = 0;
836   const char *list_iterator = list;
837   const char *p;
838   unsigned int len;
839   struct variable *var;
840
841   push_new_variable_scope ();
842   var = define_variable (varname, strlen (varname), "", o_automatic, 0);
843
844   /* loop through LIST,  put the value in VAR and expand BODY */
845   while ((p = find_next_token (&list_iterator, &len)) != 0)
846     {
847       char *result = 0;
848
849       free (var->value);
850       var->value = xstrndup (p, len);
851
852       result = allocated_variable_expand (body);
853
854       o = variable_buffer_output (o, result, strlen (result));
855       o = variable_buffer_output (o, " ", 1);
856       doneany = 1;
857       free (result);
858     }
859
860   if (doneany)
861     /* Kill the last space.  */
862     --o;
863
864   pop_variable_scope ();
865   free (varname);
866   free (list);
867
868   return o;
869 }
870
871 struct a_word
872 {
873   struct a_word *next;
874   struct a_word *chain;
875   char *str;
876   int length;
877   int matched;
878 };
879
880 static unsigned long
881 a_word_hash_1 (const void *key)
882 {
883   return_STRING_HASH_1 (((struct a_word const *) key)->str);
884 }
885
886 static unsigned long
887 a_word_hash_2 (const void *key)
888 {
889   return_STRING_HASH_2 (((struct a_word const *) key)->str);
890 }
891
892 static int
893 a_word_hash_cmp (const void *x, const void *y)
894 {
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);
900 }
901
902 struct a_pattern
903 {
904   struct a_pattern *next;
905   char *str;
906   char *percent;
907   int length;
908   int save_c;
909 };
910
911 static char *
912 func_filter_filterout (char *o, char **argv, const char *funcname)
913 {
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;
920
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;
930
931   /* Chop ARGV[0] up into patterns to match against the words.  */
932
933   pattail = &pathead;
934   while ((p = find_next_token (&pat_iterator, &len)) != 0)
935     {
936       struct a_pattern *pat = alloca (sizeof (struct a_pattern));
937
938       *pattail = pat;
939       pattail = &pat->next;
940
941       if (*pat_iterator != '\0')
942         ++pat_iterator;
943
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++;
951     }
952   *pattail = 0;
953
954   /* Chop ARGV[1] up into words to match against the patterns.  */
955
956   wordtail = &wordhead;
957   while ((p = find_next_token (&word_iterator, &len)) != 0)
958     {
959       struct a_word *word = alloca (sizeof (struct a_word));
960
961       *wordtail = word;
962       wordtail = &word->next;
963
964       if (*word_iterator != '\0')
965         ++word_iterator;
966
967       p[len] = '\0';
968       word->str = p;
969       word->length = len;
970       word->matched = 0;
971       word->chain = 0;
972       words++;
973     }
974   *wordtail = 0;
975
976   /* Only use a hash table if arg list lengths justifies the cost.  */
977   hashing = (literals >= 2 && (literals * words) >= 10);
978   if (hashing)
979     {
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)
983         {
984           struct a_word *owp = hash_insert (&a_word_table, wp);
985           if (owp)
986             wp->chain = owp;
987         }
988     }
989
990   if (words)
991     {
992       int doneany = 0;
993
994       /* Run each pattern through the words, killing words.  */
995       for (pp = pathead; pp != 0; pp = pp->next)
996         {
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)
1001             {
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)
1007                 {
1008                   wp->matched |= 1;
1009                   wp = wp->chain;
1010                 }
1011             }
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));
1016         }
1017
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)
1021           {
1022             o = variable_buffer_output (o, wp->str, strlen (wp->str));
1023             o = variable_buffer_output (o, " ", 1);
1024             doneany = 1;
1025           }
1026
1027       if (doneany)
1028         /* Kill the last space.  */
1029         --o;
1030     }
1031
1032   for (pp = pathead; pp != 0; pp = pp->next)
1033     pp->str[pp->length] = pp->save_c;
1034
1035   if (hashing)
1036     hash_free (&a_word_table, 0);
1037
1038   return o;
1039 }
1040
1041
1042 static char *
1043 func_strip (char *o, char **argv, const char *funcname UNUSED)
1044 {
1045   const char *p = argv[0];
1046   int doneany = 0;
1047
1048   while (*p != '\0')
1049     {
1050       int i=0;
1051       const char *word_start;
1052
1053       while (isspace ((unsigned char)*p))
1054         ++p;
1055       word_start = p;
1056       for (i=0; *p != '\0' && !isspace ((unsigned char)*p); ++p, ++i)
1057         {}
1058       if (!i)
1059         break;
1060       o = variable_buffer_output (o, word_start, i);
1061       o = variable_buffer_output (o, " ", 1);
1062       doneany = 1;
1063     }
1064
1065   if (doneany)
1066     /* Kill the last space.  */
1067     --o;
1068
1069   return o;
1070 }
1071
1072 /*
1073   Print a warning or fatal message.
1074 */
1075 static char *
1076 func_error (char *o, char **argv, const char *funcname)
1077 {
1078   char **argvp;
1079   char *msg, *p;
1080   int len;
1081
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;
1087
1088   p = msg = alloca (len + 1);
1089
1090   for (argvp=argv; argvp[1] != 0; ++argvp)
1091     {
1092       strcpy (p, *argvp);
1093       p += strlen (*argvp);
1094       *(p++) = ',';
1095       *(p++) = ' ';
1096     }
1097   strcpy (p, *argvp);
1098
1099   switch (*funcname) {
1100     case 'e':
1101       fatal (reading_file, "%s", msg);
1102
1103     case 'w':
1104       error (reading_file, "%s", msg);
1105       break;
1106
1107     case 'i':
1108       printf ("%s\n", msg);
1109       fflush(stdout);
1110       break;
1111
1112     default:
1113       fatal (*expanding_var, "Internal error: func_error: '%s'", funcname);
1114   }
1115
1116   /* The warning function expands to the empty string.  */
1117   return o;
1118 }
1119
1120
1121 /*
1122   chop argv[0] into words, and sort them.
1123  */
1124 static char *
1125 func_sort (char *o, char **argv, const char *funcname UNUSED)
1126 {
1127   const char *t;
1128   char **words;
1129   int wordi;
1130   char *p;
1131   unsigned int len;
1132   int i;
1133
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)
1138     {
1139       ++t;
1140       ++wordi;
1141     }
1142
1143   words = xmalloc ((wordi == 0 ? 1 : wordi) * sizeof (char *));
1144
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)
1149     {
1150       ++t;
1151       p[len] = '\0';
1152       words[wordi++] = p;
1153     }
1154
1155   if (wordi)
1156     {
1157       /* Now sort the list of words.  */
1158       qsort (words, wordi, sizeof (char *), alpha_compare);
1159
1160       /* Now write the sorted list, uniquified.  */
1161       for (i = 0; i < wordi; ++i)
1162         {
1163           len = strlen (words[i]);
1164           if (i == wordi - 1 || strlen (words[i + 1]) != len
1165               || strcmp (words[i], words[i + 1]))
1166             {
1167               o = variable_buffer_output (o, words[i], len);
1168               o = variable_buffer_output (o, " ", 1);
1169             }
1170         }
1171
1172       /* Kill the last space.  */
1173       --o;
1174     }
1175
1176   free (words);
1177
1178   return o;
1179 }
1180
1181 /*
1182   $(if condition,true-part[,false-part])
1183
1184   CONDITION is false iff it evaluates to an empty string.  White
1185   space before and after condition are stripped before evaluation.
1186
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).
1191 */
1192
1193 static char *
1194 func_if (char *o, char **argv, const char *funcname UNUSED)
1195 {
1196   const char *begp = argv[0];
1197   const char *endp = begp + strlen (argv[0]) - 1;
1198   int result = 0;
1199
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.  */
1203
1204   strip_whitespace (&begp, &endp);
1205
1206   if (begp <= endp)
1207     {
1208       char *expansion = expand_argument (begp, endp+1);
1209
1210       result = strlen (expansion);
1211       free (expansion);
1212     }
1213
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.  */
1217
1218   argv += 1 + !result;
1219
1220   if (*argv)
1221     {
1222       char *expansion = expand_argument (*argv, NULL);
1223
1224       o = variable_buffer_output (o, expansion, strlen (expansion));
1225
1226       free (expansion);
1227     }
1228
1229   return o;
1230 }
1231
1232 /*
1233   $(or condition1[,condition2[,condition3[...]]])
1234
1235   A CONDITION is false iff it evaluates to an empty string.  White
1236   space before and after CONDITION are stripped before evaluation.
1237
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.
1241
1242   Once a CONDITION is true no further conditions are evaluated
1243   (short-circuiting).
1244 */
1245
1246 static char *
1247 func_or (char *o, char **argv, const char *funcname UNUSED)
1248 {
1249   for ( ; *argv ; ++argv)
1250     {
1251       const char *begp = *argv;
1252       const char *endp = begp + strlen (*argv) - 1;
1253       char *expansion;
1254       int result = 0;
1255
1256       /* Find the result of the condition: if it's false keep going.  */
1257
1258       strip_whitespace (&begp, &endp);
1259
1260       if (begp > endp)
1261         continue;
1262
1263       expansion = expand_argument (begp, endp+1);
1264       result = strlen (expansion);
1265
1266       /* If the result is false keep going.  */
1267       if (!result)
1268         {
1269           free (expansion);
1270           continue;
1271         }
1272
1273       /* It's true!  Keep this result and return.  */
1274       o = variable_buffer_output (o, expansion, result);
1275       free (expansion);
1276       break;
1277     }
1278
1279   return o;
1280 }
1281
1282 /*
1283   $(and condition1[,condition2[,condition3[...]]])
1284
1285   A CONDITION is false iff it evaluates to an empty string.  White
1286   space before and after CONDITION are stripped before evaluation.
1287
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.
1291
1292   Once a CONDITION is false no further conditions are evaluated
1293   (short-circuiting).
1294 */
1295
1296 static char *
1297 func_and (char *o, char **argv, const char *funcname UNUSED)
1298 {
1299   char *expansion;
1300   int result;
1301
1302   while (1)
1303     {
1304       const char *begp = *argv;
1305       const char *endp = begp + strlen (*argv) - 1;
1306
1307       /* An empty condition is always false.  */
1308       strip_whitespace (&begp, &endp);
1309       if (begp > endp)
1310         return o;
1311
1312       expansion = expand_argument (begp, endp+1);
1313       result = strlen (expansion);
1314
1315       /* If the result is false, stop here: we're done.  */
1316       if (!result)
1317         break;
1318
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!  */
1321
1322       if (*(++argv))
1323         free (expansion);
1324       else
1325         {
1326           o = variable_buffer_output (o, expansion, result);
1327           break;
1328         }
1329     }
1330
1331   free (expansion);
1332
1333   return o;
1334 }
1335
1336 static char *
1337 func_wildcard (char *o, char **argv, const char *funcname UNUSED)
1338 {
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;
1346 }
1347
1348 /*
1349   $(eval <makefile string>)
1350
1351   Always resolves to the empty string.
1352
1353   Treat the arguments as a segment of makefile, and parse them.
1354 */
1355
1356 static char *
1357 func_eval (char *o, char **argv, const char *funcname UNUSED)
1358 {
1359   char *buf;
1360   unsigned int len;
1361
1362   /* Eval the buffer.  Pop the current variable buffer setting so that the
1363      eval'd code can use its own without conflicting.  */
1364
1365   install_variable_buffer (&buf, &len);
1366
1367   eval_buffer (argv[0]);
1368
1369   restore_variable_buffer (buf, len);
1370
1371   return o;
1372 }
1373
1374
1375 static char *
1376 func_value (char *o, char **argv, const char *funcname UNUSED)
1377 {
1378   /* Look up the variable.  */
1379   struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
1380
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));
1384
1385   return o;
1386 }
1387
1388 /*
1389   \r is replaced on UNIX as well. Is this desirable?
1390  */
1391 static void
1392 fold_newlines (char *buffer, unsigned int *length, int trim_newlines)
1393 {
1394   char *dst = buffer;
1395   char *src = buffer;
1396   char *last_nonnl = buffer - 1;
1397   src[*length] = 0;
1398   for (; *src != '\0'; ++src)
1399     {
1400       if (src[0] == '\r' && src[1] == '\n')
1401         continue;
1402       if (*src == '\n')
1403         {
1404           *dst++ = ' ';
1405         }
1406       else
1407         {
1408           last_nonnl = dst;
1409           *dst++ = *src;
1410         }
1411     }
1412
1413   if (!trim_newlines && (last_nonnl < (dst - 2)))
1414     last_nonnl = dst - 2;
1415
1416   *(++last_nonnl) = '\0';
1417   *length = last_nonnl - buffer;
1418 }
1419
1420
1421
1422 int shell_function_pid = 0, shell_function_completed;
1423
1424
1425 #ifdef WINDOWS32
1426 /*untested*/
1427
1428 #include <windows.h>
1429 #include <io.h>
1430 #include "sub_proc.h"
1431
1432
1433 void
1434 windows32_openpipe (int *pipedes, pid_t *pid_p, char **command_argv, char **envp)
1435 {
1436   SECURITY_ATTRIBUTES saAttr;
1437   HANDLE hIn;
1438   HANDLE hErr;
1439   HANDLE hChildOutRd;
1440   HANDLE hChildOutWr;
1441   HANDLE hProcess;
1442
1443
1444   saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
1445   saAttr.bInheritHandle = TRUE;
1446   saAttr.lpSecurityDescriptor = NULL;
1447
1448   if (DuplicateHandle (GetCurrentProcess(),
1449                       GetStdHandle(STD_INPUT_HANDLE),
1450                       GetCurrentProcess(),
1451                       &hIn,
1452                       0,
1453                       TRUE,
1454                       DUPLICATE_SAME_ACCESS) == FALSE) {
1455     fatal (NILF, _("windows32_openpipe(): DuplicateHandle(In) failed (e=%ld)\n"),
1456            GetLastError());
1457
1458   }
1459   if (DuplicateHandle(GetCurrentProcess(),
1460                       GetStdHandle(STD_ERROR_HANDLE),
1461                       GetCurrentProcess(),
1462                       &hErr,
1463                       0,
1464                       TRUE,
1465                       DUPLICATE_SAME_ACCESS) == FALSE) {
1466     fatal (NILF, _("windows32_open_pipe(): DuplicateHandle(Err) failed (e=%ld)\n"),
1467            GetLastError());
1468   }
1469
1470   if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0))
1471     fatal (NILF, _("CreatePipe() failed (e=%ld)\n"), GetLastError());
1472
1473   hProcess = process_init_fd(hIn, hChildOutWr, hErr);
1474
1475   if (!hProcess)
1476     fatal (NILF, _("windows32_openpipe(): process_init_fd() failed\n"));
1477
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;
1483
1484   if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL)) {
1485     /* register process for wait */
1486     process_register(hProcess);
1487
1488     /* set the pid for returning to caller */
1489     *pid_p = (pid_t) hProcess;
1490
1491   /* set up to read data from child */
1492   pipedes[0] = _open_osfhandle((intptr_t) hChildOutRd, O_RDONLY);
1493
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);
1499
1500     /* close handles which were duplicated, they weren't used */
1501         CloseHandle(hIn);
1502         CloseHandle(hErr);
1503
1504         /* close pipe handles, they won't be used */
1505         CloseHandle(hChildOutRd);
1506         CloseHandle(hChildOutWr);
1507
1508     /* set status for return */
1509     pipedes[0] = pipedes[1] = -1;
1510     *pid_p = (pid_t)-1;
1511   }
1512 }
1513 #endif
1514
1515
1516 #ifdef __MSDOS__
1517 FILE *
1518 msdos_openpipe (int* pipedes, int *pidp, char *text)
1519 {
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;
1525
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;
1531
1532   if (sh)
1533     {
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);
1539     }
1540
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)
1551     {
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;
1559     }
1560   else
1561     {
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;
1566     }
1567   return fpipe;
1568 }
1569 #endif
1570
1571 /*
1572   Do shell spawning, with the naughty bits for different OSes.
1573  */
1574
1575 #ifdef VMS
1576
1577 /* VMS can't do $(shell ...)  */
1578
1579 char *
1580 func_shell_base (char *o, char **argv, int trim_newlines)
1581 {
1582   fprintf (stderr, "This platform does not support shell\n");
1583   die (EXIT_FAILURE);
1584 }
1585
1586 #define func_shell 0
1587
1588 #else
1589 #ifndef _AMIGA
1590 char *
1591 func_shell_base (char *o, char **argv, int trim_newlines)
1592 {
1593   char *batch_filename = NULL;
1594
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;
1603
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;
1610
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)
1617     {
1618 #ifdef WINDOWS32
1619       just_print_flag = j_p_f;
1620 #endif
1621       return o;
1622     }
1623 #endif
1624
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.
1631
1632      See Savannah bug #10593.
1633
1634   envp = target_environment (NILF);
1635   */
1636
1637   envp = environ;
1638
1639   /* For error messages.  */
1640   if (reading_file && reading_file->filenm)
1641     {
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;
1645     }
1646   else
1647     error_prefix = "";
1648
1649 #if defined(__MSDOS__)
1650   fpipe = msdos_openpipe (pipedes, &pid, argv[0]);
1651   if (pipedes[0] < 0)
1652     {
1653       perror_with_name (error_prefix, "pipe");
1654       return o;
1655     }
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;
1660
1661   if (pipedes[0] < 0)
1662     {
1663       /* Open of the pipe failed, mark as failed execution.  */
1664       shell_function_completed = -1;
1665       return o;
1666     }
1667   else
1668 #else
1669   if (pipe (pipedes) < 0)
1670     {
1671       perror_with_name (error_prefix, "pipe");
1672       return o;
1673     }
1674
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
1692     {
1693       /* We are the parent.  */
1694       char *buffer;
1695       unsigned int maxlen, i;
1696       int cc;
1697
1698       /* Record the PID for reap_children.  */
1699       shell_function_pid = pid;
1700 #ifndef  __MSDOS__
1701       shell_function_completed = 0;
1702
1703       /* Free the storage only the child needed.  */
1704       free (command_argv[0]);
1705       free (command_argv);
1706
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
1713
1714       /* Set up and read from the pipe.  */
1715
1716       maxlen = 200;
1717       buffer = xmalloc (maxlen + 1);
1718
1719       /* Read from the pipe until it gets EOF.  */
1720       for (i = 0; ; i += cc)
1721         {
1722           if (i == maxlen)
1723             {
1724               maxlen += 512;
1725               buffer = xrealloc (buffer, maxlen + 1);
1726             }
1727
1728           EINTRLOOP (cc, read (pipedes[0], &buffer[i], maxlen - i));
1729           if (cc <= 0)
1730             break;
1731         }
1732       buffer[i] = '\0';
1733
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
1741
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);
1746
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);
1752       }
1753       shell_function_pid = 0;
1754
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.  */
1758
1759       if (shell_function_completed == -1)
1760         {
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);
1765         }
1766       else
1767         {
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);
1772         }
1773
1774       free (buffer);
1775     }
1776
1777   return o;
1778 }
1779
1780 #else   /* _AMIGA */
1781
1782 /* Do the Amiga version of func_shell.  */
1783
1784 char *
1785 func_shell_base (char *o, char **argv, int trim_newlines)
1786 {
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.  */
1795
1796 #include <dos/dos.h>
1797 #include <proto/dos.h>
1798
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;
1807
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;
1813
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);
1821
1822   for (aptr=command_argv; *aptr; aptr++)
1823     len += strlen (*aptr) + 1;
1824
1825   buffer = xmalloc (len + 1);
1826   ptr = buffer;
1827
1828   for (aptr=command_argv; *aptr; aptr++)
1829     {
1830       strcpy (ptr, *aptr);
1831       ptr += strlen (ptr) + 1;
1832       *ptr ++ = ' ';
1833       *ptr = 0;
1834     }
1835
1836   ptr[-1] = '\n';
1837
1838   Execute (buffer, NULL, child_stdout);
1839   free (buffer);
1840
1841   Close (child_stdout);
1842
1843   child_stdout = Open (tmp_output, MODE_OLDFILE);
1844
1845   buffer = xmalloc (maxlen);
1846   i = 0;
1847   do
1848     {
1849       if (i == maxlen)
1850         {
1851           maxlen += 512;
1852           buffer = xrealloc (buffer, maxlen + 1);
1853         }
1854
1855       cc = Read (child_stdout, &buffer[i], maxlen - i);
1856       if (cc > 0)
1857         i += cc;
1858     } while (cc > 0);
1859
1860   Close (child_stdout);
1861
1862   fold_newlines (buffer, &i, trim_newlines);
1863   o = variable_buffer_output (o, buffer, i);
1864   free (buffer);
1865   return o;
1866 }
1867 #endif  /* _AMIGA */
1868
1869 char *
1870 func_shell (char *o, char **argv, const char *funcname UNUSED)
1871 {
1872   return func_shell_base (o, argv, 1);
1873 }
1874 #endif  /* !VMS */
1875
1876 #ifdef EXPERIMENTAL
1877
1878 /*
1879   equality. Return is string-boolean, ie, the empty string is false.
1880  */
1881 static char *
1882 func_eq (char *o, char **argv, char *funcname)
1883 {
1884   int result = ! strcmp (argv[0], argv[1]);
1885   o = variable_buffer_output (o,  result ? "1" : "", result);
1886   return o;
1887 }
1888
1889
1890 /*
1891   string-boolean not operator.
1892  */
1893 static char *
1894 func_not (char *o, char **argv, char *funcname)
1895 {
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;
1903 }
1904 #endif
1905 \f
1906
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
1914
1915 /* Return the absolute name of file NAME which does not contain any `.',
1916    `..' components nor any repeated path separators ('/').   */
1917
1918 static char *
1919 abspath (const char *name, char *apath)
1920 {
1921   char *dest;
1922   const char *start, *end, *apath_limit;
1923   unsigned long root_len = ROOT_LEN;
1924
1925   if (name[0] == '\0' || apath == NULL)
1926     return NULL;
1927
1928   apath_limit = apath + GET_PATH_MAX;
1929
1930   if (!IS_ABSOLUTE(name))
1931     {
1932       /* It is unlikely we would make it until here but just to make sure. */
1933       if (!starting_directory)
1934         return NULL;
1935
1936       strcpy (apath, starting_directory);
1937
1938 #ifdef HAVE_DOS_PATHS
1939       if (IS_PATHSEP(name[0]))
1940         {
1941           if (IS_PATHSEP(name[1]))
1942             {
1943               /* A UNC.  Don't prepend a drive letter.  */
1944               apath[0] = name[0];
1945               apath[1] = name[1];
1946               root_len = 2;
1947             }
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';
1953         }
1954 #endif
1955
1956       dest = strchr (apath, '\0');
1957     }
1958   else
1959     {
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]))
1967         {
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--;
1975         }
1976       else
1977         apath[2] = '/'; /* make sure it's a forward slash */
1978 #endif
1979     }
1980
1981   for (start = end = name; *start != '\0'; start = end)
1982     {
1983       unsigned long len;
1984
1985       /* Skip sequence of multiple path-separators.  */
1986       while (IS_PATHSEP(*start))
1987         ++start;
1988
1989       /* Find end of path component.  */
1990       for (end = start; *end != '\0' && !IS_PATHSEP(*end); ++end)
1991         ;
1992
1993       len = end - start;
1994
1995       if (len == 0)
1996         break;
1997       else if (len == 1 && start[0] == '.')
1998         /* nothing */;
1999       else if (len == 2 && start[0] == '.' && start[1] == '.')
2000         {
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);
2004         }
2005       else
2006         {
2007           if (!IS_PATHSEP(dest[-1]))
2008             *dest++ = '/';
2009
2010           if (dest + len >= apath_limit)
2011             return NULL;
2012
2013           dest = memcpy (dest, start, len);
2014           dest += len;
2015           *dest = '\0';
2016         }
2017     }
2018
2019   /* Unless it is root strip trailing separator.  */
2020   if (dest > apath + root_len && IS_PATHSEP(dest[-1]))
2021     --dest;
2022
2023   *dest = '\0';
2024
2025   return apath;
2026 }
2027
2028
2029 static char *
2030 func_realpath (char *o, char **argv, const char *funcname UNUSED)
2031 {
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);
2042
2043   while ((path = find_next_token (&p, &len)) != 0)
2044     {
2045       if (len < GET_PATH_MAX)
2046         {
2047           strncpy (in, path, len);
2048           in[len] = '\0';
2049
2050           if (
2051 #ifdef HAVE_REALPATH
2052               realpath (in, out)
2053 #else
2054               abspath (in, out) && stat (out, &st) == 0
2055 #endif
2056              )
2057             {
2058               o = variable_buffer_output (o, out, strlen (out));
2059               o = variable_buffer_output (o, " ", 1);
2060               doneany = 1;
2061             }
2062         }
2063     }
2064
2065   /* Kill last space.  */
2066   if (doneany)
2067     --o;
2068
2069   return o;
2070 }
2071
2072 static char *
2073 func_abspath (char *o, char **argv, const char *funcname UNUSED)
2074 {
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);
2082
2083   while ((path = find_next_token (&p, &len)) != 0)
2084     {
2085       if (len < GET_PATH_MAX)
2086         {
2087           strncpy (in, path, len);
2088           in[len] = '\0';
2089
2090           if (abspath (in, out))
2091             {
2092               o = variable_buffer_output (o, out, strlen (out));
2093               o = variable_buffer_output (o, " ", 1);
2094               doneany = 1;
2095             }
2096         }
2097     }
2098
2099   /* Kill last space.  */
2100   if (doneany)
2101     --o;
2102
2103   return o;
2104 }
2105
2106 #ifdef HAVE_GUILE
2107 static char *
2108 func_guile (char *o, char **argv, const char *funcname UNUSED)
2109 {
2110   if (argv[0] && argv[0][0] != '\0')
2111     {
2112       char *str = guile_eval_string (argv[0]);
2113       o = variable_buffer_output (o, str, strlen (str));
2114       free (str);
2115     }
2116
2117   return o;
2118 }
2119 #endif
2120
2121 /* Lookup table for builtin functions.
2122
2123    This doesn't have to be sorted; we use a straight lookup.  We might gain
2124    some efficiency by moving most often used functions to the start of the
2125    table.
2126
2127    If MAXIMUM_ARGS is 0, that means there is no maximum and all
2128    comma-separated values are treated as arguments.
2129
2130    EXPAND_ARGS means that all arguments should be expanded before invocation.
2131    Functions that do namespace tricks (foreach) don't automatically expand.  */
2132
2133 static char *func_call (char *o, char **argv, const char *funcname);
2134
2135
2136 static struct function_table_entry function_table_init[] =
2137 {
2138  /* Name/size */                    /* MIN MAX EXP? Function */
2139   { STRING_SIZE_TUPLE("abspath"),       0,  1,  1,  func_abspath},
2140   { STRING_SIZE_TUPLE("addprefix"),     2,  2,  1,  func_addsuffix_addprefix},
2141   { STRING_SIZE_TUPLE("addsuffix"),     2,  2,  1,  func_addsuffix_addprefix},
2142   { STRING_SIZE_TUPLE("basename"),      0,  1,  1,  func_basename_dir},
2143   { STRING_SIZE_TUPLE("dir"),           0,  1,  1,  func_basename_dir},
2144   { STRING_SIZE_TUPLE("notdir"),        0,  1,  1,  func_notdir_suffix},
2145   { STRING_SIZE_TUPLE("subst"),         3,  3,  1,  func_subst},
2146   { STRING_SIZE_TUPLE("suffix"),        0,  1,  1,  func_notdir_suffix},
2147   { STRING_SIZE_TUPLE("filter"),        2,  2,  1,  func_filter_filterout},
2148   { STRING_SIZE_TUPLE("filter-out"),    2,  2,  1,  func_filter_filterout},
2149   { STRING_SIZE_TUPLE("findstring"),    2,  2,  1,  func_findstring},
2150   { STRING_SIZE_TUPLE("firstword"),     0,  1,  1,  func_firstword},
2151   { STRING_SIZE_TUPLE("flavor"),        0,  1,  1,  func_flavor},
2152   { STRING_SIZE_TUPLE("join"),          2,  2,  1,  func_join},
2153   { STRING_SIZE_TUPLE("lastword"),      0,  1,  1,  func_lastword},
2154   { STRING_SIZE_TUPLE("patsubst"),      3,  3,  1,  func_patsubst},
2155   { STRING_SIZE_TUPLE("realpath"),      0,  1,  1,  func_realpath},
2156   { STRING_SIZE_TUPLE("shell"),         0,  1,  1,  func_shell},
2157   { STRING_SIZE_TUPLE("sort"),          0,  1,  1,  func_sort},
2158   { STRING_SIZE_TUPLE("strip"),         0,  1,  1,  func_strip},
2159   { STRING_SIZE_TUPLE("wildcard"),      0,  1,  1,  func_wildcard},
2160   { STRING_SIZE_TUPLE("word"),          2,  2,  1,  func_word},
2161   { STRING_SIZE_TUPLE("wordlist"),      3,  3,  1,  func_wordlist},
2162   { STRING_SIZE_TUPLE("words"),         0,  1,  1,  func_words},
2163   { STRING_SIZE_TUPLE("origin"),        0,  1,  1,  func_origin},
2164   { STRING_SIZE_TUPLE("foreach"),       3,  3,  0,  func_foreach},
2165   { STRING_SIZE_TUPLE("call"),          1,  0,  1,  func_call},
2166   { STRING_SIZE_TUPLE("info"),          0,  1,  1,  func_error},
2167   { STRING_SIZE_TUPLE("error"),         0,  1,  1,  func_error},
2168   { STRING_SIZE_TUPLE("warning"),       0,  1,  1,  func_error},
2169   { STRING_SIZE_TUPLE("if"),            2,  3,  0,  func_if},
2170   { STRING_SIZE_TUPLE("or"),            1,  0,  0,  func_or},
2171   { STRING_SIZE_TUPLE("and"),           1,  0,  0,  func_and},
2172   { STRING_SIZE_TUPLE("value"),         0,  1,  1,  func_value},
2173   { STRING_SIZE_TUPLE("eval"),          0,  1,  1,  func_eval},
2174 #ifdef HAVE_GUILE
2175   { STRING_SIZE_TUPLE("guile"),         0,  1,  1,  func_guile},
2176 #endif
2177 #ifdef EXPERIMENTAL
2178   { STRING_SIZE_TUPLE("eq"),            2,  2,  1,  func_eq},
2179   { STRING_SIZE_TUPLE("not"),           0,  1,  1,  func_not},
2180 #endif
2181 };
2182
2183 #define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry))
2184 \f
2185
2186 /* These must come after the definition of function_table.  */
2187
2188 static char *
2189 expand_builtin_function (char *o, int argc, char **argv,
2190                          const struct function_table_entry *entry_p)
2191 {
2192   if (argc < (int)entry_p->minimum_args)
2193     fatal (*expanding_var,
2194            _("insufficient number of arguments (%d) to function `%s'"),
2195            argc, entry_p->name);
2196
2197   /* I suppose technically some function could do something with no
2198      arguments, but so far none do, so just test it for all functions here
2199      rather than in each one.  We can change it later if necessary.  */
2200
2201   if (!argc)
2202     return o;
2203
2204   if (!entry_p->func_ptr)
2205     fatal (*expanding_var,
2206            _("unimplemented on this platform: function `%s'"), entry_p->name);
2207
2208   return entry_p->func_ptr (o, argv, entry_p->name);
2209 }
2210
2211 /* Check for a function invocation in *STRINGP.  *STRINGP points at the
2212    opening ( or { and is not null-terminated.  If a function invocation
2213    is found, expand it into the buffer at *OP, updating *OP, incrementing
2214    *STRINGP past the reference and returning nonzero.  If not, return zero.  */
2215
2216 int
2217 handle_function (char **op, const char **stringp)
2218 {
2219   const struct function_table_entry *entry_p;
2220   char openparen = (*stringp)[0];
2221   char closeparen = openparen == '(' ? ')' : '}';
2222   const char *beg;
2223   const char *end;
2224   int count = 0;
2225   char *abeg = NULL;
2226   char **argv, **argvp;
2227   int nargs;
2228
2229   beg = *stringp + 1;
2230
2231   entry_p = lookup_function (beg);
2232
2233   if (!entry_p)
2234     return 0;
2235
2236   /* We found a builtin function.  Find the beginning of its arguments (skip
2237      whitespace after the name).  */
2238
2239   beg = next_token (beg + entry_p->len);
2240
2241   /* Find the end of the function invocation, counting nested use of
2242      whichever kind of parens we use.  Since we're looking, count commas
2243      to get a rough estimate of how many arguments we might have.  The
2244      count might be high, but it'll never be low.  */
2245
2246   for (nargs=1, end=beg; *end != '\0'; ++end)
2247     if (*end == ',')
2248       ++nargs;
2249     else if (*end == openparen)
2250       ++count;
2251     else if (*end == closeparen && --count < 0)
2252       break;
2253
2254   if (count >= 0)
2255     fatal (*expanding_var,
2256            _("unterminated call to function `%s': missing `%c'"),
2257            entry_p->name, closeparen);
2258
2259   *stringp = end;
2260
2261   /* Get some memory to store the arg pointers.  */
2262   argvp = argv = alloca (sizeof (char *) * (nargs + 2));
2263
2264   /* Chop the string into arguments, then a nul.  As soon as we hit
2265      MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
2266      last argument.
2267
2268      If we're expanding, store pointers to the expansion of each one.  If
2269      not, make a duplicate of the string and point into that, nul-terminating
2270      each argument.  */
2271
2272   if (entry_p->expand_args)
2273     {
2274       const char *p;
2275       for (p=beg, nargs=0; p <= end; ++argvp)
2276         {
2277           const char *next;
2278
2279           ++nargs;
2280
2281           if (nargs == entry_p->maximum_args
2282               || (! (next = find_next_argument (openparen, closeparen, p, end))))
2283             next = end;
2284
2285           *argvp = expand_argument (p, next);
2286           p = next + 1;
2287         }
2288     }
2289   else
2290     {
2291       int len = end - beg;
2292       char *p, *aend;
2293
2294       abeg = xmalloc (len+1);
2295       memcpy (abeg, beg, len);
2296       abeg[len] = '\0';
2297       aend = abeg + len;
2298
2299       for (p=abeg, nargs=0; p <= aend; ++argvp)
2300         {
2301           char *next;
2302
2303           ++nargs;
2304
2305           if (nargs == entry_p->maximum_args
2306               || (! (next = find_next_argument (openparen, closeparen, p, aend))))
2307             next = aend;
2308
2309           *argvp = p;
2310           *next = '\0';
2311           p = next + 1;
2312         }
2313     }
2314   *argvp = NULL;
2315
2316   /* Finally!  Run the function...  */
2317   *op = expand_builtin_function (*op, nargs, argv, entry_p);
2318
2319   /* Free memory.  */
2320   if (entry_p->expand_args)
2321     for (argvp=argv; *argvp != 0; ++argvp)
2322       free (*argvp);
2323   if (abeg)
2324     free (abeg);
2325
2326   return 1;
2327 }
2328 \f
2329
2330 /* User-defined functions.  Expand the first argument as either a builtin
2331    function or a make variable, in the context of the rest of the arguments
2332    assigned to $1, $2, ... $N.  $0 is the name of the function.  */
2333
2334 static char *
2335 func_call (char *o, char **argv, const char *funcname UNUSED)
2336 {
2337   static int max_args = 0;
2338   char *fname;
2339   char *cp;
2340   char *body;
2341   int flen;
2342   int i;
2343   int saved_args;
2344   const struct function_table_entry *entry_p;
2345   struct variable *v;
2346
2347   /* There is no way to define a variable with a space in the name, so strip
2348      leading and trailing whitespace as a favor to the user.  */
2349   fname = argv[0];
2350   while (*fname != '\0' && isspace ((unsigned char)*fname))
2351     ++fname;
2352
2353   cp = fname + strlen (fname) - 1;
2354   while (cp > fname && isspace ((unsigned char)*cp))
2355     --cp;
2356   cp[1] = '\0';
2357
2358   /* Calling nothing is a no-op */
2359   if (*fname == '\0')
2360     return o;
2361
2362   /* Are we invoking a builtin function?  */
2363
2364   entry_p = lookup_function (fname);
2365   if (entry_p)
2366     {
2367       /* How many arguments do we have?  */
2368       for (i=0; argv[i+1]; ++i)
2369         ;
2370       return expand_builtin_function (o, i, argv+1, entry_p);
2371     }
2372
2373   /* Not a builtin, so the first argument is the name of a variable to be
2374      expanded and interpreted as a function.  Find it.  */
2375   flen = strlen (fname);
2376
2377   v = lookup_variable (fname, flen);
2378
2379   if (v == 0)
2380     warn_undefined (fname, flen);
2381
2382   if (v == 0 || *v->value == '\0')
2383     return o;
2384
2385   body = alloca (flen + 4);
2386   body[0] = '$';
2387   body[1] = '(';
2388   memcpy (body + 2, fname, flen);
2389   body[flen+2] = ')';
2390   body[flen+3] = '\0';
2391
2392   /* Set up arguments $(1) .. $(N).  $(0) is the function name.  */
2393
2394   push_new_variable_scope ();
2395
2396   for (i=0; *argv; ++i, ++argv)
2397     {
2398       char num[11];
2399
2400       sprintf (num, "%d", i);
2401       define_variable (num, strlen (num), *argv, o_automatic, 0);
2402     }
2403
2404   /* If the number of arguments we have is < max_args, it means we're inside
2405      a recursive invocation of $(call ...).  Fill in the remaining arguments
2406      in the new scope with the empty value, to hide them from this
2407      invocation.  */
2408
2409   for (; i < max_args; ++i)
2410     {
2411       char num[11];
2412
2413       sprintf (num, "%d", i);
2414       define_variable (num, strlen (num), "", o_automatic, 0);
2415     }
2416
2417   /* Expand the body in the context of the arguments, adding the result to
2418      the variable buffer.  */
2419
2420   v->exp_count = EXP_COUNT_MAX;
2421
2422   saved_args = max_args;
2423   max_args = i;
2424   o = variable_expand_string (o, body, flen+3);
2425   max_args = saved_args;
2426
2427   v->exp_count = 0;
2428
2429   pop_variable_scope ();
2430
2431   return o + strlen (o);
2432 }
2433
2434 void
2435 hash_init_function_table (void)
2436 {
2437   hash_init (&function_table, FUNCTION_TABLE_ENTRIES * 2,
2438              function_table_entry_hash_1, function_table_entry_hash_2,
2439              function_table_entry_hash_cmp);
2440   hash_load (&function_table, function_table_init,
2441              FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));
2442 }