compat.c revision 1.66 1 1.66 dsl /* $NetBSD: compat.c,v 1.66 2006/11/17 22:07:39 dsl Exp $ */
2 1.10 christos
3 1.1 cgd /*
4 1.1 cgd * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
5 1.47 agc * All rights reserved.
6 1.47 agc *
7 1.47 agc * This code is derived from software contributed to Berkeley by
8 1.47 agc * Adam de Boor.
9 1.47 agc *
10 1.47 agc * Redistribution and use in source and binary forms, with or without
11 1.47 agc * modification, are permitted provided that the following conditions
12 1.47 agc * are met:
13 1.47 agc * 1. Redistributions of source code must retain the above copyright
14 1.47 agc * notice, this list of conditions and the following disclaimer.
15 1.47 agc * 2. Redistributions in binary form must reproduce the above copyright
16 1.47 agc * notice, this list of conditions and the following disclaimer in the
17 1.47 agc * documentation and/or other materials provided with the distribution.
18 1.47 agc * 3. Neither the name of the University nor the names of its contributors
19 1.47 agc * may be used to endorse or promote products derived from this software
20 1.47 agc * without specific prior written permission.
21 1.47 agc *
22 1.47 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.47 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.47 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.47 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.47 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.47 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.47 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.47 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.47 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.47 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.47 agc * SUCH DAMAGE.
33 1.47 agc */
34 1.47 agc
35 1.47 agc /*
36 1.1 cgd * Copyright (c) 1988, 1989 by Adam de Boor
37 1.1 cgd * Copyright (c) 1989 by Berkeley Softworks
38 1.1 cgd * All rights reserved.
39 1.1 cgd *
40 1.1 cgd * This code is derived from software contributed to Berkeley by
41 1.1 cgd * Adam de Boor.
42 1.1 cgd *
43 1.1 cgd * Redistribution and use in source and binary forms, with or without
44 1.1 cgd * modification, are permitted provided that the following conditions
45 1.1 cgd * are met:
46 1.1 cgd * 1. Redistributions of source code must retain the above copyright
47 1.1 cgd * notice, this list of conditions and the following disclaimer.
48 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
49 1.1 cgd * notice, this list of conditions and the following disclaimer in the
50 1.1 cgd * documentation and/or other materials provided with the distribution.
51 1.1 cgd * 3. All advertising materials mentioning features or use of this software
52 1.1 cgd * must display the following acknowledgement:
53 1.1 cgd * This product includes software developed by the University of
54 1.1 cgd * California, Berkeley and its contributors.
55 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
56 1.1 cgd * may be used to endorse or promote products derived from this software
57 1.1 cgd * without specific prior written permission.
58 1.1 cgd *
59 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69 1.1 cgd * SUCH DAMAGE.
70 1.1 cgd */
71 1.1 cgd
72 1.53 ross #ifndef MAKE_NATIVE
73 1.66 dsl static char rcsid[] = "$NetBSD: compat.c,v 1.66 2006/11/17 22:07:39 dsl Exp $";
74 1.22 lukem #else
75 1.21 christos #include <sys/cdefs.h>
76 1.1 cgd #ifndef lint
77 1.10 christos #if 0
78 1.14 christos static char sccsid[] = "@(#)compat.c 8.2 (Berkeley) 3/19/94";
79 1.10 christos #else
80 1.66 dsl __RCSID("$NetBSD: compat.c,v 1.66 2006/11/17 22:07:39 dsl Exp $");
81 1.10 christos #endif
82 1.1 cgd #endif /* not lint */
83 1.22 lukem #endif
84 1.1 cgd
85 1.1 cgd /*-
86 1.1 cgd * compat.c --
87 1.1 cgd * The routines in this file implement the full-compatibility
88 1.1 cgd * mode of PMake. Most of the special functionality of PMake
89 1.1 cgd * is available in this mode. Things not supported:
90 1.1 cgd * - different shells.
91 1.1 cgd * - friendly variable substitution.
92 1.1 cgd *
93 1.1 cgd * Interface:
94 1.1 cgd * Compat_Run Initialize things for this module and recreate
95 1.1 cgd * thems as need creatin'
96 1.1 cgd */
97 1.1 cgd
98 1.1 cgd #include <sys/types.h>
99 1.11 jtc #include <sys/stat.h>
100 1.1 cgd #include <sys/wait.h>
101 1.44 wiz
102 1.1 cgd #include <ctype.h>
103 1.11 jtc #include <errno.h>
104 1.11 jtc #include <signal.h>
105 1.44 wiz #include <stdio.h>
106 1.44 wiz
107 1.1 cgd #include "make.h"
108 1.5 cgd #include "hash.h"
109 1.5 cgd #include "dir.h"
110 1.5 cgd #include "job.h"
111 1.43 bjh21 #include "pathnames.h"
112 1.1 cgd
113 1.1 cgd /*
114 1.1 cgd * The following array is used to make a fast determination of which
115 1.1 cgd * characters are interpreted specially by the shell. If a command
116 1.1 cgd * contains any of these characters, it is executed by the shell, not
117 1.1 cgd * directly by us.
118 1.1 cgd */
119 1.1 cgd
120 1.1 cgd static char meta[256];
121 1.1 cgd
122 1.1 cgd static GNode *curTarg = NILGNODE;
123 1.1 cgd static GNode *ENDNode;
124 1.44 wiz static void CompatInterrupt(int);
125 1.1 cgd
126 1.54 sjg static void
127 1.54 sjg Compat_Init(void)
128 1.54 sjg {
129 1.54 sjg const char *cp;
130 1.54 sjg
131 1.54 sjg Shell_Init(); /* setup default shell */
132 1.54 sjg
133 1.54 sjg for (cp = "#=|^(){};&<>*?[]:$`\\\n"; *cp != '\0'; cp++) {
134 1.54 sjg meta[(unsigned char) *cp] = 1;
135 1.54 sjg }
136 1.54 sjg /*
137 1.54 sjg * The null character serves as a sentinel in the string.
138 1.54 sjg */
139 1.54 sjg meta[0] = 1;
140 1.54 sjg }
141 1.54 sjg
142 1.1 cgd /*-
143 1.1 cgd *-----------------------------------------------------------------------
144 1.1 cgd * CompatInterrupt --
145 1.1 cgd * Interrupt the creation of the current target and remove it if
146 1.1 cgd * it ain't precious.
147 1.1 cgd *
148 1.1 cgd * Results:
149 1.1 cgd * None.
150 1.1 cgd *
151 1.1 cgd * Side Effects:
152 1.1 cgd * The target is removed and the process exits. If .INTERRUPT exists,
153 1.1 cgd * its commands are run first WITH INTERRUPTS IGNORED..
154 1.1 cgd *
155 1.1 cgd *-----------------------------------------------------------------------
156 1.1 cgd */
157 1.1 cgd static void
158 1.44 wiz CompatInterrupt(int signo)
159 1.1 cgd {
160 1.1 cgd GNode *gn;
161 1.14 christos
162 1.1 cgd if ((curTarg != NILGNODE) && !Targ_Precious (curTarg)) {
163 1.7 jtc char *p1;
164 1.56 christos char *file = Var_Value(TARGET, curTarg, &p1);
165 1.1 cgd
166 1.12 christos if (!noExecute && eunlink(file) != -1) {
167 1.42 christos Error("*** %s removed", file);
168 1.1 cgd }
169 1.7 jtc if (p1)
170 1.7 jtc free(p1);
171 1.1 cgd
172 1.1 cgd /*
173 1.1 cgd * Run .INTERRUPT only if hit with interrupt signal
174 1.1 cgd */
175 1.1 cgd if (signo == SIGINT) {
176 1.1 cgd gn = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
177 1.1 cgd if (gn != NILGNODE) {
178 1.57 christos Compat_Make(gn, gn);
179 1.1 cgd }
180 1.1 cgd }
181 1.7 jtc
182 1.1 cgd }
183 1.59 christos exit(signo);
184 1.1 cgd }
185 1.1 cgd
186 1.1 cgd /*-
188 1.1 cgd *-----------------------------------------------------------------------
189 1.1 cgd * CompatRunCommand --
190 1.1 cgd * Execute the next command for a target. If the command returns an
191 1.1 cgd * error, the node's made field is set to ERROR and creation stops.
192 1.44 wiz *
193 1.44 wiz * Input:
194 1.44 wiz * cmdp Command to execute
195 1.44 wiz * gnp Node from which the command came
196 1.1 cgd *
197 1.1 cgd * Results:
198 1.1 cgd * 0 if the command succeeded, 1 if an error occurred.
199 1.1 cgd *
200 1.1 cgd * Side Effects:
201 1.1 cgd * The node's 'made' field may be set to ERROR.
202 1.1 cgd *
203 1.1 cgd *-----------------------------------------------------------------------
204 1.54 sjg */
205 1.44 wiz int
206 1.1 cgd CompatRunCommand(ClientData cmdp, ClientData gnp)
207 1.1 cgd {
208 1.24 christos char *cmdStart; /* Start of expanded command */
209 1.1 cgd char *cp, *bp;
210 1.64 christos Boolean silent, /* Don't print command */
211 1.64 christos doIt; /* Execute even if -n */
212 1.13 christos volatile Boolean errCheck; /* Check errors */
213 1.1 cgd int reason; /* Reason for child's death */
214 1.1 cgd int status; /* Description of child's death */
215 1.37 reinoud int cpid; /* Child actually found */
216 1.1 cgd ReturnStatus retstat; /* Status of fork */
217 1.64 christos LstNode cmdNode; /* Node where current command is located */
218 1.64 christos const char ** volatile av; /* Argument vector for thing to exec */
219 1.1 cgd char ** volatile mav;/* Copy of the argument vector for freeing */
220 1.1 cgd int argc; /* Number of arguments in av or 0 if not
221 1.1 cgd * dynamically allocated */
222 1.1 cgd Boolean local; /* TRUE if command should be executed
223 1.62 apb * locally */
224 1.62 apb Boolean useShell; /* TRUE if command should be executed
225 1.64 christos * using a shell */
226 1.60 christos char * volatile cmd = (char *)cmdp;
227 1.1 cgd GNode *gn = (GNode *)gnp;
228 1.14 christos
229 1.6 cgd /*
230 1.6 cgd * Avoid clobbered variable warnings by forcing the compiler
231 1.6 cgd * to ``unregister'' variables
232 1.1 cgd */
233 1.1 cgd silent = gn->type & OP_SILENT;
234 1.54 sjg errCheck = !(gn->type & OP_IGNORE);
235 1.54 sjg doIt = FALSE;
236 1.65 dsl
237 1.56 christos cmdNode = Lst_Member(gn->commands, cmd);
238 1.1 cgd cmdStart = Var_Subst(NULL, cmd, gn, FALSE);
239 1.1 cgd
240 1.24 christos /*
241 1.1 cgd * brk_string will return an argv with a NULL in av[0], thus causing
242 1.1 cgd * execvp to choke and die horribly. Besides, how can we execute a null
243 1.1 cgd * command? In any case, we warn the user that the command expanded to
244 1.1 cgd * nothing (is this the right thing to do?).
245 1.14 christos */
246 1.1 cgd
247 1.7 jtc if (*cmdStart == '\0') {
248 1.1 cgd free(cmdStart);
249 1.1 cgd Error("%s expands to empty string", cmd);
250 1.1 cgd return(0);
251 1.1 cgd } else {
252 1.1 cgd cmd = cmdStart;
253 1.65 dsl }
254 1.1 cgd Lst_Replace(cmdNode, cmdStart);
255 1.1 cgd
256 1.65 dsl if ((gn->type & OP_SAVE_CMDS) && (gn != ENDNode)) {
257 1.1 cgd (void)Lst_AtEnd(ENDNode->commands, cmdStart);
258 1.1 cgd return(0);
259 1.1 cgd } else if (strcmp(cmdStart, "...") == 0) {
260 1.1 cgd gn->type |= OP_SAVE_CMDS;
261 1.1 cgd return(0);
262 1.1 cgd }
263 1.54 sjg
264 1.54 sjg while ((*cmd == '@') || (*cmd == '-') || (*cmd == '+')) {
265 1.54 sjg switch (*cmd) {
266 1.1 cgd case '@':
267 1.54 sjg silent = TRUE;
268 1.54 sjg break;
269 1.1 cgd case '-':
270 1.54 sjg errCheck = FALSE;
271 1.54 sjg break;
272 1.54 sjg case '+':
273 1.54 sjg doIt = TRUE;
274 1.54 sjg if (!meta[0]) /* we came here from jobs */
275 1.54 sjg Compat_Init();
276 1.1 cgd break;
277 1.1 cgd }
278 1.1 cgd cmd++;
279 1.1 cgd }
280 1.5 cgd
281 1.5 cgd while (isspace((unsigned char)*cmd))
282 1.14 christos cmd++;
283 1.62 apb
284 1.62 apb #if !defined(MAKE_NATIVE)
285 1.62 apb /*
286 1.62 apb * In a non-native build, the host environment might be weird enough
287 1.62 apb * that it's necessary to go through a shell to get the correct
288 1.62 apb * behaviour. Or perhaps the shell has been replaced with something
289 1.62 apb * that does extra logging, and that should not be bypassed.
290 1.62 apb */
291 1.62 apb useShell = TRUE;
292 1.1 cgd #else
293 1.1 cgd /*
294 1.1 cgd * Search for meta characters in the command. If there are no meta
295 1.1 cgd * characters, there's no need to execute a shell to execute the
296 1.1 cgd * command.
297 1.5 cgd */
298 1.1 cgd for (cp = cmd; !meta[(unsigned char)*cp]; cp++) {
299 1.1 cgd continue;
300 1.62 apb }
301 1.62 apb useShell = (*cp != '\0');
302 1.1 cgd #endif
303 1.1 cgd
304 1.1 cgd /*
305 1.1 cgd * Print the command before echoing if we're not supposed to be quiet for
306 1.1 cgd * this one. We also print the command if -n given.
307 1.31 sommerfe */
308 1.59 christos if (!silent || NoExecute(gn)) {
309 1.1 cgd printf("%s\n", cmd);
310 1.1 cgd fflush(stdout);
311 1.1 cgd }
312 1.1 cgd
313 1.1 cgd /*
314 1.1 cgd * If we're not supposed to execute any commands, this is as far as
315 1.1 cgd * we go...
316 1.54 sjg */
317 1.1 cgd if (!doIt && NoExecute(gn)) {
318 1.1 cgd return (0);
319 1.14 christos }
320 1.62 apb
321 1.1 cgd if (useShell) {
322 1.62 apb /*
323 1.62 apb * We need to pass the command off to the shell, typically
324 1.1 cgd * because the command contains a "meta" character.
325 1.46 sjg */
326 1.1 cgd static const char *shargv[4];
327 1.46 sjg
328 1.46 sjg shargv[0] = shellPath;
329 1.46 sjg /*
330 1.46 sjg * The following work for any of the builtin shell specs.
331 1.34 sjg */
332 1.54 sjg if (DEBUG(SHELL))
333 1.34 sjg shargv[1] = "-xc";
334 1.54 sjg else
335 1.1 cgd shargv[1] = "-c";
336 1.60 christos shargv[2] = cmd;
337 1.1 cgd shargv[3] = NULL;
338 1.1 cgd av = shargv;
339 1.24 christos argc = 0;
340 1.61 christos bp = NULL;
341 1.1 cgd mav = NULL;
342 1.1 cgd } else {
343 1.1 cgd /*
344 1.1 cgd * No meta-characters, so no need to exec a shell. Break the command
345 1.1 cgd * into words to form an argument vector we can execute.
346 1.61 christos */
347 1.61 christos mav = brk_string(cmd, &argc, TRUE, &bp);
348 1.1 cgd av = (const char **)mav;
349 1.14 christos }
350 1.1 cgd
351 1.1 cgd local = TRUE;
352 1.1 cgd
353 1.1 cgd /*
354 1.1 cgd * Fork and execute the single command. If the fork fails, we abort.
355 1.1 cgd */
356 1.1 cgd cpid = vfork();
357 1.1 cgd if (cpid < 0) {
358 1.1 cgd Fatal("Could not fork");
359 1.1 cgd }
360 1.30 sjg if (cpid == 0) {
361 1.33 christos Check_Cwd(av);
362 1.45 christos if (local)
363 1.33 christos (void)execvp(av[0], (char *const *)UNCONST(av));
364 1.45 christos else
365 1.41 pk (void)execv(av[0], (char *const *)UNCONST(av));
366 1.23 thorpej execError("exec", av[0]);
367 1.1 cgd _exit(1);
368 1.61 christos }
369 1.61 christos if (mav)
370 1.61 christos free(mav);
371 1.25 itohy if (bp)
372 1.65 dsl free(bp);
373 1.14 christos Lst_Replace(cmdNode, NULL);
374 1.1 cgd
375 1.1 cgd /*
376 1.1 cgd * The child is off and running. Now all we can do is wait...
377 1.1 cgd */
378 1.1 cgd while (1) {
379 1.37 reinoud
380 1.37 reinoud while ((retstat = wait(&reason)) != cpid) {
381 1.1 cgd if (retstat == -1 && errno != EINTR) {
382 1.1 cgd break;
383 1.1 cgd }
384 1.14 christos }
385 1.37 reinoud
386 1.1 cgd if (retstat > -1) {
387 1.13 christos if (WIFSTOPPED(reason)) {
388 1.1 cgd status = WSTOPSIG(reason); /* stopped */
389 1.13 christos } else if (WIFEXITED(reason)) {
390 1.1 cgd status = WEXITSTATUS(reason); /* exited */
391 1.52 jmmv if (status != 0) {
392 1.63 dsl if (DEBUG(ERROR)) {
393 1.52 jmmv fprintf(debug_file, "\n*** Failed target: %s\n*** Failed command: ",
394 1.52 jmmv gn->name);
395 1.52 jmmv for (cp = cmd; *cp; ) {
396 1.63 dsl if (isspace((unsigned char)*cp)) {
397 1.52 jmmv fprintf(debug_file, " ");
398 1.52 jmmv while (isspace((unsigned char)*cp))
399 1.52 jmmv cp++;
400 1.63 dsl } else {
401 1.52 jmmv fprintf(debug_file, "%c", *cp);
402 1.52 jmmv cp++;
403 1.52 jmmv }
404 1.63 dsl }
405 1.51 lukem fprintf(debug_file, "\n");
406 1.63 dsl }
407 1.1 cgd fprintf(debug_file, "*** Error code %d", status);
408 1.1 cgd }
409 1.13 christos } else {
410 1.59 christos status = WTERMSIG(reason); /* signaled */
411 1.14 christos printf("*** Signal %d", status);
412 1.14 christos }
413 1.1 cgd
414 1.1 cgd
415 1.1 cgd if (!WIFEXITED(reason) || (status != 0)) {
416 1.1 cgd if (errCheck) {
417 1.1 cgd gn->made = ERROR;
418 1.1 cgd if (keepgoing) {
419 1.1 cgd /*
420 1.1 cgd * Abort the current target, but let others
421 1.1 cgd * continue.
422 1.59 christos */
423 1.1 cgd printf(" (continuing)\n");
424 1.1 cgd }
425 1.1 cgd } else {
426 1.1 cgd /*
427 1.1 cgd * Continue executing commands for this target.
428 1.1 cgd * If we return 0, this will happen...
429 1.59 christos */
430 1.1 cgd printf(" (ignored)\n");
431 1.1 cgd status = 0;
432 1.1 cgd }
433 1.1 cgd }
434 1.1 cgd break;
435 1.56 christos } else {
436 1.1 cgd Fatal("error in wait: %d: %s", retstat, strerror(errno));
437 1.1 cgd /*NOTREACHED*/
438 1.1 cgd }
439 1.50 lukem }
440 1.1 cgd free(cmdStart);
441 1.1 cgd
442 1.1 cgd return (status);
443 1.1 cgd }
444 1.1 cgd
445 1.1 cgd /*-
447 1.1 cgd *-----------------------------------------------------------------------
448 1.1 cgd * Compat_Make --
449 1.44 wiz * Make a target.
450 1.44 wiz *
451 1.44 wiz * Input:
452 1.44 wiz * gnp The node to make
453 1.1 cgd * pgnp Parent to abort if necessary
454 1.1 cgd *
455 1.1 cgd * Results:
456 1.1 cgd * 0
457 1.1 cgd *
458 1.1 cgd * Side Effects:
459 1.1 cgd * If an error is detected and not being ignored, the process exits.
460 1.1 cgd *
461 1.57 christos *-----------------------------------------------------------------------
462 1.57 christos */
463 1.1 cgd int
464 1.60 christos Compat_Make(ClientData gnp, ClientData pgnp)
465 1.60 christos {
466 1.16 christos GNode *gn = (GNode *)gnp;
467 1.57 christos GNode *pgn = (GNode *)pgnp;
468 1.57 christos
469 1.40 pk if (!meta[0]) /* we came here from jobs */
470 1.1 cgd Compat_Init();
471 1.1 cgd if (gn->made == UNMADE && (gn == pgn || (pgn->type & OP_MADE) == 0)) {
472 1.1 cgd /*
473 1.1 cgd * First mark ourselves to be made, then apply whatever transformations
474 1.1 cgd * the suffix module thinks are necessary. Once that's done, we can
475 1.1 cgd * descend and make all our children. If any of them has an error
476 1.1 cgd * but the -k flag was given, our 'make' field will be set FALSE again.
477 1.1 cgd * This is our signal to not attempt to do anything but abort our
478 1.26 christos * parent as well.
479 1.1 cgd */
480 1.38 pk gn->flags |= REMAKE;
481 1.56 christos gn->made = BEINGMADE;
482 1.65 dsl if ((gn->type & OP_MADE) == 0)
483 1.26 christos Suff_FindDeps(gn);
484 1.1 cgd Lst_ForEach(gn->children, Compat_Make, gn);
485 1.26 christos if ((gn->flags & REMAKE) == 0) {
486 1.28 mycroft gn->made = ABORTED;
487 1.1 cgd pgn->flags &= ~REMAKE;
488 1.1 cgd goto cohorts;
489 1.56 christos }
490 1.7 jtc
491 1.56 christos if (Lst_Member(gn->iParents, pgn) != NILLNODE) {
492 1.7 jtc char *p1;
493 1.7 jtc Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn, 0);
494 1.1 cgd if (p1)
495 1.14 christos free(p1);
496 1.1 cgd }
497 1.1 cgd
498 1.1 cgd /*
499 1.1 cgd * All the children were made ok. Now cmtime contains the modification
500 1.1 cgd * time of the newest child, we need to find out if we exist and when
501 1.1 cgd * we were modified last. The criteria for datedness are defined by the
502 1.1 cgd * Make_OODate function.
503 1.63 dsl */
504 1.1 cgd if (DEBUG(MAKE)) {
505 1.1 cgd fprintf(debug_file, "Examining %s...", gn->name);
506 1.1 cgd }
507 1.1 cgd if (! Make_OODate(gn)) {
508 1.63 dsl gn->made = UPTODATE;
509 1.1 cgd if (DEBUG(MAKE)) {
510 1.28 mycroft fprintf(debug_file, "up-to-date.\n");
511 1.1 cgd }
512 1.63 dsl goto cohorts;
513 1.1 cgd } else if (DEBUG(MAKE)) {
514 1.1 cgd fprintf(debug_file, "out-of-date.\n");
515 1.1 cgd }
516 1.1 cgd
517 1.1 cgd /*
518 1.1 cgd * If the user is just seeing if something is out-of-date, exit now
519 1.1 cgd * to tell him/her "yes".
520 1.59 christos */
521 1.1 cgd if (queryFlag) {
522 1.1 cgd exit(1);
523 1.1 cgd }
524 1.1 cgd
525 1.1 cgd /*
526 1.1 cgd * We need to be re-made. We also have to make sure we've got a $?
527 1.1 cgd * variable. To be nice, we also define the $> variable using
528 1.1 cgd * Make_DoAllVar().
529 1.14 christos */
530 1.1 cgd Make_DoAllVar(gn);
531 1.1 cgd
532 1.1 cgd /*
533 1.1 cgd * Alter our type to tell if errors should be ignored or things
534 1.56 christos * should not be printed so CompatRunCommand knows what to do.
535 1.1 cgd */
536 1.1 cgd if (Targ_Ignore(gn)) {
537 1.56 christos gn->type |= OP_IGNORE;
538 1.1 cgd }
539 1.1 cgd if (Targ_Silent(gn)) {
540 1.1 cgd gn->type |= OP_SILENT;
541 1.56 christos }
542 1.1 cgd
543 1.1 cgd if (Job_CheckCommands(gn, Fatal)) {
544 1.1 cgd /*
545 1.1 cgd * Our commands are ok, but we still have to worry about the -t
546 1.20 mycroft * flag...
547 1.1 cgd */
548 1.65 dsl if (!touchFlag || (gn->type & OP_MAKE)) {
549 1.1 cgd curTarg = gn;
550 1.1 cgd Lst_ForEach(gn->commands, CompatRunCommand, gn);
551 1.56 christos curTarg = NILGNODE;
552 1.1 cgd } else {
553 1.1 cgd Job_Touch(gn, gn->type & OP_SILENT);
554 1.1 cgd }
555 1.1 cgd } else {
556 1.1 cgd gn->made = ERROR;
557 1.1 cgd }
558 1.1 cgd
559 1.1 cgd if (gn->made != ERROR) {
560 1.1 cgd /*
561 1.1 cgd * If the node was made successfully, mark it so, update
562 1.1 cgd * its modification time and timestamp all its parents. Note
563 1.1 cgd * that for .ZEROTIME targets, the timestamping isn't done.
564 1.1 cgd * This is to keep its state from affecting that of its parent.
565 1.26 christos */
566 1.1 cgd gn->made = MADE;
567 1.26 christos pgn->flags |= Make_Recheck(gn) == 0 ? FORCE : 0;
568 1.1 cgd if (!(gn->type & OP_EXEC)) {
569 1.1 cgd pgn->flags |= CHILDMADE;
570 1.1 cgd Make_TimeStamp(pgn, gn);
571 1.26 christos }
572 1.1 cgd } else if (keepgoing) {
573 1.34 sjg pgn->flags &= ~REMAKE;
574 1.59 christos } else {
575 1.1 cgd PrintOnError("\n\nStop.");
576 1.1 cgd exit(1);
577 1.1 cgd }
578 1.1 cgd } else if (gn->made == ERROR) {
579 1.1 cgd /*
580 1.1 cgd * Already had an error when making this beastie. Tell the parent
581 1.26 christos * to abort.
582 1.1 cgd */
583 1.56 christos pgn->flags &= ~REMAKE;
584 1.7 jtc } else {
585 1.56 christos if (Lst_Member(gn->iParents, pgn) != NILLNODE) {
586 1.7 jtc char *p1;
587 1.7 jtc Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn, 0);
588 1.1 cgd if (p1)
589 1.1 cgd free(p1);
590 1.1 cgd }
591 1.42 christos switch(gn->made) {
592 1.1 cgd case BEINGMADE:
593 1.26 christos Error("Graph cycles through %s", gn->name);
594 1.1 cgd gn->made = ERROR;
595 1.1 cgd pgn->flags &= ~REMAKE;
596 1.1 cgd break;
597 1.26 christos case MADE:
598 1.1 cgd if ((gn->type & OP_EXEC) == 0) {
599 1.1 cgd pgn->flags |= CHILDMADE;
600 1.1 cgd Make_TimeStamp(pgn, gn);
601 1.1 cgd }
602 1.1 cgd break;
603 1.1 cgd case UPTODATE:
604 1.1 cgd if ((gn->type & OP_EXEC) == 0) {
605 1.1 cgd Make_TimeStamp(pgn, gn);
606 1.5 cgd }
607 1.5 cgd break;
608 1.1 cgd default:
609 1.1 cgd break;
610 1.1 cgd }
611 1.28 mycroft }
612 1.57 christos
613 1.1 cgd cohorts:
614 1.1 cgd Lst_ForEach(gn->cohorts, Compat_Make, pgnp);
615 1.14 christos return (0);
616 1.1 cgd }
617 1.1 cgd
618 1.1 cgd /*-
620 1.1 cgd *-----------------------------------------------------------------------
621 1.44 wiz * Compat_Run --
622 1.44 wiz * Initialize this mode and start making.
623 1.44 wiz *
624 1.1 cgd * Input:
625 1.1 cgd * targs List of target nodes to re-create
626 1.1 cgd *
627 1.1 cgd * Results:
628 1.1 cgd * None.
629 1.1 cgd *
630 1.1 cgd * Side Effects:
631 1.1 cgd * Guess what?
632 1.1 cgd *
633 1.44 wiz *-----------------------------------------------------------------------
634 1.1 cgd */
635 1.5 cgd void
636 1.1 cgd Compat_Run(Lst targs)
637 1.46 sjg {
638 1.54 sjg GNode *gn = NULL;/* Current root target */
639 1.1 cgd int errors; /* Number of targets not remade due to errors */
640 1.1 cgd
641 1.1 cgd Compat_Init();
642 1.1 cgd
643 1.1 cgd if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
644 1.1 cgd signal(SIGINT, CompatInterrupt);
645 1.1 cgd }
646 1.1 cgd if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
647 1.1 cgd signal(SIGTERM, CompatInterrupt);
648 1.1 cgd }
649 1.1 cgd if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
650 1.1 cgd signal(SIGHUP, CompatInterrupt);
651 1.1 cgd }
652 1.1 cgd if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
653 1.1 cgd signal(SIGQUIT, CompatInterrupt);
654 1.58 christos }
655 1.1 cgd
656 1.1 cgd ENDNode = Targ_FindNode(".END", TARG_CREATE);
657 1.1 cgd ENDNode->type = OP_SPECIAL;
658 1.1 cgd /*
659 1.1 cgd * If the user has defined a .BEGIN target, execute the commands attached
660 1.1 cgd * to it.
661 1.1 cgd */
662 1.57 christos if (!queryFlag) {
663 1.14 christos gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
664 1.34 sjg if (gn != NILGNODE) {
665 1.14 christos Compat_Make(gn, gn);
666 1.14 christos if (gn->made == ERROR) {
667 1.1 cgd PrintOnError("\n\nStop.");
668 1.1 cgd exit(1);
669 1.15 christos }
670 1.15 christos }
671 1.15 christos }
672 1.15 christos
673 1.15 christos /*
674 1.66 dsl * Expand .USE nodes right now, because they can modify the structure
675 1.1 cgd * of the tree.
676 1.1 cgd */
677 1.57 christos Make_ExpandUse(targs);
678 1.57 christos
679 1.1 cgd /*
680 1.1 cgd * For each entry in the list of targets to create, call Compat_Make on
681 1.1 cgd * it to create the thing. Compat_Make will leave the 'made' field of gn
682 1.1 cgd * in one of several states:
683 1.1 cgd * UPTODATE gn was already up-to-date
684 1.1 cgd * MADE gn was recreated successfully
685 1.1 cgd * ERROR An error occurred while gn was being created
686 1.1 cgd * ABORTED gn was not remade because one of its inferiors
687 1.1 cgd * could not be made due to errors.
688 1.59 christos */
689 1.57 christos errors = 0;
690 1.1 cgd while (!Lst_IsEmpty (targs)) {
691 1.1 cgd gn = (GNode *)Lst_DeQueue(targs);
692 1.59 christos Compat_Make(gn, gn);
693 1.1 cgd
694 1.59 christos if (gn->made == UPTODATE) {
695 1.1 cgd printf("`%s' is up to date.\n", gn->name);
696 1.1 cgd } else if (gn->made == ABORTED) {
697 1.1 cgd printf("`%s' not remade because of errors.\n", gn->name);
698 1.1 cgd errors += 1;
699 1.1 cgd }
700 1.1 cgd }
701 1.1 cgd
702 1.1 cgd /*
703 1.57 christos * If the user has defined a .END target, run its commands.
704 1.36 sjg */
705 1.36 sjg if (errors == 0) {
706 1.36 sjg Compat_Make(ENDNode, ENDNode);
707 1.36 sjg if (gn->made == ERROR) {
708 1.1 cgd PrintOnError("\n\nStop.");
709 1.1 cgd exit(1);
710 }
711 }
712 }
713