 @@ -1,1629 +1,1630 @@
-/*	$NetBSD: eval.c,v 1.160 2018/08/22 20:08:54 kre Exp $	*/
+/*	$NetBSD: eval.c,v 1.161 2018/08/25 02:42:49 kre Exp $	*/
 /*-
  * Copyright (c) 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Kenneth Almquist.
+ *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)eval.c	8.9 (Berkeley) 6/8/95";
 #else
-__RCSID("$NetBSD: eval.c,v 1.160 2018/08/22 20:08:54 kre Exp $");
+__RCSID("$NetBSD: eval.c,v 1.161 2018/08/25 02:42:49 kre Exp $");
 #endif
 #endif /* not lint */
 #include <stdbool.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <limits.h>
 #include <unistd.h>
 #include <sys/fcntl.h>
 #include <sys/stat.h>
 #include <sys/times.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/sysctl.h>
 /*
  * Evaluate a command.
  */
 #include "shell.h"
 #include "nodes.h"
 #include "syntax.h"
 #include "expand.h"
 #include "parser.h"
 #include "jobs.h"
 #include "eval.h"
 #include "builtins.h"
 #include "options.h"
 #include "exec.h"
 #include "redir.h"
 #include "input.h"
 #include "output.h"
 #include "trap.h"
 #include "var.h"
 #include "memalloc.h"
 #include "error.h"
 #include "show.h"
 #include "mystring.h"
 #include "main.h"
 #ifndef SMALL
 #include "nodenames.h"
 #include "myhistedit.h"
 #endif
 STATIC enum skipstate evalskip;	/* != SKIPNONE if we are skipping commands */
 STATIC int skipcount;		/* number of levels to skip */
 STATIC int loopnest;		/* current loop nesting level */
 STATIC int funcnest;		/* depth of function calls */
 STATIC int builtin_flags;	/* evalcommand flags for builtins */
 /*
  * Base function nesting level inside a dot command.  Set to 0 initially
  * and to (funcnest + 1) before every dot command to enable
  *   1) detection of being in a file sourced by a dot command and
  *   2) counting of function nesting in that file for the implementation
  *      of the return command.
  * The value is reset to its previous value after the dot command.
  */
 STATIC int dot_funcnest;
 const char *commandname;
 struct strlist *cmdenviron;
 int exitstatus;			/* exit status of last command */
 int back_exitstatus;		/* exit status of backquoted command */
 STATIC void evalloop(union node *, int);
 STATIC void evalfor(union node *, int);
 STATIC void evalcase(union node *, int);
 STATIC void evalsubshell(union node *, int);
 STATIC void expredir(union node *);
 STATIC void evalredir(union node *, int);
 STATIC void evalpipe(union node *);
 STATIC void evalcommand(union node *, int, struct backcmd *);
 STATIC void prehash(union node *);
 STATIC char *find_dot_file(char *);
 /*
  * Called to reset things after an exception.
  */
 #ifdef mkinit
 INCLUDE "eval.h"
 RESET {
 	reset_eval();
+}
 SHELLPROC {
 	exitstatus = 0;
+}
 #endif
 void
 reset_eval(void)
+{
 	evalskip = SKIPNONE;
 	dot_funcnest = 0;
 	loopnest = 0;
 	funcnest = 0;
+}
 static int
 sh_pipe(int fds[2])
+{
 	int nfd;
 	if (pipe(fds))
 		return -1;
 	if (fds[0] < 3) {
 		nfd = fcntl(fds[0], F_DUPFD, 3);
 		if (nfd != -1) {
 			close(fds[0]);
 			fds[0] = nfd;
+		}
+	}
 	if (fds[1] < 3) {
 		nfd = fcntl(fds[1], F_DUPFD, 3);
 		if (nfd != -1) {
 			close(fds[1]);
 			fds[1] = nfd;
+		}
+	}
 	return 0;
+}
 /*
  * The eval commmand.
  */
 int
 evalcmd(int argc, char **argv)
+{
 	char *p;
 	char *concat;
 	char **ap;
 	if (argc > 1) {
 		p = argv[1];
 		if (argc > 2) {
 			STARTSTACKSTR(concat);
 			ap = argv + 2;
 			for (;;) {
 				while (*p)
 					STPUTC(*p++, concat);
 				if ((p = *ap++) == NULL)
 					break;
 				STPUTC(' ', concat);
+			}
 			STPUTC('\0', concat);
 			p = grabstackstr(concat);
+		}
 		evalstring(p, builtin_flags & EV_TESTED);
 	} else
 		exitstatus = 0;
 	return exitstatus;
+}
 /*
  * Execute a command or commands contained in a string.
  */
 void
 evalstring(char *s, int flag)
+{
 	union node *n;
 	struct stackmark smark;
 	int last;
 	int any;
 	last = flag & EV_EXIT;
 	flag &= ~EV_EXIT;
 	setstackmark(&smark);
 	setinputstring(s, 1, line_number);
 	any = 0;	/* to determine if exitstatus will have been set */
 	while ((n = parsecmd(0)) != NEOF) {
 		XTRACE(DBG_EVAL, ("evalstring: "), showtree(n));
 		if (n && nflag == 0) {
 			if (last && at_eof())
 				evaltree(n, flag | EV_EXIT);
 			else
 				evaltree(n, flag);
 			any = 1;
+		}
 		rststackmark(&smark);
+	}
 	popfile();
 	popstackmark(&smark);
 	if (!any)
 		exitstatus = 0;
 	if (last)
 		exraise(EXEXIT);
+}
 /*
  * Evaluate a parse tree.  The value is left in the global variable
  * exitstatus.
  */
 void
 evaltree(union node *n, int flags)
+{
 	bool do_etest;
 	int sflags = flags & ~EV_EXIT;
 	union node *next;
 	struct stackmark smark;
 	do_etest = false;
 	if (n == NULL || nflag) {
 		VTRACE(DBG_EVAL, ("evaltree(%s) called\n",
 		    n == NULL ? "NULL" : "-n"));
 		if (nflag == 0)
 			exitstatus = 0;
 		goto out2;
+	}
 	setstackmark(&smark);
 	do {
 #ifndef SMALL
 		displayhist = 1; /* show history substitutions done with fc */
 #endif
 		next = NULL;
 		CTRACE(DBG_EVAL, ("pid %d, evaltree(%p: %s(%d), %#x) called\n",
 		    getpid(), n, NODETYPENAME(n->type), n->type, flags));
 		switch (n->type) {
 		case NSEMI:
 			evaltree(n->nbinary.ch1, sflags);
 			if (nflag || evalskip)
 				goto out1;
 			next = n->nbinary.ch2;
 			break;
 		case NAND:
 			evaltree(n->nbinary.ch1, EV_TESTED);
 			if (nflag || evalskip || exitstatus != 0)
 				goto out1;
 			next = n->nbinary.ch2;
 			break;
 		case NOR:
 			evaltree(n->nbinary.ch1, EV_TESTED);
 			if (nflag || evalskip || exitstatus == 0)
 				goto out1;
 			next = n->nbinary.ch2;
 			break;
 		case NREDIR:
 			evalredir(n, flags);
 			break;
 		case NSUBSHELL:
 			evalsubshell(n, flags);
 			do_etest = !(flags & EV_TESTED);
 			break;
 		case NBACKGND:
 			evalsubshell(n, flags);
 			break;
 		case NIF: {
 			evaltree(n->nif.test, EV_TESTED);
 			if (nflag || evalskip)
 				goto out1;
 			if (exitstatus == 0)
 				next = n->nif.ifpart;
 			else if (n->nif.elsepart)
 				next = n->nif.elsepart;
 			else
 				exitstatus = 0;
 			break;
+		}
 		case NWHILE:
 		case NUNTIL:
 			evalloop(n, sflags);
 			break;
 		case NFOR:
 			evalfor(n, sflags);
 			break;
 		case NCASE:
 			evalcase(n, sflags);
 			break;
 		case NDEFUN:
 			CTRACE(DBG_EVAL, ("Defining fn %s @%d%s\n",
 			    n->narg.text, n->narg.lineno,
 			    fnline1 ? " LINENO=1" : ""));
 			defun(n->narg.text, n->narg.next, n->narg.lineno);
 			exitstatus = 0;
 			break;
 		case NNOT:
 			evaltree(n->nnot.com, EV_TESTED);
 			exitstatus = !exitstatus;
 			break;
 		case NDNOT:
 			evaltree(n->nnot.com, EV_TESTED);
 			if (exitstatus != 0)
 				exitstatus = 1;
 			break;
 		case NPIPE:
 			evalpipe(n);
 			do_etest = !(flags & EV_TESTED);
 			break;
 		case NCMD:
 			evalcommand(n, flags, NULL);
 			do_etest = !(flags & EV_TESTED);
 			break;
 		default:
 #ifdef NODETYPENAME
 			out1fmt("Node type = %d(%s)\n",
 				n->type, NODETYPENAME(n->type));
 #else
 			out1fmt("Node type = %d\n", n->type);
 #endif
 			flushout(&output);
 			break;
+		}
 		n = next;
 		rststackmark(&smark);
 	} while(n != NULL);
  out1:
 	popstackmark(&smark);
  out2:
 	if (pendingsigs)
 		dotrap();
 	if (eflag && exitstatus != 0 && do_etest)
 		exitshell(exitstatus);
 	if (flags & EV_EXIT)
 		exraise(EXEXIT);
+}
 STATIC void
 evalloop(union node *n, int flags)
+{
 	int status;
 	loopnest++;
 	status = 0;
 	CTRACE(DBG_EVAL,  ("evalloop %s:", NODETYPENAME(n->type)));
 	VXTRACE(DBG_EVAL, (" "), showtree(n->nbinary.ch1));
 	VXTRACE(DBG_EVAL, ("evalloop    do: "), showtree(n->nbinary.ch2));
 	VTRACE(DBG_EVAL,  ("evalloop  done\n"));
 	CTRACE(DBG_EVAL,  ("\n"));
 	for (;;) {
 		evaltree(n->nbinary.ch1, EV_TESTED);
 		if (nflag)
 			break;
 		if (evalskip) {
  skipping:		if (evalskip == SKIPCONT && --skipcount <= 0) {
 				evalskip = SKIPNONE;
 				continue;
+			}
 			if (evalskip == SKIPBREAK && --skipcount <= 0)
 				evalskip = SKIPNONE;
 			break;
+		}
 		if (n->type == NWHILE) {
 			if (exitstatus != 0)
 				break;
 		} else {
 			if (exitstatus == 0)
 				break;
+		}
 		evaltree(n->nbinary.ch2, flags & EV_TESTED);
 		status = exitstatus;
 		if (evalskip)
 			goto skipping;
+	}
 	loopnest--;
 	exitstatus = status;
+}
 STATIC void
 evalfor(union node *n, int flags)
+{
 	struct arglist arglist;
 	union node *argp;
 	struct strlist *sp;
 	struct stackmark smark;
 	int status;
 	status = nflag ? exitstatus : 0;
 	setstackmark(&smark);
 	arglist.lastp = &arglist.list;
 	for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
 		expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
 		if (evalskip)
 			goto out;
+	}
 	*arglist.lastp = NULL;
 	loopnest++;
 	for (sp = arglist.list ; sp ; sp = sp->next) {
 		if (xflag) {
 			outxstr(expandstr(ps4val(), line_number));
 			outxstr("for ");
 			outxstr(n->nfor.var);
 			outxc('=');
 			outxshstr(sp->text);
 			outxc('\n');
 			flushout(outx);
+		}
 		setvar(n->nfor.var, sp->text, 0);
 		evaltree(n->nfor.body, flags & EV_TESTED);
 		status = exitstatus;
 		if (nflag)
 			break;
 		if (evalskip) {
 			if (evalskip == SKIPCONT && --skipcount <= 0) {
 				evalskip = SKIPNONE;
 				continue;
+			}
 			if (evalskip == SKIPBREAK && --skipcount <= 0)
 				evalskip = SKIPNONE;
 			break;
+		}
+	}
 	loopnest--;
 	exitstatus = status;
  out:
 	popstackmark(&smark);
+}
 STATIC void
 evalcase(union node *n, int flags)
+{
 	union node *cp, *ncp;
 	union node *patp;
 	struct arglist arglist;
 	struct stackmark smark;
 	int status = 0;
 	setstackmark(&smark);
 	arglist.lastp = &arglist.list;
 	line_number = n->ncase.lineno;
 	expandarg(n->ncase.expr, &arglist, EXP_TILDE);
 	for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
 		for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
 			line_number = patp->narg.lineno;
 			if (casematch(patp, arglist.list->text)) {
 				while (cp != NULL && evalskip == 0 &&
 				    nflag == 0) {
 					if (cp->type == NCLISTCONT)
 						ncp = cp->nclist.next;
 					else
 						ncp = NULL;
 					line_number = cp->nclist.lineno;
 					evaltree(cp->nclist.body, flags);
 					status = exitstatus;
 					cp = ncp;
+				}
 				goto out;
+			}
+		}
+	}
  out:
 	exitstatus = status;
 	popstackmark(&smark);
+}
 /*
  * Kick off a subshell to evaluate a tree.
  */
 STATIC void
 evalsubshell(union node *n, int flags)
+{
 	struct job *jp= NULL;
 	int backgnd = (n->type == NBACKGND);
 	expredir(n->nredir.redirect);
 	if (xflag && n->nredir.redirect) {
 		union node *rn;
 		outxstr(expandstr(ps4val(), line_number));
 		outxstr("using redirections:");
 		for (rn = n->nredir.redirect; rn; rn = rn->nfile.next)
 			(void) outredir(outx, rn, ' ');
 		outxstr(" do subshell ("/*)*/);
 		if (backgnd)
 			outxstr(/*(*/") &");
 		outxc('\n');
 		flushout(outx);
+	}
 	if ((!backgnd && flags & EV_EXIT && !have_traps()) ||
 	    forkshell(jp = makejob(n, 1), n, backgnd?FORK_BG:FORK_FG) == 0) {
 		INTON;
 		if (backgnd)
 			flags &=~ EV_TESTED;
 		redirect(n->nredir.redirect, REDIR_KEEP);
 		evaltree(n->nredir.n, flags | EV_EXIT);   /* never returns */
 	} else if (!backgnd) {
 		INTOFF;
 		exitstatus = waitforjob(jp);
 		INTON;
 	} else
 		exitstatus = 0;
 	if (!backgnd && xflag && n->nredir.redirect) {
 		outxstr(expandstr(ps4val(), line_number));
 		outxstr(/*(*/") done subshell\n");
 		flushout(outx);
+	}
+}
 /*
  * Compute the names of the files in a redirection list.
  */
 STATIC void
 expredir(union node *n)
+{
 	union node *redir;
 	for (redir = n ; redir ; redir = redir->nfile.next) {
 		struct arglist fn;
 		fn.lastp = &fn.list;
 		switch (redir->type) {
 		case NFROMTO:
 		case NFROM:
 		case NTO:
 		case NCLOBBER:
 		case NAPPEND:
 			expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
 			redir->nfile.expfname = fn.list->text;
 			break;
 		case NFROMFD:
 		case NTOFD:
 			if (redir->ndup.vname) {
 				expandarg(redir->ndup.vname, &fn, EXP_TILDE | EXP_REDIR);
 				fixredir(redir, fn.list->text, 1);
+			}
 			break;
+		}
+	}
+}
 /*
  * Perform redirections for a compound command, and then do it (and restore)
  */
 STATIC void
 evalredir(union node *n, int flags)
+{
 	struct jmploc jmploc;
 	struct jmploc * const savehandler = handler;
 	volatile int in_redirect = 1;
 	const char * volatile PS4 = NULL;
 	expredir(n->nredir.redirect);
 	if (xflag && n->nredir.redirect) {
 		union node *rn;
 		outxstr(PS4 = expandstr(ps4val(), line_number));
 		outxstr("using redirections:");
 		for (rn = n->nredir.redirect; rn != NULL; rn = rn->nfile.next)
 			(void) outredir(outx, rn, ' ');
 		outxstr(" do {\n");	/* } */
 		flushout(outx);
+	}
 	if (setjmp(jmploc.loc)) {
 		int e;
 		handler = savehandler;
 		e = exception;
 		popredir();
 		if (xflag && n->nredir.redirect) {
 			outxstr(PS4);
 			/* { */ outxstr("} failed\n");
 			flushout(outx);
+		}
 		if (e == EXERROR || e == EXEXEC) {
 			if (in_redirect) {
 				exitstatus = 2;
 				return;
+			}
+		}
 		longjmp(handler->loc, 1);
 	} else {
 		INTOFF;
 		handler = &jmploc;
 		redirect(n->nredir.redirect, REDIR_PUSH | REDIR_KEEP);
 		in_redirect = 0;
 		INTON;
 		evaltree(n->nredir.n, flags);
+	}
 	INTOFF;
 	handler = savehandler;
 	popredir();
 	INTON;
 	if (xflag && n->nredir.redirect) {
 		outxstr(PS4);
 		/* { */ outxstr("} done\n");
 		flushout(outx);
+	}
+}
 /*
  * Evaluate a pipeline.  All the processes in the pipeline are children
  * of the process creating the pipeline.  (This differs from some versions
  * of the shell, which make the last process in a pipeline the parent
  * of all the rest.)
  */
 STATIC void
 evalpipe(union node *n)
+{
 	struct job *jp;
 	struct nodelist *lp;
 	int pipelen;
 	int prevfd;
 	int pip[2];
 	CTRACE(DBG_EVAL, ("evalpipe(%p) called\n", n));
 	pipelen = 0;
 	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
 		pipelen++;
 	INTOFF;
 	jp = makejob(n, pipelen);
 	prevfd = -1;
 	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
 		prehash(lp->n);
 		pip[1] = -1;
 		if (lp->next) {
 			if (sh_pipe(pip) < 0) {
 				if (prevfd >= 0)
 					close(prevfd);
 				error("Pipe call failed: %s", strerror(errno));
+			}
+		}
 		if (forkshell(jp, lp->n,
 		    n->npipe.backgnd ? FORK_BG : FORK_FG) == 0) {
 			INTON;
 			if (prevfd > 0)
 				movefd(prevfd, 0);
 			if (pip[1] >= 0) {
 				close(pip[0]);
 				movefd(pip[1], 1);
+			}
 			evaltree(lp->n, EV_EXIT);
+		}
 		if (prevfd >= 0)
 			close(prevfd);
 		prevfd = pip[0];
 		close(pip[1]);
+	}
 	if (n->npipe.backgnd == 0) {
 		INTOFF;
 		exitstatus = waitforjob(jp);
 		CTRACE(DBG_EVAL, ("evalpipe:  job done exit status %d\n",
 		    exitstatus));
 		INTON;
 	} else
 		exitstatus = 0;
 	INTON;
+}
 /*
  * Execute a command inside back quotes.  If it's a builtin command, we
  * want to save its output in a block obtained from malloc.  Otherwise
  * we fork off a subprocess and get the output of the command via a pipe.
  * Should be called with interrupts off.
  */
 void
 evalbackcmd(union node *n, struct backcmd *result)
+{
 	int pip[2];
 	struct job *jp;
 	struct stackmark smark;		/* unnecessary (because we fork) */
 	result->fd = -1;
 	result->buf = NULL;
 	result->nleft = 0;
 	result->jp = NULL;
 	if (nflag || n == NULL)
 		goto out;
 	setstackmark(&smark);
 #ifdef notyet
 	/*
 	 * For now we disable executing builtins in the same
 	 * context as the shell, because we are not keeping
 	 * enough state to recover from changes that are
 	 * supposed only to affect subshells. eg. echo "`cd /`"
 	 */
 	if (n->type == NCMD) {
 		exitstatus = oexitstatus;	/* XXX o... no longer exists */
 		evalcommand(n, EV_BACKCMD, result);
 	} else
 #endif
+	{
 		INTOFF;
 		if (sh_pipe(pip) < 0)
 			error("Pipe call failed");
 		jp = makejob(n, 1);
 		if (forkshell(jp, n, FORK_NOJOB) == 0) {
 			FORCEINTON;
 			close(pip[0]);
 			movefd(pip[1], 1);
 			eflag = 0;
 			evaltree(n, EV_EXIT);
 			/* NOTREACHED */
+		}
 		close(pip[1]);
 		result->fd = pip[0];
 		result->jp = jp;
 		INTON;
+	}
 	popstackmark(&smark);
  out:
 	CTRACE(DBG_EVAL, ("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
 		result->fd, result->buf, result->nleft, result->jp));
+}
 const char *
 syspath(void)
+{
 	static char *sys_path = NULL;
 	static int mib[] = {CTL_USER, USER_CS_PATH};
 	static char def_path[] = "PATH=/usr/bin:/bin:/usr/sbin:/sbin";
 	size_t len;
 	if (sys_path == NULL) {
 		if (sysctl(mib, 2, 0, &len, 0, 0) != -1 &&
 		    (sys_path = ckmalloc(len + 5)) != NULL &&
 		    sysctl(mib, 2, sys_path + 5, &len, 0, 0) != -1) {
 			memcpy(sys_path, "PATH=", 5);
 		} else {
 			ckfree(sys_path);
 			/* something to keep things happy */
 			sys_path = def_path;
+		}
+	}
 	return sys_path;
+}
 static int
 parse_command_args(int argc, char **argv, int *use_syspath)
+{
 	int sv_argc = argc;
 	char *cp, c;
 	*use_syspath = 0;
 	for (;;) {
 		argv++;
 		if (--argc == 0)
 			break;
 		cp = *argv;
 		if (*cp++ != '-')
 			break;
 		if (*cp == '-' && cp[1] == 0) {
 			argv++;
 			argc--;
 			break;
+		}
 		while ((c = *cp++)) {
 			switch (c) {
 			case 'p':
 				*use_syspath = 1;
 				break;
 			default:
 				/* run 'typecmd' for other options */
 				return 0;
+			}
+		}
+	}
 	return sv_argc - argc;
+}
 int vforked = 0;
 extern char *trap[];
 /*
  * Execute a simple command.
  */
 STATIC void
 evalcommand(union node *cmd, int flgs, struct backcmd *backcmd)
+{
 	struct stackmark smark;
 	union node *argp;
 	struct arglist arglist;
 	struct arglist varlist;
 	volatile int flags = flgs;
 	char ** volatile argv;
 	volatile int argc;
 	char **envp;
 	int varflag;
 	struct strlist *sp;
 	volatile int mode;
 	int pip[2];
 	struct cmdentry cmdentry;
 	struct job * volatile jp;
 	struct jmploc jmploc;
 	struct jmploc *volatile savehandler = NULL;
 	const char *volatile savecmdname;
 	volatile struct shparam saveparam;
 	struct localvar *volatile savelocalvars;
 	volatile int e;
 	char * volatile lastarg;
 	const char * volatile path = pathval();
 	volatile int temp_path;
 	const int savefuncline = funclinebase;
 	const int savefuncabs = funclineabs;
 	vforked = 0;
 	/* First expand the arguments. */
 	CTRACE(DBG_EVAL, ("evalcommand(%p, %d) called [%s]\n", cmd, flags,
 	    cmd->ncmd.args ? cmd->ncmd.args->narg.text : ""));
 	setstackmark(&smark);
 	back_exitstatus = 0;
 	line_number = cmd->ncmd.lineno;
 	arglist.lastp = &arglist.list;
 	varflag = 1;
 	/* Expand arguments, ignoring the initial 'name=value' ones */
 	for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
 		char *p = argp->narg.text;
 		line_number = argp->narg.lineno;
 		if (varflag && is_name(*p)) {
 			do {
 				p++;
 			} while (is_in_name(*p));
 			if (*p == '=')
 				continue;
+		}
 		expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
 		varflag = 0;
+	}
 	*arglist.lastp = NULL;
 	expredir(cmd->ncmd.redirect);
 	/* Now do the initial 'name=value' ones we skipped above */
 	varlist.lastp = &varlist.list;
 	for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {
 		char *p = argp->narg.text;
 		line_number = argp->narg.lineno;
 		if (!is_name(*p))
 			break;
 		do
 			p++;
 		while (is_in_name(*p));
 		if (*p != '=')
 			break;
 		expandarg(argp, &varlist, EXP_VARTILDE);
+	}
 	*varlist.lastp = NULL;
 	argc = 0;
 	for (sp = arglist.list ; sp ; sp = sp->next)
 		argc++;
 	argv = stalloc(sizeof (char *) * (argc + 1));
 	for (sp = arglist.list ; sp ; sp = sp->next) {
 		VTRACE(DBG_EVAL, ("evalcommand arg: %s\n", sp->text));
 		*argv++ = sp->text;
+	}
 	*argv = NULL;
 	lastarg = NULL;
 	if (iflag && funcnest == 0 && argc > 0)
 		lastarg = argv[-1];
 	argv -= argc;
 	/* Print the command if xflag is set. */
 	if (xflag) {
 		char sep = 0;
 		union node *rn;
 		outxstr(expandstr(ps4val(), line_number));
 		for (sp = varlist.list ; sp ; sp = sp->next) {
 			char *p;
 			if (sep != 0)
 				outxc(sep);
 			/*
 			 * The "var=" part should not be quoted, regardless
 			 * of the value, or it would not represent an
 			 * assignment, but rather a command
 			 */
 			p = strchr(sp->text, '=');
 			if (p != NULL) {
 				*p = '\0';	/*XXX*/
 				outxshstr(sp->text);
 				outxc('=');
 				*p++ = '=';	/*XXX*/
 			} else
 				p = sp->text;
 			outxshstr(p);
 			sep = ' ';
+		}
 		for (sp = arglist.list ; sp ; sp = sp->next) {
 			if (sep != 0)
 				outxc(sep);
 			outxshstr(sp->text);
 			sep = ' ';
+		}
 		for (rn = cmd->ncmd.redirect; rn; rn = rn->nfile.next)
 			if (outredir(outx, rn, sep))
 				sep = ' ';
 		outxc('\n');
 		flushout(outx);
+	}
 	/* Now locate the command. */
 	if (argc == 0) {
 		cmdentry.cmdtype = CMDSPLBLTIN;
 		cmdentry.u.bltin = bltincmd;
 	} else {
 		static const char PATH[] = "PATH=";
 		int cmd_flags = 0;
 		/*
 		 * Modify the command lookup path, if a PATH= assignment
 		 * is present
 		 */
 		for (sp = varlist.list; sp; sp = sp->next)
 			if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0)
 				path = sp->text + sizeof(PATH) - 1;
 		do {
 			int argsused, use_syspath;
 			find_command(argv[0], &cmdentry, cmd_flags, path);
 #if 0
 			/*
 			 * This short circuits all of the processing that
 			 * should be done (including processing the
 			 * redirects), so just don't ...
+			 *
 			 * (eventually this whole #if'd block will vanish)
 			 */
 			if (cmdentry.cmdtype == CMDUNKNOWN) {
 				exitstatus = 127;
 				flushout(&errout);
 				goto out;
+			}
 #endif
 			/* implement the 'command' builtin here */
 			if (cmdentry.cmdtype != CMDBUILTIN ||
 			    cmdentry.u.bltin != bltincmd)
 				break;
 			cmd_flags |= DO_NOFUNC;
 			argsused = parse_command_args(argc, argv, &use_syspath);
 			if (argsused == 0) {
 				/* use 'type' builtin to display info */
 				cmdentry.u.bltin = typecmd;
 				break;
+			}
 			argc -= argsused;
 			argv += argsused;
 			if (use_syspath)
 				path = syspath() + 5;
 		} while (argc != 0);
 		if (cmdentry.cmdtype == CMDSPLBLTIN && cmd_flags & DO_NOFUNC)
 			/* posix mandates that 'command <splbltin>' act as if
 			   <splbltin> was a normal builtin */
 			cmdentry.cmdtype = CMDBUILTIN;
+	}
 	/* Fork off a child process if necessary. */
 	if (cmd->ncmd.backgnd || (trap[0] && (flags & EV_EXIT) != 0)
 	 || ((cmdentry.cmdtype == CMDNORMAL || cmdentry.cmdtype == CMDUNKNOWN)
 	     && (flags & EV_EXIT) == 0)
 	 || ((flags & EV_BACKCMD) != 0 &&
 	    ((cmdentry.cmdtype != CMDBUILTIN && cmdentry.cmdtype != CMDSPLBLTIN)
 		 || cmdentry.u.bltin == dotcmd
 		 || cmdentry.u.bltin == evalcmd))) {
 		INTOFF;
 		jp = makejob(cmd, 1);
 		mode = cmd->ncmd.backgnd;
 		if (flags & EV_BACKCMD) {
 			mode = FORK_NOJOB;
 			if (sh_pipe(pip) < 0)
 				error("Pipe call failed");
+		}
 #ifdef DO_SHAREDVFORK
 		/* It is essential that if DO_SHAREDVFORK is defined that the
 		 * child's address space is actually shared with the parent as
 		 * we rely on this.
 		 */
 		if (usefork == 0 && cmdentry.cmdtype == CMDNORMAL) {
 			pid_t	pid;
 			int serrno;
 			savelocalvars = localvars;
 			localvars = NULL;
 			vforked = 1;
 	VFORK_BLOCK
 			switch (pid = vfork()) {
 			case -1:
 				serrno = errno;
 				VTRACE(DBG_EVAL, ("vfork() failed, errno=%d\n",
 				    serrno));
 				INTON;
 				error("Cannot vfork (%s)", strerror(serrno));
 				break;
 			case 0:
 				/* Make sure that exceptions only unwind to
 				 * after the vfork(2)
 				 */
 				SHELL_FORKED();
 				if (setjmp(jmploc.loc)) {
 					if (exception == EXSHELLPROC) {
 						/*
 						 * We can't progress with the
 						 * vfork, so, set vforked = 2
 						 * so the parent knows,
 						 * and _exit();
 						 */
 						vforked = 2;
 						_exit(0);
 					} else {
-						_exit(exerrno);
+						_exit(exception == EXEXIT ?
 						    exitstatus : exerrno);
+					}
+				}
 				savehandler = handler;
 				handler = &jmploc;
 				listmklocal(varlist.list, VEXPORT | VNOFUNC);
 				forkchild(jp, cmd, mode, vforked);
 				break;
 			default:
 				VFORK_UNDO();
 						/* restore from vfork(2) */
 				handler = savehandler;
 				poplocalvars();
 				localvars = savelocalvars;
 				if (vforked == 2) {
 					vforked = 0;
 					(void)waitpid(pid, NULL, 0);
 					/*
 					 * We need to progress in a
 					 * normal fork fashion
 					 */
 					goto normal_fork;
+				}
 				/*
 				 * Here the child has left home,
 				 * getting on with its life, so
 				 * so must we...
 				 */
 				vforked = 0;
 				forkparent(jp, cmd, mode, pid);
 				goto parent;
+			}
 	VFORK_END
 		} else {
  normal_fork:
 #endif
 			if (forkshell(jp, cmd, mode) != 0)
 				goto parent;	/* at end of routine */
 			flags |= EV_EXIT;
 			FORCEINTON;
 #ifdef DO_SHAREDVFORK
+		}
 #endif
 		if (flags & EV_BACKCMD) {
 			if (!vforked) {
 				FORCEINTON;
+			}
 			close(pip[0]);
 			movefd(pip[1], 1);
+		}
 		flags |= EV_EXIT;
+	}
 	/* This is the child process if a fork occurred. */
 	/* Execute the command. */
 	switch (cmdentry.cmdtype) {
 		volatile int saved;
 	case CMDFUNCTION:
 		VXTRACE(DBG_EVAL, ("Shell function%s:  ",vforked?" VF":""),
 		    trargs(argv));
 		redirect(cmd->ncmd.redirect, saved =
 			!(flags & EV_EXIT) || have_traps() ? REDIR_PUSH : 0);
 		saveparam = shellparam;
 		shellparam.malloc = 0;
 		shellparam.reset = 1;
 		shellparam.nparam = argc - 1;
 		shellparam.p = argv + 1;
 		shellparam.optnext = NULL;
 		INTOFF;
 		savelocalvars = localvars;
 		localvars = NULL;
 		reffunc(cmdentry.u.func);
 		INTON;
 		if (setjmp(jmploc.loc)) {
 			if (exception == EXSHELLPROC) {
 				freeparam((volatile struct shparam *)
 				    &saveparam);
 			} else {
 				freeparam(&shellparam);
 				shellparam = saveparam;
+			}
 			if (saved)
 				popredir();;
 			unreffunc(cmdentry.u.func);
 			poplocalvars();
 			localvars = savelocalvars;
 			funclinebase = savefuncline;
 			funclineabs = savefuncabs;
 			handler = savehandler;
 			longjmp(handler->loc, 1);
+		}
 		savehandler = handler;
 		handler = &jmploc;
 		if (cmdentry.u.func) {
 			if (cmdentry.lno_frel)
 				funclinebase = cmdentry.lineno - 1;
 			else
 				funclinebase = 0;
 			funclineabs = cmdentry.lineno;
 			VTRACE(DBG_EVAL,
 			  ("function: node: %d '%s' # %d%s; funclinebase=%d\n",
 			    getfuncnode(cmdentry.u.func)->type,
 			    NODETYPENAME(getfuncnode(cmdentry.u.func)->type),
 			    cmdentry.lineno, cmdentry.lno_frel?" (=1)":"",
 			    funclinebase));
+		}
 		listmklocal(varlist.list, VEXPORT);
 		/* stop shell blowing its stack */
 		if (++funcnest > 1000)
 			error("too many nested function calls");
 		evaltree(getfuncnode(cmdentry.u.func),
 		    flags & (EV_TESTED|EV_EXIT));
 		funcnest--;
 		INTOFF;
 		unreffunc(cmdentry.u.func);
 		poplocalvars();
 		localvars = savelocalvars;
 		funclinebase = savefuncline;
 		funclineabs = savefuncabs;
 		freeparam(&shellparam);
 		shellparam = saveparam;
 		handler = savehandler;
 		if (saved)
 			popredir();
 		INTON;
 		if (evalskip == SKIPFUNC) {
 			evalskip = SKIPNONE;
 			skipcount = 0;
+		}
 		if (flags & EV_EXIT)
 			exitshell(exitstatus);
 		break;
 	case CMDBUILTIN:
 	case CMDSPLBLTIN:
 		VXTRACE(DBG_EVAL, ("builtin command%s:  ",vforked?" VF":""), trargs(argv));
 		mode = (cmdentry.u.bltin == execcmd) ? 0 : REDIR_PUSH;
 		if (flags == EV_BACKCMD) {
 			memout.nleft = 0;
 			memout.nextc = memout.buf;
 			memout.bufsize = 64;
 			mode |= REDIR_BACKQ;
+		}
 		e = -1;
 		savehandler = handler;
 		savecmdname = commandname;
 		handler = &jmploc;
 		temp_path = 0;
 		if (!setjmp(jmploc.loc)) {
 			/*
 			 * We need to ensure the command hash table isn't
 			 * corrupted by temporary PATH assignments.
 			 * However we must ensure the 'local' command works!
 			 */
 			if (path != pathval() && (cmdentry.u.bltin == hashcmd ||
 			    cmdentry.u.bltin == typecmd)) {
 				savelocalvars = localvars;
 				localvars = 0;
 				temp_path = 1;
 				mklocal(path - 5 /* PATH= */, 0);
+			}
 			redirect(cmd->ncmd.redirect, mode);
 			/* exec is a special builtin, but needs this list... */
 			cmdenviron = varlist.list;
 			/* we must check 'readonly' flag for all builtins */
 			listsetvar(varlist.list,
 				cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
 			commandname = argv[0];
 			/* initialize nextopt */
 			argptr = argv + 1;
 			optptr = NULL;
 			/* and getopt */
 			optreset = 1;
 			optind = 1;
 			builtin_flags = flags;
 			exitstatus = cmdentry.u.bltin(argc, argv);
 		} else {
 			e = exception;
 			if (e == EXINT)
 				exitstatus = SIGINT + 128;
 			else if (e == EXEXEC)
 				exitstatus = exerrno;
 			else if (e != EXEXIT)
 				exitstatus = 2;
+		}
 		handler = savehandler;
 		flushall();
 		out1 = &output;
 		out2 = &errout;
 		freestdout();
 		if (temp_path) {
 			poplocalvars();
 			localvars = savelocalvars;
+		}
 		cmdenviron = NULL;
 		if (e != EXSHELLPROC) {
 			commandname = savecmdname;
 			if (flags & EV_EXIT)
 				exitshell(exitstatus);
+		}
 		if (e != -1) {
 			if ((e != EXERROR && e != EXEXEC)
 			    || cmdentry.cmdtype == CMDSPLBLTIN)
 				exraise(e);
 			FORCEINTON;
+		}
 		if (cmdentry.u.bltin != execcmd)
 			popredir();
 		if (flags == EV_BACKCMD) {
 			backcmd->buf = memout.buf;
 			backcmd->nleft = memout.nextc - memout.buf;
 			memout.buf = NULL;
+		}
 		break;
 	default:
 		VXTRACE(DBG_EVAL, ("normal command%s:  ", vforked?" VF":""),
 		    trargs(argv));
 		redirect(cmd->ncmd.redirect,
 		    (vforked ? REDIR_VFORK : 0) | REDIR_KEEP);
 		if (!vforked)
 			for (sp = varlist.list ; sp ; sp = sp->next)
 				setvareq(sp->text, VEXPORT|VSTACK);
 		envp = environment();
 		shellexec(argv, envp, path, cmdentry.u.index, vforked);
 		break;
+	}
 	goto out;
  parent:			/* parent process gets here (if we forked) */
 	exitstatus = 0;		/* if not altered just below */
 	if (mode == FORK_FG) {	/* argument to fork */
 		exitstatus = waitforjob(jp);
 	} else if (mode == FORK_NOJOB) {
 		backcmd->fd = pip[0];
 		close(pip[1]);
 		backcmd->jp = jp;
+	}
 	FORCEINTON;
  out:
 	if (lastarg)
 		/* implement $_ for whatever use that really is */
 		(void) setvarsafe("_", lastarg, VNOERROR);
 	popstackmark(&smark);
+}
 /*
  * Search for a command.  This is called before we fork so that the
  * location of the command will be available in the parent as well as
  * the child.  The check for "goodname" is an overly conservative
  * check that the name will not be subject to expansion.
  */
 STATIC void
 prehash(union node *n)
+{
 	struct cmdentry entry;
 	if (n && n->type == NCMD && n->ncmd.args)
 		if (goodname(n->ncmd.args->narg.text))
 			find_command(n->ncmd.args->narg.text, &entry, 0,
 				     pathval());
+}
 int
 in_function(void)
+{
 	return funcnest;
+}
 enum skipstate
 current_skipstate(void)
+{
 	return evalskip;
+}
 void
 stop_skipping(void)
+{
 	evalskip = SKIPNONE;
 	skipcount = 0;
+}
 /*
  * Builtin commands.  Builtin commands whose functions are closely
  * tied to evaluation are implemented here.
  */
 /*
  * No command given.
  */
 int
 bltincmd(int argc, char **argv)
+{
 	/*
 	 * Preserve exitstatus of a previous possible redirection
 	 * as POSIX mandates
 	 */
 	return back_exitstatus;
+}
 /*
  * Handle break and continue commands.  Break, continue, and return are
  * all handled by setting the evalskip flag.  The evaluation routines
  * above all check this flag, and if it is set they start skipping
  * commands rather than executing them.  The variable skipcount is
  * the number of loops to break/continue, or the number of function
  * levels to return.  (The latter is always 1.)  It should probably
  * be an error to break out of more loops than exist, but it isn't
  * in the standard shell so we don't make it one here.
  */
 int
 breakcmd(int argc, char **argv)
+{
 	int n = argc > 1 ? number(argv[1]) : 1;
 	if (n <= 0)
 		error("invalid count: %d", n);
 	if (n > loopnest)
 		n = loopnest;
 	if (n > 0) {
 		evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
 		skipcount = n;
+	}
 	return 0;
+}
 int
 dotcmd(int argc, char **argv)
+{
 	exitstatus = 0;
 	if (argc >= 2) {		/* That's what SVR2 does */
 		char *fullname;
 		/*
 		 * dot_funcnest needs to be 0 when not in a dotcmd, so it
 		 * cannot be restored with (funcnest + 1).
 		 */
 		int dot_funcnest_old;
 		struct stackmark smark;
 		setstackmark(&smark);
 		fullname = find_dot_file(argv[1]);
 		setinputfile(fullname, 1);
 		commandname = fullname;
 		dot_funcnest_old = dot_funcnest;
 		dot_funcnest = funcnest + 1;
 		cmdloop(0);
 		dot_funcnest = dot_funcnest_old;
 		popfile();
 		popstackmark(&smark);
+	}
 	return exitstatus;
+}
 /*
  * Take commands from a file.  To be compatible we should do a path
  * search for the file, which is necessary to find sub-commands.
  */
 STATIC char *
 find_dot_file(char *basename)
+{
 	char *fullname;
 	const char *path = pathval();
 	struct stat statb;
 	/* don't try this for absolute or relative paths */
 	if (strchr(basename, '/')) {
 		if (stat(basename, &statb) == 0) {
 			if (S_ISDIR(statb.st_mode))
 				error("%s: is a directory", basename);
 			if (S_ISBLK(statb.st_mode))
 				error("%s: is a block device", basename);
 			return basename;
+		}
 	} else while ((fullname = padvance(&path, basename, 1)) != NULL) {
 		if ((stat(fullname, &statb) == 0)) {
 			/* weird format is to ease future code... */
 			if (S_ISDIR(statb.st_mode) || S_ISBLK(statb.st_mode))
+				;
 #if notyet
 			else if (unreadable()) {
 				/*
 				 * testing this via st_mode is ugly to get
 				 * correct (and would ignore ACLs).
 				 * better way is just to open the file.
 				 * But doing that here would (currently)
 				 * mean opening the file twice, which
 				 * might not be safe.  So, defer this
 				 * test until code is restructures so
 				 * we can return a fd.   Then we also
 				 * get to fix the mem leak just below...
 				 */
+			}
 #endif
 			else {
 				/*
 				 * Don't bother freeing here, since
 				 * it will be freed by the caller.
 				 * XXX no it won't - a bug for later.
 				 */
 				return fullname;
+			}
+		}
 		stunalloc(fullname);
+	}
 	/* not found in the PATH */
 	error("%s: not found", basename);
 	/* NOTREACHED */
+}
 /*
  * The return command.
+ *
  * Quoth the POSIX standard:
  *   The return utility shall cause the shell to stop executing the current
  *   function or dot script. If the shell is not currently executing
  *   a function or dot script, the results are unspecified.
+ *
  * As for the unspecified part, there seems to be no de-facto standard: bash
  * ignores the return with a warning, zsh ignores the return in interactive
  * mode but seems to liken it to exit in a script.  (checked May 2014)
+ *
  * We choose to silently ignore the return.  Older versions of this shell
  * set evalskip to SKIPFILE causing the shell to (indirectly) exit.  This
  * had at least the problem of circumventing the check for stopped jobs,
  * which would occur for exit or ^D.
  */
 int
 returncmd(int argc, char **argv)
+{
 	int ret = argc > 1 ? number(argv[1]) : exitstatus;
 	if ((dot_funcnest == 0 && funcnest)
 	    || (dot_funcnest > 0 && funcnest - (dot_funcnest - 1) > 0)) {
 		evalskip = SKIPFUNC;
 		skipcount = 1;
 	} else if (dot_funcnest > 0) {
 		evalskip = SKIPFILE;
 		skipcount = 1;
 	} else {
 		/* XXX: should a warning be issued? */
 		ret = 0;
+	}
 	return ret;
+}
 int
 falsecmd(int argc, char **argv)
+{
 	return 1;
+}
 int
 truecmd(int argc, char **argv)
+{
 	return 0;
+}
 int
 execcmd(int argc, char **argv)
+{
 	if (argc > 1) {
 		struct strlist *sp;
 		iflag = 0;		/* exit on error */
 		mflag = 0;
 		optschanged();
 		for (sp = cmdenviron; sp; sp = sp->next)
 			setvareq(sp->text, VEXPORT|VSTACK);
 		shellexec(argv + 1, environment(), pathval(), 0, 0);
+	}
 	return 0;
+}
 static int
 conv_time(clock_t ticks, char *seconds, size_t l)
+{
 	static clock_t tpm = 0;
 	clock_t mins;
 	int i;
 	if (!tpm)
 		tpm = sysconf(_SC_CLK_TCK) * 60;
 	mins = ticks / tpm;
 	snprintf(seconds, l, "%.4f", (ticks - mins * tpm) * 60.0 / tpm );
 	if (seconds[0] == '6' && seconds[1] == '0') {
 		/* 59.99995 got rounded up... */
 		mins++;
 		strlcpy(seconds, "0.0", l);
 		return mins;
+	}
 	/* suppress trailing zeros */
 	i = strlen(seconds) - 1;
 	for (; seconds[i] == '0' && seconds[i - 1] != '.'; i--)
 		seconds[i] = 0;
 	return mins;
+}
 int
 timescmd(int argc, char **argv)
+{
 	struct tms tms;
 	int u, s, cu, cs;
 	char us[8], ss[8], cus[8], css[8];
 	nextopt("");
 	times(&tms);
 	u = conv_time(tms.tms_utime, us, sizeof(us));
 	s = conv_time(tms.tms_stime, ss, sizeof(ss));
 	cu = conv_time(tms.tms_cutime, cus, sizeof(cus));
 	cs = conv_time(tms.tms_cstime, css, sizeof(css));
 	outfmt(out1, "%dm%ss %dm%ss\n%dm%ss %dm%ss\n",
 		u, us, s, ss, cu, cus, cs, css);
 	return 0;
+}