Add missing load.c file to POTFILES.in
[make.git] / remake.c
blobb1ddd239bb3aaf3978dad1a7a923e4107c9edfcd
1 /* Basic dependency engine for GNU Make.
2 Copyright (C) 1988-2012 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
8 version.
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
17 #include "make.h"
18 #include "filedef.h"
19 #include "job.h"
20 #include "commands.h"
21 #include "dep.h"
22 #include "variable.h"
23 #include "debug.h"
25 #include <assert.h>
27 #ifdef HAVE_FCNTL_H
28 #include <fcntl.h>
29 #else
30 #include <sys/file.h>
31 #endif
33 #ifdef VMS
34 #include <starlet.h>
35 #endif
36 #ifdef WINDOWS32
37 #include <io.h>
38 #endif
40 extern int try_implicit_rule (struct file *file, unsigned int depth);
43 /* The test for circular dependencies is based on the 'updating' bit in
44 'struct file'. However, double colon targets have seperate 'struct
45 file's; make sure we always use the base of the double colon chain. */
47 #define start_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
48 ->updating = 1)
49 #define finish_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
50 ->updating = 0)
51 #define is_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
52 ->updating)
55 /* Incremented when a command is started (under -n, when one would be). */
56 unsigned int commands_started = 0;
58 /* Current value for pruning the scan of the goal chain (toggle 0/1). */
59 static unsigned int considered;
61 static int update_file (struct file *file, unsigned int depth);
62 static int update_file_1 (struct file *file, unsigned int depth);
63 static int check_dep (struct file *file, unsigned int depth,
64 FILE_TIMESTAMP this_mtime, int *must_make_ptr);
65 static int touch_file (struct file *file);
66 static void remake_file (struct file *file);
67 static FILE_TIMESTAMP name_mtime (const char *name);
68 static const char *library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr);
71 /* Remake all the goals in the 'struct dep' chain GOALS. Return -1 if nothing
72 was done, 0 if all goals were updated successfully, or 1 if a goal failed.
74 If rebuilding_makefiles is nonzero, these goals are makefiles, so -t, -q,
75 and -n should be disabled for them unless they were also command-line
76 targets, and we should only make one goal at a time and return as soon as
77 one goal whose 'changed' member is nonzero is successfully made. */
79 int
80 update_goal_chain (struct dep *goals)
82 int t = touch_flag, q = question_flag, n = just_print_flag;
83 int status = -1;
85 #define MTIME(file) (rebuilding_makefiles ? file_mtime_no_search (file) \
86 : file_mtime (file))
88 /* Duplicate the chain so we can remove things from it. */
90 goals = copy_dep_chain (goals);
93 /* Clear the 'changed' flag of each goal in the chain.
94 We will use the flag below to notice when any commands
95 have actually been run for a target. When no commands
96 have been run, we give an "up to date" diagnostic. */
98 struct dep *g;
99 for (g = goals; g != 0; g = g->next)
100 g->changed = 0;
103 /* All files start with the considered bit 0, so the global value is 1. */
104 considered = 1;
106 /* Update all the goals until they are all finished. */
108 while (goals != 0)
110 register struct dep *g, *lastgoal;
112 /* Start jobs that are waiting for the load to go down. */
114 start_waiting_jobs ();
116 /* Wait for a child to die. */
118 reap_children (1, 0);
120 lastgoal = 0;
121 g = goals;
122 while (g != 0)
124 /* Iterate over all double-colon entries for this file. */
125 struct file *file;
126 int stop = 0, any_not_updated = 0;
128 for (file = g->file->double_colon ? g->file->double_colon : g->file;
129 file != NULL;
130 file = file->prev)
132 unsigned int ocommands_started;
133 int x;
135 file->dontcare = g->dontcare;
137 check_renamed (file);
138 if (rebuilding_makefiles)
140 if (file->cmd_target)
142 touch_flag = t;
143 question_flag = q;
144 just_print_flag = n;
146 else
147 touch_flag = question_flag = just_print_flag = 0;
150 /* Save the old value of 'commands_started' so we can compare
151 later. It will be incremented when any commands are
152 actually run. */
153 ocommands_started = commands_started;
155 x = update_file (file, rebuilding_makefiles ? 1 : 0);
156 check_renamed (file);
158 /* Set the goal's 'changed' flag if any commands were started
159 by calling update_file above. We check this flag below to
160 decide when to give an "up to date" diagnostic. */
161 if (commands_started > ocommands_started)
162 g->changed = 1;
164 /* If we updated a file and STATUS was not already 1, set it to
165 1 if updating failed, or to 0 if updating succeeded. Leave
166 STATUS as it is if no updating was done. */
168 stop = 0;
169 if ((x != 0 || file->updated) && status < 1)
171 if (file->update_status != 0)
173 /* Updating failed, or -q triggered. The STATUS value
174 tells our caller which. */
175 status = file->update_status;
176 /* If -q just triggered, stop immediately. It doesn't
177 matter how much more we run, since we already know
178 the answer to return. */
179 stop = (question_flag && !keep_going_flag
180 && !rebuilding_makefiles);
182 else
184 FILE_TIMESTAMP mtime = MTIME (file);
185 check_renamed (file);
187 if (file->updated && g->changed &&
188 mtime != file->mtime_before_update)
190 /* Updating was done. If this is a makefile and
191 just_print_flag or question_flag is set (meaning
192 -n or -q was given and this file was specified
193 as a command-line target), don't change STATUS.
194 If STATUS is changed, we will get re-exec'd, and
195 enter an infinite loop. */
196 if (!rebuilding_makefiles
197 || (!just_print_flag && !question_flag))
198 status = 0;
199 if (rebuilding_makefiles && file->dontcare)
200 /* This is a default makefile; stop remaking. */
201 stop = 1;
206 /* Keep track if any double-colon entry is not finished.
207 When they are all finished, the goal is finished. */
208 any_not_updated |= !file->updated;
210 file->dontcare = 0;
212 if (stop)
213 break;
216 /* Reset FILE since it is null at the end of the loop. */
217 file = g->file;
219 if (stop || !any_not_updated)
221 /* If we have found nothing whatever to do for the goal,
222 print a message saying nothing needs doing. */
224 if (!rebuilding_makefiles
225 /* If the update_status is zero, we updated successfully
226 or not at all. G->changed will have been set above if
227 any commands were actually started for this goal. */
228 && file->update_status == 0 && !g->changed
229 /* Never give a message under -s or -q. */
230 && !silent_flag && !question_flag)
231 message (1, ((file->phony || file->cmds == 0)
232 ? _("Nothing to be done for '%s'.")
233 : _("'%s' is up to date.")),
234 file->name);
236 /* This goal is finished. Remove it from the chain. */
237 if (lastgoal == 0)
238 goals = g->next;
239 else
240 lastgoal->next = g->next;
242 /* Free the storage. */
243 free (g);
245 g = lastgoal == 0 ? goals : lastgoal->next;
247 if (stop)
248 break;
250 else
252 lastgoal = g;
253 g = g->next;
257 /* If we reached the end of the dependency graph toggle the considered
258 flag for the next pass. */
259 if (g == 0)
260 considered = !considered;
263 if (rebuilding_makefiles)
265 touch_flag = t;
266 question_flag = q;
267 just_print_flag = n;
270 return status;
273 /* If FILE is not up to date, execute the commands for it.
274 Return 0 if successful, 1 if unsuccessful;
275 but with some flag settings, just call 'exit' if unsuccessful.
277 DEPTH is the depth in recursions of this function.
278 We increment it during the consideration of our dependencies,
279 then decrement it again after finding out whether this file
280 is out of date.
282 If there are multiple double-colon entries for FILE,
283 each is considered in turn. */
285 static int
286 update_file (struct file *file, unsigned int depth)
288 register int status = 0;
289 register struct file *f;
291 f = file->double_colon ? file->double_colon : file;
293 /* Prune the dependency graph: if we've already been here on _this_
294 pass through the dependency graph, we don't have to go any further.
295 We won't reap_children until we start the next pass, so no state
296 change is possible below here until then. */
297 if (f->considered == considered)
299 /* Check for the case where a target has been tried and failed but
300 the diagnostics hasn't been issued. If we need the diagnostics
301 then we will have to continue. */
302 if (!(f->updated && f->update_status > 0 && !f->dontcare && f->no_diag))
304 DBF (DB_VERBOSE, _("Pruning file '%s'.\n"));
305 return f->command_state == cs_finished ? f->update_status : 0;
309 /* This loop runs until we start commands for a double colon rule, or until
310 the chain is exhausted. */
311 for (; f != 0; f = f->prev)
313 f->considered = considered;
315 status |= update_file_1 (f, depth);
316 check_renamed (f);
318 /* Clean up any alloca() used during the update. */
319 alloca (0);
321 /* If we got an error, don't bother with double_colon etc. */
322 if (status != 0 && !keep_going_flag)
323 return status;
325 if (f->command_state == cs_running
326 || f->command_state == cs_deps_running)
328 /* Don't run the other :: rules for this
329 file until this rule is finished. */
330 status = 0;
331 break;
335 /* Process the remaining rules in the double colon chain so they're marked
336 considered. Start their prerequisites, too. */
337 if (file->double_colon)
338 for (; f != 0 ; f = f->prev)
340 struct dep *d;
342 f->considered = considered;
344 for (d = f->deps; d != 0; d = d->next)
345 status |= update_file (d->file, depth + 1);
348 return status;
351 /* Show a message stating the target failed to build. */
353 static void
354 complain (struct file *file)
356 /* If this file has no_diag set then it means we tried to update it
357 before in the dontcare mode and failed. The target that actually
358 failed is not necessarily this file but could be one of its direct
359 or indirect dependencies. So traverse this file's dependencies and
360 find the one that actually caused the failure. */
362 struct dep *d;
364 for (d = file->deps; d != 0; d = d->next)
366 if (d->file->updated && d->file->update_status > 0 && file->no_diag)
368 complain (d->file);
369 break;
373 if (d == 0)
375 const char *msg_noparent
376 = _("%sNo rule to make target '%s'%s");
377 const char *msg_parent
378 = _("%sNo rule to make target '%s', needed by '%s'%s");
380 /* Didn't find any dependencies to complain about. */
381 if (!keep_going_flag)
383 if (file->parent == 0)
384 fatal (NILF, msg_noparent, "", file->name, "");
386 fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
389 if (file->parent == 0)
390 error (NILF, msg_noparent, "*** ", file->name, ".");
391 else
392 error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
394 file->no_diag = 0;
398 /* Consider a single 'struct file' and update it as appropriate. */
400 static int
401 update_file_1 (struct file *file, unsigned int depth)
403 FILE_TIMESTAMP this_mtime;
404 int noexist, must_make, deps_changed;
405 int dep_status = 0;
406 struct file *ofile;
407 struct dep *d, *ad;
408 struct dep amake;
409 int running = 0;
411 DBF (DB_VERBOSE, _("Considering target file '%s'.\n"));
413 if (file->updated)
415 if (file->update_status > 0)
417 DBF (DB_VERBOSE,
418 _("Recently tried and failed to update file '%s'.\n"));
420 /* If the file we tried to make is marked no_diag then no message
421 was printed about it when it failed during the makefile rebuild.
422 If we're trying to build it again in the normal rebuild, print a
423 message now. */
424 if (file->no_diag && !file->dontcare)
425 complain (file);
427 return file->update_status;
430 DBF (DB_VERBOSE, _("File '%s' was considered already.\n"));
431 return 0;
434 switch (file->command_state)
436 case cs_not_started:
437 case cs_deps_running:
438 break;
439 case cs_running:
440 DBF (DB_VERBOSE, _("Still updating file '%s'.\n"));
441 return 0;
442 case cs_finished:
443 DBF (DB_VERBOSE, _("Finished updating file '%s'.\n"));
444 return file->update_status;
445 default:
446 abort ();
449 /* Determine whether the diagnostics will be issued should this update
450 fail. */
451 file->no_diag = file->dontcare;
453 ++depth;
455 /* Notice recursive update of the same file. */
456 start_updating (file);
458 /* We might change file if we find a different one via vpath;
459 remember this one to turn off updating. */
460 ofile = file;
462 /* Looking at the file's modtime beforehand allows the possibility
463 that its name may be changed by a VPATH search, and thus it may
464 not need an implicit rule. If this were not done, the file
465 might get implicit commands that apply to its initial name, only
466 to have that name replaced with another found by VPATH search. */
468 this_mtime = file_mtime (file);
469 check_renamed (file);
470 noexist = this_mtime == NONEXISTENT_MTIME;
471 if (noexist)
472 DBF (DB_BASIC, _("File '%s' does not exist.\n"));
473 else if (ORDINARY_MTIME_MIN <= this_mtime && this_mtime <= ORDINARY_MTIME_MAX
474 && file->low_resolution_time)
476 /* Avoid spurious rebuilds due to low resolution time stamps. */
477 int ns = FILE_TIMESTAMP_NS (this_mtime);
478 if (ns != 0)
479 error (NILF, _("*** Warning: .LOW_RESOLUTION_TIME file '%s' has a high resolution time stamp"),
480 file->name);
481 this_mtime += FILE_TIMESTAMPS_PER_S - 1 - ns;
484 must_make = noexist;
486 /* If file was specified as a target with no commands,
487 come up with some default commands. */
489 if (!file->phony && file->cmds == 0 && !file->tried_implicit)
491 if (try_implicit_rule (file, depth))
492 DBF (DB_IMPLICIT, _("Found an implicit rule for '%s'.\n"));
493 else
494 DBF (DB_IMPLICIT, _("No implicit rule found for '%s'.\n"));
495 file->tried_implicit = 1;
497 if (file->cmds == 0 && !file->is_target
498 && default_file != 0 && default_file->cmds != 0)
500 DBF (DB_IMPLICIT, _("Using default recipe for '%s'.\n"));
501 file->cmds = default_file->cmds;
504 /* Update all non-intermediate files we depend on, if necessary, and see
505 whether any of them is more recent than this file. We need to walk our
506 deps, AND the deps of any also_make targets to ensure everything happens
507 in the correct order. */
509 amake.file = file;
510 amake.next = file->also_make;
511 ad = &amake;
512 while (ad)
514 struct dep *lastd = 0;
516 /* Find the deps we're scanning */
517 d = ad->file->deps;
518 ad = ad->next;
520 while (d)
522 FILE_TIMESTAMP mtime;
523 int maybe_make;
524 int dontcare = 0;
526 check_renamed (d->file);
528 mtime = file_mtime (d->file);
529 check_renamed (d->file);
531 if (is_updating (d->file))
533 error (NILF, _("Circular %s <- %s dependency dropped."),
534 file->name, d->file->name);
535 /* We cannot free D here because our the caller will still have
536 a reference to it when we were called recursively via
537 check_dep below. */
538 if (lastd == 0)
539 file->deps = d->next;
540 else
541 lastd->next = d->next;
542 d = d->next;
543 continue;
546 d->file->parent = file;
547 maybe_make = must_make;
549 /* Inherit dontcare flag from our parent. */
550 if (rebuilding_makefiles)
552 dontcare = d->file->dontcare;
553 d->file->dontcare = file->dontcare;
556 dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make);
558 /* Restore original dontcare flag. */
559 if (rebuilding_makefiles)
560 d->file->dontcare = dontcare;
562 if (! d->ignore_mtime)
563 must_make = maybe_make;
565 check_renamed (d->file);
568 register struct file *f = d->file;
569 if (f->double_colon)
570 f = f->double_colon;
573 running |= (f->command_state == cs_running
574 || f->command_state == cs_deps_running);
575 f = f->prev;
577 while (f != 0);
580 if (dep_status != 0 && !keep_going_flag)
581 break;
583 if (!running)
584 /* The prereq is considered changed if the timestamp has changed while
585 it was built, OR it doesn't exist. */
586 d->changed = ((file_mtime (d->file) != mtime)
587 || (mtime == NONEXISTENT_MTIME));
589 lastd = d;
590 d = d->next;
594 /* Now we know whether this target needs updating.
595 If it does, update all the intermediate files we depend on. */
597 if (must_make || always_make_flag)
599 for (d = file->deps; d != 0; d = d->next)
600 if (d->file->intermediate)
602 int dontcare = 0;
604 FILE_TIMESTAMP mtime = file_mtime (d->file);
605 check_renamed (d->file);
606 d->file->parent = file;
608 /* Inherit dontcare flag from our parent. */
609 if (rebuilding_makefiles)
611 dontcare = d->file->dontcare;
612 d->file->dontcare = file->dontcare;
615 /* We may have already considered this file, when we didn't know
616 we'd need to update it. Force update_file() to consider it and
617 not prune it. */
618 d->file->considered = !considered;
620 dep_status |= update_file (d->file, depth);
622 /* Restore original dontcare flag. */
623 if (rebuilding_makefiles)
624 d->file->dontcare = dontcare;
626 check_renamed (d->file);
629 register struct file *f = d->file;
630 if (f->double_colon)
631 f = f->double_colon;
634 running |= (f->command_state == cs_running
635 || f->command_state == cs_deps_running);
636 f = f->prev;
638 while (f != 0);
641 if (dep_status != 0 && !keep_going_flag)
642 break;
644 if (!running)
645 d->changed = ((file->phony && file->cmds != 0)
646 || file_mtime (d->file) != mtime);
650 finish_updating (file);
651 finish_updating (ofile);
653 DBF (DB_VERBOSE, _("Finished prerequisites of target file '%s'.\n"));
655 if (running)
657 set_command_state (file, cs_deps_running);
658 --depth;
659 DBF (DB_VERBOSE, _("The prerequisites of '%s' are being made.\n"));
660 return 0;
663 /* If any dependency failed, give up now. */
665 if (dep_status != 0)
667 file->update_status = dep_status;
668 notice_finished_file (file);
670 --depth;
672 DBF (DB_VERBOSE, _("Giving up on target file '%s'.\n"));
674 if (depth == 0 && keep_going_flag
675 && !just_print_flag && !question_flag)
676 error (NILF,
677 _("Target '%s' not remade because of errors."), file->name);
679 return dep_status;
682 if (file->command_state == cs_deps_running)
683 /* The commands for some deps were running on the last iteration, but
684 they have finished now. Reset the command_state to not_started to
685 simplify later bookkeeping. It is important that we do this only
686 when the prior state was cs_deps_running, because that prior state
687 was definitely propagated to FILE's also_make's by set_command_state
688 (called above), but in another state an also_make may have
689 independently changed to finished state, and we would confuse that
690 file's bookkeeping (updated, but not_started is bogus state). */
691 set_command_state (file, cs_not_started);
693 /* Now record which prerequisites are more
694 recent than this file, so we can define $?. */
696 deps_changed = 0;
697 for (d = file->deps; d != 0; d = d->next)
699 FILE_TIMESTAMP d_mtime = file_mtime (d->file);
700 check_renamed (d->file);
702 if (! d->ignore_mtime)
704 #if 1
705 /* %%% In version 4, remove this code completely to
706 implement not remaking deps if their deps are newer
707 than their parents. */
708 if (d_mtime == NONEXISTENT_MTIME && !d->file->intermediate)
709 /* We must remake if this dep does not
710 exist and is not intermediate. */
711 must_make = 1;
712 #endif
714 /* Set DEPS_CHANGED if this dep actually changed. */
715 deps_changed |= d->changed;
718 /* Set D->changed if either this dep actually changed,
719 or its dependent, FILE, is older or does not exist. */
720 d->changed |= noexist || d_mtime > this_mtime;
722 if (!noexist && ISDB (DB_BASIC|DB_VERBOSE))
724 const char *fmt = 0;
726 if (d->ignore_mtime)
728 if (ISDB (DB_VERBOSE))
729 fmt = _("Prerequisite '%s' is order-only for target '%s'.\n");
731 else if (d_mtime == NONEXISTENT_MTIME)
733 if (ISDB (DB_BASIC))
734 fmt = _("Prerequisite '%s' of target '%s' does not exist.\n");
736 else if (d->changed)
738 if (ISDB (DB_BASIC))
739 fmt = _("Prerequisite '%s' is newer than target '%s'.\n");
741 else if (ISDB (DB_VERBOSE))
742 fmt = _("Prerequisite '%s' is older than target '%s'.\n");
744 if (fmt)
746 print_spaces (depth);
747 printf (fmt, dep_name (d), file->name);
748 fflush (stdout);
753 /* Here depth returns to the value it had when we were called. */
754 depth--;
756 if (file->double_colon && file->deps == 0)
758 must_make = 1;
759 DBF (DB_BASIC,
760 _("Target '%s' is double-colon and has no prerequisites.\n"));
762 else if (!noexist && file->is_target && !deps_changed && file->cmds == 0
763 && !always_make_flag)
765 must_make = 0;
766 DBF (DB_VERBOSE,
767 _("No recipe for '%s' and no prerequisites actually changed.\n"));
769 else if (!must_make && file->cmds != 0 && always_make_flag)
771 must_make = 1;
772 DBF (DB_VERBOSE, _("Making '%s' due to always-make flag.\n"));
775 if (!must_make)
777 if (ISDB (DB_VERBOSE))
779 print_spaces (depth);
780 printf (_("No need to remake target '%s'"), file->name);
781 if (!streq (file->name, file->hname))
782 printf (_("; using VPATH name '%s'"), file->hname);
783 puts (".");
784 fflush (stdout);
787 notice_finished_file (file);
789 /* Since we don't need to remake the file, convert it to use the
790 VPATH filename if we found one. hfile will be either the
791 local name if no VPATH or the VPATH name if one was found. */
793 while (file)
795 file->name = file->hname;
796 file = file->prev;
799 return 0;
802 DBF (DB_BASIC, _("Must remake target '%s'.\n"));
804 /* It needs to be remade. If it's VPATH and not reset via GPATH, toss the
805 VPATH. */
806 if (!streq(file->name, file->hname))
808 DB (DB_BASIC, (_(" Ignoring VPATH name '%s'.\n"), file->hname));
809 file->ignore_vpath = 1;
812 /* Now, take appropriate actions to remake the file. */
813 remake_file (file);
815 if (file->command_state != cs_finished)
817 DBF (DB_VERBOSE, _("Recipe of '%s' is being run.\n"));
818 return 0;
821 switch (file->update_status)
823 case 2:
824 DBF (DB_BASIC, _("Failed to remake target file '%s'.\n"));
825 break;
826 case 0:
827 DBF (DB_BASIC, _("Successfully remade target file '%s'.\n"));
828 break;
829 case 1:
830 DBF (DB_BASIC, _("Target file '%s' needs remade under -q.\n"));
831 break;
832 default:
833 assert (file->update_status >= 0 && file->update_status <= 2);
834 break;
837 file->updated = 1;
838 return file->update_status;
841 /* Set FILE's 'updated' flag and re-check its mtime and the mtime's of all
842 files listed in its 'also_make' member. Under -t, this function also
843 touches FILE.
845 On return, FILE->update_status will no longer be -1 if it was. */
847 void
848 notice_finished_file (struct file *file)
850 struct dep *d;
851 int ran = file->command_state == cs_running;
852 int touched = 0;
854 file->command_state = cs_finished;
855 file->updated = 1;
857 if (touch_flag
858 /* The update status will be:
859 -1 if this target was not remade;
860 0 if 0 or more commands (+ or ${MAKE}) were run and won;
861 1 if some commands were run and lost.
862 We touch the target if it has commands which either were not run
863 or won when they ran (i.e. status is 0). */
864 && file->update_status == 0)
866 if (file->cmds != 0 && file->cmds->any_recurse)
868 /* If all the command lines were recursive,
869 we don't want to do the touching. */
870 unsigned int i;
871 for (i = 0; i < file->cmds->ncommand_lines; ++i)
872 if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE))
873 goto have_nonrecursing;
875 else
877 have_nonrecursing:
878 if (file->phony)
879 file->update_status = 0;
880 /* According to POSIX, -t doesn't affect targets with no cmds. */
881 else if (file->cmds != 0)
883 /* Should set file's modification date and do nothing else. */
884 file->update_status = touch_file (file);
886 /* Pretend we ran a real touch command, to suppress the
887 "'foo' is up to date" message. */
888 commands_started++;
890 /* Request for the timestamp to be updated (and distributed
891 to the double-colon entries). Simply setting ran=1 would
892 almost have done the trick, but messes up with the also_make
893 updating logic below. */
894 touched = 1;
899 if (file->mtime_before_update == UNKNOWN_MTIME)
900 file->mtime_before_update = file->last_mtime;
902 if ((ran && !file->phony) || touched)
904 int i = 0;
906 /* If -n, -t, or -q and all the commands are recursive, we ran them so
907 really check the target's mtime again. Otherwise, assume the target
908 would have been updated. */
910 if ((question_flag || just_print_flag || touch_flag) && file->cmds)
912 for (i = file->cmds->ncommand_lines; i > 0; --i)
913 if (! (file->cmds->lines_flags[i-1] & COMMANDS_RECURSE))
914 break;
917 /* If there were no commands at all, it's always new. */
919 else if (file->is_target && file->cmds == 0)
920 i = 1;
922 file->last_mtime = i == 0 ? UNKNOWN_MTIME : NEW_MTIME;
925 if (file->double_colon)
927 /* If this is a double colon rule and it is the last one to be
928 updated, propagate the change of modification time to all the
929 double-colon entries for this file.
931 We do it on the last update because it is important to handle
932 individual entries as separate rules with separate timestamps
933 while they are treated as targets and then as one rule with the
934 unified timestamp when they are considered as a prerequisite
935 of some target. */
937 struct file *f;
938 FILE_TIMESTAMP max_mtime = file->last_mtime;
940 /* Check that all rules were updated and at the same time find
941 the max timestamp. We assume UNKNOWN_MTIME is newer then
942 any other value. */
943 for (f = file->double_colon; f != 0 && f->updated; f = f->prev)
944 if (max_mtime != UNKNOWN_MTIME
945 && (f->last_mtime == UNKNOWN_MTIME || f->last_mtime > max_mtime))
946 max_mtime = f->last_mtime;
948 if (f == 0)
949 for (f = file->double_colon; f != 0; f = f->prev)
950 f->last_mtime = max_mtime;
953 if (ran && file->update_status != -1)
954 /* We actually tried to update FILE, which has
955 updated its also_make's as well (if it worked).
956 If it didn't work, it wouldn't work again for them.
957 So mark them as updated with the same status. */
958 for (d = file->also_make; d != 0; d = d->next)
960 d->file->command_state = cs_finished;
961 d->file->updated = 1;
962 d->file->update_status = file->update_status;
964 if (ran && !d->file->phony)
965 /* Fetch the new modification time.
966 We do this instead of just invalidating the cached time
967 so that a vpath_search can happen. Otherwise, it would
968 never be done because the target is already updated. */
969 f_mtime (d->file, 0);
971 else if (file->update_status == -1)
972 /* Nothing was done for FILE, but it needed nothing done.
973 So mark it now as "succeeded". */
974 file->update_status = 0;
977 /* Check whether another file (whose mtime is THIS_MTIME) needs updating on
978 account of a dependency which is file FILE. If it does, store 1 in
979 *MUST_MAKE_PTR. In the process, update any non-intermediate files that
980 FILE depends on (including FILE itself). Return nonzero if any updating
981 failed. */
983 static int
984 check_dep (struct file *file, unsigned int depth,
985 FILE_TIMESTAMP this_mtime, int *must_make_ptr)
987 struct file *ofile;
988 struct dep *d;
989 int dep_status = 0;
991 ++depth;
992 start_updating (file);
994 /* We might change file if we find a different one via vpath;
995 remember this one to turn off updating. */
996 ofile = file;
998 if (file->phony || !file->intermediate)
1000 /* If this is a non-intermediate file, update it and record whether it
1001 is newer than THIS_MTIME. */
1002 FILE_TIMESTAMP mtime;
1003 dep_status = update_file (file, depth);
1004 check_renamed (file);
1005 mtime = file_mtime (file);
1006 check_renamed (file);
1007 if (mtime == NONEXISTENT_MTIME || mtime > this_mtime)
1008 *must_make_ptr = 1;
1010 else
1012 /* FILE is an intermediate file. */
1013 FILE_TIMESTAMP mtime;
1015 if (!file->phony && file->cmds == 0 && !file->tried_implicit)
1017 if (try_implicit_rule (file, depth))
1018 DBF (DB_IMPLICIT, _("Found an implicit rule for '%s'.\n"));
1019 else
1020 DBF (DB_IMPLICIT, _("No implicit rule found for '%s'.\n"));
1021 file->tried_implicit = 1;
1023 if (file->cmds == 0 && !file->is_target
1024 && default_file != 0 && default_file->cmds != 0)
1026 DBF (DB_IMPLICIT, _("Using default commands for '%s'.\n"));
1027 file->cmds = default_file->cmds;
1030 check_renamed (file);
1031 mtime = file_mtime (file);
1032 check_renamed (file);
1033 if (mtime != NONEXISTENT_MTIME && mtime > this_mtime)
1034 /* If the intermediate file actually exists and is newer, then we
1035 should remake from it. */
1036 *must_make_ptr = 1;
1037 else
1039 /* Otherwise, update all non-intermediate files we depend on, if
1040 necessary, and see whether any of them is more recent than the
1041 file on whose behalf we are checking. */
1042 struct dep *ld;
1043 int deps_running = 0;
1045 /* If this target is not running, set it's state so that we check it
1046 fresh. It could be it was checked as part of an order-only
1047 prerequisite and so wasn't rebuilt then, but should be now. */
1048 if (file->command_state != cs_running)
1049 set_command_state (file, cs_not_started);
1051 ld = 0;
1052 d = file->deps;
1053 while (d != 0)
1055 int maybe_make;
1057 if (is_updating (d->file))
1059 error (NILF, _("Circular %s <- %s dependency dropped."),
1060 file->name, d->file->name);
1061 if (ld == 0)
1063 file->deps = d->next;
1064 free_dep (d);
1065 d = file->deps;
1067 else
1069 ld->next = d->next;
1070 free_dep (d);
1071 d = ld->next;
1073 continue;
1076 d->file->parent = file;
1077 maybe_make = *must_make_ptr;
1078 dep_status |= check_dep (d->file, depth, this_mtime,
1079 &maybe_make);
1080 if (! d->ignore_mtime)
1081 *must_make_ptr = maybe_make;
1082 check_renamed (d->file);
1083 if (dep_status != 0 && !keep_going_flag)
1084 break;
1086 if (d->file->command_state == cs_running
1087 || d->file->command_state == cs_deps_running)
1088 deps_running = 1;
1090 ld = d;
1091 d = d->next;
1094 if (deps_running)
1095 /* Record that some of FILE's deps are still being made.
1096 This tells the upper levels to wait on processing it until the
1097 commands are finished. */
1098 set_command_state (file, cs_deps_running);
1102 finish_updating (file);
1103 finish_updating (ofile);
1105 return dep_status;
1108 /* Touch FILE. Return zero if successful, one if not. */
1110 #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
1112 static int
1113 touch_file (struct file *file)
1115 if (!silent_flag)
1116 message (0, "touch %s", file->name);
1118 /* Print-only (-n) takes precedence over touch (-t). */
1119 if (just_print_flag)
1120 return 0;
1122 #ifndef NO_ARCHIVES
1123 if (ar_name (file->name))
1124 return ar_touch (file->name);
1125 else
1126 #endif
1128 int fd = open (file->name, O_RDWR | O_CREAT, 0666);
1130 if (fd < 0)
1131 TOUCH_ERROR ("touch: open: ");
1132 else
1134 struct stat statbuf;
1135 char buf = 'x';
1136 int e;
1138 EINTRLOOP (e, fstat (fd, &statbuf));
1139 if (e < 0)
1140 TOUCH_ERROR ("touch: fstat: ");
1141 /* Rewrite character 0 same as it already is. */
1142 if (read (fd, &buf, 1) < 0)
1143 TOUCH_ERROR ("touch: read: ");
1144 if (lseek (fd, 0L, 0) < 0L)
1145 TOUCH_ERROR ("touch: lseek: ");
1146 if (write (fd, &buf, 1) < 0)
1147 TOUCH_ERROR ("touch: write: ");
1148 /* If file length was 0, we just
1149 changed it, so change it back. */
1150 if (statbuf.st_size == 0)
1152 (void) close (fd);
1153 fd = open (file->name, O_RDWR | O_TRUNC, 0666);
1154 if (fd < 0)
1155 TOUCH_ERROR ("touch: open: ");
1157 (void) close (fd);
1161 return 0;
1164 /* Having checked and updated the dependencies of FILE,
1165 do whatever is appropriate to remake FILE itself.
1166 Return the status from executing FILE's commands. */
1168 static void
1169 remake_file (struct file *file)
1171 if (file->cmds == 0)
1173 if (file->phony)
1174 /* Phony target. Pretend it succeeded. */
1175 file->update_status = 0;
1176 else if (file->is_target)
1177 /* This is a nonexistent target file we cannot make.
1178 Pretend it was successfully remade. */
1179 file->update_status = 0;
1180 else
1182 /* This is a dependency file we cannot remake. Fail. */
1183 if (!rebuilding_makefiles || !file->dontcare)
1184 complain (file);
1185 file->update_status = 2;
1188 else
1190 chop_commands (file->cmds);
1192 /* The normal case: start some commands. */
1193 if (!touch_flag || file->cmds->any_recurse)
1195 execute_file_commands (file);
1196 return;
1199 /* This tells notice_finished_file it is ok to touch the file. */
1200 file->update_status = 0;
1203 /* This does the touching under -t. */
1204 notice_finished_file (file);
1207 /* Return the mtime of a file, given a 'struct file'.
1208 Caches the time in the struct file to avoid excess stat calls.
1210 If the file is not found, and SEARCH is nonzero, VPATH searching and
1211 replacement is done. If that fails, a library (-lLIBNAME) is tried and
1212 the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into
1213 FILE. */
1215 FILE_TIMESTAMP
1216 f_mtime (struct file *file, int search)
1218 FILE_TIMESTAMP mtime;
1220 /* File's mtime is not known; must get it from the system. */
1222 #ifndef NO_ARCHIVES
1223 if (ar_name (file->name))
1225 /* This file is an archive-member reference. */
1227 char *arname, *memname;
1228 struct file *arfile;
1229 time_t member_date;
1231 /* Find the archive's name. */
1232 ar_parse_name (file->name, &arname, &memname);
1234 /* Find the modification time of the archive itself.
1235 Also allow for its name to be changed via VPATH search. */
1236 arfile = lookup_file (arname);
1237 if (arfile == 0)
1238 arfile = enter_file (strcache_add (arname));
1239 mtime = f_mtime (arfile, search);
1240 check_renamed (arfile);
1241 if (search && strcmp (arfile->hname, arname))
1243 /* The archive's name has changed.
1244 Change the archive-member reference accordingly. */
1246 char *name;
1247 unsigned int arlen, memlen;
1249 arlen = strlen (arfile->hname);
1250 memlen = strlen (memname);
1252 name = xmalloc (arlen + 1 + memlen + 2);
1253 memcpy (name, arfile->hname, arlen);
1254 name[arlen] = '(';
1255 memcpy (name + arlen + 1, memname, memlen);
1256 name[arlen + 1 + memlen] = ')';
1257 name[arlen + 1 + memlen + 1] = '\0';
1259 /* If the archive was found with GPATH, make the change permanent;
1260 otherwise defer it until later. */
1261 if (arfile->name == arfile->hname)
1262 rename_file (file, name);
1263 else
1264 rehash_file (file, name);
1265 check_renamed (file);
1268 free (arname);
1270 file->low_resolution_time = 1;
1272 if (mtime == NONEXISTENT_MTIME)
1273 /* The archive doesn't exist, so its members don't exist either. */
1274 return NONEXISTENT_MTIME;
1276 member_date = ar_member_date (file->hname);
1277 mtime = (member_date == (time_t) -1
1278 ? NONEXISTENT_MTIME
1279 : file_timestamp_cons (file->hname, member_date, 0));
1281 else
1282 #endif
1284 mtime = name_mtime (file->name);
1286 if (mtime == NONEXISTENT_MTIME && search && !file->ignore_vpath)
1288 /* If name_mtime failed, search VPATH. */
1289 const char *name = vpath_search (file->name, &mtime, NULL, NULL);
1290 if (name
1291 /* Last resort, is it a library (-lxxx)? */
1292 || (file->name[0] == '-' && file->name[1] == 'l'
1293 && (name = library_search (file->name, &mtime)) != 0))
1295 if (mtime != UNKNOWN_MTIME)
1296 /* vpath_search and library_search store UNKNOWN_MTIME
1297 if they didn't need to do a stat call for their work. */
1298 file->last_mtime = mtime;
1300 /* If we found it in VPATH, see if it's in GPATH too; if so,
1301 change the name right now; if not, defer until after the
1302 dependencies are updated. */
1303 if (gpath_search (name, strlen(name) - strlen(file->name) - 1))
1305 rename_file (file, name);
1306 check_renamed (file);
1307 return file_mtime (file);
1310 rehash_file (file, name);
1311 check_renamed (file);
1312 /* If the result of a vpath search is -o or -W, preserve it.
1313 Otherwise, find the mtime of the resulting file. */
1314 if (mtime != OLD_MTIME && mtime != NEW_MTIME)
1315 mtime = name_mtime (name);
1320 /* Files can have bogus timestamps that nothing newly made will be
1321 "newer" than. Updating their dependents could just result in loops.
1322 So notify the user of the anomaly with a warning.
1324 We only need to do this once, for now. */
1326 if (!clock_skew_detected
1327 && mtime != NONEXISTENT_MTIME && mtime != NEW_MTIME
1328 && !file->updated)
1330 static FILE_TIMESTAMP adjusted_now;
1332 FILE_TIMESTAMP adjusted_mtime = mtime;
1334 #if defined(WINDOWS32) || defined(__MSDOS__)
1335 /* Experimentation has shown that FAT filesystems can set file times
1336 up to 3 seconds into the future! Play it safe. */
1338 #define FAT_ADJ_OFFSET (FILE_TIMESTAMP) 3
1340 FILE_TIMESTAMP adjustment = FAT_ADJ_OFFSET << FILE_TIMESTAMP_LO_BITS;
1341 if (ORDINARY_MTIME_MIN + adjustment <= adjusted_mtime)
1342 adjusted_mtime -= adjustment;
1343 #elif defined(__EMX__)
1344 /* FAT filesystems round time to the nearest even second!
1345 Allow for any file (NTFS or FAT) to perhaps suffer from this
1346 brain damage. */
1347 FILE_TIMESTAMP adjustment = (((FILE_TIMESTAMP_S (adjusted_mtime) & 1) == 0
1348 && FILE_TIMESTAMP_NS (adjusted_mtime) == 0)
1349 ? (FILE_TIMESTAMP) 1 << FILE_TIMESTAMP_LO_BITS
1350 : 0);
1351 #endif
1353 /* If the file's time appears to be in the future, update our
1354 concept of the present and try once more. */
1355 if (adjusted_now < adjusted_mtime)
1357 int resolution;
1358 FILE_TIMESTAMP now = file_timestamp_now (&resolution);
1359 adjusted_now = now + (resolution - 1);
1360 if (adjusted_now < adjusted_mtime)
1362 #ifdef NO_FLOAT
1363 error (NILF, _("Warning: File '%s' has modification time in the future"),
1364 file->name);
1365 #else
1366 double from_now =
1367 (FILE_TIMESTAMP_S (mtime) - FILE_TIMESTAMP_S (now)
1368 + ((FILE_TIMESTAMP_NS (mtime) - FILE_TIMESTAMP_NS (now))
1369 / 1e9));
1370 char from_now_string[100];
1372 if (from_now >= 99 && from_now <= ULONG_MAX)
1373 sprintf (from_now_string, "%lu", (unsigned long) from_now);
1374 else
1375 sprintf (from_now_string, "%.2g", from_now);
1376 error (NILF, _("Warning: File '%s' has modification time %s s in the future"),
1377 file->name, from_now_string);
1378 #endif
1379 clock_skew_detected = 1;
1384 /* Store the mtime into all the entries for this file. */
1385 if (file->double_colon)
1386 file = file->double_colon;
1390 /* If this file is not implicit but it is intermediate then it was
1391 made so by the .INTERMEDIATE target. If this file has never
1392 been built by us but was found now, it existed before make
1393 started. So, turn off the intermediate bit so make doesn't
1394 delete it, since it didn't create it. */
1395 if (mtime != NONEXISTENT_MTIME && file->command_state == cs_not_started
1396 && file->command_state == cs_not_started
1397 && !file->tried_implicit && file->intermediate)
1398 file->intermediate = 0;
1400 file->last_mtime = mtime;
1401 file = file->prev;
1403 while (file != 0);
1405 return mtime;
1409 /* Return the mtime of the file or archive-member reference NAME. */
1411 /* First, we check with stat(). If the file does not exist, then we return
1412 NONEXISTENT_MTIME. If it does, and the symlink check flag is set, then
1413 examine each indirection of the symlink and find the newest mtime.
1414 This causes one duplicate stat() when -L is being used, but the code is
1415 much cleaner. */
1417 static FILE_TIMESTAMP
1418 name_mtime (const char *name)
1420 FILE_TIMESTAMP mtime;
1421 struct stat st;
1422 int e;
1424 EINTRLOOP (e, stat (name, &st));
1425 if (e == 0)
1426 mtime = FILE_TIMESTAMP_STAT_MODTIME (name, st);
1427 else if (errno == ENOENT || errno == ENOTDIR)
1428 mtime = NONEXISTENT_MTIME;
1429 else
1431 perror_with_name ("stat: ", name);
1432 return NONEXISTENT_MTIME;
1435 /* If we get here we either found it, or it doesn't exist.
1436 If it doesn't exist see if we can use a symlink mtime instead. */
1438 #ifdef MAKE_SYMLINKS
1439 #ifndef S_ISLNK
1440 # define S_ISLNK(_m) (((_m)&S_IFMT)==S_IFLNK)
1441 #endif
1442 if (check_symlink_flag)
1444 PATH_VAR (lpath);
1446 /* Check each symbolic link segment (if any). Find the latest mtime
1447 amongst all of them (and the target file of course).
1448 Note that we have already successfully dereferenced all the links
1449 above. So, if we run into any error trying to lstat(), or
1450 readlink(), or whatever, something bizarre-o happened. Just give up
1451 and use whatever mtime we've already computed at that point. */
1452 strcpy (lpath, name);
1453 while (1)
1455 FILE_TIMESTAMP ltime;
1456 PATH_VAR (lbuf);
1457 long llen;
1458 char *p;
1460 EINTRLOOP (e, lstat (lpath, &st));
1461 if (e)
1463 /* Just take what we have so far. */
1464 if (errno != ENOENT && errno != ENOTDIR)
1465 perror_with_name ("lstat: ", lpath);
1466 break;
1469 /* If this is not a symlink, we're done (we started with the real
1470 file's mtime so we don't need to test it again). */
1471 if (!S_ISLNK (st.st_mode))
1472 break;
1474 /* If this mtime is newer than what we had, keep the new one. */
1475 ltime = FILE_TIMESTAMP_STAT_MODTIME (lpath, st);
1476 if (ltime > mtime)
1477 mtime = ltime;
1479 /* Set up to check the file pointed to by this link. */
1480 EINTRLOOP (llen, readlink (lpath, lbuf, GET_PATH_MAX));
1481 if (llen < 0)
1483 /* Eh? Just take what we have. */
1484 perror_with_name ("readlink: ", lpath);
1485 break;
1487 lbuf[llen] = '\0';
1489 /* If the target is fully-qualified or the source is just a
1490 filename, then the new path is the target. Otherwise it's the
1491 source directory plus the target. */
1492 if (lbuf[0] == '/' || (p = strrchr (lpath, '/')) == NULL)
1493 strcpy (lpath, lbuf);
1494 else if ((p - lpath) + llen + 2 > GET_PATH_MAX)
1495 /* Eh? Path too long! Again, just go with what we have. */
1496 break;
1497 else
1498 /* Create the next step in the symlink chain. */
1499 strcpy (p+1, lbuf);
1502 #endif
1504 return mtime;
1508 /* Search for a library file specified as -lLIBNAME, searching for a
1509 suitable library file in the system library directories and the VPATH
1510 directories. */
1512 static const char *
1513 library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr)
1515 static char *dirs[] =
1517 #ifndef _AMIGA
1518 "/lib",
1519 "/usr/lib",
1520 #endif
1521 #if defined(WINDOWS32) && !defined(LIBDIR)
1523 * This is completely up to the user at product install time. Just define
1524 * a placeholder.
1526 #define LIBDIR "."
1527 #endif
1528 LIBDIR, /* Defined by configuration. */
1532 const char *file = 0;
1533 char *libpatterns;
1534 FILE_TIMESTAMP mtime;
1536 /* Loop variables for the libpatterns value. */
1537 char *p;
1538 const char *p2;
1539 unsigned int len;
1540 unsigned int liblen;
1542 /* Information about the earliest (in the vpath sequence) match. */
1543 unsigned int best_vpath = 0, best_path = 0;
1545 char **dp;
1547 libpatterns = xstrdup (variable_expand ("$(.LIBPATTERNS)"));
1549 /* Skip the '-l'. */
1550 lib += 2;
1551 liblen = strlen (lib);
1553 /* Loop through all the patterns in .LIBPATTERNS, and search on each one.
1554 To implement the linker-compatible behavior we have to search through
1555 all entries in .LIBPATTERNS and choose the "earliest" one. */
1556 p2 = libpatterns;
1557 while ((p = find_next_token (&p2, &len)) != 0)
1559 static char *buf = NULL;
1560 static unsigned int buflen = 0;
1561 static int libdir_maxlen = -1;
1562 static unsigned int std_dirs = 0;
1563 char *libbuf = variable_expand ("");
1565 /* Expand the pattern using LIB as a replacement. */
1567 char c = p[len];
1568 char *p3, *p4;
1570 p[len] = '\0';
1571 p3 = find_percent (p);
1572 if (!p3)
1574 /* Give a warning if there is no pattern. */
1575 error (NILF, _(".LIBPATTERNS element '%s' is not a pattern"), p);
1576 p[len] = c;
1577 continue;
1579 p4 = variable_buffer_output (libbuf, p, p3-p);
1580 p4 = variable_buffer_output (p4, lib, liblen);
1581 p4 = variable_buffer_output (p4, p3+1, len - (p3-p));
1582 p[len] = c;
1585 /* Look first for 'libNAME.a' in the current directory. */
1586 mtime = name_mtime (libbuf);
1587 if (mtime != NONEXISTENT_MTIME)
1589 if (mtime_ptr != 0)
1590 *mtime_ptr = mtime;
1591 file = strcache_add (libbuf);
1592 /* This by definition will have the best index, so stop now. */
1593 break;
1596 /* Now try VPATH search on that. */
1599 unsigned int vpath_index, path_index;
1600 const char* f = vpath_search (libbuf, mtime_ptr ? &mtime : NULL,
1601 &vpath_index, &path_index);
1602 if (f)
1604 /* If we have a better match, record it. */
1605 if (file == 0 ||
1606 vpath_index < best_vpath ||
1607 (vpath_index == best_vpath && path_index < best_path))
1609 file = f;
1610 best_vpath = vpath_index;
1611 best_path = path_index;
1613 if (mtime_ptr != 0)
1614 *mtime_ptr = mtime;
1619 /* Now try the standard set of directories. */
1621 if (!buflen)
1623 for (dp = dirs; *dp != 0; ++dp)
1625 int l = strlen (*dp);
1626 if (l > libdir_maxlen)
1627 libdir_maxlen = l;
1628 std_dirs++;
1630 buflen = strlen (libbuf);
1631 buf = xmalloc(libdir_maxlen + buflen + 2);
1633 else if (buflen < strlen (libbuf))
1635 buflen = strlen (libbuf);
1636 buf = xrealloc (buf, libdir_maxlen + buflen + 2);
1640 /* Use the last std_dirs index for standard directories. This
1641 was it will always be greater than the VPATH index. */
1642 unsigned int vpath_index = ~((unsigned int)0) - std_dirs;
1644 for (dp = dirs; *dp != 0; ++dp)
1646 sprintf (buf, "%s/%s", *dp, libbuf);
1647 mtime = name_mtime (buf);
1648 if (mtime != NONEXISTENT_MTIME)
1650 if (file == 0 || vpath_index < best_vpath)
1652 file = strcache_add (buf);
1653 best_vpath = vpath_index;
1655 if (mtime_ptr != 0)
1656 *mtime_ptr = mtime;
1660 vpath_index++;
1666 free (libpatterns);
1667 return file;