file.c@ 1960

Last change on this file since 1960 was 1959, checked in by bird, 16 years ago
file.c: Fixed pattern rule regression from earlier today.
Property svn:eol-style set to `native`
File size: 39.1 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	{
728	o = patsubst_expand_pat (buffer, d->stem, pattern, nm,
729	pattern+1, percent+1);
730	o = variable_buffer_output (o, "", 1); /* bird fix - patsubst_expand_pat doesn't terminate,
731	the if case does and strcache would appreciate it. */
732	}
733	buffer = variable_buffer + buffer_offset; /* bird fix - variable_buffer may have been reallocated. */
734
735
736	/* If the name expanded to the empty string, ignore it. */
737	if (buffer[0] == '\0')
738	{
739	struct dep *df = dp;
740	if (dp == new)
741	dp = new = new->next;
742	else
743	dp = dl->next = dp->next;
744	free_dep (df);
745	continue;
746	}
747
748	/* Save the name. */
749	dp->name = strcache_add_len (buffer, o - buffer - 1); /* bird fix - don't include the terminator. */
750	}
751	dl = dp;
752	dp = dp->next;
753	}
754	}
755
756	/* Enter them as files. */
757	for (d1 = new; d1 != 0; d1 = d1->next)
758	{
759	d1->file = lookup_file (d1->name);
760	if (d1->file == 0)
761	d1->file = enter_file (d1->name);
762	d1->name = 0;
763	d1->staticpattern = 0;
764	d1->need_2nd_expansion = 0;
765	}
766
767	#ifdef CONFIG_WITH_INCLUDEDEP
768	}
769	#endif
770
771	/* Add newly parsed deps to f->deps. If this is the last dependency
772	line and this target has commands then put it in front so the
773	last dependency line (the one with commands) ends up being the
774	first. This is important because people expect $< to hold first
775	prerequisite from the rule with commands. If it is not the last
776	dependency line or the rule does not have commands then link it
777	at the end so it appears in makefile order. */
778
779	if (new != 0)
780	{
781	if (d->next == 0 && last_dep_has_cmds)
782	{
783	struct dep **d_ptr;
784	for (d_ptr = &new; d_ptr; d_ptr = &(d_ptr)->next)
785	;
786
787	*d_ptr = f->deps;
788	f->deps = new;
789	}
790	else
791	{
792	struct dep **d_ptr;
793	for (d_ptr = &f->deps; d_ptr; d_ptr = &(d_ptr)->next)
794	;
795
796	*d_ptr = new;
797	}
798	}
799	}
800
801	free_dep_chain (old);
802	}
803
804	/* For each dependency of each file, make the `struct dep' point
805	at the appropriate `struct file' (which may have to be created).
806
807	Also mark the files depended on by .PRECIOUS, .PHONY, .SILENT,
808	and various other special targets. */
809
810	void
811	snap_deps (void)
812	{
813	struct file *f;
814	struct file *f2;
815	struct dep *d;
816	struct file **file_slot_0;
817	struct file **file_slot;
818	struct file **file_end;
819
820	/* Perform second expansion and enter each dependency name as a file. */
821
822	/* Expand .SUFFIXES first; it's dependencies are used for $$* calculation. */
823	for (f = lookup_file (".SUFFIXES"); f != 0; f = f->prev)
824	expand_deps (f);
825
826	#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
827	/* Perform 2nd target expansion on files which requires this. This will
828	be re-inserting (delete+insert) hash table entries so we have to use
829	hash_dump(). */
830	if (second_target_expansion)
831	{
832	# ifdef KMK /* turn on warnings here. */
833	int save = warn_undefined_variables_flag;
834	warn_undefined_variables_flag = 1;
835	# endif
836
837	file_slot_0 = (struct file **) hash_dump (&files, 0, 0);
838	file_end = file_slot_0 + files.ht_fill;
839	for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
840	for (f = *file_slot; f != 0; f = f->prev)
841	if (f->need_2nd_target_expansion)
842	do_2nd_target_expansion (f);
843	free (file_slot_0);
844
845	# ifdef KMK
846	warn_undefined_variables_flag = save;
847	# endif
848
849	/* Disable second target expansion now since we won't expand files
850	entered after this point. (Saves CPU cycles in enter_file()). */
851	second_target_expansion = 0;
852	}
853	#endif /* CONFIG_WITH_2ND_TARGET_EXPANSION */
854
855	#ifdef CONFIG_WITH_INCLUDEDEP
856	/* Process any queued includedep files. Since includedep is supposed
857	to be simple stuff, we can do this after the second target expansion
858	and thereby save a little time. */
859	incdep_flush_and_term ();
860	#endif
861
862	/* For every target that's not .SUFFIXES, expand its dependencies.
863	We must use hash_dump (), because within this loop we might add new files
864	to the table, possibly causing an in-situ table expansion. */
865	file_slot_0 = (struct file **) hash_dump (&files, 0, 0);
866	file_end = file_slot_0 + files.ht_fill;
867	for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
868	for (f = *file_slot; f != 0; f = f->prev)
869	#ifndef CONFIG_WITH_STRCACHE2
870	if (strcmp (f->name, ".SUFFIXES") != 0)
871	#else
872	if (f->name != suffixes_strcached)
873	#endif
874	expand_deps (f);
875	#ifdef KMK
876	/* This is a HACK to work around the still broken test #9 in
877	features/double_colon. It produces the wrong result if the build is
878	parallel because of changed evaluation order. Just make these
879	problematic rules execute in single field till a proper fix is
880	forthcomming... */
881
882	for (file_slot = file_slot_0; file_slot < file_end; file_slot++)
883	if ( (f = *file_slot) != 0
884	&& f->double_colon
885	&& ( f->double_colon != f
886	\|\| f->last != f))
887	for (f2 = f->double_colon; f2 != 0; f2 = f2->prev)
888	f2->command_flags \|= COMMANDS_NOTPARALLEL;
889	#endif
890	free (file_slot_0);
891
892	/* Now manage all the special targets. */
893
894	for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev)
895	for (d = f->deps; d != 0; d = d->next)
896	for (f2 = d->file; f2 != 0; f2 = f2->prev)
897	f2->precious = 1;
898
899	for (f = lookup_file (".LOW_RESOLUTION_TIME"); f != 0; f = f->prev)
900	for (d = f->deps; d != 0; d = d->next)
901	for (f2 = d->file; f2 != 0; f2 = f2->prev)
902	f2->low_resolution_time = 1;
903
904	for (f = lookup_file (".PHONY"); f != 0; f = f->prev)
905	for (d = f->deps; d != 0; d = d->next)
906	for (f2 = d->file; f2 != 0; f2 = f2->prev)
907	{
908	/* Mark this file as phony nonexistent target. */
909	f2->phony = 1;
910	f2->is_target = 1;
911	f2->last_mtime = NONEXISTENT_MTIME;
912	f2->mtime_before_update = NONEXISTENT_MTIME;
913	}
914
915	for (f = lookup_file (".INTERMEDIATE"); f != 0; f = f->prev)
916	/* Mark .INTERMEDIATE deps as intermediate files. */
917	for (d = f->deps; d != 0; d = d->next)
918	for (f2 = d->file; f2 != 0; f2 = f2->prev)
919	f2->intermediate = 1;
920	/* .INTERMEDIATE with no deps does nothing.
921	Marking all files as intermediates is useless since the goal targets
922	would be deleted after they are built. */
923
924	for (f = lookup_file (".SECONDARY"); f != 0; f = f->prev)
925	/* Mark .SECONDARY deps as both intermediate and secondary. */
926	if (f->deps)
927	for (d = f->deps; d != 0; d = d->next)
928	for (f2 = d->file; f2 != 0; f2 = f2->prev)
929	f2->intermediate = f2->secondary = 1;
930	/* .SECONDARY with no deps listed marks all files that way. */
931	else
932	{
933	all_secondary = 1;
934	hash_map (&files, set_intermediate);
935	}
936
937	f = lookup_file (".EXPORT_ALL_VARIABLES");
938	if (f != 0 && f->is_target)
939	export_all_variables = 1;
940
941	f = lookup_file (".IGNORE");
942	if (f != 0 && f->is_target)
943	{
944	if (f->deps == 0)
945	ignore_errors_flag = 1;
946	else
947	for (d = f->deps; d != 0; d = d->next)
948	for (f2 = d->file; f2 != 0; f2 = f2->prev)
949	f2->command_flags \|= COMMANDS_NOERROR;
950	}
951
952	f = lookup_file (".SILENT");
953	if (f != 0 && f->is_target)
954	{
955	if (f->deps == 0)
956	silent_flag = 1;
957	else
958	for (d = f->deps; d != 0; d = d->next)
959	for (f2 = d->file; f2 != 0; f2 = f2->prev)
960	f2->command_flags \|= COMMANDS_SILENT;
961	}
962
963	f = lookup_file (".NOTPARALLEL");
964	if (f != 0 && f->is_target)
965	#ifndef CONFIG_WITH_EXTENDED_NOTPARALLEL
966	not_parallel = 1;
967	#else /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
968	{
969	if (f->deps == 0)
970	{
971	DB (DB_KMK, (_("not_parallel -1\n")));
972	not_parallel = -1;
973	}
974	else
975	for (d = f->deps; d != 0; d = d->next)
976	for (f2 = d->file; f2 != 0; f2 = f2->prev)
977	f2->command_flags \|= COMMANDS_NOTPARALLEL;
978	}
979	#endif /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
980
981	#ifndef NO_MINUS_C_MINUS_O
982	/* If .POSIX was defined, remove OUTPUT_OPTION to comply. */
983	/* This needs more work: what if the user sets this in the makefile?
984	if (posix_pedantic)
985	define_variable (STRING_SIZE_TUPLE("OUTPUT_OPTION"), "", o_default, 1);
986	*/
987	#endif
988
989	/* Remember that we've done this. */
990	snapped_deps = 1;
991	}
992
993
994	/* Set the `command_state' member of FILE and all its `also_make's. */
995
996	void
997	set_command_state (struct file *file, enum cmd_state state)
998	{
999	struct dep *d;
1000
1001	file->command_state = state;
1002
1003	for (d = file->also_make; d != 0; d = d->next)
1004	d->file->command_state = state;
1005
1006	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1007	if (file->multi_head)
1008	for (file = file->multi_head; file != 0; file = file->multi_next)
1009	file->command_state = state;
1010	#endif
1011	}
1012
1013
1014	/* Convert an external file timestamp to internal form. */
1015
1016	FILE_TIMESTAMP
1017	file_timestamp_cons (const char *fname, time_t s, int ns)
1018	{
1019	int offset = ORDINARY_MTIME_MIN + (FILE_TIMESTAMP_HI_RES ? ns : 0);
1020	FILE_TIMESTAMP product = (FILE_TIMESTAMP) s << FILE_TIMESTAMP_LO_BITS;
1021	FILE_TIMESTAMP ts = product + offset;
1022
1023	if (! (s <= FILE_TIMESTAMP_S (ORDINARY_MTIME_MAX)
1024	&& product <= ts && ts <= ORDINARY_MTIME_MAX))
1025	{
1026	char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
1027	ts = s <= OLD_MTIME ? ORDINARY_MTIME_MIN : ORDINARY_MTIME_MAX;
1028	file_timestamp_sprintf (buf, ts);
1029	error (NILF, _("%s: Timestamp out of range; substituting %s"),
1030	fname ? fname : _("Current time"), buf);
1031	}
1032
1033	return ts;
1034	}
1035
1036
1037	/* Return the current time as a file timestamp, setting *RESOLUTION to
1038	its resolution. */
1039	FILE_TIMESTAMP
1040	file_timestamp_now (int *resolution)
1041	{
1042	int r;
1043	time_t s;
1044	int ns;
1045
1046	/* Don't bother with high-resolution clocks if file timestamps have
1047	only one-second resolution. The code below should work, but it's
1048	not worth the hassle of debugging it on hosts where it fails. */
1049	#if FILE_TIMESTAMP_HI_RES
1050	# if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
1051	{
1052	struct timespec timespec;
1053	if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
1054	{
1055	r = 1;
1056	s = timespec.tv_sec;
1057	ns = timespec.tv_nsec;
1058	goto got_time;
1059	}
1060	}
1061	# endif
1062	# if HAVE_GETTIMEOFDAY
1063	{
1064	struct timeval timeval;
1065	if (gettimeofday (&timeval, 0) == 0)
1066	{
1067	r = 1000;
1068	s = timeval.tv_sec;
1069	ns = timeval.tv_usec * 1000;
1070	goto got_time;
1071	}
1072	}
1073	# endif
1074	#endif
1075
1076	r = 1000000000;
1077	s = time ((time_t *) 0);
1078	ns = 0;
1079
1080	#if FILE_TIMESTAMP_HI_RES
1081	got_time:
1082	#endif
1083	*resolution = r;
1084	return file_timestamp_cons (0, s, ns);
1085	}
1086
1087	/* Place into the buffer P a printable representation of the file
1088	timestamp TS. */
1089	void
1090	file_timestamp_sprintf (char *p, FILE_TIMESTAMP ts)
1091	{
1092	time_t t = FILE_TIMESTAMP_S (ts);
1093	struct tm *tm = localtime (&t);
1094
1095	if (tm)
1096	sprintf (p, "%04d-%02d-%02d %02d:%02d:%02d",
1097	tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1098	tm->tm_hour, tm->tm_min, tm->tm_sec);
1099	else if (t < 0)
1100	sprintf (p, "%ld", (long) t);
1101	else
1102	sprintf (p, "%lu", (unsigned long) t);
1103	p += strlen (p);
1104
1105	/* Append nanoseconds as a fraction, but remove trailing zeros. We don't
1106	know the actual timestamp resolution, since clock_getres applies only to
1107	local times, whereas this timestamp might come from a remote filesystem.
1108	So removing trailing zeros is the best guess that we can do. */
1109	sprintf (p, ".%09d", FILE_TIMESTAMP_NS (ts));
1110	p += strlen (p) - 1;
1111	while (*p == '0')
1112	p--;
1113	p += *p != '.';
1114
1115	*p = '\0';
1116	}
1117
1118
1119	/* Print the data base of files. */
1120
1121	static void
1122	print_file (const void *item)
1123	{
1124	const struct file *f = item;
1125	struct dep *d;
1126	struct dep *ood = 0;
1127
1128	putchar ('\n');
1129	if (!f->is_target)
1130	puts (_("# Not a target:"));
1131	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1132	if (f->multi_head)
1133	{
1134	const struct file *f2;
1135	if (f->multi_head == f)
1136	{
1137	int multi_maybe = -1;
1138	assert (!f->multi_maybe);
1139	assert (!f->double_colon);
1140
1141	printf ("%s", f->name);
1142	for (f2 = f->multi_next; f2 != 0; f2 = f2->multi_next)
1143	{
1144	printf (" %s%s", f2->multi_maybe != multi_maybe
1145	? f2->multi_maybe ? "+\| " : "+ " : "",
1146	f2->name);
1147	multi_maybe = f2->multi_maybe;
1148	}
1149	putchar (':');
1150	}
1151	else
1152	printf ("%s:%s", f->name, f->double_colon ? ":" : "");
1153	}
1154	else
1155	#endif
1156	printf ("%s:%s", f->name, f->double_colon ? ":" : "");
1157
1158	/* Print all normal dependencies; note any order-only deps. */
1159	for (d = f->deps; d != 0; d = d->next)
1160	if (! d->ignore_mtime)
1161	printf (" %s", dep_name (d));
1162	else if (! ood)
1163	ood = d;
1164
1165	/* Print order-only deps, if we have any. */
1166	if (ood)
1167	{
1168	printf (" \| %s", dep_name (ood));
1169	for (d = ood->next; d != 0; d = d->next)
1170	if (d->ignore_mtime)
1171	printf (" %s", dep_name (d));
1172	}
1173
1174	putchar ('\n');
1175
1176	#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1177	if (f->multi_head && f->multi_head != f)
1178	{
1179	const struct file *f2;
1180	fputs (_("# In multi target list:"), stdout);
1181	for (f2 = f->multi_head; f2 != 0; f2 = f2->multi_next)
1182	printf (" %s%s", f2->name, f == f2 ? "(*)" : "");
1183	putchar ('\n');
1184	if (f->multi_maybe)
1185	puts (_("# File is an optional multi target member."));
1186	}
1187	#endif
1188
1189	if (f->precious)
1190	puts (_("# Precious file (prerequisite of .PRECIOUS)."));
1191	if (f->phony)
1192	puts (_("# Phony target (prerequisite of .PHONY)."));
1193	if (f->cmd_target)
1194	puts (_("# Command-line target."));
1195	if (f->dontcare)
1196	puts (_("# A default, MAKEFILES, or -include/sinclude makefile."));
1197	puts (f->tried_implicit
1198	? _("# Implicit rule search has been done.")
1199	: _("# Implicit rule search has not been done."));
1200	if (f->stem != 0)
1201	printf (_("# Implicit/static pattern stem: `%s'\n"), f->stem);
1202	if (f->intermediate)
1203	puts (_("# File is an intermediate prerequisite."));
1204	if (f->also_make != 0)
1205	{
1206	fputs (_("# Also makes:"), stdout);
1207	for (d = f->also_make; d != 0; d = d->next)
1208	printf (" %s", dep_name (d));
1209	putchar ('\n');
1210	}
1211	if (f->last_mtime == UNKNOWN_MTIME)
1212	puts (_("# Modification time never checked."));
1213	else if (f->last_mtime == NONEXISTENT_MTIME)
1214	puts (_("# File does not exist."));
1215	else if (f->last_mtime == OLD_MTIME)
1216	puts (_("# File is very old."));
1217	else
1218	{
1219	char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
1220	file_timestamp_sprintf (buf, f->last_mtime);
1221	printf (_("# Last modified %s\n"), buf);
1222	}
1223	puts (f->updated
1224	? _("# File has been updated.") : _("# File has not been updated."));
1225	switch (f->command_state)
1226	{
1227	case cs_running:
1228	puts (_("# Commands currently running (THIS IS A BUG)."));
1229	break;
1230	case cs_deps_running:
1231	puts (_("# Dependencies commands running (THIS IS A BUG)."));
1232	break;
1233	case cs_not_started:
1234	case cs_finished:
1235	switch (f->update_status)
1236	{
1237	case -1:
1238	break;
1239	case 0:
1240	puts (_("# Successfully updated."));
1241	break;
1242	case 1:
1243	assert (question_flag);
1244	puts (_("# Needs to be updated (-q is set)."));
1245	break;
1246	case 2:
1247	puts (_("# Failed to be updated."));
1248	break;
1249	default:
1250	puts (_("# Invalid value in `update_status' member!"));
1251	fflush (stdout);
1252	fflush (stderr);
1253	abort ();
1254	}
1255	break;
1256	default:
1257	puts (_("# Invalid value in `command_state' member!"));
1258	fflush (stdout);
1259	fflush (stderr);
1260	abort ();
1261	}
1262
1263	if (f->variables != 0)
1264	print_file_variables (f);
1265
1266	if (f->cmds != 0)
1267	print_commands (f->cmds);
1268
1269	if (f->prev)
1270	print_file ((const void *) f->prev);
1271	}
1272
1273	void
1274	print_file_data_base (void)
1275	{
1276	puts (_("\n# Files"));
1277
1278	hash_map (&files, print_file);
1279
1280	fputs (_("\n# files hash-table stats:\n# "), stdout);
1281	hash_print_stats (&files, stdout);
1282	}
1283
1284	#ifdef CONFIG_WITH_PRINT_STATS_SWITCH
1285	void
1286	print_file_stats (void)
1287	{
1288	fputs (_("\n# files hash-table stats:\n# "), stdout);
1289	hash_print_stats (&files, stdout);
1290	fputs ("\n", stdout);
1291	}
1292	#endif
1293
1294
1295	/* Verify the integrity of the data base of files. */
1296
1297	#define VERIFY_CACHED(_p,_n) \
1298	do{\
1299	if (_p->_n && _p->_n[0] && !strcache_iscached (_p->_n)) \
1300	printf ("%s: Field %s not cached: %s\n", _p->name, # _n, _p->_n); \
1301	}while(0)
1302
1303	static void
1304	verify_file (const void *item)
1305	{
1306	const struct file *f = item;
1307	const struct dep *d;
1308
1309	VERIFY_CACHED (f, name);
1310	VERIFY_CACHED (f, hname);
1311	VERIFY_CACHED (f, vpath);
1312	VERIFY_CACHED (f, stem);
1313
1314	/* Check the deps. */
1315	for (d = f->deps; d != 0; d = d->next)
1316	{
1317	VERIFY_CACHED (d, name);
1318	VERIFY_CACHED (d, stem);
1319	}
1320	}
1321
1322	void
1323	verify_file_data_base (void)
1324	{
1325	hash_map (&files, verify_file);
1326	}
1327
1328	#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
1329
1330	char *
1331	build_target_list (char *value)
1332	{
1333	static unsigned long last_targ_count = 0;
1334
1335	if (files.ht_fill != last_targ_count)
1336	{
1337	unsigned long max = EXPANSION_INCREMENT (strlen (value));
1338	unsigned long len;
1339	char *p;
1340	struct file fp = (struct file ) files.ht_vec;
1341	struct file **end = &fp[files.ht_size];
1342
1343	/* Make sure we have at least MAX bytes in the allocated buffer. */
1344	value = xrealloc (value, max);
1345
1346	p = value;
1347	len = 0;
1348	for (; fp < end; ++fp)
1349	if (!HASH_VACANT (fp) && (fp)->is_target)
1350	{
1351	struct file f = fp;
1352	int l = strlen (f->name);
1353
1354	len += l + 1;
1355	if (len > max)
1356	{
1357	unsigned long off = p - value;
1358
1359	max += EXPANSION_INCREMENT (l + 1);
1360	value = xrealloc (value, max);
1361	p = &value[off];
1362	}
1363
1364	memcpy (p, f->name, l);
1365	p += l;
1366	*(p++) = ' ';
1367	}
1368	*(p-1) = '\0';
1369
1370	last_targ_count = files.ht_fill;
1371	}
1372
1373	return value;
1374	}
1375
1376	void
1377	init_hash_files (void)
1378	{
1379	#ifndef CONFIG_WITH_STRCACHE2
1380	# ifdef KMK
1381	hash_init (&files, /65535/ 32755, file_hash_1, file_hash_2, file_hash_cmp);
1382	# else
1383	hash_init (&files, 1000, file_hash_1, file_hash_2, file_hash_cmp);
1384	# endif
1385	#else
1386	# ifdef KMK
1387	hash_init_strcached (&files, 32755, &file_strcache,
1388	offsetof (struct file, hname));
1389	# else
1390	hash_init_strcached (&files, 1000, &file_strcache,
1391	offsetof (struct file, hname));
1392	# endif
1393	#endif
1394	}
1395
1396	/* EOF */

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

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

Download in other formats: