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