Changeset 51 for trunk/src/kmk/make.c


Ignore:
Timestamp:
Apr 7, 2003, 3:30:32 AM (22 years ago)
Author:
bird
Message:

kMk and porting to kLib.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kmk/make.c

    r46 r51  
    11/*
    22 * Copyright (c) 1988, 1989, 1990, 1993
    3  *      The Regents of the University of California.  All rights reserved.
     3 *      The Regents of the University of California.  All rights reserved.
    44 * Copyright (c) 1989 by Berkeley Softworks
    55 * All rights reserved.
    … …  
    1818 * 3. All advertising materials mentioning features or use of this software
    1919 *    must display the following acknowledgement:
    20  *      This product includes software developed by the University of
    21  *      California, Berkeley and its contributors.
     20 *      This product includes software developed by the University of
     21 *      California, Berkeley and its contributors.
    2222 * 4. Neither the name of the University nor the names of its contributors
    2323 *    may be used to endorse or promote products derived from this software
    … …  
    3939#ifndef lint
    4040#if 0
    41 static char sccsid[] = "@(#)make.c      8.1 (Berkeley) 6/6/93";
     41static char sccsid[] = "@(#)make.c      8.1 (Berkeley) 6/6/93";
    4242#else
    4343static const char rcsid[] =
    4444  "$FreeBSD: src/usr.bin/make/make.c,v 1.11 1999/09/11 13:08:01 hoek Exp $";
    4545#endif
     46#define KLIBFILEDEF rcsid
    4647#endif /* not lint */
    4748
    4849/*-
    4950 * make.c --
    50  *      The functions which perform the examination of targets and
    51  *      their suitability for creation
     51 *      The functions which perform the examination of targets and
     52 *      their suitability for creation
    5253 *
    5354 * Interface:
    54  *      Make_Run                Initialize things for the module and recreate
    55  *                              whatever needs recreating. Returns TRUE if
    56  *                              work was (or would have been) done and FALSE
    57  *                              otherwise.
    58  *
    59  *      Make_Update             Update all parents of a given child. Performs
    60  *                              various bookkeeping chores like the updating
    61  *                              of the cmtime field of the parent, filling
    62  *                              of the IMPSRC context variable, etc. It will
    63  *                              place the parent on the toBeMade queue if it
    64  *                              should be.
    65  *
    66  *      Make_TimeStamp          Function to set the parent's cmtime field
    67  *                              based on a child's modification time.
    68  *
    69  *      Make_DoAllVar           Set up the various local variables for a
    70  *                              target, including the .ALLSRC variable, making
    71  *                              sure that any variable that needs to exist
    72  *                              at the very least has the empty value.
    73  *
    74  *      Make_OODate             Determine if a target is out-of-date.
    75  *
    76  *      Make_HandleUse          See if a child is a .USE node for a parent
    77  *                              and perform the .USE actions if so.
     55 *      Make_Run                Initialize things for the module and recreate
     56 *                              whatever needs recreating. Returns TRUE if
     57 *                              work was (or would have been) done and FALSE
     58 *                              otherwise.
     59 *
     60 *      Make_Update             Update all parents of a given child. Performs
     61 *                              various bookkeeping chores like the updating
     62 *                              of the cmtime field of the parent, filling
     63 *                              of the IMPSRC context variable, etc. It will
     64 *                              place the parent on the toBeMade queue if it
     65 *                              should be.
     66 *
     67 *      Make_TimeStamp          Function to set the parent's cmtime field
     68 *                              based on a child's modification time.
     69 *
     70 *      Make_DoAllVar           Set up the various local variables for a
     71 *                              target, including the .ALLSRC variable, making
     72 *                              sure that any variable that needs to exist
     73 *                              at the very least has the empty value.
     74 *
     75 *      Make_OODate             Determine if a target is out-of-date.
     76 *
     77 *      Make_HandleUse          See if a child is a .USE node for a parent
     78 *                              and perform the .USE actions if so.
    7879 */
    7980
    … …  
    8384#include    "job.h"
    8485
    85 static Lst      toBeMade;       /* The current fringe of the graph. These
    86                                 * are nodes which await examination by
    87                                 * MakeOODate. It is added to by
    88                                 * Make_Update and subtracted from by
    89                                 * MakeStartJobs */
    90 static int      numNodes;       /* Number of nodes to be processed. If this
    91                                 * is non-zero when Job_Empty() returns
    92                                 * TRUE, there's a cycle in the graph */
     86static Lst      toBeMade;       /* The current fringe of the graph. These
     87                                * are nodes which await examination by
     88                                * MakeOODate. It is added to by
     89                                * Make_Update and subtracted from by
     90                                * MakeStartJobs */
     91static int      numNodes;       /* Number of nodes to be processed. If this
     92                                * is non-zero when Job_Empty() returns
     93                                * TRUE, there's a cycle in the graph */
    9394
    9495static int MakeAddChild __P((ClientData, ClientData));
    … …  
    101102 *-----------------------------------------------------------------------
    102103 * Make_TimeStamp --
    103  *      Set the cmtime field of a parent node based on the mtime stamp in its
    104  *      child. Called from MakeOODate via Lst_ForEach.
    105  *
    106  * Results:
    107  *      Always returns 0.
    108  *
    109  * Side Effects:
    110  *      The cmtime of the parent node will be changed if the mtime
    111  *      field of the child is greater than it.
     104 *      Set the cmtime field of a parent node based on the mtime stamp in its
     105 *      child. Called from MakeOODate via Lst_ForEach.
     106 *
     107 * Results:
     108 *      Always returns 0.
     109 *
     110 * Side Effects:
     111 *      The cmtime of the parent node will be changed if the mtime
     112 *      field of the child is greater than it.
    112113 *-----------------------------------------------------------------------
    113114 */
    114115int
    115116Make_TimeStamp (pgn, cgn)
    116     GNode *pgn; /* the current parent */
    117     GNode *cgn; /* the child we've just examined */
     117    GNode *pgn; /* the current parent */
     118    GNode *cgn; /* the child we've just examined */
    118119{
    119120    if (cgn->mtime > pgn->cmtime) {
    120         pgn->cmtime = cgn->mtime;
     121        pgn->cmtime = cgn->mtime;
    121122    }
    122123    return (0);
    … …  
    125126static int
    126127MakeTimeStamp (pgn, cgn)
    127     ClientData pgn;     /* the current parent */
    128     ClientData cgn;     /* the child we've just examined */
     128    ClientData pgn;     /* the current parent */
     129    ClientData cgn;     /* the child we've just examined */
    129130{
    130131    return Make_TimeStamp((GNode *) pgn, (GNode *) cgn);
    … …  
    135136 *-----------------------------------------------------------------------
    136137 * Make_OODate --
    137  *      See if a given node is out of date with respect to its sources.
    138  *      Used by Make_Run when deciding which nodes to place on the
    139  *      toBeMade queue initially and by Make_Update to screen out USE and
    140  *      EXEC nodes. In the latter case, however, any other sort of node
    141  *      must be considered out-of-date since at least one of its children
    142  *      will have been recreated.
    143  *
    144  * Results:
    145  *      TRUE if the node is out of date. FALSE otherwise.
    146  *
    147  * Side Effects:
    148  *      The mtime field of the node and the cmtime field of its parents
    149  *      will/may be changed.
     138 *      See if a given node is out of date with respect to its sources.
     139 *      Used by Make_Run when deciding which nodes to place on the
     140 *      toBeMade queue initially and by Make_Update to screen out USE and
     141 *      EXEC nodes. In the latter case, however, any other sort of node
     142 *      must be considered out-of-date since at least one of its children
     143 *      will have been recreated.
     144 *
     145 * Results:
     146 *      TRUE if the node is out of date. FALSE otherwise.
     147 *
     148 * Side Effects:
     149 *      The mtime field of the node and the cmtime field of its parents
     150 *      will/may be changed.
    150151 *-----------------------------------------------------------------------
    151152 */
    152153Boolean
    153154Make_OODate (gn)
    154     register GNode *gn;       /* the node to check */
     155    register GNode *gn;       /* the node to check */
    155156{
    156157    Boolean         oodate;
    … …  
    161162     */
    162163    if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC)) == 0) {
    163         (void) Dir_MTime (gn);
    164         if (DEBUG(MAKE)) {
    165             if (gn->mtime != 0) {
    166                 printf ("modified %s...", Targ_FmtTime(gn->mtime));
    167             } else {
    168                 printf ("non-existent...");
    169             }
    170         }
     164        (void) Dir_MTime (gn);
     165        if (DEBUG(MAKE)) {
     166            if (gn->mtime != 0) {
     167                printf ("modified %s...", Targ_FmtTime(gn->mtime));
     168            } else {
     169                printf ("non-existent...");
     170            }
     171        }
    171172    }
    172173
    173174    /*
    174175     * A target is remade in one of the following circumstances:
    175      *  its modification time is smaller than that of its youngest child
    176      *      and it would actually be run (has commands or type OP_NOP)
    177      *  it's the object of a force operator
    178      *  it has no children, was on the lhs of an operator and doesn't exist
    179      *      already.
     176     *  its modification time is smaller than that of its youngest child
     177     *      and it would actually be run (has commands or type OP_NOP)
     178     *  it's the object of a force operator
     179     *  it has no children, was on the lhs of an operator and doesn't exist
     180     *      already.
    180181     *
    181182     * Libraries are only considered out-of-date if the archive module says
    … …  
    186187     */
    187188    if (gn->type & OP_USE) {
    188         /*
    189         * If the node is a USE node it is *never* out of date
    190         * no matter *what*.
    191         */
    192         if (DEBUG(MAKE)) {
    193             printf(".USE node...");
    194         }
    195         oodate = FALSE;
     189        /*
     190        * If the node is a USE node it is *never* out of date
     191        * no matter *what*.
     192        */
     193        if (DEBUG(MAKE)) {
     194            printf(".USE node...");
     195        }
     196        oodate = FALSE;
    196197#ifdef USE_ARCHIVES
    197198    } else if (gn->type & OP_LIB) {
    198         if (DEBUG(MAKE)) {
    199             printf("library...");
    200         }
    201 
    202         /*
    203         * always out of date if no children and :: target
    204         */
    205 
    206         oodate = Arch_LibOODate (gn) ||
    207             ((gn->cmtime == 0) && (gn->type & OP_DOUBLEDEP));
     199        if (DEBUG(MAKE)) {
     200            printf("library...");
     201        }
     202
     203        /*
     204        * always out of date if no children and :: target
     205        */
     206
     207        oodate = Arch_LibOODate (gn) ||
     208            ((gn->cmtime == 0) && (gn->type & OP_DOUBLEDEP));
    208209#endif
    209210    } else if (gn->type & OP_JOIN) {
    210         /*
    211         * A target with the .JOIN attribute is only considered
    212         * out-of-date if any of its children was out-of-date.
    213         */
    214         if (DEBUG(MAKE)) {
    215             printf(".JOIN node...");
    216         }
    217         oodate = gn->childMade;
     211        /*
     212        * A target with the .JOIN attribute is only considered
     213        * out-of-date if any of its children was out-of-date.
     214        */
     215        if (DEBUG(MAKE)) {
     216            printf(".JOIN node...");
     217        }
     218        oodate = gn->childMade;
    218219    } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) {
    219         /*
    220         * A node which is the object of the force (!) operator or which has
    221         * the .EXEC attribute is always considered out-of-date.
    222         */
    223         if (DEBUG(MAKE)) {
    224             if (gn->type & OP_FORCE) {
    225                 printf("! operator...");
    226             } else if (gn->type & OP_PHONY) {
    227                 printf(".PHONY node...");
    228             } else {
    229                 printf(".EXEC node...");
    230             }
    231         }
    232         oodate = TRUE;
     220        /*
     221        * A node which is the object of the force (!) operator or which has
     222        * the .EXEC attribute is always considered out-of-date.
     223        */
     224        if (DEBUG(MAKE)) {
     225            if (gn->type & OP_FORCE) {
     226                printf("! operator...");
     227            } else if (gn->type & OP_PHONY) {
     228                printf(".PHONY node...");
     229            } else {
     230                printf(".EXEC node...");
     231            }
     232        }
     233        oodate = TRUE;
    233234    } else if ((gn->mtime < gn->cmtime) ||
    234                ((gn->cmtime == 0) &&
    235                 ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP))))
     235               ((gn->cmtime == 0) &&
     236                ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP))))
    236237    {
    237         /*
    238         * A node whose modification time is less than that of its
    239         * youngest child or that has no children (cmtime == 0) and
    240         * either doesn't exist (mtime == 0) or was the object of a
    241         * :: operator is out-of-date. Why? Because that's the way Make does
    242         * it.
    243         */
    244         if (DEBUG(MAKE)) {
    245             if (gn->mtime < gn->cmtime) {
    246                 printf("modified before source...");
    247             } else if (gn->mtime == 0) {
    248                 printf("non-existent and no sources...");
    249             } else {
    250                 printf(":: operator and no sources...");
    251             }
    252         }
    253         oodate = TRUE;
     238        /*
     239        * A node whose modification time is less than that of its
     240        * youngest child or that has no children (cmtime == 0) and
     241        * either doesn't exist (mtime == 0) or was the object of a
     242        * :: operator is out-of-date. Why? Because that's the way Make does
     243        * it.
     244        */
     245        if (DEBUG(MAKE)) {
     246            if (gn->mtime < gn->cmtime) {
     247                printf("modified before source...");
     248            } else if (gn->mtime == 0) {
     249                printf("non-existent and no sources...");
     250            } else {
     251                printf(":: operator and no sources...");
     252            }
     253        }
     254        oodate = TRUE;
    254255    } else {
    255256#if 0
    256         /* WHY? */
    257         if (DEBUG(MAKE)) {
    258             printf("source %smade...", gn->childMade ? "" : "not ");
    259         }
    260         oodate = gn->childMade;
     257        /* WHY? */
     258        if (DEBUG(MAKE)) {
     259            printf("source %smade...", gn->childMade ? "" : "not ");
     260        }
     261        oodate = gn->childMade;
    261262#else
    262         oodate = FALSE;
     263        oodate = FALSE;
    263264#endif /* 0 */
    264265    }
    … …  
    272273     */
    273274    if (!oodate) {
    274         Lst_ForEach (gn->parents, MakeTimeStamp, (ClientData)gn);
     275        Lst_ForEach (gn->parents, MakeTimeStamp, (ClientData)gn);
    275276    }
    276277
    … …  
    282283 *-----------------------------------------------------------------------
    283284 * MakeAddChild  --
    284  *      Function used by Make_Run to add a child to the list l.
    285  *      It will only add the child if its make field is FALSE.
    286  *
    287  * Results:
    288  *      Always returns 0
    289  *
    290  * Side Effects:
    291  *      The given list is extended
     285 *      Function used by Make_Run to add a child to the list l.
     286 *      It will only add the child if its make field is FALSE.
     287 *
     288 * Results:
     289 *      Always returns 0
     290 *
     291 * Side Effects:
     292 *      The given list is extended
    292293 *-----------------------------------------------------------------------
    293294 */
    294295static int
    295296MakeAddChild (gnp, lp)
    296     ClientData     gnp;         /* the node to add */
    297     ClientData     lp;          /* the list to which to add it */
     297    ClientData     gnp;         /* the node to add */
     298    ClientData     lp;          /* the list to which to add it */
    298299{
    299300    GNode          *gn = (GNode *) gnp;
    … …  
    301302
    302303    if (!gn->make && !(gn->type & OP_USE)) {
    303         (void)Lst_EnQueue (l, (ClientData)gn);
     304        (void)Lst_EnQueue (l, (ClientData)gn);
    304305    }
    305306    return (0);
    … …  
    310311 *-----------------------------------------------------------------------
    311312 * Make_HandleUse --
    312  *      Function called by Make_Run and SuffApplyTransform on the downward
    313  *      pass to handle .USE and transformation nodes. A callback function
    314  *      for Lst_ForEach, it implements the .USE and transformation
    315  *      functionality by copying the node's commands, type flags
    316  *      and children to the parent node. Should be called before the
    317  *      children are enqueued to be looked at by MakeAddChild.
    318  *
    319  *      A .USE node is much like an explicit transformation rule, except
    320  *      its commands are always added to the target node, even if the
    321  *      target already has commands.
    322  *
    323  * Results:
    324  *      returns 0.
    325  *
    326  * Side Effects:
    327  *      Children and commands may be added to the parent and the parent's
    328  *      type may be changed.
     313 *      Function called by Make_Run and SuffApplyTransform on the downward
     314 *      pass to handle .USE and transformation nodes. A callback function
     315 *      for Lst_ForEach, it implements the .USE and transformation
     316 *      functionality by copying the node's commands, type flags
     317 *      and children to the parent node. Should be called before the
     318 *      children are enqueued to be looked at by MakeAddChild.
     319 *
     320 *      A .USE node is much like an explicit transformation rule, except
     321 *      its commands are always added to the target node, even if the
     322 *      target already has commands.
     323 *
     324 * Results:
     325 *      returns 0.
     326 *
     327 * Side Effects:
     328 *      Children and commands may be added to the parent and the parent's
     329 *      type may be changed.
    329330 *
    330331 *-----------------------------------------------------------------------
    … …  
    332333int
    333334Make_HandleUse (cgn, pgn)
    334     register GNode      *cgn;   /* The .USE node */
    335     register GNode      *pgn;   /* The target of the .USE node */
    336 {
    337     register GNode      *gn;    /* A child of the .USE node */
    338     register LstNode    ln;     /* An element in the children list */
     335    register GNode      *cgn;   /* The .USE node */
     336    register GNode      *pgn;   /* The target of the .USE node */
     337{
     338    register GNode      *gn;    /* A child of the .USE node */
     339    register LstNode    ln;     /* An element in the children list */
    339340
    340341    if (cgn->type & (OP_USE|OP_TRANSFORM)) {
    341         if ((cgn->type & OP_USE) || Lst_IsEmpty(pgn->commands)) {
    342             /*
    343              * .USE or transformation and target has no commands -- append
    344              * the child's commands to the parent.
    345              */
    346             (void) Lst_Concat (pgn->commands, cgn->commands, LST_CONCNEW);
    347         }
    348 
    349         if (Lst_Open (cgn->children) == SUCCESS) {
    350             while ((ln = Lst_Next (cgn->children)) != NILLNODE) {
    351                 gn = (GNode *)Lst_Datum (ln);
    352 
    353                 if (Lst_Member (pgn->children, gn) == NILLNODE) {
    354                     (void) Lst_AtEnd (pgn->children, gn);
    355                     (void) Lst_AtEnd (gn->parents, pgn);
    356                     pgn->unmade += 1;
    357                 }
    358             }
    359             Lst_Close (cgn->children);
    360         }
    361 
    362         pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM);
    363 
    364         /*
    365         * This child node is now "made", so we decrement the count of
    366         * unmade children in the parent... We also remove the child
    367         * from the parent's list to accurately reflect the number of decent
    368         * children the parent has. This is used by Make_Run to decide
    369         * whether to queue the parent or examine its children...
    370         */
    371         if (cgn->type & OP_USE) {
    372             pgn->unmade--;
    373         }
     342        if ((cgn->type & OP_USE) || Lst_IsEmpty(pgn->commands)) {
     343            /*
     344             * .USE or transformation and target has no commands -- append
     345             * the child's commands to the parent.
     346             */
     347            (void) Lst_Concat (pgn->commands, cgn->commands, LST_CONCNEW);
     348        }
     349
     350        if (Lst_Open (cgn->children) == SUCCESS) {
     351            while ((ln = Lst_Next (cgn->children)) != NILLNODE) {
     352                gn = (GNode *)Lst_Datum (ln);
     353
     354                if (Lst_Member (pgn->children, gn) == NILLNODE) {
     355                    (void) Lst_AtEnd (pgn->children, gn);
     356                    (void) Lst_AtEnd (gn->parents, pgn);
     357                    pgn->unmade += 1;
     358                }
     359            }
     360            Lst_Close (cgn->children);
     361        }
     362
     363        pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM);
     364
     365        /*
     366        * This child node is now "made", so we decrement the count of
     367        * unmade children in the parent... We also remove the child
     368        * from the parent's list to accurately reflect the number of decent
     369        * children the parent has. This is used by Make_Run to decide
     370        * whether to queue the parent or examine its children...
     371        */
     372        if (cgn->type & OP_USE) {
     373            pgn->unmade--;
     374        }
    374375    }
    375376    return (0);
    … …  
    377378static int
    378379MakeHandleUse (pgn, cgn)
    379     ClientData pgn;     /* the current parent */
    380     ClientData cgn;     /* the child we've just examined */
     380    ClientData pgn;     /* the current parent */
     381    ClientData cgn;     /* the child we've just examined */
    381382{
    382383    return Make_HandleUse((GNode *) pgn, (GNode *) cgn);
    … …  
    387388 *-----------------------------------------------------------------------
    388389 * Make_Update  --
    389  *      Perform update on the parents of a node. Used by JobFinish once
    390  *      a node has been dealt with and by MakeStartJobs if it finds an
    391  *      up-to-date node.
    392  *
    393  * Results:
    394  *      Always returns 0
    395  *
    396  * Side Effects:
    397  *      The unmade field of pgn is decremented and pgn may be placed on
    398  *      the toBeMade queue if this field becomes 0.
    399  *
    400  *      If the child was made, the parent's childMade field will be set true
    401  *      and its cmtime set to now.
    402  *
    403  *      If the child wasn't made, the cmtime field of the parent will be
    404  *      altered if the child's mtime is big enough.
    405  *
    406  *      Finally, if the child is the implied source for the parent, the
    407  *      parent's IMPSRC variable is set appropriately.
     390 *      Perform update on the parents of a node. Used by JobFinish once
     391 *      a node has been dealt with and by MakeStartJobs if it finds an
     392 *      up-to-date node.
     393 *
     394 * Results:
     395 *      Always returns 0
     396 *
     397 * Side Effects:
     398 *      The unmade field of pgn is decremented and pgn may be placed on
     399 *      the toBeMade queue if this field becomes 0.
     400 *
     401 *      If the child was made, the parent's childMade field will be set true
     402 *      and its cmtime set to now.
     403 *
     404 *      If the child wasn't made, the cmtime field of the parent will be
     405 *      altered if the child's mtime is big enough.
     406 *
     407 *      Finally, if the child is the implied source for the parent, the
     408 *      parent's IMPSRC variable is set appropriately.
    408409 *
    409410 *-----------------------------------------------------------------------
    … …  
    411412void
    412413Make_Update (cgn)
    413     register GNode *cgn;        /* the child node */
    414 {
    415     register GNode      *pgn;   /* the parent node */
    416     register char       *cname; /* the child's name */
    417     register LstNode    ln;     /* Element in parents and iParents lists */
     414    register GNode *cgn;        /* the child node */
     415{
     416    register GNode      *pgn;   /* the parent node */
     417    register char       *cname; /* the child's name */
     418    register LstNode    ln;     /* Element in parents and iParents lists */
    418419    char *p1;
    419420
    … …  
    428429    if (cgn->made != UPTODATE) {
    429430#ifndef RECHECK
    430         /*
    431         * We can't re-stat the thing, but we can at least take care of rules
    432         * where a target depends on a source that actually creates the
    433         * target, but only if it has changed, e.g.
    434         *
    435         * parse.h : parse.o
    436         *
    437         * parse.o : parse.y
    438          *      yacc -d parse.y
    439          *      cc -c y.tab.c
    440          *      mv y.tab.o parse.o
    441          *      cmp -s y.tab.h parse.h || mv y.tab.h parse.h
    442         *
    443         * In this case, if the definitions produced by yacc haven't changed
    444         * from before, parse.h won't have been updated and cgn->mtime will
    445         * reflect the current modification time for parse.h. This is
    446         * something of a kludge, I admit, but it's a useful one..
    447         * XXX: People like to use a rule like
    448         *
    449         * FRC:
    450         *
    451         * To force things that depend on FRC to be made, so we have to
    452         * check for gn->children being empty as well...
    453         */
    454         if (!Lst_IsEmpty(cgn->commands) || Lst_IsEmpty(cgn->children)) {
    455             cgn->mtime = now;
    456         }
     431        /*
     432        * We can't re-stat the thing, but we can at least take care of rules
     433        * where a target depends on a source that actually creates the
     434        * target, but only if it has changed, e.g.
     435        *
     436        * parse.h : parse.o
     437        *
     438        * parse.o : parse.y
     439         *      yacc -d parse.y
     440         *      cc -c y.tab.c
     441         *      mv y.tab.o parse.o
     442         *      cmp -s y.tab.h parse.h || mv y.tab.h parse.h
     443        *
     444        * In this case, if the definitions produced by yacc haven't changed
     445        * from before, parse.h won't have been updated and cgn->mtime will
     446        * reflect the current modification time for parse.h. This is
     447        * something of a kludge, I admit, but it's a useful one..
     448        * XXX: People like to use a rule like
     449        *
     450        * FRC:
     451        *
     452        * To force things that depend on FRC to be made, so we have to
     453        * check for gn->children being empty as well...
     454        */
     455        if (!Lst_IsEmpty(cgn->commands) || Lst_IsEmpty(cgn->children)) {
     456            cgn->mtime = now;
     457        }
    457458#else
    458         /*
    459         * This is what Make does and it's actually a good thing, as it
    460         * allows rules like
    461         *
    462          *      cmp -s y.tab.h parse.h || cp y.tab.h parse.h
    463         *
    464         * to function as intended. Unfortunately, thanks to the stateless
    465         * nature of NFS (by which I mean the loose coupling of two clients
    466         * using the same file from a common server), there are times
    467         * when the modification time of a file created on a remote
    468         * machine will not be modified before the local stat() implied by
    469         * the Dir_MTime occurs, thus leading us to believe that the file
    470         * is unchanged, wreaking havoc with files that depend on this one.
    471         *
    472         * I have decided it is better to make too much than to make too
    473         * little, so this stuff is commented out unless you're sure it's ok.
    474         * -- ardeb 1/12/88
    475         */
    476         /*
    477         * Christos, 4/9/92: If we are  saving commands pretend that
    478         * the target is made now. Otherwise archives with ... rules
    479         * don't work!
    480         */
    481         if (noExecute || (cgn->type & OP_SAVE_CMDS) || Dir_MTime(cgn) == 0) {
    482             cgn->mtime = now;
    483         }
    484         if (DEBUG(MAKE)) {
    485             printf("update time: %s\n", Targ_FmtTime(cgn->mtime));
    486         }
     459        /*
     460        * This is what Make does and it's actually a good thing, as it
     461        * allows rules like
     462        *
     463         *      cmp -s y.tab.h parse.h || cp y.tab.h parse.h
     464        *
     465        * to function as intended. Unfortunately, thanks to the stateless
     466        * nature of NFS (by which I mean the loose coupling of two clients
     467        * using the same file from a common server), there are times
     468        * when the modification time of a file created on a remote
     469        * machine will not be modified before the local stat() implied by
     470        * the Dir_MTime occurs, thus leading us to believe that the file
     471        * is unchanged, wreaking havoc with files that depend on this one.
     472        *
     473        * I have decided it is better to make too much than to make too
     474        * little, so this stuff is commented out unless you're sure it's ok.
     475        * -- ardeb 1/12/88
     476        */
     477        /*
     478        * Christos, 4/9/92: If we are  saving commands pretend that
     479        * the target is made now. Otherwise archives with ... rules
     480        * don't work!
     481        */
     482        if (noExecute || (cgn->type & OP_SAVE_CMDS) || Dir_MTime(cgn) == 0) {
     483            cgn->mtime = now;
     484        }
     485        if (DEBUG(MAKE)) {
     486            printf("update time: %s\n", Targ_FmtTime(cgn->mtime));
     487        }
    487488#endif
    488489    }
    489490
    490491    if (Lst_Open (cgn->parents) == SUCCESS) {
    491         while ((ln = Lst_Next (cgn->parents)) != NILLNODE) {
    492             pgn = (GNode *)Lst_Datum (ln);
    493             if (pgn->make) {
    494                 pgn->unmade -= 1;
    495 
    496                 if ( ! (cgn->type & (OP_EXEC|OP_USE))) {
    497                     if (cgn->made == MADE) {
    498                         pgn->childMade = TRUE;
    499                         if (pgn->cmtime < cgn->mtime) {
    500                             pgn->cmtime = cgn->mtime;
    501                         }
    502                     } else {
    503                         (void)Make_TimeStamp (pgn, cgn);
    504                     }
    505                 }
    506                 if (pgn->unmade == 0) {
    507                     /*
    508                      * Queue the node up -- any unmade predecessors will
    509                      * be dealt with in MakeStartJobs.
    510                      */
    511                     (void)Lst_EnQueue (toBeMade, (ClientData)pgn);
    512                 } else if (pgn->unmade < 0) {
    513                     Error ("Graph cycles through %s", pgn->name);
    514                 }
    515             }
    516         }
    517         Lst_Close (cgn->parents);
     492        while ((ln = Lst_Next (cgn->parents)) != NILLNODE) {
     493            pgn = (GNode *)Lst_Datum (ln);
     494            if (pgn->make) {
     495                pgn->unmade -= 1;
     496
     497                if ( ! (cgn->type & (OP_EXEC|OP_USE))) {
     498                    if (cgn->made == MADE) {
     499                        pgn->childMade = TRUE;
     500                        if (pgn->cmtime < cgn->mtime) {
     501                            pgn->cmtime = cgn->mtime;
     502                        }
     503                    } else {
     504                        (void)Make_TimeStamp (pgn, cgn);
     505                    }
     506                }
     507                if (pgn->unmade == 0) {
     508                    /*
     509                     * Queue the node up -- any unmade predecessors will
     510                     * be dealt with in MakeStartJobs.
     511                     */
     512                    (void)Lst_EnQueue (toBeMade, (ClientData)pgn);
     513                } else if (pgn->unmade < 0) {
     514                    Error ("Graph cycles through %s", pgn->name);
     515                }
     516            }
     517        }
     518        Lst_Close (cgn->parents);
    518519    }
    519520    /*
    … …  
    524525     */
    525526    for (ln = Lst_First(cgn->successors); ln != NILLNODE; ln = Lst_Succ(ln)) {
    526         GNode   *succ = (GNode *)Lst_Datum(ln);
    527 
    528         if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
    529             Lst_Member(toBeMade, (ClientData)succ) == NILLNODE)
    530         {
    531             (void)Lst_EnQueue(toBeMade, (ClientData)succ);
    532         }
     527        GNode   *succ = (GNode *)Lst_Datum(ln);
     528
     529        if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
     530            Lst_Member(toBeMade, (ClientData)succ) == NILLNODE)
     531        {
     532            (void)Lst_EnQueue(toBeMade, (ClientData)succ);
     533        }
    533534    }
    534535
    … …  
    538539     */
    539540    if (Lst_Open (cgn->iParents) == SUCCESS) {
    540         char    *p1;
    541         char    *cpref = Var_Value(PREFIX, cgn, &p1);
    542 
    543         while ((ln = Lst_Next (cgn->iParents)) != NILLNODE) {
    544             pgn = (GNode *)Lst_Datum (ln);
    545             if (pgn->make) {
    546                 Var_Set (IMPSRC, cname, pgn);
    547                 Var_Set (PREFIX, cpref, pgn);
    548             }
    549         }
    550         efree(p1);
    551         Lst_Close (cgn->iParents);
     541        char    *p1;
     542        char    *cpref = Var_Value(PREFIX, cgn, &p1);
     543
     544        while ((ln = Lst_Next (cgn->iParents)) != NILLNODE) {
     545            pgn = (GNode *)Lst_Datum (ln);
     546            if (pgn->make) {
     547                Var_Set (IMPSRC, cname, pgn);
     548                Var_Set (PREFIX, cpref, pgn);
     549            }
     550        }
     551        efree(p1);
     552        Lst_Close (cgn->iParents);
    552553    }
    553554}
    … …  
    557558 *-----------------------------------------------------------------------
    558559 * MakeAddAllSrc --
    559  *      Add a child's name to the ALLSRC and OODATE variables of the given
    560  *      node. Called from Make_DoAllVar via Lst_ForEach. A child is added only
    561  *      if it has not been given the .EXEC, .USE or .INVISIBLE attributes.
    562  *      .EXEC and .USE children are very rarely going to be files, so...
    563  *      A child is added to the OODATE variable if its modification time is
    564  *      later than that of its parent, as defined by Make, except if the
    565  *      parent is a .JOIN node. In that case, it is only added to the OODATE
    566  *      variable if it was actually made (since .JOIN nodes don't have
    567  *      modification times, the comparison is rather unfair...)..
    568  *
    569  * Results:
    570  *      Always returns 0
    571  *
    572  * Side Effects:
    573  *      The ALLSRC variable for the given node is extended.
     560 *      Add a child's name to the ALLSRC and OODATE variables of the given
     561 *      node. Called from Make_DoAllVar via Lst_ForEach. A child is added only
     562 *      if it has not been given the .EXEC, .USE or .INVISIBLE attributes.
     563 *      .EXEC and .USE children are very rarely going to be files, so...
     564 *      A child is added to the OODATE variable if its modification time is
     565 *      later than that of its parent, as defined by Make, except if the
     566 *      parent is a .JOIN node. In that case, it is only added to the OODATE
     567 *      variable if it was actually made (since .JOIN nodes don't have
     568 *      modification times, the comparison is rather unfair...)..
     569 *
     570 * Results:
     571 *      Always returns 0
     572 *
     573 * Side Effects:
     574 *      The ALLSRC variable for the given node is extended.
    574575 *-----------------------------------------------------------------------
    575576 */
    576577static int
    577578MakeAddAllSrc (cgnp, pgnp)
    578     ClientData  cgnp;   /* The child to add */
    579     ClientData  pgnp;   /* The parent to whose ALLSRC variable it should be */
    580                         /* added */
    581 {
    582     GNode       *cgn = (GNode *) cgnp;
    583     GNode       *pgn = (GNode *) pgnp;
     579    ClientData  cgnp;   /* The child to add */
     580    ClientData  pgnp;   /* The parent to whose ALLSRC variable it should be */
     581                        /* added */
     582{
     583    GNode       *cgn = (GNode *) cgnp;
     584    GNode       *pgn = (GNode *) pgnp;
    584585    if ((cgn->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) == 0) {
    585         char *child;
    586         char *p1 = NULL;
    587 
    588         if (OP_NOP(cgn->type)) {
    589             /*
    590              * this node is only source; use the specific pathname for it
    591              */
    592             child = cgn->path ? cgn->path : cgn->name;
    593         }
    594         else
    595             child = Var_Value(TARGET, cgn, &p1);
    596         Var_Append (ALLSRC, child, pgn);
    597         if (pgn->type & OP_JOIN) {
    598             if (cgn->made == MADE) {
    599                 Var_Append(OODATE, child, pgn);
    600             }
    601         } else if ((pgn->mtime < cgn->mtime) ||
    602                    (cgn->mtime >= now && cgn->made == MADE))
    603         {
    604             /*
    605              * It goes in the OODATE variable if the parent is younger than the
    606              * child or if the child has been modified more recently than
    607              * the start of the make. This is to keep pmake from getting
    608              * confused if something else updates the parent after the
    609              * make starts (shouldn't happen, I know, but sometimes it
    610              * does). In such a case, if we've updated the kid, the parent
    611              * is likely to have a modification time later than that of
    612              * the kid and anything that relies on the OODATE variable will
    613              * be hosed.
    614              *
    615              * XXX: This will cause all made children to go in the OODATE
    616              * variable, even if they're not touched, if RECHECK isn't defined,
    617              * since cgn->mtime is set to now in Make_Update. According to
    618              * some people, this is good...
    619              */
    620             Var_Append(OODATE, child, pgn);
    621         }
    622         efree(p1);
     586        char *child;
     587        char *p1 = NULL;
     588
     589        if (OP_NOP(cgn->type)) {
     590            /*
     591             * this node is only source; use the specific pathname for it
     592             */
     593            child = cgn->path ? cgn->path : cgn->name;
     594        }
     595        else
     596            child = Var_Value(TARGET, cgn, &p1);
     597        Var_Append (ALLSRC, child, pgn);
     598        if (pgn->type & OP_JOIN) {
     599            if (cgn->made == MADE) {
     600                Var_Append(OODATE, child, pgn);
     601            }
     602        } else if ((pgn->mtime < cgn->mtime) ||
     603                   (cgn->mtime >= now && cgn->made == MADE))
     604        {
     605            /*
     606             * It goes in the OODATE variable if the parent is younger than the
     607             * child or if the child has been modified more recently than
     608             * the start of the make. This is to keep pmake from getting
     609             * confused if something else updates the parent after the
     610             * make starts (shouldn't happen, I know, but sometimes it
     611             * does). In such a case, if we've updated the kid, the parent
     612             * is likely to have a modification time later than that of
     613             * the kid and anything that relies on the OODATE variable will
     614             * be hosed.
     615             *
     616             * XXX: This will cause all made children to go in the OODATE
     617             * variable, even if they're not touched, if RECHECK isn't defined,
     618             * since cgn->mtime is set to now in Make_Update. According to
     619             * some people, this is good...
     620             */
     621            Var_Append(OODATE, child, pgn);
     622        }
     623        efree(p1);
    623624    }
    624625    return (0);
    … …  
    632633 *
    633634 * Results:
    634  *      Always returns 0
    635  *
    636  * Side Effects:
    637  *      The PARENTS variable for the given node is extended.
     635 *      Always returns 0
     636 *
     637 * Side Effects:
     638 *      The PARENTS variable for the given node is extended.
    638639 *-----------------------------------------------------------------------
    639640 */
    640641static int
    641642MakeAddParents (pgnp, cgnp)
    642     ClientData  pgnp;   /* The parent to add to add */
    643     ClientData  cgnp;   /* The child to whose PARENTS variable it should be */
    644 {
    645     GNode       *pgn = (GNode *) pgnp;
    646     GNode       *cgn = (GNode *) cgnp;
     643    ClientData  pgnp;   /* The parent to add to add */
     644    ClientData  cgnp;   /* The child to whose PARENTS variable it should be */
     645{
     646    GNode       *pgn = (GNode *) pgnp;
     647    GNode       *cgn = (GNode *) cgnp;
    647648    if ((pgn->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) == 0) {
    648         char *parent;
    649         char *p1 = NULL;
    650 
    651 
    652         if (OP_NOP(pgn->type) || !(parent = Var_Value(TARGET, pgn, &p1))) {
    653             /* this node is only source; use the specific pathname for it */
    654             parent = pgn->path ? pgn->path : pgn->name;
    655         }
    656         Var_Append(PARENTS, parent, cgn);
    657         efree(p1);
     649        char *parent;
     650        char *p1 = NULL;
     651
     652
     653        if (OP_NOP(pgn->type) || !(parent = Var_Value(TARGET, pgn, &p1))) {
     654            /* this node is only source; use the specific pathname for it */
     655            parent = pgn->path ? pgn->path : pgn->name;
     656        }
     657        Var_Append(PARENTS, parent, cgn);
     658        efree(p1);
    658659    }
    659660    return (0);
    … …  
    665666 *-----------------------------------------------------------------------
    666667 * Make_DoAllVar --
    667  *      Set up the ALLSRC and OODATE variables. Sad to say, it must be
    668  *      done separately, rather than while traversing the graph. This is
    669  *      because Make defined OODATE to contain all sources whose modification
    670  *      times were later than that of the target, *not* those sources that
    671  *      were out-of-date. Since in both compatibility and native modes,
    672  *      the modification time of the parent isn't found until the child
    673  *      has been dealt with, we have to wait until now to fill in the
    674  *      variable. As for ALLSRC, the ordering is important and not
    675  *      guaranteed when in native mode, so it must be set here, too.
    676  *
    677  * Results:
    678  *      None
    679  *
    680  * Side Effects:
    681  *      The ALLSRC and OODATE variables of the given node is filled in.
    682  *      If the node is a .JOIN node, its TARGET variable will be set to
    683  *      match its ALLSRC variable.
     668 *      Set up the ALLSRC and OODATE variables. Sad to say, it must be
     669 *      done separately, rather than while traversing the graph. This is
     670 *      because Make defined OODATE to contain all sources whose modification
     671 *      times were later than that of the target, *not* those sources that
     672 *      were out-of-date. Since in both compatibility and native modes,
     673 *      the modification time of the parent isn't found until the child
     674 *      has been dealt with, we have to wait until now to fill in the
     675 *      variable. As for ALLSRC, the ordering is important and not
     676 *      guaranteed when in native mode, so it must be set here, too.
     677 *
     678 * Results:
     679 *      None
     680 *
     681 * Side Effects:
     682 *      The ALLSRC and OODATE variables of the given node is filled in.
     683 *      If the node is a .JOIN node, its TARGET variable will be set to
     684 *      match its ALLSRC variable.
    684685 *-----------------------------------------------------------------------
    685686 */
    686687void
    687688Make_DoAllVar (gn)
    688     GNode       *gn;
     689    GNode       *gn;
    689690{
    690691    Lst_ForEach (gn->children, MakeAddAllSrc, (ClientData) gn);
    … …  
    694695
    695696    if (!Var_Exists (OODATE, gn)) {
    696         Var_Set (OODATE, "", gn);
     697        Var_Set (OODATE, "", gn);
    697698    }
    698699    if (!Var_Exists (ALLSRC, gn)) {
    699         Var_Set (ALLSRC, "", gn);
     700        Var_Set (ALLSRC, "", gn);
    700701    }
    701702
    702703    if (gn->type & OP_JOIN) {
    703         char *p1;
    704         Var_Set (TARGET, Var_Value (ALLSRC, gn, &p1), gn);
    705         efree(p1);
     704        char *p1;
     705        Var_Set (TARGET, Var_Value (ALLSRC, gn, &p1), gn);
     706        efree(p1);
    706707    }
    707708}
    … …  
    711712 *-----------------------------------------------------------------------
    712713 * MakeStartJobs --
    713  *      Start as many jobs as possible.
    714  *
    715  * Results:
    716  *      If the query flag was given to pmake, no job will be started,
    717  *      but as soon as an out-of-date target is found, this function
    718  *      returns TRUE. At all other times, this function returns FALSE.
    719  *
    720  * Side Effects:
    721  *      Nodes are removed from the toBeMade queue and job table slots
    722  *      are filled.
     714 *      Start as many jobs as possible.
     715 *
     716 * Results:
     717 *      If the query flag was given to pmake, no job will be started,
     718 *      but as soon as an out-of-date target is found, this function
     719 *      returns TRUE. At all other times, this function returns FALSE.
     720 *
     721 * Side Effects:
     722 *      Nodes are removed from the toBeMade queue and job table slots
     723 *      are filled.
    723724 *
    724725 *-----------------------------------------------------------------------
    … …  
    727728MakeStartJobs ()
    728729{
    729     register GNode      *gn;
     730    register GNode      *gn;
    730731
    731732    while (!Job_Full() && !Lst_IsEmpty (toBeMade)) {
    732         gn = (GNode *) Lst_DeQueue (toBeMade);
    733         if (DEBUG(MAKE)) {
    734             printf ("Examining %s...", gn->name);
    735         }
    736         /*
    737         * Make sure any and all predecessors that are going to be made,
    738         * have been.
    739         */
    740         if (!Lst_IsEmpty(gn->preds)) {
    741             LstNode ln;
    742 
    743             for (ln = Lst_First(gn->preds); ln != NILLNODE; ln = Lst_Succ(ln)){
    744                 GNode   *pgn = (GNode *)Lst_Datum(ln);
    745 
    746                 if (pgn->make && pgn->made == UNMADE) {
    747                     if (DEBUG(MAKE)) {
    748                         printf("predecessor %s not made yet.\n", pgn->name);
    749                     }
    750                     break;
    751                 }
    752             }
    753             /*
    754              * If ln isn't nil, there's a predecessor as yet unmade, so we
    755              * just drop this node on the floor. When the node in question
    756              * has been made, it will notice this node as being ready to
    757              * make but as yet unmade and will place the node on the queue.
    758              */
    759             if (ln != NILLNODE) {
    760                 continue;
    761             }
    762         }
    763 
    764         numNodes--;
    765         if (Make_OODate (gn)) {
    766             if (DEBUG(MAKE)) {
    767                 printf ("out-of-date\n");
    768             }
    769             if (queryFlag) {
    770                 return (TRUE);
    771             }
    772             Make_DoAllVar (gn);
    773             Job_Make (gn);
    774         } else {
    775             if (DEBUG(MAKE)) {
    776                 printf ("up-to-date\n");
    777             }
    778             gn->made = UPTODATE;
    779             if (gn->type & OP_JOIN) {
    780                 /*
    781                 * Even for an up-to-date .JOIN node, we need it to have its
    782                 * context variables so references to it get the correct
    783                 * value for .TARGET when building up the context variables
    784                 * of its parent(s)...
    785                 */
    786                 Make_DoAllVar (gn);
    787             }
    788 
    789             Make_Update (gn);
    790         }
     733        gn = (GNode *) Lst_DeQueue (toBeMade);
     734        if (DEBUG(MAKE)) {
     735            printf ("Examining %s...", gn->name);
     736        }
     737        /*
     738        * Make sure any and all predecessors that are going to be made,
     739        * have been.
     740        */
     741        if (!Lst_IsEmpty(gn->preds)) {
     742            LstNode ln;
     743
     744            for (ln = Lst_First(gn->preds); ln != NILLNODE; ln = Lst_Succ(ln)){
     745                GNode   *pgn = (GNode *)Lst_Datum(ln);
     746
     747                if (pgn->make && pgn->made == UNMADE) {
     748                    if (DEBUG(MAKE)) {
     749                        printf("predecessor %s not made yet.\n", pgn->name);
     750                    }
     751                    break;
     752                }
     753            }
     754            /*
     755             * If ln isn't nil, there's a predecessor as yet unmade, so we
     756             * just drop this node on the floor. When the node in question
     757             * has been made, it will notice this node as being ready to
     758             * make but as yet unmade and will place the node on the queue.
     759             */
     760            if (ln != NILLNODE) {
     761                continue;
     762            }
     763        }
     764
     765        numNodes--;
     766        if (Make_OODate (gn)) {
     767            if (DEBUG(MAKE)) {
     768                printf ("out-of-date\n");
     769            }
     770            if (queryFlag) {
     771                return (TRUE);
     772            }
     773            Make_DoAllVar (gn);
     774            Job_Make (gn);
     775        } else {
     776            if (DEBUG(MAKE)) {
     777                printf ("up-to-date\n");
     778            }
     779            gn->made = UPTODATE;
     780            if (gn->type & OP_JOIN) {
     781                /*
     782                * Even for an up-to-date .JOIN node, we need it to have its
     783                * context variables so references to it get the correct
     784                * value for .TARGET when building up the context variables
     785                * of its parent(s)...
     786                */
     787                Make_DoAllVar (gn);
     788            }
     789
     790            Make_Update (gn);
     791        }
    791792    }
    792793    return (FALSE);
    … …  
    797798 *-----------------------------------------------------------------------
    798799 * MakePrintStatus --
    799  *      Print the status of a top-level node, viz. it being up-to-date
    800  *      already or not created due to an error in a lower level.
    801  *      Callback function for Make_Run via Lst_ForEach.
    802  *
    803  * Results:
    804  *      Always returns 0.
    805  *
    806  * Side Effects:
    807  *      A message may be printed.
     800 *      Print the status of a top-level node, viz. it being up-to-date
     801 *      already or not created due to an error in a lower level.
     802 *      Callback function for Make_Run via Lst_ForEach.
     803 *
     804 * Results:
     805 *      Always returns 0.
     806 *
     807 * Side Effects:
     808 *      A message may be printed.
    808809 *
    809810 *-----------------------------------------------------------------------
    … …  
    811812static int
    812813MakePrintStatus(gnp, cyclep)
    813     ClientData  gnp;        /* Node to examine */
    814     ClientData  cyclep;     /* True if gn->unmade being non-zero implies
    815                              * a cycle in the graph, not an error in an
    816                              * inferior */
    817 {
    818     GNode       *gn = (GNode *) gnp;
    819     Boolean     cycle = *(Boolean *) cyclep;
     814    ClientData  gnp;        /* Node to examine */
     815    ClientData  cyclep;     /* True if gn->unmade being non-zero implies
     816                             * a cycle in the graph, not an error in an
     817                             * inferior */
     818{
     819    GNode       *gn = (GNode *) gnp;
     820    Boolean     cycle = *(Boolean *) cyclep;
    820821    if (gn->made == UPTODATE) {
    821         printf ("`%s' is up to date.\n", gn->name);
     822        printf ("`%s' is up to date.\n", gn->name);
    822823    } else if (gn->unmade != 0) {
    823         if (cycle) {
    824             Boolean t = TRUE;
    825             /*
    826              * If printing cycles and came to one that has unmade children,
    827              * print out the cycle by recursing on its children. Note a
    828              * cycle like:
    829              *  a : b
    830              *  b : c
    831              *  c : b
    832              * will cause this to erroneously complain about a being in
    833              * the cycle, but this is a good approximation.
    834              */
    835             if (gn->made == CYCLE) {
    836                 Error("Graph cycles through `%s'", gn->name);
    837                 gn->made = ENDCYCLE;
    838                 Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
    839                 gn->made = UNMADE;
    840             } else if (gn->made != ENDCYCLE) {
    841                 gn->made = CYCLE;
    842                 Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
    843             }
    844         } else {
    845             printf ("`%s' not remade because of errors.\n", gn->name);
    846         }
     824        if (cycle) {
     825            Boolean t = TRUE;
     826            /*
     827             * If printing cycles and came to one that has unmade children,
     828             * print out the cycle by recursing on its children. Note a
     829             * cycle like:
     830             *  a : b
     831             *  b : c
     832             *  c : b
     833             * will cause this to erroneously complain about a being in
     834             * the cycle, but this is a good approximation.
     835             */
     836            if (gn->made == CYCLE) {
     837                Error("Graph cycles through `%s'", gn->name);
     838                gn->made = ENDCYCLE;
     839                Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
     840                gn->made = UNMADE;
     841            } else if (gn->made != ENDCYCLE) {
     842                gn->made = CYCLE;
     843                Lst_ForEach(gn->children, MakePrintStatus, (ClientData) &t);
     844            }
     845        } else {
     846            printf ("`%s' not remade because of errors.\n", gn->name);
     847        }
    847848    }
    848849    return (0);
    … …  
    853854 *-----------------------------------------------------------------------
    854855 * Make_Run --
    855  *      Initialize the nodes to remake and the list of nodes which are
    856  *      ready to be made by doing a breadth-first traversal of the graph
    857  *      starting from the nodes in the given list. Once this traversal
    858  *      is finished, all the 'leaves' of the graph are in the toBeMade
    859  *      queue.
    860  *      Using this queue and the Job module, work back up the graph,
    861  *      calling on MakeStartJobs to keep the job table as full as
    862  *      possible.
    863  *
    864  * Results:
    865  *      TRUE if work was done. FALSE otherwise.
    866  *
    867  * Side Effects:
    868  *      The make field of all nodes involved in the creation of the given
    869  *      targets is set to 1. The toBeMade list is set to contain all the
    870  *      'leaves' of these subgraphs.
     856 *      Initialize the nodes to remake and the list of nodes which are
     857 *      ready to be made by doing a breadth-first traversal of the graph
     858 *      starting from the nodes in the given list. Once this traversal
     859 *      is finished, all the 'leaves' of the graph are in the toBeMade
     860 *      queue.
     861 *      Using this queue and the Job module, work back up the graph,
     862 *      calling on MakeStartJobs to keep the job table as full as
     863 *      possible.
     864 *
     865 * Results:
     866 *      TRUE if work was done. FALSE otherwise.
     867 *
     868 * Side Effects:
     869 *      The make field of all nodes involved in the creation of the given
     870 *      targets is set to 1. The toBeMade list is set to contain all the
     871 *      'leaves' of these subgraphs.
    871872 *-----------------------------------------------------------------------
    872873 */
    873874Boolean
    874875Make_Run (targs)
    875     Lst             targs;      /* the initial list of targets */
    876 {
    877     register GNode  *gn;        /* a temporary pointer */
    878     register Lst    examine;    /* List of targets to examine */
    879     int             errors;     /* Number of errors the Job module reports */
     876    Lst             targs;      /* the initial list of targets */
     877{
     878    register GNode  *gn;        /* a temporary pointer */
     879    register Lst    examine;    /* List of targets to examine */
     880    int             errors;     /* Number of errors the Job module reports */
    880881
    881882    toBeMade = Lst_Init (FALSE);
    … …  
    893894     */
    894895    while (!Lst_IsEmpty (examine)) {
    895         gn = (GNode *) Lst_DeQueue (examine);
    896 
    897         if (!gn->make) {
    898             gn->make = TRUE;
    899             numNodes++;
    900 
    901             /*
    902              * Apply any .USE rules before looking for implicit dependencies
    903              * to make sure everything has commands that should...
    904              */
    905             Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn);
    906             Suff_FindDeps (gn);
    907 
    908             if (gn->unmade != 0) {
    909                 Lst_ForEach (gn->children, MakeAddChild, (ClientData)examine);
    910             } else {
    911                 (void)Lst_EnQueue (toBeMade, (ClientData)gn);
    912             }
    913         }
     896        gn = (GNode *) Lst_DeQueue (examine);
     897
     898        if (!gn->make) {
     899            gn->make = TRUE;
     900            numNodes++;
     901
     902            /*
     903             * Apply any .USE rules before looking for implicit dependencies
     904             * to make sure everything has commands that should...
     905             */
     906            Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn);
     907            Suff_FindDeps (gn);
     908
     909            if (gn->unmade != 0) {
     910                Lst_ForEach (gn->children, MakeAddChild, (ClientData)examine);
     911            } else {
     912                (void)Lst_EnQueue (toBeMade, (ClientData)gn);
     913            }
     914        }
    914915    }
    915916
    … …  
    917918
    918919    if (queryFlag) {
    919         /*
    920         * We wouldn't do any work unless we could start some jobs in the
    921         * next loop... (we won't actually start any, of course, this is just
    922         * to see if any of the targets was out of date)
    923         */
    924         return (MakeStartJobs());
     920        /*
     921        * We wouldn't do any work unless we could start some jobs in the
     922        * next loop... (we won't actually start any, of course, this is just
     923        * to see if any of the targets was out of date)
     924        */
     925        return (MakeStartJobs());
    925926    } else {
    926         /*
    927         * Initialization. At the moment, no jobs are running and until some
    928         * get started, nothing will happen since the remaining upward
    929         * traversal of the graph is performed by the routines in job.c upon
    930         * the finishing of a job. So we fill the Job table as much as we can
    931         * before going into our loop.
    932         */
    933         (void) MakeStartJobs();
     927        /*
     928        * Initialization. At the moment, no jobs are running and until some
     929        * get started, nothing will happen since the remaining upward
     930        * traversal of the graph is performed by the routines in job.c upon
     931        * the finishing of a job. So we fill the Job table as much as we can
     932        * before going into our loop.
     933        */
     934        (void) MakeStartJobs();
    934935    }
    935936
    … …  
    945946     */
    946947    while (!Job_Empty ()) {
    947         Job_CatchOutput ();
    948         Job_CatchChildren (!usePipes);
    949         (void)MakeStartJobs();
     948        Job_CatchOutput ();
     949        Job_CatchChildren (!usePipes);
     950        (void)MakeStartJobs();
    950951    }
    951952
Note: See TracChangeset for help on using the changeset viewer.