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