contrib/bmake/compat.c

   1 /*      $NetBSD: compat.c,v 1.90 2012/10/07 19:17:31 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.90 2012/10/07 19:17:31 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.90 2012/10/07 19:17:31 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 \f
 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[4];
 336
 337         shargv[0] = shellPath;
 338         /*
 339          * The following work for any of the builtin shell specs.
 340          */
 341         if (DEBUG(SHELL))
 342                 shargv[1] = "-xc";
 343         else
 344                 shargv[1] = "-c";
 345         shargv[2] = cmd;
 346         shargv[3] = NULL;
 347         av = shargv;
 348         argc = 0;
 349         bp = NULL;
 350         mav = NULL;
 351     } else {
 352         /*
 353          * No meta-characters, so no need to exec a shell. Break the command
 354          * into words to form an argument vector we can execute.
 355          */
 356         mav = brk_string(cmd, &argc, TRUE, &bp);
 357         if (mav == NULL) {
 358                 useShell = 1;
 359                 goto again;
 360         }
 361         av = (void *)mav;
 362     }
 363
 364     local = TRUE;
 365
 366 #ifdef USE_META
 367     if (useMeta) {
 368         meta_compat_start();
 369     }
 370 #endif
 371
 372     /*
 373      * Fork and execute the single command. If the fork fails, we abort.
 374      */
 375     cpid = vFork();
 376     if (cpid < 0) {
 377         Fatal("Could not fork");
 378     }
 379     if (cpid == 0) {
 380         Check_Cwd(av);
 381         Var_ExportVars();
 382 #ifdef USE_META
 383         if (useMeta) {
 384             meta_compat_child();
 385         }
 386 #endif
 387         if (local)
 388             (void)execvp(av[0], (char *const *)UNCONST(av));
 389         else
 390             (void)execv(av[0], (char *const *)UNCONST(av));
 391         execError("exec", av[0]);
 392         _exit(1);
 393     }
 394     if (mav)
 395         free(mav);
 396     if (bp)
 397         free(bp);
 398     Lst_Replace(cmdNode, NULL);
 399
 400 #ifdef USE_META
 401     if (useMeta) {
 402         meta_compat_parent();
 403     }
 404 #endif
 405
 406     /*
 407      * The child is off and running. Now all we can do is wait...
 408      */
 409     while (1) {
 410
 411         while ((retstat = wait(&reason)) != cpid) {
 412             if (retstat > 0)
 413                 JobReapChild(retstat, reason, FALSE); /* not ours? */
 414             if (retstat == -1 && errno != EINTR) {
 415                 break;
 416             }
 417         }
 418
 419         if (retstat > -1) {
 420             if (WIFSTOPPED(reason)) {
 421                 status = WSTOPSIG(reason);              /* stopped */
 422             } else if (WIFEXITED(reason)) {
 423                 status = WEXITSTATUS(reason);           /* exited */
 424 #if defined(USE_META) && defined(USE_FILEMON_ONCE)
 425                 if (useMeta) {
 426                     meta_cmd_finish(NULL);
 427                 }
 428 #endif
 429                 if (status != 0) {
 430                     if (DEBUG(ERROR)) {
 431                         fprintf(debug_file, "\n*** Failed target:  %s\n*** Failed command: ",
 432                             gn->name);
 433                         for (cp = cmd; *cp; ) {
 434                             if (isspace((unsigned char)*cp)) {
 435                                 fprintf(debug_file, " ");
 436                                 while (isspace((unsigned char)*cp))
 437                                     cp++;
 438                             } else {
 439                                 fprintf(debug_file, "%c", *cp);
 440                                 cp++;
 441                             }
 442                         }
 443                         fprintf(debug_file, "\n");
 444                     }
 445                     printf("*** Error code %d", status);
 446                 }
 447             } else {
 448                 status = WTERMSIG(reason);              /* signaled */
 449                 printf("*** Signal %d", status);
 450             }
 451
 452
 453             if (!WIFEXITED(reason) || (status != 0)) {
 454                 if (errCheck) {
 455 #ifdef USE_META
 456                     if (useMeta) {
 457                         meta_job_error(NULL, gn, 0, status);
 458                     }
 459 #endif
 460                     gn->made = ERROR;
 461                     if (keepgoing) {
 462                         /*
 463                          * Abort the current target, but let others
 464                          * continue.
 465                          */
 466                         printf(" (continuing)\n");
 467                     }
 468                 } else {
 469                     /*
 470                      * Continue executing commands for this target.
 471                      * If we return 0, this will happen...
 472                      */
 473                     printf(" (ignored)\n");
 474                     status = 0;
 475                 }
 476             }
 477             break;
 478         } else {
 479             Fatal("error in wait: %d: %s", retstat, strerror(errno));
 480             /*NOTREACHED*/
 481         }
 482     }
 483     free(cmdStart);
 484
 485     return (status);
 486 }
 487 \f
 488 /*-
 489  *-----------------------------------------------------------------------
 490  * Compat_Make --
 491  *      Make a target.
 492  *
 493  * Input:
 494  *      gnp             The node to make
 495  *      pgnp            Parent to abort if necessary
 496  *
 497  * Results:
 498  *      0
 499  *
 500  * Side Effects:
 501  *      If an error is detected and not being ignored, the process exits.
 502  *
 503  *-----------------------------------------------------------------------
 504  */
 505 int
 506 Compat_Make(void *gnp, void *pgnp)
 507 {
 508     GNode *gn = (GNode *)gnp;
 509     GNode *pgn = (GNode *)pgnp;
 510
 511     if (!meta[0])               /* we came here from jobs */
 512         Compat_Init();
 513     if (gn->made == UNMADE && (gn == pgn || (pgn->type & OP_MADE) == 0)) {
 514         /*
 515          * First mark ourselves to be made, then apply whatever transformations
 516          * the suffix module thinks are necessary. Once that's done, we can
 517          * descend and make all our children. If any of them has an error
 518          * but the -k flag was given, our 'make' field will be set FALSE again.
 519          * This is our signal to not attempt to do anything but abort our
 520          * parent as well.
 521          */
 522         gn->flags |= REMAKE;
 523         gn->made = BEINGMADE;
 524         if ((gn->type & OP_MADE) == 0)
 525             Suff_FindDeps(gn);
 526         Lst_ForEach(gn->children, Compat_Make, gn);
 527         if ((gn->flags & REMAKE) == 0) {
 528             gn->made = ABORTED;
 529             pgn->flags &= ~REMAKE;
 530             goto cohorts;
 531         }
 532
 533         if (Lst_Member(gn->iParents, pgn) != NULL) {
 534             char *p1;
 535             Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn, 0);
 536             if (p1)
 537                 free(p1);
 538         }
 539
 540         /*
 541          * All the children were made ok. Now cmgn->mtime contains the
 542          * modification time of the newest child, we need to find out if we
 543          * exist and when we were modified last. The criteria for datedness
 544          * are defined by the Make_OODate function.
 545          */
 546         if (DEBUG(MAKE)) {
 547             fprintf(debug_file, "Examining %s...", gn->name);
 548         }
 549         if (! Make_OODate(gn)) {
 550             gn->made = UPTODATE;
 551             if (DEBUG(MAKE)) {
 552                 fprintf(debug_file, "up-to-date.\n");
 553             }
 554             goto cohorts;
 555         } else if (DEBUG(MAKE)) {
 556             fprintf(debug_file, "out-of-date.\n");
 557         }
 558
 559         /*
 560          * If the user is just seeing if something is out-of-date, exit now
 561          * to tell him/her "yes".
 562          */
 563         if (queryFlag) {
 564             exit(1);
 565         }
 566
 567         /*
 568          * We need to be re-made. We also have to make sure we've got a $?
 569          * variable. To be nice, we also define the $> variable using
 570          * Make_DoAllVar().
 571          */
 572         Make_DoAllVar(gn);
 573
 574         /*
 575          * Alter our type to tell if errors should be ignored or things
 576          * should not be printed so CompatRunCommand knows what to do.
 577          */
 578         if (Targ_Ignore(gn)) {
 579             gn->type |= OP_IGNORE;
 580         }
 581         if (Targ_Silent(gn)) {
 582             gn->type |= OP_SILENT;
 583         }
 584
 585         if (Job_CheckCommands(gn, Fatal)) {
 586             /*
 587              * Our commands are ok, but we still have to worry about the -t
 588              * flag...
 589              */
 590             if (!touchFlag || (gn->type & OP_MAKE)) {
 591                 curTarg = gn;
 592 #ifdef USE_META
 593                 if (useMeta && !NoExecute(gn)) {
 594                     meta_job_start(NULL, gn);
 595                 }
 596 #endif
 597                 Lst_ForEach(gn->commands, CompatRunCommand, gn);
 598                 curTarg = NULL;
 599             } else {
 600                 Job_Touch(gn, gn->type & OP_SILENT);
 601             }
 602         } else {
 603             gn->made = ERROR;
 604         }
 605 #ifdef USE_META
 606         if (useMeta && !NoExecute(gn)) {
 607             meta_job_finish(NULL);
 608         }
 609 #endif
 610
 611         if (gn->made != ERROR) {
 612             /*
 613              * If the node was made successfully, mark it so, update
 614              * its modification time and timestamp all its parents. Note
 615              * that for .ZEROTIME targets, the timestamping isn't done.
 616              * This is to keep its state from affecting that of its parent.
 617              */
 618             gn->made = MADE;
 619             pgn->flags |= Make_Recheck(gn) == 0 ? FORCE : 0;
 620             if (!(gn->type & OP_EXEC)) {
 621                 pgn->flags |= CHILDMADE;
 622                 Make_TimeStamp(pgn, gn);
 623             }
 624         } else if (keepgoing) {
 625             pgn->flags &= ~REMAKE;
 626         } else {
 627             PrintOnError(gn, "\n\nStop.");
 628             exit(1);
 629         }
 630     } else if (gn->made == ERROR) {
 631         /*
 632          * Already had an error when making this beastie. Tell the parent
 633          * to abort.
 634          */
 635         pgn->flags &= ~REMAKE;
 636     } else {
 637         if (Lst_Member(gn->iParents, pgn) != NULL) {
 638             char *p1;
 639             Var_Set(IMPSRC, Var_Value(TARGET, gn, &p1), pgn, 0);
 640             if (p1)
 641                 free(p1);
 642         }
 643         switch(gn->made) {
 644             case BEINGMADE:
 645                 Error("Graph cycles through %s", gn->name);
 646                 gn->made = ERROR;
 647                 pgn->flags &= ~REMAKE;
 648                 break;
 649             case MADE:
 650                 if ((gn->type & OP_EXEC) == 0) {
 651                     pgn->flags |= CHILDMADE;
 652                     Make_TimeStamp(pgn, gn);
 653                 }
 654                 break;
 655             case UPTODATE:
 656                 if ((gn->type & OP_EXEC) == 0) {
 657                     Make_TimeStamp(pgn, gn);
 658                 }
 659                 break;
 660             default:
 661                 break;
 662         }
 663     }
 664
 665 cohorts:
 666     Lst_ForEach(gn->cohorts, Compat_Make, pgnp);
 667     return (0);
 668 }
 669 \f
 670 /*-
 671  *-----------------------------------------------------------------------
 672  * Compat_Run --
 673  *      Initialize this mode and start making.
 674  *
 675  * Input:
 676  *      targs           List of target nodes to re-create
 677  *
 678  * Results:
 679  *      None.
 680  *
 681  * Side Effects:
 682  *      Guess what?
 683  *
 684  *-----------------------------------------------------------------------
 685  */
 686 void
 687 Compat_Run(Lst targs)
 688 {
 689     GNode         *gn = NULL;/* Current root target */
 690     int           errors;   /* Number of targets not remade due to errors */
 691
 692     Compat_Init();
 693
 694     if (bmake_signal(SIGINT, SIG_IGN) != SIG_IGN) {
 695         bmake_signal(SIGINT, CompatInterrupt);
 696     }
 697     if (bmake_signal(SIGTERM, SIG_IGN) != SIG_IGN) {
 698         bmake_signal(SIGTERM, CompatInterrupt);
 699     }
 700     if (bmake_signal(SIGHUP, SIG_IGN) != SIG_IGN) {
 701         bmake_signal(SIGHUP, CompatInterrupt);
 702     }
 703     if (bmake_signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
 704         bmake_signal(SIGQUIT, CompatInterrupt);
 705     }
 706
 707     ENDNode = Targ_FindNode(".END", TARG_CREATE);
 708     ENDNode->type = OP_SPECIAL;
 709     /*
 710      * If the user has defined a .BEGIN target, execute the commands attached
 711      * to it.
 712      */
 713     if (!queryFlag) {
 714         gn = Targ_FindNode(".BEGIN", TARG_NOCREATE);
 715         if (gn != NULL) {
 716             Compat_Make(gn, gn);
 717             if (gn->made == ERROR) {
 718                 PrintOnError(gn, "\n\nStop.");
 719                 exit(1);
 720             }
 721         }
 722     }
 723
 724     /*
 725      * Expand .USE nodes right now, because they can modify the structure
 726      * of the tree.
 727      */
 728     Make_ExpandUse(targs);
 729
 730     /*
 731      * For each entry in the list of targets to create, call Compat_Make on
 732      * it to create the thing. Compat_Make will leave the 'made' field of gn
 733      * in one of several states:
 734      *      UPTODATE        gn was already up-to-date
 735      *      MADE            gn was recreated successfully
 736      *      ERROR           An error occurred while gn was being created
 737      *      ABORTED         gn was not remade because one of its inferiors
 738      *                      could not be made due to errors.
 739      */
 740     errors = 0;
 741     while (!Lst_IsEmpty (targs)) {
 742         gn = (GNode *)Lst_DeQueue(targs);
 743         Compat_Make(gn, gn);
 744
 745         if (gn->made == UPTODATE) {
 746             printf("`%s' is up to date.\n", gn->name);
 747         } else if (gn->made == ABORTED) {
 748             printf("`%s' not remade because of errors.\n", gn->name);
 749             errors += 1;
 750         }
 751     }
 752
 753     /*
 754      * If the user has defined a .END target, run its commands.
 755      */
 756     if (errors == 0) {
 757         Compat_Make(ENDNode, ENDNode);
 758         if (gn->made == ERROR) {
 759             PrintOnError(gn, "\n\nStop.");
 760             exit(1);
 761         }
 762     }
 763 }