![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. ! 3: * Copyright (c) 1988, 1989 by Adam de Boor ! 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 are permitted provided ! 11: * that: (1) source distributions retain this entire copyright notice and ! 12: * comment, and (2) distributions including binaries display the following ! 13: * acknowledgement: ``This product includes software developed by the ! 14: * University of California, Berkeley and its contributors'' in the ! 15: * documentation or other materials provided with the distribution and in ! 16: * all advertising materials mentioning features or use of this software. ! 17: * Neither the name of the University nor the names of its contributors may ! 18: * be used to endorse or promote products derived from this software without ! 19: * specific prior written permission. ! 20: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 21: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 22: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 23: */ ! 24: ! 25: #ifndef lint ! 26: char copyright[] = ! 27: "@(#) Copyright (c) 1989 The Regents of the University of California.\n\ ! 28: All rights reserved.\n"; ! 29: #endif /* not lint */ ! 30: ! 31: #ifndef lint ! 32: static char sccsid[] = "@(#)main.c 5.22 (Berkeley) 6/28/90"; ! 33: #endif /* not lint */ ! 34: ! 35: /*- ! 36: * main.c -- ! 37: * The main file for this entire program. Exit routines etc ! 38: * reside here. ! 39: * ! 40: * Utility functions defined in this file: ! 41: * Main_ParseArgLine Takes a line of arguments, breaks them and ! 42: * treats them as if they were given when first ! 43: * invoked. Used by the parse module to implement ! 44: * the .MFLAGS target. ! 45: * ! 46: * Error Print a tagged error message. The global ! 47: * MAKE variable must have been defined. This ! 48: * takes a format string and two optional ! 49: * arguments for it. ! 50: * ! 51: * Fatal Print an error message and exit. Also takes ! 52: * a format string and two arguments. ! 53: * ! 54: * Punt Aborts all jobs and exits with a message. Also ! 55: * takes a format string and two arguments. ! 56: * ! 57: * Finish Finish things up by printing the number of ! 58: * errors which occured, as passed to it, and ! 59: * exiting. ! 60: */ ! 61: ! 62: #include <sys/param.h> ! 63: #include <sys/signal.h> ! 64: #include <sys/stat.h> ! 65: #include <fcntl.h> ! 66: #include <stdio.h> ! 67: #include <varargs.h> ! 68: #include "make.h" ! 69: #include "pathnames.h" ! 70: ! 71: #ifndef DEFMAXLOCAL ! 72: #define DEFMAXLOCAL DEFMAXJOBS ! 73: #endif DEFMAXLOCAL ! 74: ! 75: #define MAKEFLAGS ".MAKEFLAGS" ! 76: ! 77: Lst create; /* Targets to be made */ ! 78: time_t now; /* Time at start of make */ ! 79: GNode *DEFAULT; /* .DEFAULT node */ ! 80: Boolean allPrecious; /* .PRECIOUS given on line by itself */ ! 81: ! 82: static Boolean noBuiltins; /* -r flag */ ! 83: static Lst makefiles; /* ordered list of makefiles to read */ ! 84: int maxJobs; /* -J argument */ ! 85: static int maxLocal; /* -L argument */ ! 86: Boolean debug; /* -d flag */ ! 87: Boolean noExecute; /* -n flag */ ! 88: Boolean keepgoing; /* -k flag */ ! 89: Boolean queryFlag; /* -q flag */ ! 90: Boolean touchFlag; /* -t flag */ ! 91: Boolean usePipes; /* !-P flag */ ! 92: Boolean ignoreErrors; /* -i flag */ ! 93: Boolean beSilent; /* -s flag */ ! 94: Boolean oldVars; /* variable substitution style */ ! 95: Boolean checkEnvFirst; /* -e flag */ ! 96: static Boolean jobsRunning; /* TRUE if the jobs might be running */ ! 97: ! 98: static Boolean ReadMakefile(); ! 99: ! 100: static char *curdir; /* if chdir'd for an architecture */ ! 101: ! 102: /*- ! 103: * MainParseArgs -- ! 104: * Parse a given argument vector. Called from main() and from ! 105: * Main_ParseArgLine() when the .MAKEFLAGS target is used. ! 106: * ! 107: * XXX: Deal with command line overriding .MAKEFLAGS in makefile ! 108: * ! 109: * Results: ! 110: * None ! 111: * ! 112: * Side Effects: ! 113: * Various global and local flags will be set depending on the flags ! 114: * given ! 115: */ ! 116: static void ! 117: MainParseArgs(argc, argv) ! 118: int argc; ! 119: char **argv; ! 120: { ! 121: extern int optind; ! 122: extern char *optarg; ! 123: register int i; ! 124: register char *cp; ! 125: char c; ! 126: ! 127: optind = 1; /* since we're called more than once */ ! 128: rearg: while((c = getopt(argc, argv, "D:I:d:ef:ij:knqrst")) != -1) { ! 129: switch(c) { ! 130: case 'D': ! 131: Var_Set(optarg, "1", VAR_GLOBAL); ! 132: Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL); ! 133: Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL); ! 134: break; ! 135: case 'I': ! 136: Parse_AddIncludeDir(optarg); ! 137: Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL); ! 138: Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL); ! 139: break; ! 140: #ifdef notdef ! 141: case 'L': ! 142: maxLocal = atoi(optarg); ! 143: Var_Append(MAKEFLAGS, "-L", VAR_GLOBAL); ! 144: Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL); ! 145: break; ! 146: case 'P': ! 147: usePipes = FALSE; ! 148: Var_Append(MAKEFLAGS, "-P", VAR_GLOBAL); ! 149: break; ! 150: case 'S': ! 151: keepgoing = FALSE; ! 152: Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL); ! 153: break; ! 154: #endif ! 155: case 'd': { ! 156: char *modules = optarg; ! 157: ! 158: for (; *modules; ++modules) ! 159: switch (*modules) { ! 160: case 'A': ! 161: debug = ~0; ! 162: break; ! 163: case 'a': ! 164: debug |= DEBUG_ARCH; ! 165: break; ! 166: case 'c': ! 167: debug |= DEBUG_COND; ! 168: break; ! 169: case 'd': ! 170: debug |= DEBUG_DIR; ! 171: break; ! 172: case 'g': ! 173: if (modules[1] == '1') { ! 174: debug |= DEBUG_GRAPH1; ! 175: ++modules; ! 176: } ! 177: else if (modules[1] == '2') { ! 178: debug |= DEBUG_GRAPH2; ! 179: ++modules; ! 180: } ! 181: break; ! 182: case 'j': ! 183: debug |= DEBUG_JOB; ! 184: break; ! 185: case 'm': ! 186: debug |= DEBUG_MAKE; ! 187: break; ! 188: case 's': ! 189: debug |= DEBUG_SUFF; ! 190: break; ! 191: case 't': ! 192: debug |= DEBUG_TARG; ! 193: break; ! 194: case 'v': ! 195: debug |= DEBUG_VAR; ! 196: break; ! 197: } ! 198: Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL); ! 199: Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL); ! 200: break; ! 201: } ! 202: case 'e': ! 203: checkEnvFirst = TRUE; ! 204: Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL); ! 205: break; ! 206: case 'f': ! 207: (void)Lst_AtEnd(makefiles, (ClientData)optarg); ! 208: break; ! 209: case 'i': ! 210: ignoreErrors = TRUE; ! 211: Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL); ! 212: break; ! 213: case 'j': ! 214: maxJobs = atoi(optarg); ! 215: Var_Append(MAKEFLAGS, "-J", VAR_GLOBAL); ! 216: Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL); ! 217: break; ! 218: case 'k': ! 219: keepgoing = TRUE; ! 220: Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL); ! 221: break; ! 222: case 'n': ! 223: noExecute = TRUE; ! 224: Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL); ! 225: break; ! 226: case 'q': ! 227: queryFlag = TRUE; ! 228: /* Kind of nonsensical, wot? */ ! 229: Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL); ! 230: break; ! 231: case 'r': ! 232: noBuiltins = TRUE; ! 233: Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL); ! 234: break; ! 235: case 's': ! 236: beSilent = TRUE; ! 237: Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL); ! 238: break; ! 239: case 't': ! 240: touchFlag = TRUE; ! 241: Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL); ! 242: break; ! 243: default: ! 244: case '?': ! 245: usage(); ! 246: } ! 247: } ! 248: ! 249: oldVars = TRUE; ! 250: ! 251: /* ! 252: * See if the rest of the arguments are variable assignments and ! 253: * perform them if so. Else take them to be targets and stuff them ! 254: * on the end of the "create" list. ! 255: */ ! 256: for (argv += optind, argc -= optind; *argv; ++argv, --argc) ! 257: if (Parse_IsVar(*argv)) ! 258: Parse_DoVar(*argv, VAR_CMD); ! 259: else { ! 260: if (!**argv) ! 261: Punt("illegal (null) argument."); ! 262: if (**argv == '-') { ! 263: optind = 0; ! 264: goto rearg; ! 265: } ! 266: (void)Lst_AtEnd(create, (ClientData)*argv); ! 267: } ! 268: } ! 269: ! 270: /*- ! 271: * Main_ParseArgLine -- ! 272: * Used by the parse module when a .MFLAGS or .MAKEFLAGS target ! 273: * is encountered and by main() when reading the .MAKEFLAGS envariable. ! 274: * Takes a line of arguments and breaks it into its ! 275: * component words and passes those words and the number of them to the ! 276: * MainParseArgs function. ! 277: * The line should have all its leading whitespace removed. ! 278: * ! 279: * Results: ! 280: * None ! 281: * ! 282: * Side Effects: ! 283: * Only those that come from the various arguments. ! 284: */ ! 285: void ! 286: Main_ParseArgLine(line) ! 287: char *line; /* Line to fracture */ ! 288: { ! 289: char **argv; /* Manufactured argument vector */ ! 290: int argc; /* Number of arguments in argv */ ! 291: ! 292: if (line == NULL) ! 293: return; ! 294: for (; *line == ' '; ++line); ! 295: if (!*line) ! 296: return; ! 297: ! 298: argv = brk_string(line, &argc); ! 299: MainParseArgs(argc, argv); ! 300: } ! 301: ! 302: /*- ! 303: * main -- ! 304: * The main function, for obvious reasons. Initializes variables ! 305: * and a few modules, then parses the arguments give it in the ! 306: * environment and on the command line. Reads the system makefile ! 307: * followed by either Makefile, makefile or the file given by the ! 308: * -f argument. Sets the .MAKEFLAGS PMake variable based on all the ! 309: * flags it has received by then uses either the Make or the Compat ! 310: * module to create the initial list of targets. ! 311: * ! 312: * Results: ! 313: * If -q was given, exits -1 if anything was out-of-date. Else it exits ! 314: * 0. ! 315: * ! 316: * Side Effects: ! 317: * The program exits when done. Targets are created. etc. etc. etc. ! 318: */ ! 319: main(argc, argv) ! 320: int argc; ! 321: char **argv; ! 322: { ! 323: Lst targs; /* target nodes to create -- passed to Make_Init */ ! 324: Boolean outOfDate; /* FALSE if all targets up to date */ ! 325: struct stat sb; ! 326: char *p, *path, *getenv(); ! 327: ! 328: /* ! 329: * if the MAKEOBJDIR (or by default, the _PATH_OBJDIR) directory ! 330: * exists, change into it and build there. Once things are ! 331: * initted, have to add the original directory to the search path, ! 332: * and modify the paths for the Makefiles apropriately. The ! 333: * current directory is also placed as a variable for make scripts. ! 334: */ ! 335: if (!(path = getenv("MAKEOBJDIR"))) ! 336: path = _PATH_OBJDIR; ! 337: if (!lstat(path, &sb)) { ! 338: if (S_ISDIR(sb.st_mode)) ! 339: curdir = ".."; ! 340: else { ! 341: curdir = emalloc((u_int)MAXPATHLEN + 1); ! 342: if (!getwd(curdir)) { ! 343: (void)fprintf(stderr, "make: %s.\n", curdir); ! 344: exit(2); ! 345: } ! 346: } ! 347: if (chdir(path)) { ! 348: extern int errno; ! 349: ! 350: (void)fprintf(stderr, "make: %s: %s.\n", ! 351: path, strerror(errno)); ! 352: exit(2); ! 353: } ! 354: } ! 355: ! 356: create = Lst_Init(FALSE); ! 357: makefiles = Lst_Init(FALSE); ! 358: beSilent = FALSE; /* Print commands as executed */ ! 359: ignoreErrors = FALSE; /* Pay attention to non-zero returns */ ! 360: noExecute = FALSE; /* Execute all commands */ ! 361: keepgoing = FALSE; /* Stop on error */ ! 362: allPrecious = FALSE; /* Remove targets when interrupted */ ! 363: queryFlag = FALSE; /* This is not just a check-run */ ! 364: noBuiltins = FALSE; /* Read the built-in rules */ ! 365: touchFlag = FALSE; /* Actually update targets */ ! 366: usePipes = TRUE; /* Catch child output in pipes */ ! 367: debug = 0; /* No debug verbosity, please. */ ! 368: jobsRunning = FALSE; ! 369: ! 370: maxJobs = DEFMAXJOBS; /* Set default max concurrency */ ! 371: maxLocal = DEFMAXLOCAL; /* Set default local max concurrency */ ! 372: ! 373: /* ! 374: * Initialize the parsing, directory and variable modules to prepare ! 375: * for the reading of inclusion paths and variable settings on the ! 376: * command line ! 377: */ ! 378: Dir_Init(); /* Initialize directory structures so -I flags ! 379: * can be processed correctly */ ! 380: Parse_Init(); /* Need to initialize the paths of #include ! 381: * directories */ ! 382: Var_Init(); /* As well as the lists of variables for ! 383: * parsing arguments */ ! 384: ! 385: if (curdir) { ! 386: Dir_AddDir(dirSearchPath, curdir); ! 387: Var_Set(".CURDIR", curdir, VAR_GLOBAL); ! 388: } else ! 389: Var_Set(".CURDIR", ".", VAR_GLOBAL); ! 390: ! 391: /* ! 392: * Initialize various variables. ! 393: * MAKE also gets this name, for compatibility ! 394: * .MAKEFLAGS gets set to the empty string just in case. ! 395: * MFLAGS also gets initialized empty, for compatibility. ! 396: */ ! 397: Var_Set("MAKE", argv[0], VAR_GLOBAL); ! 398: Var_Set(MAKEFLAGS, "", VAR_GLOBAL); ! 399: Var_Set("MFLAGS", "", VAR_GLOBAL); ! 400: Var_Set("MACHINE", MACHINE, VAR_GLOBAL); ! 401: ! 402: /* ! 403: * First snag any flags out of the MAKE environment variable. ! 404: * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's ! 405: * in a different format). ! 406: */ ! 407: #ifdef POSIX ! 408: Main_ParseArgLine(getenv("MAKEFLAGS")); ! 409: #else ! 410: Main_ParseArgLine(getenv("MAKE")); ! 411: #endif ! 412: ! 413: MainParseArgs(argc, argv); ! 414: ! 415: /* ! 416: * Initialize archive, target and suffix modules in preparation for ! 417: * parsing the makefile(s) ! 418: */ ! 419: Arch_Init(); ! 420: Targ_Init(); ! 421: Suff_Init(); ! 422: ! 423: DEFAULT = NILGNODE; ! 424: (void)time(&now); ! 425: ! 426: /* ! 427: * Set up the .TARGETS variable to contain the list of targets to be ! 428: * created. If none specified, make the variable empty -- the parser ! 429: * will fill the thing in with the default or .MAIN target. ! 430: */ ! 431: if (!Lst_IsEmpty(create)) { ! 432: LstNode ln; ! 433: ! 434: for (ln = Lst_First(create); ln != NILLNODE; ! 435: ln = Lst_Succ(ln)) { ! 436: char *name = (char *)Lst_Datum(ln); ! 437: ! 438: Var_Append(".TARGETS", name, VAR_GLOBAL); ! 439: } ! 440: } else ! 441: Var_Set(".TARGETS", "", VAR_GLOBAL); ! 442: ! 443: /* ! 444: * Read in the built-in rules first, followed by the specified makefile, ! 445: * if it was (makefile != (char *) NULL), or the default Makefile and ! 446: * makefile, in that order, if it wasn't. ! 447: */ ! 448: if (!noBuiltins && !ReadMakefile(_PATH_DEFSYSMK)) ! 449: Fatal("make: no system rules (%s).", _PATH_DEFSYSMK); ! 450: ! 451: if (!Lst_IsEmpty(makefiles)) { ! 452: LstNode ln; ! 453: ! 454: ln = Lst_Find(makefiles, (ClientData)NULL, ReadMakefile); ! 455: if (ln != NILLNODE) ! 456: Fatal("make: cannot open %s.", (char *)Lst_Datum(ln)); ! 457: } else if (!ReadMakefile("makefile")) ! 458: (void)ReadMakefile("Makefile"); ! 459: ! 460: (void)ReadMakefile(".depend"); ! 461: ! 462: Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL), VAR_GLOBAL); ! 463: ! 464: /* Install all the flags into the MAKE envariable. */ ! 465: if ((p = Var_Value(MAKEFLAGS, VAR_GLOBAL)) && *p) ! 466: #ifdef POSIX ! 467: setenv("MAKEFLAGS", p, 1); ! 468: #else ! 469: setenv("MAKE", p, 1); ! 470: #endif ! 471: ! 472: /* ! 473: * For compatibility, look at the directories in the VPATH variable ! 474: * and add them to the search path, if the variable is defined. The ! 475: * variable's value is in the same format as the PATH envariable, i.e. ! 476: * <directory>:<directory>:<directory>... ! 477: */ ! 478: if (Var_Exists("VPATH", VAR_CMD)) { ! 479: char *vpath, *path, *cp, savec; ! 480: /* ! 481: * GCC stores string constants in read-only memory, but ! 482: * Var_Subst will want to write this thing, so store it ! 483: * in an array ! 484: */ ! 485: static char VPATH[] = "${VPATH}"; ! 486: ! 487: vpath = Var_Subst(VPATH, VAR_CMD, FALSE); ! 488: path = vpath; ! 489: do { ! 490: /* skip to end of directory */ ! 491: for (cp = path; *cp != ':' && *cp != '\0'; cp++); ! 492: /* Save terminator character so know when to stop */ ! 493: savec = *cp; ! 494: *cp = '\0'; ! 495: /* Add directory to search path */ ! 496: Dir_AddDir(dirSearchPath, path); ! 497: *cp = savec; ! 498: path = cp + 1; ! 499: } while (savec == ':'); ! 500: (void)free((Address)vpath); ! 501: } ! 502: ! 503: /* ! 504: * Now that all search paths have been read for suffixes et al, it's ! 505: * time to add the default search path to their lists... ! 506: */ ! 507: Suff_DoPaths(); ! 508: ! 509: /* print the initial graph, if the user requested it */ ! 510: if (DEBUG(GRAPH1)) ! 511: Targ_PrintGraph(1); ! 512: ! 513: /* ! 514: * Have now read the entire graph and need to make a list of targets ! 515: * to create. If none was given on the command line, we consult the ! 516: * parsing module to find the main target(s) to create. ! 517: */ ! 518: if (Lst_IsEmpty(create)) ! 519: targs = Parse_MainName(); ! 520: else ! 521: targs = Targ_FindList(create, TARG_CREATE); ! 522: ! 523: /* ! 524: * this was original amMake -- want to allow parallelism, so put this ! 525: * back in, eventually. ! 526: */ ! 527: if (0) { ! 528: /* ! 529: * Initialize job module before traversing the graph, now that ! 530: * any .BEGIN and .END targets have been read. This is done ! 531: * only if the -q flag wasn't given (to prevent the .BEGIN from ! 532: * being executed should it exist). ! 533: */ ! 534: if (!queryFlag) { ! 535: if (maxLocal == -1) ! 536: maxLocal = maxJobs; ! 537: Job_Init(maxJobs, maxLocal); ! 538: jobsRunning = TRUE; ! 539: } ! 540: ! 541: /* Traverse the graph, checking on all the targets */ ! 542: outOfDate = Make_Run(targs); ! 543: } else ! 544: /* ! 545: * Compat_Init will take care of creating all the targets as ! 546: * well as initializing the module. ! 547: */ ! 548: Compat_Run(targs); ! 549: ! 550: /* print the graph now it's been processed if the user requested it */ ! 551: if (DEBUG(GRAPH2)) ! 552: Targ_PrintGraph(2); ! 553: ! 554: if (queryFlag && outOfDate) ! 555: exit(1); ! 556: else ! 557: exit(0); ! 558: } ! 559: ! 560: /*- ! 561: * ReadMakefile -- ! 562: * Open and parse the given makefile. ! 563: * ! 564: * Results: ! 565: * TRUE if ok. FALSE if couldn't open file. ! 566: * ! 567: * Side Effects: ! 568: * lots ! 569: */ ! 570: static Boolean ! 571: ReadMakefile(fname) ! 572: char *fname; /* makefile to read */ ! 573: { ! 574: extern Lst parseIncPath, sysIncPath; ! 575: FILE *stream; ! 576: char *name, path[MAXPATHLEN + 1]; ! 577: ! 578: if (!strcmp(fname, "-")) { ! 579: Parse_File("(stdin)", stdin); ! 580: Var_Set("MAKEFILE", "", VAR_GLOBAL); ! 581: } else { ! 582: if (stream = fopen(fname, "r")) ! 583: goto found; ! 584: /* if we've chdir'd, rebuild the path name */ ! 585: if (curdir && *fname != '/') { ! 586: (void)sprintf(path, "%s/%s", curdir, fname); ! 587: if (stream = fopen(path, "r")) { ! 588: fname = path; ! 589: goto found; ! 590: } ! 591: } ! 592: /* look in -I and system include directories. */ ! 593: name = Dir_FindFile(fname, parseIncPath); ! 594: if (!name) ! 595: name = Dir_FindFile(fname, sysIncPath); ! 596: if (!name || !(stream = fopen(name, "r"))) ! 597: return(FALSE); ! 598: fname = name; ! 599: /* ! 600: * set the MAKEFILE variable desired by System V fans -- the ! 601: * placement of the setting here means it gets set to the last ! 602: * makefile specified, as it is set by SysV make. ! 603: */ ! 604: found: Var_Set("MAKEFILE", fname, VAR_GLOBAL); ! 605: Parse_File(fname, stream); ! 606: (void)fclose(stream); ! 607: } ! 608: return(TRUE); ! 609: } ! 610: ! 611: /*- ! 612: * Error -- ! 613: * Print an error message given its format. ! 614: * ! 615: * Results: ! 616: * None. ! 617: * ! 618: * Side Effects: ! 619: * The message is printed. ! 620: */ ! 621: /* VARARGS */ ! 622: void ! 623: Error(va_alist) ! 624: va_dcl ! 625: { ! 626: va_list ap; ! 627: char *fmt; ! 628: ! 629: va_start(ap); ! 630: fmt = va_arg(ap, char *); ! 631: (void)vfprintf(stderr, fmt, ap); ! 632: va_end(ap); ! 633: (void)fprintf(stderr, "\n"); ! 634: (void)fflush(stderr); ! 635: } ! 636: ! 637: /*- ! 638: * Fatal -- ! 639: * Produce a Fatal error message. If jobs are running, waits for them ! 640: * to finish. ! 641: * ! 642: * Results: ! 643: * None ! 644: * ! 645: * Side Effects: ! 646: * The program exits ! 647: */ ! 648: /* VARARGS */ ! 649: void ! 650: Fatal(va_alist) ! 651: va_dcl ! 652: { ! 653: va_list ap; ! 654: char *fmt; ! 655: ! 656: if (jobsRunning) ! 657: Job_Wait(); ! 658: ! 659: va_start(ap); ! 660: fmt = va_arg(ap, char *); ! 661: (void)vfprintf(stderr, fmt, ap); ! 662: va_end(ap); ! 663: (void)fprintf(stderr, "\n"); ! 664: (void)fflush(stderr); ! 665: ! 666: if (DEBUG(GRAPH2)) ! 667: Targ_PrintGraph(2); ! 668: exit(2); /* Not 1 so -q can distinguish error */ ! 669: } ! 670: ! 671: /* ! 672: * Punt -- ! 673: * Major exception once jobs are being created. Kills all jobs, prints ! 674: * a message and exits. ! 675: * ! 676: * Results: ! 677: * None ! 678: * ! 679: * Side Effects: ! 680: * All children are killed indiscriminately and the program Lib_Exits ! 681: */ ! 682: /* VARARGS */ ! 683: void ! 684: Punt(va_alist) ! 685: va_dcl ! 686: { ! 687: va_list ap; ! 688: char *fmt; ! 689: ! 690: (void)fprintf(stderr, "make: "); ! 691: va_start(ap); ! 692: fmt = va_arg(ap, char *); ! 693: (void)vfprintf(stderr, fmt, ap); ! 694: va_end(ap); ! 695: (void)fprintf(stderr, "\n"); ! 696: (void)fflush(stderr); ! 697: ! 698: DieHorribly(); ! 699: } ! 700: ! 701: /*- ! 702: * DieHorribly -- ! 703: * Exit without giving a message. ! 704: * ! 705: * Results: ! 706: * None ! 707: * ! 708: * Side Effects: ! 709: * A big one... ! 710: */ ! 711: void ! 712: DieHorribly() ! 713: { ! 714: if (jobsRunning) ! 715: Job_AbortAll(); ! 716: if (DEBUG(GRAPH2)) ! 717: Targ_PrintGraph(2); ! 718: exit(2); /* Not 1, so -q can distinguish error */ ! 719: } ! 720: ! 721: /* ! 722: * Finish -- ! 723: * Called when aborting due to errors in child shell to signal ! 724: * abnormal exit. ! 725: * ! 726: * Results: ! 727: * None ! 728: * ! 729: * Side Effects: ! 730: * The program exits ! 731: */ ! 732: void ! 733: Finish(errors) ! 734: int errors; /* number of errors encountered in Make_Make */ ! 735: { ! 736: Fatal("%d error%s", errors, errors == 1 ? "" : "s"); ! 737: } ! 738: ! 739: /* ! 740: * emalloc -- ! 741: * malloc, but die on error. ! 742: */ ! 743: char * ! 744: emalloc(len) ! 745: u_int len; ! 746: { ! 747: extern int errno; ! 748: char *p, *malloc(); ! 749: ! 750: if (!(p = malloc(len))) ! 751: enomem(); ! 752: return(p); ! 753: } ! 754: ! 755: /* ! 756: * enomem -- ! 757: * die when out of memory. ! 758: */ ! 759: enomem() ! 760: { ! 761: (void)fprintf(stderr, "make: %s.\n", strerror(errno)); ! 762: exit(2); ! 763: } ! 764: ! 765: /* ! 766: * usage -- ! 767: * exit with usage message ! 768: */ ! 769: usage() ! 770: { ! 771: (void)fprintf(stderr, ! 772: "usage: make [-eiknqrst] [-D variable] [-d flags] [-f makefile ]\n\t\ ! 773: [-I directory] [-j max_jobs] [variable=value]\n"); ! 774: exit(2); ! 775: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.