VirtualBox

source: kBuild/trunk/src/gmakenew/implicit.c@ 902

最後變更 在這個檔案從902是 503,由 bird 提交於 19 年 前

Untested merge with GNU Make v3.81 (vendor/gnumake/2005-05-16 -> vendor/gnumake/current).

  • 屬性 svn:eol-style 設為 native
檔案大小: 30.7 KB
 
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
33/* 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
39int
40try_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
68
69/* Struct idep captures information about implicit prerequisites
70 that come from implicit rules. */
71struct 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
81static void
82free_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
110static char *
111get_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
201static int
202pattern_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}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette