file.c@ 1950

Last change on this file since 1950 was 1950, checked in by bird, 16 years ago
file.c: Workaround for borked double colon rules when doing parallel builds.
Property svn:eol-style set to `native`
File size: 38.8 KB

Line
1	/* Target file management for GNU Make.
2	Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3	1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4	Foundation, Inc.
5	This file is part of GNU Make.
6
7	GNU Make is free software; you can redistribute it and/or modify it under the
8	terms of the GNU General Public License as published by the Free Software
9	Foundation; either version 2, or (at your option) any later version.
10
11	GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License along with
16	GNU Make; see the file COPYING. If not, write to the Free Software
17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
18
19	#include "make.h"
20
21	#include <assert.h>
22
23	#include "dep.h"
24	#include "filedef.h"
25	#include "job.h"
26	#include "commands.h"
27	#include "variable.h"
28	#include "debug.h"
29	#include "hash.h"
30	#ifdef CONFIG_WITH_STRCACHE2
31	# include <stddef.h>
32	#endif
33
34
35	/* Remember whether snap_deps has been invoked: we need this to be sure we
36	don't add new rules (via $(eval ...)) afterwards. In the future it would
37	be nice to support this, but it means we'd need to re-run snap_deps() or
38	at least its functionality... it might mean changing snap_deps() to be run
39	per-file, so we can invoke it after the eval... or remembering which files
40	in the hash have been snapped (a new boolean flag?) and having snap_deps()
41	only work on files which have not yet been snapped. */
42	int snapped_deps = 0;
43
44	/* Hash table of files the makefile knows how to make. */
45
46	#ifndef CONFIG_WITH_STRCACHE2
47	static unsigned long
48	file_hash_1 (const void *key)
49	{
50	return_ISTRING_HASH_1 (((struct file const *) key)->hname);
51	}
52
53	static unsigned long
54	file_hash_2 (const void *key)
55	{
56	return_ISTRING_HASH_2 (((struct file const *) key)->hname);
57	}
58	#endif /* !CONFIG_WITH_STRCACHE2 */
59
60	static int
61	file_hash_cmp (const void x, const void y)
62	{
63	#ifndef CONFIG_WITH_STRCACHE2
64	return_ISTRING_COMPARE (((struct file const *) x)->hname,
65	((struct file const *) y)->hname);
66	#else /* CONFIG_WITH_STRCACHE2 */
67	return ((struct file const *) x)->hname
68	== ((struct file const *) y)->hname ? 0 : -1;
69	#endif /* CONFIG_WITH_STRCACHE2 */
70	}
71
72	#ifndef FILE_BUCKETS
73	#define FILE_BUCKETS 1007
74	#endif
75	static struct hash_table files;
76
77	/* Whether or not .SECONDARY with no prerequisites was given. */
78	static int all_secondary = 0;
79
80	/* Access the hash table of all file records.
81	lookup_file given a name, return the struct file * for that name,
82	or nil if there is none.
83	*/
84
85	#ifndef KMK
86	struct file *
87	lookup_file (const char *name)
88	#else /* KMK */
89	MY_INLINE struct file *
90	lookup_file_common (const char *name, int cached)
91	#endif /* KMK */
92	{
93	struct file *f;
94	struct file file_key;
95	#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS)
96	char *lname;
97	#endif
98
99	assert (*name != '\0');
100
101	/* This is also done in parse_file_seq, so this is redundant
102	for names read from makefiles. It is here for names passed
103	on the command line. */
104	#ifdef VMS
105	# ifndef WANT_CASE_SENSITIVE_TARGETS
106	if (*name != '.')
107	{
108	const char *n;
109	char *ln;
110	lname = xstrdup (name);
111	for (n = name, ln = lname; *n != '\0'; ++n, ++ln)
112	ln = isupper ((unsigned char)n) ? tolower ((unsigned char)n) : n;
113	*ln = '\0';
114	name = lname;
115	}
116	# endif
117
118	while (name[0] == '[' && name[1] == ']' && name[2] != '\0')
119	name += 2;
120	#endif
121	while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
122	{
123	name += 2;
124	while (*name == '/')
125	/* Skip following slashes: ".//foo" is "foo", not "/foo". */
126	++name;
127	}
128
129	if (*name == '\0')
130	/* It was all slashes after a dot. */
131	#if defined(VMS)
132	name = "[]";
133	#elif defined(_AMIGA)
134	name = "";
135	#else
136	name = "./";
137	#endif
138
139	#ifndef CONFIG_WITH_STRCACHE2
140	file_key.hname = name;
141	f = hash_find_item (&files, &file_key);
142	#else /* CONFIG_WITH_STRCACHE2 */
143	if (!cached)
144	{
145	file_key.hname = strcache2_lookup_file (&file_strcache, name, strlen (name));
146	if (file_key.hname)
147	f = hash_find_item_strcached (&files, &file_key);
148	else
149	f = NULL;
150	}
151	else
152	{
153	file_key.hname = name;
154	f = hash_find_item_strcached (&files, &file_key);
155	}
156
157	#endif /* CONFIG_WITH_STRCACHE2 */
158	#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS)
159	if (*name != '.')
160	free (lname);
161	#endif
162
163	return f;
164	}
165
166	#ifdef KMK
167	/* Given a name, return the struct file * for that name,
168	or nil if there is none. */
169
170	struct file *
171	lookup_file (const char *name)
172	{
173	return lookup_file_common (name, 0 /* cached */);
174	}
175
176	/* Given a name in the strcache, return the struct file * for that name,
177	or nil if there is none. */
178	struct file *
179	lookup_file_cached (const char *name)
180	{
181	assert (strcache_iscached (name));
182	return lookup_file_common (name, 1 /* cached */);
183	}
184	#endif /* KMK */
185
186
187	/* Look up a file record for file NAME and return it.
188	Create a new record if one doesn't exist. NAME will be stored in the
189	new record so it should be constant or in the strcache etc.
190	*/
191
192	struct file *
193	enter_file (const char *name)
194	{
195	struct file *f;
196	struct file *new;
197	struct file **file_slot;
198	struct file file_key;
199
200	assert (*name != '\0');
201	assert (strcache_iscached (name));
202
203	#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS)
204	if (*name != '.')
205	{
206	const char *n;
207	char lname, ln;
208	lname = xstrdup (name);
209	for (n = name, ln = lname; *n != '\0'; ++n, ++ln)
210	if (isupper ((unsigned char)*n))
211	ln = tolower ((unsigned char)n);
212	else
213	ln = n;
214
215	*ln = '\0';
216	name = strcache_add (lname);
217	free (lname);
218	}
219	#endif
220
221	file_key.hname = name;
222	#ifndef CONFIG_WITH_STRCACHE2
223	file_slot = (struct file **) hash_find_slot (&files, &file_key);
224	#else /* CONFIG_WITH_STRCACHE2 */
225	file_slot = (struct file **) hash_find_slot_strcached (&files, &file_key);
226	#endif /* CONFIG_WITH_STRCACHE2 */
227	f = *file_slot;
228	if (! HASH_VACANT (f) && !f->double_colon)
229	return f;
230
231	#ifndef CONFIG_WITH_ALLOC_CACHES
232	new = xmalloc (sizeof (struct file));
233	memset (new, '\0', sizeof (struct file));
234	#else
235	new = alloccache_calloc (&file_cache);
236	#endif
237	new->name = new->hname = name;
238	new->update_status = -1;
239
240	if (HASH_VACANT (f))
241	{
242	new->last = new;
243	hash_insert_at (&files, new, file_slot);
244	}
245	else
246	{
247	/* There is already a double-colon entry for this file. */
248	new->double_colon = f;
249	f->last->prev = new;
250	f->last = new;
251	}
252
253	#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
254	/* Check if the name needs 2nd expansion or not. */
255	if (second_target_expansion && strchr (name, '$') != NULL)
256	new->need_2nd_target_expansion = 1;
257	#endif
258
259	return new;
260	}
261
262
263	/* Rehash FILE to NAME. This is not as simple as resetting
264	the `hname' member, since it must be put in a new hash bucket,
265	and possibly merged with an existing file called NAME. */
266
267	void
268	rehash_file (struct file from_file, const char to_hname)
269	{
270	struct file file_key;
271	struct file **file_slot;
272	struct file *to_file;
273	struct file *deleted_file;
274	struct file *f;
275
276	#ifdef CONFIG_WITH_STRCACHE2
277	assert (strcache_iscached (to_hname));
278	assert (strcache_iscached (from_file->hname));
279	#endif
280
281	/* If it's already that name, we're done. */
282	file_key.hname = to_hname;
283	if (! file_hash_cmp (from_file, &file_key))
284	return;
285
286	/* Find the end of the renamed list for the "from" file. */
287	file_key.hname = from_file->hname;
288	while (from_file->renamed != 0)
289	from_file = from_file->renamed;
290	if (file_hash_cmp (from_file, &file_key))
291	/* hname changed unexpectedly!! */
292	abort ();
293
294	/* Remove the "from" file from the hash. */
295	#ifndef CONFIG_WITH_STRCACHE2
296	deleted_file = hash_delete (&files, from_file);
297	#else
298	deleted_file = hash_delete_strcached (&files, from_file);
299	#endif
300	if (deleted_file != from_file)
301	/* from_file isn't the one stored in files */
302	abort ();
303
304	/* Find where the newly renamed file will go in the hash. */
305	file_key.hname = to_hname;
306	#ifndef CONFIG_WITH_STRCACHE2
307	file_slot = (struct file **) hash_find_slot (&files, &file_key);
308	#else /* CONFIG_WITH_STRCACHE2 */
309	file_slot = (struct file **) hash_find_slot_strcached (&files, &file_key);
310	#endif /* CONFIG_WITH_STRCACHE2 */
311	to_file = *file_slot;
312
313	/* Change the hash name for this file. */
314	from_file->hname = to_hname;
315	for (f = from_file->double_colon; f != 0; f = f->prev)
316	f->hname = to_hname;
317
318	/* If the new name doesn't exist yet just set it to the renamed file. */
319	if (HASH_VACANT (to_file))
320	{
321	hash_insert_at (&files, from_file, file_slot);
322	return;
323	}
324
325	/* TO_FILE already exists under TO_HNAME.
326	We must retain TO_FILE and merge FROM_FILE into it. */
327
328	if (from_file->cmds != 0)
329	{
330	if (to_file->cmds == 0)
331	to_file->cmds = from_file->cmds;
332	else if (from_file->cmds != to_file->cmds)
333	{
334	/* We have two sets of commands. We will go with the
335	one given in the rule explicitly mentioning this name,
336	but give a message to let the user know what's going on. */
337	if (to_file->cmds->fileinfo.filenm != 0)
338	error (&from_file->cmds->fileinfo,
339	_("Commands were specified for file `%s' at %s:%lu,"),
340	from_file->name, to_file->cmds->fileinfo.filenm,
341	to_file->cmds->fileinfo.lineno);
342	else
343	error (&from_file->cmds->fileinfo,
344	_("Commands for file `%s' were found by implicit rule search,"),
345	from_file->name);
346	error (&from_file->cmds->fileinfo,
347	_("but `%s' is now considered the same file as `%s'."),
348	from_file->name, to_hname);
349	error (&from_file->cmds->fileinfo,
350	_("Commands for `%s' will be ignored in favor of those for `%s'."),
351	to_hname, from_file->name);
352	}
353	}
354
355	/* Merge the dependencies of the two files. */
356
357	if (to_file->deps == 0)
358	to_file->deps = from_file->deps;
359	else
360	{
361	struct dep *deps = to_file->deps;
362	while (deps->next != 0)
363	deps = deps->next;
364	deps->next = from_file->deps;
365	}
366
367	merge_variable_set_lists (&to_file->variables, from_file->variables);
368
369	if (to_file->double_colon && from_file->is_target && !from_file->double_colon)
370	fatal (NILF, _("can't rename single-colon `%s' to double-colon `%s'"),
371	from_file->name, to_hname);
372	if (!to_file->double_colon && from_file->double_colon)
373	{
374	if (to_file->is_target)
375	fatal (NILF, _("can't rename double-colon `%s' to single-colon `%s'"),
376	from_file->name, to_hname);
377	else
378	to_file->double_colon = from_file->double_colon;
379	}
380
381	if (from_file->last_mtime > to_file->last_mtime)
382	/* %%% Kludge so -W wins on a file that gets vpathized. */
383	to_file->last_mtime = from_file->last_mtime;
384
385	to_file->mtime_before_update = from_file->mtime_before_update;
386
387	#define MERGE(field) to_file->field \|= from_file->field
388	MERGE (precious);
389	MERGE (tried_implicit);
390	MERGE (updating);
391	MERGE (updated);
392	MERGE (is_target);
393	MERGE (cmd_target);
394	MERGE (phony);
395	MERGE (ignore_vpath);
396	#undef MERGE
397
398	from_file->renamed = to_file;
399	}
400
401	/* Rename FILE to NAME. This is not as simple as resetting
402	the `name' member, since it must be put in a new hash bucket,
403	and possibly merged with an existing file called NAME. */
404
405	void
406	rename_file (struct file from_file, const char to_hname)
407	{
408	rehash_file (from_file, to_hname);
409	while (from_file)
410	{
411	from_file->name = from_file->hname;
412	from_file = from_file->prev;
413	}
414	}
415
416
417	#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
418	/* Performs secondary target name expansion and then renames
419	the file using rename_file. */
420	static void
421	do_2nd_target_expansion (struct file *f)
422	{
423	unsigned int len;
424	char *tmp_name = allocated_variable_expand_2 (
425	f->name, strcache2_get_len (&file_strcache, f->name), &len);
426	const char *name = strcache_add_len (tmp_name, len);
427	free (tmp_name);
428	rename_file (f, name);
429	}
430	#endif /* CONFIG_WITH_2ND_TARGET_EXPANSION */
431
432
433	/* Remove all nonprecious intermediate files.
434	If SIG is nonzero, this was caused by a fatal signal,
435	meaning that a different message will be printed, and
436	the message will go to stderr rather than stdout. */
437
438	void
439	remove_intermediates (int sig)
440	{
441	struct file **file_slot;
442	struct file **file_end;
443	int doneany = 0;
444
445	/* If there's no way we will ever remove anything anyway, punt early. */
446	if (question_flag \|\| touch_flag \|\| all_secondary)
447	return;
448
449	if (sig && just_print_flag)
450	return;
451
452	file_slot = (struct file **) files.ht_vec;
453	file_end = file_slot + files.ht_size;
454	for ( ; file_slot < file_end; file_slot++)
455	if (! HASH_VACANT (*file_slot))
456	{
457	struct file f = file_slot;
458	/* Is this file eligible for automatic deletion?
459	Yes, IFF: it's marked intermediate, it's not secondary, it wasn't
460	given on the command-line, and it's either a -include makefile or
461	it's not precious. */
462	if (f->intermediate && (f->dontcare \|\| !f->precious)
463	&& !f->secondary && !f->cmd_target)
464	{
465	int status;
466	if (f->update_status == -1)
467	/* If nothing would have created this file yet,
468	don't print an "rm" command for it. */
469	continue;
470	if (just_print_flag)
471	status = 0;
472	else
473	{
474	status = unlink (f->name);
475	if (status < 0 && errno == ENOENT)
476	continue;
477	}
478	if (!f->dontcare)
479	{
480	if (sig)
481	error (NILF, _("*** Deleting intermediate file `%s'"), f->name);
482	else
483	{
484	if (! doneany)
485	DB (DB_BASIC, (_("Removing intermediate files...\n")));
486	if (!silent_flag)
487	{
488	if (! doneany)
489	{
490	fputs ("rm ", stdout);
491	doneany = 1;
492	}
493	else
494	putchar (' ');
495	fputs (f->name, stdout);
496	fflush (stdout);
497	}
498	}
499	if (status < 0)
500	perror_with_name ("unlink: ", f->name);
501	}
502	}
503	}
504
505	if (doneany && !sig)
506	{
507	putchar ('\n');
508	fflush (stdout);
509	}
510	}
511
512
513	struct dep *
514	parse_prereqs (char *p)
515	{
516	#ifndef CONFIG_WITH_ALLOC_CACHES
517	struct dep new = (struct dep )
518	multi_glob (parse_file_seq (&p, '\|', sizeof (struct dep), 1),
519	sizeof (struct dep));
520	#else
521	struct dep new = (struct dep )
522	multi_glob (parse_file_seq (&p, '\|', &dep_cache, 1), &dep_cache);
523	#endif
524
525	if (*p)
526	{
527	/* Files that follow '\|' are "order-only" prerequisites that satisfy the
528	dependency by existing: their modification times are irrelevant. */
529	struct dep *ood;
530
531	++p;
532	#ifndef CONFIG_WITH_ALLOC_CACHES
533	ood = (struct dep *)
534	multi_glob (parse_file_seq (&p, '\0', sizeof (struct dep), 1),
535	sizeof (struct dep));
536	#else
537	ood = (struct dep *)
538	multi_glob (parse_file_seq (&p, '\0', &dep_cache, 1), &dep_cache);
539	#endif
540	if (! new)
541	new = ood;
542	else
543	{
544	struct dep *dp;
545	for (dp = new; dp->next != NULL; dp = dp->next)
546	;
547	dp->next = ood;
548	}
549
550	for (; ood != NULL; ood = ood->next)
551	ood->ignore_mtime = 1;
552	}
553
554	return new;
555	}
556
557	/* Set the intermediate flag. */
558
559	static void
560	set_intermediate (const void *item)
561	{
562	struct file f = (struct file ) item;
563	f->intermediate = 1;
564	}
565
566	/* Expand and parse each dependency line. */
567	static void
568	expand_deps (struct file *f)
569	{
570	struct dep *d;
571	struct dep *old = f->deps;
572	const char *file_stem = f->stem;
573	unsigned int last_dep_has_cmds = f->updating;
574	int initialized = 0;
575
576	f->updating = 0;
577	f->deps = 0;
578
579	for (d = old; d != 0; d = d->next)
580	{
581	size_t buffer_offset; /* bird */
582	struct dep new, d1;
583	char *p;
584	#ifdef CONFIG_WITH_VALUE_LENGTH
585	unsigned int len;
586	#endif
587
588	if (! d->name)
589	continue;
590
591	#ifdef CONFIG_WITH_INCLUDEDEP
592	/* Dependencies loaded by includedep are ready for use and we skip
593	the expensive parsing and globbing for them. To avoid wasting
594	lots of time walking the f->deps chain, we will advance D and
595	process all subsequent includedep records. */
596
597	if (d->includedep)
598	{
599	new = d1 = alloc_dep();
600	d1->staticpattern = 0;
601	d1->need_2nd_expansion = 0;
602	d1->includedep = 1;
603	d1->file = lookup_file (d->name);
604	if (d1->file == 0)
605	d1->file = enter_file (d->name);
606
607	while (d->next && d->next->includedep)
608	{
609	d = d->next;
610	d1 = d1->next = alloc_dep();
611	d1->staticpattern = 0;
612	d1->need_2nd_expansion = 0;
613	d1->includedep = 1;
614	d1->file = lookup_file (d->name);
615	if (d1->file == 0)
616	d1->file = enter_file (d->name);
617	}
618	}
619	else
620	{
621	#endif
622
623	/* Create the dependency list.
624	If we're not doing 2nd expansion, then it's just the name. We will
625	still need to massage it though. */
626	if (! d->need_2nd_expansion)
627	{
628	p = variable_expand ("");
629	buffer_offset = p - variable_buffer;
630	#ifndef CONFIG_WITH_STRCACHE2
631	variable_buffer_output (p, d->name, strlen (d->name) + 1);
632	#else
633	len = strcache2_get_len (&file_strcache, d->name);
634	variable_buffer_output (p, d->name, len + 1);
635	#endif
636	p = variable_buffer + buffer_offset; /* bird - variable_buffer may have been reallocated. (observed it) */
637	}
638	else
639	{
640	/* If it's from a static pattern rule, convert the patterns into
641	"$" so they'll expand properly. /
642	if (d->staticpattern)
643	{
644	char *o;
645	char *buffer = variable_expand ("");
646	buffer_offset = buffer - variable_buffer; /* bird */
647
648	o = subst_expand (buffer, d->name, "%", "$*", 1, 2, 0);
649	buffer = variable_buffer + buffer_offset; /* bird - variable_buffer may have been reallocated. */
650
651	d->name = strcache_add_len (buffer, o - buffer);
652	d->staticpattern = 0; /* Clear staticpattern so that we don't
653	re-expand %s below. */
654	}
655
656	/* We are going to do second expansion so initialize file variables
657	for the file. Since the stem for static pattern rules comes from
658	individual dep lines, we will temporarily set f->stem to d->stem.
659	*/
660	if (!initialized)
661	{
662	initialize_file_variables (f, 0);
663	initialized = 1;
664	}
665
666	if (d->stem != 0)
667	f->stem = d->stem;
668
669	set_file_variables (f);
670
671	#ifndef CONFIG_WITH_STRCACHE2
672	p = variable_expand_for_file (d->name, f);
673	#else
674	len = strcache2_get_len (&file_strcache, d->name);
675	p = variable_expand_for_file_2 (NULL, d->name, len, f, &len);
676	#endif
677
678	if (d->stem != 0)
679	f->stem = file_stem;
680	}
681
682	/* Parse the prerequisites. */
683	new = parse_prereqs (p);
684
685	/* If this dep list was from a static pattern rule, expand the %s. We
686	use patsubst_expand to translate the prerequisites' patterns into
687	plain prerequisite names. */
688	if (new && d->staticpattern)
689	{
690	const char *pattern = "%";
691	char *buffer = variable_expand ("");
692	const size_t buffer_offset = buffer - variable_buffer; /* bird */
693	struct dep dp = new, dl = 0;
694
695	while (dp != 0)
696	{
697	char *percent;
698	#ifndef KMK
699	int nl = strlen (dp->name) + 1;
700	char *nm = alloca (nl);
701	memcpy (nm, dp->name, nl);
702	percent = find_percent (nm);
703	#else /* KMK - don't make a stack copy unless it's actually required! */
704	unsigned int nl = strcache2_get_len (&file_strcache, dp->name);
705	char *nm;
706	percent = memchr (dp->name, '%', nl);
707	if (percent)
708	{
709	nm = alloca (nl + 1);
710	memcpy (nm, dp->name, nl + 1);
711	percent = find_percent (nm);
712	}
713	#endif /* KMK */
714	if (percent)
715	{
716	char *o;
717
718	/* We have to handle empty stems specially, because that
719	would be equivalent to $(patsubst %,dp->name,) which
720	will always be empty. */
721	if (d->stem[0] == '\0')
722	{
723	memmove (percent, percent+1, strlen (percent));
724	o = variable_buffer_output (buffer, nm, strlen (nm) + 1);
725	}
726	else
727	o = patsubst_expand_pat (buffer, d->stem, pattern, nm,
728	pattern+1, percent+1);
729	buffer = variable_buffer + buffer_offset; /* bird fix - variable_buffer may have been reallocated. */
730
731
732	/* If the name expanded to the empty string, ignore it. */
733	if (buffer[0] == '\0')
734	{
735	struct dep *df = dp;
736	if (dp == new)
737	dp = new = new->next;
738	else
739	dp = dl->next = dp->next;
740	free_dep (df);
741	continue;
742	}
743
744	/* Save the name. */
745	dp->name = strcache_add_len (buffer, o - buffer - 1); /* bird fix - don't include the terminator. */
746	}
747	dl = dp;
748	dp = dp->next;
749	}
750	}
751
752	/* Enter them as files. */
753	for (d1 = new; d1 != 0; d1 = d1->next)
754	{
755	d1->file = lookup_file (d1->name);
756	if (d1->file == 0)
757	d1->file = enter_file (d1->name);
758	d1->name = 0;
759	d1->staticpattern = 0;
760	d1->need_2nd_expansion = 0;
761	}
762
763	#ifdef CONFIG_WITH_INCLUDEDEP
764	}
765	#endif
766
767	/* Add newly parsed deps to f->deps. If this is the last dependency
768	line and this target has commands then put it in front so the
769	last dependency line (the one with commands) ends up being the
770	first. This is important because people expect $< to hold first
771	prerequisite from the rule with commands. If it is not the last
772	dependency line or the rule does not have commands then link it
773	at the end so it appears in makefile order. */
774
775	if (new != 0)
776	{
777	if (d->next == 0 && last_dep_has_cmds)
778	{
779	struct dep **d_ptr;
780	for (d_ptr = &new; d_ptr; d_ptr = &(d_ptr)->next)
781	;
782
783	*d_ptr = f->deps;
784	f->deps = new;
785	}
786	else
787	{
788	struct dep **d_ptr;
789	for (d_ptr = &f->deps; d_ptr; d_ptr = &(d_ptr)->next)
790	;
791
792	*d_ptr = new;
793	}
794	}
795	}
796
797	free_dep_chain (old);
798	}
799
800	/* For each dependency of each file, make the `struct dep' point
801	at the appropriate `struct file' (which may have to be created).
802
803	Also mark the files depended on by .PRECIOUS, .PHONY, .SILENT,
804	and various other special targets. */
805
806	void
807	snap_deps (void)
808	{
809	struct file *f;
810	struct file *f2;
811	struct dep *d;
812	struct file **file_slot_0;
813	struct file **file_slot;
814	struct file **file_end;
815
816	/* Perform second expansion and enter each dependency name as a file. */
817
818	/* Expand .SUFFIXES first; it's dependencies are used for $$* calculation. */
819	for (f = lookup_file (".SUFFIXES"); f != 0; f = f->prev)
820	expand_deps (f);
821
822	#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
823	/* Perform 2nd target expansion on files which requires this. This will
824	be re-inserting (delete+insert) hash table entries so we have to use
825	hash_dump(). */
826	if (second_target_expansion)
827	{
828	# ifdef KMK /* turn on warnings here. */
829	int save = warn_undefined_variables_flag;
830	warn_undefined_variables_flag = 1;
831	# endif
832
833	file_slot_0 = (struct file **) hash_dump (&files, 0, 0);
834	file_end = file_slot_0 + files.ht_fill;
835	for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
836	for (f = *file_slot; f != 0; f = f->prev)
837	if (f->need_2nd_target_expansion)
838	do_2nd_target_expansion (f);
839	free (file_slot_0);
840
841	# ifdef KMK
842	warn_undefined_variables_flag = save;
843	# endif
844
845	/* Disable second target expansion now since we won't expand files
846	entered after this point. (Saves CPU cycles in enter_file()). */
847	second_target_expansion = 0;
848	}
849	#endif /* CONFIG_WITH_2ND_TARGET_EXPANSION */
850
851	#ifdef CONFIG_WITH_INCLUDEDEP
852	/* Process any queued includedep files. Since includedep is supposed
853	to be simple stuff, we can do this after the second target expansion
854	and thereby save a little time. */
855	incdep_flush_and_term ();
856	#endif
857
858	/* For every target that's not .SUFFIXES, expand its dependencies.
859	We must use hash_dump (), because within this loop we might add new files
860	to the table, possibly causing an in-situ table expansion. */
861	file_slot_0 = (struct file **) hash_dump (&files, 0, 0);
862	file_end = file_slot_0 + files.ht_fill;
863	for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
864	for (f = *file_slot; f != 0; f = f->prev)
865	#ifndef CONFIG_WITH_STRCACHE2
866	if (strcmp (f->name, ".SUFFIXES") != 0)
867	#else
868	if (f->name != suffixes_strcached)
869	#endif
870	expand_deps (f);
871	#ifdef KMK
872	/* This is a HACK to work around the still broken test #9 in
873	features/double_colon. It produces the wrong result if the build is
874	parallel because of changed evaluation order. Just make these
875	problematic rules execute in single field till a proper fix is
876	forthcomming... */
877
878	for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
879	if ( (f = *file_slot) != 0
880	&& f->double_colon
881	&& ( f->double_colon != f
882	\|\| f->last != f))
883	for (f2 = f->double_colon; f2 != 0; f2 = f2->prev)
884	f2->command_flags \|= COMMANDS_NOTPARALLEL;
885	#endif
886	free (file_slot_0);
887
888	/* Now manage all the special targets. */
889
890	for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev)
891	for (d = f->deps; d != 0; d = d->next)
892	for (f2 = d->file; f2 != 0; f2 = f2->prev)
893	f2->precious = 1;
894
895	for (f = lookup_file (".LOW_RESOLUTION_TIME"); f != 0; f = f->prev)
896	for (d = f->deps; d != 0; d = d->next)
897	for (f2 = d->file; f2 != 0; f2 = f2->prev)
898	f2->low_resolution_time = 1;
899
900	for (f = lookup_file (".PHONY"); f != 0; f = f->prev)
901	for (d = f->deps; d != 0; d = d->next)
902	for (f2 = d->file; f2 != 0; f2 = f2->prev)
903	{
904	/* Mark this file as phony nonexistent target. */
905	f2->phony = 1;
906	f2->is_target = 1;
907	f2->last_mtime = NONEXISTENT_MTIME;
908	f2->mtime_before_update = NONEXISTENT_MTIME;
909	}
910
911	for (f = lookup_file (".INTERMEDIATE"); f != 0; f = f->prev)
912	/* Mark .INTERMEDIATE deps as intermediate files. */
913	for (d = f->deps; d != 0; d = d->next)
914	for (f2 = d->file; f2 != 0; f2 = f2->prev)
915	f2->intermediate = 1;
916	/* .INTERMEDIATE with no deps does nothing.
917	Marking all files as intermediates is useless since the goal targets
918	would be deleted after they are built. */
919
920	for (f = lookup_file (".SECONDARY"); f != 0; f = f->prev)
921	/* Mark .SECONDARY deps as both intermediate and secondary. */
922	if (f->deps)
923	for (d = f->deps; d != 0; d = d->next)
924	for (f2 = d->file; f2 != 0; f2 = f2->prev)
925	f2->intermediate = f2->secondary = 1;
926	/* .SECONDARY with no deps listed marks all files that way. */
927	else
928	{
929	all_secondary = 1;
930	hash_map (&files, set_intermediate);
931	}
932
933	f = lookup_file (".EXPORT_ALL_VARIABLES");
934	if (f != 0 && f->is_target)
935	export_all_variables = 1;
936
937	f = lookup_file (".IGNORE");
938	if (f != 0 && f->is_target)
939	{
940	if (f->deps == 0)
941	ignore_errors_flag = 1;
942	else
943	for (d = f->deps; d != 0; d = d->next)
944	for (f2 = d->file; f2 != 0; f2 = f2->prev)
945	f2->command_flags \|= COMMANDS_NOERROR;
946	}
947
948	f = lookup_file (".SILENT");
949	if (f != 0 && f->is_target)
950	{
951	if (f->deps == 0)
952	silent_flag = 1;
953	else
954	for (d = f->deps; d != 0; d = d->next)
955	for (f2 = d->file; f2 != 0; f2 = f2->prev)
956	f2->command_flags \|= COMMANDS_SILENT;
957	}
958
959	f = lookup_file (".NOTPARALLEL");
960	if (f != 0 && f->is_target)
961	#ifndef CONFIG_WITH_EXTENDED_NOTPARALLEL
962	not_parallel = 1;
963	#else /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
964	{
965	if (f->deps == 0)
966	{
967	DB (DB_KMK, (_("not_parallel -1\n")));
968	not_parallel = -1;
969	}
970	else
971	for (d = f->deps; d != 0; d = d->next)
972	for (f2 = d->file; f2 != 0; f2 = f2->prev)
973	f2->command_flags \|= COMMANDS_NOTPARALLEL;
974	}
975	#endif /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
976
977	#ifndef NO_MINUS_C_MINUS_O
978	/* If .POSIX was defined, remove OUTPUT_OPTION to comply. */
979	/* This needs more work: what if the user sets this in the makefile?
980	if (posix_pedantic)
981	define_variable (STRING_SIZE_TUPLE("OUTPUT_OPTION"), "", o_default, 1);
982	*/
983	#endif
984
985	/* Remember that we've done this. */
986	snapped_deps = 1;
987	}
988
989
990	/* Set the `command_state' member of FILE and all its `also_make's. */
991
992	void
993	set_command_state (struct file *file, enum cmd_state state)
994	{
995	struct dep *d;
996
997	file->command_state = state;
998
999	for (d = file->also_make; d != 0; d = d->next)
1000	d->file->command_state = state;
1001
1002	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1003	if (file->multi_head)
1004	for (file = file->multi_head; file != 0; file = file->multi_next)
1005	file->command_state = state;
1006	#endif
1007	}
1008
1009
1010	/* Convert an external file timestamp to internal form. */
1011
1012	FILE_TIMESTAMP
1013	file_timestamp_cons (const char *fname, time_t s, int ns)
1014	{
1015	int offset = ORDINARY_MTIME_MIN + (FILE_TIMESTAMP_HI_RES ? ns : 0);
1016	FILE_TIMESTAMP product = (FILE_TIMESTAMP) s << FILE_TIMESTAMP_LO_BITS;
1017	FILE_TIMESTAMP ts = product + offset;
1018
1019	if (! (s <= FILE_TIMESTAMP_S (ORDINARY_MTIME_MAX)
1020	&& product <= ts && ts <= ORDINARY_MTIME_MAX))
1021	{
1022	char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
1023	ts = s <= OLD_MTIME ? ORDINARY_MTIME_MIN : ORDINARY_MTIME_MAX;
1024	file_timestamp_sprintf (buf, ts);
1025	error (NILF, _("%s: Timestamp out of range; substituting %s"),
1026	fname ? fname : _("Current time"), buf);
1027	}
1028
1029	return ts;
1030	}
1031
1032
1033	/* Return the current time as a file timestamp, setting *RESOLUTION to
1034	its resolution. */
1035	FILE_TIMESTAMP
1036	file_timestamp_now (int *resolution)
1037	{
1038	int r;
1039	time_t s;
1040	int ns;
1041
1042	/* Don't bother with high-resolution clocks if file timestamps have
1043	only one-second resolution. The code below should work, but it's
1044	not worth the hassle of debugging it on hosts where it fails. */
1045	#if FILE_TIMESTAMP_HI_RES
1046	# if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
1047	{
1048	struct timespec timespec;
1049	if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
1050	{
1051	r = 1;
1052	s = timespec.tv_sec;
1053	ns = timespec.tv_nsec;
1054	goto got_time;
1055	}
1056	}
1057	# endif
1058	# if HAVE_GETTIMEOFDAY
1059	{
1060	struct timeval timeval;
1061	if (gettimeofday (&timeval, 0) == 0)
1062	{
1063	r = 1000;
1064	s = timeval.tv_sec;
1065	ns = timeval.tv_usec * 1000;
1066	goto got_time;
1067	}
1068	}
1069	# endif
1070	#endif
1071
1072	r = 1000000000;
1073	s = time ((time_t *) 0);
1074	ns = 0;
1075
1076	#if FILE_TIMESTAMP_HI_RES
1077	got_time:
1078	#endif
1079	*resolution = r;
1080	return file_timestamp_cons (0, s, ns);
1081	}
1082
1083	/* Place into the buffer P a printable representation of the file
1084	timestamp TS. */
1085	void
1086	file_timestamp_sprintf (char *p, FILE_TIMESTAMP ts)
1087	{
1088	time_t t = FILE_TIMESTAMP_S (ts);
1089	struct tm *tm = localtime (&t);
1090
1091	if (tm)
1092	sprintf (p, "%04d-%02d-%02d %02d:%02d:%02d",
1093	tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1094	tm->tm_hour, tm->tm_min, tm->tm_sec);
1095	else if (t < 0)
1096	sprintf (p, "%ld", (long) t);
1097	else
1098	sprintf (p, "%lu", (unsigned long) t);
1099	p += strlen (p);
1100
1101	/* Append nanoseconds as a fraction, but remove trailing zeros. We don't
1102	know the actual timestamp resolution, since clock_getres applies only to
1103	local times, whereas this timestamp might come from a remote filesystem.
1104	So removing trailing zeros is the best guess that we can do. */
1105	sprintf (p, ".%09d", FILE_TIMESTAMP_NS (ts));
1106	p += strlen (p) - 1;
1107	while (*p == '0')
1108	p--;
1109	p += *p != '.';
1110
1111	*p = '\0';
1112	}
1113
1114
1115	/* Print the data base of files. */
1116
1117	static void
1118	print_file (const void *item)
1119	{
1120	const struct file *f = item;
1121	struct dep *d;
1122	struct dep *ood = 0;
1123
1124	putchar ('\n');
1125	if (!f->is_target)
1126	puts (_("# Not a target:"));
1127	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1128	if (f->multi_head)
1129	{
1130	const struct file *f2;
1131	if (f->multi_head == f)
1132	{
1133	int multi_maybe = -1;
1134	assert (!f->multi_maybe);
1135	assert (!f->double_colon);
1136
1137	printf ("%s", f->name);
1138	for (f2 = f->multi_next; f2 != 0; f2 = f2->multi_next)
1139	{
1140	printf (" %s%s", f2->multi_maybe != multi_maybe
1141	? f2->multi_maybe ? "+\| " : "+ " : "",
1142	f2->name);
1143	multi_maybe = f2->multi_maybe;
1144	}
1145	putchar (':');
1146	}
1147	else
1148	printf ("%s:%s", f->name, f->double_colon ? ":" : "");
1149	}
1150	else
1151	#endif
1152	printf ("%s:%s", f->name, f->double_colon ? ":" : "");
1153
1154	/* Print all normal dependencies; note any order-only deps. */
1155	for (d = f->deps; d != 0; d = d->next)
1156	if (! d->ignore_mtime)
1157	printf (" %s", dep_name (d));
1158	else if (! ood)
1159	ood = d;
1160
1161	/* Print order-only deps, if we have any. */
1162	if (ood)
1163	{
1164	printf (" \| %s", dep_name (ood));
1165	for (d = ood->next; d != 0; d = d->next)
1166	if (d->ignore_mtime)
1167	printf (" %s", dep_name (d));
1168	}
1169
1170	putchar ('\n');
1171
1172	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1173	if (f->multi_head && f->multi_head != f)
1174	{
1175	const struct file *f2;
1176	fputs (_("# In multi target list:"), stdout);
1177	for (f2 = f->multi_head; f2 != 0; f2 = f2->multi_next)
1178	printf (" %s%s", f2->name, f == f2 ? "(*)" : "");
1179	putchar ('\n');
1180	if (f->multi_maybe)
1181	puts (_("# File is an optional multi target member."));
1182	}
1183	#endif
1184
1185	if (f->precious)
1186	puts (_("# Precious file (prerequisite of .PRECIOUS)."));
1187	if (f->phony)
1188	puts (_("# Phony target (prerequisite of .PHONY)."));
1189	if (f->cmd_target)
1190	puts (_("# Command-line target."));
1191	if (f->dontcare)
1192	puts (_("# A default, MAKEFILES, or -include/sinclude makefile."));
1193	puts (f->tried_implicit
1194	? _("# Implicit rule search has been done.")
1195	: _("# Implicit rule search has not been done."));
1196	if (f->stem != 0)
1197	printf (_("# Implicit/static pattern stem: `%s'\n"), f->stem);
1198	if (f->intermediate)
1199	puts (_("# File is an intermediate prerequisite."));
1200	if (f->also_make != 0)
1201	{
1202	fputs (_("# Also makes:"), stdout);
1203	for (d = f->also_make; d != 0; d = d->next)
1204	printf (" %s", dep_name (d));
1205	putchar ('\n');
1206	}
1207	if (f->last_mtime == UNKNOWN_MTIME)
1208	puts (_("# Modification time never checked."));
1209	else if (f->last_mtime == NONEXISTENT_MTIME)
1210	puts (_("# File does not exist."));
1211	else if (f->last_mtime == OLD_MTIME)
1212	puts (_("# File is very old."));
1213	else
1214	{
1215	char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
1216	file_timestamp_sprintf (buf, f->last_mtime);
1217	printf (_("# Last modified %s\n"), buf);
1218	}
1219	puts (f->updated
1220	? _("# File has been updated.") : _("# File has not been updated."));
1221	switch (f->command_state)
1222	{
1223	case cs_running:
1224	puts (_("# Commands currently running (THIS IS A BUG)."));
1225	break;
1226	case cs_deps_running:
1227	puts (_("# Dependencies commands running (THIS IS A BUG)."));
1228	break;
1229	case cs_not_started:
1230	case cs_finished:
1231	switch (f->update_status)
1232	{
1233	case -1:
1234	break;
1235	case 0:
1236	puts (_("# Successfully updated."));
1237	break;
1238	case 1:
1239	assert (question_flag);
1240	puts (_("# Needs to be updated (-q is set)."));
1241	break;
1242	case 2:
1243	puts (_("# Failed to be updated."));
1244	break;
1245	default:
1246	puts (_("# Invalid value in `update_status' member!"));
1247	fflush (stdout);
1248	fflush (stderr);
1249	abort ();
1250	}
1251	break;
1252	default:
1253	puts (_("# Invalid value in `command_state' member!"));
1254	fflush (stdout);
1255	fflush (stderr);
1256	abort ();
1257	}
1258
1259	if (f->variables != 0)
1260	print_file_variables (f);
1261
1262	if (f->cmds != 0)
1263	print_commands (f->cmds);
1264
1265	if (f->prev)
1266	print_file ((const void *) f->prev);
1267	}
1268
1269	void
1270	print_file_data_base (void)
1271	{
1272	puts (_("\n# Files"));
1273
1274	hash_map (&files, print_file);
1275
1276	fputs (_("\n# files hash-table stats:\n# "), stdout);
1277	hash_print_stats (&files, stdout);
1278	}
1279
1280	#ifdef CONFIG_WITH_PRINT_STATS_SWITCH
1281	void
1282	print_file_stats (void)
1283	{
1284	fputs (_("\n# files hash-table stats:\n# "), stdout);
1285	hash_print_stats (&files, stdout);
1286	fputs ("\n", stdout);
1287	}
1288	#endif
1289
1290
1291	/* Verify the integrity of the data base of files. */
1292
1293	#define VERIFY_CACHED(_p,_n) \
1294	do{\
1295	if (_p->_n && _p->_n[0] && !strcache_iscached (_p->_n)) \
1296	printf ("%s: Field %s not cached: %s\n", _p->name, # _n, _p->_n); \
1297	}while(0)
1298
1299	static void
1300	verify_file (const void *item)
1301	{
1302	const struct file *f = item;
1303	const struct dep *d;
1304
1305	VERIFY_CACHED (f, name);
1306	VERIFY_CACHED (f, hname);
1307	VERIFY_CACHED (f, vpath);
1308	VERIFY_CACHED (f, stem);
1309
1310	/* Check the deps. */
1311	for (d = f->deps; d != 0; d = d->next)
1312	{
1313	VERIFY_CACHED (d, name);
1314	VERIFY_CACHED (d, stem);
1315	}
1316	}
1317
1318	void
1319	verify_file_data_base (void)
1320	{
1321	hash_map (&files, verify_file);
1322	}
1323
1324	#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
1325
1326	char *
1327	build_target_list (char *value)
1328	{
1329	static unsigned long last_targ_count = 0;
1330
1331	if (files.ht_fill != last_targ_count)
1332	{
1333	unsigned long max = EXPANSION_INCREMENT (strlen (value));
1334	unsigned long len;
1335	char *p;
1336	struct file fp = (struct file ) files.ht_vec;
1337	struct file **end = &fp[files.ht_size];
1338
1339	/* Make sure we have at least MAX bytes in the allocated buffer. */
1340	value = xrealloc (value, max);
1341
1342	p = value;
1343	len = 0;
1344	for (; fp < end; ++fp)
1345	if (!HASH_VACANT (fp) && (fp)->is_target)
1346	{
1347	struct file f = fp;
1348	int l = strlen (f->name);
1349
1350	len += l + 1;
1351	if (len > max)
1352	{
1353	unsigned long off = p - value;
1354
1355	max += EXPANSION_INCREMENT (l + 1);
1356	value = xrealloc (value, max);
1357	p = &value[off];
1358	}
1359
1360	memcpy (p, f->name, l);
1361	p += l;
1362	*(p++) = ' ';
1363	}
1364	*(p-1) = '\0';
1365
1366	last_targ_count = files.ht_fill;
1367	}
1368
1369	return value;
1370	}
1371
1372	void
1373	init_hash_files (void)
1374	{
1375	#ifndef CONFIG_WITH_STRCACHE2
1376	# ifdef KMK
1377	hash_init (&files, /65535/ 32755, file_hash_1, file_hash_2, file_hash_cmp);
1378	# else
1379	hash_init (&files, 1000, file_hash_1, file_hash_2, file_hash_cmp);
1380	# endif
1381	#else
1382	# ifdef KMK
1383	hash_init_strcached (&files, 32755, &file_strcache,
1384	offsetof (struct file, hname));
1385	# else
1386	hash_init_strcached (&files, 1000, &file_strcache,
1387	offsetof (struct file, hname));
1388	# endif
1389	#endif
1390	}
1391
1392	/* EOF */

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

source: kBuild/trunk/src/kmk/file.c@ 1950

Download in other formats: