1/* Implicit rule searching 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 "rule.h" 22#include "dep.h" 23#include "debug.h" 24#include "variable.h" 25#include "job.h" /* struct child, used inside commands.h */ 26#include "commands.h" /* set_file_variables */ 27 28static int 29pattern_search PARAMS ((struct file *file, int archive, 30 unsigned int depth, unsigned int recursions)); 31 32/* For a FILE which has no commands specified, try to figure out some 33 from the implicit pattern rules. 34 Returns 1 if a suitable implicit rule was found, 35 after modifying FILE to contain the appropriate commands and deps, 36 or returns 0 if no implicit rule was found. */ 37 38int 39try_implicit_rule (struct file *file, unsigned int depth) 40{ 41 DBF (DB_IMPLICIT, _("Looking for an implicit rule for `%s'.\n")); 42 43 /* The order of these searches was previously reversed. My logic now is 44 that since the non-archive search uses more information in the target 45 (the archive search omits the archive name), it is more specific and 46 should come first. */ 47 48 if (pattern_search (file, 0, depth, 0)) 49 return 1; 50 51#ifndef NO_ARCHIVES 52 /* If this is an archive member reference, use just the 53 archive member name to search for implicit rules. */ 54 if (ar_name (file->name)) 55 { 56 DBF (DB_IMPLICIT, 57 _("Looking for archive-member implicit rule for `%s'.\n")); 58 if (pattern_search (file, 1, depth, 0)) 59 return 1; 60 } 61#endif 62 63 return 0; 64} 65 66 67/* Struct idep captures information about implicit prerequisites 68 that come from implicit rules. */ 69struct idep 70{ 71 struct idep *next; /* struct dep -compatible interface */ 72 char *name; /* name of the prerequisite */ 73 struct file *intermediate_file; /* intermediate file, 0 otherwise */ 74 char *intermediate_pattern; /* pattern for intermediate file */ 75 unsigned char had_stem; /* had % substituted with stem */ 76 unsigned char ignore_mtime; /* ignore_mtime flag */ 77}; 78 79static void 80free_idep_chain (struct idep *p) 81{ 82 struct idep *n; 83 84 for (; p != 0; p = n) 85 { 86 n = p->next; 87 88 if (p->name) 89 { 90 struct file *f = p->intermediate_file; 91 92 if (f != 0 93 && (f->stem < f->name || f->stem > f->name + strlen (f->name))) 94 free (f->stem); 95 96 free (p->name); 97 } 98 99 free (p); 100 } 101} 102 103 104/* Scans the BUFFER for the next word with whitespace as a separator. 105 Returns the pointer to the beginning of the word. LENGTH hold the 106 length of the word. */ 107 108static char * 109get_next_word (char *buffer, unsigned int *length) 110{ 111 char *p = buffer, *beg; 112 char c; 113 114 /* Skip any leading whitespace. */ 115 while (isblank ((unsigned char)*p)) 116 ++p; 117 118 beg = p; 119 c = *(p++); 120 121 if (c == '\0') 122 return 0; 123 124 125 /* We already found the first value of "c", above. */ 126 while (1) 127 { 128 char closeparen; 129 int count; 130 131 switch (c) 132 { 133 case '\0': 134 case ' ': 135 case '\t': 136 goto done_word; 137 138 case '$': 139 c = *(p++); 140 if (c == '$') 141 break; 142 143 /* This is a variable reference, so read it to the matching 144 close paren. */ 145 146 if (c == '(') 147 closeparen = ')'; 148 else if (c == '{') 149 closeparen = '}'; 150 else 151 /* This is a single-letter variable reference. */ 152 break; 153 154 for (count = 0; *p != '\0'; ++p) 155 { 156 if (*p == c) 157 ++count; 158 else if (*p == closeparen && --count < 0) 159 { 160 ++p; 161 break; 162 } 163 } 164 break; 165 166 case '|': 167 goto done; 168 169 default: 170 break; 171 } 172 173 c = *(p++); 174 } 175 done_word: 176 --p; 177 178 done: 179 if (length) 180 *length = p - beg; 181 182 return beg; 183} 184 185/* Search the pattern rules for a rule with an existing dependency to make 186 FILE. If a rule is found, the appropriate commands and deps are put in FILE 187 and 1 is returned. If not, 0 is returned. 188 189 If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)". A rule for 190 "(MEMBER)" will be searched for, and "(MEMBER)" will not be chopped up into 191 directory and filename parts. 192 193 If an intermediate file is found by pattern search, the intermediate file 194 is set up as a target by the recursive call and is also made a dependency 195 of FILE. 196 197 DEPTH is used for debugging messages. */ 198 199static int 200pattern_search (struct file *file, int archive, 201 unsigned int depth, unsigned int recursions) 202{ 203 /* Filename we are searching for a rule for. */ 204 char *filename = archive ? strchr (file->name, '(') : file->name; 205 206 /* Length of FILENAME. */ 207 unsigned int namelen = strlen (filename); 208 209 /* The last slash in FILENAME (or nil if there is none). */ 210 char *lastslash; 211 212 /* This is a file-object used as an argument in 213 recursive calls. It never contains any data 214 except during a recursive call. */ 215 struct file *intermediate_file = 0; 216 217 /* This linked list records all the prerequisites actually 218 found for a rule along with some other useful information 219 (see struct idep for details). */ 220 struct idep* deps = 0; 221 222 /* 1 if we need to remove explicit prerequisites, 0 otherwise. */ 223 unsigned int remove_explicit_deps = 0; 224 225 /* Names of possible dependencies are constructed in this buffer. */ 226 register char *depname = (char *) alloca (namelen + max_pattern_dep_length); 227 228 /* The start and length of the stem of FILENAME for the current rule. */ 229 register char *stem = 0; 230 register unsigned int stemlen = 0; 231 register unsigned int fullstemlen = 0; 232 233 /* Buffer in which we store all the rules that are possibly applicable. */ 234 struct rule **tryrules 235 = (struct rule **) xmalloc (num_pattern_rules * max_pattern_targets 236 * sizeof (struct rule *)); 237 238 /* Number of valid elements in TRYRULES. */ 239 unsigned int nrules; 240 241 /* The numbers of the rule targets of each rule 242 in TRYRULES that matched the target file. */ 243 unsigned int *matches 244 = (unsigned int *) alloca (num_pattern_rules * sizeof (unsigned int)); 245 246 /* Each element is nonzero if LASTSLASH was used in 247 matching the corresponding element of TRYRULES. */ 248 char *checked_lastslash 249 = (char *) alloca (num_pattern_rules * sizeof (char)); 250 251 /* The index in TRYRULES of the rule we found. */ 252 unsigned int foundrule; 253 254 /* Nonzero if should consider intermediate files as dependencies. */ 255 int intermed_ok; 256 257 /* Nonzero if we have matched a pattern-rule target 258 that is not just `%'. */ 259 int specific_rule_matched = 0; 260 261 unsigned int i = 0; /* uninit checks OK */ 262 struct rule *rule; 263 struct dep *dep, *expl_d; 264 265 char *p, *vname; 266 267 struct idep *d; 268 struct idep **id_ptr; 269 struct dep **d_ptr; 270 271 PATH_VAR (stem_str); /* @@ Need to get rid of stem, stemlen, etc. */ 272 273#ifndef NO_ARCHIVES 274 if (archive || ar_name (filename)) 275 lastslash = 0; 276 else 277#endif 278 { 279 /* Set LASTSLASH to point at the last slash in FILENAME 280 but not counting any slash at the end. (foo/bar/ counts as 281 bar/ in directory foo/, not empty in directory foo/bar/.) */ 282#ifdef VMS 283 lastslash = strrchr (filename, ']'); 284 if (lastslash == 0) 285 lastslash = strrchr (filename, ':'); 286#else 287 lastslash = strrchr (filename, '/'); 288#ifdef HAVE_DOS_PATHS 289 /* Handle backslashes (possibly mixed with forward slashes) 290 and the case of "d:file". */ 291 { 292 char *bslash = strrchr (filename, '\\'); 293 if (lastslash == 0 || bslash > lastslash) 294 lastslash = bslash; 295 if (lastslash == 0 && filename[0] && filename[1] == ':') 296 lastslash = filename + 1; 297 } 298#endif 299#endif 300 if (lastslash != 0 && lastslash[1] == '\0') 301 lastslash = 0; 302 } 303 304 /* First see which pattern rules match this target 305 and may be considered. Put them in TRYRULES. */ 306 307 nrules = 0; 308 for (rule = pattern_rules; rule != 0; rule = rule->next) 309 { 310 /* If the pattern rule has deps but no commands, ignore it. 311 Users cancel built-in rules by redefining them without commands. */ 312 if (rule->deps != 0 && rule->cmds == 0) 313 continue; 314 315 /* If this rule is in use by a parent pattern_search, 316 don't use it here. */ 317 if (rule->in_use) 318 { 319 DBS (DB_IMPLICIT, (_("Avoiding implicit rule recursion.\n"))); 320 continue; 321 } 322 323 for (i = 0; rule->targets[i] != 0; ++i) 324 { 325 char *target = rule->targets[i]; 326 char *suffix = rule->suffixes[i]; 327 int check_lastslash; 328 329 /* Rules that can match any filename and are not terminal 330 are ignored if we're recursing, so that they cannot be 331 intermediate files. */ 332 if (recursions > 0 && target[1] == '\0' && !rule->terminal) 333 continue; 334 335 if (rule->lens[i] > namelen) 336 /* It can't possibly match. */ 337 continue; 338 339 /* From the lengths of the filename and the pattern parts, 340 find the stem: the part of the filename that matches the %. */ 341 stem = filename + (suffix - target - 1); 342 stemlen = namelen - rule->lens[i] + 1; 343 344 /* Set CHECK_LASTSLASH if FILENAME contains a directory 345 prefix and the target pattern does not contain a slash. */ 346 347 check_lastslash = 0; 348 if (lastslash) 349 { 350#ifdef VMS 351 check_lastslash = (strchr (target, ']') == 0 352 && strchr (target, ':') == 0); 353#else 354 check_lastslash = strchr (target, '/') == 0; 355#ifdef HAVE_DOS_PATHS 356 /* Didn't find it yet: check for DOS-type directories. */ 357 if (check_lastslash) 358 { 359 char *b = strchr (target, '\\'); 360 check_lastslash = !(b || (target[0] && target[1] == ':')); 361 } 362#endif 363#endif 364 } 365 if (check_lastslash) 366 { 367 /* If so, don't include the directory prefix in STEM here. */ 368 unsigned int difference = lastslash - filename + 1; 369 if (difference > stemlen) 370 continue; 371 stemlen -= difference; 372 stem += difference; 373 } 374 375 /* Check that the rule pattern matches the text before the stem. */ 376 if (check_lastslash) 377 { 378 if (stem > (lastslash + 1) 379 && !strneq (target, lastslash + 1, stem - lastslash - 1)) 380 continue; 381 } 382 else if (stem > filename 383 && !strneq (target, filename, stem - filename)) 384 continue; 385 386 /* Check that the rule pattern matches the text after the stem. 387 We could test simply use streq, but this way we compare the 388 first two characters immediately. This saves time in the very 389 common case where the first character matches because it is a 390 period. */ 391 if (*suffix != stem[stemlen] 392 || (*suffix != '\0' && !streq (&suffix[1], &stem[stemlen + 1]))) 393 continue; 394 395 /* Record if we match a rule that not all filenames will match. */ 396 if (target[1] != '\0') 397 specific_rule_matched = 1; 398 399 /* A rule with no dependencies and no commands exists solely to set 400 specific_rule_matched when it matches. Don't try to use it. */ 401 if (rule->deps == 0 && rule->cmds == 0) 402 continue; 403 404 /* Record this rule in TRYRULES and the index of the matching 405 target in MATCHES. If several targets of the same rule match, 406 that rule will be in TRYRULES more than once. */ 407 tryrules[nrules] = rule; 408 matches[nrules] = i; 409 checked_lastslash[nrules] = check_lastslash; 410 ++nrules; 411 } 412 } 413 414 /* If we have found a matching rule that won't match all filenames, 415 retroactively reject any non-"terminal" rules that do always match. */ 416 if (specific_rule_matched) 417 for (i = 0; i < nrules; ++i) 418 if (!tryrules[i]->terminal) 419 { 420 register unsigned int j; 421 for (j = 0; tryrules[i]->targets[j] != 0; ++j) 422 if (tryrules[i]->targets[j][1] == '\0') 423 break; 424 if (tryrules[i]->targets[j] != 0) 425 tryrules[i] = 0; 426 } 427 428 /* We are going to do second expansion so initialize file variables 429 for the rule. */ 430 initialize_file_variables (file, 0); 431 432 /* Try each rule once without intermediate files, then once with them. */ 433 for (intermed_ok = 0; intermed_ok == !!intermed_ok; ++intermed_ok) 434 { 435 /* Try each pattern rule till we find one that applies. 436 If it does, expand its dependencies (as substituted) 437 and chain them in DEPS. */ 438 439 for (i = 0; i < nrules; i++) 440 { 441 struct file *f; 442 unsigned int failed = 0; 443 int check_lastslash; 444 int file_variables_set = 0; 445 446 rule = tryrules[i]; 447 448 remove_explicit_deps = 0; 449 450 /* RULE is nil when we discover that a rule, 451 already placed in TRYRULES, should not be applied. */ 452 if (rule == 0) 453 continue; 454 455 /* Reject any terminal rules if we're 456 looking to make intermediate files. */ 457 if (intermed_ok && rule->terminal) 458 continue; 459 460 /* Mark this rule as in use so a recursive 461 pattern_search won't try to use it. */ 462 rule->in_use = 1; 463 464 /* From the lengths of the filename and the matching pattern parts, 465 find the stem: the part of the filename that matches the %. */ 466 stem = filename 467 + (rule->suffixes[matches[i]] - rule->targets[matches[i]]) - 1; 468 stemlen = namelen - rule->lens[matches[i]] + 1; 469 check_lastslash = checked_lastslash[i]; 470 if (check_lastslash) 471 { 472 stem += lastslash - filename + 1; 473 stemlen -= (lastslash - filename) + 1; 474 } 475 476 DBS (DB_IMPLICIT, (_("Trying pattern rule with stem `%.*s'.\n"), 477 (int) stemlen, stem)); 478 479 strncpy (stem_str, stem, stemlen); 480 stem_str[stemlen] = '\0'; 481 482 /* Temporary assign STEM to file->stem (needed to set file 483 variables below). */ 484 file->stem = stem_str; 485 486 /* Try each dependency; see if it "exists". */ 487 488 for (dep = rule->deps; dep != 0; dep = dep->next) 489 { 490 unsigned int len; 491 char *p2; 492 unsigned int order_only = 0; /* Set if '|' was seen. */ 493 494 /* In an ideal world we would take the dependency line, 495 substitute the stem, re-expand the whole line and chop it 496 into individual prerequisites. Unfortunately this won't work 497 because of the "check_lastslash" twist. Instead, we will 498 have to go word by word, taking $()'s into account, for each 499 word we will substitute the stem, re-expand, chop it up, and, 500 if check_lastslash != 0, add the directory part to each 501 resulting prerequisite. */ 502 503 p = get_next_word (dep->name, &len); 504 505 while (1) 506 { 507 int add_dir = 0; 508 int had_stem = 0; 509 510 if (p == 0) 511 break; /* No more words */ 512 513 /* Is there a pattern in this prerequisite? */ 514 515 for (p2 = p; p2 < p + len && *p2 != '%'; ++p2) 516 ; 517 518 if (dep->need_2nd_expansion) 519 { 520 /* If the dependency name has %, substitute the stem. 521 522 Watch out, we are going to do something tricky 523 here. If we just replace % with the stem value, 524 later, when we do the second expansion, we will 525 re-expand this stem value once again. This is not 526 good especially if you have certain characters in 527 your stem (like $). 528 529 Instead, we will replace % with $* and allow the 530 second expansion to take care of it for us. This way 531 (since $* is a simple variable) there won't be 532 additional re-expansion of the stem. */ 533 534 if (p2 < p + len) 535 { 536 register unsigned int i = p2 - p; 537 bcopy (p, depname, i); 538 bcopy ("$*", depname + i, 2); 539 bcopy (p2 + 1, depname + i + 2, len - i - 1); 540 depname[len + 2 - 1] = '\0'; 541 542 if (check_lastslash) 543 add_dir = 1; 544 545 had_stem = 1; 546 } 547 else 548 { 549 bcopy (p, depname, len); 550 depname[len] = '\0'; 551 } 552 553 /* Set file variables. Note that we cannot do it once 554 at the beginning of the function because of the stem 555 value. */ 556 if (!file_variables_set) 557 { 558 set_file_variables (file); 559 file_variables_set = 1; 560 } 561 562 p2 = variable_expand_for_file (depname, file); 563 } 564 else 565 { 566 if (p2 < p + len) 567 { 568 register unsigned int i = p2 - p; 569 bcopy (p, depname, i); 570 bcopy (stem_str, depname + i, stemlen); 571 bcopy (p2 + 1, depname + i + stemlen, len - i - 1); 572 depname[len + stemlen - 1] = '\0'; 573 574 if (check_lastslash) 575 add_dir = 1; 576 577 had_stem = 1; 578 } 579 else 580 { 581 bcopy (p, depname, len); 582 depname[len] = '\0'; 583 } 584 585 p2 = depname; 586 } 587 588 /* Parse the dependencies. */ 589 590 while (1) 591 { 592 id_ptr = &deps; 593 594 for (; *id_ptr; id_ptr = &(*id_ptr)->next) 595 ; 596 597 *id_ptr = (struct idep *) 598 multi_glob ( 599 parse_file_seq (&p2, 600 order_only ? '\0' : '|', 601 sizeof (struct idep), 602 1), sizeof (struct idep)); 603 604 /* @@ It would be nice to teach parse_file_seq or 605 multi_glob to add prefix. This would save us some 606 reallocations. */ 607 608 if (order_only || add_dir || had_stem) 609 { 610 unsigned long l = lastslash - filename + 1; 611 612 for (d = *id_ptr; d != 0; d = d->next) 613 { 614 if (order_only) 615 d->ignore_mtime = 1; 616 617 if (add_dir) 618 { 619 char *p = d->name; 620 621 d->name = xmalloc (strlen (p) + l + 1); 622 623 bcopy (filename, d->name, l); 624 bcopy (p, d->name + l, strlen (p) + 1); 625 626 free (p); 627 } 628 629 if (had_stem) 630 d->had_stem = 1; 631 } 632 } 633 634 if (!order_only && *p2) 635 { 636 ++p2; 637 order_only = 1; 638 continue; 639 } 640 641 break; 642 } 643 644 p += len; 645 p = get_next_word (p, &len); 646 } 647 } 648 649 /* Reset the stem in FILE. */ 650 651 file->stem = 0; 652 653 /* @@ This loop can be combined with the previous one. I do 654 it separately for now for transparency.*/ 655 656 for (d = deps; d != 0; d = d->next) 657 { 658 char *name = d->name; 659 660 if (file_impossible_p (name)) 661 { 662 /* If this dependency has already been ruled "impossible", 663 then the rule fails and don't bother trying it on the 664 second pass either since we know that will fail too. */ 665 DBS (DB_IMPLICIT, 666 (d->had_stem 667 ? _("Rejecting impossible implicit prerequisite `%s'.\n") 668 : _("Rejecting impossible rule prerequisite `%s'.\n"), 669 name)); 670 tryrules[i] = 0; 671 672 failed = 1; 673 break; 674 } 675 676 DBS (DB_IMPLICIT, 677 (d->had_stem 678 ? _("Trying implicit prerequisite `%s'.\n") 679 : _("Trying rule prerequisite `%s'.\n"), name)); 680 681 /* If this prerequisite also happened to be explicitly mentioned 682 for FILE skip all the test below since it it has to be built 683 anyway, no matter which implicit rule we choose. */ 684 685 for (expl_d = file->deps; expl_d != 0; expl_d = expl_d->next) 686 if (streq (dep_name (expl_d), name)) 687 break; 688 if (expl_d != 0) 689 continue; 690 691 /* The DEP->changed flag says that this dependency resides in a 692 nonexistent directory. So we normally can skip looking for 693 the file. However, if CHECK_LASTSLASH is set, then the 694 dependency file we are actually looking for is in a different 695 directory (the one gotten by prepending FILENAME's directory), 696 so it might actually exist. */ 697 698 /* @@ dep->changed check is disabled. */ 699 if (((f = lookup_file (name)) != 0 && f->is_target) 700 /*|| ((!dep->changed || check_lastslash) && */ 701 || file_exists_p (name)) 702 continue; 703 704 /* This code, given FILENAME = "lib/foo.o", dependency name 705 "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */ 706 vname = name; 707 if (vpath_search (&vname, (FILE_TIMESTAMP *) 0)) 708 { 709 DBS (DB_IMPLICIT, 710 (_("Found prerequisite `%s' as VPATH `%s'\n"), 711 name, 712 vname)); 713 714 free (vname); 715 continue; 716 } 717 718 719 /* We could not find the file in any place we should look. Try 720 to make this dependency as an intermediate file, but only on 721 the second pass. */ 722 723 if (intermed_ok) 724 { 725 if (intermediate_file == 0) 726 intermediate_file 727 = (struct file *) alloca (sizeof (struct file)); 728 729 DBS (DB_IMPLICIT, 730 (_("Looking for a rule with intermediate file `%s'.\n"), 731 name)); 732 733 bzero ((char *) intermediate_file, sizeof (struct file)); 734 intermediate_file->name = name; 735 if (pattern_search (intermediate_file, 736 0, 737 depth + 1, 738 recursions + 1)) 739 { 740 d->intermediate_file = intermediate_file; 741 d->intermediate_pattern = intermediate_file->name; 742 743 intermediate_file->name = xstrdup (name); 744 intermediate_file = 0; 745 746 continue; 747 } 748 749 /* If we have tried to find P as an intermediate 750 file and failed, mark that name as impossible 751 so we won't go through the search again later. */ 752 if (intermediate_file->variables) 753 free_variable_set (intermediate_file->variables); 754 file_impossible (name); 755 } 756 757 /* A dependency of this rule does not exist. Therefore, 758 this rule fails. */ 759 failed = 1; 760 break; 761 } 762 763 /* This rule is no longer `in use' for recursive searches. */ 764 rule->in_use = 0; 765 766 if (failed) 767 { 768 /* This pattern rule does not apply. If some of its 769 dependencies succeeded, free the data structure 770 describing them. */ 771 free_idep_chain (deps); 772 deps = 0; 773 } 774 else 775 /* This pattern rule does apply. Stop looking for one. */ 776 break; 777 } 778 779 /* If we found an applicable rule without 780 intermediate files, don't try with them. */ 781 if (i < nrules) 782 break; 783 784 rule = 0; 785 } 786 787 /* RULE is nil if the loop went all the way 788 through the list and everything failed. */ 789 if (rule == 0) 790 goto done; 791 792 foundrule = i; 793 794 /* If we are recursing, store the pattern that matched 795 FILENAME in FILE->name for use in upper levels. */ 796 797 if (recursions > 0) 798 /* Kludge-o-matic */ 799 file->name = rule->targets[matches[foundrule]]; 800 801 /* FOUND_FILES lists the dependencies for the rule we found. 802 This includes the intermediate files, if any. 803 Convert them into entries on the deps-chain of FILE. */ 804 805 if (remove_explicit_deps) 806 { 807 /* Remove all the dependencies that didn't come from 808 this implicit rule. */ 809 810 dep = file->deps; 811 while (dep != 0) 812 { 813 struct dep *next = dep->next; 814 free_dep (dep); 815 dep = next; 816 } 817 file->deps = 0; 818 } 819 820 expl_d = file->deps; /* We will add them at the end. */ 821 d_ptr = &file->deps; 822 823 for (d = deps; d != 0; d = d->next) 824 { 825 register char *s; 826 827 if (d->intermediate_file != 0) 828 { 829 /* If we need to use an intermediate file, 830 make sure it is entered as a target, with the info that was 831 found for it in the recursive pattern_search call. 832 We know that the intermediate file did not already exist as 833 a target; therefore we can assume that the deps and cmds 834 of F below are null before we change them. */ 835 836 struct file *imf = d->intermediate_file; 837 register struct file *f = lookup_file (imf->name); 838 839 /* We don't want to delete an intermediate file that happened 840 to be a prerequisite of some (other) target. Mark it as 841 precious. */ 842 if (f != 0) 843 f->precious = 1; 844 else 845 f = enter_file (imf->name); 846 847 f->deps = imf->deps; 848 f->cmds = imf->cmds; 849 f->stem = imf->stem; 850 f->also_make = imf->also_make; 851 f->is_target = 1; 852 853 if (!f->precious) 854 { 855 imf = lookup_file (d->intermediate_pattern); 856 if (imf != 0 && imf->precious) 857 f->precious = 1; 858 } 859 860 f->intermediate = 1; 861 f->tried_implicit = 1; 862 for (dep = f->deps; dep != 0; dep = dep->next) 863 { 864 dep->file = enter_file (dep->name); 865 /* enter_file uses dep->name _if_ we created a new file. */ 866 if (dep->name != dep->file->name) 867 free (dep->name); 868 dep->name = 0; 869 dep->file->tried_implicit |= dep->changed; 870 } 871 } 872 873 dep = alloc_dep (); 874 dep->ignore_mtime = d->ignore_mtime; 875 s = d->name; /* Hijacking the name. */ 876 d->name = 0; 877 if (recursions == 0) 878 { 879 dep->file = lookup_file (s); 880 if (dep->file == 0) 881 /* enter_file consumes S's storage. */ 882 dep->file = enter_file (s); 883 else 884 /* A copy of S is already allocated in DEP->file->name. 885 So we can free S. */ 886 free (s); 887 } 888 else 889 { 890 dep->name = s; 891 } 892 893 if (d->intermediate_file == 0 && tryrules[foundrule]->terminal) 894 { 895 /* If the file actually existed (was not an intermediate file), 896 and the rule that found it was a terminal one, then we want 897 to mark the found file so that it will not have implicit rule 898 search done for it. If we are not entering a `struct file' for 899 it now, we indicate this with the `changed' flag. */ 900 if (dep->file == 0) 901 dep->changed = 1; 902 else 903 dep->file->tried_implicit = 1; 904 } 905 906 *d_ptr = dep; 907 d_ptr = &dep->next; 908 } 909 910 *d_ptr = expl_d; 911 912 if (!checked_lastslash[foundrule]) 913 { 914 /* Always allocate new storage, since STEM might be 915 on the stack for an intermediate file. */ 916 file->stem = savestring (stem, stemlen); 917 fullstemlen = stemlen; 918 } 919 else 920 { 921 int dirlen = (lastslash + 1) - filename; 922 923 /* We want to prepend the directory from 924 the original FILENAME onto the stem. */ 925 fullstemlen = dirlen + stemlen; 926 file->stem = (char *) xmalloc (fullstemlen + 1); 927 bcopy (filename, file->stem, dirlen); 928 bcopy (stem, file->stem + dirlen, stemlen); 929 file->stem[fullstemlen] = '\0'; 930 } 931 932 file->cmds = rule->cmds; 933 file->is_target = 1; 934 935 /* Set precious flag. */ 936 { 937 struct file *f = lookup_file (rule->targets[matches[foundrule]]); 938 if (f && f->precious) 939 file->precious = 1; 940 } 941 942 /* If this rule builds other targets, too, put the others into FILE's 943 `also_make' member. */ 944 945 if (rule->targets[1] != 0) 946 for (i = 0; rule->targets[i] != 0; ++i) 947 if (i != matches[foundrule]) 948 { 949 struct file *f; 950 struct dep *new = alloc_dep (); 951 952 /* GKM FIMXE: handle '|' here too */ 953 new->name = p = (char *) xmalloc (rule->lens[i] + fullstemlen + 1); 954 bcopy (rule->targets[i], p, 955 rule->suffixes[i] - rule->targets[i] - 1); 956 p += rule->suffixes[i] - rule->targets[i] - 1; 957 bcopy (file->stem, p, fullstemlen); 958 p += fullstemlen; 959 bcopy (rule->suffixes[i], p, 960 rule->lens[i] - (rule->suffixes[i] - rule->targets[i]) + 1); 961 new->file = enter_file (new->name); 962 new->next = file->also_make; 963 964 /* Set precious flag. */ 965 f = lookup_file (rule->targets[i]); 966 if (f && f->precious) 967 new->file->precious = 1; 968 969 /* Set the is_target flag so that this file is not treated 970 as intermediate by the pattern rule search algorithm and 971 file_exists_p cannot pick it up yet. */ 972 new->file->is_target = 1; 973 974 file->also_make = new; 975 } 976 977 done: 978 free_idep_chain (deps); 979 free (tryrules); 980 981 return rule != 0; 982} 983