targ.c revision 321964 
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
72static 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
77static 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
139static Lst        allTargets;	/* the list of all targets found so far */
140#ifdef CLEANUP
141static Lst	  allGNs;	/* List of all the GNodes */
142#endif
143static Hash_Table targets;	/* a hash table of same */
144
145#define HTSIZE	191		/* initial size of hash table */
146
147static int TargPrintOnlySrc(void *, void *);
148static int TargPrintName(void *, void *);
149#ifdef CLEANUP
150static void TargFreeGN(void *);
151#endif
152static int TargPropagateCohort(void *, void *);
153static 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 */
167void
168Targ_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 */
186void
187Targ_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 */
209Lst
210Targ_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 */
231GNode *
232Targ_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 */
288static void
289TargFreeGN(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 */
331GNode *
332Targ_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 */
381Lst
382Targ_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 */
427Boolean
428Targ_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 */
452Boolean
453Targ_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 */
477Boolean
478Targ_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
489static 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 */
506void
507Targ_SetMain(GNode *gn)
508{
509    mainTarg = gn;
510}
511
512static int
513TargPrintName(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
523int
524Targ_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 */
544char *
545Targ_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 */
567void
568Targ_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
602static const char *
603made_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 */
624int
625Targ_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 */
717static int
718TargPrintOnlySrc(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 */
748void
749Targ_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 */
790static int
791TargPropagateNode(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 */
818static int
819TargPropagateCohort(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 */
842void
843Targ_Propagate(void)
844{
845    Lst_ForEach(allTargets, TargPropagateNode, NULL);
846}
847