contrib/bmake/compat.c

   1 /*      $NetBSD: compat.c,v 1.105 2016/05/12 20:28:34 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.105 2016/05/12 20:28:34 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.105 2016/05/12 20:28:34 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    "metachar.h"
 115 #include    "pathnames.h"
 116
 117
 118 static GNode        *curTarg = NULL;
 119 static GNode        *ENDNode;
 120 static void CompatInterrupt(int);
 121
 122 /*-
 123  *-----------------------------------------------------------------------
 124  * CompatInterrupt --
 125  *      Interrupt the creation of the current target and remove it if
 126  *      it ain't precious.
 127  *
 128  * Results:
 129  *      None.
 130  *
 131  * Side Effects:
 132  *      The target is removed and the process exits. If .INTERRUPT exists,
 133  *      its commands are run first WITH INTERRUPTS IGNORED..
 134  *
 135  *-----------------------------------------------------------------------
 136  */
 137 static void
 138 CompatInterrupt(int signo)
 139 {
 140     GNode   *gn;
 141
 142     if ((curTarg != NULL) && !Targ_Precious (curTarg)) {
 143         char      *p1;
 144         char      *file = Var_Value(TARGET, curTarg, &p1);
 145
 146         if (!noExecute && eunlink(file) != -1) {
 147             Error("*** %s removed", file);
 148         }
 149
 150         free(p1);
 151
 152         /*
 153          * Run .INTERRUPT only if hit with interrupt signal
 154          */
 155         if (signo == SIGINT) {
 156             gn = Targ_FindNode(".INTERRUPT", TARG_NOCREATE);
 157             if (gn != NULL) {
 158                 Compat_Make(gn, gn);
 159             }
 160         }
 161
 162     }
 163     if (signo == SIGQUIT)
 164         _exit(signo);
 165     bmake_signal(signo, SIG_DFL);
 166     kill(myPid, signo);
 167 }
 168 \f
 169 /*-
 170  *-----------------------------------------------------------------------
 171  * CompatRunCommand --
 172  *      Execute the next command for a target. If the command returns an
 173  *      error, the node's made field is set to ERROR and creation stops.
 174  *
 175  * Input:
 176  *      cmdp            Command to execute
 177  *      gnp             Node from which the command came
 178  *
 179  * Results:
 180  *      0 if the command succeeded, 1 if an error occurred.
 181  *
 182  * Side Effects:
 183  *      The node's 'made' field may be set to ERROR.
 184  *
 185  *-----------------------------------------------------------------------
 186  */
 187 int
 188 CompatRunCommand(void *cmdp, void *gnp)
 189 {
 190     char          *cmdStart;    /* Start of expanded command */
 191     char          *cp, *bp;
 192     Boolean       silent,       /* Don't print command */
 193                   doIt;         /* Execute even if -n */
 194     volatile Boolean errCheck;  /* Check errors */
 195     WAIT_T        reason;       /* Reason for child's death */
 196     int           status;       /* Description of child's death */
 197     pid_t         cpid;         /* Child actually found */
 198     pid_t         retstat;      /* Result of wait */
 199     LstNode       cmdNode;      /* Node where current command is located */
 200     const char  ** volatile av; /* Argument vector for thing to exec */
 201     char        ** volatile mav;/* Copy of the argument vector for freeing */
 202     int           argc;         /* Number of arguments in av or 0 if not
 203                                  * dynamically allocated */
 204     Boolean       local;        /* TRUE if command should be executed
 205                                  * locally */
 206     Boolean       useShell;     /* TRUE if command should be executed
 207                                  * using a shell */
 208     char          * volatile cmd = (char *)cmdp;
 209     GNode         *gn = (GNode *)gnp;
 210
 211     silent = gn->type & OP_SILENT;
 212     errCheck = !(gn->type & OP_IGNORE);
 213     doIt = FALSE;
 214
 215     cmdNode = Lst_Member(gn->commands, cmd);
 216     cmdStart = Var_Subst(NULL, cmd, gn, VARF_WANTRES);
 217
 218     /*
 219      * brk_string will return an argv with a NULL in av[0], thus causing
 220      * execvp to choke and die horribly. Besides, how can we execute a null
 221      * command? In any case, we warn the user that the command expanded to
 222      * nothing (is this the right thing to do?).
 223      */
 224
 225     if (*cmdStart == '\0') {
 226         free(cmdStart);
 227         return(0);
 228     }
 229     cmd = cmdStart;
 230     Lst_Replace(cmdNode, cmdStart);
 231
 232     if ((gn->type & OP_SAVE_CMDS) && (gn != ENDNode)) {
 233         (void)Lst_AtEnd(ENDNode->commands, cmdStart);
 234         return(0);
 235     }
 236     if (strcmp(cmdStart, "...") == 0) {
 237         gn->type |= OP_SAVE_CMDS;
 238         return(0);
 239     }
 240
 241     while ((*cmd == '@') || (*cmd == '-') || (*cmd == '+')) {
 242         switch (*cmd) {
 243         case '@':
 244             silent = DEBUG(LOUD) ? FALSE : TRUE;
 245             break;
 246         case '-':
 247             errCheck = FALSE;
 248             break;
 249         case '+':
 250             doIt = TRUE;
 251             if (!shellName)             /* we came here from jobs */
 252                 Shell_Init();
 253             break;
 254         }
 255         cmd++;
 256     }
 257
 258     while (isspace((unsigned char)*cmd))
 259         cmd++;
 260
 261     /*
 262      * If we did not end up with a command, just skip it.
 263      */
 264     if (!*cmd)
 265         return (0);
 266
 267 #if !defined(MAKE_NATIVE)
 268     /*
 269      * In a non-native build, the host environment might be weird enough
 270      * that it's necessary to go through a shell to get the correct
 271      * behaviour.  Or perhaps the shell has been replaced with something
 272      * that does extra logging, and that should not be bypassed.
 273      */
 274     useShell = TRUE;
 275 #else
 276     /*
 277      * Search for meta characters in the command. If there are no meta
 278      * characters, there's no need to execute a shell to execute the
 279      * command.
 280      *
 281      * Additionally variable assignments and empty commands
 282      * go to the shell. Therefore treat '=' and ':' like shell
 283      * meta characters as documented in make(1).
 284      */
 285
 286     useShell = needshell(cmd, FALSE);
 287 #endif
 288
 289     /*
 290      * Print the command before echoing if we're not supposed to be quiet for
 291      * this one. We also print the command if -n given.
 292      */
 293     if (!silent || NoExecute(gn)) {
 294         printf("%s\n", cmd);
 295         fflush(stdout);
 296     }
 297
 298     /*
 299      * If we're not supposed to execute any commands, this is as far as
 300      * we go...
 301      */
 302     if (!doIt && NoExecute(gn)) {
 303         return (0);
 304     }
 305     if (DEBUG(JOB))
 306         fprintf(debug_file, "Execute: '%s'\n", cmd);
 307
 308 again:
 309     if (useShell) {
 310         /*
 311          * We need to pass the command off to the shell, typically
 312          * because the command contains a "meta" character.
 313          */
 314         static const char *shargv[5];
 315         int shargc;
 316
 317         shargc = 0;
 318         shargv[shargc++] = shellPath;
 319         /*
 320          * The following work for any of the builtin shell specs.
 321          */
 322         if (errCheck && shellErrFlag) {
 323             shargv[shargc++] = shellErrFlag;
 324         }
 325         if (DEBUG(SHELL))
 326                 shargv[shargc++] = "-xc";
 327         else
 328                 shargv[shargc++] = "-c";
 329         shargv[shargc++] = cmd;
 330         shargv[shargc++] = NULL;
 331         av = shargv;
 332         argc = 0;
 333         bp = NULL;
 334         mav = NULL;
 335     } else {
 336         /*
 337          * No meta-characters, so no need to exec a shell. Break the command
 338          * into words to form an argument vector we can execute.
 339          */
 340         mav = brk_string(cmd, &argc, TRUE, &bp);
 341         if (mav == NULL) {
 342                 useShell = 1;
 343                 goto again;
 344         }
 345         av = (void *)mav;
 346     }
 347
 348     local = TRUE;
 349
 350 #ifdef USE_META
 351     if (useMeta) {
 352         meta_compat_start();
 353     }
 354 #endif
 355
 356     /*
 357      * Fork and execute the single command. If the fork fails, we abort.
 358      */
 359     cpid = vFork();
 360     if (cpid < 0) {
 361         Fatal("Could not fork");
 362     }
 363     if (cpid == 0) {
 364         Var_ExportVars();
 365 #ifdef USE_META
 366         if (useMeta) {
 367             meta_compat_child();
 368         }
 369 #endif
 370         if (local)
 371             (void)execvp(av[0], (char *const *)UNCONST(av));
 372         else
 373             (void)execv(av[0], (char *const *)UNCONST(av));
 374         execError("exec", av[0]);
 375         _exit(1);
 376     }
 377
 378     free(mav);
 379     free(bp);
 380
 381     Lst_Replace(cmdNode, NULL);
 382
 383 #ifdef USE_META
 384     if (useMeta) {
 385         meta_compat_parent();
 386     }
 387 #endif
 388
 389     /*
 390      * The child is off and running. Now all we can do is wait...
 391      */
 392     while (1) {
 393
 394         while ((retstat = wait(&reason)) != cpid) {
 395             if (retstat > 0)
 396                 JobReapChild(retstat, reason, FALSE); /* not ours? */
 397             if (retstat == -1 && errno != EINTR) {
 398                 break;
 399             }
 400         }
 401
 402         if (retstat > -1) {
 403             if (WIFSTOPPED(reason)) {
 404                 status = WSTOPSIG(reason);              /* stopped */
 405             } else if (WIFEXITED(reason)) {
 406                 status = WEXITSTATUS(reason);           /* exited */
 407 #if defined(USE_META) && defined(USE_FILEMON_ONCE)
 408                 if (useMeta) {
 409                     meta_cmd_finish(NULL);
 410                 }
 411 #endif
 412                 if (status != 0) {
 413                     if (DEBUG(ERROR)) {
 414                         fprintf(debug_file, "\n*** Failed target:  %s\n*** Failed command: ",
 415                             gn->name);
 416                         for (cp = cmd; *cp; ) {
 417                             if (isspace((unsigned char)*cp)) {
 418                                 fprintf(debug_file, " ");
 419                                 while (isspace((unsigned char)*cp))
 420                                     cp++;
 421                             } else {
 422                                 fprintf(debug_file, "%c", *cp);
 423                                 cp++;
 424                             }
 425                         }
 426                         fprintf(debug_file, "\n");
 427                     }
 428                     printf("*** Error code %d", status);
 429                 }
 430             } else {
 431                 status = WTERMSIG(reason);              /* signaled */
 432                 printf("*** Signal %d", status);
 433             }
 434
 435
 436             if (!WIFEXITED(reason) || (status != 0)) {
 437                 if (errCheck) {
 438 #ifdef USE_META
 439                     if (useMeta) {
 440                         meta_job_error(NULL, gn, 0, status);
 441                     }
 442 #endif
 443                     gn->made = ERROR;
 444                     if (keepgoing) {
 445                         /*
 446                          * Abort the current target, but let others
 447                          * continue.
 448                          */
 449                         printf(" (continuing)\n");
 450                     }
 451                 } else {
 452                     /*
 453                      * Continue executing commands for this target.
 454                      * If we return 0, this will happen...
 455                      */
 456                     printf(" (ignored)\n");
 457                     status = 0;
 458                 }
 459             }
 460             break;
 461         } else {
 462             Fatal("error in wait: %d: %s", retstat, strerror(errno));
 463             /*NOTREACHED*/
 464         }
 465     }
 466     free(cmdStart);
 467
 468     return (status);
 469 }
 470 \f
 471 /*-
 472  *-----------------------------------------------------------------------
 473  * Compat_Make --
 474  *      Make a target.
 475  *
 476  * Input:
 477  *      gnp             The node to make
 478  *      pgnp            Parent to abort if necessary
 479  *
 480  * Results:
 481  *      0
 482  *
 483  * Side Effects:
 484  *      If an error is detected and not being ignored, the process exits.
 485  *
 486  *-----------------------------------------------------------------------
 487  */
 488 int
 489 Compat_Make(void *gnp, void *pgnp)
 490 {
 491     GNode *gn = (GNode *)gnp;
 492     GNode *pgn = (GNode *)pgnp;
 493
 494     if (!shellName)             /* we came here from jobs */
 495         Shell_Init();
 496     if (gn->made == UNMADE && (gn == pgn || (pgn->type & OP_MADE) == 0)) {
 497         /*
 498          * First mark ourselves to be made, then apply whatever transformations
 499          * the suffix module thinks are necessary. Once that's done, we can
 500          * descend and make all our children. If any of them has an error
 501          * but the -k flag was given, our 'make' field will be set FALSE again.
 502          * This is our signal to not attempt to do anything but abort our
 503          * parent as well.
 504          */
 505         gn->flags |= REMAKE;
 506         gn->made = BEINGMADE;
 507         if ((gn->type & OP_MADE) == 0)
 508             Suff_FindDeps(gn);
 509         Lst_ForEach(gn->children, Compat_Make, gn);
 510         if ((gn->flags & REMAKE) == 0) {
 511             gn->made = ABORTED;
 512             pgn->flags &= ~REMAKE;
 513             goto cohorts;
 514         }
 515
 516         if (Lst_Member(gn->iParents, pgn) != NULL) {
 517             char *p1;
 518             Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn, 0);
 519             free(p1);
 520         }
 521
 522         /*
 523          * All the children were made ok. Now cmgn->mtime contains the
 524          * modification time of the newest child, we need to find out if we
 525          * exist and when we were modified last. The criteria for datedness
 526          * are defined by the Make_OODate function.
 527          */
 528         if (DEBUG(MAKE)) {
 529             fprintf(debug_file, "Examining %s...", gn->name);
 530         }
 531         if (! Make_OODate(gn)) {
 532             gn->made = UPTODATE;
 533             if (DEBUG(MAKE)) {
 534                 fprintf(debug_file, "up-to-date.\n");
 535             }
 536             goto cohorts;
 537         } else if (DEBUG(MAKE)) {
 538             fprintf(debug_file, "out-of-date.\n");
 539         }
 540
 541         /*
 542          * If the user is just seeing if something is out-of-date, exit now
 543          * to tell him/her "yes".
 544          */
 545         if (queryFlag) {
 546             exit(1);
 547         }
 548
 549         /*
 550          * We need to be re-made. We also have to make sure we've got a $?
 551          * variable. To be nice, we also define the $> variable using
 552          * Make_DoAllVar().
 553          */
 554         Make_DoAllVar(gn);
 555
 556         /*
 557          * Alter our type to tell if errors should be ignored or things
 558          * should not be printed so CompatRunCommand knows what to do.
 559          */
 560         if (Targ_Ignore(gn)) {
 561             gn->type |= OP_IGNORE;
 562         }
 563         if (Targ_Silent(gn)) {
 564             gn->type |= OP_SILENT;
 565         }
 566
 567         if (Job_CheckCommands(gn, Fatal)) {
 568             /*
 569              * Our commands are ok, but we still have to worry about the -t
 570              * flag...
 571              */
 572             if (!touchFlag || (gn->type & OP_MAKE)) {
 573                 curTarg = gn;
 574 #ifdef USE_META
 575                 if (useMeta && !NoExecute(gn)) {
 576                     meta_job_start(NULL, gn);
 577                 }
 578 #endif
 579                 Lst_ForEach(gn->commands, CompatRunCommand, gn);
 580                 curTarg = NULL;
 581             } else {
 582                 Job_Touch(gn, gn->type & OP_SILENT);
 583             }
 584         } else {
 585             gn->made = ERROR;
 586         }
 587 #ifdef USE_META
 588         if (useMeta && !NoExecute(gn)) {
 589             if (meta_job_finish(NULL) != 0)
 590                 gn->made = ERROR;
 591         }
 592 #endif
 593
 594         if (gn->made != ERROR) {
 595             /*
 596              * If the node was made successfully, mark it so, update
 597              * its modification time and timestamp all its parents. Note
 598              * that for .ZEROTIME targets, the timestamping isn't done.
 599              * This is to keep its state from affecting that of its parent.
 600              */
 601             gn->made = MADE;
 602             pgn->flags |= Make_Recheck(gn) == 0 ? FORCE : 0;
 603             if (!(gn->type & OP_EXEC)) {
 604                 pgn->flags |= CHILDMADE;
 605                 Make_TimeStamp(pgn, gn);
 606             }
 607         } else if (keepgoing) {
 608             pgn->flags &= ~REMAKE;
 609         } else {
 610             PrintOnError(gn, "\n\nStop.");
 611             exit(1);
 612         }
 613     } else if (gn->made == ERROR) {
 614         /*
 615          * Already had an error when making this beastie. Tell the parent
 616          * to abort.
 617          */
 618         pgn->flags &= ~REMAKE;
 619     } else {
 620         if (Lst_Member(gn->iParents, pgn) != NULL) {
 621             char *p1;
 622             Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn, 0);
 623             free(p1);
 624         }
 625         switch(gn->made) {
 626             case BEINGMADE:
 627                 Error("Graph cycles through %s", gn->name);
 628                 gn->made = ERROR;
 629                 pgn->flags &= ~REMAKE;
 630                 break;
 631             case MADE:
 632                 if ((gn->type & OP_EXEC) == 0) {
 633                     pgn->flags |= CHILDMADE;
 634                     Make_TimeStamp(pgn, gn);
 635                 }
 636                 break;
 637             case UPTODATE:
 638                 if ((gn->type & OP_EXEC) == 0) {
 639                     Make_TimeStamp(pgn, gn);
 640                 }
 641                 break;
 642             default:
 643                 break;
 644         }
 645     }
 646
 647 cohorts:
 648     Lst_ForEach(gn->cohorts, Compat_Make, pgnp);
 649     return (0);
 650 }
 651 \f
 652 /*-
 653  *-----------------------------------------------------------------------
 654  * Compat_Run --
 655  *      Initialize this mode and start making.
 656  *
 657  * Input:
 658  *      targs           List of target nodes to re-create
 659  *
 660  * Results:
 661  *      None.
 662  *
 663  * Side Effects:
 664  *      Guess what?
 665  *
 666  *-----------------------------------------------------------------------
 667  */
 668 void
 669 Compat_Run(Lst targs)
 670 {
 671     GNode         *gn = NULL;/* Current root target */
 672     int           errors;   /* Number of targets not remade due to errors */
 673
 674     if (!shellName)
 675         Shell_Init();
 676
 677     if (bmake_signal(SIGINT, SIG_IGN) != SIG_IGN) {
 678         bmake_signal(SIGINT, CompatInterrupt);
 679     }
 680     if (bmake_signal(SIGTERM, SIG_IGN) != SIG_IGN) {
 681         bmake_signal(SIGTERM, CompatInterrupt);
 682     }
 683     if (bmake_signal(SIGHUP, SIG_IGN) != SIG_IGN) {
 684         bmake_signal(SIGHUP, CompatInterrupt);
 685     }
 686     if (bmake_signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
 687         bmake_signal(SIGQUIT, CompatInterrupt);
 688     }
 689
 690     ENDNode = Targ_FindNode(".END", TARG_CREATE);
 691     ENDNode->type = OP_SPECIAL;
 692     /*
 693      * If the user has defined a .BEGIN target, execute the commands attached
 694      * to it.
 695      */
 696     if (!queryFlag) {
 697         gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
 698         if (gn != NULL) {
 699             Compat_Make(gn, gn);
 700             if (gn->made == ERROR) {
 701                 PrintOnError(gn, "\n\nStop.");
 702                 exit(1);
 703             }
 704         }
 705     }
 706
 707     /*
 708      * Expand .USE nodes right now, because they can modify the structure
 709      * of the tree.
 710      */
 711     Make_ExpandUse(targs);
 712
 713     /*
 714      * For each entry in the list of targets to create, call Compat_Make on
 715      * it to create the thing. Compat_Make will leave the 'made' field of gn
 716      * in one of several states:
 717      *      UPTODATE        gn was already up-to-date
 718      *      MADE            gn was recreated successfully
 719      *      ERROR           An error occurred while gn was being created
 720      *      ABORTED         gn was not remade because one of its inferiors
 721      *                      could not be made due to errors.
 722      */
 723     errors = 0;
 724     while (!Lst_IsEmpty (targs)) {
 725         gn = (GNode *)Lst_DeQueue(targs);
 726         Compat_Make(gn, gn);
 727
 728         if (gn->made == UPTODATE) {
 729             printf("`%s' is up to date.\n", gn->name);
 730         } else if (gn->made == ABORTED) {
 731             printf("`%s' not remade because of errors.\n", gn->name);
 732             errors += 1;
 733         }
 734     }
 735
 736     /*
 737      * If the user has defined a .END target, run its commands.
 738      */
 739     if (errors == 0) {
 740         Compat_Make(ENDNode, ENDNode);
 741         if (gn->made == ERROR) {
 742             PrintOnError(gn, "\n\nStop.");
 743             exit(1);
 744         }
 745     }
 746 }