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