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