diff options
| -rw-r--r-- | remake.c | 907 |
1 files changed, 907 insertions, 0 deletions
diff --git a/remake.c b/remake.c new file mode 100644 index 0000000..f616342 --- /dev/null +++ b/remake.c @@ -0,0 +1,907 @@ +/* Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "make.h" +#include "commands.h" +#include "job.h" +#include "dep.h" +#include "file.h" + +#if !defined (USG) && !defined (POSIX) +#ifndef sgi +#include <sys/file.h> +#endif +#else +#include <fcntl.h> +#endif + + +#if !defined(__GNU_LIBRARY__) && !defined(POSIX) +extern int fstat (); +extern time_t time (); +#endif + +extern int try_implicit_rule (); + + +/* Incremented when a file has been remade. */ +static unsigned int files_remade = 0; + +static int update_file (), update_file_1 (), check_dep (); +static void remake_file (); +static time_t name_mtime (), library_file_mtime (); +extern time_t f_mtime (); + +/* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing + was done, 0 if all goals were updated successfully, or 1 if a goal failed. + If MAKEFILES is nonzero, these goals are makefiles, so -t, -q, and -n should + be disabled for them unless they were also command-line targets, and we + should only make one goal at a time and return as soon as one goal whose + `changed' member is nonzero is successfully made. */ + +int +update_goal_chain (goals, makefiles) + register struct dep *goals; + int makefiles; +{ + int t = touch_flag, q = question_flag, n = just_print_flag; + unsigned int j = job_slots; + int status = -1; + +#define MTIME(file) (makefiles ? file_mtime_no_search (file) \ + : file_mtime (file)) + + /* Duplicate the chain so we can remove things from it. */ + + goals = copy_dep_chain (goals); + + if (makefiles) + /* Only run one job at a time. */ + job_slots = 1; + + /* Update all the goals until they are all finished. */ + + while (goals != 0) + { + register struct dep *g, *lastgoal; + + /* Wait for a child to die. */ + + wait_for_children (1, 0); + + lastgoal = 0; + g = goals; + while (g != 0) + { + int x; + time_t mtime = MTIME (g->file); + check_renamed (g->file); + + if (makefiles) + { + if (g->file->cmd_target) + { + touch_flag = t; + question_flag = q; + just_print_flag = n; + } + else + touch_flag = question_flag = just_print_flag = 0; + } + + x = update_file (g->file, makefiles ? 1 : 0); + check_renamed (g->file); + if (x != 0 || g->file->updated) + { + int stop = 0; + /* If STATUS was not already 1, set it to 1 if + updating failed, or to 0 if updating succeeded. + Leave STATUS as it is if no updating was done. */ + if (status < 1) + { + if (g->file->update_status != 0) + { + /* Updating failed. */ + status = 1; + stop = !keep_going_flag && !makefiles; + } + else if (MTIME (g->file) != mtime) + { + /* Updating was done. + If this is a makefile and just_print_flag or + question_flag is set (meaning -n or -q was given + and this file was specified as a command-line target), + don't change STATUS. If STATUS is changed, we will + get re-exec'd, and fall into an infinite loop. */ + if (!makefiles || (!just_print_flag && !question_flag)) + status = 0; + if (makefiles && g->file->dontcare) + /* This is a default makefile. Stop remaking. */ + stop = 1; + } + } + + g->file = g->file->prev; + if (stop || g->file == 0) + { + /* This goal is finished. Remove it from the chain. */ + if (lastgoal == 0) + goals = g->next; + else + lastgoal->next = g->next; + + /* Free the storage. */ + free ((char *) g); + + g = lastgoal == 0 ? goals : lastgoal->next; + } + + if (stop) + break; + } + else + { + lastgoal = g; + g = g->next; + } + } + } + + if (makefiles) + { + touch_flag = t; + question_flag = q; + just_print_flag = n; + job_slots = j; + } + + return status; +} + +/* If FILE is not up to date, execute the commands for it. + Return 0 if successful, 1 if unsuccessful; + but with some flag settings, just call `exit' if unsuccessful. + + DEPTH is the depth in recursions of this function. + We increment it during the consideration of our dependencies, + then decrement it again after finding out whether this file + is out of date. + + If there are multiple double-colon entries for FILE, + each is considered in turn. */ + +static int +update_file (file, depth) + struct file *file; + unsigned int depth; +{ + register int status = 0; + register struct file *f; + unsigned int ofiles_remade = files_remade; + int commands_finished = 0; + + for (f = file; f != 0; f = f->prev) + { + register struct dep *d; + char not_started = f->command_state == cs_not_started; + + status |= update_file_1 (f, depth); + check_renamed (f); + + for (d = f->also_make; d != 0; d = d->next) + { + d->file->command_state = f->command_state; + d->file->update_status = f->update_status; + d->file->updated = f->updated; + } + + if (status != 0 && !keep_going_flag) + return status; + + commands_finished |= not_started && f->command_state == cs_finished; + } + + /* For a top level target, if we have found nothing whatever to do for it, + print a message saying nothing needs doing. */ + + if (status == 0 && files_remade == ofiles_remade + && commands_finished && depth == 0 && !silent_flag && !question_flag) + { + if (file->phony || file->cmds == 0) + message ("Nothing to be done for `%s'.", file->name); + else + message ("`%s' is up to date.", file->name); + fflush (stdout); + } + + return status; +} + +/* Consider a single `struct file' and update it as appropriate. */ + +static int +update_file_1 (file, depth) + struct file *file; + unsigned int depth; +{ + register time_t this_mtime; + int noexist, must_make, deps_changed; + int dep_status = 0; + register struct dep *d, *lastd; + char running = 0; + + DEBUGPR ("Considering target file `%s'.\n"); + + if (file->updated) + { + if (file->update_status > 0) + { + DEBUGPR ("Recently tried and failed to update file `%s'.\n"); + return file->update_status; + } + + DEBUGPR ("File `%s' was considered already.\n"); + return 0; + } + + switch (file->command_state) + { + case cs_not_started: + case cs_deps_running: + break; + case cs_running: + DEBUGPR ("Still updating file `%s'.\n"); + return 0; + case cs_finished: + DEBUGPR ("Finished updating file `%s'.\n"); + return file->update_status; + default: + abort (); + } + + ++depth; + + /* Notice recursive update of the same file. */ + file->updating = 1; + + /* Looking at the file's modtime beforehand allows the possibility + that its name may be changed by a VPATH search, and thus it may + not need an implicit rule. If this were not done, the file + might get implicit commands that apply to its initial name, only + to have that name replaced with another found by VPATH search. */ + + this_mtime = file_mtime (file); + check_renamed (file); + noexist = this_mtime == (time_t) -1; + if (noexist) + DEBUGPR ("File `%s' does not exist.\n"); + + must_make = noexist; + + /* If file was specified as a target with no commands, + come up with some default commands. */ + + if (!file->phony && file->cmds == 0 && !file->tried_implicit) + { + if (try_implicit_rule (file, depth)) + DEBUGPR ("Found an implicit rule for `%s'.\n"); + else + { + DEBUGPR ("No implicit rule found for `%s'.\n"); + if (default_file != 0 && default_file->cmds != 0) + { + DEBUGPR ("Using default commands for `%s'.\n"); + file->cmds = default_file->cmds; + } + } + file->tried_implicit = 1; + } + + /* Update all non-intermediate files we depend on, if necessary, + and see whether any of them is more recent than this file. */ + + lastd = 0; + d = file->deps; + while (d != 0) + { + time_t mtime; + + mtime = file_mtime (d->file); + check_renamed (d->file); + + if (d->file->updating) + { + error ("Circular %s <- %s dependency dropped.", + file->name, d->file->name); + if (lastd == 0) + { + file->deps = d->next; + free ((char *) d); + d = file->deps; + } + else + { + lastd->next = d->next; + free ((char *) d); + d = lastd->next; + } + continue; + } + + d->file->parent = file; + dep_status |= check_dep (d->file, depth, this_mtime, &must_make); + check_renamed (d->file); + + { + register struct file *f = d->file; + do + { + running |= (f->command_state == cs_running + || f->command_state == cs_deps_running); + f = f->prev; + } + while (f != 0); + } + + if (dep_status != 0 && !keep_going_flag) + break; + + if (!running) + d->changed = file_mtime (d->file) != mtime; + + lastd = d; + d = d->next; + } + + /* Now we know whether this target needs updating. + If it does, update all the intermediate files we depend on. */ + + if (must_make) + { + for (d = file->deps; d != 0; d = d->next) + if (d->file->intermediate) + { + time_t mtime = file_mtime (d->file); + check_renamed (d->file); + d->file->parent = file; + dep_status |= update_file (d->file, depth); + check_renamed (d->file); + + { + register struct file *f = d->file; + do + { + running |= (f->command_state == cs_running + || f->command_state == cs_deps_running); + f = f->prev; + } + while (f != 0); + } + + if (dep_status != 0 && !keep_going_flag) + break; + + if (!running) + d->changed = ((file->phony && file->cmds != 0) + || file_mtime (d->file) != mtime); + } + } + + file->updating = 0; + + DEBUGPR ("Finished dependencies of target file `%s'.\n"); + + if (running) + { + file->command_state = cs_deps_running; + --depth; + DEBUGPR ("The dependencies of `%s' are being made.\n"); + return 0; + } + + /* If any dependency failed, give up now. */ + + if (dep_status != 0) + { + file->command_state = cs_finished; + file->update_status = dep_status; + file->updated = 1; + + depth--; + + DEBUGPR ("Giving up on target file `%s'.\n"); + + if (depth == 0 && keep_going_flag + && !just_print_flag && !question_flag) + error ("Target `%s' not remade because of errors.", file->name); + + return dep_status; + } + + file->command_state = cs_not_started; + + /* Now record which dependencies are more + recent than this file, so we can define $?. */ + + deps_changed = 0; + for (d = file->deps; d != 0; d = d->next) + { + time_t d_mtime = file_mtime (d->file); + check_renamed (d->file); + +#if 1 /* %%% In version 4, remove this code completely to + implement not remaking deps if their deps are newer + than their parents. */ + if (d_mtime == (time_t) -1 && !d->file->intermediate) + /* We must remake if this dep does not + exist and is not intermediate. */ + must_make = 1; +#endif + + /* Set DEPS_CHANGED if this dep actually changed. */ + deps_changed |= d->changed; + + /* Set D->changed if either this dep actually changed, + or its dependent, FILE, is older or does not exist. */ + d->changed |= noexist || d_mtime > this_mtime; + + if (debug_flag && !noexist) + { + print_spaces (depth); + if (d_mtime == (time_t) -1) + printf ("Dependency `%s' does not exist.\n", dep_name (d)); + else + printf ("Dependency `%s' is %s than dependent `%s'.\n", + dep_name (d), d->changed ? "newer" : "older", file->name); + fflush (stdout); + } + } + + /* Here depth returns to the value it had when we were called. */ + depth--; + + if (file->double_colon && file->deps == 0) + { + must_make = 1; + DEBUGPR ("Target `%s' is double-colon and has no dependencies.\n"); + } + else if (file->is_target && !deps_changed && file->cmds == 0) + { + must_make = 0; + DEBUGPR ("No commands for `%s' and no dependencies actually changed.\n"); + } + + if (!must_make) + { + DEBUGPR ("No need to remake target `%s'.\n"); + file->command_state = cs_finished; + file->update_status = 0; + file->updated = 1; + return 0; + } + + DEBUGPR ("Must remake target `%s'.\n"); + + /* Now, take appropriate actions to remake the file. */ + remake_file (file); + + if (file->command_state != cs_finished) + { + DEBUGPR ("Commands of `%s' are being run.\n"); + return 0; + } + + switch (file->update_status) + { + case 1: + DEBUGPR ("Failed to remake target file `%s'.\n"); + break; + case 0: + DEBUGPR ("Successfully remade target file `%s'.\n"); + break; + case -1: + error ("internal error: `%s' update_status is -1 at cs_finished!", + file->name); + abort (); + default: + error ("internal error: `%s' update_status invalid!", file->name); + abort (); + } + + file->updated = 1; + return file->update_status; +} + +/* Set FILE's `updated' flag and re-check its mtime and the mtime's + of all files listed in its `also_make' member. */ + +void +notice_finished_file (file) + register struct file *file; +{ + struct dep *d; + + file->command_state = cs_finished; + file->updated = 1; + + ++files_remade; + + if (!file->phony) + { + if (just_print_flag || question_flag + || (file->is_target && file->cmds == 0)) + file->last_mtime = time ((time_t *) 0); + else + file->last_mtime = 0; + } + + for (d = file->also_make; d != 0; d = d->next) + { + d->file->command_state = cs_finished; + d->file->updated = 1; + d->file->update_status = file->update_status; + if (just_print_flag || question_flag) + d->file->last_mtime = file->last_mtime; + else + d->file->last_mtime = 0; + } +} + +/* Check whether another file (whose mtime is THIS_MTIME) + needs updating on account of a dependency which is file FILE. + If it does, store 1 in *MUST_MAKE_PTR. + In the process, update any non-intermediate files + that FILE depends on (including FILE itself). + Return nonzero if any updating failed. */ + +static int +check_dep (file, depth, this_mtime, must_make_ptr) + struct file *file; + unsigned int depth; + time_t this_mtime; + int *must_make_ptr; +{ + register struct dep *d; + int dep_status = 0; + + ++depth; + file->updating = 1; + + if (!file->intermediate) + /* If this is a non-intermediate file, update it and record + whether it is newer than THIS_MTIME. */ + { + time_t mtime; + dep_status = update_file (file, depth); + check_renamed (file); + mtime = file_mtime (file); + check_renamed (file); + if (mtime == (time_t) -1 || mtime > this_mtime) + *must_make_ptr = 1; + } + else + { + /* FILE is an intermediate file. + Update all non-intermediate files we depend on, if necessary, + and see whether any of them is more recent than the file + on whose behalf we are checking. */ + register struct dep *lastd; + lastd = 0; + d = file->deps; + while (d != 0) + { + if (d->file->updating) + { + error ("Circular %s <- %s dependency dropped.", + file->name, d->file->name); + if (lastd == 0) + { + file->deps = d->next; + free ((char *) d); + d = file->deps; + } + else + { + lastd->next = d->next; + free ((char *) d); + d = lastd->next; + } + continue; + } + + d->file->parent = file; + dep_status |= check_dep (d->file, depth, this_mtime, must_make_ptr); + check_renamed (d->file); + if (dep_status != 0 && !keep_going_flag) + break; + + lastd = d; + d = d->next; + } + } + + file->updating = 0; + return dep_status; +} + +/* Touch FILE. Return zero if successful, nonzero if not. */ + +#define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1) + +static int +touch_file (file) + register struct file *file; +{ + if (!silent_flag) + { + printf ("touch %s\n", file->name); + fflush (stdout); + } + +#ifndef NO_ARCHIVES + if (ar_name (file->name)) + return ar_touch (file->name); + else +#endif + { + int fd = open (file->name, O_RDWR | O_CREAT, 0666); + + if (fd < 0) + TOUCH_ERROR ("touch: open: "); + else + { + struct stat statbuf; + char buf; + + if (fstat (fd, &statbuf) < 0) + TOUCH_ERROR ("touch: fstat: "); + /* Rewrite character 0 same as it already is. */ + if (read (fd, &buf, 1) < 0) + TOUCH_ERROR ("touch: read: "); + if (lseek (fd, 0L, 0) < 0L) + TOUCH_ERROR ("touch: lseek: "); + if (write (fd, &buf, 1) < 0) + TOUCH_ERROR ("touch: write: "); + /* If file length was 0, we just + changed it, so change it back. */ + if (statbuf.st_size == 0) + { + (void) close (fd); + fd = open (file->name, O_RDWR | O_TRUNC, 0666); + if (fd < 0) + TOUCH_ERROR ("touch: open: "); + } + (void) close (fd); + } + } + + return 0; +} + +/* Having checked and updated the dependencies of FILE, + do whatever is appropriate to remake FILE itself. + Return the status from executing FILE's commands. */ + +static void +remake_file (file) + struct file *file; +{ + if (file->cmds == 0) + { + if (file->phony) + /* Phony target. Pretend it succeeded. */ + file->update_status = 0; + else if (file->is_target) + /* This is a nonexistent target file we cannot make. + Pretend it was successfully remade. */ + file->update_status = 0; + else + { + /* This is a dependency file we cannot remake. Fail. */ + static char noway[] = "*** No way to make target"; + if (keep_going_flag || file->dontcare) + { + if (!file->dontcare) + error ("%s `%s'.", noway, file->name); + file->update_status = 1; + } + else + fatal ("%s `%s'", noway, file->name); + } + } + else + { + chop_commands (file->cmds); + + if (touch_flag && !file->cmds->any_recurse) + { + if (file->phony) + file->update_status = 0; + else + /* Should set file's modification date and do nothing else. */ + file->update_status = touch_file (file); + } + else + { + execute_file_commands (file); + return; + } + } + + notice_finished_file (file); +} + +/* Return the mtime of a file, given a `struct file'. + Caches the time in the struct file to avoid excess stat calls. If the file + is not found, and SEARCH is nonzero, VPATH searching and replacement is + done. If that fails, a library (-lLIBNAME) is tried but the library's + actual name (/lib/libLIBNAME.a, etc.) is not substituted into FILE. */ + +time_t +f_mtime (file, search) + register struct file *file; + int search; +{ + register time_t mtime; + + /* File's mtime is not known; must get it from the system. */ + +#ifndef NO_ARCHIVES + if (ar_name (file->name)) + { + /* This file is an archive-member reference. */ + + char *arname, *memname; + struct file *arfile; + int arname_used = 0; + + /* Find the archive's name. */ + ar_parse_name (file->name, &arname, &memname); + + /* Find the modification time of the archive itself. + Also allow for its name to be changed via VPATH search. */ + arfile = lookup_file (arname); + if (arfile == 0) + { + arfile = enter_file (arname); + arname_used = 1; + } + mtime = f_mtime (arfile, search); + check_renamed (arfile); + if (search && strcmp (arfile->name, arname)) + { + /* The archive's name has changed. + Change the archive-member reference accordingly. */ + + unsigned int arlen, memlen; + + if (!arname_used) + { + free (arname); + arname_used = 1; + } + + arname = arfile->name; + arlen = strlen (arname); + memlen = strlen (memname); + + free (file->name); + + file->name = (char *) xmalloc (arlen + 1 + memlen + 2); + bcopy (arname, file->name, arlen); + file->name[arlen] = '('; + bcopy (memname, file->name + arlen + 1, memlen); + file->name[arlen + 1 + memlen] = ')'; + file->name[arlen + 1 + memlen + 1] = '\0'; + } + + if (!arname_used) + free (arname); + free (memname); + + if (mtime == (time_t) -1) + /* The archive doesn't exist, so it's members don't exist either. */ + return (time_t) -1; + + mtime = ar_member_date (file->name); + } + else +#endif + { + mtime = name_mtime (file->name); + + if (mtime == (time_t) -1 && search) + { + /* If name_mtime failed, search VPATH. */ + char *name = file->name; + if (vpath_search (&name)) + { + rename_file (file, name); + check_renamed (file); + return file_mtime (file); + } + else + /* Last resort, is it a library (-lxxx)? */ + if (name[0] == '-' && name[1] == 'l') + mtime = library_file_mtime (&name[2]); + } + } + + /* Store the mtime into all the entries for this file. */ + + while (file != 0) + { + file->last_mtime = mtime; + file = file->prev; + } + + return mtime; +} + + +/* Return the mtime of the file or archive-member reference NAME. */ + +static time_t +name_mtime (name) + register char *name; +{ + struct stat st; + + if (stat (name, &st) < 0) + return (time_t) -1; + + return (time_t) st.st_mtime; +} + + +/* Return the mtime of a library file specified as -lLIBNAME, + searching for a suitable library file in the system library directories + and the VPATH directories. */ + +static time_t +library_file_mtime (lib) + char *lib; +{ + time_t mtime; + char *name; + + name = concat ("/usr/lib/lib", lib, ".a"); + mtime = name_mtime (name); + if (mtime == (time_t) -1) + mtime = name_mtime (name + 4); + if (mtime == (time_t) -1) + { + char *local = concat ("/usr/local/lib/lib", lib, ".a"); + mtime = name_mtime (local); + free (local); + } + if (mtime == (time_t) -1) + mtime = name_mtime (name + 9); + if (mtime == (time_t) -1) + { + char *newname = name + 9; + if (vpath_search (&newname)) + { + mtime = name_mtime (newname); + free (newname); + } + } + + free (name); + + return mtime; +} |