ash: merge changes to local variables from upstream

This brings in dash commit cbb71a8 (eval: Add assignment built-in
support again) which finally makes it possible to sort out local
commit 65189dacb (ash: fix local PATH assignments).

These changes also simplify handling of shellexec and remove the
need for varlist in the forkshell structure.

6 files changed, 156 insertions, 176 deletions

diff --git a/shell/ash.c b/shell/ash.c
index cd15d44a6..f33f72b80 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -380,7 +380,6 @@ struct forkshell {
         union node *n;
         char **argv;
         char *path;
-        struct strlist *varlist;
 };
 
 enum {
@@ -2699,24 +2698,6 @@ unsetvar(const char *s)
 }
 
 /*
- * Process a linked list of variable assignments.
- */
-static void
-listsetvar(struct strlist *list_set_var, int flags)
-{
-        struct strlist *lp = list_set_var;
-
-        if (!lp)
-                return;
-        INT_OFF;
-        do {
-                setvareq(lp->text, flags);
-                lp = lp->next;
-        } while (lp);
-        INT_ON;
-}
-
-/*
  * Generate a list of variables satisfying the given conditions.
  */
 #if !ENABLE_FEATURE_SH_NOFORK
@@ -8663,7 +8644,7 @@ struct cmdentry {
 #define DO_ABS          0x02    /* checks absolute paths */
 #define DO_NOFUNC       0x04    /* don't return shell functions, for command */
 #define DO_ALTPATH      0x08    /* using alternate path */
-#define DO_ALTBLTIN     0x20    /* %builtin in alt. path */
+#define DO_REGBLTIN     0x10    /* regular built-ins and functions only */
 
 static void find_command(char *, struct cmdentry *, int, const char *);
 
@@ -9281,24 +9262,43 @@ typecmd(int argc UNUSED_PARAM, char **argv)
 }
 
 #if ENABLE_ASH_CMDCMD
+static struct strlist *
+fill_arglist(struct arglist *arglist, union node **argpp)
+{
+        struct strlist **lastp = arglist->lastp;
+        union node *argp;
+
+        while ((argp = *argpp) != NULL) {
+                expandarg(argp, arglist, EXP_FULL | EXP_TILDE);
+                *argpp = argp->narg.next;
+                if (*lastp)
+                        break;
+        }
+
+        return *lastp;
+}
+
 /* Is it "command [-p] PROG ARGS" bltin, no other opts? Return ptr to "PROG" if yes */
-static char **
-parse_command_args(char **argv, const char **path)
+static int
+parse_command_args(struct arglist *arglist, union node **argpp, const char **path)
 {
+        struct strlist *sp = arglist->list;
         char *cp, c;
 
         for (;;) {
-                cp = *++argv;
-                if (!cp)
-                        return NULL;
+                sp = sp->next ? sp->next : fill_arglist(arglist, argpp);
+                if (!sp)
+                        return 0;
+                cp = sp->text;
                 if (*cp++ != '-')
                         break;
                 c = *cp++;
                 if (!c)
                         break;
                 if (c == '-' && !*cp) {
-                        if (!*++argv)
-                                return NULL;
+                        if (!sp->next && !fill_arglist(arglist, argpp))
+                                return 0;
+                        sp = sp->next;
                         break;
                 }
                 do {
@@ -9308,12 +9308,14 @@ parse_command_args(char **argv, const char **path)
                                 break;
                         default:
                                 /* run 'typecmd' for other options */
-                                return NULL;
+                                return 0;
                         }
                         c = *cp++;
                 } while (c);
         }
-        return argv;
+
+        arglist->list = sp;
+        return DO_NOFUNC;
 }
 
 static int FAST_FUNC
@@ -10397,18 +10399,23 @@ poplocalvars(int keep)
  * Create a new localvar environment.
  */
 static struct localvar_list *
-pushlocalvars(void)
+pushlocalvars(int push)
 {
         struct localvar_list *ll;
+        struct localvar_list *top;
+
+        top = localvar_stack;
+        if (!push)
+                goto out;
 
         INT_OFF;
         ll = ckzalloc(sizeof(*ll));
         /*ll->lv = NULL; - zalloc did it */
-        ll->next = localvar_stack;
+        ll->next = top;
         localvar_stack = ll;
         INT_ON;
-
-        return ll->next;
+ out:
+        return top;
 }
 
 static void
@@ -10467,7 +10474,7 @@ evalfun(struct funcnode *func, int argc, char **argv, int flags)
  * (options will be restored on return from the function).
  */
 static void
-mklocal(char *name)
+mklocal(char *name, int flags)
 {
         struct localvar *lvp;
         struct var **vpp;
@@ -10504,9 +10511,9 @@ mklocal(char *name)
                 if (vp == NULL) {
                         /* variable did not exist yet */
                         if (eq)
-                                vp = setvareq(name, VSTRFIXED);
+                                vp = setvareq(name, VSTRFIXED | flags);
                         else
-                                vp = setvar(name, NULL, VSTRFIXED);
+                                vp = setvar(name, NULL, VSTRFIXED | flags);
                         lvp->flags = VUNSET;
                 } else {
                         lvp->text = vp->var_text;
@@ -10516,7 +10523,7 @@ mklocal(char *name)
                          */
                         vp->flags |= VSTRFIXED|VTEXTFIXED;
                         if (eq)
-                                setvareq(name, 0);
+                                setvareq(name, flags);
                         else
                                 /* "local VAR" unsets VAR: */
                                 setvar0(name, NULL);
@@ -10542,7 +10549,7 @@ localcmd(int argc UNUSED_PARAM, char **argv)
 
         argv = argptr;
         while ((name = *argv++) != NULL) {
-                mklocal(name);
+                mklocal(name, 0);
         }
         return 0;
 }
@@ -10803,7 +10810,7 @@ static int
 evalcommand(union node *cmd, int flags)
 {
         static const struct builtincmd null_bltin = {
-                "\0\0", bltincmd /* why three NULs? */
+                BUILTIN_REGULAR "", bltincmd
         };
         struct localvar_list *localvar_stop;
         struct parsefile *file_stop;
@@ -10813,18 +10820,19 @@ evalcommand(union node *cmd, int flags)
         struct arglist varlist;
         char **argv;
         int argc;
+        struct strlist *osp;
         const struct strlist *sp;
         struct cmdentry cmdentry;
         struct job *jp;
         char *lastarg;
         const char *path;
         int spclbltin;
+        int cmd_flag;
         int status;
         char **nargv;
         smallint cmd_is_exec;
-#if ENABLE_PLATFORM_MINGW32
-        int cmdpath;
-#endif
+        int vflags;
+        int vlocal;
 
         errlinno = lineno = cmd->ncmd.linno;
         if (funcline)
@@ -10832,7 +10840,6 @@ evalcommand(union node *cmd, int flags)
 
         /* First expand the arguments. */
         TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
-        localvar_stop = pushlocalvars();
         file_stop = g_parsefile;
         back_exitstatus = 0;
 
@@ -10843,28 +10850,58 @@ evalcommand(union node *cmd, int flags)
         arglist.lastp = &arglist.list;
         *arglist.lastp = NULL;
 
+        cmd_flag = 0;
+        cmd_is_exec = 0;
+        spclbltin = -1;
+        vflags = 0;
+        vlocal = 0;
+        path = NULL;
+
         argc = 0;
-        if (cmd->ncmd.args) {
-                struct builtincmd *bcmd;
-                smallint pseudovarflag;
+        argp = cmd->ncmd.args;
+        osp = fill_arglist(&arglist, &argp);
+        if (osp) {
+                int pseudovarflag = 0;
 
-                bcmd = find_builtin(cmd->ncmd.args->narg.text);
-                pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
+                for (;;) {
+                        find_command(arglist.list->text, &cmdentry,
+                                        cmd_flag | DO_REGBLTIN, pathval());
 
-                for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
-                        struct strlist **spp;
+                        vlocal++;
 
-                        spp = arglist.lastp;
-                        if (pseudovarflag && isassignment(argp->narg.text))
-                                expandarg(argp, &arglist, EXP_VARTILDE);
-                        else
-                                expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
+                        /* implement bltin and command here */
+                        if (cmdentry.cmdtype != CMDBUILTIN)
+                                break;
 
-                        for (sp = *spp; sp; sp = sp->next)
-                                argc++;
+                        pseudovarflag = IS_BUILTIN_ASSIGN(cmdentry.u.cmd);
+                        if (spclbltin < 0) {
+                                spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd);
+                                vlocal = !spclbltin;
+                        }
+                        cmd_is_exec = cmdentry.u.cmd == EXECCMD;
+                        if (cmdentry.u.cmd != COMMANDCMD)
+                                break;
+
+                        cmd_flag = parse_command_args(&arglist, &argp, &path);
+                        if (!cmd_flag)
+                                break;
                 }
+
+                for (; argp; argp = argp->narg.next)
+                        expandarg(argp, &arglist,
+                                        pseudovarflag &&
+                                        isassignment(argp->narg.text) ?
+                                        EXP_VARTILDE : EXP_FULL | EXP_TILDE);
+
+                for (sp = arglist.list; sp; sp = sp->next)
+                        argc++;
+
+                if (cmd_is_exec && argc > 1)
+                        vflags = VEXPORT;
         }
 
+        localvar_stop = pushlocalvars(vlocal);
+
         /* Reserve one extra spot at the front for shellexec. */
         nargv = stalloc(sizeof(char *) * (argc + 2));
         argv = ++nargv;
@@ -10892,34 +10929,28 @@ evalcommand(union node *cmd, int flags)
         }
         status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH | REDIR_SAVEFD2);
 
-#if !ENABLE_PLATFORM_MINGW32
-        path = vpath.var_text;
+        if (status) {
+ bail:
+                exitstatus = status;
+
+                /* We have a redirection error. */
+                if (spclbltin > 0)
+                        raise_exception(EXERROR);
+
+                goto out;
+        }
+
         for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
                 struct strlist **spp;
-                char *p;
 
                 spp = varlist.lastp;
                 expandarg(argp, &varlist, EXP_VARTILDE);
 
-                mklocal((*spp)->text);
-
-                /*
-                 * Modify the command lookup path, if a PATH= assignment
-                 * is present
-                 */
-                p = (*spp)->text;
-                if (varcmp(p, path) == 0)
-                        path = p;
-        }
-#else
-        /* Set path after any local PATH= has been processed. */
-        for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
-                struct strlist **spp = varlist.lastp;
-                expandarg(argp, &varlist, EXP_VARTILDE);
-                mklocal((*spp)->text);
+                if (vlocal)
+                        mklocal((*spp)->text, VEXPORT);
+                else
+                        setvareq((*spp)->text, vflags);
         }
-        path = vpath.var_text;
-#endif
 
         /* Print the command if xflag is set. */
         if (xflag) {
@@ -10957,64 +10988,23 @@ evalcommand(union node *cmd, int flags)
                 safe_write(preverrout_fd, "\n", 1);
         }
 
-        cmd_is_exec = 0;
-        spclbltin = -1;
-
         /* Now locate the command. */
-        if (argc) {
-                int cmd_flag = DO_ERR;
-#if ENABLE_ASH_CMDCMD
-                const char *oldpath = path + 5;
-#endif
-                path += 5;
-                for (;;) {
-                        find_command(argv[0], &cmdentry, cmd_flag, path);
-                        if (cmdentry.cmdtype == CMDUNKNOWN) {
-                                flush_stdout_stderr();
-                                status = 127;
-                                goto bail;
-                        }
-
-                        /* implement bltin and command here */
-                        if (cmdentry.cmdtype != CMDBUILTIN)
-                                break;
-                        if (spclbltin < 0)
-                                spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd);
-                        if (cmdentry.u.cmd == EXECCMD)
-                                cmd_is_exec = 1;
-#if ENABLE_ASH_CMDCMD
-                        if (cmdentry.u.cmd == COMMANDCMD) {
-                                path = oldpath;
-                                nargv = parse_command_args(argv, &path);
-                                if (!nargv)
-                                        break;
-                                /* It's "command [-p] PROG ARGS" (that is, no -Vv).
-                                 * nargv => "PROG". path is updated if -p.
-                                 */
-                                argc -= nargv - argv;
-                                argv = nargv;
-                                cmd_flag |= DO_NOFUNC;
-                        } else
-#endif
-                                break;
-                }
-        }
-
-        if (status) {
- bail:
-                exitstatus = status;
-
-                /* We have a redirection error. */
-                if (spclbltin > 0)
-                        raise_exception(EXERROR);
-
-                goto out;
+        if (cmdentry.cmdtype != CMDBUILTIN
+         || !(IS_BUILTIN_REGULAR(cmdentry.u.cmd))
+        ) {
+                path = path ? path : pathval();
+                find_command(argv[0], &cmdentry, cmd_flag | DO_ERR, path);
         }
 
         jp = NULL;
 
         /* Execute the command. */
         switch (cmdentry.cmdtype) {
+        case CMDUNKNOWN:
+                status = 127;
+                flush_stdout_stderr();
+                goto bail;
+
         default: {
 
 #if ENABLE_FEATURE_SH_STANDALONE \
@@ -11071,19 +11061,11 @@ evalcommand(union node *cmd, int flags)
                         fs.argv = argv;
                         fs.path = (char*)path;
                         fs.fd[0] = cmdentry.u.index;
-                        fs.varlist = varlist.list;
                         jp = makejob(/*cmd,*/ 1);
                         spawn_forkshell(&fs, jp, cmd, FORK_FG);
                         TRACE(("forked child exited with %d\n", status));
                         break;
                 }
-                /* If we're running 'command -p' we need to use the value stored
-                 * in path by parse_command_args().  If PATH is a local variable
-                 * listsetvar() will free the value currently in path so we need
-                 * to fetch the updated version. */
-                cmdpath = (path != pathval());
-                listsetvar(varlist.list, VEXPORT|VSTACK);
-                shellexec(argv[0], argv, cmdpath ? path : pathval(), cmdentry.u.index);
 #else
                 if (!(flags & EV_EXIT) || may_have_traps) {
                         /* No, forking off a child is necessary */
@@ -11099,17 +11081,11 @@ evalcommand(union node *cmd, int flags)
                         FORCE_INT_ON;
                         /* fall through to exec'ing external program */
                 }
-                listsetvar(varlist.list, VEXPORT|VSTACK);
-                shellexec(argv[0], argv, path, cmdentry.u.index);
 #endif
+                shellexec(argv[0], argv, path, cmdentry.u.index);
                 /* NOTREACHED */
         } /* default */
         case CMDBUILTIN:
-                if (spclbltin > 0 || argc == 0) {
-                        poplocalvars(1);
-                        if (cmd_is_exec && argc > 1)
-                                listsetvar(varlist.list, VEXPORT);
-                }
                 if (evalbltin(cmdentry.u.cmd, argc, argv, flags)
                  && !(exception_type == EXERROR && spclbltin <= 0)
                 ) {
@@ -14290,11 +14266,8 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
 /* #if ENABLE_FEATURE_SH_STANDALONE... moved after builtin check */
 
         updatetbl = (path == pathval());
-        if (!updatetbl) {
+        if (!updatetbl)
                 act |= DO_ALTPATH;
-                if (strstr(path, "%builtin") != NULL)
-                        act |= DO_ALTBLTIN;
-        }
 
         /* If name is in the table, check answer will be ok */
         cmdp = cmdlookup(name, 0);
@@ -14307,16 +14280,19 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
                         abort();
 #endif
                 case CMDNORMAL:
-                        bit = DO_ALTPATH;
+                        bit = DO_ALTPATH | DO_REGBLTIN;
                         break;
                 case CMDFUNCTION:
                         bit = DO_NOFUNC;
                         break;
                 case CMDBUILTIN:
-                        bit = IS_BUILTIN_REGULAR(cmdp->param.cmd) ? 0 : DO_ALTBLTIN;
+                        bit = IS_BUILTIN_REGULAR(cmdp->param.cmd) ? 0 : DO_REGBLTIN;
                         break;
                 }
                 if (act & bit) {
+                        if (act & bit & DO_REGBLTIN)
+                                goto fail;
+
                         updatetbl = 0;
                         cmdp = NULL;
                 } else if (cmdp->rehash == 0)
@@ -14329,14 +14305,15 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
         if (bcmd) {
                 if (IS_BUILTIN_REGULAR(bcmd))
                         goto builtin_success;
-                if (act & DO_ALTPATH) {
-                        if (!(act & DO_ALTBLTIN))
-                                goto builtin_success;
-                } else if (builtinloc <= 0) {
+                if (act & DO_ALTPATH)
+                        goto builtin_success;
+                if (builtinloc <= 0)
                         goto builtin_success;
-                }
         }
 
+        if (act & DO_REGBLTIN)
+                goto fail;
+
 #if ENABLE_FEATURE_SH_STANDALONE
         {
                 int applet_no = find_applet_by_name(name);
@@ -14443,6 +14420,7 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
 #endif
                 ash_msg("%s: %s", name, errmsg(e, "not found"));
         }
+ fail:
         entry->cmdtype = CMDUNKNOWN;
         return;
 
@@ -15565,12 +15543,10 @@ static void
 forkshell_shellexec(struct forkshell *fs)
 {
         int idx = fs->fd[0];
-        struct strlist *varlist = fs->varlist;
         char **argv = fs->argv;
         char *path = fs->path;
 
         FORCE_INT_ON;
-        listsetvar(varlist, VEXPORT|VSTACK);
         shellexec(argv[0], argv, path, idx);
 }
 
@@ -15736,18 +15712,6 @@ SAVE_PTR((*vpp)->var_text, xasprintf("(*vpp)->var_text '%s'", vp->var_text ?: "N
 SLIST_COPY_END()
 
 /*
- * struct strlist
- */
-SLIST_SIZE_BEGIN(strlist_size,struct strlist)
-ds.funcstringsize += align_len(p->text);
-SLIST_SIZE_END()
-
-SLIST_COPY_BEGIN(strlist_copy,struct strlist)
-(*vpp)->text = nodeckstrdup(vp->text);
-SAVE_PTR((*vpp)->text, xasprintf("(*vpp)->text '%s'", vp->text ?: "NULL"), FREE);
-SLIST_COPY_END()
-
-/*
  * struct tblentry
  */
 static struct datasize
@@ -16068,7 +16032,6 @@ forkshell_size(struct forkshell *fs)
         ds.funcblocksize = calcsize(ds.funcblocksize, fs->n);
         ds = argv_size(ds, fs->argv);
         ds.funcstringsize += align_len(fs->path);
-        ds = strlist_size(ds, fs->varlist);
 
 #if MAX_HISTORY
         if (line_input_state) {
@@ -16097,11 +16060,9 @@ forkshell_copy(struct forkshell *fs, struct forkshell *new)
         new->n = copynode(fs->n);
         new->argv = argv_copy(fs->argv);
         new->path = nodeckstrdup(fs->path);
-        new->varlist = strlist_copy(fs->varlist);
-        SAVE_PTR2( new->n, "n", NO_FREE,
-                new->argv, "argv", NO_FREE);
-        SAVE_PTR2(new->path, xasprintf("path '%s'", fs->path ?: "NULL"), FREE,
-                new->varlist, "varlist", NO_FREE);
+        SAVE_PTR3( new->n, "n", NO_FREE,
+                new->argv, "argv", NO_FREE,
+                new->path, xasprintf("path '%s'", fs->path ?: "NULL"), FREE);
 
 #if MAX_HISTORY
         if (line_input_state) {
diff --git a/shell/ash_test/ash-misc/exitcode_trap2.right b/shell/ash_test/ash-misc/exitcode_trap2.right
new file mode 100644
index 000000000..6644d86bf
--- /dev/null
+++ b/shell/ash_test/ash-misc/exitcode_trap2.right
@@ -0,0 +1 @@
+42:42
diff --git a/shell/ash_test/ash-misc/exitcode_trap2.tests b/shell/ash_test/ash-misc/exitcode_trap2.tests
new file mode 100755
index 000000000..f259774bf
--- /dev/null
+++ b/shell/ash_test/ash-misc/exitcode_trap2.tests
@@ -0,0 +1,9 @@
+# "exit" in trap should not use last command's exitcode,
+# but exitcode on entering the trap.
+$THIS_SH -c '
+ trap "false;exit" term
+ kill $$ &
+ (exit 42)
+ wait
+'
+echo 42:$?
diff --git a/shell/ash_test/ash-redir/redir_exec1.right b/shell/ash_test/ash-redir/redir_exec1.right
index c98455bf5..26a664edc 100644
--- a/shell/ash_test/ash-redir/redir_exec1.right
+++ b/shell/ash_test/ash-redir/redir_exec1.right
@@ -1,2 +1 @@
 ./redir_exec1.tests: line 1: can't create /cant/be/created: nonexistent directory
-First
diff --git a/shell/hush_test/hush-misc/exitcode_trap2.right b/shell/hush_test/hush-misc/exitcode_trap2.right
new file mode 100644
index 000000000..6644d86bf
--- /dev/null
+++ b/shell/hush_test/hush-misc/exitcode_trap2.right
@@ -0,0 +1 @@
+42:42
diff --git a/shell/hush_test/hush-misc/exitcode_trap2.tests b/shell/hush_test/hush-misc/exitcode_trap2.tests
new file mode 100755
index 000000000..f259774bf
--- /dev/null
+++ b/shell/hush_test/hush-misc/exitcode_trap2.tests
@@ -0,0 +1,9 @@
+# "exit" in trap should not use last command's exitcode,
+# but exitcode on entering the trap.
+$THIS_SH -c '
+ trap "false;exit" term
+ kill $$ &
+ (exit 42)
+ wait
+'
+echo 42:$?