1 /* $NetBSD: compat.c,v 1.246 2023/03/18 22:20:11 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 /* 73 * This file implements the full-compatibility mode of make, which makes the 74 * targets without parallelism and without a custom shell. 75 * 76 * Interface: 77 * Compat_MakeAll Initialize this module and make the given targets. 78 */ 79 80 #ifdef HAVE_CONFIG_H 81 # include "config.h" 82 #endif 83 #include <sys/types.h> 84 #include <sys/stat.h> 85 #include "wait.h" 86 87 #include <errno.h> 88 #include <signal.h> 89 90 #include "make.h" 91 #include "dir.h" 92 #include "job.h" 93 #include "metachar.h" 94 #include "pathnames.h" 95 96 /* "@(#)compat.c 8.2 (Berkeley) 3/19/94" */ 97 MAKE_RCSID("$NetBSD: compat.c,v 1.246 2023/03/18 22:20:11 sjg Exp $"); 98 99 static GNode *curTarg = NULL; 100 static pid_t compatChild; 101 static int compatSigno; 102 103 /* 104 * Delete the file of a failed, interrupted, or otherwise duffed target, 105 * unless inhibited by .PRECIOUS. 106 */ 107 static void 108 CompatDeleteTarget(GNode *gn) 109 { 110 if (gn != NULL && !GNode_IsPrecious(gn) && 111 (gn->type & OP_PHONY) == 0) { 112 const char *file = GNode_VarTarget(gn); 113 114 if (!opts.noExecute && unlink_file(file) == 0) { 115 Error("*** %s removed", file); 116 } 117 } 118 } 119 120 /* 121 * Interrupt the creation of the current target and remove it if it ain't 122 * precious. Then exit. 123 * 124 * If .INTERRUPT exists, its commands are run first WITH INTERRUPTS IGNORED. 125 * 126 * XXX: is .PRECIOUS supposed to inhibit .INTERRUPT? I doubt it, but I've 127 * left the logic alone for now. - dholland 20160826 128 */ 129 static void 130 CompatInterrupt(int signo) 131 { 132 CompatDeleteTarget(curTarg); 133 134 if (curTarg != NULL && !GNode_IsPrecious(curTarg)) { 135 /* 136 * Run .INTERRUPT only if hit with interrupt signal 137 */ 138 if (signo == SIGINT) { 139 GNode *gn = Targ_FindNode(".INTERRUPT"); 140 if (gn != NULL) { 141 Compat_Make(gn, gn); 142 } 143 } 144 } 145 146 if (signo == SIGQUIT) 147 _exit(signo); 148 149 /* 150 * If there is a child running, pass the signal on. 151 * We will exist after it has exited. 152 */ 153 compatSigno = signo; 154 if (compatChild > 0) { 155 KILLPG(compatChild, signo); 156 } else { 157 bmake_signal(signo, SIG_DFL); 158 kill(myPid, signo); 159 } 160 } 161 162 static void 163 DebugFailedTarget(const char *cmd, const GNode *gn) 164 { 165 const char *p = cmd; 166 debug_printf("\n*** Failed target: %s\n*** Failed command: ", 167 gn->name); 168 169 /* 170 * Replace runs of whitespace with a single space, to reduce the 171 * amount of whitespace for multi-line command lines. 172 */ 173 while (*p != '\0') { 174 if (ch_isspace(*p)) { 175 debug_printf(" "); 176 cpp_skip_whitespace(&p); 177 } else { 178 debug_printf("%c", *p); 179 p++; 180 } 181 } 182 debug_printf("\n"); 183 } 184 185 static bool 186 UseShell(const char *cmd MAKE_ATTR_UNUSED) 187 { 188 #if defined(FORCE_USE_SHELL) || !defined(MAKE_NATIVE) 189 /* 190 * In a non-native build, the host environment might be weird enough 191 * that it's necessary to go through a shell to get the correct 192 * behaviour. Or perhaps the shell has been replaced with something 193 * that does extra logging, and that should not be bypassed. 194 */ 195 return true; 196 #else 197 /* 198 * Search for meta characters in the command. If there are no meta 199 * characters, there's no need to execute a shell to execute the 200 * command. 201 * 202 * Additionally variable assignments and empty commands 203 * go to the shell. Therefore treat '=' and ':' like shell 204 * meta characters as documented in make(1). 205 */ 206 207 return needshell(cmd); 208 #endif 209 } 210 211 /* 212 * Execute the next command for a target. If the command returns an error, 213 * the node's made field is set to ERROR and creation stops. 214 * 215 * Input: 216 * cmdp Command to execute 217 * gn Node from which the command came 218 * ln List node that contains the command 219 * 220 * Results: 221 * true if the command succeeded. 222 */ 223 bool 224 Compat_RunCommand(const char *cmdp, GNode *gn, StringListNode *ln) 225 { 226 char *cmdStart; /* Start of expanded command */ 227 char *bp; 228 bool silent; /* Don't print command */ 229 bool doIt; /* Execute even if -n */ 230 volatile bool errCheck; /* Check errors */ 231 WAIT_T reason; /* Reason for child's death */ 232 WAIT_T status; /* Description of child's death */ 233 pid_t cpid; /* Child actually found */ 234 pid_t retstat; /* Result of wait */ 235 const char **volatile av; /* Argument vector for thing to exec */ 236 char **volatile mav; /* Copy of the argument vector for freeing */ 237 bool useShell; /* True if command should be executed using a 238 * shell */ 239 const char *volatile cmd = cmdp; 240 241 silent = (gn->type & OP_SILENT) != OP_NONE; 242 errCheck = !(gn->type & OP_IGNORE); 243 doIt = false; 244 245 cmdStart = Var_Subst(cmd, gn, VARE_WANTRES); 246 /* TODO: handle errors */ 247 248 if (cmdStart[0] == '\0') { 249 free(cmdStart); 250 return true; 251 } 252 cmd = cmdStart; 253 LstNode_Set(ln, cmdStart); 254 255 if (gn->type & OP_SAVE_CMDS) { 256 GNode *endNode = Targ_GetEndNode(); 257 if (gn != endNode) { 258 /* 259 * Append the expanded command, to prevent the 260 * local variables from being interpreted in the 261 * scope of the .END node. 262 * 263 * A probably unintended side effect of this is that 264 * the expanded command will be expanded again in the 265 * .END node. Therefore, a literal '$' in these 266 * commands must be written as '$$$$' instead of the 267 * usual '$$'. 268 */ 269 Lst_Append(&endNode->commands, cmdStart); 270 return true; 271 } 272 } 273 if (strcmp(cmdStart, "...") == 0) { 274 gn->type |= OP_SAVE_CMDS; 275 return true; 276 } 277 278 for (;;) { 279 if (*cmd == '@') 280 silent = !DEBUG(LOUD); 281 else if (*cmd == '-') 282 errCheck = false; 283 else if (*cmd == '+') { 284 doIt = true; 285 if (shellName == NULL) /* we came here from jobs */ 286 Shell_Init(); 287 } else if (!ch_isspace(*cmd)) 288 /* Ignore whitespace for compatibility with gnu make */ 289 break; 290 cmd++; 291 } 292 293 while (ch_isspace(*cmd)) 294 cmd++; 295 296 /* 297 * If we did not end up with a command, just skip it. 298 */ 299 if (cmd[0] == '\0') 300 return true; 301 302 useShell = UseShell(cmd); 303 /* 304 * Print the command before echoing if we're not supposed to be quiet 305 * for this one. We also print the command if -n given. 306 */ 307 if (!silent || !GNode_ShouldExecute(gn)) { 308 printf("%s\n", cmd); 309 fflush(stdout); 310 } 311 312 /* 313 * If we're not supposed to execute any commands, this is as far as 314 * we go... 315 */ 316 if (!doIt && !GNode_ShouldExecute(gn)) 317 return true; 318 319 DEBUG1(JOB, "Execute: '%s'\n", cmd); 320 321 if (useShell) { 322 /* 323 * We need to pass the command off to the shell, typically 324 * because the command contains a "meta" character. 325 */ 326 static const char *shargv[5]; 327 328 /* The following work for any of the builtin shell specs. */ 329 int shargc = 0; 330 shargv[shargc++] = shellPath; 331 if (errCheck && shellErrFlag != NULL) 332 shargv[shargc++] = shellErrFlag; 333 shargv[shargc++] = DEBUG(SHELL) ? "-xc" : "-c"; 334 shargv[shargc++] = cmd; 335 shargv[shargc] = NULL; 336 av = shargv; 337 bp = NULL; 338 mav = NULL; 339 } else { 340 /* 341 * No meta-characters, so no need to exec a shell. Break the 342 * command into words to form an argument vector we can 343 * execute. 344 */ 345 Words words = Str_Words(cmd, false); 346 mav = words.words; 347 bp = words.freeIt; 348 av = (void *)mav; 349 } 350 351 #ifdef USE_META 352 if (useMeta) 353 meta_compat_start(); 354 #endif 355 356 Var_ReexportVars(); 357 358 compatChild = cpid = vfork(); 359 if (cpid < 0) 360 Fatal("Could not fork"); 361 362 if (cpid == 0) { 363 #ifdef USE_META 364 if (useMeta) 365 meta_compat_child(); 366 #endif 367 (void)execvp(av[0], (char *const *)UNCONST(av)); 368 execDie("exec", av[0]); 369 } 370 371 free(mav); 372 free(bp); 373 374 /* XXX: Memory management looks suspicious here. */ 375 /* XXX: Setting a list item to NULL is unexpected. */ 376 LstNode_SetNull(ln); 377 378 #ifdef USE_META 379 if (useMeta) 380 meta_compat_parent(cpid); 381 #endif 382 383 /* 384 * The child is off and running. Now all we can do is wait... 385 */ 386 while ((retstat = wait(&reason)) != cpid) { 387 if (retstat > 0) 388 JobReapChild(retstat, reason, false); /* not ours? */ 389 if (retstat == -1 && errno != EINTR) { 390 break; 391 } 392 } 393 394 if (retstat < 0) 395 Fatal("error in wait: %d: %s", retstat, strerror(errno)); 396 397 if (WIFSTOPPED(reason)) { 398 status = WSTOPSIG(reason); /* stopped */ 399 } else if (WIFEXITED(reason)) { 400 status = WEXITSTATUS(reason); /* exited */ 401 #if defined(USE_META) && defined(USE_FILEMON_ONCE) 402 if (useMeta) 403 meta_cmd_finish(NULL); 404 #endif 405 if (status != 0) { 406 if (DEBUG(ERROR)) 407 DebugFailedTarget(cmd, gn); 408 printf("*** Error code %d", status); 409 } 410 } else { 411 status = WTERMSIG(reason); /* signaled */ 412 printf("*** Signal %d", status); 413 } 414 415 416 if (!WIFEXITED(reason) || status != 0) { 417 if (errCheck) { 418 #ifdef USE_META 419 if (useMeta) 420 meta_job_error(NULL, gn, false, status); 421 #endif 422 gn->made = ERROR; 423 if (opts.keepgoing) { 424 /* 425 * Abort the current target, 426 * but let others continue. 427 */ 428 printf(" (continuing)\n"); 429 } else { 430 printf("\n"); 431 } 432 if (deleteOnError) 433 CompatDeleteTarget(gn); 434 } else { 435 /* 436 * Continue executing commands for this target. 437 * If we return 0, this will happen... 438 */ 439 printf(" (ignored)\n"); 440 status = 0; 441 } 442 } 443 444 free(cmdStart); 445 compatChild = 0; 446 if (compatSigno != 0) { 447 bmake_signal(compatSigno, SIG_DFL); 448 kill(myPid, compatSigno); 449 } 450 451 return status == 0; 452 } 453 454 static void 455 RunCommands(GNode *gn) 456 { 457 StringListNode *ln; 458 459 for (ln = gn->commands.first; ln != NULL; ln = ln->next) { 460 const char *cmd = ln->datum; 461 if (!Compat_RunCommand(cmd, gn, ln)) 462 break; 463 } 464 } 465 466 static void 467 MakeInRandomOrder(GNode **gnodes, GNode **end, GNode *pgn) 468 { 469 GNode **it; 470 size_t r; 471 472 for (r = (size_t)(end - gnodes); r >= 2; r--) { 473 /* Biased, but irrelevant in practice. */ 474 size_t i = (size_t)random() % r; 475 GNode *t = gnodes[r - 1]; 476 gnodes[r - 1] = gnodes[i]; 477 gnodes[i] = t; 478 } 479 480 for (it = gnodes; it != end; it++) 481 Compat_Make(*it, pgn); 482 } 483 484 static void 485 MakeWaitGroupsInRandomOrder(GNodeList *gnodes, GNode *pgn) 486 { 487 Vector vec; 488 GNodeListNode *ln; 489 GNode **nodes; 490 size_t i, n, start; 491 492 Vector_Init(&vec, sizeof(GNode *)); 493 for (ln = gnodes->first; ln != NULL; ln = ln->next) 494 *(GNode **)Vector_Push(&vec) = ln->datum; 495 nodes = vec.items; 496 n = vec.len; 497 498 start = 0; 499 for (i = 0; i < n; i++) { 500 if (nodes[i]->type & OP_WAIT) { 501 MakeInRandomOrder(nodes + start, nodes + i, pgn); 502 Compat_Make(nodes[i], pgn); 503 start = i + 1; 504 } 505 } 506 MakeInRandomOrder(nodes + start, nodes + i, pgn); 507 508 Vector_Done(&vec); 509 } 510 511 static void 512 MakeNodes(GNodeList *gnodes, GNode *pgn) 513 { 514 GNodeListNode *ln; 515 516 if (Lst_IsEmpty(gnodes)) 517 return; 518 if (opts.randomizeTargets) { 519 MakeWaitGroupsInRandomOrder(gnodes, pgn); 520 return; 521 } 522 523 for (ln = gnodes->first; ln != NULL; ln = ln->next) { 524 GNode *cgn = ln->datum; 525 Compat_Make(cgn, pgn); 526 } 527 } 528 529 static bool 530 MakeUnmade(GNode *gn, GNode *pgn) 531 { 532 533 assert(gn->made == UNMADE); 534 535 /* 536 * First mark ourselves to be made, then apply whatever transformations 537 * the suffix module thinks are necessary. Once that's done, we can 538 * descend and make all our children. If any of them has an error 539 * but the -k flag was given, our 'make' field will be set to false 540 * again. This is our signal to not attempt to do anything but abort 541 * our parent as well. 542 */ 543 gn->flags.remake = true; 544 gn->made = BEINGMADE; 545 546 if (!(gn->type & OP_MADE)) 547 Suff_FindDeps(gn); 548 549 MakeNodes(&gn->children, gn); 550 551 if (!gn->flags.remake) { 552 gn->made = ABORTED; 553 pgn->flags.remake = false; 554 return false; 555 } 556 557 if (Lst_FindDatum(&gn->implicitParents, pgn) != NULL) 558 Var_Set(pgn, IMPSRC, GNode_VarTarget(gn)); 559 560 /* 561 * All the children were made ok. Now youngestChild->mtime contains the 562 * modification time of the newest child, we need to find out if we 563 * exist and when we were modified last. The criteria for datedness 564 * are defined by GNode_IsOODate. 565 */ 566 DEBUG1(MAKE, "Examining %s...", gn->name); 567 if (!GNode_IsOODate(gn)) { 568 gn->made = UPTODATE; 569 DEBUG0(MAKE, "up-to-date.\n"); 570 return false; 571 } 572 573 /* 574 * If the user is just seeing if something is out-of-date, exit now 575 * to tell him/her "yes". 576 */ 577 DEBUG0(MAKE, "out-of-date.\n"); 578 if (opts.query && gn != Targ_GetEndNode()) 579 exit(1); 580 581 /* 582 * We need to be re-made. 583 * Ensure that $? (.OODATE) and $> (.ALLSRC) are both set. 584 */ 585 GNode_SetLocalVars(gn); 586 587 /* 588 * Alter our type to tell if errors should be ignored or things 589 * should not be printed so Compat_RunCommand knows what to do. 590 */ 591 if (opts.ignoreErrors) 592 gn->type |= OP_IGNORE; 593 if (opts.silent) 594 gn->type |= OP_SILENT; 595 596 if (Job_CheckCommands(gn, Fatal)) { 597 /* 598 * Our commands are ok, but we still have to worry about 599 * the -t flag. 600 */ 601 if (!opts.touch || (gn->type & OP_MAKE)) { 602 curTarg = gn; 603 #ifdef USE_META 604 if (useMeta && GNode_ShouldExecute(gn)) 605 meta_job_start(NULL, gn); 606 #endif 607 RunCommands(gn); 608 curTarg = NULL; 609 } else { 610 Job_Touch(gn, (gn->type & OP_SILENT) != OP_NONE); 611 } 612 } else { 613 gn->made = ERROR; 614 } 615 #ifdef USE_META 616 if (useMeta && GNode_ShouldExecute(gn)) { 617 if (meta_job_finish(NULL) != 0) 618 gn->made = ERROR; 619 } 620 #endif 621 622 if (gn->made != ERROR) { 623 /* 624 * If the node was made successfully, mark it so, update 625 * its modification time and timestamp all its parents. 626 * This is to keep its state from affecting that of its parent. 627 */ 628 gn->made = MADE; 629 if (Make_Recheck(gn) == 0) 630 pgn->flags.force = true; 631 if (!(gn->type & OP_EXEC)) { 632 pgn->flags.childMade = true; 633 GNode_UpdateYoungestChild(pgn, gn); 634 } 635 } else if (opts.keepgoing) { 636 pgn->flags.remake = false; 637 } else { 638 PrintOnError(gn, "\nStop.\n"); 639 exit(1); 640 } 641 return true; 642 } 643 644 static void 645 MakeOther(GNode *gn, GNode *pgn) 646 { 647 648 if (Lst_FindDatum(&gn->implicitParents, pgn) != NULL) { 649 const char *target = GNode_VarTarget(gn); 650 Var_Set(pgn, IMPSRC, target != NULL ? target : ""); 651 } 652 653 switch (gn->made) { 654 case BEINGMADE: 655 Error("Graph cycles through %s", gn->name); 656 gn->made = ERROR; 657 pgn->flags.remake = false; 658 break; 659 case MADE: 660 if (!(gn->type & OP_EXEC)) { 661 pgn->flags.childMade = true; 662 GNode_UpdateYoungestChild(pgn, gn); 663 } 664 break; 665 case UPTODATE: 666 if (!(gn->type & OP_EXEC)) 667 GNode_UpdateYoungestChild(pgn, gn); 668 break; 669 default: 670 break; 671 } 672 } 673 674 /* 675 * Make a target. 676 * 677 * If an error is detected and not being ignored, the process exits. 678 * 679 * Input: 680 * gn The node to make 681 * pgn Parent to abort if necessary 682 * 683 * Output: 684 * gn->made 685 * UPTODATE gn was already up-to-date. 686 * MADE gn was recreated successfully. 687 * ERROR An error occurred while gn was being created, 688 * either due to missing commands or in -k mode. 689 * ABORTED gn was not remade because one of its 690 * dependencies could not be made due to errors. 691 */ 692 void 693 Compat_Make(GNode *gn, GNode *pgn) 694 { 695 if (shellName == NULL) /* we came here from jobs */ 696 Shell_Init(); 697 698 if (gn->made == UNMADE && (gn == pgn || !(pgn->type & OP_MADE))) { 699 if (!MakeUnmade(gn, pgn)) 700 goto cohorts; 701 702 /* XXX: Replace with GNode_IsError(gn) */ 703 } else if (gn->made == ERROR) { 704 /* 705 * Already had an error when making this. 706 * Tell the parent to abort. 707 */ 708 pgn->flags.remake = false; 709 } else { 710 MakeOther(gn, pgn); 711 } 712 713 cohorts: 714 MakeNodes(&gn->cohorts, pgn); 715 } 716 717 static void 718 MakeBeginNode(void) 719 { 720 GNode *gn = Targ_FindNode(".BEGIN"); 721 if (gn == NULL) 722 return; 723 724 Compat_Make(gn, gn); 725 if (GNode_IsError(gn)) { 726 PrintOnError(gn, "\nStop.\n"); 727 exit(1); 728 } 729 } 730 731 static void 732 InitSignals(void) 733 { 734 if (bmake_signal(SIGINT, SIG_IGN) != SIG_IGN) 735 bmake_signal(SIGINT, CompatInterrupt); 736 if (bmake_signal(SIGTERM, SIG_IGN) != SIG_IGN) 737 bmake_signal(SIGTERM, CompatInterrupt); 738 if (bmake_signal(SIGHUP, SIG_IGN) != SIG_IGN) 739 bmake_signal(SIGHUP, CompatInterrupt); 740 if (bmake_signal(SIGQUIT, SIG_IGN) != SIG_IGN) 741 bmake_signal(SIGQUIT, CompatInterrupt); 742 } 743 744 void 745 Compat_MakeAll(GNodeList *targs) 746 { 747 GNode *errorNode = NULL; 748 749 if (shellName == NULL) 750 Shell_Init(); 751 752 InitSignals(); 753 754 /* 755 * Create the .END node now, to keep the (debug) output of the 756 * counter.mk test the same as before 2020-09-23. This 757 * implementation detail probably doesn't matter though. 758 */ 759 (void)Targ_GetEndNode(); 760 761 if (!opts.query) 762 MakeBeginNode(); 763 764 /* 765 * Expand .USE nodes right now, because they can modify the structure 766 * of the tree. 767 */ 768 Make_ExpandUse(targs); 769 770 while (!Lst_IsEmpty(targs)) { 771 GNode *gn = Lst_Dequeue(targs); 772 Compat_Make(gn, gn); 773 774 if (gn->made == UPTODATE) { 775 printf("`%s' is up to date.\n", gn->name); 776 } else if (gn->made == ABORTED) { 777 printf("`%s' not remade because of errors.\n", 778 gn->name); 779 } 780 if (GNode_IsError(gn) && errorNode == NULL) 781 errorNode = gn; 782 } 783 784 /* If the user has defined a .END target, run its commands. */ 785 if (errorNode == NULL) { 786 GNode *endNode = Targ_GetEndNode(); 787 Compat_Make(endNode, endNode); 788 if (GNode_IsError(endNode)) 789 errorNode = endNode; 790 } 791 792 if (errorNode != NULL) { 793 if (DEBUG(GRAPH2)) 794 Targ_PrintGraph(2); 795 else if (DEBUG(GRAPH3)) 796 Targ_PrintGraph(3); 797 PrintOnError(errorNode, "\nStop.\n"); 798 exit(1); 799 } 800 } 801