Ensure variables defined in $(call ...) have global scope
[make.git] / remake.c
blob669eadc8924dd5d07b840c795eb4e2d8c89b5283
1 /* Basic dependency engine for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
10 version.
12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along with
17 this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "make.h"
20 #include "filedef.h"
21 #include "job.h"
22 #include "commands.h"
23 #include "dep.h"
24 #include "variable.h"
25 #include "debug.h"
27 #include <assert.h>
29 #ifdef HAVE_FCNTL_H
30 #include <fcntl.h>
31 #else
32 #include <sys/file.h>
33 #endif
35 #ifdef VMS
36 #include <starlet.h>
37 #endif
38 #ifdef WINDOWS32
39 #include <io.h>
40 #endif
42 extern int try_implicit_rule (struct file *file, unsigned int depth);
45 /* The test for circular dependencies is based on the 'updating' bit in
46 `struct file'. However, double colon targets have seperate `struct
47 file's; make sure we always use the base of the double colon chain. */
49 #define start_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
50 ->updating = 1)
51 #define finish_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
52 ->updating = 0)
53 #define is_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
54 ->updating)
57 /* Incremented when a command is started (under -n, when one would be). */
58 unsigned int commands_started = 0;
60 /* Current value for pruning the scan of the goal chain (toggle 0/1). */
61 static unsigned int considered;
63 static int update_file (struct file *file, unsigned int depth);
64 static int update_file_1 (struct file *file, unsigned int depth);
65 static int check_dep (struct file *file, unsigned int depth,
66 FILE_TIMESTAMP this_mtime, int *must_make_ptr);
67 static int touch_file (struct file *file);
68 static void remake_file (struct file *file);
69 static FILE_TIMESTAMP name_mtime (const char *name);
70 static const char *library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr);
73 /* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing
74 was done, 0 if all goals were updated successfully, or 1 if a goal failed.
76 If rebuilding_makefiles is nonzero, these goals are makefiles, so -t, -q,
77 and -n should be disabled for them unless they were also command-line
78 targets, and we should only make one goal at a time and return as soon as
79 one goal whose `changed' member is nonzero is successfully made. */
81 int
82 update_goal_chain (struct dep *goals)
84 int t = touch_flag, q = question_flag, n = just_print_flag;
85 int status = -1;
87 #define MTIME(file) (rebuilding_makefiles ? file_mtime_no_search (file) \
88 : file_mtime (file))
90 /* Duplicate the chain so we can remove things from it. */
92 goals = copy_dep_chain (goals);
95 /* Clear the `changed' flag of each goal in the chain.
96 We will use the flag below to notice when any commands
97 have actually been run for a target. When no commands
98 have been run, we give an "up to date" diagnostic. */
100 struct dep *g;
101 for (g = goals; g != 0; g = g->next)
102 g->changed = 0;
105 /* All files start with the considered bit 0, so the global value is 1. */
106 considered = 1;
108 /* Update all the goals until they are all finished. */
110 while (goals != 0)
112 register struct dep *g, *lastgoal;
114 /* Start jobs that are waiting for the load to go down. */
116 start_waiting_jobs ();
118 /* Wait for a child to die. */
120 reap_children (1, 0);
122 lastgoal = 0;
123 g = goals;
124 while (g != 0)
126 /* Iterate over all double-colon entries for this file. */
127 struct file *file;
128 int stop = 0, any_not_updated = 0;
130 for (file = g->file->double_colon ? g->file->double_colon : g->file;
131 file != NULL;
132 file = file->prev)
134 unsigned int ocommands_started;
135 int x;
137 file->dontcare = g->dontcare;
139 check_renamed (file);
140 if (rebuilding_makefiles)
142 if (file->cmd_target)
144 touch_flag = t;
145 question_flag = q;
146 just_print_flag = n;
148 else
149 touch_flag = question_flag = just_print_flag = 0;
152 /* Save the old value of `commands_started' so we can compare
153 later. It will be incremented when any commands are
154 actually run. */
155 ocommands_started = commands_started;
157 x = update_file (file, rebuilding_makefiles ? 1 : 0);
158 check_renamed (file);
160 /* Set the goal's `changed' flag if any commands were started
161 by calling update_file above. We check this flag below to
162 decide when to give an "up to date" diagnostic. */
163 if (commands_started > ocommands_started)
164 g->changed = 1;
166 /* If we updated a file and STATUS was not already 1, set it to
167 1 if updating failed, or to 0 if updating succeeded. Leave
168 STATUS as it is if no updating was done. */
170 stop = 0;
171 if ((x != 0 || file->updated) && status < 1)
173 if (file->update_status != 0)
175 /* Updating failed, or -q triggered. The STATUS value
176 tells our caller which. */
177 status = file->update_status;
178 /* If -q just triggered, stop immediately. It doesn't
179 matter how much more we run, since we already know
180 the answer to return. */
181 stop = (question_flag && !keep_going_flag
182 && !rebuilding_makefiles);
184 else
186 FILE_TIMESTAMP mtime = MTIME (file);
187 check_renamed (file);
189 if (file->updated && g->changed &&
190 mtime != file->mtime_before_update)
192 /* Updating was done. If this is a makefile and
193 just_print_flag or question_flag is set (meaning
194 -n or -q was given and this file was specified
195 as a command-line target), don't change STATUS.
196 If STATUS is changed, we will get re-exec'd, and
197 enter an infinite loop. */
198 if (!rebuilding_makefiles
199 || (!just_print_flag && !question_flag))
200 status = 0;
201 if (rebuilding_makefiles && file->dontcare)
202 /* This is a default makefile; stop remaking. */
203 stop = 1;
208 /* Keep track if any double-colon entry is not finished.
209 When they are all finished, the goal is finished. */
210 any_not_updated |= !file->updated;
212 file->dontcare = 0;
214 if (stop)
215 break;
218 /* Reset FILE since it is null at the end of the loop. */
219 file = g->file;
221 if (stop || !any_not_updated)
223 /* If we have found nothing whatever to do for the goal,
224 print a message saying nothing needs doing. */
226 if (!rebuilding_makefiles
227 /* If the update_status is zero, we updated successfully
228 or not at all. G->changed will have been set above if
229 any commands were actually started for this goal. */
230 && file->update_status == 0 && !g->changed
231 /* Never give a message under -s or -q. */
232 && !silent_flag && !question_flag)
233 message (1, ((file->phony || file->cmds == 0)
234 ? _("Nothing to be done for `%s'.")
235 : _("`%s' is up to date.")),
236 file->name);
238 /* This goal is finished. Remove it from the chain. */
239 if (lastgoal == 0)
240 goals = g->next;
241 else
242 lastgoal->next = g->next;
244 /* Free the storage. */
245 free (g);
247 g = lastgoal == 0 ? goals : lastgoal->next;
249 if (stop)
250 break;
252 else
254 lastgoal = g;
255 g = g->next;
259 /* If we reached the end of the dependency graph toggle the considered
260 flag for the next pass. */
261 if (g == 0)
262 considered = !considered;
265 if (rebuilding_makefiles)
267 touch_flag = t;
268 question_flag = q;
269 just_print_flag = n;
272 return status;
275 /* If FILE is not up to date, execute the commands for it.
276 Return 0 if successful, 1 if unsuccessful;
277 but with some flag settings, just call `exit' if unsuccessful.
279 DEPTH is the depth in recursions of this function.
280 We increment it during the consideration of our dependencies,
281 then decrement it again after finding out whether this file
282 is out of date.
284 If there are multiple double-colon entries for FILE,
285 each is considered in turn. */
287 static int
288 update_file (struct file *file, unsigned int depth)
290 register int status = 0;
291 register struct file *f;
293 f = file->double_colon ? file->double_colon : file;
295 /* Prune the dependency graph: if we've already been here on _this_
296 pass through the dependency graph, we don't have to go any further.
297 We won't reap_children until we start the next pass, so no state
298 change is possible below here until then. */
299 if (f->considered == considered)
301 /* Check for the case where a target has been tried and failed but
302 the diagnostics hasn't been issued. If we need the diagnostics
303 then we will have to continue. */
304 if (!(f->updated && f->update_status > 0 && !f->dontcare && f->no_diag))
306 DBF (DB_VERBOSE, _("Pruning file `%s'.\n"));
307 return f->command_state == cs_finished ? f->update_status : 0;
311 /* This loop runs until we start commands for a double colon rule, or until
312 the chain is exhausted. */
313 for (; f != 0; f = f->prev)
315 f->considered = considered;
317 status |= update_file_1 (f, depth);
318 check_renamed (f);
320 /* Clean up any alloca() used during the update. */
321 alloca (0);
323 /* If we got an error, don't bother with double_colon etc. */
324 if (status != 0 && !keep_going_flag)
325 return status;
327 if (f->command_state == cs_running
328 || f->command_state == cs_deps_running)
330 /* Don't run the other :: rules for this
331 file until this rule is finished. */
332 status = 0;
333 break;
337 /* Process the remaining rules in the double colon chain so they're marked
338 considered. Start their prerequisites, too. */
339 if (file->double_colon)
340 for (; f != 0 ; f = f->prev)
342 struct dep *d;
344 f->considered = considered;
346 for (d = f->deps; d != 0; d = d->next)
347 status |= update_file (d->file, depth + 1);
350 return status;
353 /* Show a message stating the target failed to build. */
355 static void
356 complain (struct file *file)
358 /* If this file has no_diag set then it means we tried to update it
359 before in the dontcare mode and failed. The target that actually
360 failed is not necessarily this file but could be one of its direct
361 or indirect dependencies. So traverse this file's dependencies and
362 find the one that actually caused the failure. */
364 struct dep *d;
366 for (d = file->deps; d != 0; d = d->next)
368 if (d->file->updated && d->file->update_status > 0 && file->no_diag)
370 complain (d->file);
371 break;
375 if (d == 0)
377 const char *msg_noparent
378 = _("%sNo rule to make target `%s'%s");
379 const char *msg_parent
380 = _("%sNo rule to make target `%s', needed by `%s'%s");
382 /* Didn't find any dependencies to complain about. */
383 if (!keep_going_flag)
385 if (file->parent == 0)
386 fatal (NILF, msg_noparent, "", file->name, "");
388 fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
391 if (file->parent == 0)
392 error (NILF, msg_noparent, "*** ", file->name, ".");
393 else
394 error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
396 file->no_diag = 0;
400 /* Consider a single `struct file' and update it as appropriate. */
402 static int
403 update_file_1 (struct file *file, unsigned int depth)
405 FILE_TIMESTAMP this_mtime;
406 int noexist, must_make, deps_changed;
407 int dep_status = 0;
408 struct file *ofile;
409 struct dep *d, *ad;
410 struct dep amake;
411 int running = 0;
413 DBF (DB_VERBOSE, _("Considering target file `%s'.\n"));
415 if (file->updated)
417 if (file->update_status > 0)
419 DBF (DB_VERBOSE,
420 _("Recently tried and failed to update file `%s'.\n"));
422 /* If the file we tried to make is marked no_diag then no message
423 was printed about it when it failed during the makefile rebuild.
424 If we're trying to build it again in the normal rebuild, print a
425 message now. */
426 if (file->no_diag && !file->dontcare)
427 complain (file);
429 return file->update_status;
432 DBF (DB_VERBOSE, _("File `%s' was considered already.\n"));
433 return 0;
436 switch (file->command_state)
438 case cs_not_started:
439 case cs_deps_running:
440 break;
441 case cs_running:
442 DBF (DB_VERBOSE, _("Still updating file `%s'.\n"));
443 return 0;
444 case cs_finished:
445 DBF (DB_VERBOSE, _("Finished updating file `%s'.\n"));
446 return file->update_status;
447 default:
448 abort ();
451 /* Determine whether the diagnostics will be issued should this update
452 fail. */
453 file->no_diag = file->dontcare;
455 ++depth;
457 /* Notice recursive update of the same file. */
458 start_updating (file);
460 /* We might change file if we find a different one via vpath;
461 remember this one to turn off updating. */
462 ofile = file;
464 /* Looking at the file's modtime beforehand allows the possibility
465 that its name may be changed by a VPATH search, and thus it may
466 not need an implicit rule. If this were not done, the file
467 might get implicit commands that apply to its initial name, only
468 to have that name replaced with another found by VPATH search. */
470 this_mtime = file_mtime (file);
471 check_renamed (file);
472 noexist = this_mtime == NONEXISTENT_MTIME;
473 if (noexist)
474 DBF (DB_BASIC, _("File `%s' does not exist.\n"));
475 else if (ORDINARY_MTIME_MIN <= this_mtime && this_mtime <= ORDINARY_MTIME_MAX
476 && file->low_resolution_time)
478 /* Avoid spurious rebuilds due to low resolution time stamps. */
479 int ns = FILE_TIMESTAMP_NS (this_mtime);
480 if (ns != 0)
481 error (NILF, _("*** Warning: .LOW_RESOLUTION_TIME file `%s' has a high resolution time stamp"),
482 file->name);
483 this_mtime += FILE_TIMESTAMPS_PER_S - 1 - ns;
486 must_make = noexist;
488 /* If file was specified as a target with no commands,
489 come up with some default commands. */
491 if (!file->phony && file->cmds == 0 && !file->tried_implicit)
493 if (try_implicit_rule (file, depth))
494 DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n"));
495 else
496 DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n"));
497 file->tried_implicit = 1;
499 if (file->cmds == 0 && !file->is_target
500 && default_file != 0 && default_file->cmds != 0)
502 DBF (DB_IMPLICIT, _("Using default recipe for `%s'.\n"));
503 file->cmds = default_file->cmds;
506 /* Update all non-intermediate files we depend on, if necessary, and see
507 whether any of them is more recent than this file. We need to walk our
508 deps, AND the deps of any also_make targets to ensure everything happens
509 in the correct order. */
511 amake.file = file;
512 amake.next = file->also_make;
513 ad = &amake;
514 while (ad)
516 struct dep *lastd = 0;
518 /* Find the deps we're scanning */
519 d = ad->file->deps;
520 ad = ad->next;
522 while (d)
524 FILE_TIMESTAMP mtime;
525 int maybe_make;
526 int dontcare = 0;
528 check_renamed (d->file);
530 mtime = file_mtime (d->file);
531 check_renamed (d->file);
533 if (is_updating (d->file))
535 error (NILF, _("Circular %s <- %s dependency dropped."),
536 file->name, d->file->name);
537 /* We cannot free D here because our the caller will still have
538 a reference to it when we were called recursively via
539 check_dep below. */
540 if (lastd == 0)
541 file->deps = d->next;
542 else
543 lastd->next = d->next;
544 d = d->next;
545 continue;
548 d->file->parent = file;
549 maybe_make = must_make;
551 /* Inherit dontcare flag from our parent. */
552 if (rebuilding_makefiles)
554 dontcare = d->file->dontcare;
555 d->file->dontcare = file->dontcare;
558 dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make);
560 /* Restore original dontcare flag. */
561 if (rebuilding_makefiles)
562 d->file->dontcare = dontcare;
564 if (! d->ignore_mtime)
565 must_make = maybe_make;
567 check_renamed (d->file);
570 register struct file *f = d->file;
571 if (f->double_colon)
572 f = f->double_colon;
575 running |= (f->command_state == cs_running
576 || f->command_state == cs_deps_running);
577 f = f->prev;
579 while (f != 0);
582 if (dep_status != 0 && !keep_going_flag)
583 break;
585 if (!running)
586 /* The prereq is considered changed if the timestamp has changed while
587 it was built, OR it doesn't exist. */
588 d->changed = ((file_mtime (d->file) != mtime)
589 || (mtime == NONEXISTENT_MTIME));
591 lastd = d;
592 d = d->next;
596 /* Now we know whether this target needs updating.
597 If it does, update all the intermediate files we depend on. */
599 if (must_make || always_make_flag)
601 for (d = file->deps; d != 0; d = d->next)
602 if (d->file->intermediate)
604 int dontcare = 0;
606 FILE_TIMESTAMP mtime = file_mtime (d->file);
607 check_renamed (d->file);
608 d->file->parent = file;
610 /* Inherit dontcare flag from our parent. */
611 if (rebuilding_makefiles)
613 dontcare = d->file->dontcare;
614 d->file->dontcare = file->dontcare;
618 dep_status |= update_file (d->file, depth);
620 /* Restore original dontcare flag. */
621 if (rebuilding_makefiles)
622 d->file->dontcare = dontcare;
624 check_renamed (d->file);
627 register struct file *f = d->file;
628 if (f->double_colon)
629 f = f->double_colon;
632 running |= (f->command_state == cs_running
633 || f->command_state == cs_deps_running);
634 f = f->prev;
636 while (f != 0);
639 if (dep_status != 0 && !keep_going_flag)
640 break;
642 if (!running)
643 d->changed = ((file->phony && file->cmds != 0)
644 || file_mtime (d->file) != mtime);
648 finish_updating (file);
649 finish_updating (ofile);
651 DBF (DB_VERBOSE, _("Finished prerequisites of target file `%s'.\n"));
653 if (running)
655 set_command_state (file, cs_deps_running);
656 --depth;
657 DBF (DB_VERBOSE, _("The prerequisites of `%s' are being made.\n"));
658 return 0;
661 /* If any dependency failed, give up now. */
663 if (dep_status != 0)
665 file->update_status = dep_status;
666 notice_finished_file (file);
668 --depth;
670 DBF (DB_VERBOSE, _("Giving up on target file `%s'.\n"));
672 if (depth == 0 && keep_going_flag
673 && !just_print_flag && !question_flag)
674 error (NILF,
675 _("Target `%s' not remade because of errors."), file->name);
677 return dep_status;
680 if (file->command_state == cs_deps_running)
681 /* The commands for some deps were running on the last iteration, but
682 they have finished now. Reset the command_state to not_started to
683 simplify later bookkeeping. It is important that we do this only
684 when the prior state was cs_deps_running, because that prior state
685 was definitely propagated to FILE's also_make's by set_command_state
686 (called above), but in another state an also_make may have
687 independently changed to finished state, and we would confuse that
688 file's bookkeeping (updated, but not_started is bogus state). */
689 set_command_state (file, cs_not_started);
691 /* Now record which prerequisites are more
692 recent than this file, so we can define $?. */
694 deps_changed = 0;
695 for (d = file->deps; d != 0; d = d->next)
697 FILE_TIMESTAMP d_mtime = file_mtime (d->file);
698 check_renamed (d->file);
700 if (! d->ignore_mtime)
702 #if 1
703 /* %%% In version 4, remove this code completely to
704 implement not remaking deps if their deps are newer
705 than their parents. */
706 if (d_mtime == NONEXISTENT_MTIME && !d->file->intermediate)
707 /* We must remake if this dep does not
708 exist and is not intermediate. */
709 must_make = 1;
710 #endif
712 /* Set DEPS_CHANGED if this dep actually changed. */
713 deps_changed |= d->changed;
716 /* Set D->changed if either this dep actually changed,
717 or its dependent, FILE, is older or does not exist. */
718 d->changed |= noexist || d_mtime > this_mtime;
720 if (!noexist && ISDB (DB_BASIC|DB_VERBOSE))
722 const char *fmt = 0;
724 if (d->ignore_mtime)
726 if (ISDB (DB_VERBOSE))
727 fmt = _("Prerequisite `%s' is order-only for target `%s'.\n");
729 else if (d_mtime == NONEXISTENT_MTIME)
731 if (ISDB (DB_BASIC))
732 fmt = _("Prerequisite `%s' of target `%s' does not exist.\n");
734 else if (d->changed)
736 if (ISDB (DB_BASIC))
737 fmt = _("Prerequisite `%s' is newer than target `%s'.\n");
739 else if (ISDB (DB_VERBOSE))
740 fmt = _("Prerequisite `%s' is older than target `%s'.\n");
742 if (fmt)
744 print_spaces (depth);
745 printf (fmt, dep_name (d), file->name);
746 fflush (stdout);
751 /* Here depth returns to the value it had when we were called. */
752 depth--;
754 if (file->double_colon && file->deps == 0)
756 must_make = 1;
757 DBF (DB_BASIC,
758 _("Target `%s' is double-colon and has no prerequisites.\n"));
760 else if (!noexist && file->is_target && !deps_changed && file->cmds == 0
761 && !always_make_flag)
763 must_make = 0;
764 DBF (DB_VERBOSE,
765 _("No recipe for `%s' and no prerequisites actually changed.\n"));
767 else if (!must_make && file->cmds != 0 && always_make_flag)
769 must_make = 1;
770 DBF (DB_VERBOSE, _("Making `%s' due to always-make flag.\n"));
773 if (!must_make)
775 if (ISDB (DB_VERBOSE))
777 print_spaces (depth);
778 printf (_("No need to remake target `%s'"), file->name);
779 if (!streq (file->name, file->hname))
780 printf (_("; using VPATH name `%s'"), file->hname);
781 puts (".");
782 fflush (stdout);
785 notice_finished_file (file);
787 /* Since we don't need to remake the file, convert it to use the
788 VPATH filename if we found one. hfile will be either the
789 local name if no VPATH or the VPATH name if one was found. */
791 while (file)
793 file->name = file->hname;
794 file = file->prev;
797 return 0;
800 DBF (DB_BASIC, _("Must remake target `%s'.\n"));
802 /* It needs to be remade. If it's VPATH and not reset via GPATH, toss the
803 VPATH. */
804 if (!streq(file->name, file->hname))
806 DB (DB_BASIC, (_(" Ignoring VPATH name `%s'.\n"), file->hname));
807 file->ignore_vpath = 1;
810 /* Now, take appropriate actions to remake the file. */
811 remake_file (file);
813 if (file->command_state != cs_finished)
815 DBF (DB_VERBOSE, _("Recipe of `%s' is being run.\n"));
816 return 0;
819 switch (file->update_status)
821 case 2:
822 DBF (DB_BASIC, _("Failed to remake target file `%s'.\n"));
823 break;
824 case 0:
825 DBF (DB_BASIC, _("Successfully remade target file `%s'.\n"));
826 break;
827 case 1:
828 DBF (DB_BASIC, _("Target file `%s' needs remade under -q.\n"));
829 break;
830 default:
831 assert (file->update_status >= 0 && file->update_status <= 2);
832 break;
835 file->updated = 1;
836 return file->update_status;
839 /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all
840 files listed in its `also_make' member. Under -t, this function also
841 touches FILE.
843 On return, FILE->update_status will no longer be -1 if it was. */
845 void
846 notice_finished_file (struct file *file)
848 struct dep *d;
849 int ran = file->command_state == cs_running;
850 int touched = 0;
852 file->command_state = cs_finished;
853 file->updated = 1;
855 if (touch_flag
856 /* The update status will be:
857 -1 if this target was not remade;
858 0 if 0 or more commands (+ or ${MAKE}) were run and won;
859 1 if some commands were run and lost.
860 We touch the target if it has commands which either were not run
861 or won when they ran (i.e. status is 0). */
862 && file->update_status == 0)
864 if (file->cmds != 0 && file->cmds->any_recurse)
866 /* If all the command lines were recursive,
867 we don't want to do the touching. */
868 unsigned int i;
869 for (i = 0; i < file->cmds->ncommand_lines; ++i)
870 if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE))
871 goto have_nonrecursing;
873 else
875 have_nonrecursing:
876 if (file->phony)
877 file->update_status = 0;
878 /* According to POSIX, -t doesn't affect targets with no cmds. */
879 else if (file->cmds != 0)
881 /* Should set file's modification date and do nothing else. */
882 file->update_status = touch_file (file);
884 /* Pretend we ran a real touch command, to suppress the
885 "`foo' is up to date" message. */
886 commands_started++;
888 /* Request for the timestamp to be updated (and distributed
889 to the double-colon entries). Simply setting ran=1 would
890 almost have done the trick, but messes up with the also_make
891 updating logic below. */
892 touched = 1;
897 if (file->mtime_before_update == UNKNOWN_MTIME)
898 file->mtime_before_update = file->last_mtime;
900 if ((ran && !file->phony) || touched)
902 int i = 0;
904 /* If -n, -t, or -q and all the commands are recursive, we ran them so
905 really check the target's mtime again. Otherwise, assume the target
906 would have been updated. */
908 if ((question_flag || just_print_flag || touch_flag) && file->cmds)
910 for (i = file->cmds->ncommand_lines; i > 0; --i)
911 if (! (file->cmds->lines_flags[i-1] & COMMANDS_RECURSE))
912 break;
915 /* If there were no commands at all, it's always new. */
917 else if (file->is_target && file->cmds == 0)
918 i = 1;
920 file->last_mtime = i == 0 ? UNKNOWN_MTIME : NEW_MTIME;
923 if (file->double_colon)
925 /* If this is a double colon rule and it is the last one to be
926 updated, propagate the change of modification time to all the
927 double-colon entries for this file.
929 We do it on the last update because it is important to handle
930 individual entries as separate rules with separate timestamps
931 while they are treated as targets and then as one rule with the
932 unified timestamp when they are considered as a prerequisite
933 of some target. */
935 struct file *f;
936 FILE_TIMESTAMP max_mtime = file->last_mtime;
938 /* Check that all rules were updated and at the same time find
939 the max timestamp. We assume UNKNOWN_MTIME is newer then
940 any other value. */
941 for (f = file->double_colon; f != 0 && f->updated; f = f->prev)
942 if (max_mtime != UNKNOWN_MTIME
943 && (f->last_mtime == UNKNOWN_MTIME || f->last_mtime > max_mtime))
944 max_mtime = f->last_mtime;
946 if (f == 0)
947 for (f = file->double_colon; f != 0; f = f->prev)
948 f->last_mtime = max_mtime;
951 if (ran && file->update_status != -1)
952 /* We actually tried to update FILE, which has
953 updated its also_make's as well (if it worked).
954 If it didn't work, it wouldn't work again for them.
955 So mark them as updated with the same status. */
956 for (d = file->also_make; d != 0; d = d->next)
958 d->file->command_state = cs_finished;
959 d->file->updated = 1;
960 d->file->update_status = file->update_status;
962 if (ran && !d->file->phony)
963 /* Fetch the new modification time.
964 We do this instead of just invalidating the cached time
965 so that a vpath_search can happen. Otherwise, it would
966 never be done because the target is already updated. */
967 f_mtime (d->file, 0);
969 else if (file->update_status == -1)
970 /* Nothing was done for FILE, but it needed nothing done.
971 So mark it now as "succeeded". */
972 file->update_status = 0;
975 /* Check whether another file (whose mtime is THIS_MTIME) needs updating on
976 account of a dependency which is file FILE. If it does, store 1 in
977 *MUST_MAKE_PTR. In the process, update any non-intermediate files that
978 FILE depends on (including FILE itself). Return nonzero if any updating
979 failed. */
981 static int
982 check_dep (struct file *file, unsigned int depth,
983 FILE_TIMESTAMP this_mtime, int *must_make_ptr)
985 struct file *ofile;
986 struct dep *d;
987 int dep_status = 0;
989 ++depth;
990 start_updating (file);
992 /* We might change file if we find a different one via vpath;
993 remember this one to turn off updating. */
994 ofile = file;
996 if (file->phony || !file->intermediate)
998 /* If this is a non-intermediate file, update it and record whether it
999 is newer than THIS_MTIME. */
1000 FILE_TIMESTAMP mtime;
1001 dep_status = update_file (file, depth);
1002 check_renamed (file);
1003 mtime = file_mtime (file);
1004 check_renamed (file);
1005 if (mtime == NONEXISTENT_MTIME || mtime > this_mtime)
1006 *must_make_ptr = 1;
1008 else
1010 /* FILE is an intermediate file. */
1011 FILE_TIMESTAMP mtime;
1013 if (!file->phony && file->cmds == 0 && !file->tried_implicit)
1015 if (try_implicit_rule (file, depth))
1016 DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n"));
1017 else
1018 DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n"));
1019 file->tried_implicit = 1;
1021 if (file->cmds == 0 && !file->is_target
1022 && default_file != 0 && default_file->cmds != 0)
1024 DBF (DB_IMPLICIT, _("Using default commands for `%s'.\n"));
1025 file->cmds = default_file->cmds;
1028 check_renamed (file);
1029 mtime = file_mtime (file);
1030 check_renamed (file);
1031 if (mtime != NONEXISTENT_MTIME && mtime > this_mtime)
1032 /* If the intermediate file actually exists and is newer, then we
1033 should remake from it. */
1034 *must_make_ptr = 1;
1035 else
1037 /* Otherwise, update all non-intermediate files we depend on, if
1038 necessary, and see whether any of them is more recent than the
1039 file on whose behalf we are checking. */
1040 struct dep *ld;
1041 int deps_running = 0;
1043 /* If this target is not running, set it's state so that we check it
1044 fresh. It could be it was checked as part of an order-only
1045 prerequisite and so wasn't rebuilt then, but should be now. */
1046 if (file->command_state != cs_running)
1047 set_command_state (file, cs_not_started);
1049 ld = 0;
1050 d = file->deps;
1051 while (d != 0)
1053 int maybe_make;
1055 if (is_updating (d->file))
1057 error (NILF, _("Circular %s <- %s dependency dropped."),
1058 file->name, d->file->name);
1059 if (ld == 0)
1061 file->deps = d->next;
1062 free_dep (d);
1063 d = file->deps;
1065 else
1067 ld->next = d->next;
1068 free_dep (d);
1069 d = ld->next;
1071 continue;
1074 d->file->parent = file;
1075 maybe_make = *must_make_ptr;
1076 dep_status |= check_dep (d->file, depth, this_mtime,
1077 &maybe_make);
1078 if (! d->ignore_mtime)
1079 *must_make_ptr = maybe_make;
1080 check_renamed (d->file);
1081 if (dep_status != 0 && !keep_going_flag)
1082 break;
1084 if (d->file->command_state == cs_running
1085 || d->file->command_state == cs_deps_running)
1086 deps_running = 1;
1088 ld = d;
1089 d = d->next;
1092 if (deps_running)
1093 /* Record that some of FILE's deps are still being made.
1094 This tells the upper levels to wait on processing it until the
1095 commands are finished. */
1096 set_command_state (file, cs_deps_running);
1100 finish_updating (file);
1101 finish_updating (ofile);
1103 return dep_status;
1106 /* Touch FILE. Return zero if successful, one if not. */
1108 #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
1110 static int
1111 touch_file (struct file *file)
1113 if (!silent_flag)
1114 message (0, "touch %s", file->name);
1116 /* Print-only (-n) takes precedence over touch (-t). */
1117 if (just_print_flag)
1118 return 0;
1120 #ifndef NO_ARCHIVES
1121 if (ar_name (file->name))
1122 return ar_touch (file->name);
1123 else
1124 #endif
1126 int fd = open (file->name, O_RDWR | O_CREAT, 0666);
1128 if (fd < 0)
1129 TOUCH_ERROR ("touch: open: ");
1130 else
1132 struct stat statbuf;
1133 char buf = 'x';
1134 int e;
1136 EINTRLOOP (e, fstat (fd, &statbuf));
1137 if (e < 0)
1138 TOUCH_ERROR ("touch: fstat: ");
1139 /* Rewrite character 0 same as it already is. */
1140 if (read (fd, &buf, 1) < 0)
1141 TOUCH_ERROR ("touch: read: ");
1142 if (lseek (fd, 0L, 0) < 0L)
1143 TOUCH_ERROR ("touch: lseek: ");
1144 if (write (fd, &buf, 1) < 0)
1145 TOUCH_ERROR ("touch: write: ");
1146 /* If file length was 0, we just
1147 changed it, so change it back. */
1148 if (statbuf.st_size == 0)
1150 (void) close (fd);
1151 fd = open (file->name, O_RDWR | O_TRUNC, 0666);
1152 if (fd < 0)
1153 TOUCH_ERROR ("touch: open: ");
1155 (void) close (fd);
1159 return 0;
1162 /* Having checked and updated the dependencies of FILE,
1163 do whatever is appropriate to remake FILE itself.
1164 Return the status from executing FILE's commands. */
1166 static void
1167 remake_file (struct file *file)
1169 if (file->cmds == 0)
1171 if (file->phony)
1172 /* Phony target. Pretend it succeeded. */
1173 file->update_status = 0;
1174 else if (file->is_target)
1175 /* This is a nonexistent target file we cannot make.
1176 Pretend it was successfully remade. */
1177 file->update_status = 0;
1178 else
1180 /* This is a dependency file we cannot remake. Fail. */
1181 if (!rebuilding_makefiles || !file->dontcare)
1182 complain (file);
1183 file->update_status = 2;
1186 else
1188 chop_commands (file->cmds);
1190 /* The normal case: start some commands. */
1191 if (!touch_flag || file->cmds->any_recurse)
1193 execute_file_commands (file);
1194 return;
1197 /* This tells notice_finished_file it is ok to touch the file. */
1198 file->update_status = 0;
1201 /* This does the touching under -t. */
1202 notice_finished_file (file);
1205 /* Return the mtime of a file, given a `struct file'.
1206 Caches the time in the struct file to avoid excess stat calls.
1208 If the file is not found, and SEARCH is nonzero, VPATH searching and
1209 replacement is done. If that fails, a library (-lLIBNAME) is tried and
1210 the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into
1211 FILE. */
1213 FILE_TIMESTAMP
1214 f_mtime (struct file *file, int search)
1216 FILE_TIMESTAMP mtime;
1218 /* File's mtime is not known; must get it from the system. */
1220 #ifndef NO_ARCHIVES
1221 if (ar_name (file->name))
1223 /* This file is an archive-member reference. */
1225 char *arname, *memname;
1226 struct file *arfile;
1227 time_t member_date;
1229 /* Find the archive's name. */
1230 ar_parse_name (file->name, &arname, &memname);
1232 /* Find the modification time of the archive itself.
1233 Also allow for its name to be changed via VPATH search. */
1234 arfile = lookup_file (arname);
1235 if (arfile == 0)
1236 arfile = enter_file (strcache_add (arname));
1237 mtime = f_mtime (arfile, search);
1238 check_renamed (arfile);
1239 if (search && strcmp (arfile->hname, arname))
1241 /* The archive's name has changed.
1242 Change the archive-member reference accordingly. */
1244 char *name;
1245 unsigned int arlen, memlen;
1247 arlen = strlen (arfile->hname);
1248 memlen = strlen (memname);
1250 name = xmalloc (arlen + 1 + memlen + 2);
1251 memcpy (name, arfile->hname, arlen);
1252 name[arlen] = '(';
1253 memcpy (name + arlen + 1, memname, memlen);
1254 name[arlen + 1 + memlen] = ')';
1255 name[arlen + 1 + memlen + 1] = '\0';
1257 /* If the archive was found with GPATH, make the change permanent;
1258 otherwise defer it until later. */
1259 if (arfile->name == arfile->hname)
1260 rename_file (file, name);
1261 else
1262 rehash_file (file, name);
1263 check_renamed (file);
1266 free (arname);
1268 file->low_resolution_time = 1;
1270 if (mtime == NONEXISTENT_MTIME)
1271 /* The archive doesn't exist, so its members don't exist either. */
1272 return NONEXISTENT_MTIME;
1274 member_date = ar_member_date (file->hname);
1275 mtime = (member_date == (time_t) -1
1276 ? NONEXISTENT_MTIME
1277 : file_timestamp_cons (file->hname, member_date, 0));
1279 else
1280 #endif
1282 mtime = name_mtime (file->name);
1284 if (mtime == NONEXISTENT_MTIME && search && !file->ignore_vpath)
1286 /* If name_mtime failed, search VPATH. */
1287 const char *name = vpath_search (file->name, &mtime, NULL, NULL);
1288 if (name
1289 /* Last resort, is it a library (-lxxx)? */
1290 || (file->name[0] == '-' && file->name[1] == 'l'
1291 && (name = library_search (file->name, &mtime)) != 0))
1293 if (mtime != UNKNOWN_MTIME)
1294 /* vpath_search and library_search store UNKNOWN_MTIME
1295 if they didn't need to do a stat call for their work. */
1296 file->last_mtime = mtime;
1298 /* If we found it in VPATH, see if it's in GPATH too; if so,
1299 change the name right now; if not, defer until after the
1300 dependencies are updated. */
1301 if (gpath_search (name, strlen(name) - strlen(file->name) - 1))
1303 rename_file (file, name);
1304 check_renamed (file);
1305 return file_mtime (file);
1308 rehash_file (file, name);
1309 check_renamed (file);
1310 /* If the result of a vpath search is -o or -W, preserve it.
1311 Otherwise, find the mtime of the resulting file. */
1312 if (mtime != OLD_MTIME && mtime != NEW_MTIME)
1313 mtime = name_mtime (name);
1318 /* Files can have bogus timestamps that nothing newly made will be
1319 "newer" than. Updating their dependents could just result in loops.
1320 So notify the user of the anomaly with a warning.
1322 We only need to do this once, for now. */
1324 if (!clock_skew_detected
1325 && mtime != NONEXISTENT_MTIME && mtime != NEW_MTIME
1326 && !file->updated)
1328 static FILE_TIMESTAMP adjusted_now;
1330 FILE_TIMESTAMP adjusted_mtime = mtime;
1332 #if defined(WINDOWS32) || defined(__MSDOS__)
1333 /* Experimentation has shown that FAT filesystems can set file times
1334 up to 3 seconds into the future! Play it safe. */
1336 #define FAT_ADJ_OFFSET (FILE_TIMESTAMP) 3
1338 FILE_TIMESTAMP adjustment = FAT_ADJ_OFFSET << FILE_TIMESTAMP_LO_BITS;
1339 if (ORDINARY_MTIME_MIN + adjustment <= adjusted_mtime)
1340 adjusted_mtime -= adjustment;
1341 #elif defined(__EMX__)
1342 /* FAT filesystems round time to the nearest even second!
1343 Allow for any file (NTFS or FAT) to perhaps suffer from this
1344 brain damage. */
1345 FILE_TIMESTAMP adjustment = (((FILE_TIMESTAMP_S (adjusted_mtime) & 1) == 0
1346 && FILE_TIMESTAMP_NS (adjusted_mtime) == 0)
1347 ? (FILE_TIMESTAMP) 1 << FILE_TIMESTAMP_LO_BITS
1348 : 0);
1349 #endif
1351 /* If the file's time appears to be in the future, update our
1352 concept of the present and try once more. */
1353 if (adjusted_now < adjusted_mtime)
1355 int resolution;
1356 FILE_TIMESTAMP now = file_timestamp_now (&resolution);
1357 adjusted_now = now + (resolution - 1);
1358 if (adjusted_now < adjusted_mtime)
1360 #ifdef NO_FLOAT
1361 error (NILF, _("Warning: File `%s' has modification time in the future"),
1362 file->name);
1363 #else
1364 double from_now =
1365 (FILE_TIMESTAMP_S (mtime) - FILE_TIMESTAMP_S (now)
1366 + ((FILE_TIMESTAMP_NS (mtime) - FILE_TIMESTAMP_NS (now))
1367 / 1e9));
1368 char from_now_string[100];
1370 if (from_now >= 99 && from_now <= ULONG_MAX)
1371 sprintf (from_now_string, "%lu", (unsigned long) from_now);
1372 else
1373 sprintf (from_now_string, "%.2g", from_now);
1374 error (NILF, _("Warning: File `%s' has modification time %s s in the future"),
1375 file->name, from_now_string);
1376 #endif
1377 clock_skew_detected = 1;
1382 /* Store the mtime into all the entries for this file. */
1383 if (file->double_colon)
1384 file = file->double_colon;
1388 /* If this file is not implicit but it is intermediate then it was
1389 made so by the .INTERMEDIATE target. If this file has never
1390 been built by us but was found now, it existed before make
1391 started. So, turn off the intermediate bit so make doesn't
1392 delete it, since it didn't create it. */
1393 if (mtime != NONEXISTENT_MTIME && file->command_state == cs_not_started
1394 && file->command_state == cs_not_started
1395 && !file->tried_implicit && file->intermediate)
1396 file->intermediate = 0;
1398 file->last_mtime = mtime;
1399 file = file->prev;
1401 while (file != 0);
1403 return mtime;
1407 /* Return the mtime of the file or archive-member reference NAME. */
1409 /* First, we check with stat(). If the file does not exist, then we return
1410 NONEXISTENT_MTIME. If it does, and the symlink check flag is set, then
1411 examine each indirection of the symlink and find the newest mtime.
1412 This causes one duplicate stat() when -L is being used, but the code is
1413 much cleaner. */
1415 static FILE_TIMESTAMP
1416 name_mtime (const char *name)
1418 FILE_TIMESTAMP mtime;
1419 struct stat st;
1420 int e;
1422 EINTRLOOP (e, stat (name, &st));
1423 if (e == 0)
1424 mtime = FILE_TIMESTAMP_STAT_MODTIME (name, st);
1425 else if (errno == ENOENT || errno == ENOTDIR)
1426 mtime = NONEXISTENT_MTIME;
1427 else
1429 perror_with_name ("stat: ", name);
1430 return NONEXISTENT_MTIME;
1433 /* If we get here we either found it, or it doesn't exist.
1434 If it doesn't exist see if we can use a symlink mtime instead. */
1436 #ifdef MAKE_SYMLINKS
1437 #ifndef S_ISLNK
1438 # define S_ISLNK(_m) (((_m)&S_IFMT)==S_IFLNK)
1439 #endif
1440 if (check_symlink_flag)
1442 PATH_VAR (lpath);
1444 /* Check each symbolic link segment (if any). Find the latest mtime
1445 amongst all of them (and the target file of course).
1446 Note that we have already successfully dereferenced all the links
1447 above. So, if we run into any error trying to lstat(), or
1448 readlink(), or whatever, something bizarre-o happened. Just give up
1449 and use whatever mtime we've already computed at that point. */
1450 strcpy (lpath, name);
1451 while (1)
1453 FILE_TIMESTAMP ltime;
1454 PATH_VAR (lbuf);
1455 long llen;
1456 char *p;
1458 EINTRLOOP (e, lstat (lpath, &st));
1459 if (e)
1461 /* Just take what we have so far. */
1462 if (errno != ENOENT && errno != ENOTDIR)
1463 perror_with_name ("lstat: ", lpath);
1464 break;
1467 /* If this is not a symlink, we're done (we started with the real
1468 file's mtime so we don't need to test it again). */
1469 if (!S_ISLNK (st.st_mode))
1470 break;
1472 /* If this mtime is newer than what we had, keep the new one. */
1473 ltime = FILE_TIMESTAMP_STAT_MODTIME (lpath, st);
1474 if (ltime > mtime)
1475 mtime = ltime;
1477 /* Set up to check the file pointed to by this link. */
1478 EINTRLOOP (llen, readlink (lpath, lbuf, GET_PATH_MAX));
1479 if (llen < 0)
1481 /* Eh? Just take what we have. */
1482 perror_with_name ("readlink: ", lpath);
1483 break;
1485 lbuf[llen] = '\0';
1487 /* If the target is fully-qualified or the source is just a
1488 filename, then the new path is the target. Otherwise it's the
1489 source directory plus the target. */
1490 if (lbuf[0] == '/' || (p = strrchr (lpath, '/')) == NULL)
1491 strcpy (lpath, lbuf);
1492 else if ((p - lpath) + llen + 2 > GET_PATH_MAX)
1493 /* Eh? Path too long! Again, just go with what we have. */
1494 break;
1495 else
1496 /* Create the next step in the symlink chain. */
1497 strcpy (p+1, lbuf);
1500 #endif
1502 return mtime;
1506 /* Search for a library file specified as -lLIBNAME, searching for a
1507 suitable library file in the system library directories and the VPATH
1508 directories. */
1510 static const char *
1511 library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr)
1513 static char *dirs[] =
1515 #ifndef _AMIGA
1516 "/lib",
1517 "/usr/lib",
1518 #endif
1519 #if defined(WINDOWS32) && !defined(LIBDIR)
1521 * This is completely up to the user at product install time. Just define
1522 * a placeholder.
1524 #define LIBDIR "."
1525 #endif
1526 LIBDIR, /* Defined by configuration. */
1530 const char *file = 0;
1531 char *libpatterns;
1532 FILE_TIMESTAMP mtime;
1534 /* Loop variables for the libpatterns value. */
1535 char *p;
1536 const char *p2;
1537 unsigned int len;
1538 unsigned int liblen;
1540 /* Information about the earliest (in the vpath sequence) match. */
1541 unsigned int best_vpath, best_path;
1542 unsigned int std_dirs = 0;
1544 char **dp;
1546 libpatterns = xstrdup (variable_expand ("$(.LIBPATTERNS)"));
1548 /* Skip the '-l'. */
1549 lib += 2;
1550 liblen = strlen (lib);
1552 /* Loop through all the patterns in .LIBPATTERNS, and search on each one.
1553 To implement the linker-compatible behavior we have to search through
1554 all entries in .LIBPATTERNS and choose the "earliest" one. */
1555 p2 = libpatterns;
1556 while ((p = find_next_token (&p2, &len)) != 0)
1558 static char *buf = NULL;
1559 static unsigned int buflen = 0;
1560 static int libdir_maxlen = -1;
1561 char *libbuf = variable_expand ("");
1563 /* Expand the pattern using LIB as a replacement. */
1565 char c = p[len];
1566 char *p3, *p4;
1568 p[len] = '\0';
1569 p3 = find_percent (p);
1570 if (!p3)
1572 /* Give a warning if there is no pattern. */
1573 error (NILF, _(".LIBPATTERNS element `%s' is not a pattern"), p);
1574 p[len] = c;
1575 continue;
1577 p4 = variable_buffer_output (libbuf, p, p3-p);
1578 p4 = variable_buffer_output (p4, lib, liblen);
1579 p4 = variable_buffer_output (p4, p3+1, len - (p3-p));
1580 p[len] = c;
1583 /* Look first for `libNAME.a' in the current directory. */
1584 mtime = name_mtime (libbuf);
1585 if (mtime != NONEXISTENT_MTIME)
1587 if (mtime_ptr != 0)
1588 *mtime_ptr = mtime;
1589 file = strcache_add (libbuf);
1590 /* This by definition will have the best index, so stop now. */
1591 break;
1594 /* Now try VPATH search on that. */
1597 unsigned int vpath_index, path_index;
1598 const char* f = vpath_search (libbuf, mtime_ptr ? &mtime : NULL,
1599 &vpath_index, &path_index);
1600 if (f)
1602 /* If we have a better match, record it. */
1603 if (file == 0 ||
1604 vpath_index < best_vpath ||
1605 (vpath_index == best_vpath && path_index < best_path))
1607 file = f;
1608 best_vpath = vpath_index;
1609 best_path = path_index;
1611 if (mtime_ptr != 0)
1612 *mtime_ptr = mtime;
1617 /* Now try the standard set of directories. */
1619 if (!buflen)
1621 for (dp = dirs; *dp != 0; ++dp)
1623 int l = strlen (*dp);
1624 if (l > libdir_maxlen)
1625 libdir_maxlen = l;
1626 std_dirs++;
1628 buflen = strlen (libbuf);
1629 buf = xmalloc(libdir_maxlen + buflen + 2);
1631 else if (buflen < strlen (libbuf))
1633 buflen = strlen (libbuf);
1634 buf = xrealloc (buf, libdir_maxlen + buflen + 2);
1638 /* Use the last std_dirs index for standard directories. This
1639 was it will always be greater than the VPATH index. */
1640 unsigned int vpath_index = ~((unsigned int)0) - std_dirs;
1642 for (dp = dirs; *dp != 0; ++dp)
1644 sprintf (buf, "%s/%s", *dp, libbuf);
1645 mtime = name_mtime (buf);
1646 if (mtime != NONEXISTENT_MTIME)
1648 if (file == 0 || vpath_index < best_vpath)
1650 file = strcache_add (buf);
1651 best_vpath = vpath_index;
1653 if (mtime_ptr != 0)
1654 *mtime_ptr = mtime;
1658 vpath_index++;
1664 free (libpatterns);
1665 return file;