src/function.c

   1 /* Builtin function expansion for GNU Make.
   2 Copyright (C) 1988-2022 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify it under the
   6 terms of the GNU General Public License as published by the Free Software
   7 Foundation; either version 3 of the License, or (at your option) any later
   8 version.
   9
  10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License along with
  15 this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 #include "makeint.h"
  18 #include "filedef.h"
  19 #include "variable.h"
  20 #include "dep.h"
  21 #include "job.h"
  22 #include "os.h"
  23 #include "commands.h"
  24 #include "debug.h"
  25
  26 #ifdef _AMIGA
  27 #include "amiga.h"
  28 #endif
  29
  30
  31 struct function_table_entry
  32   {
  33     union {
  34       char *(*func_ptr) (char *output, char **argv, const char *fname);
  35       gmk_func_ptr alloc_func_ptr;
  36     } fptr;
  37     const char *name;
  38     unsigned char len;
  39     unsigned char minimum_args;
  40     unsigned char maximum_args;
  41     unsigned int expand_args:1;
  42     unsigned int alloc_fn:1;
  43     unsigned int adds_command:1;
  44   };
  45
  46 static unsigned long
  47 function_table_entry_hash_1 (const void *keyv)
  48 {
  49   const struct function_table_entry *key = keyv;
  50   return_STRING_N_HASH_1 (key->name, key->len);
  51 }
  52
  53 static unsigned long
  54 function_table_entry_hash_2 (const void *keyv)
  55 {
  56   const struct function_table_entry *key = keyv;
  57   return_STRING_N_HASH_2 (key->name, key->len);
  58 }
  59
  60 static int
  61 function_table_entry_hash_cmp (const void *xv, const void *yv)
  62 {
  63   const struct function_table_entry *x = xv;
  64   const struct function_table_entry *y = yv;
  65   int result = x->len - y->len;
  66   if (result)
  67     return result;
  68   return_STRING_N_COMPARE (x->name, y->name, x->len);
  69 }
  70
  71 static struct hash_table function_table;
  72 \f
  73
  74 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing
  75    each occurrence of SUBST with REPLACE. TEXT is null-terminated.  SLEN is
  76    the length of SUBST and RLEN is the length of REPLACE.  If BY_WORD is
  77    nonzero, substitutions are done only on matches which are complete
  78    whitespace-delimited words.  */
  79
  80 char *
  81 subst_expand (char *o, const char *text, const char *subst, const char *replace,
  82               size_t slen, size_t rlen, int by_word)
  83 {
  84   const char *t = text;
  85   const char *p;
  86
  87   if (slen == 0 && !by_word)
  88     {
  89       /* The first occurrence of "" in any string is its end.  */
  90       o = variable_buffer_output (o, t, strlen (t));
  91       if (rlen > 0)
  92         o = variable_buffer_output (o, replace, rlen);
  93       return o;
  94     }
  95
  96   do
  97     {
  98       if (by_word && slen == 0)
  99         /* When matching by words, the empty string should match
 100            the end of each word, rather than the end of the whole text.  */
 101         p = end_of_token (next_token (t));
 102       else
 103         {
 104           p = strstr (t, subst);
 105           if (p == 0)
 106             {
 107               /* No more matches.  Output everything left on the end.  */
 108               o = variable_buffer_output (o, t, strlen (t));
 109               return o;
 110             }
 111         }
 112
 113       /* Output everything before this occurrence of the string to replace.  */
 114       if (p > t)
 115         o = variable_buffer_output (o, t, p - t);
 116
 117       /* If we're substituting only by fully matched words,
 118          or only at the ends of words, check that this case qualifies.  */
 119       if (by_word
 120           && ((p > text && !ISSPACE (p[-1]))
 121               || ! STOP_SET (p[slen], MAP_SPACE|MAP_NUL)))
 122         /* Struck out.  Output the rest of the string that is
 123            no longer to be replaced.  */
 124         o = variable_buffer_output (o, subst, slen);
 125       else if (rlen > 0)
 126         /* Output the replacement string.  */
 127         o = variable_buffer_output (o, replace, rlen);
 128
 129       /* Advance T past the string to be replaced.  */
 130       t = p + slen;
 131     } while (*t != '\0');
 132
 133   return o;
 134 }
 135 \f
 136
 137 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT
 138    and replacing strings matching PATTERN with REPLACE.
 139    If PATTERN_PERCENT is not nil, PATTERN has already been
 140    run through find_percent, and PATTERN_PERCENT is the result.
 141    If REPLACE_PERCENT is not nil, REPLACE has already been
 142    run through find_percent, and REPLACE_PERCENT is the result.
 143    Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
 144    character _AFTER_ the %, not to the % itself.
 145 */
 146
 147 char *
 148 patsubst_expand_pat (char *o, const char *text,
 149                      const char *pattern, const char *replace,
 150                      const char *pattern_percent, const char *replace_percent)
 151 {
 152   size_t pattern_prepercent_len, pattern_postpercent_len;
 153   size_t replace_prepercent_len, replace_postpercent_len;
 154   const char *t;
 155   size_t len;
 156   int doneany = 0;
 157
 158   /* Record the length of REPLACE before and after the % so we don't have to
 159      compute these lengths more than once.  */
 160   if (replace_percent)
 161     {
 162       replace_prepercent_len = replace_percent - replace - 1;
 163       replace_postpercent_len = strlen (replace_percent);
 164     }
 165   else
 166     {
 167       replace_prepercent_len = strlen (replace);
 168       replace_postpercent_len = 0;
 169     }
 170
 171   if (!pattern_percent)
 172     /* With no % in the pattern, this is just a simple substitution.  */
 173     return subst_expand (o, text, pattern, replace,
 174                          strlen (pattern), strlen (replace), 1);
 175
 176   /* Record the length of PATTERN before and after the %
 177      so we don't have to compute it more than once.  */
 178   pattern_prepercent_len = pattern_percent - pattern - 1;
 179   pattern_postpercent_len = strlen (pattern_percent);
 180
 181   while ((t = find_next_token (&text, &len)) != 0)
 182     {
 183       int fail = 0;
 184
 185       /* Is it big enough to match?  */
 186       if (len < pattern_prepercent_len + pattern_postpercent_len)
 187         fail = 1;
 188
 189       /* Does the prefix match? */
 190       if (!fail && pattern_prepercent_len > 0
 191           && (*t != *pattern
 192               || t[pattern_prepercent_len - 1] != pattern_percent[-2]
 193               || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1)))
 194         fail = 1;
 195
 196       /* Does the suffix match? */
 197       if (!fail && pattern_postpercent_len > 0
 198           && (t[len - 1] != pattern_percent[pattern_postpercent_len - 1]
 199               || t[len - pattern_postpercent_len] != *pattern_percent
 200               || !strneq (&t[len - pattern_postpercent_len],
 201                           pattern_percent, pattern_postpercent_len - 1)))
 202         fail = 1;
 203
 204       if (fail)
 205         /* It didn't match.  Output the string.  */
 206         o = variable_buffer_output (o, t, len);
 207       else
 208         {
 209           /* It matched.  Output the replacement.  */
 210
 211           /* Output the part of the replacement before the %.  */
 212           o = variable_buffer_output (o, replace, replace_prepercent_len);
 213
 214           if (replace_percent != 0)
 215             {
 216               /* Output the part of the matched string that
 217                  matched the % in the pattern.  */
 218               o = variable_buffer_output (o, t + pattern_prepercent_len,
 219                                           len - (pattern_prepercent_len
 220                                                  + pattern_postpercent_len));
 221               /* Output the part of the replacement after the %.  */
 222               o = variable_buffer_output (o, replace_percent,
 223                                           replace_postpercent_len);
 224             }
 225         }
 226
 227       /* Output a space, but not if the replacement is "".  */
 228       if (fail || replace_prepercent_len > 0
 229           || (replace_percent != 0 && len + replace_postpercent_len > 0))
 230         {
 231           o = variable_buffer_output (o, " ", 1);
 232           doneany = 1;
 233         }
 234     }
 235   if (doneany)
 236     /* Kill the last space.  */
 237     --o;
 238
 239   return o;
 240 }
 241
 242 /* Store into VARIABLE_BUFFER at O the result of scanning TEXT
 243    and replacing strings matching PATTERN with REPLACE.
 244    If PATTERN_PERCENT is not nil, PATTERN has already been
 245    run through find_percent, and PATTERN_PERCENT is the result.
 246    If REPLACE_PERCENT is not nil, REPLACE has already been
 247    run through find_percent, and REPLACE_PERCENT is the result.
 248    Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
 249    character _AFTER_ the %, not to the % itself.
 250 */
 251
 252 char *
 253 patsubst_expand (char *o, const char *text, char *pattern, char *replace)
 254 {
 255   const char *pattern_percent = find_percent (pattern);
 256   const char *replace_percent = find_percent (replace);
 257
 258   /* If there's a percent in the pattern or replacement skip it.  */
 259   if (replace_percent)
 260     ++replace_percent;
 261   if (pattern_percent)
 262     ++pattern_percent;
 263
 264   return patsubst_expand_pat (o, text, pattern, replace,
 265                               pattern_percent, replace_percent);
 266 }
 267 \f
 268
 269 /* Look up a function by name.  */
 270
 271 static const struct function_table_entry *
 272 lookup_function (const char *s)
 273 {
 274   struct function_table_entry function_table_entry_key;
 275   const char *e = s;
 276
 277   while (STOP_SET (*e, MAP_USERFUNC))
 278     e++;
 279
 280   if (e == s || !STOP_SET(*e, MAP_NUL|MAP_SPACE))
 281     return NULL;
 282
 283   function_table_entry_key.name = s;
 284   function_table_entry_key.len = (unsigned char) (e - s);
 285
 286   return hash_find_item (&function_table, &function_table_entry_key);
 287 }
 288 \f
 289
 290 /* Return 1 if PATTERN matches STR, 0 if not.  */
 291
 292 int
 293 pattern_matches (const char *pattern, const char *percent, const char *str)
 294 {
 295   size_t sfxlen, strlength;
 296
 297   if (percent == 0)
 298     {
 299       size_t len = strlen (pattern) + 1;
 300       char *new_chars = alloca (len);
 301       memcpy (new_chars, pattern, len);
 302       percent = find_percent (new_chars);
 303       if (percent == 0)
 304         return streq (new_chars, str);
 305       pattern = new_chars;
 306     }
 307
 308   sfxlen = strlen (percent + 1);
 309   strlength = strlen (str);
 310
 311   if (strlength < (percent - pattern) + sfxlen
 312       || !strneq (pattern, str, percent - pattern))
 313     return 0;
 314
 315   return !strcmp (percent + 1, str + (strlength - sfxlen));
 316 }
 317 \f
 318
 319 /* Find the next comma or ENDPAREN (counting nested STARTPAREN and
 320    ENDPARENtheses), starting at PTR before END.  Return a pointer to
 321    next character.
 322
 323    If no next argument is found, return NULL.
 324 */
 325
 326 static char *
 327 find_next_argument (char startparen, char endparen,
 328                     const char *ptr, const char *end)
 329 {
 330   int count = 0;
 331
 332   for (; ptr < end; ++ptr)
 333     if (!STOP_SET (*ptr, MAP_VARSEP|MAP_COMMA))
 334       continue;
 335
 336     else if (*ptr == startparen)
 337       ++count;
 338
 339     else if (*ptr == endparen)
 340       {
 341         --count;
 342         if (count < 0)
 343           return NULL;
 344       }
 345
 346     else if (*ptr == ',' && !count)
 347       return (char *)ptr;
 348
 349   /* We didn't find anything.  */
 350   return NULL;
 351 }
 352 \f
 353
 354 /* Glob-expand LINE.  The returned pointer is
 355    only good until the next call to string_glob.  */
 356
 357 static char *
 358 string_glob (char *line)
 359 {
 360   static char *result = 0;
 361   static size_t length;
 362   struct nameseq *chain;
 363   size_t idx;
 364
 365   chain = PARSE_FILE_SEQ (&line, struct nameseq, MAP_NUL, NULL,
 366                           /* We do not want parse_file_seq to strip './'s.
 367                              That would break examples like:
 368                              $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)).  */
 369                           PARSEFS_NOSTRIP|PARSEFS_NOCACHE|PARSEFS_EXISTS);
 370
 371   if (result == 0)
 372     {
 373       length = 100;
 374       result = xmalloc (100);
 375     }
 376
 377   idx = 0;
 378   while (chain != 0)
 379     {
 380       struct nameseq *next = chain->next;
 381       size_t len = strlen (chain->name);
 382
 383       if (idx + len + 1 > length)
 384         {
 385           length += (len + 1) * 2;
 386           result = xrealloc (result, length);
 387         }
 388       memcpy (&result[idx], chain->name, len);
 389       idx += len;
 390       result[idx++] = ' ';
 391
 392       /* Because we used PARSEFS_NOCACHE above, we have to free() NAME.  */
 393       free ((char *)chain->name);
 394       free (chain);
 395       chain = next;
 396     }
 397
 398   /* Kill the last space and terminate the string.  */
 399   if (idx == 0)
 400     result[0] = '\0';
 401   else
 402     result[idx - 1] = '\0';
 403
 404   return result;
 405 }
 406 \f
 407 /*
 408   Builtin functions
 409  */
 410
 411 static char *
 412 func_patsubst (char *o, char **argv, const char *funcname UNUSED)
 413 {
 414   o = patsubst_expand (o, argv[2], argv[0], argv[1]);
 415   return o;
 416 }
 417
 418
 419 static char *
 420 func_join (char *o, char **argv, const char *funcname UNUSED)
 421 {
 422   int doneany = 0;
 423
 424   /* Write each word of the first argument directly followed
 425      by the corresponding word of the second argument.
 426      If the two arguments have a different number of words,
 427      the excess words are just output separated by blanks.  */
 428   const char *tp;
 429   const char *pp;
 430   const char *list1_iterator = argv[0];
 431   const char *list2_iterator = argv[1];
 432   do
 433     {
 434       size_t len1, len2;
 435
 436       tp = find_next_token (&list1_iterator, &len1);
 437       if (tp != 0)
 438         o = variable_buffer_output (o, tp, len1);
 439
 440       pp = find_next_token (&list2_iterator, &len2);
 441       if (pp != 0)
 442         o = variable_buffer_output (o, pp, len2);
 443
 444       if (tp != 0 || pp != 0)
 445         {
 446           o = variable_buffer_output (o, " ", 1);
 447           doneany = 1;
 448         }
 449     }
 450   while (tp != 0 || pp != 0);
 451   if (doneany)
 452     /* Kill the last blank.  */
 453     --o;
 454
 455   return o;
 456 }
 457
 458
 459 static char *
 460 func_origin (char *o, char **argv, const char *funcname UNUSED)
 461 {
 462   /* Expand the argument.  */
 463   struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
 464   if (v == 0)
 465     o = variable_buffer_output (o, "undefined", 9);
 466   else
 467     switch (v->origin)
 468       {
 469       case o_invalid:
 470         abort ();
 471         break;
 472       case o_default:
 473         o = variable_buffer_output (o, "default", 7);
 474         break;
 475       case o_env:
 476         o = variable_buffer_output (o, "environment", 11);
 477         break;
 478       case o_file:
 479         o = variable_buffer_output (o, "file", 4);
 480         break;
 481       case o_env_override:
 482         o = variable_buffer_output (o, "environment override", 20);
 483         break;
 484       case o_command:
 485         o = variable_buffer_output (o, "command line", 12);
 486         break;
 487       case o_override:
 488         o = variable_buffer_output (o, "override", 8);
 489         break;
 490       case o_automatic:
 491         o = variable_buffer_output (o, "automatic", 9);
 492         break;
 493       }
 494
 495   return o;
 496 }
 497
 498 static char *
 499 func_flavor (char *o, char **argv, const char *funcname UNUSED)
 500 {
 501   struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
 502
 503   if (v == 0)
 504     o = variable_buffer_output (o, "undefined", 9);
 505   else
 506     if (v->recursive)
 507       o = variable_buffer_output (o, "recursive", 9);
 508     else
 509       o = variable_buffer_output (o, "simple", 6);
 510
 511   return o;
 512 }
 513
 514
 515 static char *
 516 func_notdir_suffix (char *o, char **argv, const char *funcname)
 517 {
 518   /* Expand the argument.  */
 519   const char *list_iterator = argv[0];
 520   const char *p2;
 521   int doneany =0;
 522   size_t len=0;
 523
 524   int is_suffix = funcname[0] == 's';
 525   int is_notdir = !is_suffix;
 526   int stop = MAP_DIRSEP | (is_suffix ? MAP_DOT : 0);
 527 #ifdef VMS
 528   /* For VMS list_iterator points to a comma separated list. To use the common
 529      [find_]next_token, create a local copy and replace the commas with
 530      spaces. Obviously, there is a problem if there is a ',' in the VMS filename
 531      (can only happen on ODS5), the same problem as with spaces in filenames,
 532      which seems to be present in make on all platforms. */
 533   char *vms_list_iterator = alloca(strlen(list_iterator) + 1);
 534   int i;
 535   for (i = 0; list_iterator[i]; i++)
 536     if (list_iterator[i] == ',')
 537       vms_list_iterator[i] = ' ';
 538     else
 539       vms_list_iterator[i] = list_iterator[i];
 540   vms_list_iterator[i] = list_iterator[i];
 541   while ((p2 = find_next_token((const char**) &vms_list_iterator, &len)) != 0)
 542 #else
 543   while ((p2 = find_next_token (&list_iterator, &len)) != 0)
 544 #endif
 545     {
 546       const char *p = p2 + len - 1;
 547
 548       while (p >= p2 && ! STOP_SET (*p, stop))
 549         --p;
 550
 551       if (p >= p2)
 552         {
 553           if (is_notdir)
 554             ++p;
 555           else if (*p != '.')
 556             continue;
 557           o = variable_buffer_output (o, p, len - (p - p2));
 558         }
 559 #ifdef HAVE_DOS_PATHS
 560       /* Handle the case of "d:foo/bar".  */
 561       else if (is_notdir && p2[0] && p2[1] == ':')
 562         {
 563           p = p2 + 2;
 564           o = variable_buffer_output (o, p, len - (p - p2));
 565         }
 566 #endif
 567       else if (is_notdir)
 568         o = variable_buffer_output (o, p2, len);
 569
 570       if (is_notdir || p >= p2)
 571         {
 572 #ifdef VMS
 573           if (vms_comma_separator)
 574             o = variable_buffer_output (o, ",", 1);
 575           else
 576 #endif
 577           o = variable_buffer_output (o, " ", 1);
 578
 579           doneany = 1;
 580         }
 581     }
 582
 583   if (doneany)
 584     /* Kill last space.  */
 585     --o;
 586
 587   return o;
 588 }
 589
 590
 591 static char *
 592 func_basename_dir (char *o, char **argv, const char *funcname)
 593 {
 594   /* Expand the argument.  */
 595   const char *p3 = argv[0];
 596   const char *p2;
 597   int doneany = 0;
 598   size_t len = 0;
 599
 600   int is_basename = funcname[0] == 'b';
 601   int is_dir = !is_basename;
 602   int stop = MAP_DIRSEP | (is_basename ? MAP_DOT : 0) | MAP_NUL;
 603 #ifdef VMS
 604   /* As in func_notdir_suffix ... */
 605   char *vms_p3 = alloca (strlen(p3) + 1);
 606   int i;
 607   for (i = 0; p3[i]; i++)
 608     if (p3[i] == ',')
 609       vms_p3[i] = ' ';
 610     else
 611       vms_p3[i] = p3[i];
 612   vms_p3[i] = p3[i];
 613   while ((p2 = find_next_token((const char**) &vms_p3, &len)) != 0)
 614 #else
 615   while ((p2 = find_next_token (&p3, &len)) != 0)
 616 #endif
 617     {
 618       const char *p = p2 + len - 1;
 619       while (p >= p2 && ! STOP_SET (*p, stop))
 620         --p;
 621
 622       if (p >= p2 && (is_dir))
 623         o = variable_buffer_output (o, p2, ++p - p2);
 624       else if (p >= p2 && (*p == '.'))
 625         o = variable_buffer_output (o, p2, p - p2);
 626 #ifdef HAVE_DOS_PATHS
 627       /* Handle the "d:foobar" case */
 628       else if (p2[0] && p2[1] == ':' && is_dir)
 629         o = variable_buffer_output (o, p2, 2);
 630 #endif
 631       else if (is_dir)
 632 #ifdef VMS
 633         {
 634           extern int vms_report_unix_paths;
 635           if (vms_report_unix_paths)
 636             o = variable_buffer_output (o, "./", 2);
 637           else
 638             o = variable_buffer_output (o, "[]", 2);
 639         }
 640 #else
 641 #ifndef _AMIGA
 642       o = variable_buffer_output (o, "./", 2);
 643 #else
 644       ; /* Just a nop...  */
 645 #endif /* AMIGA */
 646 #endif /* !VMS */
 647       else
 648         /* The entire name is the basename.  */
 649         o = variable_buffer_output (o, p2, len);
 650
 651 #ifdef VMS
 652       if (vms_comma_separator)
 653         o = variable_buffer_output (o, ",", 1);
 654       else
 655 #endif
 656         o = variable_buffer_output (o, " ", 1);
 657
 658       doneany = 1;
 659     }
 660
 661   if (doneany)
 662     /* Kill last space.  */
 663     --o;
 664
 665   return o;
 666 }
 667
 668 static char *
 669 func_addsuffix_addprefix (char *o, char **argv, const char *funcname)
 670 {
 671   size_t fixlen = strlen (argv[0]);
 672   const char *list_iterator = argv[1];
 673   int is_addprefix = funcname[3] == 'p';
 674   int is_addsuffix = !is_addprefix;
 675
 676   int doneany = 0;
 677   const char *p;
 678   size_t len;
 679
 680   while ((p = find_next_token (&list_iterator, &len)) != 0)
 681     {
 682       if (is_addprefix)
 683         o = variable_buffer_output (o, argv[0], fixlen);
 684       o = variable_buffer_output (o, p, len);
 685       if (is_addsuffix)
 686         o = variable_buffer_output (o, argv[0], fixlen);
 687       o = variable_buffer_output (o, " ", 1);
 688       doneany = 1;
 689     }
 690
 691   if (doneany)
 692     /* Kill last space.  */
 693     --o;
 694
 695   return o;
 696 }
 697
 698 static char *
 699 func_subst (char *o, char **argv, const char *funcname UNUSED)
 700 {
 701   o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]),
 702                     strlen (argv[1]), 0);
 703
 704   return o;
 705 }
 706
 707
 708 static char *
 709 func_firstword (char *o, char **argv, const char *funcname UNUSED)
 710 {
 711   size_t i;
 712   const char *words = argv[0];    /* Use a temp variable for find_next_token */
 713   const char *p = find_next_token (&words, &i);
 714
 715   if (p != 0)
 716     o = variable_buffer_output (o, p, i);
 717
 718   return o;
 719 }
 720
 721 static char *
 722 func_lastword (char *o, char **argv, const char *funcname UNUSED)
 723 {
 724   size_t i;
 725   const char *words = argv[0];    /* Use a temp variable for find_next_token */
 726   const char *p = NULL;
 727   const char *t;
 728
 729   while ((t = find_next_token (&words, &i)) != NULL)
 730     p = t;
 731
 732   if (p != 0)
 733     o = variable_buffer_output (o, p, i);
 734
 735   return o;
 736 }
 737
 738 static char *
 739 func_words (char *o, char **argv, const char *funcname UNUSED)
 740 {
 741   unsigned int i = 0;
 742   const char *word_iterator = argv[0];
 743   char buf[INTSTR_LENGTH];
 744
 745   while (find_next_token (&word_iterator, NULL) != 0)
 746     ++i;
 747
 748   sprintf (buf, "%u", i);
 749   o = variable_buffer_output (o, buf, strlen (buf));
 750
 751   return o;
 752 }
 753
 754 /* Set begpp to point to the first non-whitespace character of the string,
 755  * and endpp to point to the last non-whitespace character of the string.
 756  * If the string is empty or contains nothing but whitespace, endpp will be
 757  * begpp-1.
 758  */
 759 char *
 760 strip_whitespace (const char **begpp, const char **endpp)
 761 {
 762   while (*begpp <= *endpp && ISSPACE (**begpp))
 763     (*begpp) ++;
 764   while (*endpp >= *begpp && ISSPACE (**endpp))
 765     (*endpp) --;
 766   return (char *)*begpp;
 767 }
 768
 769 static long long
 770 parse_numeric (const char *s, const char *msg)
 771 {
 772   const char *beg = s;
 773   const char *end = s + strlen (s) - 1;
 774   char *endp;
 775   long long num;
 776   strip_whitespace (&beg, &end);
 777
 778   if (beg > end)
 779     OS (fatal, *expanding_var, _("%s: empty value"), msg);
 780
 781   errno = 0;
 782   num = strtoll (beg, &endp, 10);
 783   if (errno == ERANGE)
 784     OSS (fatal, *expanding_var, _("%s: '%s' out of range"), msg, s);
 785   else if (endp == beg || endp <= end)
 786     /* Empty or non-numeric input */
 787     OSS (fatal, *expanding_var, "%s: '%s'", msg, s);
 788
 789   return num;
 790 }
 791
 792 static char *
 793 func_word (char *o, char **argv, const char *funcname UNUSED)
 794 {
 795   const char *end_p;
 796   const char *p;
 797   long long i;
 798
 799   i = parse_numeric (argv[0],
 800                      _("invalid first argument to 'word' function"));
 801   if (i < 1)
 802     O (fatal, *expanding_var,
 803        _("first argument to 'word' function must be greater than 0"));
 804
 805   end_p = argv[1];
 806   while ((p = find_next_token (&end_p, 0)) != 0)
 807     if (--i == 0)
 808       break;
 809
 810   if (i == 0)
 811     o = variable_buffer_output (o, p, end_p - p);
 812
 813   return o;
 814 }
 815
 816 static char *
 817 func_wordlist (char *o, char **argv, const char *funcname UNUSED)
 818 {
 819   char buf[INTSTR_LENGTH + 1];
 820   long long start, stop, count;
 821   const char* badfirst = _("invalid first argument to 'wordlist' function");
 822   const char* badsecond = _("invalid second argument to 'wordlist' function");
 823
 824   start = parse_numeric (argv[0], badfirst);
 825   if (start < 1)
 826     OSS (fatal, *expanding_var, "%s: '%s'", badfirst, make_lltoa (start, buf));
 827
 828   stop = parse_numeric (argv[1], badsecond);
 829   if (stop < 0)
 830     OSS (fatal, *expanding_var, "%s: '%s'", badsecond, make_lltoa (stop, buf));
 831
 832   count = stop - start + 1;
 833
 834   if (count > 0)
 835     {
 836       const char *p;
 837       const char *end_p = argv[2];
 838
 839       /* Find the beginning of the "start"th word.  */
 840       while (((p = find_next_token (&end_p, 0)) != 0) && --start)
 841         ;
 842
 843       if (p)
 844         {
 845           /* Find the end of the "count"th word from start.  */
 846           while (--count && (find_next_token (&end_p, 0) != 0))
 847             ;
 848
 849           /* Return the stuff in the middle.  */
 850           o = variable_buffer_output (o, p, end_p - p);
 851         }
 852     }
 853
 854   return o;
 855 }
 856
 857 static char *
 858 func_findstring (char *o, char **argv, const char *funcname UNUSED)
 859 {
 860   /* Find the first occurrence of the first string in the second.  */
 861   if (strstr (argv[1], argv[0]) != 0)
 862     o = variable_buffer_output (o, argv[0], strlen (argv[0]));
 863
 864   return o;
 865 }
 866
 867 static char *
 868 func_foreach (char *o, char **argv, const char *funcname UNUSED)
 869 {
 870   /* expand only the first two.  */
 871   char *varname = expand_argument (argv[0], NULL);
 872   char *list = expand_argument (argv[1], NULL);
 873   const char *body = argv[2];
 874
 875   int doneany = 0;
 876   const char *list_iterator = list;
 877   const char *p;
 878   size_t len;
 879   struct variable *var;
 880
 881   /* Clean up the variable name by removing whitespace.  */
 882   char *vp = next_token (varname);
 883   end_of_token (vp)[0] = '\0';
 884
 885   push_new_variable_scope ();
 886   var = define_variable (vp, strlen (vp), "", o_automatic, 0);
 887
 888   /* loop through LIST,  put the value in VAR and expand BODY */
 889   while ((p = find_next_token (&list_iterator, &len)) != 0)
 890     {
 891       char *result = 0;
 892
 893       free (var->value);
 894       var->value = xstrndup (p, len);
 895
 896       result = allocated_variable_expand (body);
 897
 898       o = variable_buffer_output (o, result, strlen (result));
 899       o = variable_buffer_output (o, " ", 1);
 900       doneany = 1;
 901       free (result);
 902     }
 903
 904   if (doneany)
 905     /* Kill the last space.  */
 906     --o;
 907
 908   pop_variable_scope ();
 909   free (varname);
 910   free (list);
 911
 912   return o;
 913 }
 914
 915 static char *
 916 func_let (char *o, char **argv, const char *funcname UNUSED)
 917 {
 918   /* expand only the first two.  */
 919   char *varnames = expand_argument (argv[0], NULL);
 920   char *list = expand_argument (argv[1], NULL);
 921   const char *body = argv[2];
 922
 923   const char *vp;
 924   const char *vp_next = varnames;
 925   const char *list_iterator = list;
 926   char *p;
 927   size_t len;
 928   size_t vlen;
 929
 930   push_new_variable_scope ();
 931
 932   /* loop through LIST for all but the last VARNAME */
 933   vp = find_next_token (&vp_next, &vlen);
 934   NEXT_TOKEN (vp_next);
 935   while (*vp_next != '\0')
 936     {
 937       p = find_next_token (&list_iterator, &len);
 938       if (*list_iterator != '\0')
 939         {
 940           ++list_iterator;
 941           p[len] = '\0';
 942         }
 943       define_variable (vp, vlen, p ? p : "", o_automatic, 0);
 944
 945       vp = find_next_token (&vp_next, &vlen);
 946       NEXT_TOKEN (vp_next);
 947     }
 948
 949   /* set the last VARNAME to the remainder of LIST */
 950   if (vp)
 951     define_variable (vp, vlen, next_token (list_iterator), o_automatic, 0);
 952
 953   /* Expand the body in the context of the arguments, adding the result to
 954      the variable buffer.  */
 955
 956   o = variable_expand_string (o, body, SIZE_MAX);
 957
 958   pop_variable_scope ();
 959   free (varnames);
 960   free (list);
 961
 962   return o + strlen (o);
 963 }
 964
 965 struct a_word
 966 {
 967   struct a_word *chain;
 968   char *str;
 969   size_t length;
 970   int matched;
 971 };
 972
 973 static unsigned long
 974 a_word_hash_1 (const void *key)
 975 {
 976   return_STRING_HASH_1 (((struct a_word const *) key)->str);
 977 }
 978
 979 static unsigned long
 980 a_word_hash_2 (const void *key)
 981 {
 982   return_STRING_HASH_2 (((struct a_word const *) key)->str);
 983 }
 984
 985 static int
 986 a_word_hash_cmp (const void *x, const void *y)
 987 {
 988   const struct a_word *ax = x;
 989   const struct a_word *ay = y;
 990
 991   if (ax->length != ay->length)
 992     return ax->length > ay->length ? 1 : -1;
 993
 994   return_STRING_N_COMPARE (ax->str, ay->str, ax->length);
 995 }
 996
 997 struct a_pattern
 998 {
 999   char *str;
1000   char *percent;
1001   size_t length;
1002 };
1003
1004 static char *
1005 func_filter_filterout (char *o, char **argv, const char *funcname)
1006 {
1007   struct a_word *words;
1008   struct a_word *word_end;
1009   struct a_word *wp;
1010   struct a_pattern *patterns;
1011   struct a_pattern *pat_end;
1012   struct a_pattern *pp;
1013   unsigned long pat_count = 0, word_count = 0;
1014
1015   struct hash_table a_word_table;
1016   int is_filter = funcname[CSTRLEN ("filter")] == '\0';
1017   const char *cp;
1018   int literals = 0;
1019   int hashing = 0;
1020   char *p;
1021   size_t len;
1022   int doneany = 0;
1023
1024   /* Find the number of words and get memory for them.  */
1025   cp = argv[1];
1026   while ((p = find_next_token (&cp, NULL)) != 0)
1027     ++word_count;
1028
1029   if (!word_count)
1030     return o;
1031
1032   words = xcalloc (word_count * sizeof (struct a_word));
1033   word_end = words + word_count;
1034
1035   /* Find the number of patterns and get memory for them.  */
1036   cp = argv[0];
1037   while ((p = find_next_token (&cp, NULL)) != 0)
1038     ++pat_count;
1039
1040   patterns = xcalloc (pat_count * sizeof (struct a_pattern));
1041   pat_end = patterns + pat_count;
1042
1043   /* Chop argv[0] up into patterns to match against the words.  */
1044
1045   cp = argv[0];
1046   pp = patterns;
1047   while ((p = find_next_token (&cp, &len)) != 0)
1048     {
1049       if (*cp != '\0')
1050         ++cp;
1051
1052       p[len] = '\0';
1053       pp->str = p;
1054       pp->percent = find_percent (p);
1055       if (pp->percent == 0)
1056         literals++;
1057       /* find_percent() might shorten the string so LEN is wrong.  */
1058       pp->length = strlen (pp->str);
1059
1060       ++pp;
1061     }
1062
1063   /* Chop ARGV[1] up into words to match against the patterns.  */
1064
1065   cp = argv[1];
1066   wp = words;
1067   while ((p = find_next_token (&cp, &len)) != 0)
1068     {
1069       if (*cp != '\0')
1070         ++cp;
1071
1072       p[len] = '\0';
1073       wp->str = p;
1074       wp->length = len;
1075       ++wp;
1076     }
1077
1078   /* Only use a hash table if arg list lengths justifies the cost.  */
1079   hashing = (literals > 1 && (literals * word_count) >= 10);
1080   if (hashing)
1081     {
1082       hash_init (&a_word_table, word_count, a_word_hash_1, a_word_hash_2,
1083                  a_word_hash_cmp);
1084       for (wp = words; wp < word_end; ++wp)
1085         {
1086           struct a_word *owp = hash_insert (&a_word_table, wp);
1087           if (owp)
1088             wp->chain = owp;
1089         }
1090     }
1091
1092   /* Run each pattern through the words, killing words.  */
1093   for (pp = patterns; pp < pat_end; ++pp)
1094     {
1095       if (pp->percent)
1096         for (wp = words; wp < word_end; ++wp)
1097           wp->matched |= pattern_matches (pp->str, pp->percent, wp->str);
1098       else if (hashing)
1099         {
1100           struct a_word a_word_key;
1101           a_word_key.str = pp->str;
1102           a_word_key.length = pp->length;
1103           wp = hash_find_item (&a_word_table, &a_word_key);
1104           while (wp)
1105             {
1106               wp->matched |= 1;
1107               wp = wp->chain;
1108             }
1109         }
1110       else
1111         for (wp = words; wp < word_end; ++wp)
1112           wp->matched |= (wp->length == pp->length
1113                           && memcmp (pp->str, wp->str, wp->length) == 0);
1114     }
1115
1116   /* Output the words that matched (or didn't, for filter-out).  */
1117   for (wp = words; wp < word_end; ++wp)
1118     if (is_filter ? wp->matched : !wp->matched)
1119       {
1120         o = variable_buffer_output (o, wp->str, strlen (wp->str));
1121         o = variable_buffer_output (o, " ", 1);
1122         doneany = 1;
1123       }
1124
1125   if (doneany)
1126     /* Kill the last space.  */
1127     --o;
1128
1129   if (hashing)
1130     hash_free (&a_word_table, 0);
1131
1132   free (patterns);
1133   free (words);
1134
1135   return o;
1136 }
1137
1138
1139 static char *
1140 func_strip (char *o, char **argv, const char *funcname UNUSED)
1141 {
1142   const char *p = argv[0];
1143   int doneany = 0;
1144
1145   while (*p != '\0')
1146     {
1147       int i=0;
1148       const char *word_start;
1149
1150       NEXT_TOKEN (p);
1151       word_start = p;
1152       for (i=0; *p != '\0' && !ISSPACE (*p); ++p, ++i)
1153         {}
1154       if (!i)
1155         break;
1156       o = variable_buffer_output (o, word_start, i);
1157       o = variable_buffer_output (o, " ", 1);
1158       doneany = 1;
1159     }
1160
1161   if (doneany)
1162     /* Kill the last space.  */
1163     --o;
1164
1165   return o;
1166 }
1167
1168 /*
1169   Print a warning or fatal message.
1170 */
1171 static char *
1172 func_error (char *o, char **argv, const char *funcname)
1173 {
1174   switch (*funcname)
1175     {
1176     case 'e':
1177       OS (fatal, reading_file, "%s", argv[0]);
1178
1179     case 'w':
1180       OS (error, reading_file, "%s", argv[0]);
1181       break;
1182
1183     case 'i':
1184       {
1185         size_t len = strlen (argv[0]);
1186         char *msg = alloca (len + 2);
1187         memcpy (msg, argv[0], len);
1188         msg[len] = '\n';
1189         msg[len + 1] = '\0';
1190         outputs (0, msg);
1191         break;
1192       }
1193
1194     default:
1195       OS (fatal, *expanding_var, "Internal error: func_error: '%s'", funcname);
1196     }
1197
1198   /* The warning function expands to the empty string.  */
1199   return o;
1200 }
1201
1202
1203 /*
1204   chop argv[0] into words, and sort them.
1205  */
1206 static char *
1207 func_sort (char *o, char **argv, const char *funcname UNUSED)
1208 {
1209   const char *t;
1210   char **words;
1211   int wordi;
1212   char *p;
1213   size_t len;
1214
1215   /* Find the maximum number of words we'll have.  */
1216   t = argv[0];
1217   wordi = 0;
1218   while ((p = find_next_token (&t, NULL)) != 0)
1219     {
1220       ++t;
1221       ++wordi;
1222     }
1223
1224   words = xmalloc ((wordi == 0 ? 1 : wordi) * sizeof (char *));
1225
1226   /* Now assign pointers to each string in the array.  */
1227   t = argv[0];
1228   wordi = 0;
1229   while ((p = find_next_token (&t, &len)) != 0)
1230     {
1231       ++t;
1232       p[len] = '\0';
1233       words[wordi++] = p;
1234     }
1235
1236   if (wordi)
1237     {
1238       int i;
1239
1240       /* Now sort the list of words.  */
1241       qsort (words, wordi, sizeof (char *), alpha_compare);
1242
1243       /* Now write the sorted list, uniquified.  */
1244       for (i = 0; i < wordi; ++i)
1245         {
1246           len = strlen (words[i]);
1247           if (i == wordi - 1 || strlen (words[i + 1]) != len
1248               || memcmp (words[i], words[i + 1], len))
1249             {
1250               o = variable_buffer_output (o, words[i], len);
1251               o = variable_buffer_output (o, " ", 1);
1252             }
1253         }
1254
1255       /* Kill the last space.  */
1256       --o;
1257     }
1258
1259   free (words);
1260
1261   return o;
1262 }
1263
1264 /*
1265   Traverse NUMBER consisting of optional leading white space, optional
1266   sign, digits, and optional trailing white space.
1267   If number is not of the proper form, diagnose with MSG.  Otherwise,
1268   return the address of of the first character after NUMBER, store
1269   into *SIGN an integer consistent with the number's sign (-1, 0, or 1)
1270   and store into *NUMSTART the address of NUMBER's first nonzero digit
1271   (if NUMBER contains only zero digits, store the address of the first
1272   character after NUMBER).
1273 */
1274 static const char *
1275 parse_textint (const char *number, const char *msg,
1276                int *sign, const char **numstart)
1277 {
1278   const char *after_sign, *after_number;
1279   const char *p = next_token (number);
1280   int negative = *p == '-';
1281   int nonzero;
1282
1283   if (*p == '\0')
1284     OS (fatal, *expanding_var, _("%s: empty value"), msg);
1285
1286   p += negative || *p == '+';
1287   after_sign = p;
1288
1289   while (*p == '0')
1290     p++;
1291   *numstart = p;
1292
1293   while (ISDIGIT (*p))
1294     ++p;
1295   after_number = p;
1296   nonzero = *numstart != after_number;
1297   *sign = negative ? -nonzero : nonzero;
1298
1299   /* Check for extra non-whitespace stuff after the value.  */
1300   if (after_number == after_sign || *next_token (p) != '\0')
1301     OSS (fatal, *expanding_var, "%s: '%s'", msg, number);
1302
1303   return after_number;
1304 }
1305
1306
1307 /*
1308   $(intcmp lhs,rhs[,lt-part[,eq-part[,gt-part]]])
1309
1310   LHS and RHS must be integer values (leading/trailing whitespace is ignored).
1311   If none of LT-PART, EQ-PART, or GT-PART are given then the function expands
1312   to empty if LHS and RHS are not equal, or the numeric value if they are equal.
1313   LT-PART is evaluated when LHS is strictly less than RHS, EQ-PART is evaluated
1314   when LHS is equal to RHS, and GT-part is evaluated when LHS is strictly
1315   greater than RHS.
1316   If GT-PART is not provided, it defaults to EQ-PART.  When neither EQ-PART
1317   nor GT-PART are provided, the function expands to empty if LHS is not
1318   strictly less than RHS.
1319 */
1320
1321 static char *
1322 func_intcmp (char *o, char **argv, const char *funcname UNUSED)
1323 {
1324   int lsign, rsign;
1325   const char *lnum, *rnum;
1326   char *lhs_str = expand_argument (argv[0], NULL);
1327   char *rhs_str = expand_argument (argv[1], NULL);
1328   const char *llim = parse_textint (lhs_str, _("non-numeric first argument to 'intcmp' function"), &lsign, &lnum);
1329   const char *rlim = parse_textint (rhs_str, _("non-numeric second argument to 'intcmp' function"), &rsign, &rnum);
1330   ptrdiff_t llen = llim - lnum;
1331   ptrdiff_t rlen = rlim - rnum;
1332   int cmp = lsign - rsign;
1333
1334   if (cmp == 0)
1335     {
1336       cmp = (llen > rlen) - (llen < rlen);
1337       if (cmp == 0)
1338         cmp = memcmp (lnum, rnum, llen);
1339     }
1340
1341   argv += 2;
1342
1343   /* Handle the special case where there are only two arguments.  */
1344   if (!*argv && cmp == 0)
1345     {
1346       if (lsign < 0)
1347         o = variable_buffer_output (o, "-", 1);
1348       o = variable_buffer_output(o, lnum - !lsign, llen + !lsign);
1349     }
1350
1351   free (lhs_str);
1352   free (rhs_str);
1353
1354   if (*argv && cmp >= 0)
1355     {
1356       ++argv;
1357       if (cmp > 0 && *argv && *(argv + 1))
1358         ++argv;
1359     }
1360
1361   if (*argv)
1362     {
1363       char *expansion = expand_argument (*argv, NULL);
1364
1365       o = variable_buffer_output (o, expansion, strlen (expansion));
1366
1367       free (expansion);
1368     }
1369
1370   return o;
1371 }
1372
1373 /*
1374   $(if condition,true-part[,false-part])
1375
1376   CONDITION is false iff it evaluates to an empty string.  White
1377   space before and after condition are stripped before evaluation.
1378
1379   If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is
1380   evaluated (if it exists).  Because only one of the two PARTs is evaluated,
1381   you can use $(if ...) to create side-effects (with $(shell ...), for
1382   example).
1383 */
1384
1385 static char *
1386 func_if (char *o, char **argv, const char *funcname UNUSED)
1387 {
1388   const char *begp = argv[0];
1389   const char *endp = begp + strlen (argv[0]) - 1;
1390   int result = 0;
1391
1392   /* Find the result of the condition: if we have a value, and it's not
1393      empty, the condition is true.  If we don't have a value, or it's the
1394      empty string, then it's false.  */
1395
1396   strip_whitespace (&begp, &endp);
1397
1398   if (begp <= endp)
1399     {
1400       char *expansion = expand_argument (begp, endp+1);
1401
1402       result = expansion[0] != '\0';
1403       free (expansion);
1404     }
1405
1406   /* If the result is true (1) we want to eval the first argument, and if
1407      it's false (0) we want to eval the second.  If the argument doesn't
1408      exist we do nothing, otherwise expand it and add to the buffer.  */
1409
1410   argv += 1 + !result;
1411
1412   if (*argv)
1413     {
1414       char *expansion = expand_argument (*argv, NULL);
1415
1416       o = variable_buffer_output (o, expansion, strlen (expansion));
1417
1418       free (expansion);
1419     }
1420
1421   return o;
1422 }
1423
1424 /*
1425   $(or condition1[,condition2[,condition3[...]]])
1426
1427   A CONDITION is false iff it evaluates to an empty string.  White
1428   space before and after CONDITION are stripped before evaluation.
1429
1430   CONDITION1 is evaluated.  If it's true, then this is the result of
1431   expansion.  If it's false, CONDITION2 is evaluated, and so on.  If none of
1432   the conditions are true, the expansion is the empty string.
1433
1434   Once a CONDITION is true no further conditions are evaluated
1435   (short-circuiting).
1436 */
1437
1438 static char *
1439 func_or (char *o, char **argv, const char *funcname UNUSED)
1440 {
1441   for ( ; *argv ; ++argv)
1442     {
1443       const char *begp = *argv;
1444       const char *endp = begp + strlen (*argv) - 1;
1445       char *expansion;
1446       size_t result = 0;
1447
1448       /* Find the result of the condition: if it's false keep going.  */
1449
1450       strip_whitespace (&begp, &endp);
1451
1452       if (begp > endp)
1453         continue;
1454
1455       expansion = expand_argument (begp, endp+1);
1456       result = strlen (expansion);
1457
1458       /* If the result is false keep going.  */
1459       if (!result)
1460         {
1461           free (expansion);
1462           continue;
1463         }
1464
1465       /* It's true!  Keep this result and return.  */
1466       o = variable_buffer_output (o, expansion, result);
1467       free (expansion);
1468       break;
1469     }
1470
1471   return o;
1472 }
1473
1474 /*
1475   $(and condition1[,condition2[,condition3[...]]])
1476
1477   A CONDITION is false iff it evaluates to an empty string.  White
1478   space before and after CONDITION are stripped before evaluation.
1479
1480   CONDITION1 is evaluated.  If it's false, then this is the result of
1481   expansion.  If it's true, CONDITION2 is evaluated, and so on.  If all of
1482   the conditions are true, the expansion is the result of the last condition.
1483
1484   Once a CONDITION is false no further conditions are evaluated
1485   (short-circuiting).
1486 */
1487
1488 static char *
1489 func_and (char *o, char **argv, const char *funcname UNUSED)
1490 {
1491   char *expansion;
1492
1493   while (1)
1494     {
1495       const char *begp = *argv;
1496       const char *endp = begp + strlen (*argv) - 1;
1497       size_t result;
1498
1499       /* An empty condition is always false.  */
1500       strip_whitespace (&begp, &endp);
1501       if (begp > endp)
1502         return o;
1503
1504       expansion = expand_argument (begp, endp+1);
1505       result = strlen (expansion);
1506
1507       /* If the result is false, stop here: we're done.  */
1508       if (!result)
1509         break;
1510
1511       /* Otherwise the result is true.  If this is the last one, keep this
1512          result and quit.  Otherwise go on to the next one!  */
1513
1514       if (*(++argv))
1515         free (expansion);
1516       else
1517         {
1518           o = variable_buffer_output (o, expansion, result);
1519           break;
1520         }
1521     }
1522
1523   free (expansion);
1524
1525   return o;
1526 }
1527
1528 static char *
1529 func_wildcard (char *o, char **argv, const char *funcname UNUSED)
1530 {
1531 #ifdef _AMIGA
1532    o = wildcard_expansion (argv[0], o);
1533 #else
1534    char *p = string_glob (argv[0]);
1535    o = variable_buffer_output (o, p, strlen (p));
1536 #endif
1537    return o;
1538 }
1539
1540 /*
1541   $(eval <makefile string>)
1542
1543   Always resolves to the empty string.
1544
1545   Treat the arguments as a segment of makefile, and parse them.
1546 */
1547
1548 static char *
1549 func_eval (char *o, char **argv, const char *funcname UNUSED)
1550 {
1551   char *buf;
1552   size_t len;
1553
1554   /* Eval the buffer.  Pop the current variable buffer setting so that the
1555      eval'd code can use its own without conflicting.  */
1556
1557   install_variable_buffer (&buf, &len);
1558
1559   eval_buffer (argv[0], NULL);
1560
1561   restore_variable_buffer (buf, len);
1562
1563   return o;
1564 }
1565
1566
1567 static char *
1568 func_value (char *o, char **argv, const char *funcname UNUSED)
1569 {
1570   /* Look up the variable.  */
1571   struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
1572
1573   /* Copy its value into the output buffer without expanding it.  */
1574   if (v)
1575     o = variable_buffer_output (o, v->value, strlen (v->value));
1576
1577   return o;
1578 }
1579
1580 /*
1581   \r is replaced on UNIX as well. Is this desirable?
1582  */
1583 static void
1584 fold_newlines (char *buffer, size_t *length, int trim_newlines)
1585 {
1586   char *dst = buffer;
1587   char *src = buffer;
1588   char *last_nonnl = buffer - 1;
1589   src[*length] = 0;
1590   for (; *src != '\0'; ++src)
1591     {
1592       if (src[0] == '\r' && src[1] == '\n')
1593         continue;
1594       if (*src == '\n')
1595         {
1596           *dst++ = ' ';
1597         }
1598       else
1599         {
1600           last_nonnl = dst;
1601           *dst++ = *src;
1602         }
1603     }
1604
1605   if (!trim_newlines && (last_nonnl < (dst - 2)))
1606     last_nonnl = dst - 2;
1607
1608   *(++last_nonnl) = '\0';
1609   *length = last_nonnl - buffer;
1610 }
1611
1612 pid_t shell_function_pid = 0;
1613 static int shell_function_completed;
1614
1615 void
1616 shell_completed (int exit_code, int exit_sig)
1617 {
1618   char buf[INTSTR_LENGTH];
1619
1620   shell_function_pid = 0;
1621   if (exit_sig == 0 && exit_code == 127)
1622     shell_function_completed = -1;
1623   else
1624     shell_function_completed = 1;
1625
1626   if (exit_code == 0 && exit_sig > 0)
1627     exit_code = 128 + exit_sig;
1628
1629   sprintf (buf, "%d", exit_code);
1630   define_variable_cname (".SHELLSTATUS", buf, o_override, 0);
1631 }
1632
1633 #ifdef WINDOWS32
1634 /*untested*/
1635
1636 #include <windows.h>
1637 #include <io.h>
1638 #include "sub_proc.h"
1639
1640
1641 int
1642 windows32_openpipe (int *pipedes, int errfd, pid_t *pid_p, char **command_argv, char **envp)
1643 {
1644   SECURITY_ATTRIBUTES saAttr;
1645   HANDLE hIn = INVALID_HANDLE_VALUE;
1646   HANDLE hErr = INVALID_HANDLE_VALUE;
1647   HANDLE hChildOutRd;
1648   HANDLE hChildOutWr;
1649   HANDLE hProcess, tmpIn, tmpErr;
1650   DWORD e;
1651
1652   /* Set status for return.  */
1653   pipedes[0] = pipedes[1] = -1;
1654   *pid_p = (pid_t)-1;
1655
1656   saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
1657   saAttr.bInheritHandle = TRUE;
1658   saAttr.lpSecurityDescriptor = NULL;
1659
1660   /* Standard handles returned by GetStdHandle can be NULL or
1661      INVALID_HANDLE_VALUE if the parent process closed them.  If that
1662      happens, we open the null device and pass its handle to
1663      process_begin below as the corresponding handle to inherit.  */
1664   tmpIn = GetStdHandle (STD_INPUT_HANDLE);
1665   if (DuplicateHandle (GetCurrentProcess (), tmpIn,
1666                        GetCurrentProcess (), &hIn,
1667                        0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
1668     {
1669       e = GetLastError ();
1670       if (e == ERROR_INVALID_HANDLE)
1671         {
1672           tmpIn = CreateFile ("NUL", GENERIC_READ,
1673                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1674                               OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1675           if (tmpIn != INVALID_HANDLE_VALUE
1676               && DuplicateHandle (GetCurrentProcess (), tmpIn,
1677                                   GetCurrentProcess (), &hIn,
1678                                   0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
1679             CloseHandle (tmpIn);
1680         }
1681       if (hIn == INVALID_HANDLE_VALUE)
1682         {
1683           ON (error, NILF,
1684               _("windows32_openpipe: DuplicateHandle(In) failed (e=%lu)\n"), e);
1685           return -1;
1686         }
1687     }
1688   tmpErr = (HANDLE)_get_osfhandle (errfd);
1689   if (DuplicateHandle (GetCurrentProcess (), tmpErr,
1690                        GetCurrentProcess (), &hErr,
1691                        0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
1692     {
1693       e = GetLastError ();
1694       if (e == ERROR_INVALID_HANDLE)
1695         {
1696           tmpErr = CreateFile ("NUL", GENERIC_WRITE,
1697                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1698                                OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1699           if (tmpErr != INVALID_HANDLE_VALUE
1700               && DuplicateHandle (GetCurrentProcess (), tmpErr,
1701                                   GetCurrentProcess (), &hErr,
1702                                   0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
1703             CloseHandle (tmpErr);
1704         }
1705       if (hErr == INVALID_HANDLE_VALUE)
1706         {
1707           ON (error, NILF,
1708               _("windows32_openpipe: DuplicateHandle(Err) failed (e=%lu)\n"), e);
1709           return -1;
1710         }
1711     }
1712
1713   if (! CreatePipe (&hChildOutRd, &hChildOutWr, &saAttr, 0))
1714     {
1715       ON (error, NILF, _("CreatePipe() failed (e=%lu)\n"), GetLastError());
1716       return -1;
1717     }
1718
1719   hProcess = process_init_fd (hIn, hChildOutWr, hErr);
1720
1721   if (!hProcess)
1722     {
1723       O (error, NILF, _("windows32_openpipe(): process_init_fd() failed\n"));
1724       return -1;
1725     }
1726
1727   if (! process_begin (hProcess, command_argv, envp, command_argv[0], NULL))
1728     {
1729       /* register process for wait */
1730       process_register (hProcess);
1731
1732       /* set the pid for returning to caller */
1733       *pid_p = (pid_t) hProcess;
1734
1735       /* set up to read data from child */
1736       pipedes[0] = _open_osfhandle ((intptr_t) hChildOutRd, O_RDONLY);
1737
1738       /* this will be closed almost right away */
1739       pipedes[1] = _open_osfhandle ((intptr_t) hChildOutWr, O_APPEND);
1740       return 0;
1741     }
1742   else
1743     {
1744       /* reap/cleanup the failed process */
1745       process_cleanup (hProcess);
1746
1747       /* close handles which were duplicated, they weren't used */
1748       if (hIn != INVALID_HANDLE_VALUE)
1749         CloseHandle (hIn);
1750       if (hErr != INVALID_HANDLE_VALUE)
1751         CloseHandle (hErr);
1752
1753       /* close pipe handles, they won't be used */
1754       CloseHandle (hChildOutRd);
1755       CloseHandle (hChildOutWr);
1756
1757       return -1;
1758     }
1759 }
1760 #endif
1761
1762
1763 #ifdef __MSDOS__
1764 FILE *
1765 msdos_openpipe (int* pipedes, int *pidp, char *text)
1766 {
1767   FILE *fpipe=0;
1768   /* MSDOS can't fork, but it has 'popen'.  */
1769   struct variable *sh = lookup_variable ("SHELL", 5);
1770   int e;
1771   extern int dos_command_running, dos_status;
1772
1773   /* Make sure not to bother processing an empty line.  */
1774   NEXT_TOKEN (text);
1775   if (*text == '\0')
1776     return 0;
1777
1778   if (sh)
1779     {
1780       char buf[PATH_MAX + 7];
1781       /* This makes sure $SHELL value is used by $(shell), even
1782          though the target environment is not passed to it.  */
1783       sprintf (buf, "SHELL=%s", sh->value);
1784       putenv (buf);
1785     }
1786
1787   e = errno;
1788   errno = 0;
1789   dos_command_running = 1;
1790   dos_status = 0;
1791   /* If dos_status becomes non-zero, it means the child process
1792      was interrupted by a signal, like SIGINT or SIGQUIT.  See
1793      fatal_error_signal in commands.c.  */
1794   fpipe = popen (text, "rt");
1795   dos_command_running = 0;
1796   if (!fpipe || dos_status)
1797     {
1798       pipedes[0] = -1;
1799       *pidp = -1;
1800       if (dos_status)
1801         errno = EINTR;
1802       else if (errno == 0)
1803         errno = ENOMEM;
1804       if (fpipe)
1805         pclose (fpipe);
1806       shell_completed (127, 0);
1807     }
1808   else
1809     {
1810       pipedes[0] = fileno (fpipe);
1811       *pidp = 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
1812       errno = e;
1813     }
1814   return fpipe;
1815 }
1816 #endif
1817
1818 /*
1819   Do shell spawning, with the naughty bits for different OSes.
1820  */
1821
1822 #ifdef VMS
1823
1824 /* VMS can't do $(shell ...)  */
1825
1826 char *
1827 func_shell_base (char *o, char **argv, int trim_newlines)
1828 {
1829   fprintf (stderr, "This platform does not support shell\n");
1830   die (MAKE_TROUBLE);
1831   return NULL;
1832 }
1833
1834 #define func_shell 0
1835
1836 #else
1837 #ifndef _AMIGA
1838 char *
1839 func_shell_base (char *o, char **argv, int trim_newlines)
1840 {
1841   struct childbase child = {0};
1842   char *batch_filename = NULL;
1843   int errfd;
1844 #ifdef __MSDOS__
1845   FILE *fpipe;
1846 #endif
1847   char **command_argv = NULL;
1848   int pipedes[2];
1849   pid_t pid;
1850
1851 #ifndef __MSDOS__
1852 #ifdef WINDOWS32
1853   /* Reset just_print_flag.  This is needed on Windows when batch files
1854      are used to run the commands, because we normally refrain from
1855      creating batch files under -n.  */
1856   int j_p_f = just_print_flag;
1857   just_print_flag = 0;
1858 #endif
1859
1860   /* Construct the argument list.  */
1861   command_argv = construct_command_argv (argv[0], NULL, NULL, 0,
1862                                          &batch_filename);
1863   if (command_argv == 0)
1864     {
1865 #ifdef WINDOWS32
1866       just_print_flag = j_p_f;
1867 #endif
1868       return o;
1869     }
1870 #endif /* !__MSDOS__ */
1871
1872   /* Set up the output in case the shell writes something.  */
1873   output_start ();
1874
1875   errfd = (output_context && output_context->err >= 0
1876            ? output_context->err : FD_STDERR);
1877
1878   child.environment = target_environment (NULL, 0);
1879
1880 #if defined(__MSDOS__)
1881   fpipe = msdos_openpipe (pipedes, &pid, argv[0]);
1882   if (pipedes[0] < 0)
1883     {
1884       OS (error, reading_file, "pipe: %s", strerror (errno));
1885       pid = -1;
1886       goto done;
1887     }
1888
1889 #elif defined(WINDOWS32)
1890   windows32_openpipe (pipedes, errfd, &pid, command_argv, child.environment);
1891   /* Restore the value of just_print_flag.  */
1892   just_print_flag = j_p_f;
1893
1894   if (pipedes[0] < 0)
1895     {
1896       /* Open of the pipe failed, mark as failed execution.  */
1897       shell_completed (127, 0);
1898       OS (error, reading_file, "pipe: %s", strerror (errno));
1899       pid = -1;
1900       goto done;
1901     }
1902
1903 #else
1904   if (pipe (pipedes) < 0)
1905     {
1906       OS (error, reading_file, "pipe: %s", strerror (errno));
1907       pid = -1;
1908       goto done;
1909     }
1910
1911   /* Close handles that are unnecessary for the child process.  */
1912   fd_noinherit (pipedes[1]);
1913   fd_noinherit (pipedes[0]);
1914
1915   child.output.syncout = 1;
1916   child.output.out = pipedes[1];
1917   child.output.err = errfd;
1918
1919   pid = child_execute_job (&child, 1, command_argv);
1920
1921   if (pid < 0)
1922     {
1923       shell_completed (127, 0);
1924       goto done;
1925     }
1926 #endif
1927
1928   {
1929     char *buffer;
1930     size_t maxlen, i;
1931     int cc;
1932
1933     /* Record the PID for reap_children.  */
1934     shell_function_pid = pid;
1935 #ifndef  __MSDOS__
1936     shell_function_completed = 0;
1937
1938     /* Close the write side of the pipe.  We test for -1, since
1939        pipedes[1] is -1 on MS-Windows, and some versions of MS
1940        libraries barf when 'close' is called with -1.  */
1941     if (pipedes[1] >= 0)
1942       close (pipedes[1]);
1943 #endif
1944
1945     /* Set up and read from the pipe.  */
1946
1947     maxlen = 200;
1948     buffer = xmalloc (maxlen + 1);
1949
1950     /* Read from the pipe until it gets EOF.  */
1951     for (i = 0; ; i += cc)
1952       {
1953         if (i == maxlen)
1954           {
1955             maxlen += 512;
1956             buffer = xrealloc (buffer, maxlen + 1);
1957           }
1958
1959         EINTRLOOP (cc, read (pipedes[0], &buffer[i], maxlen - i));
1960         if (cc <= 0)
1961           break;
1962       }
1963     buffer[i] = '\0';
1964
1965     /* Close the read side of the pipe.  */
1966 #ifdef  __MSDOS__
1967     if (fpipe)
1968       {
1969         int st = pclose (fpipe);
1970         shell_completed (st, 0);
1971       }
1972 #else
1973     (void) close (pipedes[0]);
1974 #endif
1975
1976     /* Loop until child_handler or reap_children()  sets
1977        shell_function_completed to the status of our child shell.  */
1978     while (shell_function_completed == 0)
1979       reap_children (1, 0);
1980
1981     if (batch_filename)
1982       {
1983         DB (DB_VERBOSE, (_("Cleaning up temporary batch file %s\n"),
1984                          batch_filename));
1985         remove (batch_filename);
1986         free (batch_filename);
1987       }
1988     shell_function_pid = 0;
1989
1990     /* Replace all newlines in the command's output with spaces, and put that
1991        in the variable output buffer.  */
1992     fold_newlines (buffer, &i, trim_newlines);
1993     o = variable_buffer_output (o, buffer, i);
1994
1995     free (buffer);
1996   }
1997
1998  done:
1999   if (command_argv)
2000     {
2001       /* Free the storage only the child needed.  */
2002       free (command_argv[0]);
2003       free (command_argv);
2004     }
2005
2006   free_childbase (&child);
2007
2008   return o;
2009 }
2010
2011 #else   /* _AMIGA */
2012
2013 /* Do the Amiga version of func_shell.  */
2014
2015 char *
2016 func_shell_base (char *o, char **argv, int trim_newlines)
2017 {
2018   /* Amiga can't fork nor spawn, but I can start a program with
2019      redirection of my choice.  However, this means that we
2020      don't have an opportunity to reopen stdout to trap it.  Thus,
2021      we save our own stdout onto a new descriptor and dup a temp
2022      file's descriptor onto our stdout temporarily.  After we
2023      spawn the shell program, we dup our own stdout back to the
2024      stdout descriptor.  The buffer reading is the same as above,
2025      except that we're now reading from a file.  */
2026
2027 #include <dos/dos.h>
2028 #include <proto/dos.h>
2029
2030   BPTR child_stdout;
2031   char tmp_output[FILENAME_MAX];
2032   size_t maxlen = 200, i;
2033   int cc;
2034   char * buffer, * ptr;
2035   char ** aptr;
2036   size_t len = 0;
2037   char* batch_filename = NULL;
2038
2039   /* Construct the argument list.  */
2040   command_argv = construct_command_argv (argv[0], NULL, NULL, 0,
2041                                          &batch_filename);
2042   if (command_argv == 0)
2043     return o;
2044
2045   /* Note the mktemp() is a security hole, but this only runs on Amiga.
2046      Ideally we would use get_tmpfile(), but this uses a special Open(), not
2047      fopen(), and I'm not familiar enough with the code to mess with it.  */
2048   strcpy (tmp_output, "t:MakeshXXXXXXXX");
2049   mktemp (tmp_output);
2050   child_stdout = Open (tmp_output, MODE_NEWFILE);
2051
2052   for (aptr=command_argv; *aptr; aptr++)
2053     len += strlen (*aptr) + 1;
2054
2055   buffer = xmalloc (len + 1);
2056   ptr = buffer;
2057
2058   for (aptr=command_argv; *aptr; aptr++)
2059     {
2060       strcpy (ptr, *aptr);
2061       ptr += strlen (ptr) + 1;
2062       *(ptr++) = ' ';
2063       *ptr = '\0';
2064     }
2065
2066   ptr[-1] = '\n';
2067
2068   Execute (buffer, NULL, child_stdout);
2069   free (buffer);
2070
2071   Close (child_stdout);
2072
2073   child_stdout = Open (tmp_output, MODE_OLDFILE);
2074
2075   buffer = xmalloc (maxlen);
2076   i = 0;
2077   do
2078     {
2079       if (i == maxlen)
2080         {
2081           maxlen += 512;
2082           buffer = xrealloc (buffer, maxlen + 1);
2083         }
2084
2085       cc = Read (child_stdout, &buffer[i], maxlen - i);
2086       if (cc > 0)
2087         i += cc;
2088     } while (cc > 0);
2089
2090   Close (child_stdout);
2091
2092   fold_newlines (buffer, &i, trim_newlines);
2093   o = variable_buffer_output (o, buffer, i);
2094   free (buffer);
2095   return o;
2096 }
2097 #endif  /* _AMIGA */
2098
2099 static char *
2100 func_shell (char *o, char **argv, const char *funcname UNUSED)
2101 {
2102   return func_shell_base (o, argv, 1);
2103 }
2104 #endif  /* !VMS */
2105
2106 #ifdef EXPERIMENTAL
2107
2108 /*
2109   equality. Return is string-boolean, i.e., the empty string is false.
2110  */
2111 static char *
2112 func_eq (char *o, char **argv, char *funcname UNUSED)
2113 {
2114   int result = ! strcmp (argv[0], argv[1]);
2115   o = variable_buffer_output (o,  result ? "1" : "", result);
2116   return o;
2117 }
2118
2119
2120 /*
2121   string-boolean not operator.
2122  */
2123 static char *
2124 func_not (char *o, char **argv, char *funcname UNUSED)
2125 {
2126   const char *s = argv[0];
2127   int result = 0;
2128   NEXT_TOKEN (s);
2129   result = ! (*s);
2130   o = variable_buffer_output (o,  result ? "1" : "", result);
2131   return o;
2132 }
2133 #endif
2134 \f
2135
2136 #ifdef HAVE_DOS_PATHS
2137 # ifdef __CYGWIN__
2138 #  define IS_ABSOLUTE(n) ((n[0] && n[1] == ':') || ISDIRSEP (n[0]))
2139 # else
2140 #  define IS_ABSOLUTE(n) (n[0] && n[1] == ':')
2141 # endif
2142 # define ROOT_LEN 3
2143 #else
2144 # define IS_ABSOLUTE(n) (n[0] == '/')
2145 # define ROOT_LEN 1
2146 #endif
2147
2148 /* Return the absolute name of file NAME which does not contain any '.',
2149    '..' components nor any repeated path separators ('/').   */
2150
2151 static char *
2152 abspath (const char *name, char *apath)
2153 {
2154   char *dest;
2155   const char *start, *end, *apath_limit;
2156   unsigned long root_len = ROOT_LEN;
2157
2158   if (name[0] == '\0')
2159     return NULL;
2160
2161   apath_limit = apath + GET_PATH_MAX;
2162
2163   if (!IS_ABSOLUTE(name))
2164     {
2165       /* It is unlikely we would make it until here but just to make sure. */
2166       if (!starting_directory)
2167         return NULL;
2168
2169       strcpy (apath, starting_directory);
2170
2171 #ifdef HAVE_DOS_PATHS
2172       if (ISDIRSEP (name[0]))
2173         {
2174           if (ISDIRSEP (name[1]))
2175             {
2176               /* A UNC.  Don't prepend a drive letter.  */
2177               apath[0] = name[0];
2178               apath[1] = name[1];
2179               root_len = 2;
2180             }
2181           /* We have /foo, an absolute file name except for the drive
2182              letter.  Assume the missing drive letter is the current
2183              drive, which we can get if we remove from starting_directory
2184              everything past the root directory.  */
2185           apath[root_len] = '\0';
2186         }
2187 #endif
2188
2189       dest = strchr (apath, '\0');
2190     }
2191   else
2192     {
2193 #if defined(__CYGWIN__) && defined(HAVE_DOS_PATHS)
2194       if (ISDIRSEP (name[0]))
2195         root_len = 1;
2196 #endif
2197       memcpy (apath, name, root_len);
2198       apath[root_len] = '\0';
2199       dest = apath + root_len;
2200       /* Get past the root, since we already copied it.  */
2201       name += root_len;
2202 #ifdef HAVE_DOS_PATHS
2203       if (! ISDIRSEP (apath[root_len - 1]))
2204         {
2205           /* Convert d:foo into d:./foo and increase root_len.  */
2206           apath[2] = '.';
2207           apath[3] = '/';
2208           dest++;
2209           root_len++;
2210           /* strncpy above copied one character too many.  */
2211           name--;
2212         }
2213       else
2214         apath[root_len - 1] = '/'; /* make sure it's a forward slash */
2215 #endif
2216     }
2217
2218   for (start = end = name; *start != '\0'; start = end)
2219     {
2220       size_t len;
2221
2222       /* Skip sequence of multiple path-separators.  */
2223       while (ISDIRSEP (*start))
2224         ++start;
2225
2226       /* Find end of path component.  */
2227       for (end = start; ! STOP_SET (*end, MAP_DIRSEP|MAP_NUL); ++end)
2228         ;
2229
2230       len = end - start;
2231
2232       if (len == 0)
2233         break;
2234       else if (len == 1 && start[0] == '.')
2235         /* nothing */;
2236       else if (len == 2 && start[0] == '.' && start[1] == '.')
2237         {
2238           /* Back up to previous component, ignore if at root already.  */
2239           if (dest > apath + root_len)
2240             for (--dest; ! ISDIRSEP (dest[-1]); --dest)
2241               ;
2242         }
2243       else
2244         {
2245           if (! ISDIRSEP (dest[-1]))
2246             *dest++ = '/';
2247
2248           if (dest + len >= apath_limit)
2249             return NULL;
2250
2251           dest = mempcpy (dest, start, len);
2252           *dest = '\0';
2253         }
2254     }
2255
2256   /* Unless it is root strip trailing separator.  */
2257   if (dest > apath + root_len && ISDIRSEP (dest[-1]))
2258     --dest;
2259
2260   *dest = '\0';
2261
2262   return apath;
2263 }
2264
2265
2266 static char *
2267 func_realpath (char *o, char **argv, const char *funcname UNUSED)
2268 {
2269   /* Expand the argument.  */
2270   const char *p = argv[0];
2271   const char *path = 0;
2272   int doneany = 0;
2273   size_t len = 0;
2274
2275   while ((path = find_next_token (&p, &len)) != 0)
2276     {
2277       if (len < GET_PATH_MAX)
2278         {
2279           char *rp;
2280           struct stat st;
2281           PATH_VAR (in);
2282           PATH_VAR (out);
2283
2284           strncpy (in, path, len);
2285           in[len] = '\0';
2286
2287 #ifdef HAVE_REALPATH
2288           ENULLLOOP (rp, realpath (in, out));
2289 # if defined _AIX
2290           /* AIX realpath() doesn't remove trailing slashes correctly.  */
2291           if (rp)
2292             {
2293               char *ep = rp + strlen (rp) - 1;
2294               while (ep > rp && ep[0] == '/')
2295                 *(ep--) = '\0';
2296             }
2297 # endif
2298 #else
2299           rp = abspath (in, out);
2300 #endif
2301
2302           if (rp)
2303             {
2304               int r;
2305               EINTRLOOP (r, stat (out, &st));
2306               if (r == 0)
2307                 {
2308                   o = variable_buffer_output (o, out, strlen (out));
2309                   o = variable_buffer_output (o, " ", 1);
2310                   doneany = 1;
2311                 }
2312             }
2313         }
2314     }
2315
2316   /* Kill last space.  */
2317   if (doneany)
2318     --o;
2319
2320   return o;
2321 }
2322
2323 static char *
2324 func_file (char *o, char **argv, const char *funcname UNUSED)
2325 {
2326   char *fn = argv[0];
2327
2328   if (fn[0] == '>')
2329     {
2330       FILE *fp;
2331       const char *mode = "w";
2332
2333       /* We are writing a file.  */
2334       ++fn;
2335       if (fn[0] == '>')
2336         {
2337           mode = "a";
2338           ++fn;
2339         }
2340       NEXT_TOKEN (fn);
2341
2342       if (fn[0] == '\0')
2343         O (fatal, *expanding_var, _("file: missing filename"));
2344
2345       ENULLLOOP (fp, fopen (fn, mode));
2346       if (fp == NULL)
2347         OSS (fatal, reading_file, _("open: %s: %s"), fn, strerror (errno));
2348
2349       /* We've changed the contents of a directory, possibly.
2350          Another option would be to look up the directory we changed and reset
2351          its counter to 0.  */
2352       ++command_count;
2353
2354       if (argv[1])
2355         {
2356           size_t l = strlen (argv[1]);
2357           int nl = l == 0 || argv[1][l-1] != '\n';
2358
2359           if (fputs (argv[1], fp) == EOF || (nl && fputc ('\n', fp) == EOF))
2360             OSS (fatal, reading_file, _("write: %s: %s"), fn, strerror (errno));
2361         }
2362       if (fclose (fp))
2363         OSS (fatal, reading_file, _("close: %s: %s"), fn, strerror (errno));
2364     }
2365   else if (fn[0] == '<')
2366     {
2367       size_t n = 0;
2368       FILE *fp;
2369
2370       ++fn;
2371       NEXT_TOKEN (fn);
2372       if (fn[0] == '\0')
2373         O (fatal, *expanding_var, _("file: missing filename"));
2374
2375       if (argv[1])
2376         O (fatal, *expanding_var, _("file: too many arguments"));
2377
2378       ENULLLOOP (fp, fopen (fn, "r"));
2379       if (fp == NULL)
2380         {
2381           if (errno == ENOENT)
2382             return o;
2383           OSS (fatal, reading_file, _("open: %s: %s"), fn, strerror (errno));
2384         }
2385
2386       while (1)
2387         {
2388           char buf[1024];
2389           size_t l = fread (buf, 1, sizeof (buf), fp);
2390           if (l > 0)
2391             {
2392               o = variable_buffer_output (o, buf, l);
2393               n += l;
2394             }
2395           if (ferror (fp))
2396             if (errno != EINTR)
2397               OSS (fatal, reading_file, _("read: %s: %s"), fn, strerror (errno));
2398           if (feof (fp))
2399             break;
2400         }
2401       if (fclose (fp))
2402         OSS (fatal, reading_file, _("close: %s: %s"), fn, strerror (errno));
2403
2404       /* Remove trailing newline.  */
2405       if (n && o[-1] == '\n')
2406         o -= 1 + (n > 1 && o[-2] == '\r');
2407     }
2408   else
2409     OS (fatal, *expanding_var, _("file: invalid file operation: %s"), fn);
2410
2411   return o;
2412 }
2413
2414 static char *
2415 func_abspath (char *o, char **argv, const char *funcname UNUSED)
2416 {
2417   /* Expand the argument.  */
2418   const char *p = argv[0];
2419   const char *path = 0;
2420   int doneany = 0;
2421   size_t len = 0;
2422
2423   while ((path = find_next_token (&p, &len)) != 0)
2424     {
2425       if (len < GET_PATH_MAX)
2426         {
2427           PATH_VAR (in);
2428           PATH_VAR (out);
2429
2430           strncpy (in, path, len);
2431           in[len] = '\0';
2432
2433           if (abspath (in, out))
2434             {
2435               o = variable_buffer_output (o, out, strlen (out));
2436               o = variable_buffer_output (o, " ", 1);
2437               doneany = 1;
2438             }
2439         }
2440     }
2441
2442   /* Kill last space.  */
2443   if (doneany)
2444     --o;
2445
2446   return o;
2447 }
2448
2449 /* Lookup table for builtin functions.
2450
2451    This doesn't have to be sorted; we use a straight lookup.  We might gain
2452    some efficiency by moving most often used functions to the start of the
2453    table.
2454
2455    If MAXIMUM_ARGS is 0, that means there is no maximum and all
2456    comma-separated values are treated as arguments.
2457
2458    EXPAND_ARGS means that all arguments should be expanded before invocation.
2459    Functions that do namespace tricks (foreach, let) don't automatically
2460    expand.  */
2461
2462 static char *func_call (char *o, char **argv, const char *funcname);
2463
2464 #define FT_ENTRY(_name, _min, _max, _exp, _func) \
2465   { { (_func) }, STRING_SIZE_TUPLE(_name), (_min), (_max), (_exp), 0, 0 }
2466
2467 static struct function_table_entry function_table_init[] =
2468 {
2469  /*         Name            MIN MAX EXP? Function */
2470   FT_ENTRY ("abspath",       0,  1,  1,  func_abspath),
2471   FT_ENTRY ("addprefix",     2,  2,  1,  func_addsuffix_addprefix),
2472   FT_ENTRY ("addsuffix",     2,  2,  1,  func_addsuffix_addprefix),
2473   FT_ENTRY ("basename",      0,  1,  1,  func_basename_dir),
2474   FT_ENTRY ("dir",           0,  1,  1,  func_basename_dir),
2475   FT_ENTRY ("notdir",        0,  1,  1,  func_notdir_suffix),
2476   FT_ENTRY ("subst",         3,  3,  1,  func_subst),
2477   FT_ENTRY ("suffix",        0,  1,  1,  func_notdir_suffix),
2478   FT_ENTRY ("filter",        2,  2,  1,  func_filter_filterout),
2479   FT_ENTRY ("filter-out",    2,  2,  1,  func_filter_filterout),
2480   FT_ENTRY ("findstring",    2,  2,  1,  func_findstring),
2481   FT_ENTRY ("firstword",     0,  1,  1,  func_firstword),
2482   FT_ENTRY ("flavor",        0,  1,  1,  func_flavor),
2483   FT_ENTRY ("join",          2,  2,  1,  func_join),
2484   FT_ENTRY ("lastword",      0,  1,  1,  func_lastword),
2485   FT_ENTRY ("patsubst",      3,  3,  1,  func_patsubst),
2486   FT_ENTRY ("realpath",      0,  1,  1,  func_realpath),
2487   FT_ENTRY ("shell",         0,  1,  1,  func_shell),
2488   FT_ENTRY ("sort",          0,  1,  1,  func_sort),
2489   FT_ENTRY ("strip",         0,  1,  1,  func_strip),
2490   FT_ENTRY ("wildcard",      0,  1,  1,  func_wildcard),
2491   FT_ENTRY ("word",          2,  2,  1,  func_word),
2492   FT_ENTRY ("wordlist",      3,  3,  1,  func_wordlist),
2493   FT_ENTRY ("words",         0,  1,  1,  func_words),
2494   FT_ENTRY ("origin",        0,  1,  1,  func_origin),
2495   FT_ENTRY ("foreach",       3,  3,  0,  func_foreach),
2496   FT_ENTRY ("let",           3,  3,  0,  func_let),
2497   FT_ENTRY ("call",          1,  0,  1,  func_call),
2498   FT_ENTRY ("info",          0,  1,  1,  func_error),
2499   FT_ENTRY ("error",         0,  1,  1,  func_error),
2500   FT_ENTRY ("warning",       0,  1,  1,  func_error),
2501   FT_ENTRY ("intcmp",        2,  5,  0,  func_intcmp),
2502   FT_ENTRY ("if",            2,  3,  0,  func_if),
2503   FT_ENTRY ("or",            1,  0,  0,  func_or),
2504   FT_ENTRY ("and",           1,  0,  0,  func_and),
2505   FT_ENTRY ("value",         0,  1,  1,  func_value),
2506   FT_ENTRY ("eval",          0,  1,  1,  func_eval),
2507   FT_ENTRY ("file",          1,  2,  1,  func_file),
2508 #ifdef EXPERIMENTAL
2509   FT_ENTRY ("eq",            2,  2,  1,  func_eq),
2510   FT_ENTRY ("not",           0,  1,  1,  func_not),
2511 #endif
2512 };
2513
2514 #define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry))
2515 \f
2516
2517 /* These must come after the definition of function_table.  */
2518
2519 static char *
2520 expand_builtin_function (char *o, unsigned int argc, char **argv,
2521                          const struct function_table_entry *entry_p)
2522 {
2523   char *p;
2524
2525   if (argc < entry_p->minimum_args)
2526     fatal (*expanding_var, strlen (entry_p->name),
2527            _("insufficient number of arguments (%u) to function '%s'"),
2528            argc, entry_p->name);
2529
2530   /* I suppose technically some function could do something with no arguments,
2531      but so far no internal ones do, so just test it for all functions here
2532      rather than in each one.  We can change it later if necessary.  */
2533
2534   if (!argc && !entry_p->alloc_fn)
2535     return o;
2536
2537   if (!entry_p->fptr.func_ptr)
2538     OS (fatal, *expanding_var,
2539         _("unimplemented on this platform: function '%s'"), entry_p->name);
2540
2541   if (entry_p->adds_command)
2542     ++command_count;
2543
2544   if (!entry_p->alloc_fn)
2545     return entry_p->fptr.func_ptr (o, argv, entry_p->name);
2546
2547   /* This function allocates memory and returns it to us.
2548      Write it to the variable buffer, then free it.  */
2549
2550   p = entry_p->fptr.alloc_func_ptr (entry_p->name, argc, argv);
2551   if (p)
2552     {
2553       o = variable_buffer_output (o, p, strlen (p));
2554       free (p);
2555     }
2556
2557   return o;
2558 }
2559
2560 /* Check for a function invocation in *STRINGP.  *STRINGP points at the
2561    opening ( or { and is not null-terminated.  If a function invocation
2562    is found, expand it into the buffer at *OP, updating *OP, incrementing
2563    *STRINGP past the reference and returning nonzero.  If not, return zero.  */
2564
2565 int
2566 handle_function (char **op, const char **stringp)
2567 {
2568   const struct function_table_entry *entry_p;
2569   char openparen = (*stringp)[0];
2570   char closeparen = openparen == '(' ? ')' : '}';
2571   const char *beg;
2572   const char *end;
2573   int count = 0;
2574   char *abeg = NULL;
2575   char **argv, **argvp;
2576   unsigned int nargs;
2577
2578   beg = *stringp + 1;
2579
2580   entry_p = lookup_function (beg);
2581
2582   if (!entry_p)
2583     return 0;
2584
2585   /* We found a builtin function.  Find the beginning of its arguments (skip
2586      whitespace after the name).  */
2587
2588   beg += entry_p->len;
2589   NEXT_TOKEN (beg);
2590
2591   /* Find the end of the function invocation, counting nested use of
2592      whichever kind of parens we use.  Since we're looking, count commas
2593      to get a rough estimate of how many arguments we might have.  The
2594      count might be high, but it'll never be low.  */
2595
2596   for (nargs=1, end=beg; *end != '\0'; ++end)
2597     if (!STOP_SET (*end, MAP_VARSEP|MAP_COMMA))
2598       continue;
2599     else if (*end == ',')
2600       ++nargs;
2601     else if (*end == openparen)
2602       ++count;
2603     else if (*end == closeparen && --count < 0)
2604       break;
2605
2606   if (count >= 0)
2607     fatal (*expanding_var, strlen (entry_p->name),
2608            _("unterminated call to function '%s': missing '%c'"),
2609            entry_p->name, closeparen);
2610
2611   *stringp = end;
2612
2613   /* Get some memory to store the arg pointers.  */
2614   argvp = argv = alloca (sizeof (char *) * (nargs + 2));
2615
2616   /* Chop the string into arguments, then a nul.  As soon as we hit
2617      MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the
2618      last argument.
2619
2620      If we're expanding, store pointers to the expansion of each one.  If
2621      not, make a duplicate of the string and point into that, nul-terminating
2622      each argument.  */
2623
2624   if (entry_p->expand_args)
2625     {
2626       const char *p;
2627       for (p=beg, nargs=0; p <= end; ++argvp)
2628         {
2629           const char *next;
2630
2631           ++nargs;
2632
2633           if (nargs == entry_p->maximum_args
2634               || ((next = find_next_argument (openparen, closeparen, p, end)) == NULL))
2635             next = end;
2636
2637           *argvp = expand_argument (p, next);
2638           p = next + 1;
2639         }
2640     }
2641   else
2642     {
2643       size_t len = end - beg;
2644       char *p, *aend;
2645
2646       abeg = xmalloc (len+1);
2647       aend = mempcpy (abeg, beg, len);
2648       *aend = '\0';
2649
2650       for (p=abeg, nargs=0; p <= aend; ++argvp)
2651         {
2652           char *next;
2653
2654           ++nargs;
2655
2656           if (nargs == entry_p->maximum_args
2657               || ((next = find_next_argument (openparen, closeparen, p, aend)) == NULL))
2658             next = aend;
2659
2660           *argvp = p;
2661           *next = '\0';
2662           p = next + 1;
2663         }
2664     }
2665   *argvp = NULL;
2666
2667   /* Finally!  Run the function...  */
2668   *op = expand_builtin_function (*op, nargs, argv, entry_p);
2669
2670   /* Free memory.  */
2671   if (entry_p->expand_args)
2672     for (argvp=argv; *argvp != 0; ++argvp)
2673       free (*argvp);
2674   else
2675     free (abeg);
2676
2677   return 1;
2678 }
2679 \f
2680
2681 /* User-defined functions.  Expand the first argument as either a builtin
2682    function or a make variable, in the context of the rest of the arguments
2683    assigned to $1, $2, ... $N.  $0 is the name of the function.  */
2684
2685 static char *
2686 func_call (char *o, char **argv, const char *funcname UNUSED)
2687 {
2688   static unsigned int max_args = 0;
2689   char *fname;
2690   char *body;
2691   size_t flen;
2692   unsigned int i;
2693   int saved_args;
2694   const struct function_table_entry *entry_p;
2695   struct variable *v;
2696
2697   /* Clean up the name of the variable to be invoked.  */
2698   fname = next_token (argv[0]);
2699   end_of_token (fname)[0] = '\0';
2700
2701   /* Calling nothing is a no-op */
2702   if (*fname == '\0')
2703     return o;
2704
2705   /* Are we invoking a builtin function?  */
2706
2707   entry_p = lookup_function (fname);
2708   if (entry_p)
2709     {
2710       /* How many arguments do we have?  */
2711       for (i=0; argv[i+1]; ++i)
2712         ;
2713       return expand_builtin_function (o, i, argv+1, entry_p);
2714     }
2715
2716   /* Not a builtin, so the first argument is the name of a variable to be
2717      expanded and interpreted as a function.  Find it.  */
2718   flen = strlen (fname);
2719
2720   v = lookup_variable (fname, flen);
2721
2722   if (v == 0)
2723     warn_undefined (fname, flen);
2724
2725   if (v == 0 || *v->value == '\0')
2726     return o;
2727
2728   body = alloca (flen + 4);
2729   body[0] = '$';
2730   body[1] = '(';
2731   memcpy (body + 2, fname, flen);
2732   body[flen+2] = ')';
2733   body[flen+3] = '\0';
2734
2735   /* Set up arguments $(1) .. $(N).  $(0) is the function name.  */
2736
2737   push_new_variable_scope ();
2738
2739   for (i=0; *argv; ++i, ++argv)
2740     {
2741       char num[INTSTR_LENGTH];
2742
2743       sprintf (num, "%u", i);
2744       define_variable (num, strlen (num), *argv, o_automatic, 0);
2745     }
2746
2747   /* If the number of arguments we have is < max_args, it means we're inside
2748      a recursive invocation of $(call ...).  Fill in the remaining arguments
2749      in the new scope with the empty value, to hide them from this
2750      invocation.  */
2751
2752   for (; i < max_args; ++i)
2753     {
2754       char num[INTSTR_LENGTH];
2755
2756       sprintf (num, "%u", i);
2757       define_variable (num, strlen (num), "", o_automatic, 0);
2758     }
2759
2760   /* Expand the body in the context of the arguments, adding the result to
2761      the variable buffer.  */
2762
2763   v->exp_count = EXP_COUNT_MAX;
2764
2765   saved_args = max_args;
2766   max_args = i;
2767   o = variable_expand_string (o, body, flen+3);
2768   max_args = saved_args;
2769
2770   v->exp_count = 0;
2771
2772   pop_variable_scope ();
2773
2774   return o + strlen (o);
2775 }
2776
2777 void
2778 define_new_function (const floc *flocp, const char *name,
2779                      unsigned int min, unsigned int max, unsigned int flags,
2780                      gmk_func_ptr func)
2781 {
2782   const char *e = name;
2783   struct function_table_entry *ent;
2784   size_t len;
2785
2786   while (STOP_SET (*e, MAP_USERFUNC))
2787     e++;
2788   len = e - name;
2789
2790   if (len == 0)
2791     O (fatal, flocp, _("Empty function name"));
2792   if (*name == '.' || *e != '\0')
2793     OS (fatal, flocp, _("Invalid function name: %s"), name);
2794   if (len > 255)
2795     OS (fatal, flocp, _("Function name too long: %s"), name);
2796   if (min > 255)
2797     ONS (fatal, flocp,
2798          _("Invalid minimum argument count (%u) for function %s"), min, name);
2799   if (max > 255 || (max && max < min))
2800     ONS (fatal, flocp,
2801          _("Invalid maximum argument count (%u) for function %s"), max, name);
2802
2803   ent = xmalloc (sizeof (struct function_table_entry));
2804   ent->name = name;
2805   ent->len = (unsigned char) len;
2806   ent->minimum_args = (unsigned char) min;
2807   ent->maximum_args = (unsigned char) max;
2808   ent->expand_args = ANY_SET(flags, GMK_FUNC_NOEXPAND) ? 0 : 1;
2809   ent->alloc_fn = 1;
2810   /* We don't know what this function will do.  */
2811   ent->adds_command = 1;
2812   ent->fptr.alloc_func_ptr = func;
2813
2814   ent = hash_insert (&function_table, ent);
2815   free (ent);
2816 }
2817
2818 void
2819 hash_init_function_table (void)
2820 {
2821   hash_init (&function_table, FUNCTION_TABLE_ENTRIES * 2,
2822              function_table_entry_hash_1, function_table_entry_hash_2,
2823              function_table_entry_hash_cmp);
2824   hash_load (&function_table, function_table_init,
2825              FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));
2826 }