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