1 /* Basic dependency engine for GNU Make.
2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 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
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 extern int try_implicit_rule ();
35 /* Incremented when a command is started (under -n, when one would be). */
36 unsigned int commands_started
= 0;
38 static int update_file (), update_file_1 (), check_dep (), touch_file ();
39 static void remake_file ();
40 static time_t name_mtime ();
41 static int library_search ();
42 extern time_t f_mtime ();
44 /* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing
45 was done, 0 if all goals were updated successfully, or 1 if a goal failed.
46 If MAKEFILES is nonzero, these goals are makefiles, so -t, -q, and -n should
47 be disabled for them unless they were also command-line targets, and we
48 should only make one goal at a time and return as soon as one goal whose
49 `changed' member is nonzero is successfully made. */
52 update_goal_chain (goals
, makefiles
)
53 register struct dep
*goals
;
56 int t
= touch_flag
, q
= question_flag
, n
= just_print_flag
;
57 unsigned int j
= job_slots
;
60 #define MTIME(file) (makefiles ? file_mtime_no_search (file) \
63 /* Duplicate the chain so we can remove things from it. */
65 goals
= copy_dep_chain (goals
);
68 /* Clear the `changed' flag of each goal in the chain.
69 We will use the flag below to notice when any commands
70 have actually been run for a target. When no commands
71 have been run, we give an "up to date" diagnostic. */
74 for (g
= goals
; g
!= 0; g
= g
->next
)
79 /* Only run one job at a time. */
82 /* Update all the goals until they are all finished. */
86 register struct dep
*g
, *lastgoal
;
88 /* Start jobs that are waiting for the load to go down. */
90 start_waiting_jobs ();
92 /* Wait for a child to die. */
100 /* Iterate over all double-colon entries for this file. */
101 struct file
*file
= g
->file
;
102 int stop
, any_not_updated
= 0;
103 for (file
= g
->file
->double_colon
? g
->file
->double_colon
: g
->file
;
107 unsigned int ocommands_started
;
109 time_t mtime
= MTIME (file
);
110 check_renamed (file
);
114 if (file
->cmd_target
)
121 touch_flag
= question_flag
= just_print_flag
= 0;
124 /* Save the old value of `commands_started' so we can compare
125 later. It will be incremented when any commands are
127 ocommands_started
= commands_started
;
129 x
= update_file (file
, makefiles
? 1 : 0);
130 check_renamed (file
);
132 /* Set the goal's `changed' flag if any commands were started
133 by calling update_file above. We check this flag below to
134 decide when to give an "up to date" diagnostic. */
135 g
->changed
+= commands_started
- ocommands_started
;
138 if (x
!= 0 || file
->updated
)
140 /* If STATUS was not already 1, set it to 1 if
141 updating failed, or to 0 if updating succeeded.
142 Leave STATUS as it is if no updating was done. */
146 if (file
->update_status
!= 0)
148 /* Updating failed, or -q triggered.
149 The STATUS value tells our caller which. */
150 status
= file
->update_status
;
151 /* If -q just triggered, stop immediately.
152 It doesn't matter how much more we run,
153 since we already know the answer to return. */
154 stop
= (!keep_going_flag
&& !question_flag
157 else if (MTIME (file
) != mtime
)
159 /* Updating was done. If this is a makefile and
160 just_print_flag or question_flag is set
161 (meaning -n or -q was given and this file was
162 specified as a command-line target), don't
163 change STATUS. If STATUS is changed, we will
164 get re-exec'd, and fall into an infinite loop. */
166 || (!just_print_flag
&& !question_flag
))
168 if (makefiles
&& file
->dontcare
)
169 /* This is a default makefile. Stop remaking. */
175 /* Keep track if any double-colon entry is not finished.
176 When they are all finished, the goal is finished. */
177 any_not_updated
|= !file
->updated
;
183 /* Reset FILE since it is null at the end of the loop. */
186 if (stop
|| !any_not_updated
)
188 /* If we have found nothing whatever to do for the goal,
189 print a message saying nothing needs doing. */
192 /* If the update_status is zero, we updated successfully
193 or not at all. G->changed will have been set above if
194 any commands were actually started for this goal. */
195 && file
->update_status
== 0 && !g
->changed
196 /* Never give a message under -s or -q. */
197 && !silent_flag
&& !question_flag
)
199 if (file
->phony
|| file
->cmds
== 0)
200 message ("Nothing to be done for `%s'.",
203 message ("`%s' is up to date.", file
->name
);
207 /* This goal is finished. Remove it from the chain. */
211 lastgoal
->next
= g
->next
;
213 /* Free the storage. */
216 g
= lastgoal
== 0 ? goals
: lastgoal
->next
;
240 /* If FILE is not up to date, execute the commands for it.
241 Return 0 if successful, 1 if unsuccessful;
242 but with some flag settings, just call `exit' if unsuccessful.
244 DEPTH is the depth in recursions of this function.
245 We increment it during the consideration of our dependencies,
246 then decrement it again after finding out whether this file
249 If there are multiple double-colon entries for FILE,
250 each is considered in turn. */
253 update_file (file
, depth
)
257 register int status
= 0;
258 register struct file
*f
;
260 for (f
= file
->double_colon
? file
->double_colon
: file
; f
!= 0; f
= f
->prev
)
262 status
|= update_file_1 (f
, depth
);
265 if (status
!= 0 && !keep_going_flag
)
268 switch (f
->command_state
)
271 /* The file is done being remade. */
275 case cs_deps_running
:
276 /* Don't run the other :: rules for this
277 file until this rule is finished. */
281 assert (f
->command_state
== cs_running
);
289 /* Consider a single `struct file' and update it as appropriate. */
292 update_file_1 (file
, depth
)
296 register time_t this_mtime
;
297 int noexist
, must_make
, deps_changed
;
299 register struct dep
*d
, *lastd
;
302 DEBUGPR ("Considering target file `%s'.\n");
306 if (file
->update_status
> 0)
308 DEBUGPR ("Recently tried and failed to update file `%s'.\n");
309 return file
->update_status
;
312 DEBUGPR ("File `%s' was considered already.\n");
316 switch (file
->command_state
)
319 case cs_deps_running
:
322 DEBUGPR ("Still updating file `%s'.\n");
325 DEBUGPR ("Finished updating file `%s'.\n");
326 return file
->update_status
;
333 /* Notice recursive update of the same file. */
336 /* Looking at the file's modtime beforehand allows the possibility
337 that its name may be changed by a VPATH search, and thus it may
338 not need an implicit rule. If this were not done, the file
339 might get implicit commands that apply to its initial name, only
340 to have that name replaced with another found by VPATH search. */
342 this_mtime
= file_mtime (file
);
343 check_renamed (file
);
344 noexist
= this_mtime
== (time_t) -1;
346 DEBUGPR ("File `%s' does not exist.\n");
350 /* If file was specified as a target with no commands,
351 come up with some default commands. */
353 if (!file
->phony
&& file
->cmds
== 0 && !file
->tried_implicit
)
355 if (try_implicit_rule (file
, depth
))
356 DEBUGPR ("Found an implicit rule for `%s'.\n");
358 DEBUGPR ("No implicit rule found for `%s'.\n");
359 file
->tried_implicit
= 1;
361 if (file
->cmds
== 0 && !file
->is_target
362 && default_file
!= 0 && default_file
->cmds
!= 0)
364 DEBUGPR ("Using default commands for `%s'.\n");
365 file
->cmds
= default_file
->cmds
;
368 /* Update all non-intermediate files we depend on, if necessary,
369 and see whether any of them is more recent than this file. */
377 check_renamed (d
->file
);
379 mtime
= file_mtime (d
->file
);
380 check_renamed (d
->file
);
382 if (d
->file
->updating
)
384 error ("Circular %s <- %s dependency dropped.",
385 file
->name
, d
->file
->name
);
388 file
->deps
= d
->next
;
394 lastd
->next
= d
->next
;
401 d
->file
->parent
= file
;
402 dep_status
|= check_dep (d
->file
, depth
, this_mtime
, &must_make
);
403 check_renamed (d
->file
);
406 register struct file
*f
= d
->file
;
411 running
|= (f
->command_state
== cs_running
412 || f
->command_state
== cs_deps_running
);
418 if (dep_status
!= 0 && !keep_going_flag
)
422 d
->changed
= file_mtime (d
->file
) != mtime
;
428 /* Now we know whether this target needs updating.
429 If it does, update all the intermediate files we depend on. */
433 for (d
= file
->deps
; d
!= 0; d
= d
->next
)
434 if (d
->file
->intermediate
)
436 time_t mtime
= file_mtime (d
->file
);
437 check_renamed (d
->file
);
438 d
->file
->parent
= file
;
439 dep_status
|= update_file (d
->file
, depth
);
440 check_renamed (d
->file
);
443 register struct file
*f
= d
->file
;
448 running
|= (f
->command_state
== cs_running
449 || f
->command_state
== cs_deps_running
);
455 if (dep_status
!= 0 && !keep_going_flag
)
459 d
->changed
= ((file
->phony
&& file
->cmds
!= 0)
460 || file_mtime (d
->file
) != mtime
);
466 DEBUGPR ("Finished dependencies of target file `%s'.\n");
470 set_command_state (file
, cs_deps_running
);
472 DEBUGPR ("The dependencies of `%s' are being made.\n");
476 /* If any dependency failed, give up now. */
480 file
->update_status
= dep_status
;
481 notice_finished_file (file
);
485 DEBUGPR ("Giving up on target file `%s'.\n");
487 if (depth
== 0 && keep_going_flag
488 && !just_print_flag
&& !question_flag
)
489 error ("Target `%s' not remade because of errors.", file
->name
);
494 if (file
->command_state
== cs_deps_running
)
495 /* The commands for some deps were running on the last iteration, but
496 they have finished now. Reset the command_state to not_started to
497 simplify later bookkeeping. It is important that we do this only
498 when the prior state was cs_deps_running, because that prior state
499 was definitely propagated to FILE's also_make's by set_command_state
500 (called above), but in another state an also_make may have
501 independently changed to finished state, and we would confuse that
502 file's bookkeeping (updated, but not_started is bogus state). */
503 set_command_state (file
, cs_not_started
);
505 /* Now record which dependencies are more
506 recent than this file, so we can define $?. */
509 for (d
= file
->deps
; d
!= 0; d
= d
->next
)
511 time_t d_mtime
= file_mtime (d
->file
);
512 check_renamed (d
->file
);
514 #if 1 /* %%% In version 4, remove this code completely to
515 implement not remaking deps if their deps are newer
516 than their parents. */
517 if (d_mtime
== (time_t) -1 && !d
->file
->intermediate
)
518 /* We must remake if this dep does not
519 exist and is not intermediate. */
523 /* Set DEPS_CHANGED if this dep actually changed. */
524 deps_changed
|= d
->changed
;
526 /* Set D->changed if either this dep actually changed,
527 or its dependent, FILE, is older or does not exist. */
528 d
->changed
|= noexist
|| d_mtime
> this_mtime
;
530 if (debug_flag
&& !noexist
)
532 print_spaces (depth
);
533 if (d_mtime
== (time_t) -1)
534 printf ("Dependency `%s' does not exist.\n", dep_name (d
));
536 printf ("Dependency `%s' is %s than dependent `%s'.\n",
537 dep_name (d
), d
->changed
? "newer" : "older", file
->name
);
542 /* Here depth returns to the value it had when we were called. */
545 if (file
->double_colon
&& file
->deps
== 0)
548 DEBUGPR ("Target `%s' is double-colon and has no dependencies.\n");
550 else if (!noexist
&& file
->is_target
&& !deps_changed
&& file
->cmds
== 0)
553 DEBUGPR ("No commands for `%s' and no dependencies actually changed.\n");
558 DEBUGPR ("No need to remake target `%s'.\n");
559 notice_finished_file (file
);
563 DEBUGPR ("Must remake target `%s'.\n");
565 /* Now, take appropriate actions to remake the file. */
568 if (file
->command_state
!= cs_finished
)
570 DEBUGPR ("Commands of `%s' are being run.\n");
574 switch (file
->update_status
)
577 DEBUGPR ("Failed to remake target file `%s'.\n");
580 DEBUGPR ("Successfully remade target file `%s'.\n");
583 DEBUGPR ("Target file `%s' needs remade under -q.\n");
586 assert (file
->update_status
>= 0 && file
->update_status
<= 2);
591 return file
->update_status
;
594 /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all
595 files listed in its `also_make' member. Under -t, this function also
599 notice_finished_file (file
)
600 register struct file
*file
;
603 int ran
= file
->command_state
== cs_running
;
605 file
->command_state
= cs_finished
;
609 /* The update status will be:
610 -1 if this target was not remade;
611 0 if 0 or more commands (+ or ${MAKE}) were run and won;
612 1 if some commands were run and lost.
613 We touch the target if it has commands which either were not run
614 or won when they ran (i.e. status is 0). */
615 && file
->update_status
== 0)
617 if (file
->cmds
!= 0 && file
->cmds
->any_recurse
)
619 /* If all the command lines were recursive,
620 we don't want to do the touching. */
622 for (i
= 0; i
< file
->cmds
->ncommand_lines
; ++i
)
623 if (!(file
->cmds
->lines_flags
[i
] & COMMANDS_RECURSE
))
624 goto have_nonrecursing
;
630 file
->update_status
= 0;
632 /* Should set file's modification date and do nothing else. */
633 file
->update_status
= touch_file (file
);
637 if (ran
&& !file
->phony
)
641 if (just_print_flag
|| question_flag
642 || (file
->is_target
&& file
->cmds
== 0))
643 file
->last_mtime
= NEW_MTIME
;
645 file
->last_mtime
= 0;
647 /* Propagate the change of modification time to all the double-colon
648 entries for this file. */
649 for (f
= file
->double_colon
; f
!= 0; f
= f
->next
)
650 f
->last_mtime
= file
->last_mtime
;
653 if (ran
&& file
->update_status
!= -1)
654 /* We actually tried to update FILE, which has
655 updated its also_make's as well (if it worked).
656 If it didn't work, it wouldn't work again for them.
657 So mark them as updated with the same status. */
658 for (d
= file
->also_make
; d
!= 0; d
= d
->next
)
660 d
->file
->command_state
= cs_finished
;
661 d
->file
->updated
= 1;
662 d
->file
->update_status
= file
->update_status
;
664 if (ran
&& !d
->file
->phony
)
665 /* Fetch the new modification time.
666 We do this instead of just invalidating the cached time
667 so that a vpath_search can happen. Otherwise, it would
668 never be done because the target is already updated. */
669 (void) f_mtime (d
->file
, 0);
673 /* Check whether another file (whose mtime is THIS_MTIME)
674 needs updating on account of a dependency which is file FILE.
675 If it does, store 1 in *MUST_MAKE_PTR.
676 In the process, update any non-intermediate files
677 that FILE depends on (including FILE itself).
678 Return nonzero if any updating failed. */
681 check_dep (file
, depth
, this_mtime
, must_make_ptr
)
687 register struct dep
*d
;
693 if (!file
->intermediate
)
694 /* If this is a non-intermediate file, update it and record
695 whether it is newer than THIS_MTIME. */
698 dep_status
= update_file (file
, depth
);
699 check_renamed (file
);
700 mtime
= file_mtime (file
);
701 check_renamed (file
);
702 if (mtime
== (time_t) -1 || mtime
> this_mtime
)
707 /* FILE is an intermediate file.
708 Update all non-intermediate files we depend on, if necessary,
709 and see whether any of them is more recent than the file
710 on whose behalf we are checking. */
711 register struct dep
*lastd
;
716 if (d
->file
->updating
)
718 error ("Circular %s <- %s dependency dropped.",
719 file
->name
, d
->file
->name
);
722 file
->deps
= d
->next
;
728 lastd
->next
= d
->next
;
735 d
->file
->parent
= file
;
736 dep_status
|= check_dep (d
->file
, depth
, this_mtime
, must_make_ptr
);
737 check_renamed (d
->file
);
738 if (dep_status
!= 0 && !keep_going_flag
)
741 if (d
->file
->command_state
== cs_running
742 || d
->file
->command_state
== cs_deps_running
)
743 /* Record that some of FILE's dependencies are still being made.
744 This tells the upper levels to wait on processing it until
745 the commands are finished. */
746 set_command_state (file
, cs_deps_running
);
757 /* Touch FILE. Return zero if successful, one if not. */
759 #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
763 register struct file
*file
;
767 printf ("touch %s\n", file
->name
);
772 if (ar_name (file
->name
))
773 return ar_touch (file
->name
);
777 int fd
= open (file
->name
, O_RDWR
| O_CREAT
, 0666);
780 TOUCH_ERROR ("touch: open: ");
790 status
= fstat (fd
, &statbuf
);
792 while (status
< 0 && errno
== EINTR
);
795 TOUCH_ERROR ("touch: fstat: ");
796 /* Rewrite character 0 same as it already is. */
797 if (read (fd
, &buf
, 1) < 0)
798 TOUCH_ERROR ("touch: read: ");
799 if (lseek (fd
, 0L, 0) < 0L)
800 TOUCH_ERROR ("touch: lseek: ");
801 if (write (fd
, &buf
, 1) < 0)
802 TOUCH_ERROR ("touch: write: ");
803 /* If file length was 0, we just
804 changed it, so change it back. */
805 if (statbuf
.st_size
== 0)
808 fd
= open (file
->name
, O_RDWR
| O_TRUNC
, 0666);
810 TOUCH_ERROR ("touch: open: ");
819 /* Having checked and updated the dependencies of FILE,
820 do whatever is appropriate to remake FILE itself.
821 Return the status from executing FILE's commands. */
830 /* Phony target. Pretend it succeeded. */
831 file
->update_status
= 0;
832 else if (file
->is_target
)
833 /* This is a nonexistent target file we cannot make.
834 Pretend it was successfully remade. */
835 file
->update_status
= 0;
838 /* This is a dependency file we cannot remake. Fail. */
839 static const char msg_noparent
[]
840 = "%sNo rule to make target `%s'%s";
841 static const char msg_parent
[]
842 = "%sNo rule to make target `%s', needed by `%s'%s";
843 if (keep_going_flag
|| file
->dontcare
)
847 if (file
->parent
== 0)
848 error (msg_noparent
, "*** ", file
->name
, ".");
850 error (msg_parent
, "*** ",
851 file
->name
, file
->parent
->name
, ".");
853 file
->update_status
= 2;
857 if (file
->parent
== 0)
858 fatal (msg_noparent
, "", file
->name
, "");
860 fatal (msg_parent
, "", file
->name
, file
->parent
->name
, "");
866 chop_commands (file
->cmds
);
868 if (!touch_flag
|| file
->cmds
->any_recurse
)
870 execute_file_commands (file
);
874 /* This tells notice_finished_file it is ok to touch the file. */
875 file
->update_status
= 0;
878 /* This does the touching under -t. */
879 notice_finished_file (file
);
882 /* Return the mtime of a file, given a `struct file'.
883 Caches the time in the struct file to avoid excess stat calls.
885 If the file is not found, and SEARCH is nonzero, VPATH searching and
886 replacement is done. If that fails, a library (-lLIBNAME) is tried and
887 the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into
891 f_mtime (file
, search
)
892 register struct file
*file
;
897 /* File's mtime is not known; must get it from the system. */
900 if (ar_name (file
->name
))
902 /* This file is an archive-member reference. */
904 char *arname
, *memname
;
908 /* Find the archive's name. */
909 ar_parse_name (file
->name
, &arname
, &memname
);
911 /* Find the modification time of the archive itself.
912 Also allow for its name to be changed via VPATH search. */
913 arfile
= lookup_file (arname
);
916 arfile
= enter_file (arname
);
919 mtime
= f_mtime (arfile
, search
);
920 check_renamed (arfile
);
921 if (search
&& strcmp (arfile
->name
, arname
))
923 /* The archive's name has changed.
924 Change the archive-member reference accordingly. */
926 unsigned int arlen
, memlen
;
934 arname
= arfile
->name
;
935 arlen
= strlen (arname
);
936 memlen
= strlen (memname
);
940 file
->name
= (char *) xmalloc (arlen
+ 1 + memlen
+ 2);
941 bcopy (arname
, file
->name
, arlen
);
942 file
->name
[arlen
] = '(';
943 bcopy (memname
, file
->name
+ arlen
+ 1, memlen
);
944 file
->name
[arlen
+ 1 + memlen
] = ')';
945 file
->name
[arlen
+ 1 + memlen
+ 1] = '\0';
952 if (mtime
== (time_t) -1)
953 /* The archive doesn't exist, so it's members don't exist either. */
956 mtime
= ar_member_date (file
->name
);
961 mtime
= name_mtime (file
->name
);
963 if (mtime
== (time_t) -1 && search
)
965 /* If name_mtime failed, search VPATH. */
966 char *name
= file
->name
;
967 if (vpath_search (&name
, &mtime
)
968 /* Last resort, is it a library (-lxxx)? */
969 || (name
[0] == '-' && name
[1] == 'l'
970 && library_search (&name
, &mtime
)))
973 /* vpath_search and library_search store zero in MTIME
974 if they didn't need to do a stat call for their work. */
975 file
->last_mtime
= mtime
;
976 rename_file (file
, name
);
977 check_renamed (file
);
978 return file_mtime (file
);
983 /* Store the mtime into all the entries for this file. */
984 if (file
->double_colon
)
985 file
= file
->double_colon
;
988 file
->last_mtime
= mtime
;
996 /* Return the mtime of the file or archive-member reference NAME. */
1000 register char *name
;
1004 if (safe_stat (name
, &st
) < 0)
1007 return (time_t) st
.st_mtime
;
1011 /* Search for a library file specified as -lLIBNAME, searching for a
1012 suitable library file in the system library directories and the VPATH
1016 library_search (lib
, mtime_ptr
)
1020 static char *dirs
[] =
1024 LIBDIR
, /* Defined by configuration. */
1028 char *libname
= &(*lib
)[2]; /* Name without the `-l'. */
1031 /* Buffer to construct possible names in. */
1032 char *buf
= xmalloc (sizeof (LIBDIR
) + 8 + strlen (libname
) + 4 + 2 + 1);
1035 /* Look first for `libNAME.a' in the current directory. */
1037 sprintf (buf
, "lib%s.a", libname
);
1038 mtime
= name_mtime (buf
);
1039 if (mtime
!= (time_t) -1)
1047 /* Now try VPATH search on that. */
1050 if (vpath_search (&file
, mtime_ptr
))
1057 /* Now try the standard set of directories. */
1059 for (dp
= dirs
; *dp
!= 0; ++dp
)
1061 sprintf (buf
, "%s/lib%s.a", *dp
, libname
);
1062 mtime
= name_mtime (buf
);
1063 if (mtime
!= (time_t) -1)