Home | History | Annotate | Line # | Download | only in make
targ.c revision 1.46
      1 /*	$NetBSD: targ.c,v 1.46 2006/12/04 21:34:47 dsl 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.46 2006/12/04 21:34:47 dsl 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.46 2006/12/04 21:34:47 dsl 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(ClientData, ClientData);
    148 static int TargPrintName(ClientData, ClientData);
    149 #ifdef CLEANUP
    150 static void TargFreeGN(ClientData);
    151 #endif
    152 static int TargPropagateCohort(ClientData, ClientData);
    153 static int TargPropagateNode(ClientData, ClientData);
    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, NOFREE);
    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 = emalloc(sizeof(GNode));
    237     gn->name = estrdup(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->mtime = gn->cmtime = 0;
    252     gn->iParents =  	Lst_Init(FALSE);
    253     gn->cohorts =   	Lst_Init(FALSE);
    254     gn->parents =   	Lst_Init(FALSE);
    255     gn->children =  	Lst_Init(FALSE);
    256     gn->order_pred =  	Lst_Init(FALSE);
    257     gn->order_succ =  	Lst_Init(FALSE);
    258     Hash_InitTable(&gn->context, 0);
    259     gn->commands =  	Lst_Init(FALSE);
    260     gn->suffix =	NULL;
    261     gn->lineno =	0;
    262     gn->fname = 	NULL;
    263 
    264 #ifdef CLEANUP
    265     if (allGNs == NULL)
    266 	allGNs = Lst_Init(FALSE);
    267     Lst_AtEnd(allGNs, gn);
    268 #endif
    269 
    270     return (gn);
    271 }
    272 
    273 #ifdef CLEANUP
    274 /*-
    275  *-----------------------------------------------------------------------
    276  * TargFreeGN  --
    277  *	Destroy a GNode
    278  *
    279  * Results:
    280  *	None.
    281  *
    282  * Side Effects:
    283  *	None.
    284  *-----------------------------------------------------------------------
    285  */
    286 static void
    287 TargFreeGN(ClientData gnp)
    288 {
    289     GNode *gn = (GNode *)gnp;
    290 
    291 
    292     free(gn->name);
    293     if (gn->uname)
    294 	free(gn->uname);
    295     if (gn->path)
    296 	free(gn->path);
    297     /* gn->fname points to name allocated when file was opened, don't free */
    298 
    299     Lst_Destroy(gn->iParents, NOFREE);
    300     Lst_Destroy(gn->cohorts, NOFREE);
    301     Lst_Destroy(gn->parents, NOFREE);
    302     Lst_Destroy(gn->children, NOFREE);
    303     Lst_Destroy(gn->order_succ, NOFREE);
    304     Lst_Destroy(gn->order_pred, NOFREE);
    305     Hash_DeleteTable(&gn->context);
    306     Lst_Destroy(gn->commands, NOFREE);
    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 NILGNODE 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;	      /* 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 (NILGNODE);
    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     return gn;
    358 }
    359 
    360 /*-
    361  *-----------------------------------------------------------------------
    362  * Targ_FindList --
    363  *	Make a complete list of GNodes from the given list of names
    364  *
    365  * Input:
    366  *	name		list of names to find
    367  *	flags		flags used if no node is found for a given name
    368  *
    369  * Results:
    370  *	A complete list of graph nodes corresponding to all instances of all
    371  *	the names in names.
    372  *
    373  * Side Effects:
    374  *	If flags is TARG_CREATE, nodes will be created for all names in
    375  *	names which do not yet have graph nodes. If flags is TARG_NOCREATE,
    376  *	an error message will be printed for each name which can't be found.
    377  * -----------------------------------------------------------------------
    378  */
    379 Lst
    380 Targ_FindList(Lst names, int flags)
    381 {
    382     Lst            nodes;	/* result list */
    383     LstNode	   ln;		/* name list element */
    384     GNode	   *gn;		/* node in tLn */
    385     char    	   *name;
    386 
    387     nodes = Lst_Init(FALSE);
    388 
    389     if (Lst_Open(names) == FAILURE) {
    390 	return (nodes);
    391     }
    392     while ((ln = Lst_Next(names)) != NILLNODE) {
    393 	name = (char *)Lst_Datum(ln);
    394 	gn = Targ_FindNode(name, flags);
    395 	if (gn != NILGNODE) {
    396 	    /*
    397 	     * Note: Lst_AtEnd must come before the Lst_Concat so the nodes
    398 	     * are added to the list in the order in which they were
    399 	     * encountered in the makefile.
    400 	     */
    401 	    (void)Lst_AtEnd(nodes, gn);
    402 	} else if (flags == TARG_NOCREATE) {
    403 	    Error("\"%s\" -- target unknown.", name);
    404 	}
    405     }
    406     Lst_Close(names);
    407     return (nodes);
    408 }
    409 
    410 /*-
    411  *-----------------------------------------------------------------------
    412  * Targ_Ignore  --
    413  *	Return true if should ignore errors when creating gn
    414  *
    415  * Input:
    416  *	gn		node to check for
    417  *
    418  * Results:
    419  *	TRUE if should ignore errors
    420  *
    421  * Side Effects:
    422  *	None
    423  *-----------------------------------------------------------------------
    424  */
    425 Boolean
    426 Targ_Ignore(GNode *gn)
    427 {
    428     if (ignoreErrors || gn->type & OP_IGNORE) {
    429 	return (TRUE);
    430     } else {
    431 	return (FALSE);
    432     }
    433 }
    434 
    435 /*-
    436  *-----------------------------------------------------------------------
    437  * Targ_Silent  --
    438  *	Return true if be silent when creating gn
    439  *
    440  * Input:
    441  *	gn		node to check for
    442  *
    443  * Results:
    444  *	TRUE if should be silent
    445  *
    446  * Side Effects:
    447  *	None
    448  *-----------------------------------------------------------------------
    449  */
    450 Boolean
    451 Targ_Silent(GNode *gn)
    452 {
    453     if (beSilent || gn->type & OP_SILENT) {
    454 	return (TRUE);
    455     } else {
    456 	return (FALSE);
    457     }
    458 }
    459 
    460 /*-
    461  *-----------------------------------------------------------------------
    462  * Targ_Precious --
    463  *	See if the given target is precious
    464  *
    465  * Input:
    466  *	gn		the node to check
    467  *
    468  * Results:
    469  *	TRUE if it is precious. FALSE otherwise
    470  *
    471  * Side Effects:
    472  *	None
    473  *-----------------------------------------------------------------------
    474  */
    475 Boolean
    476 Targ_Precious(GNode *gn)
    477 {
    478     if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
    479 	return (TRUE);
    480     } else {
    481 	return (FALSE);
    482     }
    483 }
    484 
    485 /******************* DEBUG INFO PRINTING ****************/
    486 
    487 static GNode	  *mainTarg;	/* the main target, as set by Targ_SetMain */
    488 /*-
    489  *-----------------------------------------------------------------------
    490  * Targ_SetMain --
    491  *	Set our idea of the main target we'll be creating. Used for
    492  *	debugging output.
    493  *
    494  * Input:
    495  *	gn		The main target we'll create
    496  *
    497  * Results:
    498  *	None.
    499  *
    500  * Side Effects:
    501  *	"mainTarg" is set to the main target's node.
    502  *-----------------------------------------------------------------------
    503  */
    504 void
    505 Targ_SetMain(GNode *gn)
    506 {
    507     mainTarg = gn;
    508 }
    509 
    510 static int
    511 TargPrintName(ClientData gnp, ClientData pflags)
    512 {
    513     GNode *gn = (GNode *)gnp;
    514 
    515     fprintf(debug_file, "%s%s ", gn->name, gn->cohort_num);
    516 
    517     return 0;
    518 }
    519 
    520 
    521 int
    522 Targ_PrintCmd(ClientData cmd, ClientData dummy)
    523 {
    524     fprintf(debug_file, "\t%s\n", (char *)cmd);
    525     return (dummy ? 0 : 0);
    526 }
    527 
    528 /*-
    529  *-----------------------------------------------------------------------
    530  * Targ_FmtTime --
    531  *	Format a modification time in some reasonable way and return it.
    532  *
    533  * Results:
    534  *	The time reformatted.
    535  *
    536  * Side Effects:
    537  *	The time is placed in a static area, so it is overwritten
    538  *	with each call.
    539  *
    540  *-----------------------------------------------------------------------
    541  */
    542 char *
    543 Targ_FmtTime(time_t tm)
    544 {
    545     struct tm	  	*parts;
    546     static char	  	buf[128];
    547 
    548     parts = localtime(&tm);
    549     (void)strftime(buf, sizeof buf, "%k:%M:%S %b %d, %Y", parts);
    550     return(buf);
    551 }
    552 
    553 /*-
    554  *-----------------------------------------------------------------------
    555  * Targ_PrintType --
    556  *	Print out a type field giving only those attributes the user can
    557  *	set.
    558  *
    559  * Results:
    560  *
    561  * Side Effects:
    562  *
    563  *-----------------------------------------------------------------------
    564  */
    565 void
    566 Targ_PrintType(int type)
    567 {
    568     int    tbit;
    569 
    570 #define PRINTBIT(attr)	case CONCAT(OP_,attr): fprintf(debug_file, "." #attr " "); break
    571 #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG))fprintf(debug_file, "." #attr " "); break
    572 
    573     type &= ~OP_OPMASK;
    574 
    575     while (type) {
    576 	tbit = 1 << (ffs(type) - 1);
    577 	type &= ~tbit;
    578 
    579 	switch(tbit) {
    580 	    PRINTBIT(OPTIONAL);
    581 	    PRINTBIT(USE);
    582 	    PRINTBIT(EXEC);
    583 	    PRINTBIT(IGNORE);
    584 	    PRINTBIT(PRECIOUS);
    585 	    PRINTBIT(SILENT);
    586 	    PRINTBIT(MAKE);
    587 	    PRINTBIT(JOIN);
    588 	    PRINTBIT(INVISIBLE);
    589 	    PRINTBIT(NOTMAIN);
    590 	    PRINTDBIT(LIB);
    591 	    /*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
    592 	    case OP_MEMBER: if (DEBUG(TARG))fprintf(debug_file, ".MEMBER "); break;
    593 	    PRINTDBIT(ARCHV);
    594 	    PRINTDBIT(MADE);
    595 	    PRINTDBIT(PHONY);
    596 	}
    597     }
    598 }
    599 
    600 static const char *
    601 made_name(enum enum_made made)
    602 {
    603     switch (made) {
    604     case UNMADE:     return "unmade";
    605     case DEFERRED:   return "deferred";
    606     case REQUESTED:  return "requested";
    607     case BEINGMADE:  return "being made";
    608     case MADE:       return "made";
    609     case UPTODATE:   return "up-to-date";
    610     case ERROR:      return "error when made";
    611     case ABORTED:    return "aborted";
    612     case ENDCYCLE:   return "end cycle";
    613     default:         return "unknown enum_made value";
    614     }
    615 }
    616 
    617 /*-
    618  *-----------------------------------------------------------------------
    619  * TargPrintNode --
    620  *	print the contents of a node
    621  *-----------------------------------------------------------------------
    622  */
    623 int
    624 Targ_PrintNode(ClientData gnp, ClientData passp)
    625 {
    626     GNode         *gn = (GNode *)gnp;
    627     int	    	  pass = passp ? *(int *)passp : 0;
    628 
    629     fprintf(debug_file, "# %s%s, flags %x, type %x, made %d\n",
    630 	    gn->name, gn->cohort_num, gn->flags, gn->type, gn->made);
    631     if (gn->flags == 0)
    632 	return 0;
    633 
    634     if (!OP_NOP(gn->type)) {
    635 	fprintf(debug_file, "#\n");
    636 	if (gn == mainTarg) {
    637 	    fprintf(debug_file, "# *** MAIN TARGET ***\n");
    638 	}
    639 	if (pass >= 2) {
    640 	    if (gn->unmade) {
    641 		fprintf(debug_file, "# %d unmade children\n", gn->unmade);
    642 	    } else {
    643 		fprintf(debug_file, "# No unmade children\n");
    644 	    }
    645 	    if (! (gn->type & (OP_JOIN|OP_USE|OP_USEBEFORE|OP_EXEC))) {
    646 		if (gn->mtime != 0) {
    647 		    fprintf(debug_file, "# last modified %s: %s\n",
    648 			      Targ_FmtTime(gn->mtime),
    649 			      made_name(gn->made));
    650 		} else if (gn->made != UNMADE) {
    651 		    fprintf(debug_file, "# non-existent (maybe): %s\n",
    652 			      made_name(gn->made));
    653 		} else {
    654 		    fprintf(debug_file, "# unmade\n");
    655 		}
    656 	    }
    657 	    if (!Lst_IsEmpty (gn->iParents)) {
    658 		fprintf(debug_file, "# implicit parents: ");
    659 		Lst_ForEach(gn->iParents, TargPrintName, NULL);
    660 		fprintf(debug_file, "\n");
    661 	    }
    662 	} else {
    663 	    if (gn->unmade)
    664 		fprintf(debug_file, "# %d unmade children\n", gn->unmade);
    665 	}
    666 	if (!Lst_IsEmpty (gn->parents)) {
    667 	    fprintf(debug_file, "# parents: ");
    668 	    Lst_ForEach(gn->parents, TargPrintName, NULL);
    669 	    fprintf(debug_file, "\n");
    670 	}
    671 	if (!Lst_IsEmpty (gn->order_pred)) {
    672 	    fprintf(debug_file, "# order_pred: ");
    673 	    Lst_ForEach(gn->order_pred, TargPrintName, NULL);
    674 	    fprintf(debug_file, "\n");
    675 	}
    676 	if (!Lst_IsEmpty (gn->order_succ)) {
    677 	    fprintf(debug_file, "# order_succ: ");
    678 	    Lst_ForEach(gn->order_succ, TargPrintName, NULL);
    679 	    fprintf(debug_file, "\n");
    680 	}
    681 
    682 	fprintf(debug_file, "%-16s", gn->name);
    683 	switch (gn->type & OP_OPMASK) {
    684 	    case OP_DEPENDS:
    685 		fprintf(debug_file, ": "); break;
    686 	    case OP_FORCE:
    687 		fprintf(debug_file, "! "); break;
    688 	    case OP_DOUBLEDEP:
    689 		fprintf(debug_file, ":: "); break;
    690 	}
    691 	Targ_PrintType(gn->type);
    692 	Lst_ForEach(gn->children, TargPrintName, NULL);
    693 	fprintf(debug_file, "\n");
    694 	Lst_ForEach(gn->commands, Targ_PrintCmd, NULL);
    695 	fprintf(debug_file, "\n\n");
    696 	if (gn->type & OP_DOUBLEDEP) {
    697 	    Lst_ForEach(gn->cohorts, Targ_PrintNode, &pass);
    698 	}
    699     }
    700     return (0);
    701 }
    702 
    703 /*-
    704  *-----------------------------------------------------------------------
    705  * TargPrintOnlySrc --
    706  *	Print only those targets that are just a source.
    707  *
    708  * Results:
    709  *	0.
    710  *
    711  * Side Effects:
    712  *	The name of each file is printed preceded by #\t
    713  *
    714  *-----------------------------------------------------------------------
    715  */
    716 static int
    717 TargPrintOnlySrc(ClientData gnp, ClientData dummy)
    718 {
    719     GNode   	  *gn = (GNode *)gnp;
    720     if (!OP_NOP(gn->type))
    721 	return 0;
    722 
    723     fprintf(debug_file, "#\t%s [%s] ",
    724 	    gn->name, gn->path ? gn->path : gn->name);
    725     Targ_PrintType(gn->type);
    726     fprintf(debug_file, "\n");
    727 
    728     return 0;
    729 }
    730 
    731 /*-
    732  *-----------------------------------------------------------------------
    733  * Targ_PrintGraph --
    734  *	print the entire graph. heh heh
    735  *
    736  * Input:
    737  *	pass		Which pass this is. 1 => no processing
    738  *			2 => processing done
    739  *
    740  * Results:
    741  *	none
    742  *
    743  * Side Effects:
    744  *	lots o' output
    745  *-----------------------------------------------------------------------
    746  */
    747 void
    748 Targ_PrintGraph(int pass)
    749 {
    750     fprintf(debug_file, "#*** Input graph:\n");
    751     Lst_ForEach(allTargets, Targ_PrintNode, &pass);
    752     fprintf(debug_file, "\n\n");
    753     fprintf(debug_file, "#\n#   Files that are only sources:\n");
    754     Lst_ForEach(allTargets, TargPrintOnlySrc, NULL);
    755     fprintf(debug_file, "#*** Global Variables:\n");
    756     Var_Dump(VAR_GLOBAL);
    757     fprintf(debug_file, "#*** Command-line Variables:\n");
    758     Var_Dump(VAR_CMD);
    759     fprintf(debug_file, "\n");
    760     Dir_PrintDirectories();
    761     fprintf(debug_file, "\n");
    762     Suff_PrintAll();
    763 }
    764 
    765 /*-
    766  *-----------------------------------------------------------------------
    767  * TargPropagateNode --
    768  *	Propagate information from a single node to related nodes if
    769  *	appropriate.
    770  *
    771  * Input:
    772  *	gnp		The node that we are processing.
    773  *
    774  * Results:
    775  *	Always returns 0, for the benefit of Lst_ForEach().
    776  *
    777  * Side Effects:
    778  *	Information is propagated from this node to cohort or child
    779  *	nodes.
    780  *
    781  *	If the node was defined with "::", then TargPropagateCohort()
    782  *	will be called for each cohort node.
    783  *
    784  *	If the node has recursive predecessors, then
    785  *	TargPropagateRecpred() will be called for each recursive
    786  *	predecessor.
    787  *-----------------------------------------------------------------------
    788  */
    789 static int
    790 TargPropagateNode(ClientData gnp, ClientData junk __unused)
    791 {
    792     GNode	  *gn = (GNode *)gnp;
    793 
    794     if (gn->type & OP_DOUBLEDEP)
    795 	Lst_ForEach(gn->cohorts, TargPropagateCohort, gnp);
    796     return (0);
    797 }
    798 
    799 /*-
    800  *-----------------------------------------------------------------------
    801  * TargPropagateCohort --
    802  *	Propagate some bits in the type mask from a node to
    803  *	a related cohort node.
    804  *
    805  * Input:
    806  *	cnp		The node that we are processing.
    807  *	gnp		Another node that has cnp as a cohort.
    808  *
    809  * Results:
    810  *	Always returns 0, for the benefit of Lst_ForEach().
    811  *
    812  * Side Effects:
    813  *	cnp's type bitmask is modified to incorporate some of the
    814  *	bits from gnp's type bitmask.  (XXX need a better explanation.)
    815  *-----------------------------------------------------------------------
    816  */
    817 static int
    818 TargPropagateCohort(ClientData cgnp, ClientData pgnp)
    819 {
    820     GNode	  *cgn = (GNode *)cgnp;
    821     GNode	  *pgn = (GNode *)pgnp;
    822 
    823     cgn->type |= pgn->type & ~OP_OPMASK;
    824     return (0);
    825 }
    826 
    827 /*-
    828  *-----------------------------------------------------------------------
    829  * Targ_Propagate --
    830  *	Propagate information between related nodes.  Should be called
    831  *	after the makefiles are parsed but before any action is taken.
    832  *
    833  * Results:
    834  *	none
    835  *
    836  * Side Effects:
    837  *	Information is propagated between related nodes throughout the
    838  *	graph.
    839  *-----------------------------------------------------------------------
    840  */
    841 void
    842 Targ_Propagate(void)
    843 {
    844     Lst_ForEach(allTargets, TargPropagateNode, NULL);
    845 }
    846