diff options
Diffstat (limited to 'bootstrap/bmake/make.c')
| -rw-r--r-- | bootstrap/bmake/make.c | 1107 |
1 files changed, 1107 insertions, 0 deletions
diff --git a/bootstrap/bmake/make.c b/bootstrap/bmake/make.c new file mode 100644 index 00000000000..d30d0a959ab --- /dev/null +++ b/bootstrap/bmake/make.c @@ -0,0 +1,1107 @@ +/* $NetBSD: make.c,v 1.1.1.1 2004/03/11 13:04:10 grant Exp $ */ + +/* + * Copyright (c) 1988, 1989, 1990, 1993 + * The Regents of the University of California. All rights reserved. + * Copyright (c) 1989 by Berkeley Softworks + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Adam de Boor. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifdef MAKE_BOOTSTRAP +static char rcsid[] = "$NetBSD: make.c,v 1.1.1.1 2004/03/11 13:04:10 grant Exp $"; +#else +#include <sys/cdefs.h> +#ifndef lint +#if 0 +static char sccsid[] = "@(#)make.c 8.1 (Berkeley) 6/6/93"; +#else +__RCSID("$NetBSD: make.c,v 1.1.1.1 2004/03/11 13:04:10 grant Exp $"); +#endif +#endif /* not lint */ +#endif + +#if !defined(MAKE_BOOTSTRAP) && !defined(lint) +__IDSTRING(rcs_id,"$Id: make.c,v 1.1.1.1 2004/03/11 13:04:10 grant Exp $"); +#endif + +/*- + * make.c -- + * The functions which perform the examination of targets and + * their suitability for creation + * + * Interface: + * Make_Run Initialize things for the module and recreate + * whatever needs recreating. Returns TRUE if + * work was (or would have been) done and FALSE + * otherwise. + * + * Make_Update Update all parents of a given child. Performs + * various bookkeeping chores like the updating + * of the cmtime field of the parent, filling + * of the IMPSRC context variable, etc. It will + * place the parent on the toBeMade queue if it + * should be. + * + * Make_TimeStamp Function to set the parent's cmtime field + * based on a child's modification time. + * + * Make_DoAllVar Set up the various local variables for a + * target, including the .ALLSRC variable, making + * sure that any variable that needs to exist + * at the very least has the empty value. + * + * Make_OODate Determine if a target is out-of-date. + * + * Make_HandleUse See if a child is a .USE node for a parent + * and perform the .USE actions if so. + * + * Make_ExpandUse Expand .USE nodes and return the new list of + * targets. + */ + +#include "make.h" +#include "hash.h" +#include "dir.h" +#include "job.h" + +static Lst toBeMade; /* The current fringe of the graph. These + * are nodes which await examination by + * MakeOODate. It is added to by + * Make_Update and subtracted from by + * MakeStartJobs */ +static int numNodes; /* Number of nodes to be processed. If this + * is non-zero when Job_Empty() returns + * TRUE, there's a cycle in the graph */ + +static int MakeAddChild __P((ClientData, ClientData)); +static int MakeFindChild __P((ClientData, ClientData)); +static int MakeUnmark __P((ClientData, ClientData)); +static int MakeAddAllSrc __P((ClientData, ClientData)); +static int MakeTimeStamp __P((ClientData, ClientData)); +static int MakeHandleUse __P((ClientData, ClientData)); +static Boolean MakeStartJobs __P((void)); +static int MakePrintStatus __P((ClientData, ClientData)); +/*- + *----------------------------------------------------------------------- + * Make_TimeStamp -- + * Set the cmtime field of a parent node based on the mtime stamp in its + * child. Called from MakeOODate via Lst_ForEach. + * + * Results: + * Always returns 0. + * + * Side Effects: + * The cmtime of the parent node will be changed if the mtime + * field of the child is greater than it. + *----------------------------------------------------------------------- + */ +int +Make_TimeStamp (pgn, cgn) + GNode *pgn; /* the current parent */ + GNode *cgn; /* the child we've just examined */ +{ + if (cgn->mtime > pgn->cmtime) { + pgn->cmtime = cgn->mtime; + } + return (0); +} + +static int +MakeTimeStamp (pgn, cgn) + ClientData pgn; /* the current parent */ + ClientData cgn; /* the child we've just examined */ +{ + return Make_TimeStamp((GNode *) pgn, (GNode *) cgn); +} + +/*- + *----------------------------------------------------------------------- + * Make_OODate -- + * See if a given node is out of date with respect to its sources. + * Used by Make_Run when deciding which nodes to place on the + * toBeMade queue initially and by Make_Update to screen out USE and + * EXEC nodes. In the latter case, however, any other sort of node + * must be considered out-of-date since at least one of its children + * will have been recreated. + * + * Results: + * TRUE if the node is out of date. FALSE otherwise. + * + * Side Effects: + * The mtime field of the node and the cmtime field of its parents + * will/may be changed. + *----------------------------------------------------------------------- + */ +Boolean +Make_OODate (gn) + register GNode *gn; /* the node to check */ +{ + Boolean oodate; + + /* + * Certain types of targets needn't even be sought as their datedness + * doesn't depend on their modification time... + */ + if ((gn->type & (OP_JOIN|OP_USE|OP_USEBEFORE|OP_EXEC)) == 0) { + (void) Dir_MTime (gn); + if (DEBUG(MAKE)) { + if (gn->mtime != 0) { + printf ("modified %s...", Targ_FmtTime(gn->mtime)); + } else { + printf ("non-existent..."); + } + } + } + + /* + * A target is remade in one of the following circumstances: + * its modification time is smaller than that of its youngest child + * and it would actually be run (has commands or type OP_NOP) + * it's the object of a force operator + * it has no children, was on the lhs of an operator and doesn't exist + * already. + * + * Libraries are only considered out-of-date if the archive module says + * they are. + * + * These weird rules are brought to you by Backward-Compatibility and + * the strange people who wrote 'Make'. + */ + if (gn->type & (OP_USE|OP_USEBEFORE)) { + /* + * If the node is a USE node it is *never* out of date + * no matter *what*. + */ + if (DEBUG(MAKE)) { + printf(".USE node..."); + } + oodate = FALSE; + } else if ((gn->type & OP_LIB) && + ((gn->mtime==0) || Arch_IsLib(gn))) { + if (DEBUG(MAKE)) { + printf("library..."); + } + + /* + * always out of date if no children and :: target + * or non-existent. + */ + oodate = (gn->mtime == 0 || Arch_LibOODate (gn) || + (gn->cmtime == 0 && (gn->type & OP_DOUBLEDEP))); + } else if (gn->type & OP_JOIN) { + /* + * A target with the .JOIN attribute is only considered + * out-of-date if any of its children was out-of-date. + */ + if (DEBUG(MAKE)) { + printf(".JOIN node..."); + } + if (DEBUG(MAKE)) { + printf("source %smade...", gn->flags & CHILDMADE ? "" : "not "); + } + oodate = (gn->flags & CHILDMADE) ? 1 : 0; + } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) { + /* + * A node which is the object of the force (!) operator or which has + * the .EXEC attribute is always considered out-of-date. + */ + if (DEBUG(MAKE)) { + if (gn->type & OP_FORCE) { + printf("! operator..."); + } else if (gn->type & OP_PHONY) { + printf(".PHONY node..."); + } else { + printf(".EXEC node..."); + } + } + oodate = TRUE; + } else if ((gn->mtime < gn->cmtime) || + ((gn->cmtime == 0) && + ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP)))) + { + /* + * A node whose modification time is less than that of its + * youngest child or that has no children (cmtime == 0) and + * either doesn't exist (mtime == 0) or was the object of a + * :: operator is out-of-date. Why? Because that's the way Make does + * it. + */ + if (DEBUG(MAKE)) { + if (gn->mtime < gn->cmtime) { + printf("modified before source..."); + } else if (gn->mtime == 0) { + printf("non-existent and no sources..."); + } else { + printf(":: operator and no sources..."); + } + } + oodate = TRUE; + } else { + /* + * When a non-existing child with no sources + * (such as a typically used FORCE source) has been made and + * the target of the child (usually a directory) has the same + * timestamp as the timestamp just given to the non-existing child + * after it was considered made. + */ + if (DEBUG(MAKE)) { + if (gn->flags & FORCE) + printf("non existing child..."); + } + oodate = (gn->flags & FORCE) ? 1 : 0; + } + + /* + * If the target isn't out-of-date, the parents need to know its + * modification time. Note that targets that appear to be out-of-date + * but aren't, because they have no commands and aren't of type OP_NOP, + * have their mtime stay below their children's mtime to keep parents from + * thinking they're out-of-date. + */ + if (!oodate) { + Lst_ForEach (gn->parents, MakeTimeStamp, (ClientData)gn); + } + + return (oodate); +} + +/*- + *----------------------------------------------------------------------- + * MakeAddChild -- + * Function used by Make_Run to add a child to the list l. + * It will only add the child if its make field is FALSE. + * + * Results: + * Always returns 0 + * + * Side Effects: + * The given list is extended + *----------------------------------------------------------------------- + */ +static int +MakeAddChild (gnp, lp) + ClientData gnp; /* the node to add */ + ClientData lp; /* the list to which to add it */ +{ + GNode *gn = (GNode *) gnp; + Lst l = (Lst) lp; + + if ((gn->flags & REMAKE) == 0 && !(gn->type & (OP_USE|OP_USEBEFORE))) { + (void)Lst_EnQueue (l, (ClientData)gn); + } + return (0); +} + +/*- + *----------------------------------------------------------------------- + * MakeFindChild -- + * Function used by Make_Run to find the pathname of a child + * that was already made. + * + * Results: + * Always returns 0 + * + * Side Effects: + * The path and mtime of the node and the cmtime of the parent are + * updated + *----------------------------------------------------------------------- + */ +static int +MakeFindChild (gnp, pgnp) + ClientData gnp; /* the node to find */ + ClientData pgnp; +{ + GNode *gn = (GNode *) gnp; + GNode *pgn = (GNode *) pgnp; + + (void) Dir_MTime(gn); + Make_TimeStamp(pgn, gn); + gn->made = UPTODATE; + + return (0); +} + +/*- + *----------------------------------------------------------------------- + * Make_HandleUse -- + * Function called by Make_Run and SuffApplyTransform on the downward + * pass to handle .USE and transformation nodes. A callback function + * for Lst_ForEach, it implements the .USE and transformation + * functionality by copying the node's commands, type flags + * and children to the parent node. Should be called before the + * children are enqueued to be looked at by MakeAddChild. + * + * A .USE node is much like an explicit transformation rule, except + * its commands are always added to the target node, even if the + * target already has commands. + * + * Results: + * returns 0. + * + * Side Effects: + * Children and commands may be added to the parent and the parent's + * type may be changed. + * + *----------------------------------------------------------------------- + */ +int +Make_HandleUse (cgn, pgn) + register GNode *cgn; /* The .USE node */ + register GNode *pgn; /* The target of the .USE node */ +{ + register LstNode ln; /* An element in the children list */ + + if (cgn->type & (OP_USE|OP_USEBEFORE|OP_TRANSFORM)) { + if ((cgn->type & (OP_USE|OP_USEBEFORE)) || Lst_IsEmpty(pgn->commands)) { + if (cgn->type & OP_USEBEFORE) { + /* + * .USEBEFORE -- + * prepend the child's commands to the parent. + */ + Lst cmds = pgn->commands; + pgn->commands = Lst_Duplicate (cgn->commands, NOCOPY); + (void) Lst_Concat (pgn->commands, cmds, LST_CONCNEW); + Lst_Destroy (cmds, NOFREE); + } else { + /* + * .USE or target has no commands -- + * append the child's commands to the parent. + */ + (void) Lst_Concat (pgn->commands, cgn->commands, LST_CONCNEW); + } + } + + if (Lst_Open (cgn->children) == SUCCESS) { + while ((ln = Lst_Next (cgn->children)) != NILLNODE) { + register GNode *tgn, *gn = (GNode *)Lst_Datum (ln); + + /* + * Expand variables in the .USE node's name + * and save the unexpanded form. + * We don't need to do this for commands. + * They get expanded properly when we execute. + */ + if (gn->uname == NULL) { + gn->uname = gn->name; + } else { + if (gn->name) + free(gn->name); + } + gn->name = Var_Subst(NULL, gn->uname, pgn, FALSE); + if (gn->name && gn->uname && strcmp(gn->name, gn->uname) != 0) { + /* See if we have a target for this node. */ + tgn = Targ_FindNode(gn->name, TARG_NOCREATE); + if (tgn != NILGNODE) + gn = tgn; + } + + (void) Lst_AtEnd (pgn->children, gn); + (void) Lst_AtEnd (gn->parents, pgn); + pgn->unmade += 1; + } + Lst_Close (cgn->children); + } + + pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_USEBEFORE|OP_TRANSFORM); + + /* + * This child node is now "made", so we decrement the count of + * unmade children in the parent... We also remove the child + * from the parent's list to accurately reflect the number of decent + * children the parent has. This is used by Make_Run to decide + * whether to queue the parent or examine its children... + */ + if ((cgn->type & (OP_USE|OP_USEBEFORE)) && + (ln = Lst_Member (pgn->children, (ClientData) cgn)) != NILLNODE) { + Lst_Remove(pgn->children, ln); + pgn->unmade--; + } + } + return (0); +} + +static int +MakeHandleUse (cgnp, pgnp) + ClientData cgnp; /* the child we've just examined */ + ClientData pgnp; /* the current parent */ +{ + GNode *cgn = (GNode *) cgnp; + GNode *pgn = (GNode *) pgnp; + + if (cgn->type & OP_MARK) + return (0); + cgn->type |= OP_MARK; + + return Make_HandleUse(cgn, pgn); +} + + +/*- + *----------------------------------------------------------------------- + * Make_Recheck -- + * Check the modification time of a gnode, and update it as described + * in the comments below. + * + * Results: + * returns 0 if the gnode does not exist, or it's filesystem + * time if it does. + * + * Side Effects: + * the gnode's modification time and path name are affected. + * + *----------------------------------------------------------------------- + */ +time_t +Make_Recheck (gn) + GNode *gn; +{ + time_t mtime = Dir_MTime(gn); + +#ifndef RECHECK + /* + * We can't re-stat the thing, but we can at least take care of rules + * where a target depends on a source that actually creates the + * target, but only if it has changed, e.g. + * + * parse.h : parse.o + * + * parse.o : parse.y + * yacc -d parse.y + * cc -c y.tab.c + * mv y.tab.o parse.o + * cmp -s y.tab.h parse.h || mv y.tab.h parse.h + * + * In this case, if the definitions produced by yacc haven't changed + * from before, parse.h won't have been updated and gn->mtime will + * reflect the current modification time for parse.h. This is + * something of a kludge, I admit, but it's a useful one.. + * XXX: People like to use a rule like + * + * FRC: + * + * To force things that depend on FRC to be made, so we have to + * check for gn->children being empty as well... + */ + if (!Lst_IsEmpty(gn->commands) || Lst_IsEmpty(gn->children)) { + gn->mtime = now; + } +#else + /* + * This is what Make does and it's actually a good thing, as it + * allows rules like + * + * cmp -s y.tab.h parse.h || cp y.tab.h parse.h + * + * to function as intended. Unfortunately, thanks to the stateless + * nature of NFS (by which I mean the loose coupling of two clients + * using the same file from a common server), there are times + * when the modification time of a file created on a remote + * machine will not be modified before the local stat() implied by + * the Dir_MTime occurs, thus leading us to believe that the file + * is unchanged, wreaking havoc with files that depend on this one. + * + * I have decided it is better to make too much than to make too + * little, so this stuff is commented out unless you're sure it's ok. + * -- ardeb 1/12/88 + */ + /* + * Christos, 4/9/92: If we are saving commands pretend that + * the target is made now. Otherwise archives with ... rules + * don't work! + */ + if (NoExecute(gn) || + (gn->type & OP_SAVE_CMDS) || mtime == 0) { + if (DEBUG(MAKE)) { + printf("update time to now: %s\n", Targ_FmtTime(gn->mtime)); + } + gn->mtime = now; + } + else { + if (DEBUG(MAKE)) { + printf("current update time: %s\n", Targ_FmtTime(gn->mtime)); + } + } +#endif + return mtime; +} + +/*- + *----------------------------------------------------------------------- + * Make_Update -- + * Perform update on the parents of a node. Used by JobFinish once + * a node has been dealt with and by MakeStartJobs if it finds an + * up-to-date node. + * + * Results: + * Always returns 0 + * + * Side Effects: + * The unmade field of pgn is decremented and pgn may be placed on + * the toBeMade queue if this field becomes 0. + * + * If the child was made, the parent's flag CHILDMADE field will be + * set true and its cmtime set to now. + * + * If the child is not up-to-date and still does not exist, + * set the FORCE flag on the parents. + * + * If the child wasn't made, the cmtime field of the parent will be + * altered if the child's mtime is big enough. + * + * Finally, if the child is the implied source for the parent, the + * parent's IMPSRC variable is set appropriately. + * + *----------------------------------------------------------------------- + */ +void +Make_Update (cgn) + register GNode *cgn; /* the child node */ +{ + register GNode *pgn; /* the parent node */ + register char *cname; /* the child's name */ + register LstNode ln; /* Element in parents and iParents lists */ + time_t mtime = -1; + char *p1; + + cname = Var_Value (TARGET, cgn, &p1); + if (p1) + free(p1); + + /* + * If the child was actually made, see what its modification time is + * now -- some rules won't actually update the file. If the file still + * doesn't exist, make its mtime now. + */ + if (cgn->made != UPTODATE) { + mtime = Make_Recheck(cgn); + } + + if (Lst_Open (cgn->parents) == SUCCESS) { + while ((ln = Lst_Next (cgn->parents)) != NILLNODE) { + pgn = (GNode *)Lst_Datum (ln); + if (mtime == 0) + pgn->flags |= FORCE; + if (pgn->flags & REMAKE) { + pgn->unmade -= 1; + + if ( ! (cgn->type & (OP_EXEC|OP_USE|OP_USEBEFORE))) { + if (cgn->made == MADE) + pgn->flags |= CHILDMADE; + (void)Make_TimeStamp (pgn, cgn); + } + if (pgn->unmade == 0) { + /* + * Queue the node up -- any unmade predecessors will + * be dealt with in MakeStartJobs. + */ + (void)Lst_EnQueue (toBeMade, (ClientData)pgn); + } else if (pgn->unmade < 0) { + Error ("Graph cycles through %s", pgn->name); + } + } + } + Lst_Close (cgn->parents); + } + /* + * Deal with successor nodes. If any is marked for making and has an unmade + * count of 0, has not been made and isn't in the examination queue, + * it means we need to place it in the queue as it restrained itself + * before. + */ + for (ln = Lst_First(cgn->successors); ln != NILLNODE; ln = Lst_Succ(ln)) { + GNode *succ = (GNode *)Lst_Datum(ln); + + if ((succ->flags & REMAKE) && succ->unmade == 0 && succ->made == UNMADE && + Lst_Member(toBeMade, (ClientData)succ) == NILLNODE) + { + (void)Lst_EnQueue(toBeMade, (ClientData)succ); + } + } + + /* + * Set the .PREFIX and .IMPSRC variables for all the implied parents + * of this node. + */ + if (Lst_Open (cgn->iParents) == SUCCESS) { + char *p1; + char *cpref = Var_Value(PREFIX, cgn, &p1); + + while ((ln = Lst_Next (cgn->iParents)) != NILLNODE) { + pgn = (GNode *)Lst_Datum (ln); + if (pgn->flags & REMAKE) { + Var_Set (IMPSRC, cname, pgn, 0); + if (cpref != NULL) + Var_Set (PREFIX, cpref, pgn, 0); + } + } + if (p1) + free(p1); + Lst_Close (cgn->iParents); + } +} + +/*- + *----------------------------------------------------------------------- + * MakeAddAllSrc -- + * Add a child's name to the ALLSRC and OODATE variables of the given + * node. Called from Make_DoAllVar via Lst_ForEach. A child is added only + * if it has not been given the .EXEC, .USE or .INVISIBLE attributes. + * .EXEC and .USE children are very rarely going to be files, so... + * A child is added to the OODATE variable if its modification time is + * later than that of its parent, as defined by Make, except if the + * parent is a .JOIN node. In that case, it is only added to the OODATE + * variable if it was actually made (since .JOIN nodes don't have + * modification times, the comparison is rather unfair...).. + * + * Results: + * Always returns 0 + * + * Side Effects: + * The ALLSRC variable for the given node is extended. + *----------------------------------------------------------------------- + */ +static int +MakeUnmark (cgnp, pgnp) + ClientData cgnp; + ClientData pgnp; +{ + GNode *cgn = (GNode *) cgnp; + + cgn->type &= ~OP_MARK; + return (0); +} + +static int +MakeAddAllSrc (cgnp, pgnp) + ClientData cgnp; /* The child to add */ + ClientData pgnp; /* The parent to whose ALLSRC variable it should be */ + /* added */ +{ + GNode *cgn = (GNode *) cgnp; + GNode *pgn = (GNode *) pgnp; + + if (cgn->type & OP_MARK) + return (0); + cgn->type |= OP_MARK; + + if ((cgn->type & (OP_EXEC|OP_USE|OP_USEBEFORE|OP_INVISIBLE)) == 0) { + char *child; + char *p1 = NULL; + + if (cgn->type & OP_ARCHV) + child = Var_Value (MEMBER, cgn, &p1); + else + child = cgn->path ? cgn->path : cgn->name; + Var_Append (ALLSRC, child, pgn); + if (pgn->type & OP_JOIN) { + if (cgn->made == MADE) { + Var_Append(OODATE, child, pgn); + } + } else if ((pgn->mtime < cgn->mtime) || + (cgn->mtime >= now && cgn->made == MADE)) + { + /* + * It goes in the OODATE variable if the parent is younger than the + * child or if the child has been modified more recently than + * the start of the make. This is to keep pmake from getting + * confused if something else updates the parent after the + * make starts (shouldn't happen, I know, but sometimes it + * does). In such a case, if we've updated the kid, the parent + * is likely to have a modification time later than that of + * the kid and anything that relies on the OODATE variable will + * be hosed. + * + * XXX: This will cause all made children to go in the OODATE + * variable, even if they're not touched, if RECHECK isn't defined, + * since cgn->mtime is set to now in Make_Update. According to + * some people, this is good... + */ + Var_Append(OODATE, child, pgn); + } + if (p1) + free(p1); + } + return (0); +} + +/*- + *----------------------------------------------------------------------- + * Make_DoAllVar -- + * Set up the ALLSRC and OODATE variables. Sad to say, it must be + * done separately, rather than while traversing the graph. This is + * because Make defined OODATE to contain all sources whose modification + * times were later than that of the target, *not* those sources that + * were out-of-date. Since in both compatibility and native modes, + * the modification time of the parent isn't found until the child + * has been dealt with, we have to wait until now to fill in the + * variable. As for ALLSRC, the ordering is important and not + * guaranteed when in native mode, so it must be set here, too. + * + * Results: + * None + * + * Side Effects: + * The ALLSRC and OODATE variables of the given node is filled in. + * If the node is a .JOIN node, its TARGET variable will be set to + * match its ALLSRC variable. + *----------------------------------------------------------------------- + */ +void +Make_DoAllVar (gn) + GNode *gn; +{ + Lst_ForEach (gn->children, MakeUnmark, (ClientData) gn); + Lst_ForEach (gn->children, MakeAddAllSrc, (ClientData) gn); + + if (!Var_Exists (OODATE, gn)) { + Var_Set (OODATE, "", gn, 0); + } + if (!Var_Exists (ALLSRC, gn)) { + Var_Set (ALLSRC, "", gn, 0); + } + + if (gn->type & OP_JOIN) { + char *p1; + Var_Set (TARGET, Var_Value (ALLSRC, gn, &p1), gn, 0); + if (p1) + free(p1); + } +} + +/*- + *----------------------------------------------------------------------- + * MakeStartJobs -- + * Start as many jobs as possible. + * + * Results: + * If the query flag was given to pmake, no job will be started, + * but as soon as an out-of-date target is found, this function + * returns TRUE. At all other times, this function returns FALSE. + * + * Side Effects: + * Nodes are removed from the toBeMade queue and job table slots + * are filled. + * + *----------------------------------------------------------------------- + */ +static Boolean +MakeStartJobs () +{ + register GNode *gn; + + while (!Lst_IsEmpty (toBeMade)) { + gn = (GNode *) Lst_DeQueue (toBeMade); + if (DEBUG(MAKE)) { + printf ("Examining %s...", gn->name); + } + /* + * Make sure any and all predecessors that are going to be made, + * have been. + */ + if (!Lst_IsEmpty(gn->preds)) { + LstNode ln; + + for (ln = Lst_First(gn->preds); ln != NILLNODE; ln = Lst_Succ(ln)){ + GNode *pgn = (GNode *)Lst_Datum(ln); + + if ((pgn->flags & REMAKE) && pgn->made == UNMADE) { + if (DEBUG(MAKE)) { + printf("predecessor %s not made yet.\n", pgn->name); + } + break; + } + } + /* + * If ln isn't nil, there's a predecessor as yet unmade, so we + * just drop this node on the floor. When the node in question + * has been made, it will notice this node as being ready to + * make but as yet unmade and will place the node on the queue. + */ + if (ln != NILLNODE) { + continue; + } + } + + if (!Job_TokenWithdraw()) { + Lst_AtFront(toBeMade, gn); + break; + } + + numNodes--; + if (Make_OODate (gn)) { + if (DEBUG(MAKE)) { + printf ("out-of-date\n"); + } + if (queryFlag) { + return (TRUE); + } + Make_DoAllVar (gn); + Job_Make (gn); + } else { + if (DEBUG(MAKE)) { + printf ("up-to-date\n"); + } + gn->made = UPTODATE; + if (gn->type & OP_JOIN) { + /* + * Even for an up-to-date .JOIN node, we need it to have its + * context variables so references to it get the correct + * value for .TARGET when building up the context variables + * of its parent(s)... + */ + Make_DoAllVar (gn); + } + Job_TokenReturn(); + Make_Update (gn); + } + } + return (FALSE); +} + +/*- + *----------------------------------------------------------------------- + * MakePrintStatus -- + * Print the status of a top-level node, viz. it being up-to-date + * already or not created due to an error in a lower level. + * Callback function for Make_Run via Lst_ForEach. + * + * Results: + * Always returns 0. + * + * Side Effects: + * A message may be printed. + * + *----------------------------------------------------------------------- + */ +static int +MakePrintStatus(gnp, cyclep) + ClientData gnp; /* Node to examine */ + ClientData cyclep; /* True if gn->unmade being non-zero implies + * a cycle in the graph, not an error in an + * inferior */ +{ + GNode *gn = (GNode *) gnp; + Boolean cycle = *(Boolean *) cyclep; + if (gn->made == UPTODATE) { + printf ("`%s' is up to date.\n", gn->name); + } else if (gn->unmade != 0) { + if (cycle) { + Boolean t = TRUE; + /* + * If printing cycles and came to one that has unmade children, + * print out the cycle by recursing on its children. Note a + * cycle like: + * a : b + * b : c + * c : b + * will cause this to erroneously complain about a being in + * the cycle, but this is a good approximation. + */ + if (gn->made == CYCLE) { + Error("Graph cycles through `%s'", gn->name); + gn->made = ENDCYCLE; + Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t); + gn->made = UNMADE; + } else if (gn->made != ENDCYCLE) { + gn->made = CYCLE; + Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t); + } + } else { + printf ("`%s' not remade because of errors.\n", gn->name); + } + } + return (0); +} + + +/*- + *----------------------------------------------------------------------- + * Make_ExpandUse -- + * Expand .USE nodes and create a new targets list + * Results: + * The new list of targets. + * + * Side Effects: + * numNodes is set to the number of elements in the list of targets. + *----------------------------------------------------------------------- + */ +Lst +Make_ExpandUse (targs) + Lst targs; /* the initial list of targets */ +{ + register GNode *gn; /* a temporary pointer */ + register Lst examine; /* List of targets to examine */ + register Lst ntargs; /* List of new targets to be made */ + + ntargs = Lst_Init (FALSE); + + examine = Lst_Duplicate(targs, NOCOPY); + numNodes = 0; + + /* + * Make an initial downward pass over the graph, marking nodes to be made + * as we go down. We call Suff_FindDeps to find where a node is and + * to get some children for it if it has none and also has no commands. + * If the node is a leaf, we stick it on the toBeMade queue to + * be looked at in a minute, otherwise we add its children to our queue + * and go on about our business. + */ + while (!Lst_IsEmpty (examine)) { + gn = (GNode *) Lst_DeQueue (examine); + + if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty (gn->cohorts)) { + Lst new; + new = Lst_Duplicate (gn->cohorts, NOCOPY); + Lst_Concat (new, examine, LST_CONCLINK); + examine = new; + } + + if ((gn->flags & REMAKE) == 0) { + gn->flags |= REMAKE; + numNodes++; + + /* + * Apply any .USE rules before looking for implicit dependencies + * to make sure everything has commands that should... + * Make sure that the TARGET is set, so that we can make + * expansions. + */ + if (gn->type & OP_ARCHV) { + char *eoa, *eon; + eoa = strchr(gn->name, '('); + eon = strchr(gn->name, ')'); + if (eoa == NULL || eon == NULL) + continue; + *eoa = '\0'; + *eon = '\0'; + Var_Set (MEMBER, eoa + 1, gn, 0); + Var_Set (ARCHIVE, gn->name, gn, 0); + *eoa = '('; + *eon = ')'; + } + + (void)Dir_MTime(gn); + Var_Set (TARGET, gn->path ? gn->path : gn->name, gn, 0); + Lst_ForEach (gn->children, MakeUnmark, (ClientData)gn); + Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn); + Suff_FindDeps (gn); + + if (gn->unmade != 0 && (gn->type & OP_MADE) == 0) { + Lst_ForEach (gn->children, MakeAddChild, (ClientData)examine); + } else { + (void)Lst_EnQueue (ntargs, (ClientData)gn); + if (gn->type & OP_MADE) + Lst_ForEach (gn->children, MakeFindChild, (ClientData)gn); + } + } + } + + Lst_Destroy (examine, NOFREE); + return ntargs; +} + +/*- + *----------------------------------------------------------------------- + * Make_Run -- + * Initialize the nodes to remake and the list of nodes which are + * ready to be made by doing a breadth-first traversal of the graph + * starting from the nodes in the given list. Once this traversal + * is finished, all the 'leaves' of the graph are in the toBeMade + * queue. + * Using this queue and the Job module, work back up the graph, + * calling on MakeStartJobs to keep the job table as full as + * possible. + * + * Results: + * TRUE if work was done. FALSE otherwise. + * + * Side Effects: + * The make field of all nodes involved in the creation of the given + * targets is set to 1. The toBeMade list is set to contain all the + * 'leaves' of these subgraphs. + *----------------------------------------------------------------------- + */ +Boolean +Make_Run (targs) + Lst targs; /* the initial list of targets */ +{ + int errors; /* Number of errors the Job module reports */ + + toBeMade = Make_ExpandUse (targs); + + if (queryFlag) { + /* + * We wouldn't do any work unless we could start some jobs in the + * next loop... (we won't actually start any, of course, this is just + * to see if any of the targets was out of date) + */ + return (MakeStartJobs()); + } else { + /* + * Initialization. At the moment, no jobs are running and until some + * get started, nothing will happen since the remaining upward + * traversal of the graph is performed by the routines in job.c upon + * the finishing of a job. So we fill the Job table as much as we can + * before going into our loop. + */ + (void) MakeStartJobs(); + } + + /* + * Main Loop: The idea here is that the ending of jobs will take + * care of the maintenance of data structures and the waiting for output + * will cause us to be idle most of the time while our children run as + * much as possible. Because the job table is kept as full as possible, + * the only time when it will be empty is when all the jobs which need + * running have been run, so that is the end condition of this loop. + * Note that the Job module will exit if there were any errors unless the + * keepgoing flag was given. + */ + while (!Lst_IsEmpty(toBeMade) || !Job_Empty ()) { + Job_CatchOutput (); + Job_CatchChildren (!usePipes); + (void)MakeStartJobs(); + } + + errors = Job_Finish(); + + /* + * Print the final status of each target. E.g. if it wasn't made + * because some inferior reported an error. + */ + errors = ((errors == 0) && (numNodes != 0)); + Lst_ForEach(targs, MakePrintStatus, (ClientData) &errors); + + return (TRUE); +} |