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