Home | History | Annotate | Line # | Download | only in make
main.c revision 1.51
      1  1.51       sjg /*	$NetBSD: main.c,v 1.51 2000/02/08 12:43:25 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.1       cgd  * Copyright (c) 1989 by Berkeley Softworks
      7   1.1       cgd  * All rights reserved.
      8   1.1       cgd  *
      9   1.1       cgd  * This code is derived from software contributed to Berkeley by
     10   1.1       cgd  * Adam de Boor.
     11   1.1       cgd  *
     12   1.1       cgd  * Redistribution and use in source and binary forms, with or without
     13   1.1       cgd  * modification, are permitted provided that the following conditions
     14   1.1       cgd  * are met:
     15   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     16   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     17   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     18   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     19   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     20   1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     21   1.1       cgd  *    must display the following acknowledgement:
     22   1.1       cgd  *	This product includes software developed by the University of
     23   1.1       cgd  *	California, Berkeley and its contributors.
     24   1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     25   1.1       cgd  *    may be used to endorse or promote products derived from this software
     26   1.1       cgd  *    without specific prior written permission.
     27   1.1       cgd  *
     28   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38   1.1       cgd  * SUCH DAMAGE.
     39   1.1       cgd  */
     40   1.1       cgd 
     41  1.38     lukem #ifdef MAKE_BOOTSTRAP
     42  1.51       sjg static char rcsid[] = "$NetBSD: main.c,v 1.51 2000/02/08 12:43:25 sjg Exp $";
     43  1.38     lukem #else
     44  1.37  christos #include <sys/cdefs.h>
     45   1.1       cgd #ifndef lint
     46  1.37  christos __COPYRIGHT("@(#) Copyright (c) 1988, 1989, 1990, 1993\n\
     47  1.37  christos 	The Regents of the University of California.  All rights reserved.\n");
     48   1.1       cgd #endif /* not lint */
     49   1.1       cgd 
     50   1.1       cgd #ifndef lint
     51  1.19  christos #if 0
     52  1.31  christos static char sccsid[] = "@(#)main.c	8.3 (Berkeley) 3/19/94";
     53  1.19  christos #else
     54  1.51       sjg __RCSID("$NetBSD: main.c,v 1.51 2000/02/08 12:43:25 sjg Exp $");
     55  1.19  christos #endif
     56   1.1       cgd #endif /* not lint */
     57  1.38     lukem #endif
     58   1.1       cgd 
     59   1.1       cgd /*-
     60   1.1       cgd  * main.c --
     61   1.1       cgd  *	The main file for this entire program. Exit routines etc
     62   1.1       cgd  *	reside here.
     63   1.1       cgd  *
     64   1.1       cgd  * Utility functions defined in this file:
     65   1.1       cgd  *	Main_ParseArgLine	Takes a line of arguments, breaks them and
     66   1.1       cgd  *				treats them as if they were given when first
     67   1.1       cgd  *				invoked. Used by the parse module to implement
     68   1.1       cgd  *				the .MFLAGS target.
     69   1.1       cgd  *
     70   1.1       cgd  *	Error			Print a tagged error message. The global
     71   1.1       cgd  *				MAKE variable must have been defined. This
     72   1.1       cgd  *				takes a format string and two optional
     73   1.1       cgd  *				arguments for it.
     74   1.1       cgd  *
     75   1.1       cgd  *	Fatal			Print an error message and exit. Also takes
     76   1.1       cgd  *				a format string and two arguments.
     77   1.1       cgd  *
     78   1.1       cgd  *	Punt			Aborts all jobs and exits with a message. Also
     79   1.1       cgd  *				takes a format string and two arguments.
     80   1.1       cgd  *
     81   1.1       cgd  *	Finish			Finish things up by printing the number of
     82   1.1       cgd  *				errors which occured, as passed to it, and
     83   1.1       cgd  *				exiting.
     84   1.1       cgd  */
     85   1.1       cgd 
     86  1.13       cgd #include <sys/types.h>
     87  1.13       cgd #include <sys/time.h>
     88   1.1       cgd #include <sys/param.h>
     89  1.13       cgd #include <sys/resource.h>
     90  1.21  christos #include <sys/signal.h>
     91   1.1       cgd #include <sys/stat.h>
     92  1.34       gwr #ifndef MAKE_BOOTSTRAP
     93  1.17       gwr #include <sys/utsname.h>
     94  1.31  christos #endif
     95  1.29  christos #include <sys/wait.h>
     96   1.1       cgd #include <errno.h>
     97   1.1       cgd #include <fcntl.h>
     98   1.1       cgd #include <stdio.h>
     99  1.32  christos #include <stdlib.h>
    100  1.42    kleink #include <time.h>
    101  1.32  christos #ifdef __STDC__
    102  1.13       cgd #include <stdarg.h>
    103  1.13       cgd #else
    104   1.1       cgd #include <varargs.h>
    105  1.13       cgd #endif
    106   1.1       cgd #include "make.h"
    107  1.13       cgd #include "hash.h"
    108  1.13       cgd #include "dir.h"
    109  1.13       cgd #include "job.h"
    110   1.1       cgd #include "pathnames.h"
    111   1.1       cgd 
    112   1.1       cgd #ifndef	DEFMAXLOCAL
    113   1.1       cgd #define	DEFMAXLOCAL DEFMAXJOBS
    114  1.24  christos #endif	/* DEFMAXLOCAL */
    115   1.1       cgd 
    116   1.1       cgd #define	MAKEFLAGS	".MAKEFLAGS"
    117   1.1       cgd 
    118   1.1       cgd Lst			create;		/* Targets to be made */
    119   1.1       cgd time_t			now;		/* Time at start of make */
    120   1.1       cgd GNode			*DEFAULT;	/* .DEFAULT node */
    121   1.1       cgd Boolean			allPrecious;	/* .PRECIOUS given on line by itself */
    122   1.1       cgd 
    123   1.1       cgd static Boolean		noBuiltins;	/* -r flag */
    124   1.1       cgd static Lst		makefiles;	/* ordered list of makefiles to read */
    125  1.31  christos static Boolean		printVars;	/* print value of one or more vars */
    126  1.31  christos static Lst		variables;	/* list of variables to print */
    127  1.21  christos int			maxJobs;	/* -j argument */
    128   1.1       cgd static int		maxLocal;	/* -L argument */
    129  1.13       cgd Boolean			compatMake;	/* -B argument */
    130   1.1       cgd Boolean			debug;		/* -d flag */
    131   1.1       cgd Boolean			noExecute;	/* -n flag */
    132   1.1       cgd Boolean			keepgoing;	/* -k flag */
    133   1.1       cgd Boolean			queryFlag;	/* -q flag */
    134   1.1       cgd Boolean			touchFlag;	/* -t flag */
    135   1.1       cgd Boolean			usePipes;	/* !-P flag */
    136   1.1       cgd Boolean			ignoreErrors;	/* -i flag */
    137   1.1       cgd Boolean			beSilent;	/* -s flag */
    138   1.1       cgd Boolean			oldVars;	/* variable substitution style */
    139   1.1       cgd Boolean			checkEnvFirst;	/* -e flag */
    140  1.35       cjs Boolean			mkIncPath;	/* -m flag */
    141   1.1       cgd static Boolean		jobsRunning;	/* TRUE if the jobs might be running */
    142   1.1       cgd 
    143  1.31  christos static void		MainParseArgs __P((int, char **));
    144  1.31  christos char *			chdir_verify_path __P((char *, char *));
    145  1.31  christos static int		ReadMakefile __P((ClientData, ClientData));
    146  1.31  christos static void		usage __P((void));
    147   1.1       cgd 
    148  1.13       cgd static char *curdir;			/* startup directory */
    149  1.13       cgd static char *objdir;			/* where we chdir'ed to */
    150   1.1       cgd 
    151   1.1       cgd /*-
    152   1.1       cgd  * MainParseArgs --
    153   1.1       cgd  *	Parse a given argument vector. Called from main() and from
    154   1.1       cgd  *	Main_ParseArgLine() when the .MAKEFLAGS target is used.
    155   1.1       cgd  *
    156   1.1       cgd  *	XXX: Deal with command line overriding .MAKEFLAGS in makefile
    157   1.1       cgd  *
    158   1.1       cgd  * Results:
    159   1.1       cgd  *	None
    160   1.1       cgd  *
    161   1.1       cgd  * Side Effects:
    162   1.1       cgd  *	Various global and local flags will be set depending on the flags
    163   1.1       cgd  *	given
    164   1.1       cgd  */
    165   1.1       cgd static void
    166   1.1       cgd MainParseArgs(argc, argv)
    167   1.1       cgd 	int argc;
    168   1.1       cgd 	char **argv;
    169   1.1       cgd {
    170   1.1       cgd 	extern int optind;
    171   1.1       cgd 	extern char *optarg;
    172  1.47   hubertf 	char *p;
    173  1.47   hubertf 	int c;
    174  1.22  christos 	int forceJobs = 0;
    175   1.1       cgd 
    176   1.1       cgd 	optind = 1;	/* since we're called more than once */
    177  1.21  christos #ifdef REMOTE
    178  1.31  christos # define OPTFLAGS "BD:I:L:PSV:d:ef:ij:km:nqrst"
    179  1.13       cgd #else
    180  1.31  christos # define OPTFLAGS "BD:I:PSV:d:ef:ij:km:nqrst"
    181  1.13       cgd #endif
    182  1.39     lukem rearg:	while((c = getopt(argc, argv, OPTFLAGS)) != -1) {
    183   1.1       cgd 		switch(c) {
    184   1.1       cgd 		case 'D':
    185   1.1       cgd 			Var_Set(optarg, "1", VAR_GLOBAL);
    186   1.1       cgd 			Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
    187   1.1       cgd 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    188   1.1       cgd 			break;
    189   1.1       cgd 		case 'I':
    190   1.1       cgd 			Parse_AddIncludeDir(optarg);
    191   1.1       cgd 			Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
    192   1.1       cgd 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    193   1.1       cgd 			break;
    194  1.31  christos 		case 'V':
    195  1.31  christos 			printVars = TRUE;
    196  1.31  christos 			(void)Lst_AtEnd(variables, (ClientData)optarg);
    197  1.31  christos 			Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
    198  1.31  christos 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    199  1.31  christos 			break;
    200  1.13       cgd 		case 'B':
    201  1.13       cgd 			compatMake = TRUE;
    202  1.13       cgd 			break;
    203  1.21  christos #ifdef REMOTE
    204   1.1       cgd 		case 'L':
    205  1.47   hubertf 			maxLocal = strtol(optarg, &p, 0);
    206  1.47   hubertf 			if (*p != '\0' || maxLocal < 1) {
    207  1.46   hubertf 				(void) fprintf(stderr, "make: illegal argument to -L -- must be positive integer!\n");
    208  1.46   hubertf 				exit(1);
    209  1.46   hubertf 			}
    210   1.1       cgd 			Var_Append(MAKEFLAGS, "-L", VAR_GLOBAL);
    211   1.1       cgd 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    212   1.1       cgd 			break;
    213  1.21  christos #endif
    214   1.1       cgd 		case 'P':
    215   1.1       cgd 			usePipes = FALSE;
    216   1.1       cgd 			Var_Append(MAKEFLAGS, "-P", VAR_GLOBAL);
    217   1.1       cgd 			break;
    218   1.1       cgd 		case 'S':
    219   1.1       cgd 			keepgoing = FALSE;
    220   1.1       cgd 			Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
    221   1.1       cgd 			break;
    222   1.1       cgd 		case 'd': {
    223   1.1       cgd 			char *modules = optarg;
    224   1.1       cgd 
    225   1.1       cgd 			for (; *modules; ++modules)
    226   1.1       cgd 				switch (*modules) {
    227   1.1       cgd 				case 'A':
    228   1.1       cgd 					debug = ~0;
    229   1.1       cgd 					break;
    230   1.1       cgd 				case 'a':
    231   1.1       cgd 					debug |= DEBUG_ARCH;
    232   1.1       cgd 					break;
    233   1.1       cgd 				case 'c':
    234   1.1       cgd 					debug |= DEBUG_COND;
    235   1.1       cgd 					break;
    236   1.1       cgd 				case 'd':
    237   1.1       cgd 					debug |= DEBUG_DIR;
    238   1.1       cgd 					break;
    239  1.13       cgd 				case 'f':
    240  1.13       cgd 					debug |= DEBUG_FOR;
    241  1.13       cgd 					break;
    242   1.1       cgd 				case 'g':
    243   1.1       cgd 					if (modules[1] == '1') {
    244   1.1       cgd 						debug |= DEBUG_GRAPH1;
    245   1.1       cgd 						++modules;
    246   1.1       cgd 					}
    247   1.1       cgd 					else if (modules[1] == '2') {
    248   1.1       cgd 						debug |= DEBUG_GRAPH2;
    249   1.1       cgd 						++modules;
    250   1.1       cgd 					}
    251   1.1       cgd 					break;
    252   1.1       cgd 				case 'j':
    253   1.1       cgd 					debug |= DEBUG_JOB;
    254   1.1       cgd 					break;
    255   1.1       cgd 				case 'm':
    256   1.1       cgd 					debug |= DEBUG_MAKE;
    257   1.1       cgd 					break;
    258   1.1       cgd 				case 's':
    259   1.1       cgd 					debug |= DEBUG_SUFF;
    260   1.1       cgd 					break;
    261   1.1       cgd 				case 't':
    262   1.1       cgd 					debug |= DEBUG_TARG;
    263   1.1       cgd 					break;
    264   1.1       cgd 				case 'v':
    265   1.1       cgd 					debug |= DEBUG_VAR;
    266   1.1       cgd 					break;
    267   1.1       cgd 				default:
    268   1.1       cgd 					(void)fprintf(stderr,
    269   1.1       cgd 				"make: illegal argument to d option -- %c\n",
    270   1.1       cgd 					    *modules);
    271   1.1       cgd 					usage();
    272   1.1       cgd 				}
    273   1.1       cgd 			Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
    274   1.1       cgd 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    275   1.1       cgd 			break;
    276   1.1       cgd 		}
    277   1.1       cgd 		case 'e':
    278   1.1       cgd 			checkEnvFirst = TRUE;
    279   1.1       cgd 			Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
    280   1.1       cgd 			break;
    281   1.1       cgd 		case 'f':
    282   1.1       cgd 			(void)Lst_AtEnd(makefiles, (ClientData)optarg);
    283   1.1       cgd 			break;
    284   1.1       cgd 		case 'i':
    285   1.1       cgd 			ignoreErrors = TRUE;
    286   1.1       cgd 			Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
    287   1.1       cgd 			break;
    288   1.1       cgd 		case 'j':
    289  1.22  christos 			forceJobs = TRUE;
    290  1.47   hubertf 			maxJobs = strtol(optarg, &p, 0);
    291  1.47   hubertf 			if (*p != '\0' || maxJobs < 1) {
    292  1.46   hubertf 				(void) fprintf(stderr, "make: illegal argument to -j -- must be positive integer!\n");
    293  1.46   hubertf 				exit(1);
    294  1.46   hubertf 			}
    295  1.21  christos #ifndef REMOTE
    296  1.21  christos 			maxLocal = maxJobs;
    297  1.21  christos #endif
    298   1.9       jtc 			Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
    299   1.1       cgd 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    300   1.1       cgd 			break;
    301   1.1       cgd 		case 'k':
    302   1.1       cgd 			keepgoing = TRUE;
    303   1.1       cgd 			Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
    304   1.1       cgd 			break;
    305  1.25  christos 		case 'm':
    306  1.35       cjs 			mkIncPath = TRUE;
    307  1.36       gwr 			(void) Dir_AddDir(sysIncPath, optarg);
    308  1.25  christos 			Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
    309  1.25  christos 			Var_Append(MAKEFLAGS, optarg, VAR_GLOBAL);
    310  1.25  christos 			break;
    311   1.1       cgd 		case 'n':
    312   1.1       cgd 			noExecute = TRUE;
    313   1.1       cgd 			Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
    314   1.1       cgd 			break;
    315   1.1       cgd 		case 'q':
    316   1.1       cgd 			queryFlag = TRUE;
    317   1.1       cgd 			/* Kind of nonsensical, wot? */
    318   1.1       cgd 			Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL);
    319   1.1       cgd 			break;
    320   1.1       cgd 		case 'r':
    321   1.1       cgd 			noBuiltins = TRUE;
    322   1.1       cgd 			Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL);
    323   1.1       cgd 			break;
    324   1.1       cgd 		case 's':
    325   1.1       cgd 			beSilent = TRUE;
    326   1.1       cgd 			Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL);
    327   1.1       cgd 			break;
    328   1.1       cgd 		case 't':
    329   1.1       cgd 			touchFlag = TRUE;
    330   1.1       cgd 			Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
    331   1.1       cgd 			break;
    332   1.1       cgd 		default:
    333   1.1       cgd 		case '?':
    334   1.1       cgd 			usage();
    335   1.1       cgd 		}
    336   1.1       cgd 	}
    337   1.1       cgd 
    338  1.22  christos 	/*
    339  1.22  christos 	 * Be compatible if user did not specify -j and did not explicitly
    340  1.22  christos 	 * turned compatibility on
    341  1.22  christos 	 */
    342  1.22  christos 	if (!compatMake && !forceJobs)
    343  1.22  christos 		compatMake = TRUE;
    344  1.22  christos 
    345   1.1       cgd 	oldVars = TRUE;
    346   1.1       cgd 
    347   1.1       cgd 	/*
    348   1.1       cgd 	 * See if the rest of the arguments are variable assignments and
    349   1.1       cgd 	 * perform them if so. Else take them to be targets and stuff them
    350   1.1       cgd 	 * on the end of the "create" list.
    351   1.1       cgd 	 */
    352   1.1       cgd 	for (argv += optind, argc -= optind; *argv; ++argv, --argc)
    353   1.1       cgd 		if (Parse_IsVar(*argv))
    354   1.1       cgd 			Parse_DoVar(*argv, VAR_CMD);
    355   1.1       cgd 		else {
    356   1.1       cgd 			if (!**argv)
    357   1.1       cgd 				Punt("illegal (null) argument.");
    358   1.1       cgd 			if (**argv == '-') {
    359  1.13       cgd 				if ((*argv)[1])
    360  1.13       cgd 					optind = 0;     /* -flag... */
    361  1.13       cgd 				else
    362  1.13       cgd 					optind = 1;     /* - */
    363   1.1       cgd 				goto rearg;
    364   1.1       cgd 			}
    365  1.30  christos 			(void)Lst_AtEnd(create, (ClientData)estrdup(*argv));
    366   1.1       cgd 		}
    367   1.1       cgd }
    368   1.1       cgd 
    369   1.1       cgd /*-
    370   1.1       cgd  * Main_ParseArgLine --
    371   1.1       cgd  *  	Used by the parse module when a .MFLAGS or .MAKEFLAGS target
    372   1.1       cgd  *	is encountered and by main() when reading the .MAKEFLAGS envariable.
    373   1.1       cgd  *	Takes a line of arguments and breaks it into its
    374   1.1       cgd  * 	component words and passes those words and the number of them to the
    375   1.1       cgd  *	MainParseArgs function.
    376   1.1       cgd  *	The line should have all its leading whitespace removed.
    377   1.1       cgd  *
    378   1.1       cgd  * Results:
    379   1.1       cgd  *	None
    380   1.1       cgd  *
    381   1.1       cgd  * Side Effects:
    382   1.1       cgd  *	Only those that come from the various arguments.
    383   1.1       cgd  */
    384   1.1       cgd void
    385   1.1       cgd Main_ParseArgLine(line)
    386   1.1       cgd 	char *line;			/* Line to fracture */
    387   1.1       cgd {
    388   1.1       cgd 	char **argv;			/* Manufactured argument vector */
    389   1.1       cgd 	int argc;			/* Number of arguments in argv */
    390  1.40  christos 	char *args;			/* Space used by the args */
    391  1.40  christos 	char *buf, *p1;
    392  1.40  christos 	char *argv0 = Var_Value(".MAKE", VAR_GLOBAL, &p1);
    393  1.48  christos 	size_t len;
    394   1.1       cgd 
    395   1.1       cgd 	if (line == NULL)
    396   1.1       cgd 		return;
    397  1.13       cgd 	for (; *line == ' '; ++line)
    398  1.13       cgd 		continue;
    399   1.1       cgd 	if (!*line)
    400   1.1       cgd 		return;
    401   1.1       cgd 
    402  1.48  christos 	buf = emalloc(len = strlen(line) + strlen(argv0) + 2);
    403  1.48  christos 	(void)snprintf(buf, len, "%s %s", argv0, line);
    404  1.40  christos 	if (p1)
    405  1.40  christos 		free(p1);
    406  1.40  christos 
    407  1.41  christos 	argv = brk_string(buf, &argc, TRUE, &args);
    408  1.45     itohy 	free(buf);
    409   1.1       cgd 	MainParseArgs(argc, argv);
    410  1.40  christos 
    411  1.40  christos 	free(args);
    412  1.40  christos 	free(argv);
    413   1.1       cgd }
    414   1.1       cgd 
    415  1.31  christos char *
    416  1.31  christos chdir_verify_path(path, obpath)
    417  1.31  christos 	char *path;
    418  1.31  christos 	char *obpath;
    419  1.31  christos {
    420  1.31  christos 	struct stat sb;
    421  1.31  christos 
    422  1.51       sjg 	if (strchr(path, '$') != 0) {
    423  1.51       sjg 		path = Var_Subst(NULL, path, VAR_GLOBAL, 0);
    424  1.51       sjg 	}
    425  1.31  christos 	if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
    426  1.31  christos 		if (chdir(path)) {
    427  1.31  christos 			(void)fprintf(stderr, "make warning: %s: %s.\n",
    428  1.31  christos 				      path, strerror(errno));
    429  1.31  christos 			return 0;
    430  1.31  christos 		}
    431  1.31  christos 		else {
    432  1.31  christos 			if (path[0] != '/') {
    433  1.31  christos 				(void) snprintf(obpath, MAXPATHLEN, "%s/%s",
    434  1.31  christos 						curdir, path);
    435  1.31  christos 				return obpath;
    436  1.31  christos 			}
    437  1.31  christos 			else
    438  1.31  christos 				return path;
    439  1.31  christos 		}
    440  1.31  christos 	}
    441  1.31  christos 
    442  1.31  christos 	return 0;
    443  1.31  christos }
    444  1.31  christos 
    445  1.31  christos 
    446   1.1       cgd /*-
    447   1.1       cgd  * main --
    448   1.1       cgd  *	The main function, for obvious reasons. Initializes variables
    449   1.1       cgd  *	and a few modules, then parses the arguments give it in the
    450   1.1       cgd  *	environment and on the command line. Reads the system makefile
    451   1.1       cgd  *	followed by either Makefile, makefile or the file given by the
    452   1.1       cgd  *	-f argument. Sets the .MAKEFLAGS PMake variable based on all the
    453   1.1       cgd  *	flags it has received by then uses either the Make or the Compat
    454   1.1       cgd  *	module to create the initial list of targets.
    455   1.1       cgd  *
    456   1.1       cgd  * Results:
    457   1.1       cgd  *	If -q was given, exits -1 if anything was out-of-date. Else it exits
    458   1.1       cgd  *	0.
    459   1.1       cgd  *
    460   1.1       cgd  * Side Effects:
    461   1.1       cgd  *	The program exits when done. Targets are created. etc. etc. etc.
    462   1.1       cgd  */
    463  1.13       cgd int
    464   1.1       cgd main(argc, argv)
    465   1.1       cgd 	int argc;
    466   1.1       cgd 	char **argv;
    467   1.1       cgd {
    468   1.1       cgd 	Lst targs;	/* target nodes to create -- passed to Make_Init */
    469  1.13       cgd 	Boolean outOfDate = TRUE; 	/* FALSE if all targets up to date */
    470  1.13       cgd 	struct stat sb, sa;
    471  1.31  christos 	char *p, *p1, *path, *pathp, *pwd;
    472  1.13       cgd 	char mdpath[MAXPATHLEN + 1];
    473  1.13       cgd 	char obpath[MAXPATHLEN + 1];
    474  1.13       cgd 	char cdpath[MAXPATHLEN + 1];
    475  1.18  christos     	char *machine = getenv("MACHINE");
    476  1.33  christos 	char *machine_arch = getenv("MACHINE_ARCH");
    477  1.25  christos 	Lst sysMkPath;			/* Path of sys.mk */
    478  1.25  christos 	char *cp = NULL, *start;
    479  1.25  christos 					/* avoid faults on read-only strings */
    480  1.25  christos 	static char syspath[] = _PATH_DEFSYSPATH;
    481  1.13       cgd 
    482  1.21  christos #ifdef RLIMIT_NOFILE
    483  1.21  christos 	/*
    484  1.21  christos 	 * get rid of resource limit on file descriptors
    485  1.21  christos 	 */
    486  1.21  christos 	{
    487  1.21  christos 		struct rlimit rl;
    488  1.21  christos 		if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
    489  1.21  christos 		    rl.rlim_cur != rl.rlim_max) {
    490  1.21  christos 			rl.rlim_cur = rl.rlim_max;
    491  1.21  christos 			(void) setrlimit(RLIMIT_NOFILE, &rl);
    492  1.21  christos 		}
    493  1.21  christos 	}
    494  1.21  christos #endif
    495  1.13       cgd 	/*
    496  1.13       cgd 	 * Find where we are and take care of PWD for the automounter...
    497  1.13       cgd 	 * All this code is so that we know where we are when we start up
    498  1.13       cgd 	 * on a different machine with pmake.
    499  1.13       cgd 	 */
    500  1.13       cgd 	curdir = cdpath;
    501  1.16   mycroft 	if (getcwd(curdir, MAXPATHLEN) == NULL) {
    502  1.16   mycroft 		(void)fprintf(stderr, "make: %s.\n", strerror(errno));
    503  1.13       cgd 		exit(2);
    504  1.13       cgd 	}
    505  1.13       cgd 
    506  1.13       cgd 	if (stat(curdir, &sa) == -1) {
    507  1.13       cgd 	    (void)fprintf(stderr, "make: %s: %s.\n",
    508  1.13       cgd 			  curdir, strerror(errno));
    509  1.13       cgd 	    exit(2);
    510  1.13       cgd 	}
    511  1.13       cgd 
    512  1.13       cgd 	if ((pwd = getenv("PWD")) != NULL) {
    513  1.13       cgd 	    if (stat(pwd, &sb) == 0 && sa.st_ino == sb.st_ino &&
    514  1.31  christos 		sa.st_dev == sb.st_dev)
    515  1.13       cgd 		(void) strcpy(curdir, pwd);
    516  1.13       cgd 	}
    517  1.13       cgd 
    518  1.17       gwr 	/*
    519  1.17       gwr 	 * Get the name of this type of MACHINE from utsname
    520  1.17       gwr 	 * so we can share an executable for similar machines.
    521  1.17       gwr 	 * (i.e. m68k: amiga hp300, mac68k, sun3, ...)
    522  1.17       gwr 	 *
    523  1.33  christos 	 * Note that both MACHINE and MACHINE_ARCH are decided at
    524  1.33  christos 	 * run-time.
    525  1.17       gwr 	 */
    526  1.34       gwr 	if (!machine) {
    527  1.34       gwr #ifndef MAKE_BOOTSTRAP
    528  1.31  christos 	    struct utsname utsname;
    529  1.31  christos 
    530  1.23  christos 	    if (uname(&utsname) == -1) {
    531  1.18  christos 		    perror("make: uname");
    532  1.18  christos 		    exit(2);
    533  1.18  christos 	    }
    534  1.18  christos 	    machine = utsname.machine;
    535  1.26  christos #else
    536  1.26  christos 	    machine = MACHINE;
    537  1.26  christos #endif
    538  1.17       gwr 	}
    539   1.1       cgd 
    540  1.33  christos 	if (!machine_arch) {
    541  1.33  christos #ifndef MACHINE_ARCH
    542  1.43  wsanchez #ifdef __ARCHITECTURE__
    543  1.43  wsanchez             machine_arch = __ARCHITECTURE__;
    544  1.43  wsanchez #else
    545  1.33  christos 	    machine_arch = "unknown";	/* XXX: no uname -p yet */
    546  1.43  wsanchez #endif
    547  1.33  christos #else
    548  1.33  christos 	    machine_arch = MACHINE_ARCH;
    549  1.33  christos #endif
    550  1.33  christos 	}
    551  1.33  christos 
    552   1.1       cgd 	/*
    553  1.51       sjg 	 * Just in case MAKEOBJDIR wants us to do something tricky.
    554  1.51       sjg 	 */
    555  1.51       sjg 	Var_Init();		/* Initialize the lists of variables for
    556  1.51       sjg 				 * parsing arguments */
    557  1.51       sjg 	Var_Set(".CURDIR", curdir, VAR_GLOBAL);
    558  1.51       sjg 	Var_Set("MACHINE", machine, VAR_GLOBAL);
    559  1.51       sjg 	Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL);
    560  1.51       sjg 
    561  1.51       sjg 	/*
    562  1.31  christos 	 * If the MAKEOBJDIR (or by default, the _PATH_OBJDIR) directory
    563  1.31  christos 	 * exists, change into it and build there.  (If a .${MACHINE} suffix
    564  1.31  christos 	 * exists, use that directory instead).
    565  1.31  christos 	 * Otherwise check MAKEOBJDIRPREFIX`cwd` (or by default,
    566  1.31  christos 	 * _PATH_OBJDIRPREFIX`cwd`) and build there if it exists.
    567  1.31  christos 	 * If all fails, use the current directory to build.
    568  1.31  christos 	 *
    569  1.31  christos 	 * Once things are initted,
    570  1.31  christos 	 * have to add the original directory to the search path,
    571   1.1       cgd 	 * and modify the paths for the Makefiles apropriately.  The
    572   1.1       cgd 	 * current directory is also placed as a variable for make scripts.
    573   1.1       cgd 	 */
    574  1.31  christos 	if (!(pathp = getenv("MAKEOBJDIRPREFIX"))) {
    575  1.31  christos 		if (!(path = getenv("MAKEOBJDIR"))) {
    576  1.31  christos 			path = _PATH_OBJDIR;
    577  1.31  christos 			pathp = _PATH_OBJDIRPREFIX;
    578  1.31  christos 			(void) snprintf(mdpath, MAXPATHLEN, "%s.%s",
    579  1.31  christos 					path, machine);
    580  1.31  christos 			if (!(objdir = chdir_verify_path(mdpath, obpath)))
    581  1.31  christos 				if (!(objdir=chdir_verify_path(path, obpath))) {
    582  1.31  christos 					(void) snprintf(mdpath, MAXPATHLEN,
    583  1.31  christos 							"%s%s", pathp, curdir);
    584  1.31  christos 					if (!(objdir=chdir_verify_path(mdpath,
    585  1.31  christos 								       obpath)))
    586  1.31  christos 						objdir = curdir;
    587  1.31  christos 				}
    588  1.31  christos 		}
    589  1.31  christos 		else if (!(objdir = chdir_verify_path(path, obpath)))
    590  1.13       cgd 			objdir = curdir;
    591   1.4       cgd 	}
    592  1.13       cgd 	else {
    593  1.31  christos 		(void) snprintf(mdpath, MAXPATHLEN, "%s%s", pathp, curdir);
    594  1.31  christos 		if (!(objdir = chdir_verify_path(mdpath, obpath)))
    595  1.13       cgd 			objdir = curdir;
    596   1.1       cgd 	}
    597   1.1       cgd 
    598  1.13       cgd 	setenv("PWD", objdir, 1);
    599  1.13       cgd 
    600   1.1       cgd 	create = Lst_Init(FALSE);
    601   1.1       cgd 	makefiles = Lst_Init(FALSE);
    602  1.31  christos 	printVars = FALSE;
    603  1.31  christos 	variables = Lst_Init(FALSE);
    604   1.1       cgd 	beSilent = FALSE;		/* Print commands as executed */
    605   1.1       cgd 	ignoreErrors = FALSE;		/* Pay attention to non-zero returns */
    606   1.1       cgd 	noExecute = FALSE;		/* Execute all commands */
    607   1.1       cgd 	keepgoing = FALSE;		/* Stop on error */
    608   1.1       cgd 	allPrecious = FALSE;		/* Remove targets when interrupted */
    609   1.1       cgd 	queryFlag = FALSE;		/* This is not just a check-run */
    610   1.1       cgd 	noBuiltins = FALSE;		/* Read the built-in rules */
    611   1.1       cgd 	touchFlag = FALSE;		/* Actually update targets */
    612   1.1       cgd 	usePipes = TRUE;		/* Catch child output in pipes */
    613   1.1       cgd 	debug = 0;			/* No debug verbosity, please. */
    614   1.1       cgd 	jobsRunning = FALSE;
    615   1.1       cgd 
    616  1.21  christos 	maxLocal = DEFMAXLOCAL;		/* Set default local max concurrency */
    617  1.21  christos #ifdef REMOTE
    618   1.1       cgd 	maxJobs = DEFMAXJOBS;		/* Set default max concurrency */
    619  1.13       cgd #else
    620  1.21  christos 	maxJobs = maxLocal;
    621  1.13       cgd #endif
    622  1.21  christos 	compatMake = FALSE;		/* No compat mode */
    623  1.31  christos 
    624  1.13       cgd 
    625   1.1       cgd 	/*
    626   1.1       cgd 	 * Initialize the parsing, directory and variable modules to prepare
    627   1.1       cgd 	 * for the reading of inclusion paths and variable settings on the
    628   1.1       cgd 	 * command line
    629   1.1       cgd 	 */
    630  1.36       gwr 
    631  1.36       gwr 	/*
    632  1.36       gwr 	 * Initialize directory structures so -I flags can be processed
    633  1.36       gwr 	 * correctly, if we have a different objdir, then let the directory
    634  1.36       gwr 	 * know our curdir.
    635  1.36       gwr 	 */
    636  1.36       gwr 	Dir_Init(curdir != objdir ? curdir : NULL);
    637   1.1       cgd 	Parse_Init();		/* Need to initialize the paths of #include
    638   1.1       cgd 				 * directories */
    639  1.13       cgd 	Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
    640   1.1       cgd 
    641   1.1       cgd 	/*
    642   1.1       cgd 	 * Initialize various variables.
    643   1.1       cgd 	 *	MAKE also gets this name, for compatibility
    644   1.1       cgd 	 *	.MAKEFLAGS gets set to the empty string just in case.
    645   1.1       cgd 	 *	MFLAGS also gets initialized empty, for compatibility.
    646   1.1       cgd 	 */
    647   1.1       cgd 	Var_Set("MAKE", argv[0], VAR_GLOBAL);
    648  1.41  christos 	Var_Set(".MAKE", argv[0], VAR_GLOBAL);
    649   1.1       cgd 	Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
    650   1.1       cgd 	Var_Set("MFLAGS", "", VAR_GLOBAL);
    651   1.1       cgd 
    652   1.1       cgd 	/*
    653   1.1       cgd 	 * First snag any flags out of the MAKE environment variable.
    654   1.1       cgd 	 * (Note this is *not* MAKEFLAGS since /bin/make uses that and it's
    655   1.1       cgd 	 * in a different format).
    656   1.1       cgd 	 */
    657   1.1       cgd #ifdef POSIX
    658   1.1       cgd 	Main_ParseArgLine(getenv("MAKEFLAGS"));
    659   1.1       cgd #else
    660   1.1       cgd 	Main_ParseArgLine(getenv("MAKE"));
    661   1.1       cgd #endif
    662  1.31  christos 
    663   1.1       cgd 	MainParseArgs(argc, argv);
    664   1.1       cgd 
    665   1.1       cgd 	/*
    666   1.1       cgd 	 * Initialize archive, target and suffix modules in preparation for
    667   1.1       cgd 	 * parsing the makefile(s)
    668   1.1       cgd 	 */
    669   1.1       cgd 	Arch_Init();
    670   1.1       cgd 	Targ_Init();
    671   1.1       cgd 	Suff_Init();
    672   1.1       cgd 
    673   1.1       cgd 	DEFAULT = NILGNODE;
    674   1.1       cgd 	(void)time(&now);
    675   1.1       cgd 
    676   1.1       cgd 	/*
    677   1.1       cgd 	 * Set up the .TARGETS variable to contain the list of targets to be
    678   1.1       cgd 	 * created. If none specified, make the variable empty -- the parser
    679   1.1       cgd 	 * will fill the thing in with the default or .MAIN target.
    680   1.1       cgd 	 */
    681   1.1       cgd 	if (!Lst_IsEmpty(create)) {
    682   1.1       cgd 		LstNode ln;
    683   1.1       cgd 
    684   1.1       cgd 		for (ln = Lst_First(create); ln != NILLNODE;
    685   1.1       cgd 		    ln = Lst_Succ(ln)) {
    686   1.1       cgd 			char *name = (char *)Lst_Datum(ln);
    687   1.1       cgd 
    688   1.1       cgd 			Var_Append(".TARGETS", name, VAR_GLOBAL);
    689   1.1       cgd 		}
    690   1.1       cgd 	} else
    691   1.1       cgd 		Var_Set(".TARGETS", "", VAR_GLOBAL);
    692   1.1       cgd 
    693  1.25  christos 
    694   1.1       cgd 	/*
    695  1.25  christos 	 * If no user-supplied system path was given (through the -m option)
    696  1.25  christos 	 * add the directories from the DEFSYSPATH (more than one may be given
    697  1.25  christos 	 * as dir1:...:dirn) to the system include path.
    698   1.1       cgd 	 */
    699  1.35       cjs 	if (!mkIncPath) {
    700  1.25  christos 		for (start = syspath; *start != '\0'; start = cp) {
    701  1.31  christos 			for (cp = start; *cp != '\0' && *cp != ':'; cp++)
    702  1.25  christos 				continue;
    703  1.25  christos 			if (*cp == '\0') {
    704  1.36       gwr 				(void) Dir_AddDir(sysIncPath, start);
    705  1.25  christos 			} else {
    706  1.25  christos 				*cp++ = '\0';
    707  1.36       gwr 				(void) Dir_AddDir(sysIncPath, start);
    708  1.25  christos 			}
    709  1.25  christos 		}
    710  1.25  christos 	}
    711  1.25  christos 
    712  1.25  christos 	/*
    713  1.25  christos 	 * Read in the built-in rules first, followed by the specified
    714  1.25  christos 	 * makefile, if it was (makefile != (char *) NULL), or the default
    715  1.25  christos 	 * Makefile and makefile, in that order, if it wasn't.
    716  1.25  christos 	 */
    717  1.25  christos 	if (!noBuiltins) {
    718  1.25  christos 		LstNode ln;
    719  1.25  christos 
    720  1.25  christos 		sysMkPath = Lst_Init (FALSE);
    721  1.25  christos 		Dir_Expand (_PATH_DEFSYSMK, sysIncPath, sysMkPath);
    722  1.25  christos 		if (Lst_IsEmpty(sysMkPath))
    723  1.25  christos 			Fatal("make: no system rules (%s).", _PATH_DEFSYSMK);
    724  1.25  christos 		ln = Lst_Find(sysMkPath, (ClientData)NULL, ReadMakefile);
    725  1.25  christos 		if (ln != NILLNODE)
    726  1.25  christos 			Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
    727  1.25  christos 	}
    728   1.1       cgd 
    729   1.1       cgd 	if (!Lst_IsEmpty(makefiles)) {
    730   1.1       cgd 		LstNode ln;
    731   1.1       cgd 
    732   1.1       cgd 		ln = Lst_Find(makefiles, (ClientData)NULL, ReadMakefile);
    733   1.1       cgd 		if (ln != NILLNODE)
    734   1.1       cgd 			Fatal("make: cannot open %s.", (char *)Lst_Datum(ln));
    735  1.31  christos 	} else if (!ReadMakefile("makefile", NULL))
    736  1.31  christos 		(void)ReadMakefile("Makefile", NULL);
    737   1.1       cgd 
    738  1.31  christos 	(void)ReadMakefile(".depend", NULL);
    739   1.1       cgd 
    740  1.14       jtc 	Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
    741  1.14       jtc 	if (p1)
    742  1.14       jtc 	    free(p1);
    743   1.1       cgd 
    744   1.1       cgd 	/* Install all the flags into the MAKE envariable. */
    745  1.14       jtc 	if (((p = Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1)) != NULL) && *p)
    746   1.1       cgd #ifdef POSIX
    747   1.1       cgd 		setenv("MAKEFLAGS", p, 1);
    748   1.1       cgd #else
    749   1.1       cgd 		setenv("MAKE", p, 1);
    750   1.1       cgd #endif
    751  1.14       jtc 	if (p1)
    752  1.14       jtc 	    free(p1);
    753   1.1       cgd 
    754   1.1       cgd 	/*
    755   1.1       cgd 	 * For compatibility, look at the directories in the VPATH variable
    756   1.1       cgd 	 * and add them to the search path, if the variable is defined. The
    757   1.1       cgd 	 * variable's value is in the same format as the PATH envariable, i.e.
    758   1.1       cgd 	 * <directory>:<directory>:<directory>...
    759   1.1       cgd 	 */
    760   1.1       cgd 	if (Var_Exists("VPATH", VAR_CMD)) {
    761   1.1       cgd 		char *vpath, *path, *cp, savec;
    762   1.1       cgd 		/*
    763   1.1       cgd 		 * GCC stores string constants in read-only memory, but
    764   1.1       cgd 		 * Var_Subst will want to write this thing, so store it
    765   1.1       cgd 		 * in an array
    766   1.1       cgd 		 */
    767   1.1       cgd 		static char VPATH[] = "${VPATH}";
    768   1.1       cgd 
    769  1.13       cgd 		vpath = Var_Subst(NULL, VPATH, VAR_CMD, FALSE);
    770   1.1       cgd 		path = vpath;
    771   1.1       cgd 		do {
    772   1.1       cgd 			/* skip to end of directory */
    773  1.13       cgd 			for (cp = path; *cp != ':' && *cp != '\0'; cp++)
    774  1.13       cgd 				continue;
    775   1.1       cgd 			/* Save terminator character so know when to stop */
    776   1.1       cgd 			savec = *cp;
    777   1.1       cgd 			*cp = '\0';
    778   1.1       cgd 			/* Add directory to search path */
    779  1.36       gwr 			(void) Dir_AddDir(dirSearchPath, path);
    780   1.1       cgd 			*cp = savec;
    781   1.1       cgd 			path = cp + 1;
    782   1.1       cgd 		} while (savec == ':');
    783   1.1       cgd 		(void)free((Address)vpath);
    784   1.1       cgd 	}
    785   1.1       cgd 
    786   1.1       cgd 	/*
    787   1.1       cgd 	 * Now that all search paths have been read for suffixes et al, it's
    788   1.1       cgd 	 * time to add the default search path to their lists...
    789   1.1       cgd 	 */
    790   1.1       cgd 	Suff_DoPaths();
    791  1.50   mycroft 
    792  1.50   mycroft 	/*
    793  1.50   mycroft 	 * Propagate attributes through :: dependency lists.
    794  1.50   mycroft 	 */
    795  1.50   mycroft 	Targ_Propagate();
    796   1.1       cgd 
    797   1.1       cgd 	/* print the initial graph, if the user requested it */
    798   1.1       cgd 	if (DEBUG(GRAPH1))
    799   1.1       cgd 		Targ_PrintGraph(1);
    800   1.1       cgd 
    801  1.31  christos 	/* print the values of any variables requested by the user */
    802  1.31  christos 	if (printVars) {
    803  1.31  christos 		LstNode ln;
    804  1.31  christos 
    805  1.31  christos 		for (ln = Lst_First(variables); ln != NILLNODE;
    806  1.31  christos 		    ln = Lst_Succ(ln)) {
    807  1.31  christos 			char *value = Var_Value((char *)Lst_Datum(ln),
    808  1.31  christos 					  VAR_GLOBAL, &p1);
    809  1.31  christos 
    810  1.31  christos 			printf("%s\n", value ? value : "");
    811  1.31  christos 			if (p1)
    812  1.31  christos 				free(p1);
    813  1.31  christos 		}
    814  1.31  christos 	}
    815  1.31  christos 
    816   1.1       cgd 	/*
    817   1.1       cgd 	 * Have now read the entire graph and need to make a list of targets
    818   1.1       cgd 	 * to create. If none was given on the command line, we consult the
    819   1.1       cgd 	 * parsing module to find the main target(s) to create.
    820   1.1       cgd 	 */
    821   1.1       cgd 	if (Lst_IsEmpty(create))
    822   1.1       cgd 		targs = Parse_MainName();
    823   1.1       cgd 	else
    824   1.1       cgd 		targs = Targ_FindList(create, TARG_CREATE);
    825   1.1       cgd 
    826  1.31  christos 	if (!compatMake && !printVars) {
    827   1.1       cgd 		/*
    828   1.1       cgd 		 * Initialize job module before traversing the graph, now that
    829   1.1       cgd 		 * any .BEGIN and .END targets have been read.  This is done
    830   1.1       cgd 		 * only if the -q flag wasn't given (to prevent the .BEGIN from
    831   1.1       cgd 		 * being executed should it exist).
    832   1.1       cgd 		 */
    833   1.1       cgd 		if (!queryFlag) {
    834   1.1       cgd 			if (maxLocal == -1)
    835   1.1       cgd 				maxLocal = maxJobs;
    836   1.1       cgd 			Job_Init(maxJobs, maxLocal);
    837   1.1       cgd 			jobsRunning = TRUE;
    838   1.1       cgd 		}
    839   1.1       cgd 
    840   1.1       cgd 		/* Traverse the graph, checking on all the targets */
    841   1.1       cgd 		outOfDate = Make_Run(targs);
    842  1.31  christos 	} else if (!printVars) {
    843   1.1       cgd 		/*
    844   1.1       cgd 		 * Compat_Init will take care of creating all the targets as
    845   1.1       cgd 		 * well as initializing the module.
    846   1.1       cgd 		 */
    847   1.1       cgd 		Compat_Run(targs);
    848  1.31  christos 	}
    849  1.31  christos 
    850  1.49   mycroft #ifdef CLEANUP
    851  1.14       jtc 	Lst_Destroy(targs, NOFREE);
    852  1.31  christos 	Lst_Destroy(variables, NOFREE);
    853  1.14       jtc 	Lst_Destroy(makefiles, NOFREE);
    854  1.14       jtc 	Lst_Destroy(create, (void (*) __P((ClientData))) free);
    855  1.49   mycroft #endif
    856  1.14       jtc 
    857   1.1       cgd 	/* print the graph now it's been processed if the user requested it */
    858   1.1       cgd 	if (DEBUG(GRAPH2))
    859   1.1       cgd 		Targ_PrintGraph(2);
    860   1.1       cgd 
    861  1.14       jtc 	Suff_End();
    862  1.14       jtc         Targ_End();
    863  1.14       jtc 	Arch_End();
    864  1.14       jtc 	Var_End();
    865  1.14       jtc 	Parse_End();
    866  1.14       jtc 	Dir_End();
    867  1.40  christos 	Job_End();
    868  1.14       jtc 
    869   1.1       cgd 	if (queryFlag && outOfDate)
    870  1.13       cgd 		return(1);
    871   1.1       cgd 	else
    872  1.13       cgd 		return(0);
    873   1.1       cgd }
    874   1.1       cgd 
    875   1.1       cgd /*-
    876   1.1       cgd  * ReadMakefile  --
    877   1.1       cgd  *	Open and parse the given makefile.
    878   1.1       cgd  *
    879   1.1       cgd  * Results:
    880   1.1       cgd  *	TRUE if ok. FALSE if couldn't open file.
    881   1.1       cgd  *
    882   1.1       cgd  * Side Effects:
    883   1.1       cgd  *	lots
    884   1.1       cgd  */
    885   1.1       cgd static Boolean
    886  1.31  christos ReadMakefile(p, q)
    887  1.31  christos 	ClientData p, q;
    888   1.1       cgd {
    889  1.31  christos 	char *fname = p;		/* makefile to read */
    890  1.25  christos 	extern Lst parseIncPath;
    891   1.1       cgd 	FILE *stream;
    892  1.48  christos 	size_t len = MAXPATHLEN;
    893  1.48  christos 	char *name, *path = emalloc(len);
    894   1.1       cgd 
    895   1.1       cgd 	if (!strcmp(fname, "-")) {
    896   1.1       cgd 		Parse_File("(stdin)", stdin);
    897   1.1       cgd 		Var_Set("MAKEFILE", "", VAR_GLOBAL);
    898   1.1       cgd 	} else {
    899  1.13       cgd 		if ((stream = fopen(fname, "r")) != NULL)
    900   1.1       cgd 			goto found;
    901   1.1       cgd 		/* if we've chdir'd, rebuild the path name */
    902  1.13       cgd 		if (curdir != objdir && *fname != '/') {
    903  1.48  christos 			size_t plen = strlen(curdir) + strlen(fname) + 2;
    904  1.48  christos 			if (len < plen)
    905  1.48  christos 				path = erealloc(path, len = 2 * plen);
    906  1.48  christos 
    907  1.48  christos 			(void)snprintf(path, len, "%s/%s", curdir, fname);
    908  1.13       cgd 			if ((stream = fopen(path, "r")) != NULL) {
    909   1.1       cgd 				fname = path;
    910   1.1       cgd 				goto found;
    911   1.1       cgd 			}
    912   1.1       cgd 		}
    913   1.1       cgd 		/* look in -I and system include directories. */
    914   1.1       cgd 		name = Dir_FindFile(fname, parseIncPath);
    915   1.1       cgd 		if (!name)
    916   1.1       cgd 			name = Dir_FindFile(fname, sysIncPath);
    917  1.48  christos 		if (!name || !(stream = fopen(name, "r"))) {
    918  1.48  christos 			free(path);
    919   1.1       cgd 			return(FALSE);
    920  1.48  christos 		}
    921   1.1       cgd 		fname = name;
    922   1.1       cgd 		/*
    923   1.1       cgd 		 * set the MAKEFILE variable desired by System V fans -- the
    924   1.1       cgd 		 * placement of the setting here means it gets set to the last
    925   1.1       cgd 		 * makefile specified, as it is set by SysV make.
    926   1.1       cgd 		 */
    927   1.1       cgd found:		Var_Set("MAKEFILE", fname, VAR_GLOBAL);
    928   1.1       cgd 		Parse_File(fname, stream);
    929   1.1       cgd 		(void)fclose(stream);
    930   1.1       cgd 	}
    931  1.48  christos 	free(path);
    932   1.1       cgd 	return(TRUE);
    933  1.29  christos }
    934  1.29  christos 
    935  1.29  christos /*-
    936  1.29  christos  * Cmd_Exec --
    937  1.29  christos  *	Execute the command in cmd, and return the output of that command
    938  1.29  christos  *	in a string.
    939  1.29  christos  *
    940  1.29  christos  * Results:
    941  1.29  christos  *	A string containing the output of the command, or the empty string
    942  1.29  christos  *	If err is not NULL, it contains the reason for the command failure
    943  1.29  christos  *
    944  1.29  christos  * Side Effects:
    945  1.29  christos  *	The string must be freed by the caller.
    946  1.29  christos  */
    947  1.29  christos char *
    948  1.29  christos Cmd_Exec(cmd, err)
    949  1.29  christos     char *cmd;
    950  1.29  christos     char **err;
    951  1.29  christos {
    952  1.29  christos     char	*args[4];   	/* Args for invoking the shell */
    953  1.29  christos     int 	fds[2];	    	/* Pipe streams */
    954  1.29  christos     int 	cpid;	    	/* Child PID */
    955  1.29  christos     int 	pid;	    	/* PID from wait() */
    956  1.29  christos     char	*res;		/* result */
    957  1.29  christos     int		status;		/* command exit status */
    958  1.29  christos     Buffer	buf;		/* buffer to store the result */
    959  1.29  christos     char	*cp;
    960  1.29  christos     int		cc;
    961  1.29  christos 
    962  1.29  christos 
    963  1.29  christos     *err = NULL;
    964  1.29  christos 
    965  1.29  christos     /*
    966  1.29  christos      * Set up arguments for shell
    967  1.29  christos      */
    968  1.29  christos     args[0] = "sh";
    969  1.29  christos     args[1] = "-c";
    970  1.29  christos     args[2] = cmd;
    971  1.29  christos     args[3] = NULL;
    972  1.29  christos 
    973  1.29  christos     /*
    974  1.29  christos      * Open a pipe for fetching its output
    975  1.29  christos      */
    976  1.29  christos     if (pipe(fds) == -1) {
    977  1.29  christos 	*err = "Couldn't create pipe for \"%s\"";
    978  1.29  christos 	goto bad;
    979  1.29  christos     }
    980  1.29  christos 
    981  1.29  christos     /*
    982  1.29  christos      * Fork
    983  1.29  christos      */
    984  1.29  christos     switch (cpid = vfork()) {
    985  1.29  christos     case 0:
    986  1.29  christos 	/*
    987  1.29  christos 	 * Close input side of pipe
    988  1.29  christos 	 */
    989  1.29  christos 	(void) close(fds[0]);
    990  1.29  christos 
    991  1.29  christos 	/*
    992  1.29  christos 	 * Duplicate the output stream to the shell's output, then
    993  1.29  christos 	 * shut the extra thing down. Note we don't fetch the error
    994  1.29  christos 	 * stream...why not? Why?
    995  1.29  christos 	 */
    996  1.29  christos 	(void) dup2(fds[1], 1);
    997  1.29  christos 	(void) close(fds[1]);
    998  1.31  christos 
    999  1.29  christos 	(void) execv("/bin/sh", args);
   1000  1.29  christos 	_exit(1);
   1001  1.29  christos 	/*NOTREACHED*/
   1002  1.29  christos 
   1003  1.29  christos     case -1:
   1004  1.29  christos 	*err = "Couldn't exec \"%s\"";
   1005  1.29  christos 	goto bad;
   1006  1.29  christos 
   1007  1.29  christos     default:
   1008  1.29  christos 	/*
   1009  1.29  christos 	 * No need for the writing half
   1010  1.29  christos 	 */
   1011  1.29  christos 	(void) close(fds[1]);
   1012  1.31  christos 
   1013  1.29  christos 	buf = Buf_Init (MAKE_BSIZE);
   1014  1.29  christos 
   1015  1.29  christos 	do {
   1016  1.29  christos 	    char   result[BUFSIZ];
   1017  1.29  christos 	    cc = read(fds[0], result, sizeof(result));
   1018  1.31  christos 	    if (cc > 0)
   1019  1.29  christos 		Buf_AddBytes(buf, cc, (Byte *) result);
   1020  1.29  christos 	}
   1021  1.29  christos 	while (cc > 0 || (cc == -1 && errno == EINTR));
   1022  1.29  christos 
   1023  1.29  christos 	/*
   1024  1.29  christos 	 * Close the input side of the pipe.
   1025  1.29  christos 	 */
   1026  1.29  christos 	(void) close(fds[0]);
   1027  1.29  christos 
   1028  1.29  christos 	/*
   1029  1.29  christos 	 * Wait for the process to exit.
   1030  1.29  christos 	 */
   1031  1.29  christos 	while(((pid = wait(&status)) != cpid) && (pid >= 0))
   1032  1.29  christos 	    continue;
   1033  1.29  christos 
   1034  1.29  christos 	res = (char *)Buf_GetAll (buf, &cc);
   1035  1.29  christos 	Buf_Destroy (buf, FALSE);
   1036  1.29  christos 
   1037  1.31  christos 	if (cc == 0)
   1038  1.29  christos 	    *err = "Couldn't read shell's output for \"%s\"";
   1039  1.29  christos 
   1040  1.29  christos 	if (status)
   1041  1.29  christos 	    *err = "\"%s\" returned non-zero status";
   1042  1.29  christos 
   1043  1.29  christos 	/*
   1044  1.29  christos 	 * Null-terminate the result, convert newlines to spaces and
   1045  1.29  christos 	 * install it in the variable.
   1046  1.29  christos 	 */
   1047  1.29  christos 	res[cc] = '\0';
   1048  1.44     itohy 	cp = &res[cc];
   1049  1.29  christos 
   1050  1.44     itohy 	if (cc > 0 && *--cp == '\n') {
   1051  1.29  christos 	    /*
   1052  1.29  christos 	     * A final newline is just stripped
   1053  1.29  christos 	     */
   1054  1.29  christos 	    *cp-- = '\0';
   1055  1.29  christos 	}
   1056  1.29  christos 	while (cp >= res) {
   1057  1.29  christos 	    if (*cp == '\n') {
   1058  1.29  christos 		*cp = ' ';
   1059  1.29  christos 	    }
   1060  1.29  christos 	    cp--;
   1061  1.29  christos 	}
   1062  1.29  christos 	break;
   1063  1.29  christos     }
   1064  1.29  christos     return res;
   1065  1.29  christos bad:
   1066  1.29  christos     res = emalloc(1);
   1067  1.29  christos     *res = '\0';
   1068  1.29  christos     return res;
   1069   1.1       cgd }
   1070   1.1       cgd 
   1071   1.1       cgd /*-
   1072   1.1       cgd  * Error --
   1073   1.1       cgd  *	Print an error message given its format.
   1074   1.1       cgd  *
   1075   1.1       cgd  * Results:
   1076   1.1       cgd  *	None.
   1077   1.1       cgd  *
   1078   1.1       cgd  * Side Effects:
   1079   1.1       cgd  *	The message is printed.
   1080   1.1       cgd  */
   1081   1.1       cgd /* VARARGS */
   1082   1.1       cgd void
   1083  1.32  christos #ifdef __STDC__
   1084  1.13       cgd Error(char *fmt, ...)
   1085  1.13       cgd #else
   1086   1.1       cgd Error(va_alist)
   1087   1.1       cgd 	va_dcl
   1088  1.13       cgd #endif
   1089   1.1       cgd {
   1090   1.1       cgd 	va_list ap;
   1091  1.32  christos #ifdef __STDC__
   1092  1.13       cgd 	va_start(ap, fmt);
   1093  1.13       cgd #else
   1094   1.1       cgd 	char *fmt;
   1095   1.1       cgd 
   1096   1.1       cgd 	va_start(ap);
   1097   1.1       cgd 	fmt = va_arg(ap, char *);
   1098  1.13       cgd #endif
   1099   1.1       cgd 	(void)vfprintf(stderr, fmt, ap);
   1100   1.1       cgd 	va_end(ap);
   1101   1.1       cgd 	(void)fprintf(stderr, "\n");
   1102   1.1       cgd 	(void)fflush(stderr);
   1103   1.1       cgd }
   1104   1.1       cgd 
   1105   1.1       cgd /*-
   1106   1.1       cgd  * Fatal --
   1107   1.1       cgd  *	Produce a Fatal error message. If jobs are running, waits for them
   1108   1.1       cgd  *	to finish.
   1109   1.1       cgd  *
   1110   1.1       cgd  * Results:
   1111   1.1       cgd  *	None
   1112   1.1       cgd  *
   1113   1.1       cgd  * Side Effects:
   1114   1.1       cgd  *	The program exits
   1115   1.1       cgd  */
   1116   1.1       cgd /* VARARGS */
   1117   1.1       cgd void
   1118  1.32  christos #ifdef __STDC__
   1119  1.13       cgd Fatal(char *fmt, ...)
   1120  1.13       cgd #else
   1121   1.1       cgd Fatal(va_alist)
   1122   1.1       cgd 	va_dcl
   1123  1.13       cgd #endif
   1124   1.1       cgd {
   1125   1.1       cgd 	va_list ap;
   1126  1.32  christos #ifdef __STDC__
   1127  1.13       cgd 	va_start(ap, fmt);
   1128  1.13       cgd #else
   1129   1.1       cgd 	char *fmt;
   1130   1.1       cgd 
   1131  1.13       cgd 	va_start(ap);
   1132  1.13       cgd 	fmt = va_arg(ap, char *);
   1133  1.13       cgd #endif
   1134   1.1       cgd 	if (jobsRunning)
   1135   1.1       cgd 		Job_Wait();
   1136   1.1       cgd 
   1137   1.1       cgd 	(void)vfprintf(stderr, fmt, ap);
   1138   1.1       cgd 	va_end(ap);
   1139   1.1       cgd 	(void)fprintf(stderr, "\n");
   1140   1.1       cgd 	(void)fflush(stderr);
   1141   1.1       cgd 
   1142   1.1       cgd 	if (DEBUG(GRAPH2))
   1143   1.1       cgd 		Targ_PrintGraph(2);
   1144   1.1       cgd 	exit(2);		/* Not 1 so -q can distinguish error */
   1145   1.1       cgd }
   1146   1.1       cgd 
   1147   1.1       cgd /*
   1148   1.1       cgd  * Punt --
   1149   1.1       cgd  *	Major exception once jobs are being created. Kills all jobs, prints
   1150   1.1       cgd  *	a message and exits.
   1151   1.1       cgd  *
   1152   1.1       cgd  * Results:
   1153  1.31  christos  *	None
   1154   1.1       cgd  *
   1155   1.1       cgd  * Side Effects:
   1156   1.1       cgd  *	All children are killed indiscriminately and the program Lib_Exits
   1157   1.1       cgd  */
   1158   1.1       cgd /* VARARGS */
   1159   1.1       cgd void
   1160  1.32  christos #ifdef __STDC__
   1161  1.13       cgd Punt(char *fmt, ...)
   1162  1.13       cgd #else
   1163   1.1       cgd Punt(va_alist)
   1164   1.1       cgd 	va_dcl
   1165  1.13       cgd #endif
   1166   1.1       cgd {
   1167   1.1       cgd 	va_list ap;
   1168  1.32  christos #ifdef __STDC__
   1169  1.13       cgd 	va_start(ap, fmt);
   1170  1.13       cgd #else
   1171   1.1       cgd 	char *fmt;
   1172   1.1       cgd 
   1173   1.1       cgd 	va_start(ap);
   1174   1.1       cgd 	fmt = va_arg(ap, char *);
   1175  1.13       cgd #endif
   1176  1.13       cgd 
   1177  1.13       cgd 	(void)fprintf(stderr, "make: ");
   1178   1.1       cgd 	(void)vfprintf(stderr, fmt, ap);
   1179   1.1       cgd 	va_end(ap);
   1180   1.1       cgd 	(void)fprintf(stderr, "\n");
   1181   1.1       cgd 	(void)fflush(stderr);
   1182   1.1       cgd 
   1183   1.1       cgd 	DieHorribly();
   1184   1.1       cgd }
   1185   1.1       cgd 
   1186   1.1       cgd /*-
   1187   1.1       cgd  * DieHorribly --
   1188   1.1       cgd  *	Exit without giving a message.
   1189   1.1       cgd  *
   1190   1.1       cgd  * Results:
   1191   1.1       cgd  *	None
   1192   1.1       cgd  *
   1193   1.1       cgd  * Side Effects:
   1194   1.1       cgd  *	A big one...
   1195   1.1       cgd  */
   1196   1.1       cgd void
   1197   1.1       cgd DieHorribly()
   1198   1.1       cgd {
   1199   1.1       cgd 	if (jobsRunning)
   1200   1.1       cgd 		Job_AbortAll();
   1201   1.1       cgd 	if (DEBUG(GRAPH2))
   1202   1.1       cgd 		Targ_PrintGraph(2);
   1203   1.1       cgd 	exit(2);		/* Not 1, so -q can distinguish error */
   1204   1.1       cgd }
   1205   1.1       cgd 
   1206   1.1       cgd /*
   1207   1.1       cgd  * Finish --
   1208   1.1       cgd  *	Called when aborting due to errors in child shell to signal
   1209  1.31  christos  *	abnormal exit.
   1210   1.1       cgd  *
   1211   1.1       cgd  * Results:
   1212  1.31  christos  *	None
   1213   1.1       cgd  *
   1214   1.1       cgd  * Side Effects:
   1215   1.1       cgd  *	The program exits
   1216   1.1       cgd  */
   1217   1.1       cgd void
   1218   1.1       cgd Finish(errors)
   1219   1.1       cgd 	int errors;	/* number of errors encountered in Make_Make */
   1220   1.1       cgd {
   1221   1.1       cgd 	Fatal("%d error%s", errors, errors == 1 ? "" : "s");
   1222   1.1       cgd }
   1223   1.1       cgd 
   1224   1.1       cgd /*
   1225   1.1       cgd  * emalloc --
   1226   1.1       cgd  *	malloc, but die on error.
   1227   1.1       cgd  */
   1228  1.28  christos void *
   1229   1.1       cgd emalloc(len)
   1230  1.14       jtc 	size_t len;
   1231   1.1       cgd {
   1232  1.28  christos 	void *p;
   1233   1.1       cgd 
   1234  1.28  christos 	if ((p = malloc(len)) == NULL)
   1235  1.30  christos 		enomem();
   1236  1.30  christos 	return(p);
   1237  1.30  christos }
   1238  1.30  christos 
   1239  1.30  christos /*
   1240  1.31  christos  * estrdup --
   1241  1.30  christos  *	strdup, but die on error.
   1242  1.30  christos  */
   1243  1.30  christos char *
   1244  1.30  christos estrdup(str)
   1245  1.30  christos 	const char *str;
   1246  1.30  christos {
   1247  1.30  christos 	char *p;
   1248  1.30  christos 
   1249  1.30  christos 	if ((p = strdup(str)) == NULL)
   1250  1.27       jtc 		enomem();
   1251  1.27       jtc 	return(p);
   1252  1.27       jtc }
   1253  1.27       jtc 
   1254  1.27       jtc /*
   1255  1.27       jtc  * erealloc --
   1256  1.27       jtc  *	realloc, but die on error.
   1257  1.27       jtc  */
   1258  1.28  christos void *
   1259  1.27       jtc erealloc(ptr, size)
   1260  1.28  christos 	void *ptr;
   1261  1.27       jtc 	size_t size;
   1262  1.27       jtc {
   1263  1.28  christos 	if ((ptr = realloc(ptr, size)) == NULL)
   1264   1.1       cgd 		enomem();
   1265  1.28  christos 	return(ptr);
   1266   1.1       cgd }
   1267   1.1       cgd 
   1268   1.1       cgd /*
   1269   1.1       cgd  * enomem --
   1270   1.1       cgd  *	die when out of memory.
   1271   1.1       cgd  */
   1272  1.13       cgd void
   1273   1.1       cgd enomem()
   1274   1.1       cgd {
   1275   1.1       cgd 	(void)fprintf(stderr, "make: %s.\n", strerror(errno));
   1276   1.1       cgd 	exit(2);
   1277  1.21  christos }
   1278  1.21  christos 
   1279  1.21  christos /*
   1280  1.21  christos  * enunlink --
   1281  1.21  christos  *	Remove a file carefully, avoiding directories.
   1282  1.21  christos  */
   1283  1.21  christos int
   1284  1.21  christos eunlink(file)
   1285  1.21  christos 	const char *file;
   1286  1.21  christos {
   1287  1.21  christos 	struct stat st;
   1288  1.21  christos 
   1289  1.21  christos 	if (lstat(file, &st) == -1)
   1290  1.21  christos 		return -1;
   1291  1.21  christos 
   1292  1.21  christos 	if (S_ISDIR(st.st_mode)) {
   1293  1.21  christos 		errno = EISDIR;
   1294  1.21  christos 		return -1;
   1295  1.21  christos 	}
   1296  1.21  christos 	return unlink(file);
   1297   1.1       cgd }
   1298   1.1       cgd 
   1299   1.1       cgd /*
   1300   1.1       cgd  * usage --
   1301   1.1       cgd  *	exit with usage message
   1302   1.1       cgd  */
   1303  1.13       cgd static void
   1304   1.1       cgd usage()
   1305   1.1       cgd {
   1306   1.1       cgd 	(void)fprintf(stderr,
   1307  1.31  christos "usage: make [-Beiknqrst] [-D variable] [-d flags] [-f makefile ]\n\
   1308  1.31  christos             [-I directory] [-j max_jobs] [-m directory] [-V variable]\n\
   1309  1.31  christos             [variable=value] [target ...]\n");
   1310   1.1       cgd 	exit(2);
   1311  1.14       jtc }
   1312  1.14       jtc 
   1313  1.14       jtc 
   1314  1.14       jtc int
   1315  1.14       jtc PrintAddr(a, b)
   1316  1.14       jtc     ClientData a;
   1317  1.14       jtc     ClientData b;
   1318  1.14       jtc {
   1319  1.14       jtc     printf("%lx ", (unsigned long) a);
   1320  1.14       jtc     return b ? 0 : 0;
   1321   1.1       cgd }
   1322