1 /* Implicit rule searching for GNU Make.
2 Copyright (C) 1988,89,90,91,92,93,94,97,2000 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
26 static int pattern_search
PARAMS ((struct file
*file
, int archive
, unsigned int depth
,
27 unsigned int recursions
));
29 /* For a FILE which has no commands specified, try to figure out some
30 from the implicit pattern rules.
31 Returns 1 if a suitable implicit rule was found,
32 after modifying FILE to contain the appropriate commands and deps,
33 or returns 0 if no implicit rule was found. */
36 try_implicit_rule (struct file
*file
, unsigned int depth
)
38 DBF (DB_IMPLICIT
, _("Looking for an implicit rule for `%s'.\n"));
40 /* The order of these searches was previously reversed. My logic now is
41 that since the non-archive search uses more information in the target
42 (the archive search omits the archive name), it is more specific and
45 if (pattern_search (file
, 0, depth
, 0))
49 /* If this is an archive member reference, use just the
50 archive member name to search for implicit rules. */
51 if (ar_name (file
->name
))
54 _("Looking for archive-member implicit rule for `%s'.\n"));
55 if (pattern_search (file
, 1, depth
, 0))
64 /* Search the pattern rules for a rule with an existing dependency to make
65 FILE. If a rule is found, the appropriate commands and deps are put in FILE
66 and 1 is returned. If not, 0 is returned.
68 If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)". A rule for
69 "(MEMBER)" will be searched for, and "(MEMBER)" will not be chopped up into
70 directory and filename parts.
72 If an intermediate file is found by pattern search, the intermediate file
73 is set up as a target by the recursive call and is also made a dependency
76 DEPTH is used for debugging messages. */
79 pattern_search (struct file
*file
, int archive
,
80 unsigned int depth
, unsigned int recursions
)
82 /* Filename we are searching for a rule for. */
83 char *filename
= archive
? strchr (file
->name
, '(') : file
->name
;
85 /* Length of FILENAME. */
86 unsigned int namelen
= strlen (filename
);
88 /* The last slash in FILENAME (or nil if there is none). */
91 /* This is a file-object used as an argument in
92 recursive calls. It never contains any data
93 except during a recursive call. */
94 struct file
*intermediate_file
= 0;
96 /* List of dependencies found recursively. */
97 struct file
**intermediate_files
98 = (struct file
**) xmalloc (max_pattern_deps
* sizeof (struct file
*));
100 /* List of the patterns used to find intermediate files. */
101 char **intermediate_patterns
102 = (char **) alloca (max_pattern_deps
* sizeof (char *));
104 /* This buffer records all the dependencies actually found for a rule. */
105 char **found_files
= (char **) alloca (max_pattern_deps
* sizeof (char *));
106 /* Remember whether the associated dep has an "ignore_mtime" flag set. */
107 unsigned char *found_files_im
= (unsigned char *) alloca (max_pattern_deps
* sizeof (unsigned char));
108 /* Number of dep names now in FOUND_FILES. */
109 unsigned int deps_found
= 0;
111 /* Names of possible dependencies are constructed in this buffer. */
112 register char *depname
= (char *) alloca (namelen
+ max_pattern_dep_length
);
114 /* The start and length of the stem of FILENAME for the current rule. */
115 register char *stem
= 0;
116 register unsigned int stemlen
= 0;
117 register unsigned int fullstemlen
= 0;
119 /* Buffer in which we store all the rules that are possibly applicable. */
120 struct rule
**tryrules
121 = (struct rule
**) xmalloc (num_pattern_rules
* max_pattern_targets
122 * sizeof (struct rule
*));
124 /* Number of valid elements in TRYRULES. */
127 /* The numbers of the rule targets of each rule
128 in TRYRULES that matched the target file. */
129 unsigned int *matches
130 = (unsigned int *) alloca (num_pattern_rules
* sizeof (unsigned int));
132 /* Each element is nonzero if LASTSLASH was used in
133 matching the corresponding element of TRYRULES. */
134 char *checked_lastslash
135 = (char *) alloca (num_pattern_rules
* sizeof (char));
137 /* The index in TRYRULES of the rule we found. */
138 unsigned int foundrule
;
140 /* Nonzero if should consider intermediate files as dependencies. */
143 /* Nonzero if we have matched a pattern-rule target
144 that is not just `%'. */
145 int specific_rule_matched
= 0;
147 register unsigned int i
= 0; /* uninit checks OK */
148 register struct rule
*rule
;
149 register struct dep
*dep
;
154 if (archive
|| ar_name (filename
))
159 /* Set LASTSLASH to point at the last slash in FILENAME
160 but not counting any slash at the end. (foo/bar/ counts as
161 bar/ in directory foo/, not empty in directory foo/bar/.) */
163 lastslash
= strrchr (filename
, ']');
165 lastslash
= strrchr (filename
, ':');
167 lastslash
= strrchr (filename
, '/');
168 #ifdef HAVE_DOS_PATHS
169 /* Handle backslashes (possibly mixed with forward slashes)
170 and the case of "d:file". */
172 char *bslash
= strrchr (filename
, '\\');
173 if (lastslash
== 0 || bslash
> lastslash
)
175 if (lastslash
== 0 && filename
[0] && filename
[1] == ':')
176 lastslash
= filename
+ 1;
180 if (lastslash
!= 0 && lastslash
[1] == '\0')
184 /* First see which pattern rules match this target
185 and may be considered. Put them in TRYRULES. */
188 for (rule
= pattern_rules
; rule
!= 0; rule
= rule
->next
)
190 /* If the pattern rule has deps but no commands, ignore it.
191 Users cancel built-in rules by redefining them without commands. */
192 if (rule
->deps
!= 0 && rule
->cmds
== 0)
195 /* If this rule is in use by a parent pattern_search,
196 don't use it here. */
199 DBS (DB_IMPLICIT
, (_("Avoiding implicit rule recursion.\n")));
203 for (i
= 0; rule
->targets
[i
] != 0; ++i
)
205 char *target
= rule
->targets
[i
];
206 char *suffix
= rule
->suffixes
[i
];
209 /* Rules that can match any filename and are not terminal
210 are ignored if we're recursing, so that they cannot be
211 intermediate files. */
212 if (recursions
> 0 && target
[1] == '\0' && !rule
->terminal
)
215 if (rule
->lens
[i
] > namelen
)
216 /* It can't possibly match. */
219 /* From the lengths of the filename and the pattern parts,
220 find the stem: the part of the filename that matches the %. */
221 stem
= filename
+ (suffix
- target
- 1);
222 stemlen
= namelen
- rule
->lens
[i
] + 1;
224 /* Set CHECK_LASTSLASH if FILENAME contains a directory
225 prefix and the target pattern does not contain a slash. */
228 check_lastslash
= lastslash
!= 0
229 && ((strchr (target
, ']') == 0)
230 && (strchr (target
, ':') == 0));
232 check_lastslash
= lastslash
!= 0 && strchr (target
, '/') == 0;
236 /* In that case, don't include the
237 directory prefix in STEM here. */
238 unsigned int difference
= lastslash
- filename
+ 1;
239 if (difference
> stemlen
)
241 stemlen
-= difference
;
245 /* Check that the rule pattern matches the text before the stem. */
248 if (stem
> (lastslash
+ 1)
249 && !strneq (target
, lastslash
+ 1, stem
- lastslash
- 1))
252 else if (stem
> filename
253 && !strneq (target
, filename
, stem
- filename
))
256 /* Check that the rule pattern matches the text after the stem.
257 We could test simply use streq, but this way we compare the
258 first two characters immediately. This saves time in the very
259 common case where the first character matches because it is a
261 if (*suffix
!= stem
[stemlen
]
262 || (*suffix
!= '\0' && !streq (&suffix
[1], &stem
[stemlen
+ 1])))
265 /* Record if we match a rule that not all filenames will match. */
266 if (target
[1] != '\0')
267 specific_rule_matched
= 1;
269 /* A rule with no dependencies and no commands exists solely to set
270 specific_rule_matched when it matches. Don't try to use it. */
271 if (rule
->deps
== 0 && rule
->cmds
== 0)
274 /* Record this rule in TRYRULES and the index of the matching
275 target in MATCHES. If several targets of the same rule match,
276 that rule will be in TRYRULES more than once. */
277 tryrules
[nrules
] = rule
;
279 checked_lastslash
[nrules
] = check_lastslash
;
284 /* If we have found a matching rule that won't match all filenames,
285 retroactively reject any non-"terminal" rules that do always match. */
286 if (specific_rule_matched
)
287 for (i
= 0; i
< nrules
; ++i
)
288 if (!tryrules
[i
]->terminal
)
290 register unsigned int j
;
291 for (j
= 0; tryrules
[i
]->targets
[j
] != 0; ++j
)
292 if (tryrules
[i
]->targets
[j
][1] == '\0')
294 if (tryrules
[i
]->targets
[j
] != 0)
298 /* Try each rule once without intermediate files, then once with them. */
299 for (intermed_ok
= 0; intermed_ok
== !!intermed_ok
; ++intermed_ok
)
301 /* Try each pattern rule till we find one that applies.
302 If it does, copy the names of its dependencies (as substituted)
303 and store them in FOUND_FILES. DEPS_FOUND is the number of them. */
305 for (i
= 0; i
< nrules
; i
++)
311 /* RULE is nil when we discover that a rule,
312 already placed in TRYRULES, should not be applied. */
316 /* Reject any terminal rules if we're
317 looking to make intermediate files. */
318 if (intermed_ok
&& rule
->terminal
)
321 /* Mark this rule as in use so a recursive
322 pattern_search won't try to use it. */
325 /* From the lengths of the filename and the matching pattern parts,
326 find the stem: the part of the filename that matches the %. */
328 + (rule
->suffixes
[matches
[i
]] - rule
->targets
[matches
[i
]]) - 1;
329 stemlen
= namelen
- rule
->lens
[matches
[i
]] + 1;
330 check_lastslash
= checked_lastslash
[i
];
333 stem
+= lastslash
- filename
+ 1;
334 stemlen
-= (lastslash
- filename
) + 1;
337 DBS (DB_IMPLICIT
, (_("Trying pattern rule with stem `%.*s'.\n"),
338 (int) stemlen
, stem
));
340 /* Try each dependency; see if it "exists". */
343 for (dep
= rule
->deps
; dep
!= 0; dep
= dep
->next
)
347 /* If the dependency name has a %, substitute the stem. */
348 p
= strchr (dep_name (dep
), '%');
351 register unsigned int i
;
354 /* Copy directory name from the original FILENAME. */
355 i
= lastslash
- filename
+ 1;
356 bcopy (filename
, depname
, i
);
360 bcopy (dep_name (dep
), depname
+ i
, p
- dep_name (dep
));
361 i
+= p
- dep_name (dep
);
362 bcopy (stem
, depname
+ i
, stemlen
);
364 strcpy (depname
+ i
, p
+ 1);
370 /* P is now the actual dependency name as substituted. */
372 if (file_impossible_p (p
))
374 /* If this dependency has already been ruled
375 "impossible", then the rule fails and don't
376 bother trying it on the second pass either
377 since we know that will fail too. */
380 ? _("Rejecting impossible implicit prerequisite `%s'.\n")
381 : _("Rejecting impossible rule prerequisite `%s'.\n"),
387 intermediate_files
[deps_found
] = 0;
391 ? _("Trying implicit prerequisite `%s'.\n")
392 : _("Trying rule prerequisite `%s'.\n"), p
));
394 /* The DEP->changed flag says that this dependency resides in a
395 nonexistent directory. So we normally can skip looking for
396 the file. However, if CHECK_LASTSLASH is set, then the
397 dependency file we are actually looking for is in a different
398 directory (the one gotten by prepending FILENAME's directory),
399 so it might actually exist. */
401 if (((f
= lookup_file (p
)) != 0 && f
->is_target
)
402 || ((!dep
->changed
|| check_lastslash
) && file_exists_p (p
)))
404 found_files_im
[deps_found
] = dep
->ignore_mtime
;
405 found_files
[deps_found
++] = xstrdup (p
);
408 /* This code, given FILENAME = "lib/foo.o", dependency name
409 "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */
411 if (vpath_search (&vp
, (FILE_TIMESTAMP
*) 0))
414 (_("Found prerequisite `%s' as VPATH `%s'\n"), p
, vp
));
416 found_files_im
[deps_found
] = dep
->ignore_mtime
;
417 found_files
[deps_found
++] = vp
;
421 /* We could not find the file in any place we should look.
422 Try to make this dependency as an intermediate file,
423 but only on the second pass. */
427 if (intermediate_file
== 0)
429 = (struct file
*) alloca (sizeof (struct file
));
432 (_("Looking for a rule with intermediate file `%s'.\n"),
435 bzero ((char *) intermediate_file
, sizeof (struct file
));
436 intermediate_file
->name
= p
;
437 if (pattern_search (intermediate_file
, 0, depth
+ 1,
441 intermediate_patterns
[deps_found
]
442 = intermediate_file
->name
;
443 intermediate_file
->name
= p
;
444 intermediate_files
[deps_found
] = intermediate_file
;
445 intermediate_file
= 0;
446 found_files_im
[deps_found
] = dep
->ignore_mtime
;
447 /* Allocate an extra copy to go in FOUND_FILES,
448 because every elt of FOUND_FILES is consumed
450 found_files
[deps_found
++] = xstrdup (p
);
454 /* If we have tried to find P as an intermediate
455 file and failed, mark that name as impossible
456 so we won't go through the search again later. */
460 /* A dependency of this rule does not exist.
461 Therefore, this rule fails. */
465 /* This rule is no longer `in use' for recursive searches. */
470 /* This pattern rule does not apply.
471 If some of its dependencies succeeded,
472 free the data structure describing them. */
473 while (deps_found
-- > 0)
475 register struct file
*f
= intermediate_files
[deps_found
];
476 free (found_files
[deps_found
]);
478 && (f
->stem
< f
->name
479 || f
->stem
> f
->name
+ strlen (f
->name
)))
484 /* This pattern rule does apply. Stop looking for one. */
488 /* If we found an applicable rule without
489 intermediate files, don't try with them. */
496 /* RULE is nil if the loop went all the way
497 through the list and everything failed. */
503 /* If we are recursing, store the pattern that matched
504 FILENAME in FILE->name for use in upper levels. */
508 file
->name
= rule
->targets
[matches
[foundrule
]];
510 /* FOUND_FILES lists the dependencies for the rule we found.
511 This includes the intermediate files, if any.
512 Convert them into entries on the deps-chain of FILE. */
514 while (deps_found
-- > 0)
518 if (intermediate_files
[deps_found
] != 0)
520 /* If we need to use an intermediate file,
521 make sure it is entered as a target, with the info that was
522 found for it in the recursive pattern_search call.
523 We know that the intermediate file did not already exist as
524 a target; therefore we can assume that the deps and cmds
525 of F below are null before we change them. */
527 struct file
*imf
= intermediate_files
[deps_found
];
528 register struct file
*f
= enter_file (imf
->name
);
532 f
->also_make
= imf
->also_make
;
533 imf
= lookup_file (intermediate_patterns
[deps_found
]);
534 if (imf
!= 0 && imf
->precious
)
537 f
->tried_implicit
= 1;
538 for (dep
= f
->deps
; dep
!= 0; dep
= dep
->next
)
540 dep
->file
= enter_file (dep
->name
);
541 /* enter_file uses dep->name _if_ we created a new file. */
542 if (dep
->name
!= dep
->file
->name
)
545 dep
->file
->tried_implicit
|= dep
->changed
;
549 dep
= (struct dep
*) xmalloc (sizeof (struct dep
));
550 dep
->ignore_mtime
= found_files_im
[deps_found
];
551 s
= found_files
[deps_found
];
555 dep
->file
= lookup_file (s
);
557 /* enter_file consumes S's storage. */
558 dep
->file
= enter_file (s
);
560 /* A copy of S is already allocated in DEP->file->name.
570 if (intermediate_files
[deps_found
] == 0 && tryrules
[foundrule
]->terminal
)
572 /* If the file actually existed (was not an intermediate file),
573 and the rule that found it was a terminal one, then we want
574 to mark the found file so that it will not have implicit rule
575 search done for it. If we are not entering a `struct file' for
576 it now, we indicate this with the `changed' flag. */
580 dep
->file
->tried_implicit
= 1;
582 dep
->next
= file
->deps
;
586 if (!checked_lastslash
[foundrule
])
588 /* Always allocate new storage, since STEM might be
589 on the stack for an intermediate file. */
590 file
->stem
= savestring (stem
, stemlen
);
591 fullstemlen
= stemlen
;
595 int dirlen
= (lastslash
+ 1) - filename
;
597 /* We want to prepend the directory from
598 the original FILENAME onto the stem. */
599 fullstemlen
= dirlen
+ stemlen
;
600 file
->stem
= (char *) xmalloc (fullstemlen
+ 1);
601 bcopy (filename
, file
->stem
, dirlen
);
602 bcopy (stem
, file
->stem
+ dirlen
, stemlen
);
603 file
->stem
[fullstemlen
] = '\0';
606 file
->cmds
= rule
->cmds
;
608 /* If this rule builds other targets, too, put the others into FILE's
609 `also_make' member. */
611 if (rule
->targets
[1] != 0)
612 for (i
= 0; rule
->targets
[i
] != 0; ++i
)
613 if (i
!= matches
[foundrule
])
615 struct dep
*new = (struct dep
*) xmalloc (sizeof (struct dep
));
616 /* GKM FIMXE: handle '|' here too */
617 new->ignore_mtime
= 0;
618 new->name
= p
= (char *) xmalloc (rule
->lens
[i
] + fullstemlen
+ 1);
619 bcopy (rule
->targets
[i
], p
,
620 rule
->suffixes
[i
] - rule
->targets
[i
] - 1);
621 p
+= rule
->suffixes
[i
] - rule
->targets
[i
] - 1;
622 bcopy (file
->stem
, p
, fullstemlen
);
624 bcopy (rule
->suffixes
[i
], p
,
625 rule
->lens
[i
] - (rule
->suffixes
[i
] - rule
->targets
[i
]) + 1);
626 new->file
= enter_file (new->name
);
627 new->next
= file
->also_make
;
628 file
->also_make
= new;
632 free (intermediate_files
);