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