 @@ -1,14 +1,14 @@
-/*	$NetBSD: compat.c,v 1.168 2020/10/24 04:40:45 rillig Exp $	*/
+/*	$NetBSD: compat.c,v 1.169 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -86,44 +86,44 @@
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <errno.h>
 #include <signal.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "metachar.h"
 #include "pathnames.h"
 /*	"@(#)compat.c	8.2 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: compat.c,v 1.168 2020/10/24 04:40:45 rillig Exp $");
+MAKE_RCSID("$NetBSD: compat.c,v 1.169 2020/10/26 21:34:10 rillig Exp $");
 static GNode *curTarg = NULL;
 static pid_t compatChild;
 static int compatSigno;
 /*
  * CompatDeleteTarget -- delete a failed, interrupted, or otherwise
  * duffed target if not inhibited by .PRECIOUS.
  */
 static void
 CompatDeleteTarget(GNode *gn)
+{
     if (gn != NULL && !Targ_Precious(gn)) {
 	char *file_freeIt;
 	const char *file = Var_Value(TARGET, gn, &file_freeIt);
-	if (!noExecute && eunlink(file) != -1) {
+	if (!opts.noExecute && eunlink(file) != -1) {
 	    Error("*** %s removed", file);
+	}
 	bmake_free(file_freeIt);
+    }
+}
 /* Interrupt the creation of the current target and remove it if it ain't
  * precious. Then exit.
+ *
  * If .INTERRUPT exists, its commands are run first WITH INTERRUPTS IGNORED.
+ *
  * XXX: is .PRECIOUS supposed to inhibit .INTERRUPT? I doubt it, but I've
 @@ -410,27 +410,27 @@ Compat_RunCommand(const char *cmdp, GNod
 	status = WTERMSIG(reason);		/* signaled */
 	printf("*** Signal %d", status);
+    }
     if (!WIFEXITED(reason) || status != 0) {
 	if (errCheck) {
 #ifdef USE_META
 	    if (useMeta) {
 		meta_job_error(NULL, gn, 0, status);
+	    }
 #endif
 	    gn->made = ERROR;
-	    if (keepgoing) {
+	    if (opts.keepgoing) {
 		/* Abort the current target, but let others continue. */
 		printf(" (continuing)\n");
 	    } else {
 		printf("\n");
+	    }
 	    if (deleteOnError)
 		CompatDeleteTarget(gn);
 	} else {
 	    /*
 	     * Continue executing commands for this target.
 	     * If we return 0, this will happen...
 	     */
 	    printf(" (ignored)\n");
 @@ -516,52 +516,52 @@ Compat_Make(GNode *gn, GNode *pgn)
 	 */
 	DEBUG1(MAKE, "Examining %s...", gn->name);
 	if (!Make_OODate(gn)) {
 	    gn->made = UPTODATE;
 	    DEBUG0(MAKE, "up-to-date.\n");
 	    goto cohorts;
 	} else
 	    DEBUG0(MAKE, "out-of-date.\n");
 	/*
 	 * If the user is just seeing if something is out-of-date, exit now
 	 * to tell him/her "yes".
 	 */
-	if (queryFlag) {
+	if (opts.queryFlag) {
 	    exit(1);
+	}
 	/*
 	 * We need to be re-made. We also have to make sure we've got a $?
 	 * variable. To be nice, we also define the $> variable using
 	 * Make_DoAllVar().
 	 */
 	Make_DoAllVar(gn);
 	/*
 	 * Alter our type to tell if errors should be ignored or things
 	 * should not be printed so CompatRunCommand knows what to do.
 	 */
 	if (Targ_Ignore(gn))
 	    gn->type |= OP_IGNORE;
 	if (Targ_Silent(gn))
 	    gn->type |= OP_SILENT;
 	if (Job_CheckCommands(gn, Fatal)) {
 	    /*
 	     * Our commands are ok, but we still have to worry about the -t
 	     * flag...
 	     */
-	    if (!touchFlag || (gn->type & OP_MAKE)) {
+	    if (!opts.touchFlag || (gn->type & OP_MAKE)) {
 		curTarg = gn;
 #ifdef USE_META
 		if (useMeta && !NoExecute(gn)) {
 		    meta_job_start(NULL, gn);
+		}
 #endif
 		RunCommands(gn);
 		curTarg = NULL;
 	    } else {
 		Job_Touch(gn, (gn->type & OP_SILENT) != 0);
+	    }
 	} else {
 	    gn->made = ERROR;
 @@ -576,27 +576,27 @@ Compat_Make(GNode *gn, GNode *pgn)
 	if (gn->made != ERROR) {
 	    /*
 	     * If the node was made successfully, mark it so, update
 	     * its modification time and timestamp all its parents. Note
 	     * that for .ZEROTIME targets, the timestamping isn't done.
 	     * This is to keep its state from affecting that of its parent.
 	     */
 	    gn->made = MADE;
 	    pgn->flags |= Make_Recheck(gn) == 0 ? FORCE : 0;
 	    if (!(gn->type & OP_EXEC)) {
 		pgn->flags |= CHILDMADE;
 		Make_TimeStamp(pgn, gn);
+	    }
-	} else if (keepgoing) {
+	} else if (opts.keepgoing) {
 	    pgn->flags &= ~(unsigned)REMAKE;
 	} else {
 	    PrintOnError(gn, "\nStop.");
 	    exit(1);
+	}
     } else if (gn->made == ERROR) {
 	/* Already had an error when making this. Tell the parent to abort. */
 	pgn->flags &= ~(unsigned)REMAKE;
     } else {
 	if (Lst_FindDatum(gn->implicitParents, pgn) != NULL) {
 	    char *target_freeIt;
 	    const char *target = Var_Value(TARGET, gn, &target_freeIt);
 	    Var_Set(IMPSRC, target != NULL ? target : "", pgn);
 @@ -649,27 +649,27 @@ Compat_Run(GNodeList *targs)
     if (bmake_signal(SIGHUP, SIG_IGN) != SIG_IGN)
 	bmake_signal(SIGHUP, CompatInterrupt);
     if (bmake_signal(SIGQUIT, SIG_IGN) != SIG_IGN)
 	bmake_signal(SIGQUIT, CompatInterrupt);
     /* Create the .END node now, to keep the (debug) output of the
      * counter.mk test the same as before 2020-09-23.  This implementation
      * detail probably doesn't matter though. */
     (void)Targ_GetEndNode();
     /*
      * If the user has defined a .BEGIN target, execute the commands attached
      * to it.
      */
-    if (!queryFlag) {
+    if (!opts.queryFlag) {
 	gn = Targ_FindNode(".BEGIN");
 	if (gn != NULL) {
 	    Compat_Make(gn, gn);
 	    if (gn->made == ERROR) {
 		PrintOnError(gn, "\nStop.");
 		exit(1);
+	    }
+	}
+    }
     /*
      * Expand .USE nodes right now, because they can modify the structure
      * of the tree.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.c,v 1.289 2020/10/26 20:11:02 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.290 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -133,27 +133,27 @@
 #ifndef USE_SELECT
 #include <poll.h>
 #endif
 #include <signal.h>
 #include <utime.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 /*	"@(#)job.c	8.2 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: job.c,v 1.289 2020/10/26 20:11:02 rillig Exp $");
+MAKE_RCSID("$NetBSD: job.c,v 1.290 2020/10/26 21:34:10 rillig Exp $");
 /* A shell defines how the commands are run.  All commands for a target are
  * written into a single file, which is then given to the shell to execute
  * the commands from it.  The commands are written to the file using a few
  * templates for echo control and error control.
+ *
  * The name of the shell is the basename for the predefined shells, such as
  * "sh", "csh", "bash".  For custom shells, it is the full pathname, and its
  * basename is used to select the type of shell; the longest match wins.
  * So /usr/pkg/bin/bash has type sh, /usr/local/bin/tcsh has type csh.
+ *
  * The echoing of command lines is controlled using hasEchoCtl, echoOff,
  * echoOn, noPrint and noPrintLen.  When echoOff is executed by the shell, it
 @@ -392,27 +392,27 @@ static int readyfd(Job *);
 static GNode *lastNode;		/* The node for which output was most recently
 				 * produced. */
 static char *targPrefix = NULL; /* What we print at the start of TARG_FMT */
 static Job tokenWaitJob;	/* token wait pseudo-job */
 static Job childExitJob;	/* child exit pseudo-job */
 #define	CHILD_EXIT	"."
 #define	DO_JOB_RESUME	"R"
 enum { npseudojobs = 2 };	/* number of pseudo-jobs */
 #define TARG_FMT  "%s %s ---\n" /* Default format */
 #define MESSAGE(fp, gn) \
-	if (maxJobs != 1 && targPrefix && *targPrefix) \
+	if (opts.maxJobs != 1 && targPrefix && *targPrefix) \
 	    (void)fprintf(fp, TARG_FMT, targPrefix, gn->name)
 static sigset_t caught_signals;	/* Set of signals we handle */
 static void JobDoOutput(Job *, Boolean);
 static void JobInterrupt(int, int) MAKE_ATTR_DEAD;
 static void JobRestartJobs(void);
 static void JobSigReset(void);
 static unsigned
 nfds_per_job(void)
+{
 #if defined(USE_FILEMON) && !defined(USE_FILEMON_DEV)
 @@ -439,27 +439,27 @@ job_table_dump(const char *where)
  * unsuccessful job unless inhibited by .PRECIOUS.
  */
 static void
 JobDeleteTarget(GNode *gn)
+{
     const char *file;
     if (gn->type & OP_JOIN)
 	return;
     if (gn->type & OP_PHONY)
 	return;
     if (Targ_Precious(gn))
 	return;
-    if (noExecute)
+    if (opts.noExecute)
 	return;
     file = GNode_Path(gn);
     if (eunlink(file) != -1)
 	Error("*** %s removed", file);
+}
 /*
  * JobSigLock/JobSigUnlock
+ *
  * Signal lock routines to get exclusive access. Currently used to
  * protect `jobs' and `stoppedJobs' list manipulations.
  */
 @@ -1073,27 +1073,27 @@ JobFinish(Job *job, int status)
 	job->node->made = MADE;
 	if (!(job->flags & JOB_SPECIAL))
 	    return_job_token = TRUE;
 	Make_Update(job->node);
 	job->job_state = JOB_ST_FREE;
     } else if (status != 0) {
 	errors++;
 	job->job_state = JOB_ST_FREE;
+    }
     /*
      * Set aborting if any error.
      */
-    if (errors && !keepgoing && (aborting != ABORT_INTERRUPT)) {
+    if (errors && !opts.keepgoing && (aborting != ABORT_INTERRUPT)) {
 	/*
 	 * If we found any errors in this batch of children and the -k flag
 	 * wasn't given, we set the aborting flag so no more jobs get
 	 * started.
 	 */
 	aborting = ABORT_ERROR;
+    }
     if (return_job_token)
 	Job_TokenReturn();
     if (aborting == ABORT_ERROR && jobTokensRunning == 0) {
 	/*
 @@ -1225,27 +1225,27 @@ Job_CheckCommands(GNode *gn, void (*abor
 	    fprintf(stdout, "%s: %s, %d: ignoring stale %s for %s\n",
 		    progname, gn->fname, gn->lineno, makeDependfile,
 		    gn->name);
 	return TRUE;
+    }
     if (gn->type & OP_OPTIONAL) {
 	(void)fprintf(stdout, "%s: don't know how to make %s (%s)\n",
 		      progname, gn->name, "ignored");
 	(void)fflush(stdout);
 	return TRUE;
+    }
-    if (keepgoing) {
+    if (opts.keepgoing) {
 	(void)fprintf(stdout, "%s: don't know how to make %s (%s)\n",
 		      progname, gn->name, "continuing");
 	(void)fflush(stdout);
 	return FALSE;
+    }
     abortProc("%s: don't know how to make %s. Stop", progname, gn->name);
     return FALSE;
+}
 /* Execute the shell for the given job.
+ *
  * A shell is executed, its output is altered and the Job structure added
 @@ -1514,28 +1514,28 @@ JobStart(GNode *gn, int flags)
     /*
      * Check the commands now so any attributes from .DEFAULT have a chance
      * to migrate to the node
      */
     cmdsOK = Job_CheckCommands(gn, Error);
     job->inPollfd = NULL;
     /*
      * If the -n flag wasn't given, we open up OUR (not the child's)
      * temporary file to stuff commands in it. The thing is rd/wr so we don't
      * need to reopen it to feed it to the shell. If the -n flag *was* given,
      * we just set the file to be stdout. Cute, huh?
      */
-    if (((gn->type & OP_MAKE) && !(noRecursiveExecute)) ||
+    if (((gn->type & OP_MAKE) && !opts.noRecursiveExecute) ||
-	    (!noExecute && !touchFlag)) {
+	    (!opts.noExecute && !opts.touchFlag)) {
 	/*
 	 * tfile is the name of a file into which all shell commands are
 	 * put. It is removed before the child shell is executed, unless
 	 * DEBUG(SCRIPT) is set.
 	 */
 	char *tfile;
 	sigset_t mask;
 	/*
 	 * We're serious here, but if the commands were bogus, we're
 	 * also dead...
 	 */
 	if (!cmdsOK) {
 	    PrintOnError(gn, NULL);	/* provide some clue */
 @@ -1814,27 +1814,27 @@ end_loop:
 	 */
 	job->outBuf[i] = '\0';
 	if (i >= job->curPos) {
 	    char *cp;
 	    cp = JobOutput(job, job->outBuf, &job->outBuf[i]);
 	    /*
 	     * There's still more in that thar buffer. This time, though,
 	     * we know there's no newline at the end, so we add one of
 	     * our own free will.
 	     */
 	    if (*cp != '\0') {
-		if (!beSilent && job->node != lastNode) {
+		if (!opts.beSilent && job->node != lastNode) {
 		    MESSAGE(stdout, job->node);
 		    lastNode = job->node;
+		}
 #ifdef USE_META
 		if (useMeta) {
 		    meta_job_output(job, cp, gotNL ? "\n" : "");
+		}
 #endif
 		(void)fprintf(stdout, "%s%s", cp, gotNL ? "\n" : "");
 		(void)fflush(stdout);
+	    }
+	}
 	/*
 @@ -2107,29 +2107,29 @@ Job_SetPrefix(void)
+    }
     (void)Var_Subst("${" MAKE_JOB_PREFIX "}",
 		    VAR_GLOBAL, VARE_WANTRES, &targPrefix);
     /* TODO: handle errors */
+}
 /* Initialize the process module. */
 void
 Job_Init(void)
+{
     Job_SetPrefix();
     /* Allocate space for all the job info */
-    job_table = bmake_malloc((size_t)maxJobs * sizeof *job_table);
+    job_table = bmake_malloc((size_t)opts.maxJobs * sizeof *job_table);
-    memset(job_table, 0, (size_t)maxJobs * sizeof *job_table);
+    memset(job_table, 0, (size_t)opts.maxJobs * sizeof *job_table);
-    job_table_end = job_table + maxJobs;
+    job_table_end = job_table + opts.maxJobs;
     wantToken =	0;
     aborting = 0;
     errors = 0;
     lastNode = NULL;
     /*
      * There is a non-zero chance that we already have children.
      * eg after 'make -f- <<EOF'
      * Since their termination causes a 'Child (pid) not in table' message,
      * Collect the status of any that are already dead, and suppress the
      * error message if there are any undead ones.
 @@ -2140,29 +2140,29 @@ Job_Init(void)
 	if (rval > 0)
 	    continue;
 	if (rval == 0)
 	    lurking_children = 1;
 	break;
+    }
     Shell_Init();
     JobCreatePipe(&childExitJob, 3);
     /* Preallocate enough for the maximum number of jobs.  */
     fds = bmake_malloc(sizeof(*fds) *
-	(npseudojobs + (size_t)maxJobs) * nfds_per_job());
+	(npseudojobs + (size_t)opts.maxJobs) * nfds_per_job());
     jobfds = bmake_malloc(sizeof(*jobfds) *
-	(npseudojobs + (size_t)maxJobs) * nfds_per_job());
+	(npseudojobs + (size_t)opts.maxJobs) * nfds_per_job());
     /* These are permanent entries and take slots 0 and 1 */
     watchfd(&tokenWaitJob);
     watchfd(&childExitJob);
     sigemptyset(&caught_signals);
     /*
      * Install a SIGCHLD handler.
      */
     (void)bmake_signal(SIGCHLD, JobChildSig);
     sigaddset(&caught_signals, SIGCHLD);
 #define ADDSIG(s,h)				\
 @@ -2464,30 +2464,30 @@ JobInterrupt(int runINTERRUPT, int signo
 	gn = job->node;
 	JobDeleteTarget(gn);
 	if (job->pid) {
 	    DEBUG2(JOB, "JobInterrupt passing signal %d to child %d.\n",
 		   signo, job->pid);
 	    KILLPG(job->pid, signo);
+	}
+    }
     JobSigUnlock(&mask);
-    if (runINTERRUPT && !touchFlag) {
+    if (runINTERRUPT && !opts.touchFlag) {
 	interrupt = Targ_FindNode(".INTERRUPT");
 	if (interrupt != NULL) {
-	    ignoreErrors = FALSE;
+	    opts.ignoreErrors = FALSE;
 	    JobRun(interrupt);
+	}
+    }
     Trace_Log(MAKEINTR, 0);
     exit(signo);
+}
 /* Do the final processing, i.e. run the commands attached to the .END target.
+ *
  * Return the number of errors reported. */
 int
 Job_Finish(void)
+{
 @@ -2720,27 +2720,27 @@ Job_TokenReturn(void)
+ *
  * Returns TRUE if a token was withdrawn, and FALSE if the pool is currently
  * empty. */
 Boolean
 Job_TokenWithdraw(void)
+{
     char tok, tok1;
     ssize_t count;
     wantToken = 0;
     DEBUG3(JOB, "Job_TokenWithdraw(%d): aborting %d, running %d\n",
 	   getpid(), aborting, jobTokensRunning);
-    if (aborting || (jobTokensRunning >= maxJobs))
+    if (aborting || (jobTokensRunning >= opts.maxJobs))
 	return FALSE;
     count = read(tokenWaitJob.inPipe, &tok, 1);
     if (count == 0)
 	Fatal("eof on job pipe!");
     if (count < 0 && jobTokensRunning != 0) {
 	if (errno != EAGAIN) {
 	    Fatal("job pipe read: %s", strerror(errno));
+	}
 	DEBUG1(JOB, "(%d) blocked for token\n", getpid());
 	return FALSE;
+    }

 @@ -1,14 +1,14 @@
-/*	$NetBSD: main.c,v 1.390 2020/10/25 19:19:07 rillig Exp $	*/
+/*	$NetBSD: main.c,v 1.391 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -108,86 +108,64 @@
 #include <errno.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <time.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 /*	"@(#)main.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: main.c,v 1.390 2020/10/25 19:19:07 rillig Exp $");
+MAKE_RCSID("$NetBSD: main.c,v 1.391 2020/10/26 21:34:10 rillig Exp $");
 #if defined(MAKE_NATIVE) && !defined(lint)
 __COPYRIGHT("@(#) Copyright (c) 1988, 1989, 1990, 1993 "
 	    "The Regents of the University of California.  "
 	    "All rights reserved.");
 #endif
 #ifndef	DEFMAXLOCAL
 #define	DEFMAXLOCAL DEFMAXJOBS
 #endif
-StringList *		create;		/* Targets to be made */
+CmdOpts opts;
 time_t			now;		/* Time at start of make */
 GNode			*DEFAULT;	/* .DEFAULT node */
 Boolean			allPrecious;	/* .PRECIOUS given on line by itself */
 Boolean			deleteOnError;	/* .DELETE_ON_ERROR: set */
 static Boolean		noBuiltins;	/* -r flag */
 static StringList *	makefiles;	/* ordered list of makefiles to read */
 static int		printVars;	/* -[vV] argument */
 #define COMPAT_VARS 1
 #define EXPAND_VARS 2
 static StringList *	variables;	/* list of variables to print
 					 * (for -v and -V) */
 int			maxJobs;	/* -j argument */
 static int		maxJobTokens;	/* -j argument */
 Boolean			compatMake;	/* -B argument */
 DebugFlags		debug;		/* -d argument */
 Boolean			debugVflag;	/* -dV */
 Boolean			noExecute;	/* -n flag */
 Boolean			noRecursiveExecute;	/* -N flag */
 Boolean			keepgoing;	/* -k flag */
 Boolean			queryFlag;	/* -q flag */
 Boolean			touchFlag;	/* -t flag */
 Boolean			enterFlag;	/* -w flag */
 Boolean			enterFlagObj;	/* -w and objdir != srcdir */
 Boolean			ignoreErrors;	/* -i flag */
 Boolean			beSilent;	/* -s flag */
 Boolean			oldVars;	/* variable substitution style */
 Boolean			checkEnvFirst;	/* -e flag */
 Boolean			parseWarnFatal;	/* -W flag */
 static int jp_0 = -1, jp_1 = -1;	/* ends of parent job pipe */
 Boolean			varNoExportEnv;	/* -X flag */
 Boolean			doing_depend;	/* Set while reading .depend */
 static Boolean		jobsRunning;	/* TRUE if the jobs might be running */
 static const char *	tracefile;
 static int		ReadMakefile(const char *);
 static void		usage(void) MAKE_ATTR_DEAD;
 static void		purge_cached_realpaths(void);
 static Boolean		ignorePWD;	/* if we use -C, PWD is meaningless */
 static char objdir[MAXPATHLEN + 1];	/* where we chdir'ed to */
 char curdir[MAXPATHLEN + 1];		/* Startup directory */
 char *progname;				/* the program name */
 char *makeDependfile;
 pid_t myPid;
 int makelevel;
 FILE *debug_file;
 Boolean forceJobs = FALSE;
 extern SearchPath *parseIncPath;
 /*
  * For compatibility with the POSIX version of MAKEFLAGS that includes
  * all the options with out -, convert flags to -f -l -a -g -s.
  */
 static char *
 explode(const char *flags)
+{
     size_t len;
     char *nf, *st;
 @@ -211,162 +189,162 @@ explode(const char *flags)
 	*nf++ = ' ';
+    }
     *nf = '\0';
     return st;
+}
 static void
 parse_debug_option_F(const char *modules)
+{
     const char *mode;
     size_t len;
     char *fname;
-    if (debug_file != stdout && debug_file != stderr)
+    if (opts.debug_file != stdout && opts.debug_file != stderr)
-	fclose(debug_file);
+	fclose(opts.debug_file);
     if (*modules == '+') {
 	modules++;
 	mode = "a";
     } else
 	mode = "w";
     if (strcmp(modules, "stdout") == 0) {
-	debug_file = stdout;
+	opts.debug_file = stdout;
 	return;
+    }
     if (strcmp(modules, "stderr") == 0) {
-	debug_file = stderr;
+	opts.debug_file = stderr;
 	return;
+    }
     len = strlen(modules);
     fname = bmake_malloc(len + 20);
     memcpy(fname, modules, len + 1);
     /* Let the filename be modified by the pid */
     if (strcmp(fname + len - 3, ".%d") == 0)
 	snprintf(fname + len - 2, 20, "%d", getpid());
-    debug_file = fopen(fname, mode);
+    opts.debug_file = fopen(fname, mode);
-    if (!debug_file) {
+    if (!opts.debug_file) {
 	fprintf(stderr, "Cannot open debug file %s\n",
 		fname);
 	usage();
+    }
     free(fname);
+}
 static void
 parse_debug_options(const char *argvalue)
+{
 	const char *modules;
 	for (modules = argvalue; *modules; ++modules) {
 		switch (*modules) {
 		case '0':	/* undocumented, only intended for tests */
-			debug &= DEBUG_LINT;
+			opts.debug &= DEBUG_LINT;
 			break;
 		case 'A':
-			debug = ~(0|DEBUG_LINT);
+			opts.debug = ~(0|DEBUG_LINT);
 			break;
 		case 'a':
-			debug |= DEBUG_ARCH;
+			opts.debug |= DEBUG_ARCH;
 			break;
 		case 'C':
-			debug |= DEBUG_CWD;
+			opts.debug |= DEBUG_CWD;
 			break;
 		case 'c':
-			debug |= DEBUG_COND;
+			opts.debug |= DEBUG_COND;
 			break;
 		case 'd':
-			debug |= DEBUG_DIR;
+			opts.debug |= DEBUG_DIR;
 			break;
 		case 'e':
-			debug |= DEBUG_ERROR;
+			opts.debug |= DEBUG_ERROR;
 			break;
 		case 'f':
-			debug |= DEBUG_FOR;
+			opts.debug |= DEBUG_FOR;
 			break;
 		case 'g':
 			if (modules[1] == '1') {
-				debug |= DEBUG_GRAPH1;
+				opts.debug |= DEBUG_GRAPH1;
 				++modules;
+			}
 			else if (modules[1] == '2') {
-				debug |= DEBUG_GRAPH2;
+				opts.debug |= DEBUG_GRAPH2;
 				++modules;
+			}
 			else if (modules[1] == '3') {
-				debug |= DEBUG_GRAPH3;
+				opts.debug |= DEBUG_GRAPH3;
 				++modules;
+			}
 			break;
 		case 'h':
-			debug |= DEBUG_HASH;
+			opts.debug |= DEBUG_HASH;
 			break;
 		case 'j':
-			debug |= DEBUG_JOB;
+			opts.debug |= DEBUG_JOB;
 			break;
 		case 'L':
-			debug |= DEBUG_LINT;
+			opts.debug |= DEBUG_LINT;
 			break;
 		case 'l':
-			debug |= DEBUG_LOUD;
+			opts.debug |= DEBUG_LOUD;
 			break;
 		case 'M':
-			debug |= DEBUG_META;
+			opts.debug |= DEBUG_META;
 			break;
 		case 'm':
-			debug |= DEBUG_MAKE;
+			opts.debug |= DEBUG_MAKE;
 			break;
 		case 'n':
-			debug |= DEBUG_SCRIPT;
+			opts.debug |= DEBUG_SCRIPT;
 			break;
 		case 'p':
-			debug |= DEBUG_PARSE;
+			opts.debug |= DEBUG_PARSE;
 			break;
 		case 's':
-			debug |= DEBUG_SUFF;
+			opts.debug |= DEBUG_SUFF;
 			break;
 		case 't':
-			debug |= DEBUG_TARG;
+			opts.debug |= DEBUG_TARG;
 			break;
 		case 'V':
 			debugVflag = TRUE;
 			break;
 		case 'v':
-			debug |= DEBUG_VAR;
+			opts.debug |= DEBUG_VAR;
 			break;
 		case 'x':
-			debug |= DEBUG_SHELL;
+			opts.debug |= DEBUG_SHELL;
 			break;
 		case 'F':
 			parse_debug_option_F(modules + 1);
 			goto debug_setbuf;
 		default:
 			(void)fprintf(stderr,
 			    "%s: illegal argument to d option -- %c\n",
 			    progname, *modules);
 			usage();
+		}
+	}
 debug_setbuf:
 	/*
 	 * Make the debug_file unbuffered, and make
 	 * stdout line buffered (unless debugfile == stdout).
 	 */
-	setvbuf(debug_file, NULL, _IONBF, 0);
+	setvbuf(opts.debug_file, NULL, _IONBF, 0);
-	if (debug_file != stdout) {
+	if (opts.debug_file != stdout) {
 		setvbuf(stdout, NULL, _IOLBF, 0);
+	}
+}
 /*
  * does path contain any relative components
  */
 static Boolean
 is_relpath(const char *path)
+{
 	const char *cp;
 	if (path[0] != '/')
 @@ -416,179 +394,180 @@ MainParseArgJobsInternal(const char *arg
 			      progname, argvalue);
 		usage();
+	}
 	if ((fcntl(jp_0, F_GETFD, 0) < 0) ||
 	    (fcntl(jp_1, F_GETFD, 0) < 0)) {
 #if 0
 		(void)fprintf(stderr,
 		    "%s: ###### warning -- J descriptors were closed!\n",
 		    progname);
 		exit(2);
 #endif
 		jp_0 = -1;
 		jp_1 = -1;
-		compatMake = TRUE;
+		opts.compatMake = TRUE;
 	} else {
 		Var_Append(MAKEFLAGS, "-J", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
+	}
+}
 static void
 MainParseArgJobs(const char *argvalue)
+{
 	char *p;
 	forceJobs = TRUE;
-	maxJobs = (int)strtol(argvalue, &p, 0);
+	opts.maxJobs = (int)strtol(argvalue, &p, 0);
-	if (*p != '\0' || maxJobs < 1) {
+	if (*p != '\0' || opts.maxJobs < 1) {
 		(void)fprintf(stderr,
 		    "%s: illegal argument to -j -- must be positive integer!\n",
 		    progname);
 		exit(1);	/* XXX: why not 2? */
+	}
 	Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
 	Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 	Var_Set(".MAKE.JOBS", argvalue, VAR_GLOBAL);
-	maxJobTokens = maxJobs;
+	maxJobTokens = opts.maxJobs;
+}
 static void
 MainParseArgSysInc(const char *argvalue)
+{
 	/* look for magic parent directory search string */
 	if (strncmp(".../", argvalue, 4) == 0) {
 		char *found_path = Dir_FindHereOrAbove(curdir, argvalue + 4);
 		if (found_path == NULL)
 			return;
 		(void)Dir_AddDir(sysIncPath, found_path);
 		free(found_path);
 	} else {
 		(void)Dir_AddDir(sysIncPath, argvalue);
+	}
 	Var_Append(MAKEFLAGS, "-m", VAR_GLOBAL);
 	Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
+}
 static Boolean
 MainParseArg(char c, const char *argvalue)
+{
 	switch (c) {
 	case '\0':
 		break;
 	case 'B':
-		compatMake = TRUE;
+		opts.compatMake = TRUE;
 		Var_Append(MAKEFLAGS, "-B", VAR_GLOBAL);
 		Var_Set(MAKE_MODE, "compat", VAR_GLOBAL);
 		break;
 	case 'C':
 		MainParseArgChdir(argvalue);
 		break;
 	case 'D':
 		if (argvalue[0] == '\0') return FALSE;
 		Var_Set(argvalue, "1", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, "-D", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 		break;
 	case 'I':
 		Parse_AddIncludeDir(argvalue);
 		Var_Append(MAKEFLAGS, "-I", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 		break;
 	case 'J':
 		MainParseArgJobsInternal(argvalue);
 		break;
 	case 'N':
-		noExecute = TRUE;
+		opts.noExecute = TRUE;
-		noRecursiveExecute = TRUE;
+		opts.noRecursiveExecute = TRUE;
 		Var_Append(MAKEFLAGS, "-N", VAR_GLOBAL);
 		break;
 	case 'S':
-		keepgoing = FALSE;
+		opts.keepgoing = FALSE;
 		Var_Append(MAKEFLAGS, "-S", VAR_GLOBAL);
 		break;
 	case 'T':
 		tracefile = bmake_strdup(argvalue);
 		Var_Append(MAKEFLAGS, "-T", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 		break;
 	case 'V':
 	case 'v':
-		printVars = c == 'v' ? EXPAND_VARS : COMPAT_VARS;
+		opts.printVars = c == 'v' ? EXPAND_VARS : COMPAT_VARS;
-		Lst_Append(variables, bmake_strdup(argvalue));
+		Lst_Append(opts.variables, bmake_strdup(argvalue));
 		/* XXX: Why always -V? */
 		Var_Append(MAKEFLAGS, "-V", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
 		break;
 	case 'W':
-		parseWarnFatal = TRUE;
+		opts.parseWarnFatal = TRUE;
 		break;
 	case 'X':
-		varNoExportEnv = TRUE;
+		opts.varNoExportEnv = TRUE;
 		Var_Append(MAKEFLAGS, "-X", VAR_GLOBAL);
 		break;
 	case 'd':
 		/* If '-d-opts' don't pass to children */
 		if (argvalue[0] == '-')
 			argvalue++;
 		else {
 			Var_Append(MAKEFLAGS, "-d", VAR_GLOBAL);
 			Var_Append(MAKEFLAGS, argvalue, VAR_GLOBAL);
+		}
 		parse_debug_options(argvalue);
 		break;
 	case 'e':
-		checkEnvFirst = TRUE;
+		opts.checkEnvFirst = TRUE;
 		Var_Append(MAKEFLAGS, "-e", VAR_GLOBAL);
 		break;
 	case 'f':
-		Lst_Append(makefiles, bmake_strdup(argvalue));
+		Lst_Append(opts.makefiles, bmake_strdup(argvalue));
 		break;
 	case 'i':
-		ignoreErrors = TRUE;
+		opts.ignoreErrors = TRUE;
 		Var_Append(MAKEFLAGS, "-i", VAR_GLOBAL);
 		break;
 	case 'j':
 		MainParseArgJobs(argvalue);
 		break;
 	case 'k':
-		keepgoing = TRUE;
+		opts.keepgoing = TRUE;
 		Var_Append(MAKEFLAGS, "-k", VAR_GLOBAL);
 		break;
 	case 'm':
 		MainParseArgSysInc(argvalue);
 		break;
 	case 'n':
-		noExecute = TRUE;
+		opts.noExecute = TRUE;
 		Var_Append(MAKEFLAGS, "-n", VAR_GLOBAL);
 		break;
 	case 'q':
-		queryFlag = TRUE;
+		opts.queryFlag = TRUE;
 		/* Kind of nonsensical, wot? */
 		Var_Append(MAKEFLAGS, "-q", VAR_GLOBAL);
 		break;
 	case 'r':
-		noBuiltins = TRUE;
+		opts.noBuiltins = TRUE;
 		Var_Append(MAKEFLAGS, "-r", VAR_GLOBAL);
 		break;
 	case 's':
-		beSilent = TRUE;
+		opts.beSilent = TRUE;
 		Var_Append(MAKEFLAGS, "-s", VAR_GLOBAL);
 		break;
 	case 't':
-		touchFlag = TRUE;
+		opts.touchFlag = TRUE;
 		Var_Append(MAKEFLAGS, "-t", VAR_GLOBAL);
 		break;
 	case 'w':
-		enterFlag = TRUE;
+		opts.enterFlag = TRUE;
 		Var_Append(MAKEFLAGS, "-w", VAR_GLOBAL);
 		break;
 	default:
 	case '?':
 		usage();
+	}
 	return TRUE;
+}
 /* Parse the given arguments.  Called from main() and from
  * Main_ParseArgLine() when the .MAKEFLAGS target is used.
+ *
  * The arguments must be treated as read-only and will be freed after the
 @@ -667,27 +646,27 @@ rearg:
 	 * See if the rest of the arguments are variable assignments and
 	 * perform them if so. Else take them to be targets and stuff them
 	 * on the end of the "create" list.
 	 */
 	for (; argc > 1; ++argv, --argc) {
 		VarAssign var;
 		if (Parse_IsVar(argv[1], &var)) {
 			Parse_DoVar(&var, VAR_CMD);
 		} else {
 			if (!*argv[1])
 				Punt("illegal (null) argument.");
 			if (*argv[1] == '-' && !dashDash)
 				goto rearg;
-			Lst_Append(create, bmake_strdup(argv[1]));
+			Lst_Append(opts.create, bmake_strdup(argv[1]));
+		}
+	}
 	return;
 noarg:
 	(void)fprintf(stderr, "%s: option requires an argument -- %c\n",
 	    progname, c);
 	usage();
+}
 /* Break a line of arguments into words and parse them.
+ *
  * Used when a .MFLAGS or .MAKEFLAGS target is encountered during parsing and
 @@ -743,27 +722,27 @@ Main_SetObjdir(const char *fmt, ...)
 	/* look for the directory and try to chdir there */
 	if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
 		if (chdir(path)) {
 			(void)fprintf(stderr, "make warning: %s: %s.\n",
 				      path, strerror(errno));
 		} else {
 			snprintf(objdir, sizeof objdir, "%s", path);
 			Var_Set(".OBJDIR", objdir, VAR_GLOBAL);
 			setenv("PWD", objdir, 1);
 			Dir_InitDot();
 			purge_cached_realpaths();
 			rc = TRUE;
-			if (enterFlag && strcmp(objdir, curdir) != 0)
+			if (opts.enterFlag && strcmp(objdir, curdir) != 0)
 				enterFlagObj = TRUE;
+		}
+	}
 	return rc;
+}
 static Boolean
 Main_SetVarObjdir(const char *var, const char *suffix)
+{
 	char *path_freeIt;
 	const char *path = Var_Value(var, VAR_CMD, &path_freeIt);
 	const char *xpath;
 @@ -837,27 +816,27 @@ void
 MakeMode(const char *mode)
+{
     char *mode_freeIt = NULL;
     if (mode == NULL) {
 	(void)Var_Subst("${" MAKE_MODE ":tl}",
 		  VAR_GLOBAL, VARE_WANTRES, &mode_freeIt);
 	/* TODO: handle errors */
 	mode = mode_freeIt;
+    }
     if (mode[0] != '\0') {
 	if (strstr(mode, "compat")) {
-	    compatMake = TRUE;
+	    opts.compatMake = TRUE;
 	    forceJobs = FALSE;
+	}
 #if USE_META
 	if (strstr(mode, "meta"))
 	    meta_mode_init(mode);
 #endif
+    }
     free(mode_freeIt);
+}
 static void
 PrintVar(const char *varname, Boolean expandVars)
 @@ -882,65 +861,65 @@ PrintVar(const char *varname, Boolean ex
 		char *freeIt;
 		const char *value = Var_Value(varname, VAR_GLOBAL, &freeIt);
 		printf("%s\n", value ? value : "");
 		bmake_free(freeIt);
+	}
+}
 static void
 doPrintVars(void)
+{
 	StringListNode *ln;
 	Boolean expandVars;
-	if (printVars == EXPAND_VARS)
+	if (opts.printVars == EXPAND_VARS)
 		expandVars = TRUE;
 	else if (debugVflag)
 		expandVars = FALSE;
 	else
 		expandVars = getBoolean(".MAKE.EXPAND_VARIABLES", FALSE);
-	for (ln = variables->first; ln != NULL; ln = ln->next) {
+	for (ln = opts.variables->first; ln != NULL; ln = ln->next) {
 		const char *varname = ln->datum;
 		PrintVar(varname, expandVars);
+	}
+}
 static Boolean
 runTargets(void)
+{
 	GNodeList *targs; /* target nodes to create -- passed to Make_Init */
 	Boolean outOfDate;	/* FALSE if all targets up to date */
 	/*
 	 * Have now read the entire graph and need to make a list of
 	 * targets to create. If none was given on the command line,
 	 * we consult the parsing module to find the main target(s)
 	 * to create.
 	 */
-	if (Lst_IsEmpty(create))
+	if (Lst_IsEmpty(opts.create))
 		targs = Parse_MainName();
 	else
-		targs = Targ_FindList(create);
+		targs = Targ_FindList(opts.create);
-	if (!compatMake) {
+	if (!opts.compatMake) {
 		/*
 		 * Initialize job module before traversing the graph
 		 * now that any .BEGIN and .END targets have been read.
 		 * This is done only if the -q flag wasn't given
 		 * (to prevent the .BEGIN from being executed should
 		 * it exist).
 		 */
-		if (!queryFlag) {
+		if (!opts.queryFlag) {
 			Job_Init();
 			jobsRunning = TRUE;
+		}
 		/* Traverse the graph, checking on all the targets */
 		outOfDate = Make_Run(targs);
 	} else {
 		/*
 		 * Compat_Init will take care of creating all the
 		 * targets as well as initializing the module.
 		 */
 		Compat_Run(targs);
 		outOfDate = FALSE;
 @@ -949,32 +928,32 @@ runTargets(void)
 	return outOfDate;
+}
 /*
  * Set up the .TARGETS variable to contain the list of targets to be
  * created. If none specified, make the variable empty -- the parser
  * will fill the thing in with the default or .MAIN target.
  */
 static void
 InitVarTargets(void)
+{
 	StringListNode *ln;
-	if (Lst_IsEmpty(create)) {
+	if (Lst_IsEmpty(opts.create)) {
 		Var_Set(".TARGETS", "", VAR_GLOBAL);
 		return;
+	}
-	for (ln = create->first; ln != NULL; ln = ln->next) {
+	for (ln = opts.create->first; ln != NULL; ln = ln->next) {
 		char *name = ln->datum;
 		Var_Append(".TARGETS", name, VAR_GLOBAL);
+	}
+}
 static const char *
 init_machine(const struct utsname *utsname)
+{
 	const char *machine = getenv("MACHINE");
 	if (machine != NULL)
 		return machine;
 #ifdef MAKE_NATIVE
 @@ -1093,27 +1072,27 @@ main(int argc, char **argv)
 	char *p1, *path;
 	char mdpath[MAXPATHLEN];
 	const char *machine;
 	const char *machine_arch;
 	char *syspath = getenv("MAKESYSPATH");
 	StringList *sysMkPath;		/* Path of sys.mk */
 	char *cp = NULL, *start;
 					/* avoid faults on read-only strings */
 	static char defsyspath[] = _PATH_DEFSYSPATH;
 	struct timeval rightnow;	/* to initialize random seed */
 	struct utsname utsname;
 	/* default to writing debug to stderr */
-	debug_file = stderr;
+	opts.debug_file = stderr;
 #ifdef SIGINFO
 	(void)bmake_signal(SIGINFO, siginfo);
 #endif
 	/*
 	 * Set the seed to produce a different random sequence
 	 * on each program execution.
 	 */
 	gettimeofday(&rightnow, NULL);
 	srandom((unsigned int)(rightnow.tv_sec + rightnow.tv_usec));
 	if ((progname = strrchr(argv[0], '/')) != NULL)
 		progname++;
 @@ -1164,47 +1143,47 @@ main(int argc, char **argv)
 	Var_Set("MAKE_VERSION", MAKE_VERSION, VAR_GLOBAL);
 #endif
 	Var_Set(".newline", "\n", VAR_GLOBAL); /* handy for :@ loops */
 	/*
 	 * This is the traditional preference for makefiles.
 	 */
 #ifndef MAKEFILE_PREFERENCE_LIST
 # define MAKEFILE_PREFERENCE_LIST "makefile Makefile"
 #endif
 	Var_Set(MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST,
 		VAR_GLOBAL);
 	Var_Set(MAKE_DEPENDFILE, ".depend", VAR_GLOBAL);
-	create = Lst_New();
+	opts.create = Lst_New();
-	makefiles = Lst_New();
+	opts.makefiles = Lst_New();
-	printVars = 0;
+	opts.printVars = 0;
 	debugVflag = FALSE;
-	variables = Lst_New();
+	opts.variables = Lst_New();
-	beSilent = FALSE;		/* Print commands as executed */
+	opts.beSilent = FALSE;		/* Print commands as executed */
-	ignoreErrors = FALSE;		/* Pay attention to non-zero returns */
+	opts.ignoreErrors = FALSE;	/* Pay attention to non-zero returns */
-	noExecute = FALSE;		/* Execute all commands */
+	opts.noExecute = FALSE;		/* Execute all commands */
-	noRecursiveExecute = FALSE;	/* Execute all .MAKE targets */
+	opts.noRecursiveExecute = FALSE; /* Execute all .MAKE targets */
-	keepgoing = FALSE;		/* Stop on error */
+	opts.keepgoing = FALSE;		/* Stop on error */
 	allPrecious = FALSE;		/* Remove targets when interrupted */
 	deleteOnError = FALSE;		/* Historical default behavior */
-	queryFlag = FALSE;		/* This is not just a check-run */
+	opts.queryFlag = FALSE;		/* This is not just a check-run */
-	noBuiltins = FALSE;		/* Read the built-in rules */
+	opts.noBuiltins = FALSE;	/* Read the built-in rules */
-	touchFlag = FALSE;		/* Actually update targets */
+	opts.touchFlag = FALSE;		/* Actually update targets */
-	debug = 0;			/* No debug verbosity, please. */
+	opts.debug = 0;			/* No debug verbosity, please. */
 	jobsRunning = FALSE;
-	maxJobs = DEFMAXLOCAL;		/* Set default local max concurrency */
+	opts.maxJobs = DEFMAXLOCAL;	/* Set default local max concurrency */
-	maxJobTokens = maxJobs;
+	maxJobTokens = opts.maxJobs;
-	compatMake = FALSE;		/* No compat mode */
+	opts.compatMake = FALSE;	/* No compat mode */
 	ignorePWD = FALSE;
 	/*
 	 * Initialize the parsing, directory and variable modules to prepare
 	 * for the reading of inclusion paths and variable settings on the
 	 * command line
 	 */
 	/*
 	 * Initialize various variables.
 	 *	MAKE also gets this name, for compatibility
 	 *	.MAKEFLAGS gets set to the empty string just in case.
 	 *	MFLAGS also gets initialized empty, for compatibility.
 @@ -1278,27 +1257,27 @@ main(int argc, char **argv)
 	/*
 	 * Find where we are (now).
 	 * We take care of PWD for the automounter below...
 	 */
 	if (getcwd(curdir, MAXPATHLEN) == NULL) {
 		(void)fprintf(stderr, "%s: getcwd: %s.\n",
 		    progname, strerror(errno));
 		exit(2);
+	}
 	MainParseArgs(argc, argv);
-	if (enterFlag)
+	if (opts.enterFlag)
 		printf("%s: Entering directory `%s'\n", progname, curdir);
 	/*
 	 * Verify that cwd is sane.
 	 */
 	if (stat(curdir, &sa) == -1) {
 	    (void)fprintf(stderr, "%s: %s: %s.\n",
 		 progname, curdir, strerror(errno));
 	    exit(2);
+	}
 #ifndef NO_PWD_OVERRIDE
 	HandlePWD(&sa);
 @@ -1366,114 +1345,115 @@ main(int argc, char **argv)
 				(void)Dir_AddDir(defIncPath, dir);
 				free(dir);
+			}
+		}
+	}
 	if (syspath != defsyspath)
 		free(syspath);
 	/*
 	 * Read in the built-in rules first, followed by the specified
 	 * makefiles, or the default makefile and Makefile, in that order,
 	 * if no makefiles were given on the command line.
 	 */
-	if (!noBuiltins) {
+	if (!opts.noBuiltins) {
 		sysMkPath = Lst_New();
 		Dir_Expand(_PATH_DEFSYSMK,
 			   Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath,
 			   sysMkPath);
 		if (Lst_IsEmpty(sysMkPath))
 			Fatal("%s: no system rules (%s).", progname,
 			    _PATH_DEFSYSMK);
 		if (!Lst_ForEachUntil(sysMkPath, ReadMakefileSucceeded, NULL))
 			Fatal("%s: cannot open %s.", progname,
 			    (char *)sysMkPath->first->datum);
+	}
-	if (makefiles->first != NULL) {
+	if (opts.makefiles->first != NULL) {
 		StringListNode *ln;
-		for (ln = makefiles->first; ln != NULL; ln = ln->next) {
+		for (ln = opts.makefiles->first; ln != NULL; ln = ln->next) {
 			if (ReadMakefile(ln->datum) != 0)
 				Fatal("%s: cannot open %s.",
 				      progname, (char *)ln->datum);
+		}
 	} else {
 		(void)Var_Subst("${" MAKEFILE_PREFERENCE "}",
 		    VAR_CMD, VARE_WANTRES, &p1);
 		/* TODO: handle errors */
-		(void)str2Lst_Append(makefiles, p1, NULL);
+		(void)str2Lst_Append(opts.makefiles, p1, NULL);
-		(void)Lst_ForEachUntil(makefiles, ReadMakefileSucceeded, NULL);
+		(void)Lst_ForEachUntil(opts.makefiles,
 				       ReadMakefileSucceeded, NULL);
 		free(p1);
+	}
 	/* In particular suppress .depend for '-r -V .OBJDIR -f /dev/null' */
-	if (!noBuiltins || !printVars) {
+	if (!opts.noBuiltins || !opts.printVars) {
 	    /* ignore /dev/null and anything starting with "no" */
 	    (void)Var_Subst("${.MAKE.DEPENDFILE:N/dev/null:Nno*:T}",
 		VAR_CMD, VARE_WANTRES, &makeDependfile);
 	    if (makeDependfile[0] != '\0') {
 		/* TODO: handle errors */
 		doing_depend = TRUE;
 		(void)ReadMakefile(makeDependfile);
 		doing_depend = FALSE;
+	    }
+	}
 	if (enterFlagObj)
 		printf("%s: Entering directory `%s'\n", progname, objdir);
 	MakeMode(NULL);
 	Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
 	bmake_free(p1);
-	if (!forceJobs && !compatMake &&
+	if (!forceJobs && !opts.compatMake &&
 	    Var_Exists(".MAKE.JOBS", VAR_GLOBAL)) {
 	    char *value;
 	    int n;
 	    (void)Var_Subst("${.MAKE.JOBS}", VAR_GLOBAL, VARE_WANTRES, &value);
 	    /* TODO: handle errors */
 	    n = (int)strtol(value, NULL, 0);
 	    if (n < 1) {
 		(void)fprintf(stderr, "%s: illegal value for .MAKE.JOBS -- must be positive integer!\n",
 		    progname);
 		exit(1);
+	    }
-	    if (n != maxJobs) {
+	    if (n != opts.maxJobs) {
 		Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
 		Var_Append(MAKEFLAGS, value, VAR_GLOBAL);
+	    }
-	    maxJobs = n;
+	    opts.maxJobs = n;
-	    maxJobTokens = maxJobs;
+	    maxJobTokens = opts.maxJobs;
 	    forceJobs = TRUE;
 	    free(value);
+	}
 	/*
 	 * Be compatible if user did not specify -j and did not explicitly
 	 * turned compatibility on
 	 */
-	if (!compatMake && !forceJobs) {
+	if (!opts.compatMake && !forceJobs) {
-	    compatMake = TRUE;
+	    opts.compatMake = TRUE;
+	}
-	if (!compatMake)
+	if (!opts.compatMake)
 	    Job_ServerStart(maxJobTokens, jp_0, jp_1);
 	DEBUG5(JOB, "job_pipe %d %d, maxjobs %d, tokens %d, compat %d\n",
-	       jp_0, jp_1, maxJobs, maxJobTokens, compatMake ? 1 : 0);
+	       jp_0, jp_1, opts.maxJobs, maxJobTokens, opts.compatMake ? 1 : 0);
-	if (!printVars)
+	if (!opts.printVars)
 	    Main_ExportMAKEFLAGS(TRUE);	/* initial export */
 	/*
 	 * For compatibility, look at the directories in the VPATH variable
 	 * and add them to the search path, if the variable is defined. The
 	 * variable's value is in the same format as the PATH envariable, i.e.
 	 * <directory>:<directory>:<directory>...
 	 */
 	if (Var_Exists("VPATH", VAR_CMD)) {
 		char *vpath, savec;
 		/*
 		 * GCC stores string constants in read-only memory, but
 @@ -1506,48 +1486,48 @@ main(int argc, char **argv)
 	 */
 	Suff_DoPaths();
 	/*
 	 * Propagate attributes through :: dependency lists.
 	 */
 	Targ_Propagate();
 	/* print the initial graph, if the user requested it */
 	if (DEBUG(GRAPH1))
 		Targ_PrintGraph(1);
 	/* print the values of any variables requested by the user */
-	if (printVars) {
+	if (opts.printVars) {
 		doPrintVars();
 		outOfDate = FALSE;
 	} else {
 		outOfDate = runTargets();
+	}
 #ifdef CLEANUP
-	Lst_Free(variables);
+	Lst_Free(opts.variables);
-	Lst_Free(makefiles);
+	Lst_Free(opts.makefiles);
-	Lst_Destroy(create, free);
+	Lst_Destroy(opts.create, free);
 #endif
 	/* print the graph now it's been processed if the user requested it */
 	if (DEBUG(GRAPH2))
 		Targ_PrintGraph(2);
 	Trace_Log(MAKEEND, 0);
 	if (enterFlagObj)
 		printf("%s: Leaving directory `%s'\n", progname, objdir);
-	if (enterFlag)
+	if (opts.enterFlag)
 		printf("%s: Leaving directory `%s'\n", progname, curdir);
 #ifdef USE_META
 	meta_finish();
 #endif
 	Suff_End();
 	Targ_End();
 	Arch_End();
 	Var_End();
 	Parse_End();
 	Dir_End();
 	Job_End();
 	Trace_End();
 @@ -1750,27 +1730,27 @@ bad:
     return bmake_strdup("");
+}
 /* Print a printf-style error message.
+ *
  * This error message has no consequences, in particular it does not affect
  * the exit status. */
 void
 Error(const char *fmt, ...)
+{
 	va_list ap;
 	FILE *err_file;
-	err_file = debug_file;
+	err_file = opts.debug_file;
 	if (err_file == stdout)
 		err_file = stderr;
 	(void)fflush(stdout);
 	for (;;) {
 		va_start(ap, fmt);
 		fprintf(err_file, "%s: ", progname);
 		(void)vfprintf(err_file, fmt, ap);
 		va_end(ap);
 		(void)fprintf(err_file, "\n");
 		(void)fflush(err_file);
 		if (err_file == stderr)
 			break;
 		err_file = stderr;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: make.c,v 1.180 2020/10/25 21:51:48 rillig Exp $	*/
+/*	$NetBSD: make.c,v 1.181 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -97,46 +97,46 @@
  *	Make_OODate	Determine if a target is out-of-date.
+ *
  *	Make_HandleUse	See if a child is a .USE node for a parent
  *			and perform the .USE actions if so.
+ *
  *	Make_ExpandUse	Expand .USE nodes
  */
 #include    "make.h"
 #include    "dir.h"
 #include    "job.h"
 /*	"@(#)make.c	8.1 (Berkeley) 6/6/93"	*/
-MAKE_RCSID("$NetBSD: make.c,v 1.180 2020/10/25 21:51:48 rillig Exp $");
+MAKE_RCSID("$NetBSD: make.c,v 1.181 2020/10/26 21:34:10 rillig Exp $");
 /* Sequence # to detect recursion. */
 static unsigned int checked = 1;
 /* The current fringe of the graph.
  * These are nodes which await examination by MakeOODate.
  * It is added to by Make_Update and subtracted from by MakeStartJobs */
 static GNodeList *toBeMade;
 static int MakeCheckOrder(void *, void *);
 static int MakeBuildParent(void *, void *);
 void
 debug_printf(const char *fmt, ...)
+{
     va_list args;
     va_start(args, fmt);
-    vfprintf(debug_file, fmt, args);
+    vfprintf(opts.debug_file, fmt, args);
     va_end(args);
+}
 MAKE_ATTR_DEAD static void
 make_abort(GNode *gn, int line)
+{
     debug_printf("make_abort from line %d\n", line);
     Targ_PrintNode(gn, 2);
     Targ_PrintNodes(toBeMade, 2);
     Targ_PrintGraph(3);
     abort();
+}
 @@ -170,27 +170,27 @@ GNode_FprintDetails(FILE *f, const char
     fprintf(f, "%smade %s, type %s, flags %s%s",
 	    prefix,
 	    Enum_ValueToString(gn->made, GNodeMade_ToStringSpecs),
 	    Enum_FlagsToString(type_buf, sizeof type_buf,
 			       gn->type, GNodeType_ToStringSpecs),
 	    Enum_FlagsToString(flags_buf, sizeof flags_buf,
 			       gn->flags, GNodeFlags_ToStringSpecs),
 	    suffix);
+}
 Boolean
 NoExecute(GNode *gn)
+{
-    return (gn->type & OP_MAKE) ? noRecursiveExecute : noExecute;
+    return (gn->type & OP_MAKE) ? opts.noRecursiveExecute : opts.noExecute;
+}
 /* Update the youngest child of the node, according to the given child. */
 void
 Make_TimeStamp(GNode *pgn, GNode *cgn)
+{
     if (pgn->youngestChild == NULL || cgn->mtime > pgn->youngestChild->mtime) {
 	pgn->youngestChild = cgn;
+    }
+}
 /* See if the node is out of date with respect to its sources.
+ *
 @@ -968,27 +968,27 @@ MakeStartJobs(void)
 	     * We can't build this yet, add all unmade children to toBeMade,
 	     * just before the current first element.
 	     */
 	    gn->made = DEFERRED;
 	    Lst_ForEachUntil(gn->children, MakeBuildChild, toBeMade->first);
 	    /* and drop this node on the floor */
 	    DEBUG2(MAKE, "dropped %s%s\n", gn->name, gn->cohort_num);
 	    continue;
+	}
 	gn->made = BEINGMADE;
 	if (Make_OODate(gn)) {
 	    DEBUG0(MAKE, "out-of-date\n");
-	    if (queryFlag) {
+	    if (opts.queryFlag) {
 		return TRUE;
+	    }
 	    Make_DoAllVar(gn);
 	    Job_Make(gn);
 	    have_token = 0;
 	} else {
 	    DEBUG0(MAKE, "up-to-date\n");
 	    gn->made = UPTODATE;
 	    if (gn->type & OP_JOIN) {
 		/*
 		 * Even for an up-to-date .JOIN node, we need it to have its
 		 * context variables so references to it get the correct
 		 * value for .TARGET when building up the context variables
 @@ -1007,30 +1007,30 @@ MakeStartJobs(void)
+}
 static void
 MakePrintStatusOrderNode(GNode *ogn, GNode *gn)
+{
     if (!(ogn->flags & REMAKE) || ogn->made > REQUESTED)
 	/* not waiting for this one */
 	return;
     printf("    `%s%s' has .ORDER dependency against %s%s ",
 	   gn->name, gn->cohort_num, ogn->name, ogn->cohort_num);
     GNode_FprintDetails(stdout, "(", ogn, ")\n");
-    if (DEBUG(MAKE) && debug_file != stdout) {
+    if (DEBUG(MAKE) && opts.debug_file != stdout) {
 	debug_printf("    `%s%s' has .ORDER dependency against %s%s ",
 		     gn->name, gn->cohort_num, ogn->name, ogn->cohort_num);
-	GNode_FprintDetails(debug_file, "(", ogn, ")\n");
+	GNode_FprintDetails(opts.debug_file, "(", ogn, ")\n");
+    }
+}
 static void
 MakePrintStatusOrder(GNode *gn)
+{
     GNodeListNode *ln;
     for (ln = gn->order_pred->first; ln != NULL; ln = ln->next)
         MakePrintStatusOrderNode(ln->datum, gn);
+}
 static void MakePrintStatusList(GNodeList *, int *);
 @@ -1050,38 +1050,38 @@ MakePrintStatus(GNode *gn, int *errors)
 	switch (gn->made) {
 	case UPTODATE:
 	    printf("`%s%s' is up to date.\n", gn->name, gn->cohort_num);
 	    break;
 	case MADE:
 	    break;
 	case UNMADE:
 	case DEFERRED:
 	case REQUESTED:
 	case BEINGMADE:
 	    (*errors)++;
 	    printf("`%s%s' was not built", gn->name, gn->cohort_num);
 	    GNode_FprintDetails(stdout, " (", gn, ")!\n");
-	    if (DEBUG(MAKE) && debug_file != stdout) {
+	    if (DEBUG(MAKE) && opts.debug_file != stdout) {
 		debug_printf("`%s%s' was not built", gn->name, gn->cohort_num);
-		GNode_FprintDetails(debug_file, " (", gn, ")!\n");
+		GNode_FprintDetails(opts.debug_file, " (", gn, ")!\n");
+	    }
 	    /* Most likely problem is actually caused by .ORDER */
 	    MakePrintStatusOrder(gn);
 	    break;
 	default:
 	    /* Errors - already counted */
 	    printf("`%s%s' not remade because of errors.\n",
 		    gn->name, gn->cohort_num);
-	    if (DEBUG(MAKE) && debug_file != stdout)
+	    if (DEBUG(MAKE) && opts.debug_file != stdout)
 		debug_printf("`%s%s' not remade because of errors.\n",
 			     gn->name, gn->cohort_num);
 	    break;
+	}
 	return FALSE;
+    }
     DEBUG3(MAKE, "MakePrintStatus: %s%s has %d unmade children\n",
 	   gn->name, gn->cohort_num, gn->unmade);
     /*
      * If printing cycles and came to one that has unmade children,
      * print out the cycle by recursing on its children.
      */
 @@ -1312,27 +1312,27 @@ Make_Run(GNodeList *targs)
     int errors;			/* Number of errors the Job module reports */
     /* Start trying to make the current targets... */
     toBeMade = Lst_New();
     Make_ExpandUse(targs);
     Make_ProcessWait(targs);
     if (DEBUG(MAKE)) {
 	 debug_printf("#***# full graph\n");
 	 Targ_PrintGraph(1);
+    }
-    if (queryFlag) {
+    if (opts.queryFlag) {
 	/*
 	 * We wouldn't do any work unless we could start some jobs in the
 	 * next loop... (we won't actually start any, of course, this is just
 	 * to see if any of the targets was out of date)
 	 */
 	return MakeStartJobs();
+    }
     /*
      * Initialization. At the moment, no jobs are running and until some
      * get started, nothing will happen since the remaining upward
      * traversal of the graph is performed by the routines in job.c upon
      * the finishing of a job. So we fill the Job table as much as we can
      * before going into our loop.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: make.h,v 1.172 2020/10/25 21:51:49 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.173 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -410,60 +410,33 @@ typedef enum CondEvalResult {
 #define ARCHIVE		"!"	/* Archive in "archive(member)" syntax */
 #define MEMBER		"%"	/* Member in "archive(member)" syntax */
 #define FTARGET		"@F"	/* file part of TARGET */
 #define DTARGET		"@D"	/* directory part of TARGET */
 #define FIMPSRC		"<F"	/* file part of IMPSRC */
 #define DIMPSRC		"<D"	/* directory part of IMPSRC */
 #define FPREFIX		"*F"	/* file part of PREFIX */
 #define DPREFIX		"*D"	/* directory part of PREFIX */
 /*
  * Global Variables
  */
 extern StringList *create;	/* The list of target names specified on the
 				 * command line. used to resolve #if
 				 * make(...) statements */
 extern SearchPath *dirSearchPath;
 				/* The list of directories to search when
 				 * looking for targets */
 extern Boolean	compatMake;	/* True if we are make compatible */
 extern Boolean	ignoreErrors;	/* True if should ignore all errors */
 extern Boolean  beSilent;	/* True if should print no commands */
 extern Boolean  noExecute;	/* True if should execute almost nothing */
 extern Boolean  noRecursiveExecute;
 				/* True if should execute nothing */
 extern Boolean  allPrecious;	/* True if every target is precious */
 extern Boolean  deleteOnError;	/* True if failed targets should be deleted */
 extern Boolean  keepgoing;	/* True if should continue on unaffected
 				 * portions of the graph when an error occurs
 				 * in one portion */
 extern Boolean	touchFlag;	/* TRUE if targets should just be 'touched'
 				 * if out of date. Set by the -t flag */
 extern Boolean	queryFlag;	/* TRUE if we aren't supposed to really make
 				 * anything, just see if the targets are out-
 				 * of-date */
 extern Boolean	doing_depend;	/* TRUE if processing .depend */
 extern Boolean	checkEnvFirst;	/* TRUE if environment should be searched for
 				 * variables before the global context */
 extern Boolean	parseWarnFatal;	/* TRUE if makefile parsing warnings are
 				 * treated as errors */
 extern Boolean	varNoExportEnv;	/* TRUE if we should not export variables
 				 * set on the command line to the env. */
 extern GNode    *DEFAULT;	/* .DEFAULT rule */
 extern GNode	*VAR_INTERNAL;	/* Variables defined internally by make
 				 * which should not override those set by
 				 * makefiles.
 				 */
 extern GNode    *VAR_GLOBAL;	/* Variables defined in a global context, e.g
 				 * in the Makefile itself */
 extern GNode    *VAR_CMD;	/* Variables defined on the command line */
 extern char	var_Error[];	/* Value returned by Var_Parse when an error
 				 * is encountered. It actually points to
 				 * an empty string, so naive callers needn't
 				 * worry about it. */
 @@ -519,37 +492,29 @@ typedef enum DebugFlags {
     DEBUG_ERROR		= 1 << 12,
     DEBUG_LOUD		= 1 << 13,
     DEBUG_META		= 1 << 14,
     DEBUG_HASH		= 1 << 15,
     DEBUG_GRAPH3	= 1 << 16,
     DEBUG_SCRIPT	= 1 << 17,
     DEBUG_PARSE		= 1 << 18,
     DEBUG_CWD		= 1 << 19,
     DEBUG_LINT		= 1 << 20
 } DebugFlags;
 /*
  * debug control:
  *	There is one bit per module.  It is up to the module what debug
  *	information to print.
  */
 extern FILE *debug_file;	/* Output is written here - default stderr */
 extern DebugFlags debug;
 #define CONCAT(a,b)	a##b
-#define	DEBUG(module)	(debug & CONCAT(DEBUG_,module))
+#define	DEBUG(module)	(opts.debug & CONCAT(DEBUG_,module))
 void debug_printf(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2);
 #define DEBUG0(module, text) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf("%s", text)
 #define DEBUG1(module, fmt, arg1) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1)
 #define DEBUG2(module, fmt, arg1, arg2) \
     if (!DEBUG(module)) (void)0; \
 @@ -557,26 +522,103 @@ void debug_printf(const char *, ...) MAK
 #define DEBUG3(module, fmt, arg1, arg2, arg3) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2, arg3)
 #define DEBUG4(module, fmt, arg1, arg2, arg3, arg4) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2, arg3, arg4)
 #define DEBUG5(module, fmt, arg1, arg2, arg3, arg4, arg5) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2, arg3, arg4, arg5)
 typedef enum PrintVarsMode {
     COMPAT_VARS = 1,
     EXPAND_VARS
 } PrintVarsMode;
 /* Command line options */
 typedef struct CmdOpts {
     /* -B: whether we are make compatible */
     Boolean compatMake;
     /* -d: debug control: There is one bit per module.  It is up to the
      * module what debug information to print. */
     DebugFlags debug;
     /* -df: debug output is written here - default stderr */
     FILE *debug_file;
     /* -e: check environment variables before global variables */
     Boolean checkEnvFirst;
     /* -f: the makefiles to read */
     StringList *makefiles;
     /* -i: if true, ignore all errors from shell commands */
     Boolean ignoreErrors;
     /* -j: the maximum number of jobs that can run in parallel;
      * this is coordinated with the submakes */
     int maxJobs;
     /* -k: if true, continue on unaffected portions of the graph when an
      * error occurs in one portion */
     Boolean keepgoing;
     /* -N: execute no commands from the targets */
     Boolean noRecursiveExecute;
     /* -n: execute almost no commands from the targets */
     Boolean noExecute;
     /* -q: if true, we aren't supposed to really make anything, just see if
      * the targets are out-of-date */
     Boolean queryFlag;
     /* -r: raw mode, without loading the builtin rules. */
     Boolean noBuiltins;
     /* -s: don't echo the shell commands before executing them */
     Boolean beSilent;
     /* -t: touch the targets if they are out-of-date, but don't actually
      * make them */
     Boolean touchFlag;
     /* -[Vv]: print expanded or unexpanded selected variables */
     PrintVarsMode printVars;
     /* -[Vv]: the variables to print */
     StringList *variables;
     /* -W: if true, makefile parsing warnings are treated as errors */
     Boolean parseWarnFatal;
     /* -w: print Entering and Leaving for submakes */
     Boolean enterFlag;
     /* -X: if true, do not export variables set on the command line to the
      * environment. */
     Boolean varNoExportEnv;
     /* The target names specified on the command line.
      * Used to resolve .if make(...) statements. */
     StringList *create;
 } CmdOpts;
 extern CmdOpts opts;
 #include "nonints.h"
 void Make_TimeStamp(GNode *, GNode *);
 Boolean Make_OODate(GNode *);
 void Make_ExpandUse(GNodeList *);
 time_t Make_Recheck(GNode *);
 void Make_HandleUse(GNode *, GNode *);
 void Make_Update(GNode *);
 void Make_DoAllVar(GNode *);
 Boolean Make_Run(GNodeList *);
 int dieQuietly(GNode *, int);
 void PrintOnError(GNode *, const char *);
 void Main_ExportMAKEFLAGS(Boolean);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.400 2020/10/25 13:06:12 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.401 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -121,27 +121,27 @@
 #ifndef MAP_FILE
 #define MAP_FILE 0
 #endif
 #ifndef MAP_COPY
 #define MAP_COPY MAP_PRIVATE
 #endif
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: parse.c,v 1.400 2020/10/25 13:06:12 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.401 2020/10/26 21:34:10 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
     char *fname;		/* name of file */
     Boolean fromForLoop;	/* simulated .include by the .for loop */
     int lineno;			/* current line number in file */
     int first_lineno;		/* line number of start of text */
     unsigned int cond_depth;	/* 'if' nesting when file opened */
     Boolean depending;		/* state of doing_depend on EOF */
 @@ -658,48 +658,49 @@ ParseVErrorInternal(FILE *f, const char
 	(void)fprintf(f, "%s: ", progname);
 	if (cfname != NULL)
 		PrintLocation(f, cfname, clineno);
 	if (type == PARSE_WARNING)
 		(void)fprintf(f, "warning: ");
 	(void)vfprintf(f, fmt, ap);
 	(void)fprintf(f, "\n");
 	(void)fflush(f);
 	if (type == PARSE_INFO)
 		return;
-	if (type == PARSE_FATAL || parseWarnFatal)
+	if (type == PARSE_FATAL || opts.parseWarnFatal)
 		fatals++;
-	if (parseWarnFatal && !fatal_warning_error_printed) {
+	if (opts.parseWarnFatal && !fatal_warning_error_printed) {
 		Error("parsing warnings being treated as errors");
 		fatal_warning_error_printed = TRUE;
+	}
+}
 static void
 ParseErrorInternal(const char *cfname, size_t clineno, ParseErrorLevel type,
 		   const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	(void)fflush(stdout);
 	ParseVErrorInternal(stderr, cfname, clineno, type, fmt, ap);
 	va_end(ap);
-	if (debug_file != stderr && debug_file != stdout) {
+	if (opts.debug_file != stderr && opts.debug_file != stdout) {
 		va_start(ap, fmt);
-		ParseVErrorInternal(debug_file, cfname, clineno, type, fmt, ap);
+		ParseVErrorInternal(opts.debug_file, cfname, clineno, type,
 				    fmt, ap);
 		va_end(ap);
+	}
+}
 /* External interface to ParseErrorInternal; uses the default filename and
  * line number.
+ *
  * Fmt is given without a trailing newline. */
 void
 Parse_Error(ParseErrorLevel type, const char *fmt, ...)
+{
 	va_list ap;
 	const char *fname;
 @@ -708,29 +709,30 @@ Parse_Error(ParseErrorLevel type, const
 	if (curFile == NULL) {
 		fname = NULL;
 		lineno = 0;
 	} else {
 		fname = curFile->fname;
 		lineno = (size_t)curFile->lineno;
+	}
 	va_start(ap, fmt);
 	(void)fflush(stdout);
 	ParseVErrorInternal(stderr, fname, lineno, type, fmt, ap);
 	va_end(ap);
-	if (debug_file != stderr && debug_file != stdout) {
+	if (opts.debug_file != stderr && opts.debug_file != stdout) {
 		va_start(ap, fmt);
-		ParseVErrorInternal(debug_file, fname, lineno, type, fmt, ap);
+		ParseVErrorInternal(opts.debug_file, fname, lineno, type,
 				    fmt, ap);
 		va_end(ap);
+	}
+}
 /* Parse a .info .warning or .error directive.
+ *
  * The input is the line minus the ".".  We substitute variables, print the
  * message and exit(1) (for .error) or just print a warning if the directive
  * is malformed.
  */
 static Boolean
 ParseMessage(const char *directive)
 @@ -900,27 +902,27 @@ ParseDoSrcKeyword(const char *src, Parse
+}
 static void
 ParseDoSrcMain(const char *src)
+{
     /*
      * If we have noted the existence of a .MAIN, it means we need
      * to add the sources of said target to the list of things
      * to create. The string 'src' is likely to be free, so we
      * must make a new copy of it. Note that this will only be
      * invoked if the user didn't specify a target on the command
      * line. This is to allow #ifmake's to succeed, or something...
      */
-    Lst_Append(create, bmake_strdup(src));
+    Lst_Append(opts.create, bmake_strdup(src));
     /*
      * Add the name to the .TARGETS variable as well, so the user can
      * employ that, if desired.
      */
     Var_Append(".TARGETS", src, VAR_GLOBAL);
+}
 static void
 ParseDoSrcOrder(const char *src)
+{
     GNode *gn;
     /*
      * Create proper predecessor/successor links between the previous
 @@ -1115,57 +1117,57 @@ ParseDependencyTargetWord(/*const*/ char
 static void
 ParseDoDependencyTargetSpecial(ParseSpecial *inout_specType,
 			       const char *line,
 			       SearchPathList **inout_paths)
+{
     switch (*inout_specType) {
     case ExPath:
 	if (*inout_paths == NULL) {
 	    *inout_paths = Lst_New();
+	}
 	Lst_Append(*inout_paths, dirSearchPath);
 	break;
     case Main:
-	if (!Lst_IsEmpty(create)) {
+	if (!Lst_IsEmpty(opts.create)) {
 	    *inout_specType = Not;
+	}
 	break;
     case Begin:
     case End:
     case Stale:
     case dotError:
     case Interrupt: {
 	GNode *gn = Targ_GetNode(line);
 	if (doing_depend)
 	    ParseMark(gn);
 	gn->type |= OP_NOTMAIN|OP_SPECIAL;
 	Lst_Append(targets, gn);
 	break;
+    }
     case Default: {
 	GNode *gn = Targ_NewGN(".DEFAULT");
 	gn->type |= OP_NOTMAIN|OP_TRANSFORM;
 	Lst_Append(targets, gn);
 	DEFAULT = gn;
 	break;
+    }
     case DeleteOnError:
 	deleteOnError = TRUE;
 	break;
     case NotParallel:
-	maxJobs = 1;
+	opts.maxJobs = 1;
 	break;
     case SingleShell:
-	compatMake = TRUE;
+	opts.compatMake = TRUE;
 	break;
     case Order:
 	predecessor = NULL;
 	break;
     default:
 	break;
+    }
+}
 /*
  * .PATH<suffix> has to be handled specially.
  * Call on the suffix module to give us a path to modify.
  */
 @@ -1351,30 +1353,30 @@ ClearPaths(SearchPathList *paths)
+}
 static void
 ParseDoDependencySourcesEmpty(ParseSpecial specType, SearchPathList *paths)
+{
     switch (specType) {
     case Suffixes:
 	Suff_ClearSuffixes();
 	break;
     case Precious:
 	allPrecious = TRUE;
 	break;
     case Ignore:
-	ignoreErrors = TRUE;
+	opts.ignoreErrors = TRUE;
 	break;
     case Silent:
-	beSilent = TRUE;
+	opts.beSilent = TRUE;
 	break;
     case ExPath:
 	ClearPaths(paths);
 	break;
 #ifdef POSIX
     case Posix:
 	Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
 	break;
 #endif
     default:
 	break;
+    }
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: cond.c,v 1.168 2020/10/24 04:51:19 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.169 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -83,27 +83,27 @@
  *	Cond_restore_depth
  *			Save and restore the nesting of the conditions, at
  *			the start and end of including another makefile, to
  *			ensure that in each makefile the conditional
  *			directives are well-balanced.
  */
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)cond.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: cond.c,v 1.168 2020/10/24 04:51:19 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.169 2020/10/26 21:34:10 rillig Exp $");
 /*
  * The parsing of conditional expressions is based on this grammar:
  *	E -> F || E
  *	E -> F
  *	F -> T && F
  *	F -> T
  *	T -> defined(variable)
  *	T -> make(target)
  *	T -> exists(file)
  *	T -> empty(varspec)
  *	T -> target(name)
  *	T -> commands(name)
 @@ -284,27 +284,27 @@ FuncDefined(size_t argLen MAKE_ATTR_UNUS
+{
     char *freeIt;
     Boolean result = Var_Value(arg, VAR_CMD, &freeIt) != NULL;
     bmake_free(freeIt);
     return result;
+}
 /* See if the given target is being made. */
 static Boolean
 FuncMake(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
+{
     StringListNode *ln;
-    for (ln = create->first; ln != NULL; ln = ln->next)
+    for (ln = opts.create->first; ln != NULL; ln = ln->next)
 	if (Str_Match(ln->datum, arg))
 	    return TRUE;
     return FALSE;
+}
 /* See if the given file exists. */
 static Boolean
 FuncExists(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
+{
     Boolean result;
     char *path;
     path = Dir_FindFile(arg, dirSearchPath);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.h,v 1.57 2020/10/23 07:14:32 rillig Exp $	*/
+/*	$NetBSD: job.h,v 1.58 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -182,27 +182,26 @@ typedef struct Job {
     char outBuf[JOB_BUFSIZE + 1];
     size_t curPos;		/* Current position in outBuf. */
 #ifdef USE_META
     struct BuildMon bm;
 #endif
 } Job;
 extern const char *shellPath;
 extern const char *shellName;
 extern char *shellErrFlag;
 extern int jobTokensRunning;	/* tokens currently "out" */
 extern int maxJobs;		/* Max jobs we can run */
 void Shell_Init(void);
 const char *Shell_GetNewline(void);
 void Job_Touch(GNode *, Boolean);
 Boolean Job_CheckCommands(GNode *, void (*abortProc)(const char *, ...));
 void Job_CatchChildren(void);
 void Job_CatchOutput(void);
 void Job_Make(GNode *);
 void Job_Init(void);
 Boolean Job_ParseShell(char *);
 int Job_Finish(void);
 void Job_End(void);
 void Job_Wait(void);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: targ.c,v 1.124 2020/10/25 21:51:49 rillig Exp $	*/
+/*	$NetBSD: targ.c,v 1.125 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -111,27 +111,27 @@
  * Debugging:
  *	Targ_PrintGraph
  *			Print out the entire graphm all variables and
  *			statistics for the directory cache. Should print
  *			something for suffixes, too, but...
  */
 #include <time.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)targ.c	8.2 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: targ.c,v 1.124 2020/10/25 21:51:49 rillig Exp $");
+MAKE_RCSID("$NetBSD: targ.c,v 1.125 2020/10/26 21:34:10 rillig Exp $");
 static GNodeList *allTargets;	/* the list of all targets found so far */
 #ifdef CLEANUP
 static GNodeList *allGNs;	/* List of all the GNodes */
 #endif
 static HashTable targets;	/* a hash table of same */
 #ifdef CLEANUP
 static void TargFreeGN(void *);
 #endif
 void
 Targ_Init(void)
 @@ -295,34 +295,34 @@ Targ_FindList(StringList *names)
     GNodeList *nodes = Lst_New();
     for (ln = names->first; ln != NULL; ln = ln->next) {
 	const char *name = ln->datum;
 	GNode *gn = Targ_GetNode(name);
 	Lst_Append(nodes, gn);
+    }
     return nodes;
+}
 /* Return true if should ignore errors when creating gn. */
 Boolean
 Targ_Ignore(GNode *gn)
+{
-    return ignoreErrors || gn->type & OP_IGNORE;
+    return opts.ignoreErrors || gn->type & OP_IGNORE;
+}
 /* Return true if be silent when creating gn. */
 Boolean
 Targ_Silent(GNode *gn)
+{
-    return beSilent || gn->type & OP_SILENT;
+    return opts.beSilent || gn->type & OP_SILENT;
+}
 /* See if the given target is precious. */
 Boolean
 Targ_Precious(GNode *gn)
+{
     return allPrecious || gn->type & (OP_PRECIOUS | OP_DOUBLEDEP);
+}
 /******************* DEBUG INFO PRINTING ****************/
 static GNode	  *mainTarg;	/* the main target, as set by Targ_SetMain */
 @@ -439,27 +439,27 @@ GNode_OpName(const GNode *gn)
     case OP_FORCE:
 	return "!";
     case OP_DOUBLEDEP:
 	return "::";
+    }
     return "";
+}
 /* Print the contents of a node. */
 void
 Targ_PrintNode(GNode *gn, int pass)
+{
     debug_printf("# %s%s", gn->name, gn->cohort_num);
-    GNode_FprintDetails(debug_file, ", ", gn, "\n");
+    GNode_FprintDetails(opts.debug_file, ", ", gn, "\n");
     if (gn->flags == 0)
 	return;
     if (GNode_IsTarget(gn)) {
 	debug_printf("#\n");
 	if (gn == mainTarg) {
 	    debug_printf("# *** MAIN TARGET ***\n");
+	}
 	if (pass >= 2) {
 	    if (gn->unmade) {
 		debug_printf("# %d unmade children\n", gn->unmade);
 	    } else {
 		debug_printf("# No unmade children\n");

 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.589 2020/10/25 21:51:49 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.590 2020/10/26 21:34:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -111,27 +111,27 @@
 #include    <sys/types.h>
 #include    <regex.h>
 #endif
 #include    <inttypes.h>
 #include    <limits.h>
 #include    <time.h>
 #include    "make.h"
 #include    "dir.h"
 #include    "job.h"
 #include    "metachar.h"
 /*	"@(#)var.c	8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: var.c,v 1.589 2020/10/25 21:51:49 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.590 2020/10/26 21:34:10 rillig Exp $");
 #define VAR_DEBUG1(fmt, arg1) DEBUG1(VAR, fmt, arg1)
 #define VAR_DEBUG2(fmt, arg1, arg2) DEBUG2(VAR, fmt, arg1, arg2)
 #define VAR_DEBUG3(fmt, arg1, arg2, arg3) DEBUG3(VAR, fmt, arg1, arg2, arg3)
 #define VAR_DEBUG4(fmt, arg1, arg2, arg3, arg4) DEBUG4(VAR, fmt, arg1, arg2, arg3, arg4)
 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 @@ -370,45 +370,45 @@ VarFind(const char *name, GNode *ctxt, V
     name = CanonicalVarname(name);
     nameHash = Hash_Hash(name);
     /*
      * First look for the variable in the given context. If it's not there,
      * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'
      */
     var = GNode_FindVar(ctxt, name, nameHash);
     if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD)
 	var = GNode_FindVar(VAR_CMD, name, nameHash);
-    if (!checkEnvFirst && var == NULL && (flags & FIND_GLOBAL) &&
+    if (!opts.checkEnvFirst && var == NULL && (flags & FIND_GLOBAL) &&
 	ctxt != VAR_GLOBAL)
+    {
 	var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	if (var == NULL && ctxt != VAR_INTERNAL) {
 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 	    var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
+	}
+    }
     if (var == NULL && (flags & FIND_ENV)) {
 	char *env;
 	if ((env = getenv(name)) != NULL) {
 	    char *varname = bmake_strdup(name);
 	    return VarNew(varname, varname, env, VAR_FROM_ENV);
+	}
-	if (checkEnvFirst && (flags & FIND_GLOBAL) && ctxt != VAR_GLOBAL) {
+	if (opts.checkEnvFirst && (flags & FIND_GLOBAL) && ctxt != VAR_GLOBAL) {
 	    var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	    if (var == NULL && ctxt != VAR_INTERNAL)
 		var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
 	    return var;
+	}
 	return NULL;
+    }
     return var;
+}
 /*-
 @@ -834,27 +834,27 @@ Var_Set_with_flags(const char *name, con
     if (ctxt == VAR_CMD && !(flags & VAR_NO_EXPORT) && name[0] != '.') {
 	if (v == NULL) {
 	    /* we just added it */
 	    v = VarFind(name, ctxt, 0);
+	}
 	if (v != NULL)
 	    v->flags |= VAR_FROM_CMD;
 	/*
 	 * If requested, don't export these in the environment
 	 * individually.  We still put them in MAKEOVERRIDES so
 	 * that the command-line settings continue to override
 	 * Makefile settings.
 	 */
-	if (!varNoExportEnv)
+	if (!opts.varNoExportEnv)
 	    setenv(name, val ? val : "", 1);
 	Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
+    }
     if (name[0] == '.' && strcmp(name, SAVE_DOLLARS) == 0)
 	save_dollars = s2Boolean(val, save_dollars);
 out:
     free(name_freeIt);
     if (v != NULL)
 	VarFreeEnv(v, TRUE);
+}