contrib/bmake/compat.c

   1 /*      $NetBSD: compat.c,v 1.93 2013/09/02 19:26:42 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.93 2013/09/02 19:26:42 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.93 2013/09/02 19:26:42 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[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 \f
 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 \f
 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 }