Annotation of src/usr.bin/make/main.c, Revision 1.302
1.302 ! rillig 1: /* $NetBSD: main.c,v 1.301 2020/08/09 09:27:44 rillig Exp $ */
1.19 christos 2:
1.1 cgd 3: /*
1.31 christos 4: * Copyright (c) 1988, 1989, 1990, 1993
5: * The Regents of the University of California. All rights reserved.
1.91 agc 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: /*
1.1 cgd 36: * Copyright (c) 1989 by Berkeley Softworks
37: * All rights reserved.
38: *
39: * This code is derived from software contributed to Berkeley by
40: * Adam de Boor.
41: *
42: * Redistribution and use in source and binary forms, with or without
43: * modification, are permitted provided that the following conditions
44: * are met:
45: * 1. Redistributions of source code must retain the above copyright
46: * notice, this list of conditions and the following disclaimer.
47: * 2. Redistributions in binary form must reproduce the above copyright
48: * notice, this list of conditions and the following disclaimer in the
49: * documentation and/or other materials provided with the distribution.
50: * 3. All advertising materials mentioning features or use of this software
51: * must display the following acknowledgement:
52: * This product includes software developed by the University of
53: * California, Berkeley and its contributors.
54: * 4. Neither the name of the University nor the names of its contributors
55: * may be used to endorse or promote products derived from this software
56: * without specific prior written permission.
57: *
58: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68: * SUCH DAMAGE.
69: */
70:
1.102 ross 71: #ifndef MAKE_NATIVE
1.302 ! rillig 72: static char rcsid[] = "$NetBSD: main.c,v 1.301 2020/08/09 09:27:44 rillig Exp $";
1.38 lukem 73: #else
1.37 christos 74: #include <sys/cdefs.h>
1.1 cgd 75: #ifndef lint
1.150 lukem 76: __COPYRIGHT("@(#) Copyright (c) 1988, 1989, 1990, 1993\
77: The Regents of the University of California. All rights reserved.");
1.1 cgd 78: #endif /* not lint */
79:
80: #ifndef lint
1.19 christos 81: #if 0
1.31 christos 82: static char sccsid[] = "@(#)main.c 8.3 (Berkeley) 3/19/94";
1.19 christos 83: #else
1.302 ! rillig 84: __RCSID("$NetBSD: main.c,v 1.301 2020/08/09 09:27:44 rillig Exp $");
1.19 christos 85: #endif
1.1 cgd 86: #endif /* not lint */
1.38 lukem 87: #endif
1.1 cgd 88:
89: /*-
90: * main.c --
91: * The main file for this entire program. Exit routines etc
92: * reside here.
93: *
94: * Utility functions defined in this file:
95: * Main_ParseArgLine Takes a line of arguments, breaks them and
96: * treats them as if they were given when first
97: * invoked. Used by the parse module to implement
98: * the .MFLAGS target.
99: *
100: * Error Print a tagged error message. The global
101: * MAKE variable must have been defined. This
1.227 gson 102: * takes a format string and optional arguments
103: * for it.
1.1 cgd 104: *
105: * Fatal Print an error message and exit. Also takes
1.227 gson 106: * a format string and arguments for it.
1.1 cgd 107: *
108: * Punt Aborts all jobs and exits with a message. Also
1.227 gson 109: * takes a format string and arguments for it.
1.1 cgd 110: *
111: * Finish Finish things up by printing the number of
1.72 wiz 112: * errors which occurred, as passed to it, and
1.1 cgd 113: * exiting.
114: */
115:
1.13 cgd 116: #include <sys/types.h>
117: #include <sys/time.h>
1.1 cgd 118: #include <sys/param.h>
1.13 cgd 119: #include <sys/resource.h>
1.1 cgd 120: #include <sys/stat.h>
1.225 matt 121: #ifdef MAKE_NATIVE
122: #include <sys/sysctl.h>
123: #endif
1.17 gwr 124: #include <sys/utsname.h>
1.29 christos 125: #include <sys/wait.h>
1.85 wiz 126:
1.302 ! rillig 127: #include <ctype.h>
1.1 cgd 128: #include <errno.h>
1.215 christos 129: #include <signal.h>
1.85 wiz 130: #include <stdarg.h>
1.1 cgd 131: #include <stdio.h>
1.32 christos 132: #include <stdlib.h>
1.42 kleink 133: #include <time.h>
1.85 wiz 134:
1.1 cgd 135: #include "make.h"
1.13 cgd 136: #include "hash.h"
137: #include "dir.h"
138: #include "job.h"
1.1 cgd 139: #include "pathnames.h"
1.58 sommerfe 140: #include "trace.h"
1.1 cgd 141:
1.66 christos 142: #ifdef USE_IOVEC
143: #include <sys/uio.h>
144: #endif
145:
1.1 cgd 146: #ifndef DEFMAXLOCAL
147: #define DEFMAXLOCAL DEFMAXJOBS
1.24 christos 148: #endif /* DEFMAXLOCAL */
1.1 cgd 149:
150: Lst create; /* Targets to be made */
151: time_t now; /* Time at start of make */
152: GNode *DEFAULT; /* .DEFAULT node */
153: Boolean allPrecious; /* .PRECIOUS given on line by itself */
1.251 dholland 154: Boolean deleteOnError; /* .DELETE_ON_ERROR: set */
1.1 cgd 155:
156: static Boolean noBuiltins; /* -r flag */
157: static Lst makefiles; /* ordered list of makefiles to read */
1.272 christos 158: static int printVars; /* -[vV] argument */
159: #define COMPAT_VARS 1
160: #define EXPAND_VARS 2
1.31 christos 161: static Lst variables; /* list of variables to print */
1.21 christos 162: int maxJobs; /* -j argument */
1.132 dsl 163: static int maxJobTokens; /* -j argument */
1.13 cgd 164: Boolean compatMake; /* -B argument */
1.113 christos 165: int debug; /* -d argument */
1.201 sjg 166: Boolean debugVflag; /* -dV */
1.1 cgd 167: Boolean noExecute; /* -n flag */
1.61 sommerfe 168: Boolean noRecursiveExecute; /* -N flag */
1.1 cgd 169: Boolean keepgoing; /* -k flag */
170: Boolean queryFlag; /* -q flag */
171: Boolean touchFlag; /* -t flag */
1.220 christos 172: Boolean enterFlag; /* -w flag */
1.233 sjg 173: Boolean enterFlagObj; /* -w and objdir != srcdir */
1.1 cgd 174: Boolean ignoreErrors; /* -i flag */
175: Boolean beSilent; /* -s flag */
176: Boolean oldVars; /* variable substitution style */
177: Boolean checkEnvFirst; /* -e flag */
1.63 christos 178: Boolean parseWarnFatal; /* -W flag */
1.58 sommerfe 179: Boolean jobServer; /* -J flag */
1.132 dsl 180: static int jp_0 = -1, jp_1 = -1; /* ends of parent job pipe */
1.87 thorpej 181: Boolean varNoExportEnv; /* -X flag */
1.145 dsl 182: Boolean doing_depend; /* Set while reading .depend */
1.1 cgd 183: static Boolean jobsRunning; /* TRUE if the jobs might be running */
1.58 sommerfe 184: static const char * tracefile;
1.149 christos 185: static void MainParseArgs(int, char **);
1.165 dsl 186: static int ReadMakefile(const void *, const void *);
1.200 joerg 187: static void usage(void) MAKE_ATTR_DEAD;
1.262 riastrad 188: static void purge_cached_realpaths(void);
1.1 cgd 189:
1.174 sjg 190: static Boolean ignorePWD; /* if we use -C, PWD is meaningless */
1.74 tv 191: static char objdir[MAXPATHLEN + 1]; /* where we chdir'ed to */
1.196 joerg 192: char curdir[MAXPATHLEN + 1]; /* Startup directory */
1.63 christos 193: char *progname; /* the program name */
1.176 sjg 194: char *makeDependfile;
1.183 sjg 195: pid_t myPid;
1.220 christos 196: int makelevel;
1.1 cgd 197:
1.274 sjg 198: FILE *debug_file;
199:
1.58 sommerfe 200: Boolean forceJobs = FALSE;
201:
1.63 christos 202: extern Lst parseIncPath;
203:
1.220 christos 204: /*
205: * For compatibility with the POSIX version of MAKEFLAGS that includes
206: * all the options with out -, convert flags to -f -l -a -g -s.
207: */
208: static char *
209: explode(const char *flags)
210: {
211: size_t len;
212: char *nf, *st;
213: const char *f;
214:
215: if (flags == NULL)
216: return NULL;
217:
218: for (f = flags; *f; f++)
219: if (!isalpha((unsigned char)*f))
220: break;
221:
222: if (*f)
1.221 christos 223: return bmake_strdup(flags);
1.220 christos 224:
225: len = strlen(flags);
1.221 christos 226: st = nf = bmake_malloc(len * 3 + 1);
1.220 christos 227: while (*flags) {
228: *nf++ = '-';
229: *nf++ = *flags++;
230: *nf++ = ' ';
231: }
232: *nf = '\0';
233: return st;
234: }
1.279 rillig 235:
1.133 dsl 236: static void
237: parse_debug_options(const char *argvalue)
238: {
239: const char *modules;
1.136 dsl 240: const char *mode;
241: char *fname;
1.149 christos 242: int len;
1.133 dsl 243:
244: for (modules = argvalue; *modules; ++modules) {
245: switch (*modules) {
246: case 'A':
1.285 sjg 247: debug = ~(0|DEBUG_LINT);
1.133 dsl 248: break;
249: case 'a':
250: debug |= DEBUG_ARCH;
251: break;
1.155 christos 252: case 'C':
253: debug |= DEBUG_CWD;
254: break;
1.133 dsl 255: case 'c':
256: debug |= DEBUG_COND;
257: break;
258: case 'd':
259: debug |= DEBUG_DIR;
260: break;
261: case 'e':
262: debug |= DEBUG_ERROR;
263: break;
264: case 'f':
265: debug |= DEBUG_FOR;
266: break;
267: case 'g':
268: if (modules[1] == '1') {
269: debug |= DEBUG_GRAPH1;
270: ++modules;
271: }
272: else if (modules[1] == '2') {
273: debug |= DEBUG_GRAPH2;
274: ++modules;
275: }
276: else if (modules[1] == '3') {
277: debug |= DEBUG_GRAPH3;
278: ++modules;
279: }
280: break;
1.280 sjg 281: case 'h':
282: debug |= DEBUG_HASH;
283: break;
1.133 dsl 284: case 'j':
285: debug |= DEBUG_JOB;
286: break;
1.285 sjg 287: case 'L':
288: debug |= DEBUG_LINT;
289: break;
1.146 sjg 290: case 'l':
291: debug |= DEBUG_LOUD;
292: break;
1.190 sjg 293: case 'M':
294: debug |= DEBUG_META;
295: break;
1.133 dsl 296: case 'm':
297: debug |= DEBUG_MAKE;
298: break;
299: case 'n':
300: debug |= DEBUG_SCRIPT;
301: break;
302: case 'p':
303: debug |= DEBUG_PARSE;
304: break;
305: case 's':
306: debug |= DEBUG_SUFF;
307: break;
308: case 't':
309: debug |= DEBUG_TARG;
310: break;
1.201 sjg 311: case 'V':
312: debugVflag = TRUE;
313: break;
1.133 dsl 314: case 'v':
315: debug |= DEBUG_VAR;
316: break;
317: case 'x':
318: debug |= DEBUG_SHELL;
319: break;
320: case 'F':
321: if (debug_file != stdout && debug_file != stderr)
322: fclose(debug_file);
1.199 sjg 323: if (*++modules == '+') {
324: modules++;
1.136 dsl 325: mode = "a";
1.199 sjg 326: } else
1.136 dsl 327: mode = "w";
1.153 apb 328: if (strcmp(modules, "stdout") == 0) {
1.152 apb 329: debug_file = stdout;
1.153 apb 330: goto debug_setbuf;
1.152 apb 331: }
1.153 apb 332: if (strcmp(modules, "stderr") == 0) {
1.152 apb 333: debug_file = stderr;
1.153 apb 334: goto debug_setbuf;
1.152 apb 335: }
1.136 dsl 336: len = strlen(modules);
1.261 maya 337: fname = bmake_malloc(len + 20);
1.136 dsl 338: memcpy(fname, modules, len + 1);
339: /* Let the filename be modified by the pid */
340: if (strcmp(fname + len - 3, ".%d") == 0)
1.149 christos 341: snprintf(fname + len - 2, 20, "%d", getpid());
1.136 dsl 342: debug_file = fopen(fname, mode);
1.133 dsl 343: if (!debug_file) {
1.139 dsl 344: fprintf(stderr, "Cannot open debug file %s\n",
1.136 dsl 345: fname);
1.133 dsl 346: usage();
347: }
1.136 dsl 348: free(fname);
1.153 apb 349: goto debug_setbuf;
1.133 dsl 350: default:
351: (void)fprintf(stderr,
352: "%s: illegal argument to d option -- %c\n",
353: progname, *modules);
354: usage();
355: }
356: }
1.153 apb 357: debug_setbuf:
358: /*
359: * Make the debug_file unbuffered, and make
360: * stdout line buffered (unless debugfile == stdout).
361: */
362: setvbuf(debug_file, NULL, _IONBF, 0);
363: if (debug_file != stdout) {
364: setvbuf(stdout, NULL, _IOLBF, 0);
365: }
1.133 dsl 366: }
367:
1.264 sjg 368: /*
369: * does path contain any relative components
370: */
1.286 rillig 371: static Boolean
1.264 sjg 372: is_relpath(const char *path)
373: {
374: const char *cp;
375:
376: if (path[0] != '/')
377: return TRUE;
378: cp = path;
1.286 rillig 379: while ((cp = strstr(cp, "/.")) != NULL) {
1.264 sjg 380: cp += 2;
381: if (cp[0] == '/' || cp[0] == '\0')
382: return TRUE;
383: else if (cp[0] == '.') {
384: if (cp[1] == '/' || cp[1] == '\0')
385: return TRUE;
386: }
1.286 rillig 387: }
1.264 sjg 388: return FALSE;
389: }
390:
1.1 cgd 391: /*-
392: * MainParseArgs --
393: * Parse a given argument vector. Called from main() and from
394: * Main_ParseArgLine() when the .MAKEFLAGS target is used.
395: *
396: * XXX: Deal with command line overriding .MAKEFLAGS in makefile
397: *
398: * Results:
399: * None
400: *
401: * Side Effects:
402: * Various global and local flags will be set depending on the flags
403: * given
404: */
405: static void
1.149 christos 406: MainParseArgs(int argc, char **argv)
1.1 cgd 407: {
1.47 hubertf 408: char *p;
1.122 christos 409: int c = '?';
1.98 ross 410: int arginc;
1.133 dsl 411: char *argvalue;
1.98 ross 412: const char *getopt_def;
1.256 christos 413: struct stat sa, sb;
1.98 ross 414: char *optscan;
1.101 ross 415: Boolean inOption, dashDash = FALSE;
1.97 chuck 416: char found_path[MAXPATHLEN + 1]; /* for searching for sys.mk */
1.1 cgd 417:
1.272 christos 418: #define OPTFLAGS "BC:D:I:J:NST:V:WXd:ef:ij:km:nqrstv:w"
1.98 ross 419: /* Can't actually use getopt(3) because rescanning is not portable */
420:
421: getopt_def = OPTFLAGS;
1.279 rillig 422: rearg:
1.98 ross 423: inOption = FALSE;
1.108 lukem 424: optscan = NULL;
1.98 ross 425: while(argc > 1) {
426: char *getopt_spec;
427: if(!inOption)
428: optscan = argv[1];
429: c = *optscan++;
430: arginc = 0;
431: if(inOption) {
432: if(c == '\0') {
433: ++argv;
434: --argc;
435: inOption = FALSE;
436: continue;
437: }
438: } else {
1.101 ross 439: if (c != '-' || dashDash)
1.98 ross 440: break;
441: inOption = TRUE;
442: c = *optscan++;
443: }
444: /* '-' found at some earlier point */
445: getopt_spec = strchr(getopt_def, c);
446: if(c != '\0' && getopt_spec != NULL && getopt_spec[1] == ':') {
447: /* -<something> found, and <something> should have an arg */
448: inOption = FALSE;
449: arginc = 1;
450: argvalue = optscan;
451: if(*argvalue == '\0') {
1.122 christos 452: if (argc < 3)
453: goto noarg;
1.98 ross 454: argvalue = argv[2];
455: arginc = 2;
456: }
1.108 lukem 457: } else {
1.279 rillig 458: argvalue = NULL;
1.98 ross 459: }
1.1 cgd 460: switch(c) {
1.98 ross 461: case '\0':
462: arginc = 1;
463: inOption = FALSE;
464: break;
1.92 sjg 465: case 'B':
466: compatMake = TRUE;
467: Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
1.277 rillig 468: Var_Set(MAKE_MODE, "compat", VAR_GLOBAL);
1.92 sjg 469: break;
1.171 sjg 470: case 'C':
471: if (chdir(argvalue) == -1) {
472: (void)fprintf(stderr,
473: "%s: chdir %s: %s\n",
474: progname, argvalue,
475: strerror(errno));
476: exit(1);
477: }
1.175 sjg 478: if (getcwd(curdir, MAXPATHLEN) == NULL) {
479: (void)fprintf(stderr, "%s: %s.\n", progname, strerror(errno));
480: exit(2);
481: }
1.264 sjg 482: if (!is_relpath(argvalue) &&
1.258 sjg 483: stat(argvalue, &sa) != -1 &&
1.256 christos 484: stat(curdir, &sb) != -1 &&
485: sa.st_ino == sb.st_ino &&
486: sa.st_dev == sb.st_dev)
1.257 christos 487: strncpy(curdir, argvalue, MAXPATHLEN);
1.174 sjg 488: ignorePWD = TRUE;
1.171 sjg 489: break;
1.1 cgd 490: case 'D':
1.156 dsl 491: if (argvalue == NULL || argvalue[0] == 0) goto noarg;
1.277 rillig 492: Var_Set(argvalue, "1", VAR_GLOBAL);
1.1 cgd 493: Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
1.122 christos 494: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.1 cgd 495: break;
496: case 'I':
1.122 christos 497: if (argvalue == NULL) goto noarg;
498: Parse_AddIncludeDir(argvalue);
1.1 cgd 499: Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
1.122 christos 500: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.1 cgd 501: break;
1.58 sommerfe 502: case 'J':
1.122 christos 503: if (argvalue == NULL) goto noarg;
1.132 dsl 504: if (sscanf(argvalue, "%d,%d", &jp_0, &jp_1) != 2) {
1.63 christos 505: (void)fprintf(stderr,
1.132 dsl 506: "%s: internal error -- J option malformed (%s)\n",
1.122 christos 507: progname, argvalue);
1.58 sommerfe 508: usage();
509: }
1.132 dsl 510: if ((fcntl(jp_0, F_GETFD, 0) < 0) ||
511: (fcntl(jp_1, F_GETFD, 0) < 0)) {
1.61 sommerfe 512: #if 0
1.58 sommerfe 513: (void)fprintf(stderr,
1.121 dsl 514: "%s: ###### warning -- J descriptors were closed!\n",
1.63 christos 515: progname);
1.118 dsl 516: exit(2);
1.61 sommerfe 517: #endif
1.132 dsl 518: jp_0 = -1;
519: jp_1 = -1;
1.61 sommerfe 520: compatMake = TRUE;
1.58 sommerfe 521: } else {
522: Var_Append(MAKEFLAGS, "-J", VAR_GLOBAL);
1.122 christos 523: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.58 sommerfe 524: jobServer = TRUE;
525: }
526: break;
1.61 sommerfe 527: case 'N':
528: noExecute = TRUE;
529: noRecursiveExecute = TRUE;
530: Var_Append(MAKEFLAGS, "-N", VAR_GLOBAL);
531: break;
1.1 cgd 532: case 'S':
533: keepgoing = FALSE;
534: Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
535: break;
1.58 sommerfe 536: case 'T':
1.122 christos 537: if (argvalue == NULL) goto noarg;
1.151 joerg 538: tracefile = bmake_strdup(argvalue);
1.58 sommerfe 539: Var_Append(MAKEFLAGS, "-T", VAR_GLOBAL);
1.122 christos 540: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.58 sommerfe 541: break;
1.92 sjg 542: case 'V':
1.272 christos 543: case 'v':
1.122 christos 544: if (argvalue == NULL) goto noarg;
1.272 christos 545: printVars = c == 'v' ? EXPAND_VARS : COMPAT_VARS;
1.134 dsl 546: (void)Lst_AtEnd(variables, argvalue);
1.92 sjg 547: Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
1.122 christos 548: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.92 sjg 549: break;
1.63 christos 550: case 'W':
551: parseWarnFatal = TRUE;
1.87 thorpej 552: break;
553: case 'X':
554: varNoExportEnv = TRUE;
555: Var_Append(MAKEFLAGS, "-X", VAR_GLOBAL);
1.63 christos 556: break;
1.133 dsl 557: case 'd':
1.122 christos 558: if (argvalue == NULL) goto noarg;
1.133 dsl 559: /* If '-d-opts' don't pass to children */
560: if (argvalue[0] == '-')
561: argvalue++;
562: else {
563: Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
564: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
565: }
566: parse_debug_options(argvalue);
1.1 cgd 567: break;
568: case 'e':
569: checkEnvFirst = TRUE;
570: Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
571: break;
572: case 'f':
1.122 christos 573: if (argvalue == NULL) goto noarg;
1.134 dsl 574: (void)Lst_AtEnd(makefiles, argvalue);
1.1 cgd 575: break;
576: case 'i':
577: ignoreErrors = TRUE;
578: Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
579: break;
580: case 'j':
1.122 christos 581: if (argvalue == NULL) goto noarg;
1.22 christos 582: forceJobs = TRUE;
1.122 christos 583: maxJobs = strtol(argvalue, &p, 0);
1.47 hubertf 584: if (*p != '\0' || maxJobs < 1) {
1.112 christos 585: (void)fprintf(stderr, "%s: illegal argument to -j -- must be positive integer!\n",
1.63 christos 586: progname);
1.46 hubertf 587: exit(1);
588: }
1.9 jtc 589: Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
1.122 christos 590: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.277 rillig 591: Var_Set(".MAKE.JOBS", argvalue, VAR_GLOBAL);
1.123 dsl 592: maxJobTokens = maxJobs;
1.1 cgd 593: break;
594: case 'k':
595: keepgoing = TRUE;
596: Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
597: break;
1.25 christos 598: case 'm':
1.122 christos 599: if (argvalue == NULL) goto noarg;
1.97 chuck 600: /* look for magic parent directory search string */
1.122 christos 601: if (strncmp(".../", argvalue, 4) == 0) {
602: if (!Dir_FindHereOrAbove(curdir, argvalue+4,
1.97 chuck 603: found_path, sizeof(found_path)))
604: break; /* nothing doing */
1.112 christos 605: (void)Dir_AddDir(sysIncPath, found_path);
1.97 chuck 606: } else {
1.122 christos 607: (void)Dir_AddDir(sysIncPath, argvalue);
1.97 chuck 608: }
1.25 christos 609: Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
1.122 christos 610: Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
1.25 christos 611: break;
1.1 cgd 612: case 'n':
613: noExecute = TRUE;
614: Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
615: break;
616: case 'q':
617: queryFlag = TRUE;
618: /* Kind of nonsensical, wot? */
619: Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL);
620: break;
621: case 'r':
622: noBuiltins = TRUE;
623: Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL);
624: break;
625: case 's':
626: beSilent = TRUE;
627: Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL);
628: break;
629: case 't':
630: touchFlag = TRUE;
631: Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
632: break;
1.220 christos 633: case 'w':
634: enterFlag = TRUE;
635: Var_Append(MAKEFLAGS, "-w", VAR_GLOBAL);
636: break;
1.101 ross 637: case '-':
638: dashDash = TRUE;
639: break;
1.1 cgd 640: default:
641: case '?':
642: usage();
643: }
1.98 ross 644: argv += arginc;
645: argc -= arginc;
1.1 cgd 646: }
647:
648: oldVars = TRUE;
649:
650: /*
651: * See if the rest of the arguments are variable assignments and
652: * perform them if so. Else take them to be targets and stuff them
653: * on the end of the "create" list.
654: */
1.98 ross 655: for (; argc > 1; ++argv, --argc)
656: if (Parse_IsVar(argv[1])) {
657: Parse_DoVar(argv[1], VAR_CMD);
1.67 sjg 658: } else {
1.98 ross 659: if (!*argv[1])
1.1 cgd 660: Punt("illegal (null) argument.");
1.101 ross 661: if (*argv[1] == '-' && !dashDash)
1.1 cgd 662: goto rearg;
1.151 joerg 663: (void)Lst_AtEnd(create, bmake_strdup(argv[1]));
1.1 cgd 664: }
1.122 christos 665:
666: return;
667: noarg:
668: (void)fprintf(stderr, "%s: option requires an argument -- %c\n",
669: progname, c);
670: usage();
1.1 cgd 671: }
672:
673: /*-
674: * Main_ParseArgLine --
675: * Used by the parse module when a .MFLAGS or .MAKEFLAGS target
676: * is encountered and by main() when reading the .MAKEFLAGS envariable.
677: * Takes a line of arguments and breaks it into its
678: * component words and passes those words and the number of them to the
679: * MainParseArgs function.
680: * The line should have all its leading whitespace removed.
681: *
1.85 wiz 682: * Input:
683: * line Line to fracture
684: *
1.1 cgd 685: * Results:
686: * None
687: *
688: * Side Effects:
689: * Only those that come from the various arguments.
690: */
691: void
1.161 dsl 692: Main_ParseArgLine(const char *line)
1.1 cgd 693: {
694: char **argv; /* Manufactured argument vector */
1.149 christos 695: int argc; /* Number of arguments in argv */
1.40 christos 696: char *args; /* Space used by the args */
1.287 rillig 697: char *p1;
1.289 rillig 698: const char *argv0 = Var_Value(".MAKE", VAR_GLOBAL, &p1);
1.296 rillig 699: char *buf;
1.1 cgd 700:
701: if (line == NULL)
702: return;
1.13 cgd 703: for (; *line == ' '; ++line)
704: continue;
1.1 cgd 705: if (!*line)
706: return;
707:
1.296 rillig 708: buf = str_concat(argv0, line, STR_ADDSPACE);
1.238 christos 709: free(p1);
1.40 christos 710:
1.41 christos 711: argv = brk_string(buf, &argc, TRUE, &args);
1.159 christos 712: if (argv == NULL) {
713: Error("Unterminated quoted string [%s]", buf);
714: free(buf);
715: return;
716: }
1.45 itohy 717: free(buf);
1.1 cgd 718: MainParseArgs(argc, argv);
1.40 christos 719:
720: free(args);
721: free(argv);
1.1 cgd 722: }
723:
1.74 tv 724: Boolean
1.252 christos 725: Main_SetObjdir(const char *fmt, ...)
1.31 christos 726: {
727: struct stat sb;
1.260 christos 728: char *path;
729: char buf[MAXPATHLEN + 1];
1.265 sjg 730: char buf2[MAXPATHLEN + 1];
1.76 tv 731: Boolean rc = FALSE;
1.252 christos 732: va_list ap;
733:
734: va_start(ap, fmt);
1.260 christos 735: vsnprintf(path = buf, MAXPATHLEN, fmt, ap);
1.252 christos 736: va_end(ap);
1.31 christos 737:
1.74 tv 738: if (path[0] != '/') {
1.263 sjg 739: snprintf(buf2, MAXPATHLEN, "%s/%s", curdir, path);
740: path = buf2;
1.74 tv 741: }
742:
743: /* look for the directory and try to chdir there */
1.31 christos 744: if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
745: if (chdir(path)) {
746: (void)fprintf(stderr, "make warning: %s: %s.\n",
747: path, strerror(errno));
1.74 tv 748: } else {
1.295 rillig 749: snprintf(objdir, sizeof objdir, "%s", path);
1.277 rillig 750: Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
1.74 tv 751: setenv("PWD", objdir, 1);
1.79 tv 752: Dir_InitDot();
1.262 riastrad 753: purge_cached_realpaths();
1.74 tv 754: rc = TRUE;
1.233 sjg 755: if (enterFlag && strcmp(objdir, curdir) != 0)
756: enterFlagObj = TRUE;
1.31 christos 757: }
758: }
759:
1.74 tv 760: return rc;
1.31 christos 761: }
762:
1.252 christos 763: static Boolean
1.253 christos 764: Main_SetVarObjdir(const char *var, const char *suffix)
1.252 christos 765: {
1.288 rillig 766: char *path_freeIt;
767: const char *path = Var_Value(var, VAR_CMD, &path_freeIt);
1.296 rillig 768: const char *xpath;
769: char *xpath_freeIt;
770:
1.288 rillig 771: if (path == NULL || path[0] == '\0') {
1.290 rillig 772: bmake_free(path_freeIt);
1.252 christos 773: return FALSE;
1.288 rillig 774: }
1.252 christos 775:
1.260 christos 776: /* expand variable substitutions */
1.296 rillig 777: xpath = path;
778: xpath_freeIt = NULL;
1.260 christos 779: if (strchr(path, '$') != 0)
1.288 rillig 780: xpath = xpath_freeIt = Var_Subst(path, VAR_GLOBAL,
781: VARE_WANTRES);
1.260 christos 782:
783: (void)Main_SetObjdir("%s%s", xpath, suffix);
784:
1.290 rillig 785: bmake_free(xpath_freeIt);
786: bmake_free(path_freeIt);
1.252 christos 787: return TRUE;
788: }
789:
1.124 sjg 790: /*-
791: * ReadAllMakefiles --
792: * wrapper around ReadMakefile() to read all.
793: *
794: * Results:
795: * TRUE if ok, FALSE on error
796: */
797: static int
1.165 dsl 798: ReadAllMakefiles(const void *p, const void *q)
1.124 sjg 799: {
1.278 rillig 800: return ReadMakefile(p, q) == 0;
1.124 sjg 801: }
1.31 christos 802:
1.197 sjg 803: int
1.176 sjg 804: str2Lst_Append(Lst lp, char *str, const char *sep)
805: {
806: char *cp;
807: int n;
808:
809: if (!sep)
810: sep = " \t";
811:
812: for (n = 0, cp = strtok(str, sep); cp; cp = strtok(NULL, sep)) {
813: (void)Lst_AtEnd(lp, cp);
814: n++;
815: }
1.278 rillig 816: return n;
1.176 sjg 817: }
818:
1.167 christos 819: #ifdef SIGINFO
820: /*ARGSUSED*/
821: static void
1.200 joerg 822: siginfo(int signo MAKE_ATTR_UNUSED)
1.167 christos 823: {
824: char dir[MAXPATHLEN];
825: char str[2 * MAXPATHLEN];
826: int len;
827: if (getcwd(dir, sizeof(dir)) == NULL)
828: return;
1.168 christos 829: len = snprintf(str, sizeof(str), "%s: Working in: %s\n", progname, dir);
1.167 christos 830: if (len > 0)
831: (void)write(STDERR_FILENO, str, (size_t)len);
832: }
833: #endif
834:
1.176 sjg 835: /*
836: * Allow makefiles some control over the mode we run in.
837: */
838: void
839: MakeMode(const char *mode)
840: {
841: char *mp = NULL;
842:
843: if (!mode)
1.284 rillig 844: mode = mp = Var_Subst("${" MAKE_MODE ":tl}",
1.281 rillig 845: VAR_GLOBAL, VARE_WANTRES);
1.176 sjg 846:
847: if (mode && *mode) {
848: if (strstr(mode, "compat")) {
849: compatMake = TRUE;
850: forceJobs = FALSE;
851: }
1.190 sjg 852: #if USE_META
853: if (strstr(mode, "meta"))
1.210 sjg 854: meta_mode_init(mode);
1.190 sjg 855: #endif
1.176 sjg 856: }
1.238 christos 857:
858: free(mp);
1.176 sjg 859: }
860:
1.266 christos 861: static void
862: doPrintVars(void)
863: {
864: LstNode ln;
865: Boolean expandVars;
866:
1.272 christos 867: if (printVars == EXPAND_VARS)
868: expandVars = TRUE;
869: else if (debugVflag)
1.266 christos 870: expandVars = FALSE;
871: else
1.272 christos 872: expandVars = getBoolean(".MAKE.EXPAND_VARIABLES", FALSE);
1.266 christos 873:
874: for (ln = Lst_First(variables); ln != NULL;
875: ln = Lst_Succ(ln)) {
876: char *var = (char *)Lst_Datum(ln);
1.289 rillig 877: const char *value;
1.266 christos 878: char *p1;
1.277 rillig 879:
1.266 christos 880: if (strchr(var, '$')) {
1.284 rillig 881: value = p1 = Var_Subst(var, VAR_GLOBAL, VARE_WANTRES);
1.266 christos 882: } else if (expandVars) {
883: char tmp[128];
884: int len = snprintf(tmp, sizeof(tmp), "${%s}", var);
1.277 rillig 885:
1.266 christos 886: if (len >= (int)sizeof(tmp))
887: Fatal("%s: variable name too big: %s",
1.267 christos 888: progname, var);
1.284 rillig 889: value = p1 = Var_Subst(tmp, VAR_GLOBAL, VARE_WANTRES);
1.266 christos 890: } else {
1.271 christos 891: value = Var_Value(var, VAR_GLOBAL, &p1);
1.266 christos 892: }
893: printf("%s\n", value ? value : "");
1.290 rillig 894: bmake_free(p1);
1.266 christos 895: }
896: }
897:
898: static Boolean
899: runTargets(void)
900: {
901: Lst targs; /* target nodes to create -- passed to Make_Init */
902: Boolean outOfDate; /* FALSE if all targets up to date */
903:
904: /*
905: * Have now read the entire graph and need to make a list of
906: * targets to create. If none was given on the command line,
907: * we consult the parsing module to find the main target(s)
908: * to create.
909: */
910: if (Lst_IsEmpty(create))
911: targs = Parse_MainName();
912: else
913: targs = Targ_FindList(create, TARG_CREATE);
914:
915: if (!compatMake) {
916: /*
917: * Initialize job module before traversing the graph
918: * now that any .BEGIN and .END targets have been read.
919: * This is done only if the -q flag wasn't given
920: * (to prevent the .BEGIN from being executed should
921: * it exist).
922: */
923: if (!queryFlag) {
924: Job_Init();
925: jobsRunning = TRUE;
926: }
927:
928: /* Traverse the graph, checking on all the targets */
929: outOfDate = Make_Run(targs);
930: } else {
931: /*
932: * Compat_Init will take care of creating all the
933: * targets as well as initializing the module.
934: */
935: Compat_Run(targs);
936: outOfDate = FALSE;
937: }
938: Lst_Destroy(targs, NULL);
939: return outOfDate;
940: }
941:
1.1 cgd 942: /*-
943: * main --
944: * The main function, for obvious reasons. Initializes variables
945: * and a few modules, then parses the arguments give it in the
946: * environment and on the command line. Reads the system makefile
947: * followed by either Makefile, makefile or the file given by the
948: * -f argument. Sets the .MAKEFLAGS PMake variable based on all the
949: * flags it has received by then uses either the Make or the Compat
950: * module to create the initial list of targets.
951: *
952: * Results:
953: * If -q was given, exits -1 if anything was out-of-date. Else it exits
954: * 0.
955: *
956: * Side Effects:
957: * The program exits when done. Targets are created. etc. etc. etc.
958: */
1.13 cgd 959: int
1.85 wiz 960: main(int argc, char **argv)
1.1 cgd 961: {
1.266 christos 962: Boolean outOfDate; /* FALSE if all targets up to date */
1.77 tv 963: struct stat sb, sa;
1.222 sjg 964: char *p1, *path;
1.74 tv 965: char mdpath[MAXPATHLEN];
1.291 rillig 966: const char *machine = getenv("MACHINE");
1.89 christos 967: const char *machine_arch = getenv("MACHINE_ARCH");
1.55 sjg 968: char *syspath = getenv("MAKESYSPATH");
1.25 christos 969: Lst sysMkPath; /* Path of sys.mk */
970: char *cp = NULL, *start;
971: /* avoid faults on read-only strings */
1.55 sjg 972: static char defsyspath[] = _PATH_DEFSYSPATH;
1.97 chuck 973: char found_path[MAXPATHLEN + 1]; /* for searching for sys.mk */
1.107 sjg 974: struct timeval rightnow; /* to initialize random seed */
1.119 tsutsui 975: struct utsname utsname;
1.107 sjg 976:
1.154 apb 977: /* default to writing debug to stderr */
978: debug_file = stderr;
1.133 dsl 979:
1.167 christos 980: #ifdef SIGINFO
1.188 sjg 981: (void)bmake_signal(SIGINFO, siginfo);
1.167 christos 982: #endif
1.107 sjg 983: /*
1.158 dholland 984: * Set the seed to produce a different random sequence
1.107 sjg 985: * on each program execution.
986: */
987: gettimeofday(&rightnow, NULL);
1.149 christos 988: srandom(rightnow.tv_sec + rightnow.tv_usec);
1.277 rillig 989:
1.53 christos 990: if ((progname = strrchr(argv[0], '/')) != NULL)
991: progname++;
992: else
993: progname = argv[0];
1.209 christos 994: #if defined(MAKE_NATIVE) || (defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE))
1.21 christos 995: /*
996: * get rid of resource limit on file descriptors
997: */
998: {
999: struct rlimit rl;
1000: if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
1001: rl.rlim_cur != rl.rlim_max) {
1002: rl.rlim_cur = rl.rlim_max;
1.112 christos 1003: (void)setrlimit(RLIMIT_NOFILE, &rl);
1.21 christos 1004: }
1005: }
1006: #endif
1.13 cgd 1007:
1.206 christos 1008: if (uname(&utsname) == -1) {
1009: (void)fprintf(stderr, "%s: uname failed (%s).\n", progname,
1010: strerror(errno));
1011: exit(2);
1012: }
1013:
1.17 gwr 1014: /*
1015: * Get the name of this type of MACHINE from utsname
1016: * so we can share an executable for similar machines.
1017: * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
1018: *
1.33 christos 1019: * Note that both MACHINE and MACHINE_ARCH are decided at
1020: * run-time.
1.17 gwr 1021: */
1.34 gwr 1022: if (!machine) {
1.102 ross 1023: #ifdef MAKE_NATIVE
1.18 christos 1024: machine = utsname.machine;
1.26 christos 1025: #else
1.81 tv 1026: #ifdef MAKE_MACHINE
1.80 thorpej 1027: machine = MAKE_MACHINE;
1.81 tv 1028: #else
1029: machine = "unknown";
1030: #endif
1.26 christos 1031: #endif
1.17 gwr 1032: }
1.1 cgd 1033:
1.33 christos 1034: if (!machine_arch) {
1.225 matt 1035: #ifdef MAKE_NATIVE
1036: static char machine_arch_buf[sizeof(utsname.machine)];
1037: const int mib[2] = { CTL_HW, HW_MACHINE_ARCH };
1038: size_t len = sizeof(machine_arch_buf);
1.277 rillig 1039:
1.225 matt 1040: if (sysctl(mib, __arraycount(mib), machine_arch_buf,
1041: &len, NULL, 0) < 0) {
1042: (void)fprintf(stderr, "%s: sysctl failed (%s).\n", progname,
1043: strerror(errno));
1044: exit(2);
1045: }
1046:
1047: machine_arch = machine_arch_buf;
1048: #else
1.33 christos 1049: #ifndef MACHINE_ARCH
1.80 thorpej 1050: #ifdef MAKE_MACHINE_ARCH
1.291 rillig 1051: machine_arch = MAKE_MACHINE_ARCH;
1.43 wsanchez 1052: #else
1.81 tv 1053: machine_arch = "unknown";
1.43 wsanchez 1054: #endif
1.33 christos 1055: #else
1056: machine_arch = MACHINE_ARCH;
1057: #endif
1.225 matt 1058: #endif
1.33 christos 1059: }
1060:
1.183 sjg 1061: myPid = getpid(); /* remember this for vFork() */
1062:
1.1 cgd 1063: /*
1.51 sjg 1064: * Just in case MAKEOBJDIR wants us to do something tricky.
1065: */
1066: Var_Init(); /* Initialize the lists of variables for
1067: * parsing arguments */
1.277 rillig 1068: Var_Set(".MAKE.OS", utsname.sysname, VAR_GLOBAL);
1069: Var_Set("MACHINE", machine, VAR_GLOBAL);
1070: Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL);
1.170 perry 1071: #ifdef MAKE_VERSION
1.277 rillig 1072: Var_Set("MAKE_VERSION", MAKE_VERSION, VAR_GLOBAL);
1.170 perry 1073: #endif
1.277 rillig 1074: Var_Set(".newline", "\n", VAR_GLOBAL); /* handy for :@ loops */
1.176 sjg 1075: /*
1076: * This is the traditional preference for makefiles.
1077: */
1078: #ifndef MAKEFILE_PREFERENCE_LIST
1079: # define MAKEFILE_PREFERENCE_LIST "makefile Makefile"
1080: #endif
1081: Var_Set(MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST,
1.277 rillig 1082: VAR_GLOBAL);
1083: Var_Set(MAKE_DEPENDFILE, ".depend", VAR_GLOBAL);
1.51 sjg 1084:
1.1 cgd 1085: create = Lst_Init(FALSE);
1086: makefiles = Lst_Init(FALSE);
1.272 christos 1087: printVars = 0;
1.201 sjg 1088: debugVflag = FALSE;
1.31 christos 1089: variables = Lst_Init(FALSE);
1.1 cgd 1090: beSilent = FALSE; /* Print commands as executed */
1091: ignoreErrors = FALSE; /* Pay attention to non-zero returns */
1092: noExecute = FALSE; /* Execute all commands */
1.61 sommerfe 1093: noRecursiveExecute = FALSE; /* Execute all .MAKE targets */
1.1 cgd 1094: keepgoing = FALSE; /* Stop on error */
1095: allPrecious = FALSE; /* Remove targets when interrupted */
1.251 dholland 1096: deleteOnError = FALSE; /* Historical default behavior */
1.1 cgd 1097: queryFlag = FALSE; /* This is not just a check-run */
1098: noBuiltins = FALSE; /* Read the built-in rules */
1099: touchFlag = FALSE; /* Actually update targets */
1100: debug = 0; /* No debug verbosity, please. */
1101: jobsRunning = FALSE;
1102:
1.121 dsl 1103: maxJobs = DEFMAXLOCAL; /* Set default local max concurrency */
1.123 dsl 1104: maxJobTokens = maxJobs;
1.21 christos 1105: compatMake = FALSE; /* No compat mode */
1.174 sjg 1106: ignorePWD = FALSE;
1.13 cgd 1107:
1.1 cgd 1108: /*
1109: * Initialize the parsing, directory and variable modules to prepare
1110: * for the reading of inclusion paths and variable settings on the
1111: * command line
1112: */
1.36 gwr 1113:
1114: /*
1.1 cgd 1115: * Initialize various variables.
1116: * MAKE also gets this name, for compatibility
1117: * .MAKEFLAGS gets set to the empty string just in case.
1118: * MFLAGS also gets initialized empty, for compatibility.
1119: */
1.79 tv 1120: Parse_Init();
1.187 christos 1121: if (argv[0][0] == '/' || strchr(argv[0], '/') == NULL) {
1122: /*
1123: * Leave alone if it is an absolute path, or if it does
1124: * not contain a '/' in which case we need to find it in
1125: * the path, like execvp(3) and the shells do.
1126: */
1127: p1 = argv[0];
1128: } else {
1129: /*
1130: * A relative path, canonicalize it.
1131: */
1.245 sjg 1132: p1 = cached_realpath(argv[0], mdpath);
1.187 christos 1133: if (!p1 || *p1 != '/' || stat(p1, &sb) < 0) {
1134: p1 = argv[0]; /* realpath failed */
1135: }
1136: }
1.277 rillig 1137: Var_Set("MAKE", p1, VAR_GLOBAL);
1138: Var_Set(".MAKE", p1, VAR_GLOBAL);
1139: Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
1140: Var_Set(MAKEOVERRIDES, "", VAR_GLOBAL);
1141: Var_Set("MFLAGS", "", VAR_GLOBAL);
1142: Var_Set(".ALLTARGETS", "", VAR_GLOBAL);
1.217 sjg 1143: /* some makefiles need to know this */
1.277 rillig 1144: Var_Set(MAKE_LEVEL ".ENV", MAKE_LEVEL_ENV, VAR_CMD);
1.1 cgd 1145:
1146: /*
1.142 sjg 1147: * Set some other useful macros
1148: */
1149: {
1.213 christos 1150: char tmp[64], *ep;
1.142 sjg 1151:
1.220 christos 1152: makelevel = ((ep = getenv(MAKE_LEVEL_ENV)) && *ep) ? atoi(ep) : 0;
1153: if (makelevel < 0)
1154: makelevel = 0;
1155: snprintf(tmp, sizeof(tmp), "%d", makelevel);
1.277 rillig 1156: Var_Set(MAKE_LEVEL, tmp, VAR_GLOBAL);
1.183 sjg 1157: snprintf(tmp, sizeof(tmp), "%u", myPid);
1.277 rillig 1158: Var_Set(".MAKE.PID", tmp, VAR_GLOBAL);
1.149 christos 1159: snprintf(tmp, sizeof(tmp), "%u", getppid());
1.277 rillig 1160: Var_Set(".MAKE.PPID", tmp, VAR_GLOBAL);
1.142 sjg 1161: }
1.220 christos 1162: if (makelevel > 0) {
1163: char pn[1024];
1164: snprintf(pn, sizeof(pn), "%s[%d]", progname, makelevel);
1.221 christos 1165: progname = bmake_strdup(pn);
1.220 christos 1166: }
1.142 sjg 1167:
1.210 sjg 1168: #ifdef USE_META
1169: meta_init();
1170: #endif
1.255 sjg 1171: Dir_Init(NULL); /* Dir_* safe to call from MainParseArgs */
1172:
1.142 sjg 1173: /*
1.1 cgd 1174: * First snag any flags out of the MAKE environment variable.
1175: * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's
1176: * in a different format).
1177: */
1178: #ifdef POSIX
1.220 christos 1179: p1 = explode(getenv("MAKEFLAGS"));
1180: Main_ParseArgLine(p1);
1181: free(p1);
1.1 cgd 1182: #else
1183: Main_ParseArgLine(getenv("MAKE"));
1184: #endif
1.31 christos 1185:
1.1 cgd 1186: /*
1.175 sjg 1187: * Find where we are (now).
1188: * We take care of PWD for the automounter below...
1.174 sjg 1189: */
1190: if (getcwd(curdir, MAXPATHLEN) == NULL) {
1.194 dholland 1191: (void)fprintf(stderr, "%s: getcwd: %s.\n",
1192: progname, strerror(errno));
1.174 sjg 1193: exit(2);
1194: }
1195:
1.175 sjg 1196: MainParseArgs(argc, argv);
1197:
1.220 christos 1198: if (enterFlag)
1199: printf("%s: Entering directory `%s'\n", progname, curdir);
1200:
1.175 sjg 1201: /*
1202: * Verify that cwd is sane.
1203: */
1.174 sjg 1204: if (stat(curdir, &sa) == -1) {
1205: (void)fprintf(stderr, "%s: %s: %s.\n",
1206: progname, curdir, strerror(errno));
1207: exit(2);
1208: }
1209:
1210: /*
1.175 sjg 1211: * All this code is so that we know where we are when we start up
1212: * on a different machine with pmake.
1.174 sjg 1213: * Overriding getcwd() with $PWD totally breaks MAKEOBJDIRPREFIX
1214: * since the value of curdir can vary depending on how we got
1215: * here. Ie sitting at a shell prompt (shell that provides $PWD)
1216: * or via subdir.mk in which case its likely a shell which does
1217: * not provide it.
1218: * So, to stop it breaking this case only, we ignore PWD if
1219: * MAKEOBJDIRPREFIX is set or MAKEOBJDIR contains a transform.
1220: */
1.222 sjg 1221: #ifndef NO_PWD_OVERRIDE
1222: if (!ignorePWD) {
1.226 pooka 1223: char *pwd, *ptmp1 = NULL, *ptmp2 = NULL;
1.222 sjg 1224:
1225: if ((pwd = getenv("PWD")) != NULL &&
1.226 pooka 1226: Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &ptmp1) == NULL) {
1227: const char *makeobjdir = Var_Value("MAKEOBJDIR",
1228: VAR_CMD, &ptmp2);
1.222 sjg 1229:
1230: if (makeobjdir == NULL || !strchr(makeobjdir, '$')) {
1231: if (stat(pwd, &sb) == 0 &&
1232: sa.st_ino == sb.st_ino &&
1233: sa.st_dev == sb.st_dev)
1234: (void)strncpy(curdir, pwd, MAXPATHLEN);
1235: }
1.174 sjg 1236: }
1.290 rillig 1237: bmake_free(ptmp1);
1238: bmake_free(ptmp2);
1.174 sjg 1239: }
1.222 sjg 1240: #endif
1.277 rillig 1241: Var_Set(".CURDIR", curdir, VAR_GLOBAL);
1.174 sjg 1242:
1243: /*
1244: * Find the .OBJDIR. If MAKEOBJDIRPREFIX, or failing that,
1245: * MAKEOBJDIR is set in the environment, try only that value
1246: * and fall back to .CURDIR if it does not exist.
1247: *
1.252 christos 1248: * Otherwise, try _PATH_OBJDIR.MACHINE-MACHINE_ARCH, _PATH_OBJDIR.MACHINE,
1249: * and * finally _PATH_OBJDIRPREFIX`pwd`, in that order. If none
1.174 sjg 1250: * of these paths exist, just use .CURDIR.
1251: */
1252: Dir_Init(curdir);
1.252 christos 1253: (void)Main_SetObjdir("%s", curdir);
1.174 sjg 1254:
1.253 christos 1255: if (!Main_SetVarObjdir("MAKEOBJDIRPREFIX", curdir) &&
1256: !Main_SetVarObjdir("MAKEOBJDIR", "") &&
1.254 christos 1257: !Main_SetObjdir("%s.%s-%s", _PATH_OBJDIR, machine, machine_arch) &&
1.252 christos 1258: !Main_SetObjdir("%s.%s", _PATH_OBJDIR, machine) &&
1259: !Main_SetObjdir("%s", _PATH_OBJDIR))
1260: (void)Main_SetObjdir("%s%s", _PATH_OBJDIRPREFIX, curdir);
1.174 sjg 1261:
1262: /*
1.1 cgd 1263: * Initialize archive, target and suffix modules in preparation for
1264: * parsing the makefile(s)
1265: */
1266: Arch_Init();
1267: Targ_Init();
1268: Suff_Init();
1.58 sommerfe 1269: Trace_Init(tracefile);
1.1 cgd 1270:
1.157 dsl 1271: DEFAULT = NULL;
1.1 cgd 1272: (void)time(&now);
1273:
1.58 sommerfe 1274: Trace_Log(MAKESTART, NULL);
1.279 rillig 1275:
1.1 cgd 1276: /*
1277: * Set up the .TARGETS variable to contain the list of targets to be
1278: * created. If none specified, make the variable empty -- the parser
1279: * will fill the thing in with the default or .MAIN target.
1280: */
1281: if (!Lst_IsEmpty(create)) {
1282: LstNode ln;
1283:
1.157 dsl 1284: for (ln = Lst_First(create); ln != NULL;
1.1 cgd 1285: ln = Lst_Succ(ln)) {
1286: char *name = (char *)Lst_Datum(ln);
1287:
1288: Var_Append(".TARGETS", name, VAR_GLOBAL);
1289: }
1290: } else
1.277 rillig 1291: Var_Set(".TARGETS", "", VAR_GLOBAL);
1.1 cgd 1292:
1.25 christos 1293:
1.1 cgd 1294: /*
1.25 christos 1295: * If no user-supplied system path was given (through the -m option)
1296: * add the directories from the DEFSYSPATH (more than one may be given
1297: * as dir1:...:dirn) to the system include path.
1.1 cgd 1298: */
1.73 tv 1299: if (syspath == NULL || *syspath == '\0')
1300: syspath = defsyspath;
1301: else
1.151 joerg 1302: syspath = bmake_strdup(syspath);
1.73 tv 1303:
1304: for (start = syspath; *start != '\0'; start = cp) {
1305: for (cp = start; *cp != '\0' && *cp != ':'; cp++)
1306: continue;
1.97 chuck 1307: if (*cp == ':') {
1308: *cp++ = '\0';
1309: }
1310: /* look for magic parent directory search string */
1311: if (strncmp(".../", start, 4) != 0) {
1.112 christos 1312: (void)Dir_AddDir(defIncPath, start);
1.73 tv 1313: } else {
1.279 rillig 1314: if (Dir_FindHereOrAbove(curdir, start+4,
1.97 chuck 1315: found_path, sizeof(found_path))) {
1.112 christos 1316: (void)Dir_AddDir(defIncPath, found_path);
1.97 chuck 1317: }
1.25 christos 1318: }
1319: }
1.73 tv 1320: if (syspath != defsyspath)
1321: free(syspath);
1.25 christos 1322:
1323: /*
1324: * Read in the built-in rules first, followed by the specified
1.115 christos 1325: * makefile, if it was (makefile != NULL), or the default
1.99 fair 1326: * makefile and Makefile, in that order, if it wasn't.
1.25 christos 1327: */
1328: if (!noBuiltins) {
1329: LstNode ln;
1330:
1.106 christos 1331: sysMkPath = Lst_Init(FALSE);
1.73 tv 1332: Dir_Expand(_PATH_DEFSYSMK,
1333: Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath,
1334: sysMkPath);
1.25 christos 1335: if (Lst_IsEmpty(sysMkPath))
1.63 christos 1336: Fatal("%s: no system rules (%s).", progname,
1337: _PATH_DEFSYSMK);
1.134 dsl 1338: ln = Lst_Find(sysMkPath, NULL, ReadMakefile);
1.157 dsl 1339: if (ln == NULL)
1.63 christos 1340: Fatal("%s: cannot open %s.", progname,
1341: (char *)Lst_Datum(ln));
1.25 christos 1342: }
1.1 cgd 1343:
1344: if (!Lst_IsEmpty(makefiles)) {
1345: LstNode ln;
1346:
1.134 dsl 1347: ln = Lst_Find(makefiles, NULL, ReadAllMakefiles);
1.157 dsl 1348: if (ln != NULL)
1.279 rillig 1349: Fatal("%s: cannot open %s.", progname,
1.63 christos 1350: (char *)Lst_Datum(ln));
1.176 sjg 1351: } else {
1.284 rillig 1352: p1 = Var_Subst("${" MAKEFILE_PREFERENCE "}",
1.281 rillig 1353: VAR_CMD, VARE_WANTRES);
1.176 sjg 1354: if (p1) {
1355: (void)str2Lst_Append(makefiles, p1, NULL);
1356: (void)Lst_Find(makefiles, NULL, ReadMakefile);
1357: free(p1);
1358: }
1359: }
1.1 cgd 1360:
1.138 dsl 1361: /* In particular suppress .depend for '-r -V .OBJDIR -f /dev/null' */
1.145 dsl 1362: if (!noBuiltins || !printVars) {
1.284 rillig 1363: makeDependfile = Var_Subst("${.MAKE.DEPENDFILE:T}",
1.281 rillig 1364: VAR_CMD, VARE_WANTRES);
1.176 sjg 1365: doing_depend = TRUE;
1366: (void)ReadMakefile(makeDependfile, NULL);
1367: doing_depend = FALSE;
1.145 dsl 1368: }
1.1 cgd 1369:
1.233 sjg 1370: if (enterFlagObj)
1371: printf("%s: Entering directory `%s'\n", progname, objdir);
1.279 rillig 1372:
1.176 sjg 1373: MakeMode(NULL);
1374:
1.14 jtc 1375: Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
1.290 rillig 1376: bmake_free(p1);
1.1 cgd 1377:
1.244 sjg 1378: if (!forceJobs && !compatMake &&
1379: Var_Exists(".MAKE.JOBS", VAR_GLOBAL)) {
1.243 matthias 1380: char *value;
1381: int n;
1382:
1.284 rillig 1383: value = Var_Subst("${.MAKE.JOBS}", VAR_GLOBAL, VARE_WANTRES);
1.243 matthias 1384: n = strtol(value, NULL, 0);
1385: if (n < 1) {
1386: (void)fprintf(stderr, "%s: illegal value for .MAKE.JOBS -- must be positive integer!\n",
1387: progname);
1388: exit(1);
1389: }
1390: if (n != maxJobs) {
1391: Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
1392: Var_Append(MAKEFLAGS, value, VAR_GLOBAL);
1393: }
1394: maxJobs = n;
1395: maxJobTokens = maxJobs;
1396: forceJobs = TRUE;
1397: free(value);
1398: }
1399:
1400: /*
1401: * Be compatible if user did not specify -j and did not explicitly
1402: * turned compatibility on
1403: */
1404: if (!compatMake && !forceJobs) {
1405: compatMake = TRUE;
1406: }
1407:
1.132 dsl 1408: if (!compatMake)
1409: Job_ServerStart(maxJobTokens, jp_0, jp_1);
1.58 sommerfe 1410: if (DEBUG(JOB))
1.133 dsl 1411: fprintf(debug_file, "job_pipe %d %d, maxjobs %d, tokens %d, compat %d\n",
1.132 dsl 1412: jp_0, jp_1, maxJobs, maxJobTokens, compatMake);
1.58 sommerfe 1413:
1.255 sjg 1414: if (!printVars)
1415: Main_ExportMAKEFLAGS(TRUE); /* initial export */
1.279 rillig 1416:
1.54 sjg 1417:
1.1 cgd 1418: /*
1419: * For compatibility, look at the directories in the VPATH variable
1420: * and add them to the search path, if the variable is defined. The
1421: * variable's value is in the same format as the PATH envariable, i.e.
1422: * <directory>:<directory>:<directory>...
1423: */
1424: if (Var_Exists("VPATH", VAR_CMD)) {
1.82 reinoud 1425: char *vpath, savec;
1.1 cgd 1426: /*
1427: * GCC stores string constants in read-only memory, but
1428: * Var_Subst will want to write this thing, so store it
1429: * in an array
1430: */
1431: static char VPATH[] = "${VPATH}";
1432:
1.284 rillig 1433: vpath = Var_Subst(VPATH, VAR_CMD, VARE_WANTRES);
1.1 cgd 1434: path = vpath;
1435: do {
1436: /* skip to end of directory */
1.13 cgd 1437: for (cp = path; *cp != ':' && *cp != '\0'; cp++)
1438: continue;
1.1 cgd 1439: /* Save terminator character so know when to stop */
1440: savec = *cp;
1441: *cp = '\0';
1442: /* Add directory to search path */
1.112 christos 1443: (void)Dir_AddDir(dirSearchPath, path);
1.1 cgd 1444: *cp = savec;
1445: path = cp + 1;
1446: } while (savec == ':');
1.114 christos 1447: free(vpath);
1.1 cgd 1448: }
1449:
1450: /*
1451: * Now that all search paths have been read for suffixes et al, it's
1452: * time to add the default search path to their lists...
1453: */
1454: Suff_DoPaths();
1.50 mycroft 1455:
1456: /*
1457: * Propagate attributes through :: dependency lists.
1458: */
1459: Targ_Propagate();
1.1 cgd 1460:
1461: /* print the initial graph, if the user requested it */
1462: if (DEBUG(GRAPH1))
1463: Targ_PrintGraph(1);
1464:
1.31 christos 1465: /* print the values of any variables requested by the user */
1466: if (printVars) {
1.266 christos 1467: doPrintVars();
1468: outOfDate = FALSE;
1.138 dsl 1469: } else {
1.266 christos 1470: outOfDate = runTargets();
1.31 christos 1471: }
1472:
1.49 mycroft 1473: #ifdef CLEANUP
1.157 dsl 1474: Lst_Destroy(variables, NULL);
1475: Lst_Destroy(makefiles, NULL);
1.116 christos 1476: Lst_Destroy(create, (FreeProc *)free);
1.49 mycroft 1477: #endif
1.14 jtc 1478:
1.1 cgd 1479: /* print the graph now it's been processed if the user requested it */
1480: if (DEBUG(GRAPH2))
1481: Targ_PrintGraph(2);
1482:
1.58 sommerfe 1483: Trace_Log(MAKEEND, 0);
1484:
1.233 sjg 1485: if (enterFlagObj)
1486: printf("%s: Leaving directory `%s'\n", progname, objdir);
1.220 christos 1487: if (enterFlag)
1488: printf("%s: Leaving directory `%s'\n", progname, curdir);
1489:
1.242 christos 1490: #ifdef USE_META
1491: meta_finish();
1492: #endif
1.230 joerg 1493: Suff_End();
1.291 rillig 1494: Targ_End();
1.14 jtc 1495: Arch_End();
1496: Var_End();
1497: Parse_End();
1498: Dir_End();
1.40 christos 1499: Job_End();
1.58 sommerfe 1500: Trace_End();
1.14 jtc 1501:
1.137 dsl 1502: return outOfDate ? 1 : 0;
1.1 cgd 1503: }
1504:
1505: /*-
1506: * ReadMakefile --
1507: * Open and parse the given makefile.
1508: *
1509: * Results:
1.124 sjg 1510: * 0 if ok. -1 if couldn't open file.
1.1 cgd 1511: *
1512: * Side Effects:
1513: * lots
1514: */
1.124 sjg 1515: static int
1.200 joerg 1516: ReadMakefile(const void *p, const void *q MAKE_ATTR_UNUSED)
1.1 cgd 1517: {
1.165 dsl 1518: const char *fname = p; /* makefile to read */
1.140 dsl 1519: int fd;
1.48 christos 1520: size_t len = MAXPATHLEN;
1.151 joerg 1521: char *name, *path = bmake_malloc(len);
1.1 cgd 1522:
1523: if (!strcmp(fname, "-")) {
1.193 dholland 1524: Parse_File(NULL /*stdin*/, -1);
1.277 rillig 1525: Var_Set("MAKEFILE", "", VAR_INTERNAL);
1.1 cgd 1526: } else {
1527: /* if we've chdir'd, rebuild the path name */
1.74 tv 1528: if (strcmp(curdir, objdir) && *fname != '/') {
1.48 christos 1529: size_t plen = strlen(curdir) + strlen(fname) + 2;
1530: if (len < plen)
1.151 joerg 1531: path = bmake_realloc(path, len = 2 * plen);
1.279 rillig 1532:
1.48 christos 1533: (void)snprintf(path, len, "%s/%s", curdir, fname);
1.140 dsl 1534: fd = open(path, O_RDONLY);
1535: if (fd != -1) {
1.1 cgd 1536: fname = path;
1537: goto found;
1538: }
1.279 rillig 1539:
1.95 jmc 1540: /* If curdir failed, try objdir (ala .depend) */
1541: plen = strlen(objdir) + strlen(fname) + 2;
1542: if (len < plen)
1.151 joerg 1543: path = bmake_realloc(path, len = 2 * plen);
1.95 jmc 1544: (void)snprintf(path, len, "%s/%s", objdir, fname);
1.140 dsl 1545: fd = open(path, O_RDONLY);
1546: if (fd != -1) {
1.95 jmc 1547: fname = path;
1548: goto found;
1549: }
1.140 dsl 1550: } else {
1551: fd = open(fname, O_RDONLY);
1552: if (fd != -1)
1553: goto found;
1554: }
1.1 cgd 1555: /* look in -I and system include directories. */
1556: name = Dir_FindFile(fname, parseIncPath);
1557: if (!name)
1.73 tv 1558: name = Dir_FindFile(fname,
1559: Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath);
1.140 dsl 1560: if (!name || (fd = open(name, O_RDONLY)) == -1) {
1.238 christos 1561: free(name);
1.48 christos 1562: free(path);
1.278 rillig 1563: return -1;
1.48 christos 1564: }
1.1 cgd 1565: fname = name;
1566: /*
1567: * set the MAKEFILE variable desired by System V fans -- the
1568: * placement of the setting here means it gets set to the last
1569: * makefile specified, as it is set by SysV make.
1570: */
1.67 sjg 1571: found:
1.176 sjg 1572: if (!doing_depend)
1.277 rillig 1573: Var_Set("MAKEFILE", fname, VAR_INTERNAL);
1.140 dsl 1574: Parse_File(fname, fd);
1.1 cgd 1575: }
1.48 christos 1576: free(path);
1.278 rillig 1577: return 0;
1.54 sjg 1578: }
1579:
1580:
1.29 christos 1581:
1582: /*-
1583: * Cmd_Exec --
1584: * Execute the command in cmd, and return the output of that command
1.302 ! rillig 1585: * in a string. In the output, newlines are replaced with spaces.
1.29 christos 1586: *
1587: * Results:
1.293 rillig 1588: * A string containing the output of the command, or the empty string.
1589: * *errfmt returns a format string describing the command failure,
1590: * if any, using a single %s conversion specification.
1.29 christos 1591: *
1592: * Side Effects:
1593: * The string must be freed by the caller.
1594: */
1595: char *
1.293 rillig 1596: Cmd_Exec(const char *cmd, const char **errfmt)
1.29 christos 1597: {
1.89 christos 1598: const char *args[4]; /* Args for invoking the shell */
1.29 christos 1599: int fds[2]; /* Pipe streams */
1.149 christos 1600: int cpid; /* Child PID */
1601: int pid; /* PID from wait() */
1.29 christos 1602: int status; /* command exit status */
1603: Buffer buf; /* buffer to store the result */
1.298 rillig 1604: ssize_t bytes_read;
1605: char *res; /* result */
1606: size_t res_len;
1.29 christos 1607: char *cp;
1.231 dholland 1608: int savederr; /* saved errno */
1.29 christos 1609:
1.293 rillig 1610: *errfmt = NULL;
1.29 christos 1611:
1.90 sjg 1612: if (!shellName)
1613: Shell_Init();
1.29 christos 1614: /*
1615: * Set up arguments for shell
1616: */
1.90 sjg 1617: args[0] = shellName;
1.29 christos 1618: args[1] = "-c";
1619: args[2] = cmd;
1620: args[3] = NULL;
1621:
1622: /*
1623: * Open a pipe for fetching its output
1624: */
1625: if (pipe(fds) == -1) {
1.293 rillig 1626: *errfmt = "Couldn't create pipe for \"%s\"";
1.29 christos 1627: goto bad;
1628: }
1629:
1630: /*
1631: * Fork
1632: */
1.183 sjg 1633: switch (cpid = vFork()) {
1.29 christos 1634: case 0:
1635: /*
1636: * Close input side of pipe
1637: */
1.112 christos 1638: (void)close(fds[0]);
1.29 christos 1639:
1640: /*
1641: * Duplicate the output stream to the shell's output, then
1642: * shut the extra thing down. Note we don't fetch the error
1643: * stream...why not? Why?
1644: */
1.112 christos 1645: (void)dup2(fds[1], 1);
1646: (void)close(fds[1]);
1.31 christos 1647:
1.143 sjg 1648: Var_ExportVars();
1649:
1.112 christos 1650: (void)execv(shellPath, UNCONST(args));
1.29 christos 1651: _exit(1);
1652: /*NOTREACHED*/
1653:
1654: case -1:
1.293 rillig 1655: *errfmt = "Couldn't exec \"%s\"";
1.29 christos 1656: goto bad;
1657:
1658: default:
1659: /*
1660: * No need for the writing half
1661: */
1.112 christos 1662: (void)close(fds[1]);
1.31 christos 1663:
1.232 sjg 1664: savederr = 0;
1.297 rillig 1665: Buf_Init(&buf, 0);
1.29 christos 1666:
1667: do {
1668: char result[BUFSIZ];
1.298 rillig 1669: bytes_read = read(fds[0], result, sizeof(result));
1670: if (bytes_read > 0)
1671: Buf_AddBytes(&buf, result, (size_t)bytes_read);
1.29 christos 1672: }
1.298 rillig 1673: while (bytes_read > 0 || (bytes_read == -1 && errno == EINTR));
1674: if (bytes_read == -1)
1.231 dholland 1675: savederr = errno;
1.29 christos 1676:
1677: /*
1678: * Close the input side of the pipe.
1679: */
1.112 christos 1680: (void)close(fds[0]);
1.29 christos 1681:
1682: /*
1683: * Wait for the process to exit.
1684: */
1.189 sjg 1685: while(((pid = waitpid(cpid, &status, 0)) != cpid) && (pid >= 0)) {
1686: JobReapChild(pid, status, FALSE);
1.29 christos 1687: continue;
1.189 sjg 1688: }
1.298 rillig 1689: res_len = Buf_Size(&buf);
1.163 dsl 1690: res = Buf_Destroy(&buf, FALSE);
1.29 christos 1691:
1.231 dholland 1692: if (savederr != 0)
1.293 rillig 1693: *errfmt = "Couldn't read shell's output for \"%s\"";
1.29 christos 1694:
1.172 dholland 1695: if (WIFSIGNALED(status))
1.293 rillig 1696: *errfmt = "\"%s\" exited on a signal";
1.172 dholland 1697: else if (WEXITSTATUS(status) != 0)
1.293 rillig 1698: *errfmt = "\"%s\" returned non-zero status";
1.29 christos 1699:
1.299 rillig 1700: /* Convert newlines to spaces. A final newline is just stripped */
1.300 rillig 1701: if (res_len > 0 && res[res_len - 1] == '\n')
1702: res[res_len - 1] = '\0';
1703: for (cp = res; *cp != '\0'; cp++)
1.299 rillig 1704: if (*cp == '\n')
1.29 christos 1705: *cp = ' ';
1706: break;
1707: }
1708: return res;
1709: bad:
1.293 rillig 1710: return bmake_strdup("");
1.1 cgd 1711: }
1712:
1713: /*-
1714: * Error --
1715: * Print an error message given its format.
1716: *
1717: * Results:
1718: * None.
1719: *
1720: * Side Effects:
1721: * The message is printed.
1722: */
1723: /* VARARGS */
1724: void
1.89 christos 1725: Error(const char *fmt, ...)
1.1 cgd 1726: {
1727: va_list ap;
1.162 dsl 1728: FILE *err_file;
1.85 wiz 1729:
1.162 dsl 1730: err_file = debug_file;
1731: if (err_file == stdout)
1732: err_file = stderr;
1.184 sjg 1733: (void)fflush(stdout);
1.162 dsl 1734: for (;;) {
1735: va_start(ap, fmt);
1736: fprintf(err_file, "%s: ", progname);
1737: (void)vfprintf(err_file, fmt, ap);
1738: va_end(ap);
1739: (void)fprintf(err_file, "\n");
1740: (void)fflush(err_file);
1741: if (err_file == stderr)
1742: break;
1743: err_file = stderr;
1744: }
1.1 cgd 1745: }
1746:
1747: /*-
1748: * Fatal --
1749: * Produce a Fatal error message. If jobs are running, waits for them
1750: * to finish.
1751: *
1752: * Results:
1753: * None
1754: *
1755: * Side Effects:
1756: * The program exits
1757: */
1758: /* VARARGS */
1759: void
1.89 christos 1760: Fatal(const char *fmt, ...)
1.1 cgd 1761: {
1762: va_list ap;
1.85 wiz 1763:
1.13 cgd 1764: va_start(ap, fmt);
1.1 cgd 1765: if (jobsRunning)
1766: Job_Wait();
1767:
1.184 sjg 1768: (void)fflush(stdout);
1.1 cgd 1769: (void)vfprintf(stderr, fmt, ap);
1770: va_end(ap);
1771: (void)fprintf(stderr, "\n");
1772: (void)fflush(stderr);
1773:
1.176 sjg 1774: PrintOnError(NULL, NULL);
1.67 sjg 1775:
1.94 dsl 1776: if (DEBUG(GRAPH2) || DEBUG(GRAPH3))
1.1 cgd 1777: Targ_PrintGraph(2);
1.58 sommerfe 1778: Trace_Log(MAKEERROR, 0);
1.1 cgd 1779: exit(2); /* Not 1 so -q can distinguish error */
1780: }
1781:
1782: /*
1783: * Punt --
1784: * Major exception once jobs are being created. Kills all jobs, prints
1785: * a message and exits.
1786: *
1787: * Results:
1.31 christos 1788: * None
1.1 cgd 1789: *
1790: * Side Effects:
1791: * All children are killed indiscriminately and the program Lib_Exits
1792: */
1793: /* VARARGS */
1794: void
1.89 christos 1795: Punt(const char *fmt, ...)
1.1 cgd 1796: {
1797: va_list ap;
1.85 wiz 1798:
1.13 cgd 1799: va_start(ap, fmt);
1.184 sjg 1800: (void)fflush(stdout);
1.63 christos 1801: (void)fprintf(stderr, "%s: ", progname);
1.1 cgd 1802: (void)vfprintf(stderr, fmt, ap);
1803: va_end(ap);
1804: (void)fprintf(stderr, "\n");
1805: (void)fflush(stderr);
1806:
1.176 sjg 1807: PrintOnError(NULL, NULL);
1.67 sjg 1808:
1.1 cgd 1809: DieHorribly();
1810: }
1811:
1812: /*-
1813: * DieHorribly --
1814: * Exit without giving a message.
1815: *
1816: * Results:
1817: * None
1818: *
1819: * Side Effects:
1820: * A big one...
1821: */
1822: void
1.85 wiz 1823: DieHorribly(void)
1.1 cgd 1824: {
1825: if (jobsRunning)
1826: Job_AbortAll();
1827: if (DEBUG(GRAPH2))
1828: Targ_PrintGraph(2);
1.58 sommerfe 1829: Trace_Log(MAKEERROR, 0);
1.1 cgd 1830: exit(2); /* Not 1, so -q can distinguish error */
1831: }
1832:
1833: /*
1834: * Finish --
1835: * Called when aborting due to errors in child shell to signal
1.31 christos 1836: * abnormal exit.
1.1 cgd 1837: *
1838: * Results:
1.31 christos 1839: * None
1.1 cgd 1840: *
1841: * Side Effects:
1842: * The program exits
1843: */
1844: void
1.85 wiz 1845: Finish(int errors)
1.291 rillig 1846: /* number of errors encountered in Make_Make */
1.1 cgd 1847: {
1.275 sjg 1848: if (dieQuietly(NULL, -1))
1849: exit(2);
1.1 cgd 1850: Fatal("%d error%s", errors, errors == 1 ? "" : "s");
1851: }
1852:
1.21 christos 1853: /*
1.208 dholland 1854: * eunlink --
1.21 christos 1855: * Remove a file carefully, avoiding directories.
1856: */
1857: int
1.85 wiz 1858: eunlink(const char *file)
1.21 christos 1859: {
1860: struct stat st;
1861:
1862: if (lstat(file, &st) == -1)
1863: return -1;
1864:
1865: if (S_ISDIR(st.st_mode)) {
1866: errno = EISDIR;
1867: return -1;
1868: }
1869: return unlink(file);
1.1 cgd 1870: }
1871:
1872: /*
1.66 christos 1873: * execError --
1874: * Print why exec failed, avoiding stdio.
1875: */
1876: void
1.85 wiz 1877: execError(const char *af, const char *av)
1.66 christos 1878: {
1879: #ifdef USE_IOVEC
1880: int i = 0;
1.83 pk 1881: struct iovec iov[8];
1.66 christos 1882: #define IOADD(s) \
1.89 christos 1883: (void)(iov[i].iov_base = UNCONST(s), \
1.66 christos 1884: iov[i].iov_len = strlen(iov[i].iov_base), \
1885: i++)
1886: #else
1.112 christos 1887: #define IOADD(void)write(2, s, strlen(s))
1.66 christos 1888: #endif
1889:
1890: IOADD(progname);
1.83 pk 1891: IOADD(": ");
1.89 christos 1892: IOADD(af);
1.83 pk 1893: IOADD("(");
1.89 christos 1894: IOADD(av);
1.83 pk 1895: IOADD(") failed (");
1.66 christos 1896: IOADD(strerror(errno));
1897: IOADD(")\n");
1898:
1899: #ifdef USE_IOVEC
1.205 christos 1900: while (writev(2, iov, 8) == -1 && errno == EAGAIN)
1901: continue;
1.66 christos 1902: #endif
1903: }
1904:
1905: /*
1.1 cgd 1906: * usage --
1907: * exit with usage message
1908: */
1.13 cgd 1909: static void
1.85 wiz 1910: usage(void)
1.1 cgd 1911: {
1.220 christos 1912: char *p;
1913: if ((p = strchr(progname, '[')) != NULL)
1.292 rillig 1914: *p = '\0';
1.220 christos 1915:
1.1 cgd 1916: (void)fprintf(stderr,
1.292 rillig 1917: "usage: %s [-BeikNnqrstWwX] \n"
1918: " [-C directory] [-D variable] [-d flags] [-f makefile]\n"
1919: " [-I directory] [-J private] [-j max_jobs] [-m directory] [-T file]\n"
1920: " [-V variable] [-v variable] [variable=value] [target ...]\n",
1.272 christos 1921: progname);
1.1 cgd 1922: exit(2);
1.14 jtc 1923: }
1924:
1.245 sjg 1925: /*
1926: * realpath(3) can get expensive, cache results...
1927: */
1.262 riastrad 1928: static GNode *cached_realpaths = NULL;
1929:
1930: static GNode *
1931: get_cached_realpaths(void)
1932: {
1933:
1934: if (!cached_realpaths) {
1935: cached_realpaths = Targ_NewGN("Realpath");
1936: #ifndef DEBUG_REALPATH_CACHE
1937: cached_realpaths->flags = INTERNAL;
1938: #endif
1939: }
1940:
1941: return cached_realpaths;
1942: }
1943:
1944: /* purge any relative paths */
1945: static void
1946: purge_cached_realpaths(void)
1947: {
1948: GNode *cache = get_cached_realpaths();
1949: Hash_Entry *he, *nhe;
1950: Hash_Search hs;
1951:
1952: he = Hash_EnumFirst(&cache->context, &hs);
1953: while (he) {
1954: nhe = Hash_EnumNext(&hs);
1955: if (he->name[0] != '/') {
1956: if (DEBUG(DIR))
1957: fprintf(stderr, "cached_realpath: purging %s\n", he->name);
1958: Hash_DeleteEntry(&cache->context, he);
1959: }
1960: he = nhe;
1961: }
1962: }
1963:
1.245 sjg 1964: char *
1965: cached_realpath(const char *pathname, char *resolved)
1966: {
1.262 riastrad 1967: GNode *cache;
1.289 rillig 1968: const char *rp;
1969: char *cp;
1.245 sjg 1970:
1971: if (!pathname || !pathname[0])
1972: return NULL;
1973:
1.262 riastrad 1974: cache = get_cached_realpaths();
1975:
1.248 christos 1976: if ((rp = Var_Value(pathname, cache, &cp)) != NULL) {
1.245 sjg 1977: /* a hit */
1.248 christos 1978: strncpy(resolved, rp, MAXPATHLEN);
1979: resolved[MAXPATHLEN - 1] = '\0';
1980: } else if ((rp = realpath(pathname, resolved)) != NULL) {
1.277 rillig 1981: Var_Set(pathname, rp, cache);
1.248 christos 1982: } /* else should we negative-cache? */
1983:
1.290 rillig 1984: bmake_free(cp);
1.245 sjg 1985: return rp ? resolved : NULL;
1986: }
1987:
1.14 jtc 1988: int
1.164 dsl 1989: PrintAddr(void *a, void *b)
1.14 jtc 1990: {
1991: printf("%lx ", (unsigned long) a);
1992: return b ? 0 : 0;
1.67 sjg 1993: }
1.149 christos 1994:
1.67 sjg 1995:
1.249 sjg 1996: static int
1997: addErrorCMD(void *cmdp, void *gnp)
1998: {
1.250 sjg 1999: if (cmdp == NULL)
2000: return 1; /* stop */
1.249 sjg 2001: Var_Append(".ERROR_CMD", cmdp, VAR_GLOBAL);
2002: return 0;
2003: }
1.67 sjg 2004:
1.275 sjg 2005: /*
2006: * Return true if we should die without noise.
2007: * For example our failing child was a sub-make
2008: * or failure happend elsewhere.
2009: */
2010: int
2011: dieQuietly(GNode *gn, int bf)
2012: {
2013: static int quietly = -1;
2014:
2015: if (quietly < 0) {
2016: if (DEBUG(JOB) || getBoolean(".MAKE.DIE_QUIETLY", 1) == 0)
2017: quietly = 0;
2018: else if (bf >= 0)
2019: quietly = bf;
2020: else
1.276 sjg 2021: quietly = (gn) ? ((gn->type & (OP_MAKE)) != 0) : 0;
1.275 sjg 2022: }
2023: return quietly;
2024: }
2025:
1.67 sjg 2026: void
1.176 sjg 2027: PrintOnError(GNode *gn, const char *s)
1.67 sjg 2028: {
1.177 sjg 2029: static GNode *en = NULL;
1.296 rillig 2030: const char *expr;
2031: char *cp;
1.128 sjg 2032:
1.283 sjg 2033: if (DEBUG(HASH)) {
2034: Targ_Stats();
2035: Var_Stats();
2036: }
2037:
1.275 sjg 2038: /* we generally want to keep quiet if a sub-make died */
2039: if (dieQuietly(gn, -1))
2040: return;
2041:
1.67 sjg 2042: if (s)
1.176 sjg 2043: printf("%s", s);
1.279 rillig 2044:
1.67 sjg 2045: printf("\n%s: stopped in %s\n", progname, curdir);
1.176 sjg 2046:
1.177 sjg 2047: if (en)
2048: return; /* we've been here! */
1.176 sjg 2049: if (gn) {
2050: /*
2051: * We can print this even if there is no .ERROR target.
2052: */
1.277 rillig 2053: Var_Set(".ERROR_TARGET", gn->name, VAR_GLOBAL);
1.249 sjg 2054: Var_Delete(".ERROR_CMD", VAR_GLOBAL);
2055: Lst_ForEach(gn->commands, addErrorCMD, gn);
1.176 sjg 2056: }
1.296 rillig 2057: expr = "${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'\n@}";
2058: cp = Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES);
1.186 sjg 2059: if (cp) {
2060: if (*cp)
2061: printf("%s", cp);
2062: free(cp);
2063: }
1.235 sjg 2064: fflush(stdout);
2065:
1.176 sjg 2066: /*
1.186 sjg 2067: * Finally, see if there is a .ERROR target, and run it if so.
1.176 sjg 2068: */
2069: en = Targ_FindNode(".ERROR", TARG_NOCREATE);
2070: if (en) {
2071: en->type |= OP_SPECIAL;
2072: Compat_Make(en, en);
2073: }
1.68 sjg 2074: }
2075:
2076: void
1.85 wiz 2077: Main_ExportMAKEFLAGS(Boolean first)
1.68 sjg 2078: {
2079: static int once = 1;
1.296 rillig 2080: const char *expr;
2081: char *s;
1.68 sjg 2082:
2083: if (once != first)
2084: return;
2085: once = 0;
1.279 rillig 2086:
1.296 rillig 2087: expr = "${.MAKEFLAGS} ${.MAKEOVERRIDES:O:u:@v@$v=${$v:Q}@}";
2088: s = Var_Subst(expr, VAR_CMD, VARE_WANTRES);
1.282 rillig 2089: if (s != NULL && s[0] != '\0') {
1.68 sjg 2090: #ifdef POSIX
2091: setenv("MAKEFLAGS", s, 1);
2092: #else
2093: setenv("MAKE", s, 1);
2094: #endif
2095: }
1.1 cgd 2096: }
1.180 sjg 2097:
1.191 sjg 2098: char *
2099: getTmpdir(void)
1.180 sjg 2100: {
2101: static char *tmpdir = NULL;
2102:
2103: if (!tmpdir) {
2104: struct stat st;
2105:
2106: /*
2107: * Honor $TMPDIR but only if it is valid.
2108: * Ensure it ends with /.
2109: */
1.284 rillig 2110: tmpdir = Var_Subst("${TMPDIR:tA:U" _PATH_TMP "}/", VAR_GLOBAL,
1.281 rillig 2111: VARE_WANTRES);
1.180 sjg 2112: if (stat(tmpdir, &st) < 0 || !S_ISDIR(st.st_mode)) {
2113: free(tmpdir);
2114: tmpdir = bmake_strdup(_PATH_TMP);
2115: }
2116: }
1.191 sjg 2117: return tmpdir;
2118: }
2119:
2120: /*
2121: * Create and open a temp file using "pattern".
2122: * If "fnamep" is provided set it to a copy of the filename created.
2123: * Otherwise unlink the file once open.
2124: */
2125: int
2126: mkTempFile(const char *pattern, char **fnamep)
2127: {
2128: static char *tmpdir = NULL;
2129: char tfile[MAXPATHLEN];
2130: int fd;
1.279 rillig 2131:
1.191 sjg 2132: if (!pattern)
2133: pattern = TMPPAT;
2134: if (!tmpdir)
2135: tmpdir = getTmpdir();
1.180 sjg 2136: if (pattern[0] == '/') {
1.181 dholland 2137: snprintf(tfile, sizeof(tfile), "%s", pattern);
1.180 sjg 2138: } else {
2139: snprintf(tfile, sizeof(tfile), "%s%s", tmpdir, pattern);
2140: }
2141: if ((fd = mkstemp(tfile)) < 0)
2142: Punt("Could not create temporary file %s: %s", tfile, strerror(errno));
2143: if (fnamep) {
2144: *fnamep = bmake_strdup(tfile);
2145: } else {
2146: unlink(tfile); /* we just want the descriptor */
2147: }
2148: return fd;
2149: }
1.201 sjg 2150:
1.240 sjg 2151: /*
2152: * Convert a string representation of a boolean.
2153: * Anything that looks like "No", "False", "Off", "0" etc,
2154: * is FALSE, otherwise TRUE.
2155: */
2156: Boolean
2157: s2Boolean(const char *s, Boolean bf)
2158: {
2159: if (s) {
2160: switch(*s) {
2161: case '\0': /* not set - the default wins */
2162: break;
2163: case '0':
2164: case 'F':
2165: case 'f':
2166: case 'N':
2167: case 'n':
2168: bf = FALSE;
2169: break;
2170: case 'O':
2171: case 'o':
2172: switch (s[1]) {
2173: case 'F':
2174: case 'f':
2175: bf = FALSE;
2176: break;
2177: default:
2178: bf = TRUE;
2179: break;
2180: }
2181: break;
2182: default:
2183: bf = TRUE;
2184: break;
2185: }
2186: }
1.278 rillig 2187: return bf;
1.240 sjg 2188: }
1.201 sjg 2189:
2190: /*
2191: * Return a Boolean based on setting of a knob.
2192: *
2193: * If the knob is not set, the supplied default is the return value.
2194: * If set, anything that looks or smells like "No", "False", "Off", "0" etc,
2195: * is FALSE, otherwise TRUE.
2196: */
2197: Boolean
2198: getBoolean(const char *name, Boolean bf)
2199: {
2200: char tmp[64];
2201: char *cp;
2202:
1.241 sjg 2203: if (snprintf(tmp, sizeof(tmp), "${%s:U:tl}", name) < (int)(sizeof(tmp))) {
1.284 rillig 2204: cp = Var_Subst(tmp, VAR_GLOBAL, VARE_WANTRES);
1.201 sjg 2205:
2206: if (cp) {
1.240 sjg 2207: bf = s2Boolean(cp, bf);
1.201 sjg 2208: free(cp);
2209: }
2210: }
1.278 rillig 2211: return bf;
1.201 sjg 2212: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / usr.bin / make