| /* Implicit rule searching for GNU Make. |
| Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, |
| 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software |
| Foundation, Inc. |
| This file is part of GNU Make. |
| |
| GNU Make is free software; you can redistribute it and/or modify it under the |
| terms of the GNU General Public License as published by the Free Software |
| Foundation; either version 2, or (at your option) any later version. |
| |
| GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR |
| A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License along with |
| GNU Make; see the file COPYING. If not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */ |
| |
| #include "make.h" |
| #include "filedef.h" |
| #include "rule.h" |
| #include "dep.h" |
| #include "debug.h" |
| #include "variable.h" |
| #include "job.h" /* struct child, used inside commands.h */ |
| #include "commands.h" /* set_file_variables */ |
| |
| static int |
| pattern_search PARAMS ((struct file *file, int archive, |
| unsigned int depth, unsigned int recursions)); |
| |
| /* For a FILE which has no commands specified, try to figure out some |
| from the implicit pattern rules. |
| Returns 1 if a suitable implicit rule was found, |
| after modifying FILE to contain the appropriate commands and deps, |
| or returns 0 if no implicit rule was found. */ |
| |
| int |
| try_implicit_rule (struct file *file, unsigned int depth) |
| { |
| DBF (DB_IMPLICIT, _("Looking for an implicit rule for `%s'.\n")); |
| |
| /* The order of these searches was previously reversed. My logic now is |
| that since the non-archive search uses more information in the target |
| (the archive search omits the archive name), it is more specific and |
| should come first. */ |
| |
| if (pattern_search (file, 0, depth, 0)) |
| return 1; |
| |
| #ifndef NO_ARCHIVES |
| /* If this is an archive member reference, use just the |
| archive member name to search for implicit rules. */ |
| if (ar_name (file->name)) |
| { |
| DBF (DB_IMPLICIT, |
| _("Looking for archive-member implicit rule for `%s'.\n")); |
| if (pattern_search (file, 1, depth, 0)) |
| return 1; |
| } |
| #endif |
| |
| return 0; |
| } |
| |
| |
| /* Struct idep captures information about implicit prerequisites |
| that come from implicit rules. */ |
| struct idep |
| { |
| struct idep *next; /* struct dep -compatible interface */ |
| char *name; /* name of the prerequisite */ |
| struct file *intermediate_file; /* intermediate file, 0 otherwise */ |
| char *intermediate_pattern; /* pattern for intermediate file */ |
| unsigned char had_stem; /* had % substituted with stem */ |
| unsigned char ignore_mtime; /* ignore_mtime flag */ |
| }; |
| |
| static void |
| free_idep_chain (struct idep *p) |
| { |
| struct idep *n; |
| |
| for (; p != 0; p = n) |
| { |
| n = p->next; |
| |
| if (p->name) |
| { |
| struct file *f = p->intermediate_file; |
| |
| if (f != 0 |
| && (f->stem < f->name || f->stem > f->name + strlen (f->name))) |
| free (f->stem); |
| |
| free (p->name); |
| } |
| |
| free (p); |
| } |
| } |
| |
| |
| /* Scans the BUFFER for the next word with whitespace as a separator. |
| Returns the pointer to the beginning of the word. LENGTH hold the |
| length of the word. */ |
| |
| static char * |
| get_next_word (char *buffer, unsigned int *length) |
| { |
| char *p = buffer, *beg; |
| char c; |
| |
| /* Skip any leading whitespace. */ |
| while (isblank ((unsigned char)*p)) |
| ++p; |
| |
| beg = p; |
| c = *(p++); |
| |
| if (c == '\0') |
| return 0; |
| |
| |
| /* We already found the first value of "c", above. */ |
| while (1) |
| { |
| char closeparen; |
| int count; |
| |
| switch (c) |
| { |
| case '\0': |
| case ' ': |
| case '\t': |
| goto done_word; |
| |
| case '$': |
| c = *(p++); |
| if (c == '$') |
| break; |
| |
| /* This is a variable reference, so read it to the matching |
| close paren. */ |
| |
| if (c == '(') |
| closeparen = ')'; |
| else if (c == '{') |
| closeparen = '}'; |
| else |
| /* This is a single-letter variable reference. */ |
| break; |
| |
| for (count = 0; *p != '\0'; ++p) |
| { |
| if (*p == c) |
| ++count; |
| else if (*p == closeparen && --count < 0) |
| { |
| ++p; |
| break; |
| } |
| } |
| break; |
| |
| case '|': |
| goto done; |
| |
| default: |
| break; |
| } |
| |
| c = *(p++); |
| } |
| done_word: |
| --p; |
| |
| done: |
| if (length) |
| *length = p - beg; |
| |
| return beg; |
| } |
| |
| /* Search the pattern rules for a rule with an existing dependency to make |
| FILE. If a rule is found, the appropriate commands and deps are put in FILE |
| and 1 is returned. If not, 0 is returned. |
| |
| If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)". A rule for |
| "(MEMBER)" will be searched for, and "(MEMBER)" will not be chopped up into |
| directory and filename parts. |
| |
| If an intermediate file is found by pattern search, the intermediate file |
| is set up as a target by the recursive call and is also made a dependency |
| of FILE. |
| |
| DEPTH is used for debugging messages. */ |
| |
| static int |
| pattern_search (struct file *file, int archive, |
| unsigned int depth, unsigned int recursions) |
| { |
| /* Filename we are searching for a rule for. */ |
| char *filename = archive ? strchr (file->name, '(') : file->name; |
| |
| /* Length of FILENAME. */ |
| unsigned int namelen = strlen (filename); |
| |
| /* The last slash in FILENAME (or nil if there is none). */ |
| char *lastslash; |
| |
| /* This is a file-object used as an argument in |
| recursive calls. It never contains any data |
| except during a recursive call. */ |
| struct file *intermediate_file = 0; |
| |
| /* This linked list records all the prerequisites actually |
| found for a rule along with some other useful information |
| (see struct idep for details). */ |
| struct idep* deps = 0; |
| |
| /* 1 if we need to remove explicit prerequisites, 0 otherwise. */ |
| unsigned int remove_explicit_deps = 0; |
| |
| /* Names of possible dependencies are constructed in this buffer. */ |
| register char *depname = (char *) alloca (namelen + max_pattern_dep_length); |
| |
| /* The start and length of the stem of FILENAME for the current rule. */ |
| register char *stem = 0; |
| register unsigned int stemlen = 0; |
| register unsigned int fullstemlen = 0; |
| |
| /* Buffer in which we store all the rules that are possibly applicable. */ |
| struct rule **tryrules |
| = (struct rule **) xmalloc (num_pattern_rules * max_pattern_targets |
| * sizeof (struct rule *)); |
| |
| /* Number of valid elements in TRYRULES. */ |
| unsigned int nrules; |
| |
| /* The numbers of the rule targets of each rule |
| in TRYRULES that matched the target file. */ |
| unsigned int *matches |
| = (unsigned int *) alloca (num_pattern_rules * sizeof (unsigned int)); |
| |
| /* Each element is nonzero if LASTSLASH was used in |
| matching the corresponding element of TRYRULES. */ |
| char *checked_lastslash |
| = (char *) alloca (num_pattern_rules * sizeof (char)); |
| |
| /* The index in TRYRULES of the rule we found. */ |
| unsigned int foundrule; |
| |
| /* Nonzero if should consider intermediate files as dependencies. */ |
| int intermed_ok; |
| |
| /* Nonzero if we have matched a pattern-rule target |
| that is not just `%'. */ |
| int specific_rule_matched = 0; |
| |
| unsigned int i = 0; /* uninit checks OK */ |
| struct rule *rule; |
| struct dep *dep, *expl_d; |
| |
| char *p, *vname; |
| |
| struct idep *d; |
| struct idep **id_ptr; |
| struct dep **d_ptr; |
| |
| PATH_VAR (stem_str); /* @@ Need to get rid of stem, stemlen, etc. */ |
| |
| #ifndef NO_ARCHIVES |
| if (archive || ar_name (filename)) |
| lastslash = 0; |
| else |
| #endif |
| { |
| /* Set LASTSLASH to point at the last slash in FILENAME |
| but not counting any slash at the end. (foo/bar/ counts as |
| bar/ in directory foo/, not empty in directory foo/bar/.) */ |
| #ifdef VMS |
| lastslash = strrchr (filename, ']'); |
| if (lastslash == 0) |
| lastslash = strrchr (filename, ':'); |
| #else |
| lastslash = strrchr (filename, '/'); |
| #ifdef HAVE_DOS_PATHS |
| /* Handle backslashes (possibly mixed with forward slashes) |
| and the case of "d:file". */ |
| { |
| char *bslash = strrchr (filename, '\\'); |
| if (lastslash == 0 || bslash > lastslash) |
| lastslash = bslash; |
| if (lastslash == 0 && filename[0] && filename[1] == ':') |
| lastslash = filename + 1; |
| } |
| #endif |
| #endif |
| if (lastslash != 0 && lastslash[1] == '\0') |
| lastslash = 0; |
| } |
| |
| /* First see which pattern rules match this target |
| and may be considered. Put them in TRYRULES. */ |
| |
| nrules = 0; |
| for (rule = pattern_rules; rule != 0; rule = rule->next) |
| { |
| /* If the pattern rule has deps but no commands, ignore it. |
| Users cancel built-in rules by redefining them without commands. */ |
| if (rule->deps != 0 && rule->cmds == 0) |
| continue; |
| |
| /* If this rule is in use by a parent pattern_search, |
| don't use it here. */ |
| if (rule->in_use) |
| { |
| DBS (DB_IMPLICIT, (_("Avoiding implicit rule recursion.\n"))); |
| continue; |
| } |
| |
| for (i = 0; rule->targets[i] != 0; ++i) |
| { |
| char *target = rule->targets[i]; |
| char *suffix = rule->suffixes[i]; |
| int check_lastslash; |
| |
| /* Rules that can match any filename and are not terminal |
| are ignored if we're recursing, so that they cannot be |
| intermediate files. */ |
| if (recursions > 0 && target[1] == '\0' && !rule->terminal) |
| continue; |
| |
| if (rule->lens[i] > namelen) |
| /* It can't possibly match. */ |
| continue; |
| |
| /* From the lengths of the filename and the pattern parts, |
| find the stem: the part of the filename that matches the %. */ |
| stem = filename + (suffix - target - 1); |
| stemlen = namelen - rule->lens[i] + 1; |
| |
| /* Set CHECK_LASTSLASH if FILENAME contains a directory |
| prefix and the target pattern does not contain a slash. */ |
| |
| check_lastslash = 0; |
| if (lastslash) |
| { |
| #ifdef VMS |
| check_lastslash = (strchr (target, ']') == 0 |
| && strchr (target, ':') == 0); |
| #else |
| check_lastslash = strchr (target, '/') == 0; |
| #ifdef HAVE_DOS_PATHS |
| /* Didn't find it yet: check for DOS-type directories. */ |
| if (check_lastslash) |
| { |
| char *b = strchr (target, '\\'); |
| check_lastslash = !(b || (target[0] && target[1] == ':')); |
| } |
| #endif |
| #endif |
| } |
| if (check_lastslash) |
| { |
| /* If so, don't include the directory prefix in STEM here. */ |
| unsigned int difference = lastslash - filename + 1; |
| if (difference > stemlen) |
| continue; |
| stemlen -= difference; |
| stem += difference; |
| } |
| |
| /* Check that the rule pattern matches the text before the stem. */ |
| if (check_lastslash) |
| { |
| if (stem > (lastslash + 1) |
| && !strneq (target, lastslash + 1, stem - lastslash - 1)) |
| continue; |
| } |
| else if (stem > filename |
| && !strneq (target, filename, stem - filename)) |
| continue; |
| |
| /* Check that the rule pattern matches the text after the stem. |
| We could test simply use streq, but this way we compare the |
| first two characters immediately. This saves time in the very |
| common case where the first character matches because it is a |
| period. */ |
| if (*suffix != stem[stemlen] |
| || (*suffix != '\0' && !streq (&suffix[1], &stem[stemlen + 1]))) |
| continue; |
| |
| /* Record if we match a rule that not all filenames will match. */ |
| if (target[1] != '\0') |
| specific_rule_matched = 1; |
| |
| /* A rule with no dependencies and no commands exists solely to set |
| specific_rule_matched when it matches. Don't try to use it. */ |
| if (rule->deps == 0 && rule->cmds == 0) |
| continue; |
| |
| /* Record this rule in TRYRULES and the index of the matching |
| target in MATCHES. If several targets of the same rule match, |
| that rule will be in TRYRULES more than once. */ |
| tryrules[nrules] = rule; |
| matches[nrules] = i; |
| checked_lastslash[nrules] = check_lastslash; |
| ++nrules; |
| } |
| } |
| |
| /* If we have found a matching rule that won't match all filenames, |
| retroactively reject any non-"terminal" rules that do always match. */ |
| if (specific_rule_matched) |
| for (i = 0; i < nrules; ++i) |
| if (!tryrules[i]->terminal) |
| { |
| register unsigned int j; |
| for (j = 0; tryrules[i]->targets[j] != 0; ++j) |
| if (tryrules[i]->targets[j][1] == '\0') |
| break; |
| if (tryrules[i]->targets[j] != 0) |
| tryrules[i] = 0; |
| } |
| |
| /* We are going to do second expansion so initialize file variables |
| for the rule. */ |
| initialize_file_variables (file, 0); |
| |
| /* Try each rule once without intermediate files, then once with them. */ |
| for (intermed_ok = 0; intermed_ok == !!intermed_ok; ++intermed_ok) |
| { |
| /* Try each pattern rule till we find one that applies. |
| If it does, expand its dependencies (as substituted) |
| and chain them in DEPS. */ |
| |
| for (i = 0; i < nrules; i++) |
| { |
| struct file *f; |
| unsigned int failed = 0; |
| int check_lastslash; |
| int file_variables_set = 0; |
| |
| rule = tryrules[i]; |
| |
| remove_explicit_deps = 0; |
| |
| /* RULE is nil when we discover that a rule, |
| already placed in TRYRULES, should not be applied. */ |
| if (rule == 0) |
| continue; |
| |
| /* Reject any terminal rules if we're |
| looking to make intermediate files. */ |
| if (intermed_ok && rule->terminal) |
| continue; |
| |
| /* Mark this rule as in use so a recursive |
| pattern_search won't try to use it. */ |
| rule->in_use = 1; |
| |
| /* From the lengths of the filename and the matching pattern parts, |
| find the stem: the part of the filename that matches the %. */ |
| stem = filename |
| + (rule->suffixes[matches[i]] - rule->targets[matches[i]]) - 1; |
| stemlen = namelen - rule->lens[matches[i]] + 1; |
| check_lastslash = checked_lastslash[i]; |
| if (check_lastslash) |
| { |
| stem += lastslash - filename + 1; |
| stemlen -= (lastslash - filename) + 1; |
| } |
| |
| DBS (DB_IMPLICIT, (_("Trying pattern rule with stem `%.*s'.\n"), |
| (int) stemlen, stem)); |
| |
| strncpy (stem_str, stem, stemlen); |
| stem_str[stemlen] = '\0'; |
| |
| /* Temporary assign STEM to file->stem (needed to set file |
| variables below). */ |
| file->stem = stem_str; |
| |
| /* Try each dependency; see if it "exists". */ |
| |
| for (dep = rule->deps; dep != 0; dep = dep->next) |
| { |
| unsigned int len; |
| char *p2; |
| unsigned int order_only = 0; /* Set if '|' was seen. */ |
| |
| /* In an ideal world we would take the dependency line, |
| substitute the stem, re-expand the whole line and chop it |
| into individual prerequisites. Unfortunately this won't work |
| because of the "check_lastslash" twist. Instead, we will |
| have to go word by word, taking $()'s into account, for each |
| word we will substitute the stem, re-expand, chop it up, and, |
| if check_lastslash != 0, add the directory part to each |
| resulting prerequisite. */ |
| |
| p = get_next_word (dep->name, &len); |
| |
| while (1) |
| { |
| int add_dir = 0; |
| int had_stem = 0; |
| |
| if (p == 0) |
| break; /* No more words */ |
| |
| /* Is there a pattern in this prerequisite? */ |
| |
| for (p2 = p; p2 < p + len && *p2 != '%'; ++p2) |
| ; |
| |
| if (dep->need_2nd_expansion) |
| { |
| /* If the dependency name has %, substitute the stem. |
| |
| Watch out, we are going to do something tricky |
| here. If we just replace % with the stem value, |
| later, when we do the second expansion, we will |
| re-expand this stem value once again. This is not |
| good especially if you have certain characters in |
| your stem (like $). |
| |
| Instead, we will replace % with $* and allow the |
| second expansion to take care of it for us. This way |
| (since $* is a simple variable) there won't be |
| additional re-expansion of the stem. */ |
| |
| if (p2 < p + len) |
| { |
| register unsigned int i = p2 - p; |
| bcopy (p, depname, i); |
| bcopy ("$*", depname + i, 2); |
| bcopy (p2 + 1, depname + i + 2, len - i - 1); |
| depname[len + 2 - 1] = '\0'; |
| |
| if (check_lastslash) |
| add_dir = 1; |
| |
| had_stem = 1; |
| } |
| else |
| { |
| bcopy (p, depname, len); |
| depname[len] = '\0'; |
| } |
| |
| /* Set file variables. Note that we cannot do it once |
| at the beginning of the function because of the stem |
| value. */ |
| if (!file_variables_set) |
| { |
| set_file_variables (file); |
| file_variables_set = 1; |
| } |
| |
| p2 = variable_expand_for_file (depname, file); |
| } |
| else |
| { |
| if (p2 < p + len) |
| { |
| register unsigned int i = p2 - p; |
| bcopy (p, depname, i); |
| bcopy (stem_str, depname + i, stemlen); |
| bcopy (p2 + 1, depname + i + stemlen, len - i - 1); |
| depname[len + stemlen - 1] = '\0'; |
| |
| if (check_lastslash) |
| add_dir = 1; |
| |
| had_stem = 1; |
| } |
| else |
| { |
| bcopy (p, depname, len); |
| depname[len] = '\0'; |
| } |
| |
| p2 = depname; |
| } |
| |
| /* Parse the dependencies. */ |
| |
| while (1) |
| { |
| id_ptr = &deps; |
| |
| for (; *id_ptr; id_ptr = &(*id_ptr)->next) |
| ; |
| |
| *id_ptr = (struct idep *) |
| multi_glob ( |
| parse_file_seq (&p2, |
| order_only ? '\0' : '|', |
| sizeof (struct idep), |
| 1), sizeof (struct idep)); |
| |
| /* @@ It would be nice to teach parse_file_seq or |
| multi_glob to add prefix. This would save us some |
| reallocations. */ |
| |
| if (order_only || add_dir || had_stem) |
| { |
| unsigned long l = lastslash - filename + 1; |
| |
| for (d = *id_ptr; d != 0; d = d->next) |
| { |
| if (order_only) |
| d->ignore_mtime = 1; |
| |
| if (add_dir) |
| { |
| char *p = d->name; |
| |
| d->name = xmalloc (strlen (p) + l + 1); |
| |
| bcopy (filename, d->name, l); |
| bcopy (p, d->name + l, strlen (p) + 1); |
| |
| free (p); |
| } |
| |
| if (had_stem) |
| d->had_stem = 1; |
| } |
| } |
| |
| if (!order_only && *p2) |
| { |
| ++p2; |
| order_only = 1; |
| continue; |
| } |
| |
| break; |
| } |
| |
| p += len; |
| p = get_next_word (p, &len); |
| } |
| } |
| |
| /* Reset the stem in FILE. */ |
| |
| file->stem = 0; |
| |
| /* @@ This loop can be combined with the previous one. I do |
| it separately for now for transparency.*/ |
| |
| for (d = deps; d != 0; d = d->next) |
| { |
| char *name = d->name; |
| |
| if (file_impossible_p (name)) |
| { |
| /* If this dependency has already been ruled "impossible", |
| then the rule fails and don't bother trying it on the |
| second pass either since we know that will fail too. */ |
| DBS (DB_IMPLICIT, |
| (d->had_stem |
| ? _("Rejecting impossible implicit prerequisite `%s'.\n") |
| : _("Rejecting impossible rule prerequisite `%s'.\n"), |
| name)); |
| tryrules[i] = 0; |
| |
| failed = 1; |
| break; |
| } |
| |
| DBS (DB_IMPLICIT, |
| (d->had_stem |
| ? _("Trying implicit prerequisite `%s'.\n") |
| : _("Trying rule prerequisite `%s'.\n"), name)); |
| |
| /* If this prerequisite also happened to be explicitly mentioned |
| for FILE skip all the test below since it it has to be built |
| anyway, no matter which implicit rule we choose. */ |
| |
| for (expl_d = file->deps; expl_d != 0; expl_d = expl_d->next) |
| if (streq (dep_name (expl_d), name)) |
| break; |
| if (expl_d != 0) |
| continue; |
| |
| /* The DEP->changed flag says that this dependency resides in a |
| nonexistent directory. So we normally can skip looking for |
| the file. However, if CHECK_LASTSLASH is set, then the |
| dependency file we are actually looking for is in a different |
| directory (the one gotten by prepending FILENAME's directory), |
| so it might actually exist. */ |
| |
| /* @@ dep->changed check is disabled. */ |
| if (((f = lookup_file (name)) != 0 && f->is_target) |
| /*|| ((!dep->changed || check_lastslash) && */ |
| || file_exists_p (name)) |
| continue; |
| |
| /* This code, given FILENAME = "lib/foo.o", dependency name |
| "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */ |
| vname = name; |
| if (vpath_search (&vname, (FILE_TIMESTAMP *) 0)) |
| { |
| DBS (DB_IMPLICIT, |
| (_("Found prerequisite `%s' as VPATH `%s'\n"), |
| name, |
| vname)); |
| |
| free (vname); |
| continue; |
| } |
| |
| |
| /* We could not find the file in any place we should look. Try |
| to make this dependency as an intermediate file, but only on |
| the second pass. */ |
| |
| if (intermed_ok) |
| { |
| if (intermediate_file == 0) |
| intermediate_file |
| = (struct file *) alloca (sizeof (struct file)); |
| |
| DBS (DB_IMPLICIT, |
| (_("Looking for a rule with intermediate file `%s'.\n"), |
| name)); |
| |
| bzero ((char *) intermediate_file, sizeof (struct file)); |
| intermediate_file->name = name; |
| if (pattern_search (intermediate_file, |
| 0, |
| depth + 1, |
| recursions + 1)) |
| { |
| d->intermediate_file = intermediate_file; |
| d->intermediate_pattern = intermediate_file->name; |
| |
| intermediate_file->name = xstrdup (name); |
| intermediate_file = 0; |
| |
| continue; |
| } |
| |
| /* If we have tried to find P as an intermediate |
| file and failed, mark that name as impossible |
| so we won't go through the search again later. */ |
| if (intermediate_file->variables) |
| free_variable_set (intermediate_file->variables); |
| file_impossible (name); |
| } |
| |
| /* A dependency of this rule does not exist. Therefore, |
| this rule fails. */ |
| failed = 1; |
| break; |
| } |
| |
| /* This rule is no longer `in use' for recursive searches. */ |
| rule->in_use = 0; |
| |
| if (failed) |
| { |
| /* This pattern rule does not apply. If some of its |
| dependencies succeeded, free the data structure |
| describing them. */ |
| free_idep_chain (deps); |
| deps = 0; |
| } |
| else |
| /* This pattern rule does apply. Stop looking for one. */ |
| break; |
| } |
| |
| /* If we found an applicable rule without |
| intermediate files, don't try with them. */ |
| if (i < nrules) |
| break; |
| |
| rule = 0; |
| } |
| |
| /* RULE is nil if the loop went all the way |
| through the list and everything failed. */ |
| if (rule == 0) |
| goto done; |
| |
| foundrule = i; |
| |
| /* If we are recursing, store the pattern that matched |
| FILENAME in FILE->name for use in upper levels. */ |
| |
| if (recursions > 0) |
| /* Kludge-o-matic */ |
| file->name = rule->targets[matches[foundrule]]; |
| |
| /* FOUND_FILES lists the dependencies for the rule we found. |
| This includes the intermediate files, if any. |
| Convert them into entries on the deps-chain of FILE. */ |
| |
| if (remove_explicit_deps) |
| { |
| /* Remove all the dependencies that didn't come from |
| this implicit rule. */ |
| |
| dep = file->deps; |
| while (dep != 0) |
| { |
| struct dep *next = dep->next; |
| free_dep (dep); |
| dep = next; |
| } |
| file->deps = 0; |
| } |
| |
| expl_d = file->deps; /* We will add them at the end. */ |
| d_ptr = &file->deps; |
| |
| for (d = deps; d != 0; d = d->next) |
| { |
| register char *s; |
| |
| if (d->intermediate_file != 0) |
| { |
| /* If we need to use an intermediate file, |
| make sure it is entered as a target, with the info that was |
| found for it in the recursive pattern_search call. |
| We know that the intermediate file did not already exist as |
| a target; therefore we can assume that the deps and cmds |
| of F below are null before we change them. */ |
| |
| struct file *imf = d->intermediate_file; |
| register struct file *f = lookup_file (imf->name); |
| |
| /* We don't want to delete an intermediate file that happened |
| to be a prerequisite of some (other) target. Mark it as |
| precious. */ |
| if (f != 0) |
| f->precious = 1; |
| else |
| f = enter_file (imf->name); |
| |
| f->deps = imf->deps; |
| f->cmds = imf->cmds; |
| f->stem = imf->stem; |
| f->also_make = imf->also_make; |
| f->is_target = 1; |
| |
| if (!f->precious) |
| { |
| imf = lookup_file (d->intermediate_pattern); |
| if (imf != 0 && imf->precious) |
| f->precious = 1; |
| } |
| |
| f->intermediate = 1; |
| f->tried_implicit = 1; |
| for (dep = f->deps; dep != 0; dep = dep->next) |
| { |
| dep->file = enter_file (dep->name); |
| /* enter_file uses dep->name _if_ we created a new file. */ |
| if (dep->name != dep->file->name) |
| free (dep->name); |
| dep->name = 0; |
| dep->file->tried_implicit |= dep->changed; |
| } |
| } |
| |
| dep = alloc_dep (); |
| dep->ignore_mtime = d->ignore_mtime; |
| s = d->name; /* Hijacking the name. */ |
| d->name = 0; |
| if (recursions == 0) |
| { |
| dep->file = lookup_file (s); |
| if (dep->file == 0) |
| /* enter_file consumes S's storage. */ |
| dep->file = enter_file (s); |
| else |
| /* A copy of S is already allocated in DEP->file->name. |
| So we can free S. */ |
| free (s); |
| } |
| else |
| { |
| dep->name = s; |
| } |
| |
| if (d->intermediate_file == 0 && tryrules[foundrule]->terminal) |
| { |
| /* If the file actually existed (was not an intermediate file), |
| and the rule that found it was a terminal one, then we want |
| to mark the found file so that it will not have implicit rule |
| search done for it. If we are not entering a `struct file' for |
| it now, we indicate this with the `changed' flag. */ |
| if (dep->file == 0) |
| dep->changed = 1; |
| else |
| dep->file->tried_implicit = 1; |
| } |
| |
| *d_ptr = dep; |
| d_ptr = &dep->next; |
| } |
| |
| *d_ptr = expl_d; |
| |
| if (!checked_lastslash[foundrule]) |
| { |
| /* Always allocate new storage, since STEM might be |
| on the stack for an intermediate file. */ |
| file->stem = savestring (stem, stemlen); |
| fullstemlen = stemlen; |
| } |
| else |
| { |
| int dirlen = (lastslash + 1) - filename; |
| |
| /* We want to prepend the directory from |
| the original FILENAME onto the stem. */ |
| fullstemlen = dirlen + stemlen; |
| file->stem = (char *) xmalloc (fullstemlen + 1); |
| bcopy (filename, file->stem, dirlen); |
| bcopy (stem, file->stem + dirlen, stemlen); |
| file->stem[fullstemlen] = '\0'; |
| } |
| |
| file->cmds = rule->cmds; |
| file->is_target = 1; |
| |
| /* Set precious flag. */ |
| { |
| struct file *f = lookup_file (rule->targets[matches[foundrule]]); |
| if (f && f->precious) |
| file->precious = 1; |
| } |
| |
| /* If this rule builds other targets, too, put the others into FILE's |
| `also_make' member. */ |
| |
| if (rule->targets[1] != 0) |
| for (i = 0; rule->targets[i] != 0; ++i) |
| if (i != matches[foundrule]) |
| { |
| struct file *f; |
| struct dep *new = alloc_dep (); |
| |
| /* GKM FIMXE: handle '|' here too */ |
| new->name = p = (char *) xmalloc (rule->lens[i] + fullstemlen + 1); |
| bcopy (rule->targets[i], p, |
| rule->suffixes[i] - rule->targets[i] - 1); |
| p += rule->suffixes[i] - rule->targets[i] - 1; |
| bcopy (file->stem, p, fullstemlen); |
| p += fullstemlen; |
| bcopy (rule->suffixes[i], p, |
| rule->lens[i] - (rule->suffixes[i] - rule->targets[i]) + 1); |
| new->file = enter_file (new->name); |
| new->next = file->also_make; |
| |
| /* Set precious flag. */ |
| f = lookup_file (rule->targets[i]); |
| if (f && f->precious) |
| new->file->precious = 1; |
| |
| /* Set the is_target flag so that this file is not treated |
| as intermediate by the pattern rule search algorithm and |
| file_exists_p cannot pick it up yet. */ |
| new->file->is_target = 1; |
| |
| file->also_make = new; |
| } |
| |
| done: |
| free_idep_chain (deps); |
| free (tryrules); |
| |
| return rule != 0; |
| } |
