targ.c revision 1.45 1 /* $NetBSD: targ.c,v 1.45 2006/11/17 22:07:39 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.45 2006/11/17 22:07:39 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.45 2006/11/17 22:07:39 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 if (gn->fname)
298 free(gn->fname);
299
300 Lst_Destroy(gn->iParents, NOFREE);
301 Lst_Destroy(gn->cohorts, NOFREE);
302 Lst_Destroy(gn->parents, NOFREE);
303 Lst_Destroy(gn->children, NOFREE);
304 Lst_Destroy(gn->order_succ, NOFREE);
305 Lst_Destroy(gn->order_pred, NOFREE);
306 Hash_DeleteTable(&gn->context);
307 Lst_Destroy(gn->commands, NOFREE);
308 free(gn);
309 }
310 #endif
311
312
313 /*-
314 *-----------------------------------------------------------------------
315 * Targ_FindNode --
316 * Find a node in the list using the given name for matching
317 *
318 * Input:
319 * name the name to find
320 * flags flags governing events when target not
321 * found
322 *
323 * Results:
324 * The node in the list if it was. If it wasn't, return NILGNODE of
325 * flags was TARG_NOCREATE or the newly created and initialized node
326 * if it was TARG_CREATE
327 *
328 * Side Effects:
329 * Sometimes a node is created and added to the list
330 *-----------------------------------------------------------------------
331 */
332 GNode *
333 Targ_FindNode(const char *name, int flags)
334 {
335 GNode *gn; /* node in that element */
336 Hash_Entry *he; /* New or used hash entry for node */
337 Boolean isNew; /* Set TRUE if Hash_CreateEntry had to create */
338 /* an entry for the node */
339
340 if (!(flags & (TARG_CREATE | TARG_NOHASH))) {
341 he = Hash_FindEntry(&targets, name);
342 if (he == NULL)
343 return (NILGNODE);
344 return (GNode *)Hash_GetValue(he);
345 }
346
347 if (!(flags & TARG_NOHASH)) {
348 he = Hash_CreateEntry(&targets, name, &isNew);
349 if (!isNew)
350 return (GNode *)Hash_GetValue(he);
351 }
352
353 gn = Targ_NewGN(name);
354 if (!(flags & TARG_NOHASH))
355 Hash_SetValue(he, gn);
356 Var_Append(".ALLTARGETS", name, VAR_GLOBAL);
357 (void)Lst_AtEnd(allTargets, gn);
358 return gn;
359 }
360
361 /*-
362 *-----------------------------------------------------------------------
363 * Targ_FindList --
364 * Make a complete list of GNodes from the given list of names
365 *
366 * Input:
367 * name list of names to find
368 * flags flags used if no node is found for a given name
369 *
370 * Results:
371 * A complete list of graph nodes corresponding to all instances of all
372 * the names in names.
373 *
374 * Side Effects:
375 * If flags is TARG_CREATE, nodes will be created for all names in
376 * names which do not yet have graph nodes. If flags is TARG_NOCREATE,
377 * an error message will be printed for each name which can't be found.
378 * -----------------------------------------------------------------------
379 */
380 Lst
381 Targ_FindList(Lst names, int flags)
382 {
383 Lst nodes; /* result list */
384 LstNode ln; /* name list element */
385 GNode *gn; /* node in tLn */
386 char *name;
387
388 nodes = Lst_Init(FALSE);
389
390 if (Lst_Open(names) == FAILURE) {
391 return (nodes);
392 }
393 while ((ln = Lst_Next(names)) != NILLNODE) {
394 name = (char *)Lst_Datum(ln);
395 gn = Targ_FindNode(name, flags);
396 if (gn != NILGNODE) {
397 /*
398 * Note: Lst_AtEnd must come before the Lst_Concat so the nodes
399 * are added to the list in the order in which they were
400 * encountered in the makefile.
401 */
402 (void)Lst_AtEnd(nodes, gn);
403 } else if (flags == TARG_NOCREATE) {
404 Error("\"%s\" -- target unknown.", name);
405 }
406 }
407 Lst_Close(names);
408 return (nodes);
409 }
410
411 /*-
412 *-----------------------------------------------------------------------
413 * Targ_Ignore --
414 * Return true if should ignore errors when creating gn
415 *
416 * Input:
417 * gn node to check for
418 *
419 * Results:
420 * TRUE if should ignore errors
421 *
422 * Side Effects:
423 * None
424 *-----------------------------------------------------------------------
425 */
426 Boolean
427 Targ_Ignore(GNode *gn)
428 {
429 if (ignoreErrors || gn->type & OP_IGNORE) {
430 return (TRUE);
431 } else {
432 return (FALSE);
433 }
434 }
435
436 /*-
437 *-----------------------------------------------------------------------
438 * Targ_Silent --
439 * Return true if be silent when creating gn
440 *
441 * Input:
442 * gn node to check for
443 *
444 * Results:
445 * TRUE if should be silent
446 *
447 * Side Effects:
448 * None
449 *-----------------------------------------------------------------------
450 */
451 Boolean
452 Targ_Silent(GNode *gn)
453 {
454 if (beSilent || gn->type & OP_SILENT) {
455 return (TRUE);
456 } else {
457 return (FALSE);
458 }
459 }
460
461 /*-
462 *-----------------------------------------------------------------------
463 * Targ_Precious --
464 * See if the given target is precious
465 *
466 * Input:
467 * gn the node to check
468 *
469 * Results:
470 * TRUE if it is precious. FALSE otherwise
471 *
472 * Side Effects:
473 * None
474 *-----------------------------------------------------------------------
475 */
476 Boolean
477 Targ_Precious(GNode *gn)
478 {
479 if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
480 return (TRUE);
481 } else {
482 return (FALSE);
483 }
484 }
485
486 /******************* DEBUG INFO PRINTING ****************/
487
488 static GNode *mainTarg; /* the main target, as set by Targ_SetMain */
489 /*-
490 *-----------------------------------------------------------------------
491 * Targ_SetMain --
492 * Set our idea of the main target we'll be creating. Used for
493 * debugging output.
494 *
495 * Input:
496 * gn The main target we'll create
497 *
498 * Results:
499 * None.
500 *
501 * Side Effects:
502 * "mainTarg" is set to the main target's node.
503 *-----------------------------------------------------------------------
504 */
505 void
506 Targ_SetMain(GNode *gn)
507 {
508 mainTarg = gn;
509 }
510
511 static int
512 TargPrintName(ClientData gnp, ClientData pflags)
513 {
514 GNode *gn = (GNode *)gnp;
515
516 fprintf(debug_file, "%s%s ", gn->name, gn->cohort_num);
517
518 return 0;
519 }
520
521
522 int
523 Targ_PrintCmd(ClientData cmd, ClientData dummy)
524 {
525 fprintf(debug_file, "\t%s\n", (char *)cmd);
526 return (dummy ? 0 : 0);
527 }
528
529 /*-
530 *-----------------------------------------------------------------------
531 * Targ_FmtTime --
532 * Format a modification time in some reasonable way and return it.
533 *
534 * Results:
535 * The time reformatted.
536 *
537 * Side Effects:
538 * The time is placed in a static area, so it is overwritten
539 * with each call.
540 *
541 *-----------------------------------------------------------------------
542 */
543 char *
544 Targ_FmtTime(time_t tm)
545 {
546 struct tm *parts;
547 static char buf[128];
548
549 parts = localtime(&tm);
550 (void)strftime(buf, sizeof buf, "%k:%M:%S %b %d, %Y", parts);
551 return(buf);
552 }
553
554 /*-
555 *-----------------------------------------------------------------------
556 * Targ_PrintType --
557 * Print out a type field giving only those attributes the user can
558 * set.
559 *
560 * Results:
561 *
562 * Side Effects:
563 *
564 *-----------------------------------------------------------------------
565 */
566 void
567 Targ_PrintType(int type)
568 {
569 int tbit;
570
571 #define PRINTBIT(attr) case CONCAT(OP_,attr): fprintf(debug_file, "." #attr " "); break
572 #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG))fprintf(debug_file, "." #attr " "); break
573
574 type &= ~OP_OPMASK;
575
576 while (type) {
577 tbit = 1 << (ffs(type) - 1);
578 type &= ~tbit;
579
580 switch(tbit) {
581 PRINTBIT(OPTIONAL);
582 PRINTBIT(USE);
583 PRINTBIT(EXEC);
584 PRINTBIT(IGNORE);
585 PRINTBIT(PRECIOUS);
586 PRINTBIT(SILENT);
587 PRINTBIT(MAKE);
588 PRINTBIT(JOIN);
589 PRINTBIT(INVISIBLE);
590 PRINTBIT(NOTMAIN);
591 PRINTDBIT(LIB);
592 /*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
593 case OP_MEMBER: if (DEBUG(TARG))fprintf(debug_file, ".MEMBER "); break;
594 PRINTDBIT(ARCHV);
595 PRINTDBIT(MADE);
596 PRINTDBIT(PHONY);
597 }
598 }
599 }
600
601 static const char *
602 made_name(enum enum_made made)
603 {
604 switch (made) {
605 case UNMADE: return "unmade";
606 case DEFERRED: return "deferred";
607 case REQUESTED: return "requested";
608 case BEINGMADE: return "being made";
609 case MADE: return "made";
610 case UPTODATE: return "up-to-date";
611 case ERROR: return "error when made";
612 case ABORTED: return "aborted";
613 case ENDCYCLE: return "end cycle";
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(ClientData gnp, ClientData 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(ClientData gnp, ClientData dummy)
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(ClientData gnp, ClientData junk __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(ClientData cgnp, ClientData 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 }
847