implicit.c@ 1993

Last change on this file since 1993 was 1993, checked in by bird, 16 years ago
Merged in current GNU Make code (CVS from 2008-10-28). Ref #55.
Property svn:eol-style set to `native`
File size: 30.8 KB

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

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kmk/implicit.c@ 1993

Download in other formats: