1/* Builtin function expansion for GNU Make. 2Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 31998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software 4Foundation, Inc. 5This file is part of GNU Make. 6 7GNU Make is free software; you can redistribute it and/or modify it under the 8terms of the GNU General Public License as published by the Free Software 9Foundation; either version 2, or (at your option) any later version. 10 11GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR 13A PARTICULAR PURPOSE. See the GNU General Public License for more details. 14 15You should have received a copy of the GNU General Public License along with 16GNU Make; see the file COPYING. If not, write to the Free Software 17Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */ 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 32struct 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) PARAMS ((char *output, char **argv, const char *fname)); 40 }; 41 42static unsigned long 43function_table_entry_hash_1 (const void *keyv) 44{ 45 struct function_table_entry const *key = (struct function_table_entry const *) keyv; 46 return_STRING_N_HASH_1 (key->name, key->len); 47} 48 49static unsigned long 50function_table_entry_hash_2 (const void *keyv) 51{ 52 struct function_table_entry const *key = (struct function_table_entry const *) keyv; 53 return_STRING_N_HASH_2 (key->name, key->len); 54} 55 56static int 57function_table_entry_hash_cmp (const void *xv, const void *yv) 58{ 59 struct function_table_entry const *x = (struct function_table_entry const *) xv; 60 struct function_table_entry const *y = (struct function_table_entry const *) 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 67static struct hash_table function_table; 68 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 76char * 77subst_expand (char *o, char *text, char *subst, char *replace, 78 unsigned int slen, unsigned int rlen, int by_word) 79{ 80 char *t = text; 81 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 { 127 char *nt = p + slen; 128 t = nt; 129 } 130 } while (*t != '\0'); 131 132 return o; 133} 134 135 136/* Store into VARIABLE_BUFFER at O the result of scanning TEXT 137 and replacing strings matching PATTERN with REPLACE. 138 If PATTERN_PERCENT is not nil, PATTERN has already been 139 run through find_percent, and PATTERN_PERCENT is the result. 140 If REPLACE_PERCENT is not nil, REPLACE has already been 141 run through find_percent, and REPLACE_PERCENT is the result. 142 Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the 143 character _AFTER_ the %, not to the % itself. 144*/ 145 146char * 147patsubst_expand (char *o, char *text, char *pattern, char *replace, 148 char *pattern_percent, char *replace_percent) 149{ 150 unsigned int pattern_prepercent_len, pattern_postpercent_len; 151 unsigned int replace_prepercent_len, replace_postpercent_len; 152 char *t; 153 unsigned int len; 154 int doneany = 0; 155 156 /* We call find_percent on REPLACE before checking PATTERN so that REPLACE 157 will be collapsed before we call subst_expand if PATTERN has no %. */ 158 if (!replace_percent) 159 { 160 replace_percent = find_percent (replace); 161 if (replace_percent) 162 ++replace_percent; 163 } 164 165 /* Record the length of REPLACE before and after the % so we don't have to 166 compute these lengths more than once. */ 167 if (replace_percent) 168 { 169 replace_prepercent_len = replace_percent - replace - 1; 170 replace_postpercent_len = strlen (replace_percent); 171 } 172 else 173 { 174 replace_prepercent_len = strlen (replace); 175 replace_postpercent_len = 0; 176 } 177 178 if (!pattern_percent) 179 { 180 pattern_percent = find_percent (pattern); 181 if (pattern_percent) 182 ++pattern_percent; 183 } 184 if (!pattern_percent) 185 /* With no % in the pattern, this is just a simple substitution. */ 186 return subst_expand (o, text, pattern, replace, 187 strlen (pattern), strlen (replace), 1); 188 189 /* Record the length of PATTERN before and after the % 190 so we don't have to compute it more than once. */ 191 pattern_prepercent_len = pattern_percent - pattern - 1; 192 pattern_postpercent_len = strlen (pattern_percent); 193 194 while ((t = find_next_token (&text, &len)) != 0) 195 { 196 int fail = 0; 197 198 /* Is it big enough to match? */ 199 if (len < pattern_prepercent_len + pattern_postpercent_len) 200 fail = 1; 201 202 /* Does the prefix match? */ 203 if (!fail && pattern_prepercent_len > 0 204 && (*t != *pattern 205 || t[pattern_prepercent_len - 1] != pattern_percent[-2] 206 || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1))) 207 fail = 1; 208 209 /* Does the suffix match? */ 210 if (!fail && pattern_postpercent_len > 0 211 && (t[len - 1] != pattern_percent[pattern_postpercent_len - 1] 212 || t[len - pattern_postpercent_len] != *pattern_percent 213 || !strneq (&t[len - pattern_postpercent_len], 214 pattern_percent, pattern_postpercent_len - 1))) 215 fail = 1; 216 217 if (fail) 218 /* It didn't match. Output the string. */ 219 o = variable_buffer_output (o, t, len); 220 else 221 { 222 /* It matched. Output the replacement. */ 223 224 /* Output the part of the replacement before the %. */ 225 o = variable_buffer_output (o, replace, replace_prepercent_len); 226 227 if (replace_percent != 0) 228 { 229 /* Output the part of the matched string that 230 matched the % in the pattern. */ 231 o = variable_buffer_output (o, t + pattern_prepercent_len, 232 len - (pattern_prepercent_len 233 + pattern_postpercent_len)); 234 /* Output the part of the replacement after the %. */ 235 o = variable_buffer_output (o, replace_percent, 236 replace_postpercent_len); 237 } 238 } 239 240 /* Output a space, but not if the replacement is "". */ 241 if (fail || replace_prepercent_len > 0 242 || (replace_percent != 0 && len + replace_postpercent_len > 0)) 243 { 244 o = variable_buffer_output (o, " ", 1); 245 doneany = 1; 246 } 247 } 248 if (doneany) 249 /* Kill the last space. */ 250 --o; 251 252 return o; 253} 254 255 256/* Look up a function by name. */ 257 258static const struct function_table_entry * 259lookup_function (const char *s) 260{ 261 const char *e = s; 262 263 while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-')) 264 e++; 265 if (*e == '\0' || isblank ((unsigned char) *e)) 266 { 267 struct function_table_entry function_table_entry_key; 268 function_table_entry_key.name = s; 269 function_table_entry_key.len = e - s; 270 271 return hash_find_item (&function_table, &function_table_entry_key); 272 } 273 return 0; 274} 275 276 277/* Return 1 if PATTERN matches STR, 0 if not. */ 278 279int 280pattern_matches (char *pattern, char *percent, char *str) 281{ 282 unsigned int sfxlen, strlength; 283 284 if (percent == 0) 285 { 286 unsigned int len = strlen (pattern) + 1; 287 char *new_chars = (char *) alloca (len); 288 bcopy (pattern, new_chars, len); 289 pattern = new_chars; 290 percent = find_percent (pattern); 291 if (percent == 0) 292 return streq (pattern, str); 293 } 294 295 sfxlen = strlen (percent + 1); 296 strlength = strlen (str); 297 298 if (strlength < (percent - pattern) + sfxlen 299 || !strneq (pattern, str, percent - pattern)) 300 return 0; 301 302 return !strcmp (percent + 1, str + (strlength - sfxlen)); 303} 304 305 306/* Find the next comma or ENDPAREN (counting nested STARTPAREN and 307 ENDPARENtheses), starting at PTR before END. Return a pointer to 308 next character. 309 310 If no next argument is found, return NULL. 311*/ 312 313static char * 314find_next_argument (char startparen, char endparen, 315 const char *ptr, const char *end) 316{ 317 int count = 0; 318 319 for (; ptr < end; ++ptr) 320 if (*ptr == startparen) 321 ++count; 322 323 else if (*ptr == endparen) 324 { 325 --count; 326 if (count < 0) 327 return NULL; 328 } 329 330 else if (*ptr == ',' && !count) 331 return (char *)ptr; 332 333 /* We didn't find anything. */ 334 return NULL; 335} 336 337 338/* Glob-expand LINE. The returned pointer is 339 only good until the next call to string_glob. */ 340 341static char * 342string_glob (char *line) 343{ 344 static char *result = 0; 345 static unsigned int length; 346 register struct nameseq *chain; 347 register unsigned int idx; 348 349 chain = multi_glob (parse_file_seq 350 (&line, '\0', sizeof (struct nameseq), 351 /* We do not want parse_file_seq to strip `./'s. 352 That would break examples like: 353 $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)). */ 354 0), 355 sizeof (struct nameseq)); 356 357 if (result == 0) 358 { 359 length = 100; 360 result = (char *) xmalloc (100); 361 } 362 363 idx = 0; 364 while (chain != 0) 365 { 366 register char *name = chain->name; 367 unsigned int len = strlen (name); 368 369 struct nameseq *next = chain->next; 370 free ((char *) chain); 371 chain = next; 372 373 /* multi_glob will pass names without globbing metacharacters 374 through as is, but we want only files that actually exist. */ 375 if (file_exists_p (name)) 376 { 377 if (idx + len + 1 > length) 378 { 379 length += (len + 1) * 2; 380 result = (char *) xrealloc (result, length); 381 } 382 bcopy (name, &result[idx], len); 383 idx += len; 384 result[idx++] = ' '; 385 } 386 387 free (name); 388 } 389 390 /* Kill the last space and terminate the string. */ 391 if (idx == 0) 392 result[0] = '\0'; 393 else 394 result[idx - 1] = '\0'; 395 396 return result; 397} 398 399/* 400 Builtin functions 401 */ 402 403static char * 404func_patsubst (char *o, char **argv, const char *funcname UNUSED) 405{ 406 o = patsubst_expand (o, argv[2], argv[0], argv[1], (char *) 0, (char *) 0); 407 return o; 408} 409 410 411static char * 412func_join (char *o, char **argv, const char *funcname UNUSED) 413{ 414 int doneany = 0; 415 416 /* Write each word of the first argument directly followed 417 by the corresponding word of the second argument. 418 If the two arguments have a different number of words, 419 the excess words are just output separated by blanks. */ 420 register char *tp; 421 register char *pp; 422 char *list1_iterator = argv[0]; 423 char *list2_iterator = argv[1]; 424 do 425 { 426 unsigned int len1, len2; 427 428 tp = find_next_token (&list1_iterator, &len1); 429 if (tp != 0) 430 o = variable_buffer_output (o, tp, len1); 431 432 pp = find_next_token (&list2_iterator, &len2); 433 if (pp != 0) 434 o = variable_buffer_output (o, pp, len2); 435 436 if (tp != 0 || pp != 0) 437 { 438 o = variable_buffer_output (o, " ", 1); 439 doneany = 1; 440 } 441 } 442 while (tp != 0 || pp != 0); 443 if (doneany) 444 /* Kill the last blank. */ 445 --o; 446 447 return o; 448} 449 450 451static char * 452func_origin (char *o, char **argv, const char *funcname UNUSED) 453{ 454 /* Expand the argument. */ 455 register struct variable *v = lookup_variable (argv[0], strlen (argv[0])); 456 if (v == 0) 457 o = variable_buffer_output (o, "undefined", 9); 458 else 459 switch (v->origin) 460 { 461 default: 462 case o_invalid: 463 abort (); 464 break; 465 case o_default: 466 o = variable_buffer_output (o, "default", 7); 467 break; 468 case o_env: 469 o = variable_buffer_output (o, "environment", 11); 470 break; 471 case o_file: 472 o = variable_buffer_output (o, "file", 4); 473 break; 474 case o_env_override: 475 o = variable_buffer_output (o, "environment override", 20); 476 break; 477 case o_command: 478 o = variable_buffer_output (o, "command line", 12); 479 break; 480 case o_override: 481 o = variable_buffer_output (o, "override", 8); 482 break; 483 case o_automatic: 484 o = variable_buffer_output (o, "automatic", 9); 485 break; 486 } 487 488 return o; 489} 490 491static char * 492func_flavor (char *o, char **argv, const char *funcname UNUSED) 493{ 494 register struct variable *v = lookup_variable (argv[0], strlen (argv[0])); 495 496 if (v == 0) 497 o = variable_buffer_output (o, "undefined", 9); 498 else 499 if (v->recursive) 500 o = variable_buffer_output (o, "recursive", 9); 501 else 502 o = variable_buffer_output (o, "simple", 6); 503 504 return o; 505} 506 507#ifdef VMS 508# define IS_PATHSEP(c) ((c) == ']') 509#else 510# ifdef HAVE_DOS_PATHS 511# define IS_PATHSEP(c) ((c) == '/' || (c) == '\\') 512# else 513# define IS_PATHSEP(c) ((c) == '/') 514# endif 515#endif 516 517 518static char * 519func_notdir_suffix (char *o, char **argv, const char *funcname) 520{ 521 /* Expand the argument. */ 522 char *list_iterator = argv[0]; 523 char *p2 =0; 524 int doneany =0; 525 unsigned int len=0; 526 527 int is_suffix = streq (funcname, "suffix"); 528 int is_notdir = !is_suffix; 529 while ((p2 = find_next_token (&list_iterator, &len)) != 0) 530 { 531 char *p = p2 + len; 532 533 534 while (p >= p2 && (!is_suffix || *p != '.')) 535 { 536 if (IS_PATHSEP (*p)) 537 break; 538 --p; 539 } 540 541 if (p >= p2) 542 { 543 if (is_notdir) 544 ++p; 545 else if (*p != '.') 546 continue; 547 o = variable_buffer_output (o, p, len - (p - p2)); 548 } 549#ifdef HAVE_DOS_PATHS 550 /* Handle the case of "d:foo/bar". */ 551 else if (streq (funcname, "notdir") && p2[0] && p2[1] == ':') 552 { 553 p = p2 + 2; 554 o = variable_buffer_output (o, p, len - (p - p2)); 555 } 556#endif 557 else if (is_notdir) 558 o = variable_buffer_output (o, p2, len); 559 560 if (is_notdir || p >= p2) 561 { 562 o = variable_buffer_output (o, " ", 1); 563 doneany = 1; 564 } 565 } 566 if (doneany) 567 /* Kill last space. */ 568 --o; 569 570 571 return o; 572 573} 574 575 576static char * 577func_basename_dir (char *o, char **argv, const char *funcname) 578{ 579 /* Expand the argument. */ 580 char *p3 = argv[0]; 581 char *p2=0; 582 int doneany=0; 583 unsigned int len=0; 584 char *p=0; 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 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 if (doneany) 625 /* Kill last space. */ 626 --o; 627 628 629 return o; 630} 631 632static char * 633func_addsuffix_addprefix (char *o, char **argv, const char *funcname) 634{ 635 int fixlen = strlen (argv[0]); 636 char *list_iterator = argv[1]; 637 int is_addprefix = streq (funcname, "addprefix"); 638 int is_addsuffix = !is_addprefix; 639 640 int doneany = 0; 641 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 662static char * 663func_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 672static char * 673func_firstword (char *o, char **argv, const char *funcname UNUSED) 674{ 675 unsigned int i; 676 char *words = argv[0]; /* Use a temp variable for find_next_token */ 677 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 685static char * 686func_lastword (char *o, char **argv, const char *funcname UNUSED) 687{ 688 unsigned int i; 689 char *words = argv[0]; /* Use a temp variable for find_next_token */ 690 char *p = 0; 691 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 702static char * 703func_words (char *o, char **argv, const char *funcname UNUSED) 704{ 705 int i = 0; 706 char *word_iterator = argv[0]; 707 char buf[20]; 708 709 while (find_next_token (&word_iterator, (unsigned int *) 0) != 0) 710 ++i; 711 712 sprintf (buf, "%d", i); 713 o = variable_buffer_output (o, buf, strlen (buf)); 714 715 716 return o; 717} 718 719/* Set begpp to point to the first non-whitespace character of the string, 720 * and endpp to point to the last non-whitespace character of the string. 721 * If the string is empty or contains nothing but whitespace, endpp will be 722 * begpp-1. 723 */ 724char * 725strip_whitespace (const char **begpp, const char **endpp) 726{ 727 while (*begpp <= *endpp && isspace ((unsigned char)**begpp)) 728 (*begpp) ++; 729 while (*endpp >= *begpp && isspace ((unsigned char)**endpp)) 730 (*endpp) --; 731 return (char *)*begpp; 732} 733 734static void 735check_numeric (const char *s, const char *message) 736{ 737 const char *end = s + strlen (s) - 1; 738 const char *beg = s; 739 strip_whitespace (&s, &end); 740 741 for (; s <= end; ++s) 742 if (!ISDIGIT (*s)) /* ISDIGIT only evals its arg once: see make.h. */ 743 break; 744 745 if (s <= end || end - beg < 0) 746 fatal (*expanding_var, "%s: '%s'", message, beg); 747} 748 749 750 751static char * 752func_word (char *o, char **argv, const char *funcname UNUSED) 753{ 754 char *end_p=0; 755 int i=0; 756 char *p=0; 757 758 /* Check the first argument. */ 759 check_numeric (argv[0], _("non-numeric first argument to `word' function")); 760 i = atoi (argv[0]); 761 762 if (i == 0) 763 fatal (*expanding_var, 764 _("first argument to `word' function must be greater than 0")); 765 766 767 end_p = argv[1]; 768 while ((p = find_next_token (&end_p, 0)) != 0) 769 if (--i == 0) 770 break; 771 772 if (i == 0) 773 o = variable_buffer_output (o, p, end_p - p); 774 775 return o; 776} 777 778static char * 779func_wordlist (char *o, char **argv, const char *funcname UNUSED) 780{ 781 int start, count; 782 783 /* Check the arguments. */ 784 check_numeric (argv[0], 785 _("non-numeric first argument to `wordlist' function")); 786 check_numeric (argv[1], 787 _("non-numeric second argument to `wordlist' function")); 788 789 start = atoi (argv[0]); 790 if (start < 1) 791 fatal (*expanding_var, 792 "invalid first argument to `wordlist' function: `%d'", start); 793 794 count = atoi (argv[1]) - start + 1; 795 796 if (count > 0) 797 { 798 char *p; 799 char *end_p = argv[2]; 800 801 /* Find the beginning of the "start"th word. */ 802 while (((p = find_next_token (&end_p, 0)) != 0) && --start) 803 ; 804 805 if (p) 806 { 807 /* Find the end of the "count"th word from start. */ 808 while (--count && (find_next_token (&end_p, 0) != 0)) 809 ; 810 811 /* Return the stuff in the middle. */ 812 o = variable_buffer_output (o, p, end_p - p); 813 } 814 } 815 816 return o; 817} 818 819static char* 820func_findstring (char *o, char **argv, const char *funcname UNUSED) 821{ 822 /* Find the first occurrence of the first string in the second. */ 823 if (strstr (argv[1], argv[0]) != 0) 824 o = variable_buffer_output (o, argv[0], strlen (argv[0])); 825 826 return o; 827} 828 829static char * 830func_foreach (char *o, char **argv, const char *funcname UNUSED) 831{ 832 /* expand only the first two. */ 833 char *varname = expand_argument (argv[0], NULL); 834 char *list = expand_argument (argv[1], NULL); 835 char *body = argv[2]; 836 837 int doneany = 0; 838 char *list_iterator = list; 839 char *p; 840 unsigned int len; 841 register struct variable *var; 842 843 push_new_variable_scope (); 844 var = define_variable (varname, strlen (varname), "", o_automatic, 0); 845 846 /* loop through LIST, put the value in VAR and expand BODY */ 847 while ((p = find_next_token (&list_iterator, &len)) != 0) 848 { 849 char *result = 0; 850 851 { 852 char save = p[len]; 853 854 p[len] = '\0'; 855 free (var->value); 856 var->value = (char *) xstrdup ((char*) p); 857 p[len] = save; 858 } 859 860 result = allocated_variable_expand (body); 861 862 o = variable_buffer_output (o, result, strlen (result)); 863 o = variable_buffer_output (o, " ", 1); 864 doneany = 1; 865 free (result); 866 } 867 868 if (doneany) 869 /* Kill the last space. */ 870 --o; 871 872 pop_variable_scope (); 873 free (varname); 874 free (list); 875 876 return o; 877} 878 879struct a_word 880{ 881 struct a_word *next; 882 struct a_word *chain; 883 char *str; 884 int length; 885 int matched; 886}; 887 888static unsigned long 889a_word_hash_1 (const void *key) 890{ 891 return_STRING_HASH_1 (((struct a_word const *) key)->str); 892} 893 894static unsigned long 895a_word_hash_2 (const void *key) 896{ 897 return_STRING_HASH_2 (((struct a_word const *) key)->str); 898} 899 900static int 901a_word_hash_cmp (const void *x, const void *y) 902{ 903 int result = ((struct a_word const *) x)->length - ((struct a_word const *) y)->length; 904 if (result) 905 return result; 906 return_STRING_COMPARE (((struct a_word const *) x)->str, 907 ((struct a_word const *) y)->str); 908} 909 910struct a_pattern 911{ 912 struct a_pattern *next; 913 char *str; 914 char *percent; 915 int length; 916 int save_c; 917}; 918 919static char * 920func_filter_filterout (char *o, char **argv, const char *funcname) 921{ 922 struct a_word *wordhead; 923 struct a_word **wordtail; 924 struct a_word *wp; 925 struct a_pattern *pathead; 926 struct a_pattern **pattail; 927 struct a_pattern *pp; 928 929 struct hash_table a_word_table; 930 int is_filter = streq (funcname, "filter"); 931 char *pat_iterator = argv[0]; 932 char *word_iterator = argv[1]; 933 int literals = 0; 934 int words = 0; 935 int hashing = 0; 936 char *p; 937 unsigned int len; 938 939 /* Chop ARGV[0] up into patterns to match against the words. */ 940 941 pattail = &pathead; 942 while ((p = find_next_token (&pat_iterator, &len)) != 0) 943 { 944 struct a_pattern *pat = (struct a_pattern *) alloca (sizeof (struct a_pattern)); 945 946 *pattail = pat; 947 pattail = &pat->next; 948 949 if (*pat_iterator != '\0') 950 ++pat_iterator; 951 952 pat->str = p; 953 pat->length = len; 954 pat->save_c = p[len]; 955 p[len] = '\0'; 956 pat->percent = find_percent (p); 957 if (pat->percent == 0) 958 literals++; 959 } 960 *pattail = 0; 961 962 /* Chop ARGV[1] up into words to match against the patterns. */ 963 964 wordtail = &wordhead; 965 while ((p = find_next_token (&word_iterator, &len)) != 0) 966 { 967 struct a_word *word = (struct a_word *) alloca (sizeof (struct a_word)); 968 969 *wordtail = word; 970 wordtail = &word->next; 971 972 if (*word_iterator != '\0') 973 ++word_iterator; 974 975 p[len] = '\0'; 976 word->str = p; 977 word->length = len; 978 word->matched = 0; 979 word->chain = 0; 980 words++; 981 } 982 *wordtail = 0; 983 984 /* Only use a hash table if arg list lengths justifies the cost. */ 985 hashing = (literals >= 2 && (literals * words) >= 10); 986 if (hashing) 987 { 988 hash_init (&a_word_table, words, a_word_hash_1, a_word_hash_2, a_word_hash_cmp); 989 for (wp = wordhead; wp != 0; wp = wp->next) 990 { 991 struct a_word *owp = hash_insert (&a_word_table, wp); 992 if (owp) 993 wp->chain = owp; 994 } 995 } 996 997 if (words) 998 { 999 int doneany = 0; 1000 1001 /* Run each pattern through the words, killing words. */ 1002 for (pp = pathead; pp != 0; pp = pp->next) 1003 { 1004 if (pp->percent) 1005 for (wp = wordhead; wp != 0; wp = wp->next) 1006 wp->matched |= pattern_matches (pp->str, pp->percent, wp->str); 1007 else if (hashing) 1008 { 1009 struct a_word a_word_key; 1010 a_word_key.str = pp->str; 1011 a_word_key.length = pp->length; 1012 wp = (struct a_word *) hash_find_item (&a_word_table, &a_word_key); 1013 while (wp) 1014 { 1015 wp->matched |= 1; 1016 wp = wp->chain; 1017 } 1018 } 1019 else 1020 for (wp = wordhead; wp != 0; wp = wp->next) 1021 wp->matched |= (wp->length == pp->length 1022 && strneq (pp->str, wp->str, wp->length)); 1023 } 1024 1025 /* Output the words that matched (or didn't, for filter-out). */ 1026 for (wp = wordhead; wp != 0; wp = wp->next) 1027 if (is_filter ? wp->matched : !wp->matched) 1028 { 1029 o = variable_buffer_output (o, wp->str, strlen (wp->str)); 1030 o = variable_buffer_output (o, " ", 1); 1031 doneany = 1; 1032 } 1033 1034 if (doneany) 1035 /* Kill the last space. */ 1036 --o; 1037 } 1038 1039 for (pp = pathead; pp != 0; pp = pp->next) 1040 pp->str[pp->length] = pp->save_c; 1041 1042 if (hashing) 1043 hash_free (&a_word_table, 0); 1044 1045 return o; 1046} 1047 1048 1049static char * 1050func_strip (char *o, char **argv, const char *funcname UNUSED) 1051{ 1052 char *p = argv[0]; 1053 int doneany =0; 1054 1055 while (*p != '\0') 1056 { 1057 int i=0; 1058 char *word_start=0; 1059 1060 while (isspace ((unsigned char)*p)) 1061 ++p; 1062 word_start = p; 1063 for (i=0; *p != '\0' && !isspace ((unsigned char)*p); ++p, ++i) 1064 {} 1065 if (!i) 1066 break; 1067 o = variable_buffer_output (o, word_start, i); 1068 o = variable_buffer_output (o, " ", 1); 1069 doneany = 1; 1070 } 1071 1072 if (doneany) 1073 /* Kill the last space. */ 1074 --o; 1075 return o; 1076} 1077 1078/* 1079 Print a warning or fatal message. 1080*/ 1081static char * 1082func_error (char *o, char **argv, const char *funcname) 1083{ 1084 char **argvp; 1085 char *msg, *p; 1086 int len; 1087 1088 /* The arguments will be broken on commas. Rather than create yet 1089 another special case where function arguments aren't broken up, 1090 just create a format string that puts them back together. */ 1091 for (len=0, argvp=argv; *argvp != 0; ++argvp) 1092 len += strlen (*argvp) + 2; 1093 1094 p = msg = (char *) alloca (len + 1); 1095 1096 for (argvp=argv; argvp[1] != 0; ++argvp) 1097 { 1098 strcpy (p, *argvp); 1099 p += strlen (*argvp); 1100 *(p++) = ','; 1101 *(p++) = ' '; 1102 } 1103 strcpy (p, *argvp); 1104 1105 switch (*funcname) { 1106 case 'e': 1107 fatal (reading_file, "%s", msg); 1108 1109 case 'w': 1110 error (reading_file, "%s", msg); 1111 break; 1112 1113 case 'i': 1114 printf ("%s\n", msg); 1115 fflush(stdout); 1116 break; 1117 1118 default: 1119 fatal (*expanding_var, "Internal error: func_error: '%s'", funcname); 1120 } 1121 1122 /* The warning function expands to the empty string. */ 1123 return o; 1124} 1125 1126 1127/* 1128 chop argv[0] into words, and sort them. 1129 */ 1130static char * 1131func_sort (char *o, char **argv, const char *funcname UNUSED) 1132{ 1133 char **words = 0; 1134 int nwords = 0; 1135 register int wordi = 0; 1136 1137 /* Chop ARGV[0] into words and put them in WORDS. */ 1138 char *t = argv[0]; 1139 char *p; 1140 unsigned int len; 1141 int i; 1142 1143 while ((p = find_next_token (&t, &len)) != 0) 1144 { 1145 if (wordi >= nwords - 1) 1146 { 1147 nwords = (2 * nwords) + 5; 1148 words = (char **) xrealloc ((char *) words, 1149 nwords * sizeof (char *)); 1150 } 1151 words[wordi++] = savestring (p, len); 1152 } 1153 1154 if (!wordi) 1155 return o; 1156 1157 /* Now sort the list of words. */ 1158 qsort ((char *) words, wordi, sizeof (char *), alpha_compare); 1159 1160 /* Now write the sorted list. */ 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 free (words[i]); 1171 } 1172 /* Kill the last space. */ 1173 --o; 1174 1175 free (words); 1176 1177 return o; 1178} 1179 1180/* 1181 $(if condition,true-part[,false-part]) 1182 1183 CONDITION is false iff it evaluates to an empty string. White 1184 space before and after condition are stripped before evaluation. 1185 1186 If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is 1187 evaluated (if it exists). Because only one of the two PARTs is evaluated, 1188 you can use $(if ...) to create side-effects (with $(shell ...), for 1189 example). 1190*/ 1191 1192static char * 1193func_if (char *o, char **argv, const char *funcname UNUSED) 1194{ 1195 const char *begp = argv[0]; 1196 const char *endp = begp + strlen (argv[0]) - 1; 1197 int result = 0; 1198 1199 /* Find the result of the condition: if we have a value, and it's not 1200 empty, the condition is true. If we don't have a value, or it's the 1201 empty string, then it's false. */ 1202 1203 strip_whitespace (&begp, &endp); 1204 1205 if (begp <= endp) 1206 { 1207 char *expansion = expand_argument (begp, endp+1); 1208 1209 result = strlen (expansion); 1210 free (expansion); 1211 } 1212 1213 /* If the result is true (1) we want to eval the first argument, and if 1214 it's false (0) we want to eval the second. If the argument doesn't 1215 exist we do nothing, otherwise expand it and add to the buffer. */ 1216 1217 argv += 1 + !result; 1218 1219 if (argv[0]) 1220 { 1221 char *expansion; 1222 1223 expansion = expand_argument (argv[0], NULL); 1224 1225 o = variable_buffer_output (o, expansion, strlen (expansion)); 1226 1227 free (expansion); 1228 } 1229 1230 return o; 1231} 1232 1233/* 1234 $(or condition1[,condition2[,condition3[...]]]) 1235 1236 A CONDITION is false iff it evaluates to an empty string. White 1237 space before and after CONDITION are stripped before evaluation. 1238 1239 CONDITION1 is evaluated. If it's true, then this is the result of 1240 expansion. If it's false, CONDITION2 is evaluated, and so on. If none of 1241 the conditions are true, the expansion is the empty string. 1242 1243 Once a CONDITION is true no further conditions are evaluated 1244 (short-circuiting). 1245*/ 1246 1247static char * 1248func_or (char *o, char **argv, const char *funcname UNUSED) 1249{ 1250 for ( ; *argv ; ++argv) 1251 { 1252 const char *begp = *argv; 1253 const char *endp = begp + strlen (*argv) - 1; 1254 char *expansion; 1255 int result = 0; 1256 1257 /* Find the result of the condition: if it's false keep going. */ 1258 1259 strip_whitespace (&begp, &endp); 1260 1261 if (begp > endp) 1262 continue; 1263 1264 expansion = expand_argument (begp, endp+1); 1265 result = strlen (expansion); 1266 1267 /* If the result is false keep going. */ 1268 if (!result) 1269 { 1270 free (expansion); 1271 continue; 1272 } 1273 1274 /* It's true! Keep this result and return. */ 1275 o = variable_buffer_output (o, expansion, result); 1276 free (expansion); 1277 break; 1278 } 1279 1280 return o; 1281} 1282 1283/* 1284 $(and condition1[,condition2[,condition3[...]]]) 1285 1286 A CONDITION is false iff it evaluates to an empty string. White 1287 space before and after CONDITION are stripped before evaluation. 1288 1289 CONDITION1 is evaluated. If it's false, then this is the result of 1290 expansion. If it's true, CONDITION2 is evaluated, and so on. If all of 1291 the conditions are true, the expansion is the result of the last condition. 1292 1293 Once a CONDITION is false no further conditions are evaluated 1294 (short-circuiting). 1295*/ 1296 1297static char * 1298func_and (char *o, char **argv, const char *funcname UNUSED) 1299{ 1300 char *expansion; 1301 int result; 1302 1303 while (1) 1304 { 1305 const char *begp = *argv; 1306 const char *endp = begp + strlen (*argv) - 1; 1307 1308 /* An empty condition is always false. */ 1309 strip_whitespace (&begp, &endp); 1310 if (begp > endp) 1311 return o; 1312 1313 expansion = expand_argument (begp, endp+1); 1314 result = strlen (expansion); 1315 1316 /* If the result is false, stop here: we're done. */ 1317 if (!result) 1318 break; 1319 1320 /* Otherwise the result is true. If this is the last one, keep this 1321 result and quit. Otherwise go on to the next one! */ 1322 1323 if (*(++argv)) 1324 free (expansion); 1325 else 1326 { 1327 o = variable_buffer_output (o, expansion, result); 1328 break; 1329 } 1330 } 1331 1332 free (expansion); 1333 1334 return o; 1335} 1336 1337static char * 1338func_wildcard (char *o, char **argv, const char *funcname UNUSED) 1339{ 1340 1341#ifdef _AMIGA 1342 o = wildcard_expansion (argv[0], o); 1343#else 1344 char *p = string_glob (argv[0]); 1345 o = variable_buffer_output (o, p, strlen (p)); 1346#endif 1347 return o; 1348} 1349 1350/* 1351 $(eval <makefile string>) 1352 1353 Always resolves to the empty string. 1354 1355 Treat the arguments as a segment of makefile, and parse them. 1356*/ 1357 1358static char * 1359func_eval (char *o, char **argv, const char *funcname UNUSED) 1360{ 1361 char *buf; 1362 unsigned int len; 1363 1364 /* Eval the buffer. Pop the current variable buffer setting so that the 1365 eval'd code can use its own without conflicting. */ 1366 1367 install_variable_buffer (&buf, &len); 1368 1369 eval_buffer (argv[0]); 1370 1371 restore_variable_buffer (buf, len); 1372 1373 return o; 1374} 1375 1376 1377static char * 1378func_value (char *o, char **argv, const char *funcname UNUSED) 1379{ 1380 /* Look up the variable. */ 1381 struct variable *v = lookup_variable (argv[0], strlen (argv[0])); 1382 1383 /* Copy its value into the output buffer without expanding it. */ 1384 if (v) 1385 o = variable_buffer_output (o, v->value, strlen(v->value)); 1386 1387 return o; 1388} 1389 1390/* 1391 \r is replaced on UNIX as well. Is this desirable? 1392 */ 1393static void 1394fold_newlines (char *buffer, unsigned int *length) 1395{ 1396 char *dst = buffer; 1397 char *src = buffer; 1398 char *last_nonnl = buffer -1; 1399 src[*length] = 0; 1400 for (; *src != '\0'; ++src) 1401 { 1402 if (src[0] == '\r' && src[1] == '\n') 1403 continue; 1404 if (*src == '\n') 1405 { 1406 *dst++ = ' '; 1407 } 1408 else 1409 { 1410 last_nonnl = dst; 1411 *dst++ = *src; 1412 } 1413 } 1414 *(++last_nonnl) = '\0'; 1415 *length = last_nonnl - buffer; 1416} 1417 1418 1419 1420int shell_function_pid = 0, shell_function_completed; 1421 1422 1423#ifdef WINDOWS32 1424/*untested*/ 1425 1426#include <windows.h> 1427#include <io.h> 1428#include "sub_proc.h" 1429 1430 1431void 1432windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp) 1433{ 1434 SECURITY_ATTRIBUTES saAttr; 1435 HANDLE hIn; 1436 HANDLE hErr; 1437 HANDLE hChildOutRd; 1438 HANDLE hChildOutWr; 1439 HANDLE hProcess; 1440 1441 1442 saAttr.nLength = sizeof (SECURITY_ATTRIBUTES); 1443 saAttr.bInheritHandle = TRUE; 1444 saAttr.lpSecurityDescriptor = NULL; 1445 1446 if (DuplicateHandle (GetCurrentProcess(), 1447 GetStdHandle(STD_INPUT_HANDLE), 1448 GetCurrentProcess(), 1449 &hIn, 1450 0, 1451 TRUE, 1452 DUPLICATE_SAME_ACCESS) == FALSE) { 1453 fatal (NILF, _("create_child_process: DuplicateHandle(In) failed (e=%ld)\n"), 1454 GetLastError()); 1455 1456 } 1457 if (DuplicateHandle(GetCurrentProcess(), 1458 GetStdHandle(STD_ERROR_HANDLE), 1459 GetCurrentProcess(), 1460 &hErr, 1461 0, 1462 TRUE, 1463 DUPLICATE_SAME_ACCESS) == FALSE) { 1464 fatal (NILF, _("create_child_process: DuplicateHandle(Err) failed (e=%ld)\n"), 1465 GetLastError()); 1466 } 1467 1468 if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0)) 1469 fatal (NILF, _("CreatePipe() failed (e=%ld)\n"), GetLastError()); 1470 1471 hProcess = process_init_fd(hIn, hChildOutWr, hErr); 1472 1473 if (!hProcess) 1474 fatal (NILF, _("windows32_openpipe (): process_init_fd() failed\n")); 1475 1476 /* make sure that CreateProcess() has Path it needs */ 1477 sync_Path_environment(); 1478 1479 if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL)) { 1480 /* register process for wait */ 1481 process_register(hProcess); 1482 1483 /* set the pid for returning to caller */ 1484 *pid_p = (intptr_t) hProcess; 1485 1486 /* set up to read data from child */ 1487 pipedes[0] = _open_osfhandle((intptr_t) hChildOutRd, O_RDONLY); 1488 1489 /* this will be closed almost right away */ 1490 pipedes[1] = _open_osfhandle((intptr_t) hChildOutWr, O_APPEND); 1491 } else { 1492 /* reap/cleanup the failed process */ 1493 process_cleanup(hProcess); 1494 1495 /* close handles which were duplicated, they weren't used */ 1496 CloseHandle(hIn); 1497 CloseHandle(hErr); 1498 1499 /* close pipe handles, they won't be used */ 1500 CloseHandle(hChildOutRd); 1501 CloseHandle(hChildOutWr); 1502 1503 /* set status for return */ 1504 pipedes[0] = pipedes[1] = -1; 1505 *pid_p = -1; 1506 } 1507} 1508#endif 1509 1510 1511#ifdef __MSDOS__ 1512FILE * 1513msdos_openpipe (int* pipedes, int *pidp, char *text) 1514{ 1515 FILE *fpipe=0; 1516 /* MSDOS can't fork, but it has `popen'. */ 1517 struct variable *sh = lookup_variable ("SHELL", 5); 1518 int e; 1519 extern int dos_command_running, dos_status; 1520 1521 /* Make sure not to bother processing an empty line. */ 1522 while (isblank ((unsigned char)*text)) 1523 ++text; 1524 if (*text == '\0') 1525 return 0; 1526 1527 if (sh) 1528 { 1529 char buf[PATH_MAX + 7]; 1530 /* This makes sure $SHELL value is used by $(shell), even 1531 though the target environment is not passed to it. */ 1532 sprintf (buf, "SHELL=%s", sh->value); 1533 putenv (buf); 1534 } 1535 1536 e = errno; 1537 errno = 0; 1538 dos_command_running = 1; 1539 dos_status = 0; 1540 /* If dos_status becomes non-zero, it means the child process 1541 was interrupted by a signal, like SIGINT or SIGQUIT. See 1542 fatal_error_signal in commands.c. */ 1543 fpipe = popen (text, "rt"); 1544 dos_command_running = 0; 1545 if (!fpipe || dos_status) 1546 { 1547 pipedes[0] = -1; 1548 *pidp = -1; 1549 if (dos_status) 1550 errno = EINTR; 1551 else if (errno == 0) 1552 errno = ENOMEM; 1553 shell_function_completed = -1; 1554 } 1555 else 1556 { 1557 pipedes[0] = fileno (fpipe); 1558 *pidp = 42; /* Yes, the Meaning of Life, the Universe, and Everything! */ 1559 errno = e; 1560 shell_function_completed = 1; 1561 } 1562 return fpipe; 1563} 1564#endif 1565 1566/* 1567 Do shell spawning, with the naughty bits for different OSes. 1568 */ 1569 1570#ifdef VMS 1571 1572/* VMS can't do $(shell ...) */ 1573#define func_shell 0 1574 1575#else 1576#ifndef _AMIGA 1577static char * 1578func_shell (char *o, char **argv, const char *funcname UNUSED) 1579{ 1580 char* batch_filename = NULL; 1581 1582#ifdef __MSDOS__ 1583 FILE *fpipe; 1584#endif 1585 char **command_argv; 1586 char *error_prefix; 1587 char **envp; 1588 int pipedes[2]; 1589 int pid; 1590 1591#ifndef __MSDOS__ 1592 /* Construct the argument list. */ 1593 command_argv = construct_command_argv (argv[0], 1594 (char **) NULL, (struct file *) 0, 1595 &batch_filename); 1596 if (command_argv == 0) 1597 return o; 1598#endif 1599 1600 /* Using a target environment for `shell' loses in cases like: 1601 export var = $(shell echo foobie) 1602 because target_environment hits a loop trying to expand $(var) 1603 to put it in the environment. This is even more confusing when 1604 var was not explicitly exported, but just appeared in the 1605 calling environment. 1606 1607 envp = target_environment (NILF); 1608 */ 1609 1610 envp = environ; 1611 1612 /* For error messages. */ 1613 if (reading_file && reading_file->filenm) 1614 { 1615 error_prefix = (char *) alloca (strlen (reading_file->filenm)+11+4); 1616 sprintf (error_prefix, 1617 "%s:%lu: ", reading_file->filenm, reading_file->lineno); 1618 } 1619 else 1620 error_prefix = ""; 1621 1622#ifdef WINDOWS32 1623 1624 windows32_openpipe (pipedes, &pid, command_argv, envp); 1625 1626 if (pipedes[0] < 0) { 1627 /* open of the pipe failed, mark as failed execution */ 1628 shell_function_completed = -1; 1629 1630 return o; 1631 } else 1632 1633#elif defined(__MSDOS__) 1634 1635 fpipe = msdos_openpipe (pipedes, &pid, argv[0]); 1636 if (pipedes[0] < 0) 1637 { 1638 perror_with_name (error_prefix, "pipe"); 1639 return o; 1640 } 1641 1642#else 1643 1644 if (pipe (pipedes) < 0) 1645 { 1646 perror_with_name (error_prefix, "pipe"); 1647 return o; 1648 } 1649 1650# ifdef __EMX__ 1651 1652 /* close some handles that are unnecessary for the child process */ 1653 CLOSE_ON_EXEC(pipedes[1]); 1654 CLOSE_ON_EXEC(pipedes[0]); 1655 /* Never use fork()/exec() here! Use spawn() instead in exec_command() */ 1656 pid = child_execute_job (0, pipedes[1], command_argv, envp); 1657 if (pid < 0) 1658 perror_with_name (error_prefix, "spawn"); 1659 1660# else /* ! __EMX__ */ 1661 1662 pid = vfork (); 1663 if (pid < 0) 1664 perror_with_name (error_prefix, "fork"); 1665 else if (pid == 0) 1666 child_execute_job (0, pipedes[1], command_argv, envp); 1667 else 1668 1669# endif 1670 1671#endif 1672 { 1673 /* We are the parent. */ 1674 char *buffer; 1675 unsigned int maxlen, i; 1676 int cc; 1677 1678 /* Record the PID for reap_children. */ 1679 shell_function_pid = pid; 1680#ifndef __MSDOS__ 1681 shell_function_completed = 0; 1682 1683 /* Free the storage only the child needed. */ 1684 free (command_argv[0]); 1685 free ((char *) command_argv); 1686 1687 /* Close the write side of the pipe. */ 1688 (void) close (pipedes[1]); 1689#endif 1690 1691 /* Set up and read from the pipe. */ 1692 1693 maxlen = 200; 1694 buffer = (char *) xmalloc (maxlen + 1); 1695 1696 /* Read from the pipe until it gets EOF. */ 1697 for (i = 0; ; i += cc) 1698 { 1699 if (i == maxlen) 1700 { 1701 maxlen += 512; 1702 buffer = (char *) xrealloc (buffer, maxlen + 1); 1703 } 1704 1705 EINTRLOOP (cc, read (pipedes[0], &buffer[i], maxlen - i)); 1706 if (cc <= 0) 1707 break; 1708 } 1709 buffer[i] = '\0'; 1710 1711 /* Close the read side of the pipe. */ 1712#ifdef __MSDOS__ 1713 if (fpipe) 1714 (void) pclose (fpipe); 1715#else 1716 (void) close (pipedes[0]); 1717#endif 1718 1719 /* Loop until child_handler or reap_children() sets 1720 shell_function_completed to the status of our child shell. */ 1721 while (shell_function_completed == 0) 1722 reap_children (1, 0); 1723 1724 if (batch_filename) { 1725 DB (DB_VERBOSE, (_("Cleaning up temporary batch file %s\n"), 1726 batch_filename)); 1727 remove (batch_filename); 1728 free (batch_filename); 1729 } 1730 shell_function_pid = 0; 1731 1732 /* The child_handler function will set shell_function_completed 1733 to 1 when the child dies normally, or to -1 if it 1734 dies with status 127, which is most likely an exec fail. */ 1735 1736 if (shell_function_completed == -1) 1737 { 1738 /* This likely means that the execvp failed, so we should just 1739 write the error message in the pipe from the child. */ 1740 fputs (buffer, stderr); 1741 fflush (stderr); 1742 } 1743 else 1744 { 1745 /* The child finished normally. Replace all newlines in its output 1746 with spaces, and put that in the variable output buffer. */ 1747 fold_newlines (buffer, &i); 1748 o = variable_buffer_output (o, buffer, i); 1749 } 1750 1751 free (buffer); 1752 } 1753 1754 return o; 1755} 1756 1757#else /* _AMIGA */ 1758 1759/* Do the Amiga version of func_shell. */ 1760 1761static char * 1762func_shell (char *o, char **argv, const char *funcname) 1763{ 1764 /* Amiga can't fork nor spawn, but I can start a program with 1765 redirection of my choice. However, this means that we 1766 don't have an opportunity to reopen stdout to trap it. Thus, 1767 we save our own stdout onto a new descriptor and dup a temp 1768 file's descriptor onto our stdout temporarily. After we 1769 spawn the shell program, we dup our own stdout back to the 1770 stdout descriptor. The buffer reading is the same as above, 1771 except that we're now reading from a file. */ 1772 1773#include <dos/dos.h> 1774#include <proto/dos.h> 1775 1776 BPTR child_stdout; 1777 char tmp_output[FILENAME_MAX]; 1778 unsigned int maxlen = 200, i; 1779 int cc; 1780 char * buffer, * ptr; 1781 char ** aptr; 1782 int len = 0; 1783 char* batch_filename = NULL; 1784 1785 /* Construct the argument list. */ 1786 command_argv = construct_command_argv (argv[0], (char **) NULL, 1787 (struct file *) 0, &batch_filename); 1788 if (command_argv == 0) 1789 return o; 1790 1791 /* Note the mktemp() is a security hole, but this only runs on Amiga. 1792 Ideally we would use main.c:open_tmpfile(), but this uses a special 1793 Open(), not fopen(), and I'm not familiar enough with the code to mess 1794 with it. */ 1795 strcpy (tmp_output, "t:MakeshXXXXXXXX"); 1796 mktemp (tmp_output); 1797 child_stdout = Open (tmp_output, MODE_NEWFILE); 1798 1799 for (aptr=command_argv; *aptr; aptr++) 1800 len += strlen (*aptr) + 1; 1801 1802 buffer = xmalloc (len + 1); 1803 ptr = buffer; 1804 1805 for (aptr=command_argv; *aptr; aptr++) 1806 { 1807 strcpy (ptr, *aptr); 1808 ptr += strlen (ptr) + 1; 1809 *ptr ++ = ' '; 1810 *ptr = 0; 1811 } 1812 1813 ptr[-1] = '\n'; 1814 1815 Execute (buffer, NULL, child_stdout); 1816 free (buffer); 1817 1818 Close (child_stdout); 1819 1820 child_stdout = Open (tmp_output, MODE_OLDFILE); 1821 1822 buffer = xmalloc (maxlen); 1823 i = 0; 1824 do 1825 { 1826 if (i == maxlen) 1827 { 1828 maxlen += 512; 1829 buffer = (char *) xrealloc (buffer, maxlen + 1); 1830 } 1831 1832 cc = Read (child_stdout, &buffer[i], maxlen - i); 1833 if (cc > 0) 1834 i += cc; 1835 } while (cc > 0); 1836 1837 Close (child_stdout); 1838 1839 fold_newlines (buffer, &i); 1840 o = variable_buffer_output (o, buffer, i); 1841 free (buffer); 1842 return o; 1843} 1844#endif /* _AMIGA */ 1845#endif /* !VMS */ 1846 1847#ifdef EXPERIMENTAL 1848 1849/* 1850 equality. Return is string-boolean, ie, the empty string is false. 1851 */ 1852static char * 1853func_eq (char *o, char **argv, char *funcname) 1854{ 1855 int result = ! strcmp (argv[0], argv[1]); 1856 o = variable_buffer_output (o, result ? "1" : "", result); 1857 return o; 1858} 1859 1860 1861/* 1862 string-boolean not operator. 1863 */ 1864static char * 1865func_not (char *o, char **argv, char *funcname) 1866{ 1867 char *s = argv[0]; 1868 int result = 0; 1869 while (isspace ((unsigned char)*s)) 1870 s++; 1871 result = ! (*s); 1872 o = variable_buffer_output (o, result ? "1" : "", result); 1873 return o; 1874} 1875#endif 1876 1877 1878/* Return the absolute name of file NAME which does not contain any `.', 1879 `..' components nor any repeated path separators ('/'). */ 1880 1881static char * 1882abspath (const char *name, char *apath) 1883{ 1884 char *dest; 1885 const char *start, *end, *apath_limit; 1886 1887 if (name[0] == '\0' || apath == NULL) 1888 return NULL; 1889 1890 apath_limit = apath + GET_PATH_MAX; 1891 1892 if (name[0] != '/') 1893 { 1894 /* It is unlikely we would make it until here but just to make sure. */ 1895 if (!starting_directory) 1896 return NULL; 1897 1898 strcpy (apath, starting_directory); 1899 1900 dest = strchr (apath, '\0'); 1901 } 1902 else 1903 { 1904 apath[0] = '/'; 1905 dest = apath + 1; 1906 } 1907 1908 for (start = end = name; *start != '\0'; start = end) 1909 { 1910 unsigned long len; 1911 1912 /* Skip sequence of multiple path-separators. */ 1913 while (*start == '/') 1914 ++start; 1915 1916 /* Find end of path component. */ 1917 for (end = start; *end != '\0' && *end != '/'; ++end) 1918 ; 1919 1920 len = end - start; 1921 1922 if (len == 0) 1923 break; 1924 else if (len == 1 && start[0] == '.') 1925 /* nothing */; 1926 else if (len == 2 && start[0] == '.' && start[1] == '.') 1927 { 1928 /* Back up to previous component, ignore if at root already. */ 1929 if (dest > apath + 1) 1930 while ((--dest)[-1] != '/'); 1931 } 1932 else 1933 { 1934 if (dest[-1] != '/') 1935 *dest++ = '/'; 1936 1937 if (dest + len >= apath_limit) 1938 return NULL; 1939 1940 dest = memcpy (dest, start, len); 1941 dest += len; 1942 *dest = '\0'; 1943 } 1944 } 1945 1946 /* Unless it is root strip trailing separator. */ 1947 if (dest > apath + 1 && dest[-1] == '/') 1948 --dest; 1949 1950 *dest = '\0'; 1951 1952 return apath; 1953} 1954 1955 1956static char * 1957func_realpath (char *o, char **argv, const char *funcname UNUSED) 1958{ 1959 /* Expand the argument. */ 1960 char *p = argv[0]; 1961 char *path = 0; 1962 int doneany = 0; 1963 unsigned int len = 0; 1964 PATH_VAR (in); 1965 PATH_VAR (out); 1966 1967 while ((path = find_next_token (&p, &len)) != 0) 1968 { 1969 if (len < GET_PATH_MAX) 1970 { 1971 strncpy (in, path, len); 1972 in[len] = '\0'; 1973 1974 if 1975 ( 1976#ifdef HAVE_REALPATH 1977 realpath (in, out) 1978#else 1979 abspath (in, out) 1980#endif 1981 ) 1982 { 1983 o = variable_buffer_output (o, out, strlen (out)); 1984 o = variable_buffer_output (o, " ", 1); 1985 doneany = 1; 1986 } 1987 } 1988 } 1989 1990 /* Kill last space. */ 1991 if (doneany) 1992 --o; 1993 1994 return o; 1995} 1996 1997static char * 1998func_abspath (char *o, char **argv, const char *funcname UNUSED) 1999{ 2000 /* Expand the argument. */ 2001 char *p = argv[0]; 2002 char *path = 0; 2003 int doneany = 0; 2004 unsigned int len = 0; 2005 PATH_VAR (in); 2006 PATH_VAR (out); 2007 2008 while ((path = find_next_token (&p, &len)) != 0) 2009 { 2010 if (len < GET_PATH_MAX) 2011 { 2012 strncpy (in, path, len); 2013 in[len] = '\0'; 2014 2015 if (abspath (in, out)) 2016 { 2017 o = variable_buffer_output (o, out, strlen (out)); 2018 o = variable_buffer_output (o, " ", 1); 2019 doneany = 1; 2020 } 2021 } 2022 } 2023 2024 /* Kill last space. */ 2025 if (doneany) 2026 --o; 2027 2028 return o; 2029} 2030 2031/* Lookup table for builtin functions. 2032 2033 This doesn't have to be sorted; we use a straight lookup. We might gain 2034 some efficiency by moving most often used functions to the start of the 2035 table. 2036 2037 If MAXIMUM_ARGS is 0, that means there is no maximum and all 2038 comma-separated values are treated as arguments. 2039 2040 EXPAND_ARGS means that all arguments should be expanded before invocation. 2041 Functions that do namespace tricks (foreach) don't automatically expand. */ 2042 2043static char *func_call PARAMS ((char *o, char **argv, const char *funcname)); 2044 2045 2046static struct function_table_entry function_table_init[] = 2047{ 2048 /* Name/size */ /* MIN MAX EXP? Function */ 2049 { STRING_SIZE_TUPLE("abspath"), 0, 1, 1, func_abspath}, 2050 { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix}, 2051 { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix}, 2052 { STRING_SIZE_TUPLE("basename"), 0, 1, 1, func_basename_dir}, 2053 { STRING_SIZE_TUPLE("dir"), 0, 1, 1, func_basename_dir}, 2054 { STRING_SIZE_TUPLE("notdir"), 0, 1, 1, func_notdir_suffix}, 2055 { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst}, 2056 { STRING_SIZE_TUPLE("suffix"), 0, 1, 1, func_notdir_suffix}, 2057 { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout}, 2058 { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout}, 2059 { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring}, 2060 { STRING_SIZE_TUPLE("firstword"), 0, 1, 1, func_firstword}, 2061 { STRING_SIZE_TUPLE("flavor"), 0, 1, 1, func_flavor}, 2062 { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join}, 2063 { STRING_SIZE_TUPLE("lastword"), 0, 1, 1, func_lastword}, 2064 { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst}, 2065 { STRING_SIZE_TUPLE("realpath"), 0, 1, 1, func_realpath}, 2066 { STRING_SIZE_TUPLE("shell"), 0, 1, 1, func_shell}, 2067 { STRING_SIZE_TUPLE("sort"), 0, 1, 1, func_sort}, 2068 { STRING_SIZE_TUPLE("strip"), 0, 1, 1, func_strip}, 2069 { STRING_SIZE_TUPLE("wildcard"), 0, 1, 1, func_wildcard}, 2070 { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word}, 2071 { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist}, 2072 { STRING_SIZE_TUPLE("words"), 0, 1, 1, func_words}, 2073 { STRING_SIZE_TUPLE("origin"), 0, 1, 1, func_origin}, 2074 { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach}, 2075 { STRING_SIZE_TUPLE("call"), 1, 0, 1, func_call}, 2076 { STRING_SIZE_TUPLE("info"), 0, 1, 1, func_error}, 2077 { STRING_SIZE_TUPLE("error"), 0, 1, 1, func_error}, 2078 { STRING_SIZE_TUPLE("warning"), 0, 1, 1, func_error}, 2079 { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if}, 2080 { STRING_SIZE_TUPLE("or"), 1, 0, 0, func_or}, 2081 { STRING_SIZE_TUPLE("and"), 1, 0, 0, func_and}, 2082 { STRING_SIZE_TUPLE("value"), 0, 1, 1, func_value}, 2083 { STRING_SIZE_TUPLE("eval"), 0, 1, 1, func_eval}, 2084#ifdef EXPERIMENTAL 2085 { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq}, 2086 { STRING_SIZE_TUPLE("not"), 0, 1, 1, func_not}, 2087#endif 2088}; 2089 2090#define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry)) 2091 2092 2093/* These must come after the definition of function_table. */ 2094 2095static char * 2096expand_builtin_function (char *o, int argc, char **argv, 2097 const struct function_table_entry *entry_p) 2098{ 2099 if (argc < (int)entry_p->minimum_args) 2100 fatal (*expanding_var, 2101 _("insufficient number of arguments (%d) to function `%s'"), 2102 argc, entry_p->name); 2103 2104 /* I suppose technically some function could do something with no 2105 arguments, but so far none do, so just test it for all functions here 2106 rather than in each one. We can change it later if necessary. */ 2107 2108 if (!argc) 2109 return o; 2110 2111 if (!entry_p->func_ptr) 2112 fatal (*expanding_var, 2113 _("unimplemented on this platform: function `%s'"), entry_p->name); 2114 2115 return entry_p->func_ptr (o, argv, entry_p->name); 2116} 2117 2118/* Check for a function invocation in *STRINGP. *STRINGP points at the 2119 opening ( or { and is not null-terminated. If a function invocation 2120 is found, expand it into the buffer at *OP, updating *OP, incrementing 2121 *STRINGP past the reference and returning nonzero. If not, return zero. */ 2122 2123int 2124handle_function (char **op, char **stringp) 2125{ 2126 const struct function_table_entry *entry_p; 2127 char openparen = (*stringp)[0]; 2128 char closeparen = openparen == '(' ? ')' : '}'; 2129 char *beg; 2130 char *end; 2131 int count = 0; 2132 register char *p; 2133 char **argv, **argvp; 2134 int nargs; 2135 2136 beg = *stringp + 1; 2137 2138 entry_p = lookup_function (beg); 2139 2140 if (!entry_p) 2141 return 0; 2142 2143 /* We found a builtin function. Find the beginning of its arguments (skip 2144 whitespace after the name). */ 2145 2146 beg = next_token (beg + entry_p->len); 2147 2148 /* Find the end of the function invocation, counting nested use of 2149 whichever kind of parens we use. Since we're looking, count commas 2150 to get a rough estimate of how many arguments we might have. The 2151 count might be high, but it'll never be low. */ 2152 2153 for (nargs=1, end=beg; *end != '\0'; ++end) 2154 if (*end == ',') 2155 ++nargs; 2156 else if (*end == openparen) 2157 ++count; 2158 else if (*end == closeparen && --count < 0) 2159 break; 2160 2161 if (count >= 0) 2162 fatal (*expanding_var, 2163 _("unterminated call to function `%s': missing `%c'"), 2164 entry_p->name, closeparen); 2165 2166 *stringp = end; 2167 2168 /* Get some memory to store the arg pointers. */ 2169 argvp = argv = (char **) alloca (sizeof (char *) * (nargs + 2)); 2170 2171 /* Chop the string into arguments, then a nul. As soon as we hit 2172 MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the 2173 last argument. 2174 2175 If we're expanding, store pointers to the expansion of each one. If 2176 not, make a duplicate of the string and point into that, nul-terminating 2177 each argument. */ 2178 2179 if (!entry_p->expand_args) 2180 { 2181 int len = end - beg; 2182 2183 p = xmalloc (len+1); 2184 memcpy (p, beg, len); 2185 p[len] = '\0'; 2186 beg = p; 2187 end = beg + len; 2188 } 2189 2190 for (p=beg, nargs=0; p <= end; ++argvp) 2191 { 2192 char *next; 2193 2194 ++nargs; 2195 2196 if (nargs == entry_p->maximum_args 2197 || (! (next = find_next_argument (openparen, closeparen, p, end)))) 2198 next = end; 2199 2200 if (entry_p->expand_args) 2201 *argvp = expand_argument (p, next); 2202 else 2203 { 2204 *argvp = p; 2205 *next = '\0'; 2206 } 2207 2208 p = next + 1; 2209 } 2210 *argvp = NULL; 2211 2212 /* Finally! Run the function... */ 2213 *op = expand_builtin_function (*op, nargs, argv, entry_p); 2214 2215 /* Free memory. */ 2216 if (entry_p->expand_args) 2217 for (argvp=argv; *argvp != 0; ++argvp) 2218 free (*argvp); 2219 else 2220 free (beg); 2221 2222 return 1; 2223} 2224 2225 2226/* User-defined functions. Expand the first argument as either a builtin 2227 function or a make variable, in the context of the rest of the arguments 2228 assigned to $1, $2, ... $N. $0 is the name of the function. */ 2229 2230static char * 2231func_call (char *o, char **argv, const char *funcname UNUSED) 2232{ 2233 static int max_args = 0; 2234 char *fname; 2235 char *cp; 2236 char *body; 2237 int flen; 2238 int i; 2239 int saved_args; 2240 const struct function_table_entry *entry_p; 2241 struct variable *v; 2242 2243 /* There is no way to define a variable with a space in the name, so strip 2244 leading and trailing whitespace as a favor to the user. */ 2245 fname = argv[0]; 2246 while (*fname != '\0' && isspace ((unsigned char)*fname)) 2247 ++fname; 2248 2249 cp = fname + strlen (fname) - 1; 2250 while (cp > fname && isspace ((unsigned char)*cp)) 2251 --cp; 2252 cp[1] = '\0'; 2253 2254 /* Calling nothing is a no-op */ 2255 if (*fname == '\0') 2256 return o; 2257 2258 /* Are we invoking a builtin function? */ 2259 2260 entry_p = lookup_function (fname); 2261 2262 if (entry_p) 2263 { 2264 /* How many arguments do we have? */ 2265 for (i=0; argv[i+1]; ++i) 2266 ; 2267 2268 return expand_builtin_function (o, i, argv+1, entry_p); 2269 } 2270 2271 /* Not a builtin, so the first argument is the name of a variable to be 2272 expanded and interpreted as a function. Find it. */ 2273 flen = strlen (fname); 2274 2275 v = lookup_variable (fname, flen); 2276 2277 if (v == 0) 2278 warn_undefined (fname, flen); 2279 2280 if (v == 0 || *v->value == '\0') 2281 return o; 2282 2283 body = (char *) alloca (flen + 4); 2284 body[0] = '$'; 2285 body[1] = '('; 2286 memcpy (body + 2, fname, flen); 2287 body[flen+2] = ')'; 2288 body[flen+3] = '\0'; 2289 2290 /* Set up arguments $(1) .. $(N). $(0) is the function name. */ 2291 2292 push_new_variable_scope (); 2293 2294 for (i=0; *argv; ++i, ++argv) 2295 { 2296 char num[11]; 2297 2298 sprintf (num, "%d", i); 2299 define_variable (num, strlen (num), *argv, o_automatic, 0); 2300 } 2301 2302 /* If the number of arguments we have is < max_args, it means we're inside 2303 a recursive invocation of $(call ...). Fill in the remaining arguments 2304 in the new scope with the empty value, to hide them from this 2305 invocation. */ 2306 2307 for (; i < max_args; ++i) 2308 { 2309 char num[11]; 2310 2311 sprintf (num, "%d", i); 2312 define_variable (num, strlen (num), "", o_automatic, 0); 2313 } 2314 2315 /* Expand the body in the context of the arguments, adding the result to 2316 the variable buffer. */ 2317 2318 v->exp_count = EXP_COUNT_MAX; 2319 2320 saved_args = max_args; 2321 max_args = i; 2322 o = variable_expand_string (o, body, flen+3); 2323 max_args = saved_args; 2324 2325 v->exp_count = 0; 2326 2327 pop_variable_scope (); 2328 2329 return o + strlen (o); 2330} 2331 2332void 2333hash_init_function_table (void) 2334{ 2335 hash_init (&function_table, FUNCTION_TABLE_ENTRIES * 2, 2336 function_table_entry_hash_1, function_table_entry_hash_2, 2337 function_table_entry_hash_cmp); 2338 hash_load (&function_table, function_table_init, 2339 FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry)); 2340} 2341