contrib/bmake/targ.c

   1 /*      $NetBSD: targ.c,v 1.62 2017/04/16 19:53:58 riastradh Exp $      */
   2
   3 /*
   4  * Copyright (c) 1988, 1989, 1990, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Adam de Boor.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 /*
  36  * Copyright (c) 1989 by Berkeley Softworks
  37  * All rights reserved.
  38  *
  39  * This code is derived from software contributed to Berkeley by
  40  * Adam de Boor.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. All advertising materials mentioning features or use of this software
  51  *    must display the following acknowledgement:
  52  *      This product includes software developed by the University of
  53  *      California, Berkeley and its contributors.
  54  * 4. Neither the name of the University nor the names of its contributors
  55  *    may be used to endorse or promote products derived from this software
  56  *    without specific prior written permission.
  57  *
  58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  68  * SUCH DAMAGE.
  69  */
  70
  71 #ifndef MAKE_NATIVE
  72 static char rcsid[] = "$NetBSD: targ.c,v 1.62 2017/04/16 19:53:58 riastradh Exp $";
  73 #else
  74 #include <sys/cdefs.h>
  75 #ifndef lint
  76 #if 0
  77 static char sccsid[] = "@(#)targ.c      8.2 (Berkeley) 3/19/94";
  78 #else
  79 __RCSID("$NetBSD: targ.c,v 1.62 2017/04/16 19:53:58 riastradh Exp $");
  80 #endif
  81 #endif /* not lint */
  82 #endif
  83
  84 /*-
  85  * targ.c --
  86  *      Functions for maintaining the Lst allTargets. Target nodes are
  87  * kept in two structures: a Lst, maintained by the list library, and a
  88  * hash table, maintained by the hash library.
  89  *
  90  * Interface:
  91  *      Targ_Init               Initialization procedure.
  92  *
  93  *      Targ_End                Cleanup the module
  94  *
  95  *      Targ_List               Return the list of all targets so far.
  96  *
  97  *      Targ_NewGN              Create a new GNode for the passed target
  98  *                              (string). The node is *not* placed in the
  99  *                              hash table, though all its fields are
 100  *                              initialized.
 101  *
 102  *      Targ_FindNode           Find the node for a given target, creating
 103  *                              and storing it if it doesn't exist and the
 104  *                              flags are right (TARG_CREATE)
 105  *
 106  *      Targ_FindList           Given a list of names, find nodes for all
 107  *                              of them. If a name doesn't exist and the
 108  *                              TARG_NOCREATE flag was given, an error message
 109  *                              is printed. Else, if a name doesn't exist,
 110  *                              its node is created.
 111  *
 112  *      Targ_Ignore             Return TRUE if errors should be ignored when
 113  *                              creating the given target.
 114  *
 115  *      Targ_Silent             Return TRUE if we should be silent when
 116  *                              creating the given target.
 117  *
 118  *      Targ_Precious           Return TRUE if the target is precious and
 119  *                              should not be removed if we are interrupted.
 120  *
 121  *      Targ_Propagate          Propagate information between related
 122  *                              nodes.  Should be called after the
 123  *                              makefiles are parsed but before any
 124  *                              action is taken.
 125  *
 126  * Debugging:
 127  *      Targ_PrintGraph         Print out the entire graphm all variables
 128  *                              and statistics for the directory cache. Should
 129  *                              print something for suffixes, too, but...
 130  */
 131
 132 #include          <stdio.h>
 133 #include          <time.h>
 134
 135 #include          "make.h"
 136 #include          "hash.h"
 137 #include          "dir.h"
 138
 139 static Lst        allTargets;   /* the list of all targets found so far */
 140 #ifdef CLEANUP
 141 static Lst        allGNs;       /* List of all the GNodes */
 142 #endif
 143 static Hash_Table targets;      /* a hash table of same */
 144
 145 #define HTSIZE  191             /* initial size of hash table */
 146
 147 static int TargPrintOnlySrc(void *, void *);
 148 static int TargPrintName(void *, void *);
 149 #ifdef CLEANUP
 150 static void TargFreeGN(void *);
 151 #endif
 152 static int TargPropagateCohort(void *, void *);
 153 static int TargPropagateNode(void *, void *);
 154
 155 /*-
 156  *-----------------------------------------------------------------------
 157  * Targ_Init --
 158  *      Initialize this module
 159  *
 160  * Results:
 161  *      None
 162  *
 163  * Side Effects:
 164  *      The allTargets list and the targets hash table are initialized
 165  *-----------------------------------------------------------------------
 166  */
 167 void
 168 Targ_Init(void)
 169 {
 170     allTargets = Lst_Init(FALSE);
 171     Hash_InitTable(&targets, HTSIZE);
 172 }
 173
 174 /*-
 175  *-----------------------------------------------------------------------
 176  * Targ_End --
 177  *      Finalize this module
 178  *
 179  * Results:
 180  *      None
 181  *
 182  * Side Effects:
 183  *      All lists and gnodes are cleared
 184  *-----------------------------------------------------------------------
 185  */
 186 void
 187 Targ_End(void)
 188 {
 189 #ifdef CLEANUP
 190     Lst_Destroy(allTargets, NULL);
 191     if (allGNs)
 192         Lst_Destroy(allGNs, TargFreeGN);
 193     Hash_DeleteTable(&targets);
 194 #endif
 195 }
 196
 197 /*-
 198  *-----------------------------------------------------------------------
 199  * Targ_List --
 200  *      Return the list of all targets
 201  *
 202  * Results:
 203  *      The list of all targets.
 204  *
 205  * Side Effects:
 206  *      None
 207  *-----------------------------------------------------------------------
 208  */
 209 Lst
 210 Targ_List(void)
 211 {
 212     return allTargets;
 213 }
 214
 215 /*-
 216  *-----------------------------------------------------------------------
 217  * Targ_NewGN  --
 218  *      Create and initialize a new graph node
 219  *
 220  * Input:
 221  *      name            the name to stick in the new node
 222  *
 223  * Results:
 224  *      An initialized graph node with the name field filled with a copy
 225  *      of the passed name
 226  *
 227  * Side Effects:
 228  *      The gnode is added to the list of all gnodes.
 229  *-----------------------------------------------------------------------
 230  */
 231 GNode *
 232 Targ_NewGN(const char *name)
 233 {
 234     GNode *gn;
 235
 236     gn = bmake_malloc(sizeof(GNode));
 237     gn->name = bmake_strdup(name);
 238     gn->uname = NULL;
 239     gn->path = NULL;
 240     if (name[0] == '-' && name[1] == 'l') {
 241         gn->type = OP_LIB;
 242     } else {
 243         gn->type = 0;
 244     }
 245     gn->unmade =        0;
 246     gn->unmade_cohorts = 0;
 247     gn->cohort_num[0] = 0;
 248     gn->centurion =     NULL;
 249     gn->made =          UNMADE;
 250     gn->flags =         0;
 251     gn->checked =       0;
 252     gn->mtime =         0;
 253     gn->cmgn =          NULL;
 254     gn->iParents =      Lst_Init(FALSE);
 255     gn->cohorts =       Lst_Init(FALSE);
 256     gn->parents =       Lst_Init(FALSE);
 257     gn->children =      Lst_Init(FALSE);
 258     gn->order_pred =    Lst_Init(FALSE);
 259     gn->order_succ =    Lst_Init(FALSE);
 260     Hash_InitTable(&gn->context, 0);
 261     gn->commands =      Lst_Init(FALSE);
 262     gn->suffix =        NULL;
 263     gn->lineno =        0;
 264     gn->fname =         NULL;
 265
 266 #ifdef CLEANUP
 267     if (allGNs == NULL)
 268         allGNs = Lst_Init(FALSE);
 269     Lst_AtEnd(allGNs, gn);
 270 #endif
 271
 272     return (gn);
 273 }
 274
 275 #ifdef CLEANUP
 276 /*-
 277  *-----------------------------------------------------------------------
 278  * TargFreeGN  --
 279  *      Destroy a GNode
 280  *
 281  * Results:
 282  *      None.
 283  *
 284  * Side Effects:
 285  *      None.
 286  *-----------------------------------------------------------------------
 287  */
 288 static void
 289 TargFreeGN(void *gnp)
 290 {
 291     GNode *gn = (GNode *)gnp;
 292
 293
 294     free(gn->name);
 295     free(gn->uname);
 296     free(gn->path);
 297     /* gn->fname points to name allocated when file was opened, don't free */
 298
 299     Lst_Destroy(gn->iParents, NULL);
 300     Lst_Destroy(gn->cohorts, NULL);
 301     Lst_Destroy(gn->parents, NULL);
 302     Lst_Destroy(gn->children, NULL);
 303     Lst_Destroy(gn->order_succ, NULL);
 304     Lst_Destroy(gn->order_pred, NULL);
 305     Hash_DeleteTable(&gn->context);
 306     Lst_Destroy(gn->commands, NULL);
 307     free(gn);
 308 }
 309 #endif
 310
 311
 312 /*-
 313  *-----------------------------------------------------------------------
 314  * Targ_FindNode  --
 315  *      Find a node in the list using the given name for matching
 316  *
 317  * Input:
 318  *      name            the name to find
 319  *      flags           flags governing events when target not
 320  *                      found
 321  *
 322  * Results:
 323  *      The node in the list if it was. If it wasn't, return NULL of
 324  *      flags was TARG_NOCREATE or the newly created and initialized node
 325  *      if it was TARG_CREATE
 326  *
 327  * Side Effects:
 328  *      Sometimes a node is created and added to the list
 329  *-----------------------------------------------------------------------
 330  */
 331 GNode *
 332 Targ_FindNode(const char *name, int flags)
 333 {
 334     GNode         *gn;        /* node in that element */
 335     Hash_Entry    *he = NULL; /* New or used hash entry for node */
 336     Boolean       isNew;      /* Set TRUE if Hash_CreateEntry had to create */
 337                               /* an entry for the node */
 338
 339     if (!(flags & (TARG_CREATE | TARG_NOHASH))) {
 340         he = Hash_FindEntry(&targets, name);
 341         if (he == NULL)
 342             return NULL;
 343         return (GNode *)Hash_GetValue(he);
 344     }
 345
 346     if (!(flags & TARG_NOHASH)) {
 347         he = Hash_CreateEntry(&targets, name, &isNew);
 348         if (!isNew)
 349             return (GNode *)Hash_GetValue(he);
 350     }
 351
 352     gn = Targ_NewGN(name);
 353     if (!(flags & TARG_NOHASH))
 354         Hash_SetValue(he, gn);
 355     Var_Append(".ALLTARGETS", name, VAR_GLOBAL);
 356     (void)Lst_AtEnd(allTargets, gn);
 357     if (doing_depend)
 358         gn->flags |= FROM_DEPEND;
 359     return gn;
 360 }
 361
 362 /*-
 363  *-----------------------------------------------------------------------
 364  * Targ_FindList --
 365  *      Make a complete list of GNodes from the given list of names
 366  *
 367  * Input:
 368  *      name            list of names to find
 369  *      flags           flags used if no node is found for a given name
 370  *
 371  * Results:
 372  *      A complete list of graph nodes corresponding to all instances of all
 373  *      the names in names.
 374  *
 375  * Side Effects:
 376  *      If flags is TARG_CREATE, nodes will be created for all names in
 377  *      names which do not yet have graph nodes. If flags is TARG_NOCREATE,
 378  *      an error message will be printed for each name which can't be found.
 379  * -----------------------------------------------------------------------
 380  */
 381 Lst
 382 Targ_FindList(Lst names, int flags)
 383 {
 384     Lst            nodes;       /* result list */
 385     LstNode        ln;          /* name list element */
 386     GNode          *gn;         /* node in tLn */
 387     char           *name;
 388
 389     nodes = Lst_Init(FALSE);
 390
 391     if (Lst_Open(names) == FAILURE) {
 392         return (nodes);
 393     }
 394     while ((ln = Lst_Next(names)) != NULL) {
 395         name = (char *)Lst_Datum(ln);
 396         gn = Targ_FindNode(name, flags);
 397         if (gn != NULL) {
 398             /*
 399              * Note: Lst_AtEnd must come before the Lst_Concat so the nodes
 400              * are added to the list in the order in which they were
 401              * encountered in the makefile.
 402              */
 403             (void)Lst_AtEnd(nodes, gn);
 404         } else if (flags == TARG_NOCREATE) {
 405             Error("\"%s\" -- target unknown.", name);
 406         }
 407     }
 408     Lst_Close(names);
 409     return (nodes);
 410 }
 411
 412 /*-
 413  *-----------------------------------------------------------------------
 414  * Targ_Ignore  --
 415  *      Return true if should ignore errors when creating gn
 416  *
 417  * Input:
 418  *      gn              node to check for
 419  *
 420  * Results:
 421  *      TRUE if should ignore errors
 422  *
 423  * Side Effects:
 424  *      None
 425  *-----------------------------------------------------------------------
 426  */
 427 Boolean
 428 Targ_Ignore(GNode *gn)
 429 {
 430     if (ignoreErrors || gn->type & OP_IGNORE) {
 431         return (TRUE);
 432     } else {
 433         return (FALSE);
 434     }
 435 }
 436
 437 /*-
 438  *-----------------------------------------------------------------------
 439  * Targ_Silent  --
 440  *      Return true if be silent when creating gn
 441  *
 442  * Input:
 443  *      gn              node to check for
 444  *
 445  * Results:
 446  *      TRUE if should be silent
 447  *
 448  * Side Effects:
 449  *      None
 450  *-----------------------------------------------------------------------
 451  */
 452 Boolean
 453 Targ_Silent(GNode *gn)
 454 {
 455     if (beSilent || gn->type & OP_SILENT) {
 456         return (TRUE);
 457     } else {
 458         return (FALSE);
 459     }
 460 }
 461
 462 /*-
 463  *-----------------------------------------------------------------------
 464  * Targ_Precious --
 465  *      See if the given target is precious
 466  *
 467  * Input:
 468  *      gn              the node to check
 469  *
 470  * Results:
 471  *      TRUE if it is precious. FALSE otherwise
 472  *
 473  * Side Effects:
 474  *      None
 475  *-----------------------------------------------------------------------
 476  */
 477 Boolean
 478 Targ_Precious(GNode *gn)
 479 {
 480     if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
 481         return (TRUE);
 482     } else {
 483         return (FALSE);
 484     }
 485 }
 486
 487 /******************* DEBUG INFO PRINTING ****************/
 488
 489 static GNode      *mainTarg;    /* the main target, as set by Targ_SetMain */
 490 /*-
 491  *-----------------------------------------------------------------------
 492  * Targ_SetMain --
 493  *      Set our idea of the main target we'll be creating. Used for
 494  *      debugging output.
 495  *
 496  * Input:
 497  *      gn              The main target we'll create
 498  *
 499  * Results:
 500  *      None.
 501  *
 502  * Side Effects:
 503  *      "mainTarg" is set to the main target's node.
 504  *-----------------------------------------------------------------------
 505  */
 506 void
 507 Targ_SetMain(GNode *gn)
 508 {
 509     mainTarg = gn;
 510 }
 511
 512 static int
 513 TargPrintName(void *gnp, void *pflags MAKE_ATTR_UNUSED)
 514 {
 515     GNode *gn = (GNode *)gnp;
 516
 517     fprintf(debug_file, "%s%s ", gn->name, gn->cohort_num);
 518
 519     return 0;
 520 }
 521
 522
 523 int
 524 Targ_PrintCmd(void *cmd, void *dummy MAKE_ATTR_UNUSED)
 525 {
 526     fprintf(debug_file, "\t%s\n", (char *)cmd);
 527     return 0;
 528 }
 529
 530 /*-
 531  *-----------------------------------------------------------------------
 532  * Targ_FmtTime --
 533  *      Format a modification time in some reasonable way and return it.
 534  *
 535  * Results:
 536  *      The time reformatted.
 537  *
 538  * Side Effects:
 539  *      The time is placed in a static area, so it is overwritten
 540  *      with each call.
 541  *
 542  *-----------------------------------------------------------------------
 543  */
 544 char *
 545 Targ_FmtTime(time_t tm)
 546 {
 547     struct tm           *parts;
 548     static char         buf[128];
 549
 550     parts = localtime(&tm);
 551     (void)strftime(buf, sizeof buf, "%k:%M:%S %b %d, %Y", parts);
 552     return(buf);
 553 }
 554
 555 /*-
 556  *-----------------------------------------------------------------------
 557  * Targ_PrintType --
 558  *      Print out a type field giving only those attributes the user can
 559  *      set.
 560  *
 561  * Results:
 562  *
 563  * Side Effects:
 564  *
 565  *-----------------------------------------------------------------------
 566  */
 567 void
 568 Targ_PrintType(int type)
 569 {
 570     int    tbit;
 571
 572 #define PRINTBIT(attr)  case CONCAT(OP_,attr): fprintf(debug_file, "." #attr " "); break
 573 #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG))fprintf(debug_file, "." #attr " "); break
 574
 575     type &= ~OP_OPMASK;
 576
 577     while (type) {
 578         tbit = 1 << (ffs(type) - 1);
 579         type &= ~tbit;
 580
 581         switch(tbit) {
 582             PRINTBIT(OPTIONAL);
 583             PRINTBIT(USE);
 584             PRINTBIT(EXEC);
 585             PRINTBIT(IGNORE);
 586             PRINTBIT(PRECIOUS);
 587             PRINTBIT(SILENT);
 588             PRINTBIT(MAKE);
 589             PRINTBIT(JOIN);
 590             PRINTBIT(INVISIBLE);
 591             PRINTBIT(NOTMAIN);
 592             PRINTDBIT(LIB);
 593             /*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
 594             case OP_MEMBER: if (DEBUG(TARG))fprintf(debug_file, ".MEMBER "); break;
 595             PRINTDBIT(ARCHV);
 596             PRINTDBIT(MADE);
 597             PRINTDBIT(PHONY);
 598         }
 599     }
 600 }
 601
 602 static const char *
 603 made_name(enum enum_made made)
 604 {
 605     switch (made) {
 606     case UNMADE:     return "unmade";
 607     case DEFERRED:   return "deferred";
 608     case REQUESTED:  return "requested";
 609     case BEINGMADE:  return "being made";
 610     case MADE:       return "made";
 611     case UPTODATE:   return "up-to-date";
 612     case ERROR:      return "error when made";
 613     case ABORTED:    return "aborted";
 614     default:         return "unknown enum_made value";
 615     }
 616 }
 617
 618 /*-
 619  *-----------------------------------------------------------------------
 620  * TargPrintNode --
 621  *      print the contents of a node
 622  *-----------------------------------------------------------------------
 623  */
 624 int
 625 Targ_PrintNode(void *gnp, void *passp)
 626 {
 627     GNode         *gn = (GNode *)gnp;
 628     int           pass = passp ? *(int *)passp : 0;
 629
 630     fprintf(debug_file, "# %s%s, flags %x, type %x, made %d\n",
 631             gn->name, gn->cohort_num, gn->flags, gn->type, gn->made);
 632     if (gn->flags == 0)
 633         return 0;
 634
 635     if (!OP_NOP(gn->type)) {
 636         fprintf(debug_file, "#\n");
 637         if (gn == mainTarg) {
 638             fprintf(debug_file, "# *** MAIN TARGET ***\n");
 639         }
 640         if (pass >= 2) {
 641             if (gn->unmade) {
 642                 fprintf(debug_file, "# %d unmade children\n", gn->unmade);
 643             } else {
 644                 fprintf(debug_file, "# No unmade children\n");
 645             }
 646             if (! (gn->type & (OP_JOIN|OP_USE|OP_USEBEFORE|OP_EXEC))) {
 647                 if (gn->mtime != 0) {
 648                     fprintf(debug_file, "# last modified %s: %s\n",
 649                               Targ_FmtTime(gn->mtime),
 650                               made_name(gn->made));
 651                 } else if (gn->made != UNMADE) {
 652                     fprintf(debug_file, "# non-existent (maybe): %s\n",
 653                               made_name(gn->made));
 654                 } else {
 655                     fprintf(debug_file, "# unmade\n");
 656                 }
 657             }
 658             if (!Lst_IsEmpty (gn->iParents)) {
 659                 fprintf(debug_file, "# implicit parents: ");
 660                 Lst_ForEach(gn->iParents, TargPrintName, NULL);
 661                 fprintf(debug_file, "\n");
 662             }
 663         } else {
 664             if (gn->unmade)
 665                 fprintf(debug_file, "# %d unmade children\n", gn->unmade);
 666         }
 667         if (!Lst_IsEmpty (gn->parents)) {
 668             fprintf(debug_file, "# parents: ");
 669             Lst_ForEach(gn->parents, TargPrintName, NULL);
 670             fprintf(debug_file, "\n");
 671         }
 672         if (!Lst_IsEmpty (gn->order_pred)) {
 673             fprintf(debug_file, "# order_pred: ");
 674             Lst_ForEach(gn->order_pred, TargPrintName, NULL);
 675             fprintf(debug_file, "\n");
 676         }
 677         if (!Lst_IsEmpty (gn->order_succ)) {
 678             fprintf(debug_file, "# order_succ: ");
 679             Lst_ForEach(gn->order_succ, TargPrintName, NULL);
 680             fprintf(debug_file, "\n");
 681         }
 682
 683         fprintf(debug_file, "%-16s", gn->name);
 684         switch (gn->type & OP_OPMASK) {
 685             case OP_DEPENDS:
 686                 fprintf(debug_file, ": "); break;
 687             case OP_FORCE:
 688                 fprintf(debug_file, "! "); break;
 689             case OP_DOUBLEDEP:
 690                 fprintf(debug_file, ":: "); break;
 691         }
 692         Targ_PrintType(gn->type);
 693         Lst_ForEach(gn->children, TargPrintName, NULL);
 694         fprintf(debug_file, "\n");
 695         Lst_ForEach(gn->commands, Targ_PrintCmd, NULL);
 696         fprintf(debug_file, "\n\n");
 697         if (gn->type & OP_DOUBLEDEP) {
 698             Lst_ForEach(gn->cohorts, Targ_PrintNode, &pass);
 699         }
 700     }
 701     return (0);
 702 }
 703
 704 /*-
 705  *-----------------------------------------------------------------------
 706  * TargPrintOnlySrc --
 707  *      Print only those targets that are just a source.
 708  *
 709  * Results:
 710  *      0.
 711  *
 712  * Side Effects:
 713  *      The name of each file is printed preceded by #\t
 714  *
 715  *-----------------------------------------------------------------------
 716  */
 717 static int
 718 TargPrintOnlySrc(void *gnp, void *dummy MAKE_ATTR_UNUSED)
 719 {
 720     GNode         *gn = (GNode *)gnp;
 721     if (!OP_NOP(gn->type))
 722         return 0;
 723
 724     fprintf(debug_file, "#\t%s [%s] ",
 725             gn->name, gn->path ? gn->path : gn->name);
 726     Targ_PrintType(gn->type);
 727     fprintf(debug_file, "\n");
 728
 729     return 0;
 730 }
 731
 732 /*-
 733  *-----------------------------------------------------------------------
 734  * Targ_PrintGraph --
 735  *      print the entire graph. heh heh
 736  *
 737  * Input:
 738  *      pass            Which pass this is. 1 => no processing
 739  *                      2 => processing done
 740  *
 741  * Results:
 742  *      none
 743  *
 744  * Side Effects:
 745  *      lots o' output
 746  *-----------------------------------------------------------------------
 747  */
 748 void
 749 Targ_PrintGraph(int pass)
 750 {
 751     fprintf(debug_file, "#*** Input graph:\n");
 752     Lst_ForEach(allTargets, Targ_PrintNode, &pass);
 753     fprintf(debug_file, "\n\n");
 754     fprintf(debug_file, "#\n#   Files that are only sources:\n");
 755     Lst_ForEach(allTargets, TargPrintOnlySrc, NULL);
 756     fprintf(debug_file, "#*** Global Variables:\n");
 757     Var_Dump(VAR_GLOBAL);
 758     fprintf(debug_file, "#*** Command-line Variables:\n");
 759     Var_Dump(VAR_CMD);
 760     fprintf(debug_file, "\n");
 761     Dir_PrintDirectories();
 762     fprintf(debug_file, "\n");
 763     Suff_PrintAll();
 764 }
 765
 766 /*-
 767  *-----------------------------------------------------------------------
 768  * TargPropagateNode --
 769  *      Propagate information from a single node to related nodes if
 770  *      appropriate.
 771  *
 772  * Input:
 773  *      gnp             The node that we are processing.
 774  *
 775  * Results:
 776  *      Always returns 0, for the benefit of Lst_ForEach().
 777  *
 778  * Side Effects:
 779  *      Information is propagated from this node to cohort or child
 780  *      nodes.
 781  *
 782  *      If the node was defined with "::", then TargPropagateCohort()
 783  *      will be called for each cohort node.
 784  *
 785  *      If the node has recursive predecessors, then
 786  *      TargPropagateRecpred() will be called for each recursive
 787  *      predecessor.
 788  *-----------------------------------------------------------------------
 789  */
 790 static int
 791 TargPropagateNode(void *gnp, void *junk MAKE_ATTR_UNUSED)
 792 {
 793     GNode         *gn = (GNode *)gnp;
 794
 795     if (gn->type & OP_DOUBLEDEP)
 796         Lst_ForEach(gn->cohorts, TargPropagateCohort, gnp);
 797     return (0);
 798 }
 799
 800 /*-
 801  *-----------------------------------------------------------------------
 802  * TargPropagateCohort --
 803  *      Propagate some bits in the type mask from a node to
 804  *      a related cohort node.
 805  *
 806  * Input:
 807  *      cnp             The node that we are processing.
 808  *      gnp             Another node that has cnp as a cohort.
 809  *
 810  * Results:
 811  *      Always returns 0, for the benefit of Lst_ForEach().
 812  *
 813  * Side Effects:
 814  *      cnp's type bitmask is modified to incorporate some of the
 815  *      bits from gnp's type bitmask.  (XXX need a better explanation.)
 816  *-----------------------------------------------------------------------
 817  */
 818 static int
 819 TargPropagateCohort(void *cgnp, void *pgnp)
 820 {
 821     GNode         *cgn = (GNode *)cgnp;
 822     GNode         *pgn = (GNode *)pgnp;
 823
 824     cgn->type |= pgn->type & ~OP_OPMASK;
 825     return (0);
 826 }
 827
 828 /*-
 829  *-----------------------------------------------------------------------
 830  * Targ_Propagate --
 831  *      Propagate information between related nodes.  Should be called
 832  *      after the makefiles are parsed but before any action is taken.
 833  *
 834  * Results:
 835  *      none
 836  *
 837  * Side Effects:
 838  *      Information is propagated between related nodes throughout the
 839  *      graph.
 840  *-----------------------------------------------------------------------
 841  */
 842 void
 843 Targ_Propagate(void)
 844 {
 845     Lst_ForEach(allTargets, TargPropagateNode, NULL);
 846 }