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