main.c revision 186279
1/*- 2 * Copyright (c) 1988, 1989, 1990, 1993 3 * The Regents of the University of California. All rights reserved. 4 * Copyright (c) 1989 by Berkeley Softworks 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. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)main.c 8.3 (Berkeley) 3/19/94 39 */ 40 41#ifndef lint 42#if 0 43static char copyright[] = 44"@(#) Copyright (c) 1988, 1989, 1990, 1993\n\ 45 The Regents of the University of California. All rights reserved.\n"; 46#endif 47#endif /* not lint */ 48#include <sys/cdefs.h> 49__FBSDID("$FreeBSD: head/usr.bin/make/main.c 186279 2008-12-18 12:16:51Z fjoe $"); 50 51/* 52 * main.c 53 * The main file for this entire program. Exit routines etc 54 * reside here. 55 * 56 * Utility functions defined in this file: 57 * Main_ParseArgLine 58 * Takes a line of arguments, breaks them and 59 * treats them as if they were given when first 60 * invoked. Used by the parse module to implement 61 * the .MFLAGS target. 62 */ 63 64#include <sys/param.h> 65#include <sys/stat.h> 66#include <sys/sysctl.h> 67#include <sys/time.h> 68#include <sys/queue.h> 69#include <sys/resource.h> 70#include <sys/utsname.h> 71#include <sys/wait.h> 72#include <err.h> 73#include <errno.h> 74#include <stdlib.h> 75#include <string.h> 76#include <unistd.h> 77 78#include "arch.h" 79#include "buf.h" 80#include "config.h" 81#include "dir.h" 82#include "globals.h" 83#include "GNode.h" 84#include "job.h" 85#include "make.h" 86#include "parse.h" 87#include "pathnames.h" 88#include "shell.h" 89#include "str.h" 90#include "suff.h" 91#include "targ.h" 92#include "util.h" 93#include "var.h" 94 95extern char **environ; /* XXX what header declares this variable? */ 96 97#define WANT_ENV_MKLVL 1 98#define MKLVL_MAXVAL 500 99#define MKLVL_ENVVAR "__MKLVL__" 100 101/* ordered list of makefiles to read */ 102static Lst makefiles = Lst_Initializer(makefiles); 103 104/* ordered list of source makefiles */ 105static Lst source_makefiles = Lst_Initializer(source_makefiles); 106 107/* list of variables to print */ 108static Lst variables = Lst_Initializer(variables); 109 110static Boolean expandVars; /* fully expand printed variables */ 111static Boolean noBuiltins; /* -r flag */ 112static Boolean forceJobs; /* -j argument given */ 113static char *curdir; /* startup directory */ 114static char *objdir; /* where we chdir'ed to */ 115static char **save_argv; /* saved argv */ 116static char *save_makeflags;/* saved MAKEFLAGS */ 117 118/* (-E) vars to override from env */ 119Lst envFirstVars = Lst_Initializer(envFirstVars); 120 121/* Targets to be made */ 122Lst create = Lst_Initializer(create); 123 124Boolean allPrecious; /* .PRECIOUS given on line by itself */ 125Boolean is_posix; /* .POSIX target seen */ 126Boolean mfAutoDeps; /* .MAKEFILEDEPS target seen */ 127Boolean beSilent; /* -s flag */ 128Boolean beVerbose; /* -v flag */ 129Boolean compatMake; /* -B argument */ 130int debug; /* -d flag */ 131Boolean ignoreErrors; /* -i flag */ 132int jobLimit; /* -j argument */ 133int makeErrors; /* Number of targets not remade due to errors */ 134Boolean jobsRunning; /* TRUE if the jobs might be running */ 135Boolean keepgoing; /* -k flag */ 136Boolean noExecute; /* -n flag */ 137Boolean printGraphOnly; /* -p flag */ 138Boolean queryFlag; /* -q flag */ 139Boolean touchFlag; /* -t flag */ 140Boolean usePipes; /* !-P flag */ 141uint32_t warn_cmd; /* command line warning flags */ 142uint32_t warn_flags; /* actual warning flags */ 143uint32_t warn_nocmd; /* command line no-warning flags */ 144 145time_t now; /* Time at start of make */ 146struct GNode *DEFAULT; /* .DEFAULT node */ 147 148/** 149 * Exit with usage message. 150 */ 151static void 152usage(void) 153{ 154 fprintf(stderr, 155 "usage: make [-BPSXeiknpqrstv] [-C directory] [-D variable]\n" 156 "\t[-d flags] [-E variable] [-f makefile] [-I directory]\n" 157 "\t[-j max_jobs] [-m directory] [-V variable]\n" 158 "\t[variable=value] [target ...]\n"); 159 exit(2); 160} 161 162/** 163 * MFLAGS_append 164 * Append a flag with an optional argument to MAKEFLAGS and MFLAGS 165 */ 166static void 167MFLAGS_append(const char *flag, char *arg) 168{ 169 char *str; 170 171 Var_Append(".MAKEFLAGS", flag, VAR_GLOBAL); 172 if (arg != NULL) { 173 str = MAKEFLAGS_quote(arg); 174 Var_Append(".MAKEFLAGS", str, VAR_GLOBAL); 175 free(str); 176 } 177 178 Var_Append("MFLAGS", flag, VAR_GLOBAL); 179 if (arg != NULL) { 180 str = MAKEFLAGS_quote(arg); 181 Var_Append("MFLAGS", str, VAR_GLOBAL); 182 free(str); 183 } 184} 185 186/** 187 * Main_ParseWarn 188 * 189 * Handle argument to warning option. 190 */ 191int 192Main_ParseWarn(const char *arg, int iscmd) 193{ 194 int i, neg; 195 196 static const struct { 197 const char *option; 198 uint32_t flag; 199 } options[] = { 200 { "dirsyntax", WARN_DIRSYNTAX }, 201 { NULL, 0 } 202 }; 203 204 neg = 0; 205 if (arg[0] == 'n' && arg[1] == 'o') { 206 neg = 1; 207 arg += 2; 208 } 209 210 for (i = 0; options[i].option != NULL; i++) 211 if (strcmp(arg, options[i].option) == 0) 212 break; 213 214 if (options[i].option == NULL) 215 /* unknown option */ 216 return (-1); 217 218 if (iscmd) { 219 if (!neg) { 220 warn_cmd |= options[i].flag; 221 warn_nocmd &= ~options[i].flag; 222 warn_flags |= options[i].flag; 223 } else { 224 warn_nocmd |= options[i].flag; 225 warn_cmd &= ~options[i].flag; 226 warn_flags &= ~options[i].flag; 227 } 228 } else { 229 if (!neg) { 230 warn_flags |= (options[i].flag & ~warn_nocmd); 231 } else { 232 warn_flags &= ~(options[i].flag | warn_cmd); 233 } 234 } 235 return (0); 236} 237 238/** 239 * Open and parse the given makefile. 240 * 241 * Results: 242 * TRUE if ok. FALSE if couldn't open file. 243 */ 244static Boolean 245ReadMakefile(const char p[]) 246{ 247 char *fname, *fnamesave; /* makefile to read */ 248 FILE *stream; 249 char *name, path[MAXPATHLEN]; 250 char *MAKEFILE; 251 int setMAKEFILE; 252 253 /* XXX - remove this once constification is done */ 254 fnamesave = fname = estrdup(p); 255 256 if (!strcmp(fname, "-")) { 257 Parse_File("(stdin)", stdin); 258 Var_SetGlobal("MAKEFILE", ""); 259 } else { 260 setMAKEFILE = strcmp(fname, ".depend"); 261 262 /* if we've chdir'd, rebuild the path name */ 263 if (curdir != objdir && *fname != '/') { 264 snprintf(path, MAXPATHLEN, "%s/%s", curdir, fname); 265 /* 266 * XXX The realpath stuff breaks relative includes 267 * XXX in some cases. The problem likely is in 268 * XXX parse.c where it does special things in 269 * XXX ParseDoInclude if the file is relateive 270 * XXX or absolute and not a system file. There 271 * XXX it assumes that if the current file that's 272 * XXX being included is absolute, that any files 273 * XXX that it includes shouldn't do the -I path 274 * XXX stuff, which is inconsistant with historical 275 * XXX behavior. However, I can't pentrate the mists 276 * XXX further, so I'm putting this workaround in 277 * XXX here until such time as the underlying bug 278 * XXX can be fixed. 279 */ 280#if THIS_BREAKS_THINGS 281 if (realpath(path, path) != NULL && 282 (stream = fopen(path, "r")) != NULL) { 283 MAKEFILE = fname; 284 fname = path; 285 goto found; 286 } 287 } else if (realpath(fname, path) != NULL) { 288 MAKEFILE = fname; 289 fname = path; 290 if ((stream = fopen(fname, "r")) != NULL) 291 goto found; 292 } 293#else 294 if ((stream = fopen(path, "r")) != NULL) { 295 MAKEFILE = fname; 296 fname = path; 297 goto found; 298 } 299 } else { 300 MAKEFILE = fname; 301 if ((stream = fopen(fname, "r")) != NULL) 302 goto found; 303 } 304#endif 305 /* look in -I and system include directories. */ 306 name = Path_FindFile(fname, &parseIncPath); 307 if (!name) 308 name = Path_FindFile(fname, &sysIncPath); 309 if (!name || !(stream = fopen(name, "r"))) { 310 free(fnamesave); 311 return (FALSE); 312 } 313 MAKEFILE = fname = name; 314 /* 315 * set the MAKEFILE variable desired by System V fans -- the 316 * placement of the setting here means it gets set to the last 317 * makefile specified, as it is set by SysV make. 318 */ 319found: 320 if (setMAKEFILE) 321 Var_SetGlobal("MAKEFILE", MAKEFILE); 322 Parse_File(fname, stream); 323 } 324 free(fnamesave); 325 return (TRUE); 326} 327 328/** 329 * Open and parse the given makefile. 330 * If open is successful add it to the list of makefiles. 331 * 332 * Results: 333 * TRUE if ok. FALSE if couldn't open file. 334 */ 335static Boolean 336TryReadMakefile(const char p[]) 337{ 338 char *data; 339 LstNode *last = Lst_Last(&source_makefiles); 340 341 if (!ReadMakefile(p)) 342 return (FALSE); 343 344 data = estrdup(p); 345 if (last == NULL) { 346 LstNode *first = Lst_First(&source_makefiles); 347 Lst_Insert(&source_makefiles, first, data); 348 } else 349 Lst_Append(&source_makefiles, last, estrdup(p)); 350 return (TRUE); 351} 352 353/** 354 * MainParseArgs 355 * Parse a given argument vector. Called from main() and from 356 * Main_ParseArgLine() when the .MAKEFLAGS target is used. 357 * 358 * XXX: Deal with command line overriding .MAKEFLAGS in makefile 359 * 360 * Side Effects: 361 * Various global and local flags will be set depending on the flags 362 * given 363 */ 364static void 365MainParseArgs(int argc, char **argv) 366{ 367 int c; 368 Boolean found_dd = FALSE; 369 370rearg: 371 optind = 1; /* since we're called more than once */ 372 optreset = 1; 373#define OPTFLAGS "ABC:D:E:I:PSV:Xd:ef:ij:km:npqrstvx:" 374 for (;;) { 375 if ((optind < argc) && strcmp(argv[optind], "--") == 0) { 376 found_dd = TRUE; 377 } 378 if ((c = getopt(argc, argv, OPTFLAGS)) == -1) { 379 break; 380 } 381 switch(c) { 382 383 case 'A': 384 arch_fatal = FALSE; 385 MFLAGS_append("-A", NULL); 386 break; 387 case 'C': 388 if (chdir(optarg) == -1) 389 err(1, "chdir %s", optarg); 390 break; 391 case 'D': 392 Var_SetGlobal(optarg, "1"); 393 MFLAGS_append("-D", optarg); 394 break; 395 case 'I': 396 Parse_AddIncludeDir(optarg); 397 MFLAGS_append("-I", optarg); 398 break; 399 case 'V': 400 Lst_AtEnd(&variables, estrdup(optarg)); 401 MFLAGS_append("-V", optarg); 402 break; 403 case 'X': 404 expandVars = FALSE; 405 break; 406 case 'B': 407 compatMake = TRUE; 408 MFLAGS_append("-B", NULL); 409 unsetenv("MAKE_JOBS_FIFO"); 410 break; 411 case 'P': 412 usePipes = FALSE; 413 MFLAGS_append("-P", NULL); 414 break; 415 case 'S': 416 keepgoing = FALSE; 417 MFLAGS_append("-S", NULL); 418 break; 419 case 'd': { 420 char *modules = optarg; 421 422 for (; *modules; ++modules) 423 switch (*modules) { 424 case 'A': 425 debug = ~0; 426 break; 427 case 'a': 428 debug |= DEBUG_ARCH; 429 break; 430 case 'c': 431 debug |= DEBUG_COND; 432 break; 433 case 'd': 434 debug |= DEBUG_DIR; 435 break; 436 case 'f': 437 debug |= DEBUG_FOR; 438 break; 439 case 'g': 440 if (modules[1] == '1') { 441 debug |= DEBUG_GRAPH1; 442 ++modules; 443 } 444 else if (modules[1] == '2') { 445 debug |= DEBUG_GRAPH2; 446 ++modules; 447 } 448 break; 449 case 'j': 450 debug |= DEBUG_JOB; 451 break; 452 case 'l': 453 debug |= DEBUG_LOUD; 454 break; 455 case 'm': 456 debug |= DEBUG_MAKE; 457 break; 458 case 's': 459 debug |= DEBUG_SUFF; 460 break; 461 case 't': 462 debug |= DEBUG_TARG; 463 break; 464 case 'v': 465 debug |= DEBUG_VAR; 466 break; 467 default: 468 warnx("illegal argument to d option " 469 "-- %c", *modules); 470 usage(); 471 } 472 MFLAGS_append("-d", optarg); 473 break; 474 } 475 case 'E': 476 Lst_AtEnd(&envFirstVars, estrdup(optarg)); 477 MFLAGS_append("-E", optarg); 478 break; 479 case 'e': 480 checkEnvFirst = TRUE; 481 MFLAGS_append("-e", NULL); 482 break; 483 case 'f': 484 Lst_AtEnd(&makefiles, estrdup(optarg)); 485 break; 486 case 'i': 487 ignoreErrors = TRUE; 488 MFLAGS_append("-i", NULL); 489 break; 490 case 'j': { 491 char *endptr; 492 493 forceJobs = TRUE; 494 jobLimit = strtol(optarg, &endptr, 10); 495 if (jobLimit <= 0 || *endptr != '\0') { 496 warnx("illegal number, -j argument -- %s", 497 optarg); 498 usage(); 499 } 500 MFLAGS_append("-j", optarg); 501 break; 502 } 503 case 'k': 504 keepgoing = TRUE; 505 MFLAGS_append("-k", NULL); 506 break; 507 case 'm': 508 Path_AddDir(&sysIncPath, optarg); 509 MFLAGS_append("-m", optarg); 510 break; 511 case 'n': 512 noExecute = TRUE; 513 MFLAGS_append("-n", NULL); 514 break; 515 case 'p': 516 printGraphOnly = TRUE; 517 debug |= DEBUG_GRAPH1; 518 break; 519 case 'q': 520 queryFlag = TRUE; 521 /* Kind of nonsensical, wot? */ 522 MFLAGS_append("-q", NULL); 523 break; 524 case 'r': 525 noBuiltins = TRUE; 526 MFLAGS_append("-r", NULL); 527 break; 528 case 's': 529 beSilent = TRUE; 530 MFLAGS_append("-s", NULL); 531 break; 532 case 't': 533 touchFlag = TRUE; 534 MFLAGS_append("-t", NULL); 535 break; 536 case 'v': 537 beVerbose = TRUE; 538 MFLAGS_append("-v", NULL); 539 break; 540 case 'x': 541 if (Main_ParseWarn(optarg, 1) != -1) 542 MFLAGS_append("-x", optarg); 543 break; 544 545 default: 546 case '?': 547 usage(); 548 } 549 } 550 argv += optind; 551 argc -= optind; 552 553 oldVars = TRUE; 554 555 /* 556 * Parse the rest of the arguments. 557 * o Check for variable assignments and perform them if so. 558 * o Check for more flags and restart getopt if so. 559 * o Anything else is taken to be a target and added 560 * to the end of the "create" list. 561 */ 562 for (; *argv != NULL; ++argv, --argc) { 563 if (Parse_IsVar(*argv)) { 564 char *ptr = MAKEFLAGS_quote(*argv); 565 char *v = estrdup(*argv); 566 567 Var_Append(".MAKEFLAGS", ptr, VAR_GLOBAL); 568 Parse_DoVar(v, VAR_CMD); 569 free(ptr); 570 free(v); 571 572 } else if ((*argv)[0] == '-') { 573 if ((*argv)[1] == '\0') { 574 /* 575 * (*argv) is a single dash, so we 576 * just ignore it. 577 */ 578 } else if (found_dd) { 579 /* 580 * Double dash has been found, ignore 581 * any more options. But what do we do 582 * with it? For now treat it like a target. 583 */ 584 Lst_AtEnd(&create, estrdup(*argv)); 585 } else { 586 /* 587 * (*argv) is a -flag, so backup argv and 588 * argc. getopt() expects options to start 589 * in the 2nd position. 590 */ 591 argc++; 592 argv--; 593 goto rearg; 594 } 595 596 } else if ((*argv)[0] == '\0') { 597 Punt("illegal (null) argument."); 598 599 } else { 600 Lst_AtEnd(&create, estrdup(*argv)); 601 } 602 } 603} 604 605/** 606 * Main_ParseArgLine 607 * Used by the parse module when a .MFLAGS or .MAKEFLAGS target 608 * is encountered and by main() when reading the .MAKEFLAGS envariable. 609 * Takes a line of arguments and breaks it into its 610 * component words and passes those words and the number of them to the 611 * MainParseArgs function. 612 * The line should have all its leading whitespace removed. 613 * 614 * Side Effects: 615 * Only those that come from the various arguments. 616 */ 617void 618Main_ParseArgLine(char *line, int mflags) 619{ 620 ArgArray aa; 621 622 if (line == NULL) 623 return; 624 for (; *line == ' '; ++line) 625 continue; 626 if (!*line) 627 return; 628 629 if (mflags) 630 MAKEFLAGS_break(&aa, line); 631 else 632 brk_string(&aa, line, TRUE); 633 634 MainParseArgs(aa.argc, aa.argv); 635 ArgArray_Done(&aa); 636} 637 638static char * 639chdir_verify_path(const char *path, char *obpath) 640{ 641 struct stat sb; 642 643 if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) { 644 if (chdir(path) == -1 || getcwd(obpath, MAXPATHLEN) == NULL) { 645 warn("warning: %s", path); 646 return (NULL); 647 } 648 return (obpath); 649 } 650 651 return (NULL); 652} 653 654/** 655 * In lieu of a good way to prevent every possible looping in make(1), stop 656 * there from being more than MKLVL_MAXVAL processes forked by make(1), to 657 * prevent a forkbomb from happening, in a dumb and mechanical way. 658 * 659 * Side Effects: 660 * Creates or modifies enviornment variable MKLVL_ENVVAR via setenv(). 661 */ 662static void 663check_make_level(void) 664{ 665#ifdef WANT_ENV_MKLVL 666 char *value = getenv(MKLVL_ENVVAR); 667 int level = (value == NULL) ? 0 : atoi(value); 668 669 if (level < 0) { 670 errc(2, EAGAIN, "Invalid value for recursion level (%d).", 671 level); 672 } else if (level > MKLVL_MAXVAL) { 673 errc(2, EAGAIN, "Max recursion level (%d) exceeded.", 674 MKLVL_MAXVAL); 675 } else { 676 char new_value[32]; 677 sprintf(new_value, "%d", level + 1); 678 setenv(MKLVL_ENVVAR, new_value, 1); 679 } 680#endif /* WANT_ENV_MKLVL */ 681} 682 683/** 684 * Main_AddSourceMakefile 685 * Add a file to the list of source makefiles 686 */ 687void 688Main_AddSourceMakefile(const char *name) 689{ 690 691 Lst_AtEnd(&source_makefiles, estrdup(name)); 692} 693 694/** 695 * Remake_Makefiles 696 * Remake all the makefiles 697 */ 698static void 699Remake_Makefiles(void) 700{ 701 LstNode *ln; 702 int error_cnt = 0; 703 int remade_cnt = 0; 704 705 Compat_InstallSignalHandlers(); 706 if (curdir != objdir) { 707 if (chdir(curdir) < 0) 708 Fatal("Failed to change directory to %s.", curdir); 709 } 710 711 LST_FOREACH(ln, &source_makefiles) { 712 LstNode *ln2; 713 struct GNode *gn; 714 const char *name = Lst_Datum(ln); 715 Boolean saveTouchFlag = touchFlag; 716 Boolean saveQueryFlag = queryFlag; 717 Boolean saveNoExecute = noExecute; 718 int mtime; 719 720 /* 721 * Create node 722 */ 723 gn = Targ_FindNode(name, TARG_CREATE); 724 DEBUGF(MAKE, ("Checking %s...", gn->name)); 725 Suff_FindDeps(gn); 726 727 /* 728 * ! dependencies as well as 729 * dependencies with .FORCE, .EXEC and .PHONY attributes 730 * are skipped to prevent infinite loops 731 */ 732 if (gn->type & (OP_FORCE | OP_EXEC | OP_PHONY)) { 733 DEBUGF(MAKE, ("skipping (force, exec or phony).\n", 734 gn->name)); 735 continue; 736 } 737 738 /* 739 * Skip :: targets that have commands and no children 740 * because such targets are always out-of-date 741 */ 742 if ((gn->type & OP_DOUBLEDEP) && 743 !Lst_IsEmpty(&gn->commands) && 744 Lst_IsEmpty(&gn->children)) { 745 DEBUGF(MAKE, ("skipping (doubledep, no sources " 746 "and has commands).\n")); 747 continue; 748 } 749 750 /* 751 * Skip targets without sources and without commands 752 */ 753 if (Lst_IsEmpty(&gn->commands) && 754 Lst_IsEmpty(&gn->children)) { 755 DEBUGF(MAKE, 756 ("skipping (no sources and no commands).\n")); 757 continue; 758 } 759 760 DEBUGF(MAKE, ("\n")); 761 762 /* 763 * -t, -q and -n has no effect unless the makefile is 764 * specified as one of the targets explicitly in the 765 * command line 766 */ 767 LST_FOREACH(ln2, &create) { 768 if (!strcmp(gn->name, Lst_Datum(ln2))) { 769 /* found as a target */ 770 break; 771 } 772 } 773 if (ln2 == NULL) { 774 touchFlag = FALSE; 775 queryFlag = FALSE; 776 noExecute = FALSE; 777 } 778 779 /* 780 * Check and remake the makefile 781 */ 782 mtime = Dir_MTime(gn); 783 Compat_Make(gn, gn); 784 785 /* 786 * Restore -t, -q and -n behaviour 787 */ 788 touchFlag = saveTouchFlag; 789 queryFlag = saveQueryFlag; 790 noExecute = saveNoExecute; 791 792 /* 793 * Compat_Make will leave the 'made' field of gn 794 * in one of the following states: 795 * UPTODATE gn was already up-to-date 796 * MADE gn was recreated successfully 797 * ERROR An error occurred while gn was being created 798 * ABORTED gn was not remade because one of its inferiors 799 * could not be made due to errors. 800 */ 801 if (gn->made == MADE) { 802 if (mtime != Dir_MTime(gn)) { 803 DEBUGF(MAKE, 804 ("%s updated (%d -> %d).\n", 805 gn->name, mtime, gn->mtime)); 806 remade_cnt++; 807 } else { 808 DEBUGF(MAKE, 809 ("%s not updated: skipping restart.\n", 810 gn->name)); 811 } 812 } else if (gn->made == ERROR) 813 error_cnt++; 814 else if (gn->made == ABORTED) { 815 printf("`%s' not remade because of errors.\n", 816 gn->name); 817 error_cnt++; 818 } else if (gn->made == UPTODATE) { 819 Lst examine; 820 821 Lst_Init(&examine); 822 Lst_EnQueue(&examine, gn); 823 while (!Lst_IsEmpty(&examine)) { 824 LstNode *eln; 825 GNode *egn = Lst_DeQueue(&examine); 826 827 egn->make = FALSE; 828 LST_FOREACH(eln, &egn->children) { 829 GNode *cgn = Lst_Datum(eln); 830 831 Lst_EnQueue(&examine, cgn); 832 } 833 } 834 } 835 } 836 837 if (error_cnt > 0) 838 Fatal("Failed to remake Makefiles."); 839 if (remade_cnt > 0) { 840 DEBUGF(MAKE, ("Restarting `%s'.\n", save_argv[0])); 841 842 /* 843 * Some of makefiles were remade -- restart from clean state 844 */ 845 if (save_makeflags != NULL) 846 setenv("MAKEFLAGS", save_makeflags, 1); 847 else 848 unsetenv("MAKEFLAGS"); 849 if (execvp(save_argv[0], save_argv) < 0) { 850 Fatal("Can't restart `%s': %s.", 851 save_argv[0], strerror(errno)); 852 } 853 } 854 855 if (curdir != objdir) { 856 if (chdir(objdir) < 0) 857 Fatal("Failed to change directory to %s.", objdir); 858 } 859} 860 861/** 862 * main 863 * The main function, for obvious reasons. Initializes variables 864 * and a few modules, then parses the arguments give it in the 865 * environment and on the command line. Reads the system makefile 866 * followed by either Makefile, makefile or the file given by the 867 * -f argument. Sets the .MAKEFLAGS PMake variable based on all the 868 * flags it has received by then uses either the Make or the Compat 869 * module to create the initial list of targets. 870 * 871 * Results: 872 * If -q was given, exits -1 if anything was out-of-date. Else it exits 873 * 0. 874 * 875 * Side Effects: 876 * The program exits when done. Targets are created. etc. etc. etc. 877 */ 878int 879main(int argc, char **argv) 880{ 881 const char *machine; 882 const char *machine_arch; 883 const char *machine_cpu; 884 Boolean outOfDate = TRUE; /* FALSE if all targets up to date */ 885 const char *p; 886 const char *pathp; 887 const char *path; 888 char mdpath[MAXPATHLEN]; 889 char obpath[MAXPATHLEN]; 890 char cdpath[MAXPATHLEN]; 891 char *cp = NULL, *start; 892 893 save_argv = argv; 894 save_makeflags = getenv("MAKEFLAGS"); 895 if (save_makeflags != NULL) 896 save_makeflags = estrdup(save_makeflags); 897 898 /* 899 * Initialize file global variables. 900 */ 901 expandVars = TRUE; 902 noBuiltins = FALSE; /* Read the built-in rules */ 903 forceJobs = FALSE; /* No -j flag */ 904 curdir = cdpath; 905 906 /* 907 * Initialize program global variables. 908 */ 909 beSilent = FALSE; /* Print commands as executed */ 910 ignoreErrors = FALSE; /* Pay attention to non-zero returns */ 911 noExecute = FALSE; /* Execute all commands */ 912 printGraphOnly = FALSE; /* Don't stop after printing graph */ 913 keepgoing = FALSE; /* Stop on error */ 914 allPrecious = FALSE; /* Remove targets when interrupted */ 915 queryFlag = FALSE; /* This is not just a check-run */ 916 touchFlag = FALSE; /* Actually update targets */ 917 usePipes = TRUE; /* Catch child output in pipes */ 918 debug = 0; /* No debug verbosity, please. */ 919 jobsRunning = FALSE; 920 921 jobLimit = DEFMAXJOBS; 922 compatMake = FALSE; /* No compat mode */ 923 924 check_make_level(); 925 926#ifdef RLIMIT_NOFILE 927 /* 928 * get rid of resource limit on file descriptors 929 */ 930 { 931 struct rlimit rl; 932 if (getrlimit(RLIMIT_NOFILE, &rl) == -1) { 933 err(2, "getrlimit"); 934 } 935 rl.rlim_cur = rl.rlim_max; 936 if (setrlimit(RLIMIT_NOFILE, &rl) == -1) { 937 err(2, "setrlimit"); 938 } 939 } 940#endif 941 942 /* 943 * Prior to 7.0, FreeBSD/pc98 kernel used to set the 944 * utsname.machine to "i386", and MACHINE was defined as 945 * "i386", so it could not be distinguished from FreeBSD/i386. 946 * Therefore, we had to check machine.ispc98 and adjust the 947 * MACHINE variable. NOTE: The code is still here to be able 948 * to compile new make binary on old FreeBSD/pc98 systems, and 949 * have the MACHINE variable set properly. 950 */ 951 if ((machine = getenv("MACHINE")) == NULL) { 952 int ispc98; 953 size_t len; 954 955 len = sizeof(ispc98); 956 if (!sysctlbyname("machdep.ispc98", &ispc98, &len, NULL, 0)) { 957 if (ispc98) 958 machine = "pc98"; 959 } 960 } 961 962 /* 963 * Get the name of this type of MACHINE from utsname 964 * so we can share an executable for similar machines. 965 * (i.e. m68k: amiga hp300, mac68k, sun3, ...) 966 * 967 * Note that both MACHINE and MACHINE_ARCH are decided at 968 * run-time. 969 */ 970 if (machine == NULL) { 971 static struct utsname utsname; 972 973 if (uname(&utsname) == -1) 974 err(2, "uname"); 975 machine = utsname.machine; 976 } 977 978 if ((machine_arch = getenv("MACHINE_ARCH")) == NULL) { 979#ifdef MACHINE_ARCH 980 machine_arch = MACHINE_ARCH; 981#else 982 machine_arch = "unknown"; 983#endif 984 } 985 986 /* 987 * Set machine_cpu to the minumum supported CPU revision based 988 * on the target architecture, if not already set. 989 */ 990 if ((machine_cpu = getenv("MACHINE_CPU")) == NULL) { 991 if (!strcmp(machine_arch, "i386")) 992 machine_cpu = "i386"; 993 else if (!strcmp(machine_arch, "alpha")) 994 machine_cpu = "ev4"; 995 else 996 machine_cpu = "unknown"; 997 } 998 999 /* 1000 * Initialize the parsing, directory and variable modules to prepare 1001 * for the reading of inclusion paths and variable settings on the 1002 * command line 1003 */ 1004 Proc_Init(); 1005 1006 Dir_Init(); /* Initialize directory structures so -I flags 1007 * can be processed correctly */ 1008 Var_Init(environ); /* As well as the lists of variables for 1009 * parsing arguments */ 1010 1011 /* 1012 * Initialize the Shell so that we have a shell for != assignments 1013 * on the command line. 1014 */ 1015 Shell_Init(); 1016 1017 /* 1018 * Initialize various variables. 1019 * MAKE also gets this name, for compatibility 1020 * .MAKEFLAGS gets set to the empty string just in case. 1021 * MFLAGS also gets initialized empty, for compatibility. 1022 */ 1023 Var_SetGlobal("MAKE", argv[0]); 1024 Var_SetGlobal(".MAKEFLAGS", ""); 1025 Var_SetGlobal("MFLAGS", ""); 1026 Var_SetGlobal("MACHINE", machine); 1027 Var_SetGlobal("MACHINE_ARCH", machine_arch); 1028 Var_SetGlobal("MACHINE_CPU", machine_cpu); 1029#ifdef MAKE_VERSION 1030 Var_SetGlobal("MAKE_VERSION", MAKE_VERSION); 1031#endif 1032 1033 /* 1034 * First snag things out of the MAKEFLAGS environment 1035 * variable. Then parse the command line arguments. 1036 */ 1037 Main_ParseArgLine(getenv("MAKEFLAGS"), 1); 1038 1039 MainParseArgs(argc, argv); 1040 1041 /* 1042 * Find where we are... 1043 */ 1044 if (getcwd(curdir, MAXPATHLEN) == NULL) 1045 err(2, NULL); 1046 1047 { 1048 struct stat sa; 1049 1050 if (stat(curdir, &sa) == -1) 1051 err(2, "%s", curdir); 1052 } 1053 1054 /* 1055 * The object directory location is determined using the 1056 * following order of preference: 1057 * 1058 * 1. MAKEOBJDIRPREFIX`cwd` 1059 * 2. MAKEOBJDIR 1060 * 3. PATH_OBJDIR.${MACHINE} 1061 * 4. PATH_OBJDIR 1062 * 5. PATH_OBJDIRPREFIX`cwd` 1063 * 1064 * If one of the first two fails, use the current directory. 1065 * If the remaining three all fail, use the current directory. 1066 * 1067 * Once things are initted, 1068 * have to add the original directory to the search path, 1069 * and modify the paths for the Makefiles apropriately. The 1070 * current directory is also placed as a variable for make scripts. 1071 */ 1072 if (!(pathp = getenv("MAKEOBJDIRPREFIX"))) { 1073 if (!(path = getenv("MAKEOBJDIR"))) { 1074 path = PATH_OBJDIR; 1075 pathp = PATH_OBJDIRPREFIX; 1076 snprintf(mdpath, MAXPATHLEN, "%s.%s", path, machine); 1077 if (!(objdir = chdir_verify_path(mdpath, obpath))) 1078 if (!(objdir=chdir_verify_path(path, obpath))) { 1079 snprintf(mdpath, MAXPATHLEN, 1080 "%s%s", pathp, curdir); 1081 if (!(objdir=chdir_verify_path(mdpath, 1082 obpath))) 1083 objdir = curdir; 1084 } 1085 } 1086 else if (!(objdir = chdir_verify_path(path, obpath))) 1087 objdir = curdir; 1088 } 1089 else { 1090 snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir); 1091 if (!(objdir = chdir_verify_path(mdpath, obpath))) 1092 objdir = curdir; 1093 } 1094 Dir_InitDot(); /* Initialize the "." directory */ 1095 if (objdir != curdir) 1096 Path_AddDir(&dirSearchPath, curdir); 1097 Var_SetGlobal(".ST_EXPORTVAR", "YES"); 1098 Var_SetGlobal(".CURDIR", curdir); 1099 Var_SetGlobal(".OBJDIR", objdir); 1100 1101 if (getenv("MAKE_JOBS_FIFO") != NULL) 1102 forceJobs = TRUE; 1103 /* 1104 * Be compatible if user did not specify -j and did not explicitly 1105 * turned compatibility on 1106 */ 1107 if (!compatMake && !forceJobs) 1108 compatMake = TRUE; 1109 1110 /* 1111 * Initialize target and suffix modules in preparation for 1112 * parsing the makefile(s) 1113 */ 1114 Targ_Init(); 1115 Suff_Init(); 1116 1117 DEFAULT = NULL; 1118 time(&now); 1119 1120 /* 1121 * Set up the .TARGETS variable to contain the list of targets to be 1122 * created. If none specified, make the variable empty -- the parser 1123 * will fill the thing in with the default or .MAIN target. 1124 */ 1125 if (Lst_IsEmpty(&create)) { 1126 Var_SetGlobal(".TARGETS", ""); 1127 } else { 1128 LstNode *ln; 1129 1130 for (ln = Lst_First(&create); ln != NULL; ln = Lst_Succ(ln)) { 1131 char *name = Lst_Datum(ln); 1132 1133 Var_Append(".TARGETS", name, VAR_GLOBAL); 1134 } 1135 } 1136 1137 1138 /* 1139 * If no user-supplied system path was given (through the -m option) 1140 * add the directories from the DEFSYSPATH (more than one may be given 1141 * as dir1:...:dirn) to the system include path. 1142 */ 1143 if (TAILQ_EMPTY(&sysIncPath)) { 1144 char syspath[] = PATH_DEFSYSPATH; 1145 1146 for (start = syspath; *start != '\0'; start = cp) { 1147 for (cp = start; *cp != '\0' && *cp != ':'; cp++) 1148 continue; 1149 if (*cp == '\0') { 1150 Path_AddDir(&sysIncPath, start); 1151 } else { 1152 *cp++ = '\0'; 1153 Path_AddDir(&sysIncPath, start); 1154 } 1155 } 1156 } 1157 1158 /* 1159 * Read in the built-in rules first, followed by the specified 1160 * makefile, if it was (makefile != (char *) NULL), or the default 1161 * Makefile and makefile, in that order, if it wasn't. 1162 */ 1163 if (!noBuiltins) { 1164 /* Path of sys.mk */ 1165 Lst sysMkPath = Lst_Initializer(sysMkPath); 1166 LstNode *ln; 1167 char defsysmk[] = PATH_DEFSYSMK; 1168 1169 Path_Expand(defsysmk, &sysIncPath, &sysMkPath); 1170 if (Lst_IsEmpty(&sysMkPath)) 1171 Fatal("make: no system rules (%s).", PATH_DEFSYSMK); 1172 LST_FOREACH(ln, &sysMkPath) { 1173 if (!ReadMakefile(Lst_Datum(ln))) 1174 break; 1175 } 1176 if (ln != NULL) 1177 Fatal("make: cannot open %s.", (char *)Lst_Datum(ln)); 1178 Lst_Destroy(&sysMkPath, free); 1179 } 1180 1181 if (!Lst_IsEmpty(&makefiles)) { 1182 LstNode *ln; 1183 1184 LST_FOREACH(ln, &makefiles) { 1185 if (!TryReadMakefile(Lst_Datum(ln))) 1186 break; 1187 } 1188 if (ln != NULL) 1189 Fatal("make: cannot open %s.", (char *)Lst_Datum(ln)); 1190 } else if (!TryReadMakefile("BSDmakefile")) 1191 if (!TryReadMakefile("makefile")) 1192 TryReadMakefile("Makefile"); 1193 1194 ReadMakefile(".depend"); 1195 1196 /* Install all the flags into the MAKEFLAGS envariable. */ 1197 if (((p = Var_Value(".MAKEFLAGS", VAR_GLOBAL)) != NULL) && *p) 1198 setenv("MAKEFLAGS", p, 1); 1199 else 1200 setenv("MAKEFLAGS", "", 1); 1201 1202 /* 1203 * For compatibility, look at the directories in the VPATH variable 1204 * and add them to the search path, if the variable is defined. The 1205 * variable's value is in the same format as the PATH envariable, i.e. 1206 * <directory>:<directory>:<directory>... 1207 */ 1208 if (Var_Exists("VPATH", VAR_CMD)) { 1209 /* 1210 * GCC stores string constants in read-only memory, but 1211 * Var_Subst will want to write this thing, so store it 1212 * in an array 1213 */ 1214 static char VPATH[] = "${VPATH}"; 1215 Buffer *buf; 1216 char *vpath; 1217 char *ptr; 1218 char savec; 1219 1220 buf = Var_Subst(VPATH, VAR_CMD, FALSE); 1221 1222 vpath = Buf_Data(buf); 1223 do { 1224 /* skip to end of directory */ 1225 for (ptr = vpath; *ptr != ':' && *ptr != '\0'; ptr++) 1226 ; 1227 1228 /* Save terminator character so know when to stop */ 1229 savec = *ptr; 1230 *ptr = '\0'; 1231 1232 /* Add directory to search path */ 1233 Path_AddDir(&dirSearchPath, vpath); 1234 1235 vpath = ptr + 1; 1236 } while (savec != '\0'); 1237 1238 Buf_Destroy(buf, TRUE); 1239 } 1240 1241 /* 1242 * Now that all search paths have been read for suffixes et al, it's 1243 * time to add the default search path to their lists... 1244 */ 1245 Suff_DoPaths(); 1246 1247 /* print the initial graph, if the user requested it */ 1248 if (DEBUG(GRAPH1)) 1249 Targ_PrintGraph(1); 1250 1251 /* print the values of any variables requested by the user */ 1252 if (Lst_IsEmpty(&variables) && !printGraphOnly) { 1253 /* 1254 * Since the user has not requested that any variables 1255 * be printed, we can build targets. 1256 * 1257 * Have read the entire graph and need to make a list of targets 1258 * to create. If none was given on the command line, we consult 1259 * the parsing module to find the main target(s) to create. 1260 */ 1261 Lst targs = Lst_Initializer(targs); 1262 1263 if (!is_posix && mfAutoDeps) { 1264 /* 1265 * Check if any of the makefiles are out-of-date. 1266 */ 1267 Remake_Makefiles(); 1268 } 1269 1270 if (Lst_IsEmpty(&create)) 1271 Parse_MainName(&targs); 1272 else 1273 Targ_FindList(&targs, &create, TARG_CREATE); 1274 1275 if (compatMake) { 1276 /* 1277 * Compat_Init will take care of creating 1278 * all the targets as well as initializing 1279 * the module. 1280 */ 1281 Compat_Run(&targs); 1282 outOfDate = 0; 1283 } else { 1284 /* 1285 * Initialize job module before traversing 1286 * the graph, now that any .BEGIN and .END 1287 * targets have been read. This is done 1288 * only if the -q flag wasn't given (to 1289 * prevent the .BEGIN from being executed 1290 * should it exist). 1291 */ 1292 if (!queryFlag) { 1293 Job_Init(jobLimit); 1294 jobsRunning = TRUE; 1295 } 1296 1297 /* Traverse the graph, checking on all the targets */ 1298 outOfDate = Make_Run(&targs); 1299 } 1300 Lst_Destroy(&targs, NOFREE); 1301 1302 } else { 1303 Var_Print(&variables, expandVars); 1304 } 1305 1306 Lst_Destroy(&variables, free); 1307 Lst_Destroy(&makefiles, free); 1308 Lst_Destroy(&source_makefiles, free); 1309 Lst_Destroy(&create, free); 1310 1311 /* print the graph now it's been processed if the user requested it */ 1312 if (DEBUG(GRAPH2)) 1313 Targ_PrintGraph(2); 1314 1315 if (queryFlag) 1316 return (outOfDate); 1317 1318 if (makeErrors != 0) 1319 Finish(makeErrors); 1320 1321 return (0); 1322} 1323