VirtualBox

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

Last change on this file since 1945 was 1945, checked in by bird, 16 years ago

file.c: Fixed call to strcache_add_len where the terminator was included in the string length.

  • Property svn:eol-style set to native
File size: 38.2 KB
Line 
1/* Target file management for GNU Make.
2Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
31998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4Foundation, Inc.
5This file is part of GNU Make.
6
7GNU Make is free software; you can redistribute it and/or modify it under the
8terms of the GNU General Public License as published by the Free Software
9Foundation; either version 2, or (at your option) any later version.
10
11GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License along with
16GNU Make; see the file COPYING. If not, write to the Free Software
17Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
18
19#include "make.h"
20
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. */
42int snapped_deps = 0;
43
44/* Hash table of files the makefile knows how to make. */
45
46#ifndef CONFIG_WITH_STRCACHE2
47static unsigned long
48file_hash_1 (const void *key)
49{
50 return_ISTRING_HASH_1 (((struct file const *) key)->hname);
51}
52
53static unsigned long
54file_hash_2 (const void *key)
55{
56 return_ISTRING_HASH_2 (((struct file const *) key)->hname);
57}
58#endif /* !CONFIG_WITH_STRCACHE2 */
59
60static int
61file_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
75static struct hash_table files;
76
77/* Whether or not .SECONDARY with no prerequisites was given. */
78static 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
86struct file *
87lookup_file (const char *name)
88#else /* KMK */
89MY_INLINE struct file *
90lookup_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
170struct file *
171lookup_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. */
178struct file *
179lookup_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
192struct file *
193enter_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
267void
268rehash_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
405void
406rename_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. */
420static void
421do_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
438void
439remove_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
513struct dep *
514parse_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
559static void
560set_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. */
567static void
568expand_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
806void
807snap_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 free (file_slot_0);
872
873 /* Now manage all the special targets. */
874
875 for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev)
876 for (d = f->deps; d != 0; d = d->next)
877 for (f2 = d->file; f2 != 0; f2 = f2->prev)
878 f2->precious = 1;
879
880 for (f = lookup_file (".LOW_RESOLUTION_TIME"); f != 0; f = f->prev)
881 for (d = f->deps; d != 0; d = d->next)
882 for (f2 = d->file; f2 != 0; f2 = f2->prev)
883 f2->low_resolution_time = 1;
884
885 for (f = lookup_file (".PHONY"); f != 0; f = f->prev)
886 for (d = f->deps; d != 0; d = d->next)
887 for (f2 = d->file; f2 != 0; f2 = f2->prev)
888 {
889 /* Mark this file as phony nonexistent target. */
890 f2->phony = 1;
891 f2->is_target = 1;
892 f2->last_mtime = NONEXISTENT_MTIME;
893 f2->mtime_before_update = NONEXISTENT_MTIME;
894 }
895
896 for (f = lookup_file (".INTERMEDIATE"); f != 0; f = f->prev)
897 /* Mark .INTERMEDIATE deps as intermediate files. */
898 for (d = f->deps; d != 0; d = d->next)
899 for (f2 = d->file; f2 != 0; f2 = f2->prev)
900 f2->intermediate = 1;
901 /* .INTERMEDIATE with no deps does nothing.
902 Marking all files as intermediates is useless since the goal targets
903 would be deleted after they are built. */
904
905 for (f = lookup_file (".SECONDARY"); f != 0; f = f->prev)
906 /* Mark .SECONDARY deps as both intermediate and secondary. */
907 if (f->deps)
908 for (d = f->deps; d != 0; d = d->next)
909 for (f2 = d->file; f2 != 0; f2 = f2->prev)
910 f2->intermediate = f2->secondary = 1;
911 /* .SECONDARY with no deps listed marks *all* files that way. */
912 else
913 {
914 all_secondary = 1;
915 hash_map (&files, set_intermediate);
916 }
917
918 f = lookup_file (".EXPORT_ALL_VARIABLES");
919 if (f != 0 && f->is_target)
920 export_all_variables = 1;
921
922 f = lookup_file (".IGNORE");
923 if (f != 0 && f->is_target)
924 {
925 if (f->deps == 0)
926 ignore_errors_flag = 1;
927 else
928 for (d = f->deps; d != 0; d = d->next)
929 for (f2 = d->file; f2 != 0; f2 = f2->prev)
930 f2->command_flags |= COMMANDS_NOERROR;
931 }
932
933 f = lookup_file (".SILENT");
934 if (f != 0 && f->is_target)
935 {
936 if (f->deps == 0)
937 silent_flag = 1;
938 else
939 for (d = f->deps; d != 0; d = d->next)
940 for (f2 = d->file; f2 != 0; f2 = f2->prev)
941 f2->command_flags |= COMMANDS_SILENT;
942 }
943
944 f = lookup_file (".NOTPARALLEL");
945 if (f != 0 && f->is_target)
946#ifndef CONFIG_WITH_EXTENDED_NOTPARALLEL
947 not_parallel = 1;
948#else /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
949 {
950 if (f->deps == 0)
951 {
952 DB (DB_KMK, (_("not_parallel -1\n")));
953 not_parallel = -1;
954 }
955 else
956 for (d = f->deps; d != 0; d = d->next)
957 for (f2 = d->file; f2 != 0; f2 = f2->prev)
958 f2->command_flags |= COMMANDS_NOTPARALLEL;
959 }
960#endif /* CONFIG_WITH_EXTENDED_NOTPARALLEL */
961
962#ifndef NO_MINUS_C_MINUS_O
963 /* If .POSIX was defined, remove OUTPUT_OPTION to comply. */
964 /* This needs more work: what if the user sets this in the makefile?
965 if (posix_pedantic)
966 define_variable (STRING_SIZE_TUPLE("OUTPUT_OPTION"), "", o_default, 1);
967 */
968#endif
969
970 /* Remember that we've done this. */
971 snapped_deps = 1;
972}
973
974
975/* Set the `command_state' member of FILE and all its `also_make's. */
976
977void
978set_command_state (struct file *file, enum cmd_state state)
979{
980 struct dep *d;
981
982 file->command_state = state;
983
984 for (d = file->also_make; d != 0; d = d->next)
985 d->file->command_state = state;
986
987#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
988 if (file->multi_head)
989 for (file = file->multi_head; file != 0; file = file->multi_next)
990 file->command_state = state;
991#endif
992}
993
994
995/* Convert an external file timestamp to internal form. */
996
997FILE_TIMESTAMP
998file_timestamp_cons (const char *fname, time_t s, int ns)
999{
1000 int offset = ORDINARY_MTIME_MIN + (FILE_TIMESTAMP_HI_RES ? ns : 0);
1001 FILE_TIMESTAMP product = (FILE_TIMESTAMP) s << FILE_TIMESTAMP_LO_BITS;
1002 FILE_TIMESTAMP ts = product + offset;
1003
1004 if (! (s <= FILE_TIMESTAMP_S (ORDINARY_MTIME_MAX)
1005 && product <= ts && ts <= ORDINARY_MTIME_MAX))
1006 {
1007 char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
1008 ts = s <= OLD_MTIME ? ORDINARY_MTIME_MIN : ORDINARY_MTIME_MAX;
1009 file_timestamp_sprintf (buf, ts);
1010 error (NILF, _("%s: Timestamp out of range; substituting %s"),
1011 fname ? fname : _("Current time"), buf);
1012 }
1013
1014 return ts;
1015}
1016
1017
1018/* Return the current time as a file timestamp, setting *RESOLUTION to
1019 its resolution. */
1020FILE_TIMESTAMP
1021file_timestamp_now (int *resolution)
1022{
1023 int r;
1024 time_t s;
1025 int ns;
1026
1027 /* Don't bother with high-resolution clocks if file timestamps have
1028 only one-second resolution. The code below should work, but it's
1029 not worth the hassle of debugging it on hosts where it fails. */
1030#if FILE_TIMESTAMP_HI_RES
1031# if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
1032 {
1033 struct timespec timespec;
1034 if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
1035 {
1036 r = 1;
1037 s = timespec.tv_sec;
1038 ns = timespec.tv_nsec;
1039 goto got_time;
1040 }
1041 }
1042# endif
1043# if HAVE_GETTIMEOFDAY
1044 {
1045 struct timeval timeval;
1046 if (gettimeofday (&timeval, 0) == 0)
1047 {
1048 r = 1000;
1049 s = timeval.tv_sec;
1050 ns = timeval.tv_usec * 1000;
1051 goto got_time;
1052 }
1053 }
1054# endif
1055#endif
1056
1057 r = 1000000000;
1058 s = time ((time_t *) 0);
1059 ns = 0;
1060
1061#if FILE_TIMESTAMP_HI_RES
1062 got_time:
1063#endif
1064 *resolution = r;
1065 return file_timestamp_cons (0, s, ns);
1066}
1067
1068/* Place into the buffer P a printable representation of the file
1069 timestamp TS. */
1070void
1071file_timestamp_sprintf (char *p, FILE_TIMESTAMP ts)
1072{
1073 time_t t = FILE_TIMESTAMP_S (ts);
1074 struct tm *tm = localtime (&t);
1075
1076 if (tm)
1077 sprintf (p, "%04d-%02d-%02d %02d:%02d:%02d",
1078 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1079 tm->tm_hour, tm->tm_min, tm->tm_sec);
1080 else if (t < 0)
1081 sprintf (p, "%ld", (long) t);
1082 else
1083 sprintf (p, "%lu", (unsigned long) t);
1084 p += strlen (p);
1085
1086 /* Append nanoseconds as a fraction, but remove trailing zeros. We don't
1087 know the actual timestamp resolution, since clock_getres applies only to
1088 local times, whereas this timestamp might come from a remote filesystem.
1089 So removing trailing zeros is the best guess that we can do. */
1090 sprintf (p, ".%09d", FILE_TIMESTAMP_NS (ts));
1091 p += strlen (p) - 1;
1092 while (*p == '0')
1093 p--;
1094 p += *p != '.';
1095
1096 *p = '\0';
1097}
1098
1099
1100/* Print the data base of files. */
1101
1102static void
1103print_file (const void *item)
1104{
1105 const struct file *f = item;
1106 struct dep *d;
1107 struct dep *ood = 0;
1108
1109 putchar ('\n');
1110 if (!f->is_target)
1111 puts (_("# Not a target:"));
1112#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1113 if (f->multi_head)
1114 {
1115 const struct file *f2;
1116 if (f->multi_head == f)
1117 {
1118 int multi_maybe = -1;
1119 assert (!f->multi_maybe);
1120 assert (!f->double_colon);
1121
1122 printf ("%s", f->name);
1123 for (f2 = f->multi_next; f2 != 0; f2 = f2->multi_next)
1124 {
1125 printf (" %s%s", f2->multi_maybe != multi_maybe
1126 ? f2->multi_maybe ? "+| " : "+ " : "",
1127 f2->name);
1128 multi_maybe = f2->multi_maybe;
1129 }
1130 putchar (':');
1131 }
1132 else
1133 printf ("%s:%s", f->name, f->double_colon ? ":" : "");
1134 }
1135 else
1136#endif
1137 printf ("%s:%s", f->name, f->double_colon ? ":" : "");
1138
1139 /* Print all normal dependencies; note any order-only deps. */
1140 for (d = f->deps; d != 0; d = d->next)
1141 if (! d->ignore_mtime)
1142 printf (" %s", dep_name (d));
1143 else if (! ood)
1144 ood = d;
1145
1146 /* Print order-only deps, if we have any. */
1147 if (ood)
1148 {
1149 printf (" | %s", dep_name (ood));
1150 for (d = ood->next; d != 0; d = d->next)
1151 if (d->ignore_mtime)
1152 printf (" %s", dep_name (d));
1153 }
1154
1155 putchar ('\n');
1156
1157#ifdef CONFIG_WITH_EXPLICIT_MULTITARGET
1158 if (f->multi_head && f->multi_head != f)
1159 {
1160 const struct file *f2;
1161 fputs (_("# In multi target list:"), stdout);
1162 for (f2 = f->multi_head; f2 != 0; f2 = f2->multi_next)
1163 printf (" %s%s", f2->name, f == f2 ? "(*)" : "");
1164 putchar ('\n');
1165 if (f->multi_maybe)
1166 puts (_("# File is an optional multi target member."));
1167 }
1168#endif
1169
1170 if (f->precious)
1171 puts (_("# Precious file (prerequisite of .PRECIOUS)."));
1172 if (f->phony)
1173 puts (_("# Phony target (prerequisite of .PHONY)."));
1174 if (f->cmd_target)
1175 puts (_("# Command-line target."));
1176 if (f->dontcare)
1177 puts (_("# A default, MAKEFILES, or -include/sinclude makefile."));
1178 puts (f->tried_implicit
1179 ? _("# Implicit rule search has been done.")
1180 : _("# Implicit rule search has not been done."));
1181 if (f->stem != 0)
1182 printf (_("# Implicit/static pattern stem: `%s'\n"), f->stem);
1183 if (f->intermediate)
1184 puts (_("# File is an intermediate prerequisite."));
1185 if (f->also_make != 0)
1186 {
1187 fputs (_("# Also makes:"), stdout);
1188 for (d = f->also_make; d != 0; d = d->next)
1189 printf (" %s", dep_name (d));
1190 putchar ('\n');
1191 }
1192 if (f->last_mtime == UNKNOWN_MTIME)
1193 puts (_("# Modification time never checked."));
1194 else if (f->last_mtime == NONEXISTENT_MTIME)
1195 puts (_("# File does not exist."));
1196 else if (f->last_mtime == OLD_MTIME)
1197 puts (_("# File is very old."));
1198 else
1199 {
1200 char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
1201 file_timestamp_sprintf (buf, f->last_mtime);
1202 printf (_("# Last modified %s\n"), buf);
1203 }
1204 puts (f->updated
1205 ? _("# File has been updated.") : _("# File has not been updated."));
1206 switch (f->command_state)
1207 {
1208 case cs_running:
1209 puts (_("# Commands currently running (THIS IS A BUG)."));
1210 break;
1211 case cs_deps_running:
1212 puts (_("# Dependencies commands running (THIS IS A BUG)."));
1213 break;
1214 case cs_not_started:
1215 case cs_finished:
1216 switch (f->update_status)
1217 {
1218 case -1:
1219 break;
1220 case 0:
1221 puts (_("# Successfully updated."));
1222 break;
1223 case 1:
1224 assert (question_flag);
1225 puts (_("# Needs to be updated (-q is set)."));
1226 break;
1227 case 2:
1228 puts (_("# Failed to be updated."));
1229 break;
1230 default:
1231 puts (_("# Invalid value in `update_status' member!"));
1232 fflush (stdout);
1233 fflush (stderr);
1234 abort ();
1235 }
1236 break;
1237 default:
1238 puts (_("# Invalid value in `command_state' member!"));
1239 fflush (stdout);
1240 fflush (stderr);
1241 abort ();
1242 }
1243
1244 if (f->variables != 0)
1245 print_file_variables (f);
1246
1247 if (f->cmds != 0)
1248 print_commands (f->cmds);
1249
1250 if (f->prev)
1251 print_file ((const void *) f->prev);
1252}
1253
1254void
1255print_file_data_base (void)
1256{
1257 puts (_("\n# Files"));
1258
1259 hash_map (&files, print_file);
1260
1261 fputs (_("\n# files hash-table stats:\n# "), stdout);
1262 hash_print_stats (&files, stdout);
1263}
1264
1265#ifdef CONFIG_WITH_PRINT_STATS_SWITCH
1266void
1267print_file_stats (void)
1268{
1269 fputs (_("\n# files hash-table stats:\n# "), stdout);
1270 hash_print_stats (&files, stdout);
1271 fputs ("\n", stdout);
1272}
1273#endif
1274
1275
1276/* Verify the integrity of the data base of files. */
1277
1278#define VERIFY_CACHED(_p,_n) \
1279 do{\
1280 if (_p->_n && _p->_n[0] && !strcache_iscached (_p->_n)) \
1281 printf ("%s: Field %s not cached: %s\n", _p->name, # _n, _p->_n); \
1282 }while(0)
1283
1284static void
1285verify_file (const void *item)
1286{
1287 const struct file *f = item;
1288 const struct dep *d;
1289
1290 VERIFY_CACHED (f, name);
1291 VERIFY_CACHED (f, hname);
1292 VERIFY_CACHED (f, vpath);
1293 VERIFY_CACHED (f, stem);
1294
1295 /* Check the deps. */
1296 for (d = f->deps; d != 0; d = d->next)
1297 {
1298 VERIFY_CACHED (d, name);
1299 VERIFY_CACHED (d, stem);
1300 }
1301}
1302
1303void
1304verify_file_data_base (void)
1305{
1306 hash_map (&files, verify_file);
1307}
1308
1309#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500)
1310
1311char *
1312build_target_list (char *value)
1313{
1314 static unsigned long last_targ_count = 0;
1315
1316 if (files.ht_fill != last_targ_count)
1317 {
1318 unsigned long max = EXPANSION_INCREMENT (strlen (value));
1319 unsigned long len;
1320 char *p;
1321 struct file **fp = (struct file **) files.ht_vec;
1322 struct file **end = &fp[files.ht_size];
1323
1324 /* Make sure we have at least MAX bytes in the allocated buffer. */
1325 value = xrealloc (value, max);
1326
1327 p = value;
1328 len = 0;
1329 for (; fp < end; ++fp)
1330 if (!HASH_VACANT (*fp) && (*fp)->is_target)
1331 {
1332 struct file *f = *fp;
1333 int l = strlen (f->name);
1334
1335 len += l + 1;
1336 if (len > max)
1337 {
1338 unsigned long off = p - value;
1339
1340 max += EXPANSION_INCREMENT (l + 1);
1341 value = xrealloc (value, max);
1342 p = &value[off];
1343 }
1344
1345 memcpy (p, f->name, l);
1346 p += l;
1347 *(p++) = ' ';
1348 }
1349 *(p-1) = '\0';
1350
1351 last_targ_count = files.ht_fill;
1352 }
1353
1354 return value;
1355}
1356
1357void
1358init_hash_files (void)
1359{
1360#ifndef CONFIG_WITH_STRCACHE2
1361# ifdef KMK
1362 hash_init (&files, /*65535*/ 32755, file_hash_1, file_hash_2, file_hash_cmp);
1363# else
1364 hash_init (&files, 1000, file_hash_1, file_hash_2, file_hash_cmp);
1365# endif
1366#else
1367# ifdef KMK
1368 hash_init_strcached (&files, 32755, &file_strcache,
1369 offsetof (struct file, hname));
1370# else
1371 hash_init_strcached (&files, 1000, &file_strcache,
1372 offsetof (struct file, hname));
1373# endif
1374#endif
1375}
1376
1377/* EOF */
Note: See TracBrowser for help on using the repository browser.

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