Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/shell

Timestamp:

Nov 4, 2007, 3:16:40 AM (16 years ago)

Author:

Bruno Cornec

Message:

Update to busybox 1.7.2

Location:

branches/2.2.5/mindi-busybox/shell

Files:

• Config.in (modified) (11 diffs)
• Kbuild (added)
• Makefile (deleted)
• Makefile.in (deleted)
• README (added)
• README.job (added)
• ash.c (modified) (172 diffs)
• ash_test (added)
• ash_test/ash-alias (added)
• ash_test/ash-alias/alias.right (added)
• ash_test/ash-alias/alias.tests (added)
• ash_test/ash-arith (added)
• ash_test/ash-arith/README.ash (added)
• ash_test/ash-arith/arith-for.right (added)
• ash_test/ash-arith/arith-for.testsx (added)
• ash_test/ash-arith/arith.right (added)
• ash_test/ash-arith/arith.tests (added)
• ash_test/ash-arith/arith1.sub (added)
• ash_test/ash-arith/arith2.sub (added)
• ash_test/ash-heredoc (added)
• ash_test/ash-heredoc/heredoc.right (added)
• ash_test/ash-heredoc/heredoc.tests (added)
• ash_test/ash-invert (added)
• ash_test/ash-invert/invert.right (added)
• ash_test/ash-invert/invert.tests (added)
• ash_test/printenv.c (added)
• ash_test/recho.c (added)
• ash_test/run-all (added)
• ash_test/zecho.c (added)
• bbsh.c (added)
• cmdedit.c (deleted)
• cmdedit.h (deleted)
• cttyhack.c (added)
• hush.c (modified) (88 diffs)
• hush_test (added)
• hush_test/hush-bugs (added)
• hush_test/hush-bugs/quote3.right (added)
• hush_test/hush-bugs/quote3.tests (added)
• hush_test/hush-bugs/tick.tests (added)
• hush_test/hush-misc (added)
• hush_test/hush-misc/read.right (added)
• hush_test/hush-misc/read.tests (added)
• hush_test/hush-misc/shift.right (added)
• hush_test/hush-misc/shift.tests (added)
• hush_test/hush-misc/syntax_err.right (added)
• hush_test/hush-misc/syntax_err.tests (added)
• hush_test/hush-parsing (added)
• hush_test/hush-parsing/argv0.right (added)
• hush_test/hush-parsing/argv0.tests (added)
• hush_test/hush-parsing/noeol.right (added)
• hush_test/hush-parsing/noeol.tests (added)
• hush_test/hush-parsing/noeol2.right (added)
• hush_test/hush-parsing/noeol2.tests (added)
• hush_test/hush-parsing/noeol3.right (added)
• hush_test/hush-parsing/noeol3.tests (added)
• hush_test/hush-parsing/process_subst.right (added)
• hush_test/hush-parsing/process_subst.tests (added)
• hush_test/hush-parsing/quote1.right (added)
• hush_test/hush-parsing/quote1.tests (added)
• hush_test/hush-parsing/quote2.right (added)
• hush_test/hush-parsing/quote2.tests (added)
• hush_test/hush-parsing/quote4.right (added)
• hush_test/hush-parsing/quote4.tests (added)
• hush_test/hush-parsing/starquoted.right (added)
• hush_test/hush-parsing/starquoted.tests (added)
• hush_test/hush-vars (added)
• hush_test/hush-vars/star.right (added)
• hush_test/hush-vars/star.tests (added)
• hush_test/hush-vars/var.right (added)
• hush_test/hush-vars/var.tests (added)
• hush_test/hush-vars/var_expand_in_assign.right (added)
• hush_test/hush-vars/var_expand_in_assign.tests (added)
• hush_test/hush-vars/var_subst_in_for.right (added)
• hush_test/hush-vars/var_subst_in_for.tests (added)
• hush_test/hush-z_slow (added)
• hush_test/hush-z_slow/leak_var.right (added)
• hush_test/hush-z_slow/leak_var.tests (added)
• hush_test/run-all (added)
• lash.c (modified) (93 diffs)
• msh.c (modified) (227 diffs)
• susv3_doc.tar.bz2 (added)

branches/2.2.5/mindi-busybox/shell/Config.in

@@ -8 +8 @@
 choice
     prompt "Choose your default shell"
-    default CONFIG_FEATURE_SH_IS_NONE
+    default FEATURE_SH_IS_NONE
     help
       Choose a shell. The ash shell is the most bash compatible
       and full featured one.
 
-config CONFIG_FEATURE_SH_IS_ASH
-    select CONFIG_ASH
+config FEATURE_SH_IS_ASH
+    select ASH
     bool "ash"
 
-config CONFIG_FEATURE_SH_IS_HUSH
-    select CONFIG_HUSH
+config FEATURE_SH_IS_HUSH
+    select HUSH
     bool "hush"
 
-config CONFIG_FEATURE_SH_IS_LASH
-    select CONFIG_LASH
+config FEATURE_SH_IS_LASH
+    select LASH
     bool "lash"
 
-config CONFIG_FEATURE_SH_IS_MSH
-    select CONFIG_MSH
+config FEATURE_SH_IS_MSH
+    select MSH
     bool "msh"
 
-config CONFIG_FEATURE_SH_IS_NONE
+config FEATURE_SH_IS_NONE
     bool "none"
 
 endchoice
 
-config CONFIG_ASH
+config ASH
     bool "ash"
     default n
-    select CONFIG_TEST
+    select TEST
     help
       Tha 'ash' shell adds about 60k in the default configuration and is
@@ -46 +46 @@
 
 comment "Ash Shell Options"
-    depends on CONFIG_ASH
-
-config CONFIG_ASH_JOB_CONTROL
+    depends on ASH
+
+config ASH_JOB_CONTROL
     bool "Job control"
     default y
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable job control in the ash shell.
 
-config CONFIG_ASH_READ_NCHARS
+config ASH_READ_NCHARS
     bool "'read -n N' and 'read -s' support"
     default n
-    depends on CONFIG_ASH
+    depends on ASH
     help
       'read -n N' will return a value after N characters have been read.
       'read -s' will read without echoing the user's input.
 
-config CONFIG_ASH_READ_TIMEOUT
+config ASH_READ_TIMEOUT
     bool "'read -t S' support."
     default n
-    depends on CONFIG_ASH
+    depends on ASH
     help
       'read -t S' will return a value after S seconds have passed.
@@ -72 +72 @@
       as a decimal fraction, e.g. 'read -t 2.5 foo'.
 
-config CONFIG_ASH_ALIAS
+config ASH_ALIAS
     bool "alias support"
     default y
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable alias support in the ash shell.
 
-config CONFIG_ASH_MATH_SUPPORT
+config ASH_MATH_SUPPORT
     bool "Posix math support"
     default y
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable math support in the ash shell.
 
-config CONFIG_ASH_MATH_SUPPORT_64
+config ASH_MATH_SUPPORT_64
     bool "Extend Posix math support to 64 bit"
     default n
-    depends on CONFIG_ASH_MATH_SUPPORT
+    depends on ASH_MATH_SUPPORT
     help
       Enable 64-bit math support in the ash shell.  This will make
@@ -95 +95 @@
       large numbers.
 
-config CONFIG_ASH_GETOPTS
+config ASH_GETOPTS
     bool "Builtin getopt to parse positional parameters"
     default n
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable getopts builtin in the ash shell.
 
-config CONFIG_ASH_BUILTIN_ECHO
+config ASH_BUILTIN_ECHO
     bool "Builtin version of 'echo'"
     default y
-    select CONFIG_ECHO
-    depends on CONFIG_ASH
-    help
-      Enable support for echo, built in to ash.
-
-config CONFIG_ASH_BUILTIN_TEST
+    select ECHO
+    depends on ASH
+    help
+      Enable support for echo, builtin to ash.
+
+config ASH_BUILTIN_TEST
     bool "Builtin version of 'test'"
     default y
-    select CONFIG_TEST
-    depends on CONFIG_ASH
-    help
-      Enable support for test, built in to ash.
-
-config CONFIG_ASH_CMDCMD
+    select TEST
+    depends on ASH
+    help
+      Enable support for test, builtin to ash.
+
+config ASH_CMDCMD
     bool "'command' command to override shell builtins"
     default n
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable support for the ash 'command' builtin, which allows
@@ -127 +127 @@
       even when there is an ash builtin command with the same name.
 
-config CONFIG_ASH_MAIL
+config ASH_MAIL
     bool "Check for new mail on interactive shells"
     default y
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable "check for new mail" in the ash shell.
 
-config CONFIG_ASH_OPTIMIZE_FOR_SIZE
+config ASH_OPTIMIZE_FOR_SIZE
     bool "Optimize for size instead of speed"
     default y
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Compile ash for reduced size at the price of speed.
 
-config CONFIG_ASH_RANDOM_SUPPORT
+config ASH_RANDOM_SUPPORT
     bool "Pseudorandom generator and variable $RANDOM"
     default n
-    depends on CONFIG_ASH
+    depends on ASH
     help
       Enable pseudorandom generator and dynamic variable "$RANDOM".
@@ -152 +152 @@
       variable will no longer have special treatment.
 
-config CONFIG_ASH_EXPAND_PRMT
+config ASH_EXPAND_PRMT
     bool "Expand prompt string"
     default n
-    depends on CONFIG_ASH
+    depends on ASH
     help
       "PS#" may be contain volatile content, such as backquote commands.
@@ -161 +161 @@
       variable each time it is displayed.
 
-config CONFIG_HUSH
+config HUSH
     bool "hush"
     default n
-    select CONFIG_TRUE
-    select CONFIG_FALSE
-    select CONFIG_TEST
+    select TRUE
+    select FALSE
+    select TEST
     help
       hush is a very small shell (just 18k) and it has fairly complete
@@ -177 +177 @@
       expansion, &> and >& redirection of stdout+stderr, etc.
 
-
-config CONFIG_LASH
+config HUSH_HELP
+    bool "help builtin"
+    default n
+    depends on HUSH
+    help
+      Enable help builtin in hush. Code size + ~1 kbyte.
+
+config HUSH_INTERACTIVE
+    bool "Interactive mode"
+    default y
+    depends on HUSH
+    help
+      Enable interactive mode (prompt and command editing).
+      Without this, hush simply reads and executes commands
+      from stdin just like a shell script from the file.
+      No prompt, no PS1/PS2 magic shell variables.
+
+config HUSH_JOB
+    bool "Job control"
+    default n
+    depends on HUSH_INTERACTIVE
+    help
+      Enable job control: Ctrl-Z backgrounds, Ctrl-C interrupts current
+      command (not entire shell), fg/bg builtins work. Without this option,
+      "cmd &" still works by simply spawning a process and immediately
+      prompting for next command (or executing next command in a script),
+      but no separate process group is formed.
+
+config HUSH_TICK
+    bool "Process substitution"
+    default n
+    depends on HUSH
+    help
+      Enable process substitution `command` and $(command) in hush.
+
+config HUSH_IF
+    bool "Support if/then/elif/else/fi"
+    default n
+    depends on HUSH
+    help
+      Enable if/then/elif/else/fi in hush.
+
+config HUSH_LOOPS
+    bool "Support for, while and until loops"
+    default n
+    depends on HUSH
+    help
+      Enable for, while and until loops in hush.
+
+config LASH
     bool "lash"
     default n
-    select CONFIG_TRUE
-    select CONFIG_FALSE
-    select CONFIG_TEST
+    select TRUE
+    select FALSE
+    select TEST
     help
       lash is the very smallest shell (adds just 10k) and it is quite
@@ -193 +241 @@
 
 
-config CONFIG_MSH
+config MSH
     bool "msh"
     default n
-    select CONFIG_TRUE
-    select CONFIG_FALSE
-    select CONFIG_TEST
+    select TRUE
+    select FALSE
+    select TEST
     help
       The minix shell (adds just 30k) is quite complete and handles things
@@ -208 +256 @@
 
 comment "Bourne Shell Options"
-    depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
-
-config CONFIG_FEATURE_SH_EXTRA_QUIET
+    depends on MSH || LASH || HUSH || ASH
+
+config FEATURE_SH_EXTRA_QUIET
     bool "Hide message on interactive shell startup"
     default n
-    depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+    depends on MSH || LASH || HUSH || ASH
     help
       Remove the busybox introduction when starting a shell.
 
-config CONFIG_FEATURE_SH_STANDALONE_SHELL
+config FEATURE_SH_STANDALONE
     bool "Standalone shell"
     default n
-    depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
-    help
-      This option causes the selected busybox shell to use busybox applets
+    depends on (MSH || LASH || HUSH || ASH) && FEATURE_PREFER_APPLETS
+    help
+      This option causes busybox shells to use busybox applets
       in preference to executables in the PATH whenever possible.  For
       example, entering the command 'ifconfig' into the shell would cause
@@ -231 +279 @@
       for use as a rescue shell, in the event that you screw up your system.
 
-      Note that this will *also* cause applets to take precedence
-      over shell builtins of the same name.  So turning this on will
-      eliminate any performance gained by turning on the builtin "echo"
-      and "test" commands in ash.
-
-      Note that when using this option, the shell will attempt to directly
-      run '/bin/busybox'.  If you do not have the busybox binary sitting in
-      that exact location with that exact name, this option will not work at
-      all.
-
-config CONFIG_FEATURE_COMMAND_EDITING
-    bool "Command line editing"
-    default n
-    depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
-    help
-      Enable command editing in shell.
-
-config CONFIG_FEATURE_COMMAND_EDITING_VI
-    bool "vi-style line editing commands"
-    default n
-    depends on CONFIG_FEATURE_COMMAND_EDITING
-    help
-      Enable vi-style line editing in the shell.  This mode can be
-      turned on and off with "set -o vi" and "set +o vi".
-
-config CONFIG_FEATURE_COMMAND_HISTORY
-    int "History size"
-    default 15
-    depends on CONFIG_FEATURE_COMMAND_EDITING
-    help
-      Specify command history size in shell.
-
-config CONFIG_FEATURE_COMMAND_SAVEHISTORY
-    bool "History saving"
-    default n
-    depends on CONFIG_ASH && CONFIG_FEATURE_COMMAND_EDITING
-    help
-      Enable history saving in ash shell.
-
-config CONFIG_FEATURE_COMMAND_TAB_COMPLETION
-    bool "Tab completion"
-    default n
-    depends on CONFIG_FEATURE_COMMAND_EDITING
-    help
-      Enable tab completion in shell.
-
-config CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
-    bool "Username completion"
-    default n
-    depends on CONFIG_FEATURE_COMMAND_TAB_COMPLETION
-    help
-      Enable username completion in shell.
-
-config CONFIG_FEATURE_SH_FANCY_PROMPT
-    bool "Fancy shell prompts"
-    default n
-    depends on CONFIG_FEATURE_COMMAND_EDITING
-    help
-      Setting this option allows for prompts to use things like \w and
-      \$ and also using escape codes.
+      This is implemented by re-execing /proc/self/exe (typically)
+      with right parameters. Some selected applets ("NOFORK" applets)
+      can even be executed without creating new process.
+      Instead, busybox will call <applet>_main() internally.
+
+      However, this causes problems in chroot jails without mounted /proc
+      and with ps/top (command name can be shown as 'exe' for applets
+      started this way).
+# untrue?
+#     Note that this will *also* cause applets to take precedence
+#     over shell builtins of the same name.  So turning this on will
+#     eliminate any performance gained by turning on the builtin "echo"
+#     and "test" commands in ash.
+# untrue?
+#     Note that when using this option, the shell will attempt to directly
+#     run '/bin/busybox'.  If you do not have the busybox binary sitting in
+#     that exact location with that exact name, this option will not work at
+#     all.
+
+config CTTYHACK
+    bool "cttyhack"
+    default n
+    help
+      One common problem reported on the mailing list is "can't access tty;
+      job control turned off" error message which typically appears when
+      one tries to use shell with stdin/stdout opened to /dev/console.
+      This device is special - it cannot be a controlling tty.
+
+      Proper solution is to use correct device instead of /dev/console.
+
+      cttyhack provides "quick and dirty" solution to this problem.
+      It analyzes stdin with various ioctls, trying to determine whether
+      it is a /dev/ttyN or /dev/ttySN (virtual terminal or serial line).
+      If it detects one, it closes stdin/out/err and reopens that device.
+      Then it executes given program. Usage example for /etc/inittab
+      (for busybox init):
+
+      ::respawn:/bin/cttyhack /bin/sh
 
 endmenu

branches/2.2.5/mindi-busybox/shell/ash.c

@@ -32 +32 @@
  */
 
-
 /*
  * The follow should be set to reflect the type of system you have:
@@ -43 +42 @@
  * a quit signal will generate a core dump.
  */
-
-
+#define DEBUG 0
 #define IFS_BROKEN
-
 #define PROFILE 0
-
-#include "busybox.h"
-
-#ifdef DEBUG
+#if ENABLE_ASH_JOB_CONTROL
+#define JOBS 1
+#else
+#define JOBS 0
+#endif
+
+#if DEBUG
 #define _GNU_SOURCE
 #endif
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <assert.h>
-#include <ctype.h>
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
+#include "busybox.h" /* for struct bb_applet */
 #include <paths.h>
 #include <setjmp.h>
-#include <signal.h>
-/*#include <stdint.h>*/
-#include <time.h>
 #include <fnmatch.h>
-
-#include "pwd_.h"
-
-#ifdef CONFIG_ASH_JOB_CONTROL
-#define JOBS 1
-#else
-#undef JOBS
-#endif
-
-#if JOBS || defined(CONFIG_ASH_READ_NCHARS)
+#if JOBS || ENABLE_ASH_READ_NCHARS
 #include <termios.h>
 #endif
-
-#include "cmdedit.h"
-
-#ifdef __GLIBC__
-/* glibc sucks */
-static int *dash_errno;
-#undef errno
-#define errno (*dash_errno)
-#endif
+extern char **environ;
 
 #if defined(__uClinux__)
@@ -107 +67 @@
 #endif
 
-#ifdef DEBUG
-#define _DIAGASSERT(assert_expr) assert(assert_expr)
-#else
-#define _DIAGASSERT(assert_expr)
-#endif
-
-
-#ifdef CONFIG_ASH_ALIAS
-/*      alias.h       */
-
-#define ALIASINUSE      1
-#define ALIASDEAD       2
-
-struct alias {
-    struct alias *next;
-    char *name;
-    char *val;
-    int flag;
+
+/* ============ Misc helpers */
+
+#define xbarrier() do { __asm__ __volatile__ ("": : :"memory"); } while (0)
+
+/* C99 say: "char" declaration may be signed or unsigned default */
+#define signed_char2int(sc) ((int)((signed char)sc))
+
+
+/* ============ Shell options */
+
+static const char *const optletters_optnames[] = {
+    "e"   "errexit",
+    "f"   "noglob",
+    "I"   "ignoreeof",
+    "i"   "interactive",
+    "m"   "monitor",
+    "n"   "noexec",
+    "s"   "stdin",
+    "x"   "xtrace",
+    "v"   "verbose",
+    "C"   "noclobber",
+    "a"   "allexport",
+    "b"   "notify",
+    "u"   "nounset",
+    "\0"  "vi"
+#if DEBUG
+    ,"\0"  "nolog"
+    ,"\0"  "debug"
+#endif
 };
 
-static struct alias *lookupalias(const char *, int);
-static int aliascmd(int, char **);
-static int unaliascmd(int, char **);
-static void rmaliases(void);
-static int unalias(const char *);
-static void printalias(const struct alias *);
-#endif
-
-/*      cd.h  */
-
-
-static void    setpwd(const char *, int);
-
-/*      error.h      */
-
-
-/*
- * Types of operations (passed to the errmsg routine).
- */
-
-
-static const char not_found_msg[] = "%s: not found";
-
-
-#define E_OPEN  "No such file"          /* opening a file */
-#define E_CREAT "Directory nonexistent" /* creating a file */
-#define E_EXEC  not_found_msg+4         /* executing a program */
+#define optletters(n) optletters_optnames[(n)][0]
+#define optnames(n) (&optletters_optnames[(n)][1])
+
+enum { NOPTS = ARRAY_SIZE(optletters_optnames) };
+
+static char optlist[NOPTS] ALIGN1;
+
+#define eflag optlist[0]
+#define fflag optlist[1]
+#define Iflag optlist[2]
+#define iflag optlist[3]
+#define mflag optlist[4]
+#define nflag optlist[5]
+#define sflag optlist[6]
+#define xflag optlist[7]
+#define vflag optlist[8]
+#define Cflag optlist[9]
+#define aflag optlist[10]
+#define bflag optlist[11]
+#define uflag optlist[12]
+#define viflag optlist[13]
+#if DEBUG
+#define nolog optlist[14]
+#define debug optlist[15]
+#endif
+
+
+/* ============ Misc data */
+
+static char nullstr[1] ALIGN1;  /* zero length string */
+static const char homestr[] ALIGN1 = "HOME";
+static const char snlfmt[] ALIGN1 = "%s\n";
+static const char illnum[] ALIGN1 = "Illegal number: %s";
+
+static char *minusc;  /* argument to -c option */
+
+/* pid of main shell */
+static int rootpid;
+/* shell level: 0 for the main shell, 1 for its children, and so on */
+static int shlvl;
+#define rootshell (!shlvl)
+/* trap handler commands */
+static char *trap[NSIG];
+static smallint isloginsh;
+/* current value of signal */
+static char sigmode[NSIG - 1];
+/* indicates specified signal received */
+static char gotsig[NSIG - 1];
+static char *arg0; /* value of $0 */
+
+
+/* ============ Interrupts / exceptions */
 
 /*
@@ -164 +161 @@
  * inner scope, and restore handler on exit from the scope.
  */
-
 struct jmploc {
     jmp_buf loc;
 };
-
-static struct jmploc *handler;
+static struct jmploc *exception_handler;
 static int exception;
-static volatile int suppressint;
-static volatile sig_atomic_t intpending;
-
 /* exceptions */
 #define EXINT 0         /* SIGINT received */
@@ -181 +173 @@
 #define EXEXIT 4        /* exit the shell */
 #define EXSIG 5         /* trapped signal in wait(1) */
-
-
+static volatile int suppressint;
+static volatile sig_atomic_t intpending;
 /* do we generate EXSIG events */
 static int exsig;
 /* last pending signal */
-static volatile sig_atomic_t pendingsigs;
+static volatile sig_atomic_t pendingsig;
+
+/*
+ * Sigmode records the current value of the signal handlers for the various
+ * modes.  A value of zero means that the current handler is not known.
+ * S_HARD_IGN indicates that the signal was ignored on entry to the shell,
+ */
+
+#define S_DFL 1                 /* default signal handling (SIG_DFL) */
+#define S_CATCH 2               /* signal is caught */
+#define S_IGN 3                 /* signal is ignored (SIG_IGN) */
+#define S_HARD_IGN 4            /* signal is ignored permenantly */
+#define S_RESET 5               /* temporary - to reset a hard ignored sig */
 
 /*
@@ -194 +198 @@
  * more fun than worrying about efficiency and portability. :-))
  */
-
-#define xbarrier() ({ __asm__ __volatile__ ("": : :"memory"); })
-#define INTOFF \
-    ({ \
+#define INT_OFF \
+    do { \
         suppressint++; \
         xbarrier(); \
-        0; \
-    })
-#define SAVEINT(v) ((v) = suppressint)
-#define RESTOREINT(v) \
-    ({ \
+    } while (0)
+
+/*
+ * Called to raise an exception.  Since C doesn't include exceptions, we
+ * just do a longjmp to the exception handler.  The type of exception is
+ * stored in the global variable "exception".
+ */
+static void raise_exception(int) ATTRIBUTE_NORETURN;
+static void
+raise_exception(int e)
+{
+#if DEBUG
+    if (exception_handler == NULL)
+        abort();
+#endif
+    INT_OFF;
+    exception = e;
+    longjmp(exception_handler->loc, 1);
+}
+
+/*
+ * Called from trap.c when a SIGINT is received.  (If the user specifies
+ * that SIGINT is to be trapped or ignored using the trap builtin, then
+ * this routine is not called.)  Suppressint is nonzero when interrupts
+ * are held using the INT_OFF macro.  (The test for iflag is just
+ * defensive programming.)
+ */
+static void raise_interrupt(void) ATTRIBUTE_NORETURN;
+static void
+raise_interrupt(void)
+{
+    int i;
+    sigset_t mask;
+
+    intpending = 0;
+    /* Signal is not automatically re-enabled after it is raised,
+     * do it ourself */
+    sigemptyset(&mask);
+    sigprocmask(SIG_SETMASK, &mask, 0);
+    /* pendingsig = 0; - now done in onsig() */
+
+    i = EXSIG;
+    if (gotsig[SIGINT - 1] && !trap[SIGINT]) {
+        if (!(rootshell && iflag)) {
+            signal(SIGINT, SIG_DFL);
+            raise(SIGINT);
+        }
+        i = EXINT;
+    }
+    raise_exception(i);
+    /* NOTREACHED */
+}
+
+#if ENABLE_ASH_OPTIMIZE_FOR_SIZE
+static void
+int_on(void)
+{
+    if (--suppressint == 0 && intpending) {
+        raise_interrupt();
+    }
+}
+#define INT_ON int_on()
+static void
+force_int_on(void)
+{
+    suppressint = 0;
+    if (intpending)
+        raise_interrupt();
+}
+#define FORCE_INT_ON force_int_on()
+#else
+#define INT_ON \
+    do { \
         xbarrier(); \
-        if ((suppressint = (v)) == 0 && intpending) onint(); \
-        0; \
-    })
-#define EXSIGON() \
-    ({ \
+        if (--suppressint == 0 && intpending) \
+            raise_interrupt(); \
+    } while (0)
+#define FORCE_INT_ON \
+    do { \
+        xbarrier(); \
+        suppressint = 0; \
+        if (intpending) \
+            raise_interrupt(); \
+    } while (0)
+#endif /* ASH_OPTIMIZE_FOR_SIZE */
+
+#define SAVE_INT(v) ((v) = suppressint)
+
+#define RESTORE_INT(v) \
+    do { \
+        xbarrier(); \
+        suppressint = (v); \
+        if (suppressint == 0 && intpending) \
+            raise_interrupt(); \
+    } while (0)
+
+#define EXSIGON \
+    do { \
         exsig++; \
         xbarrier(); \
-        if (pendingsigs) \
-            exraise(EXSIG); \
-        0; \
-    })
+        if (pendingsig) \
+            raise_exception(EXSIG); \
+    } while (0)
 /* EXSIG is turned off by evalbltin(). */
 
-
-static void exraise(int) ATTRIBUTE_NORETURN;
-static void onint(void) ATTRIBUTE_NORETURN;
-
-static void sh_error(const char *, ...) ATTRIBUTE_NORETURN;
-static void exerror(int, const char *, ...) ATTRIBUTE_NORETURN;
-
-static void sh_warnx(const char *, ...);
-
-#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
-static void
-inton(void) {
-    if (--suppressint == 0 && intpending) {
-        onint();
-    }
-}
-#define INTON inton()
-static void forceinton(void)
-{
-    suppressint = 0;
-    if (intpending)
-        onint();
-}
-#define FORCEINTON forceinton()
-#else
-#define INTON \
-    ({ \
-        xbarrier(); \
-        if (--suppressint == 0 && intpending) onint(); \
-        0; \
-    })
-#define FORCEINTON \
-    ({ \
-        xbarrier(); \
-        suppressint = 0; \
-        if (intpending) onint(); \
-        0; \
-    })
-#endif /* CONFIG_ASH_OPTIMIZE_FOR_SIZE */
-
-/*      expand.h     */
-
-struct strlist {
-    struct strlist *next;
-    char *text;
+/*
+ * Ignore a signal. Only one usage site - in forkchild()
+ */
+static void
+ignoresig(int signo)
+{
+    if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
+        signal(signo, SIG_IGN);
+    }
+    sigmode[signo - 1] = S_HARD_IGN;
+}
+
+/*
+ * Signal handler. Only one usage site - in setsignal()
+ */
+static void
+onsig(int signo)
+{
+    gotsig[signo - 1] = 1;
+    pendingsig = signo;
+
+    if (exsig || (signo == SIGINT && !trap[SIGINT])) {
+        if (!suppressint) {
+            pendingsig = 0;
+            raise_interrupt();
+        }
+        intpending = 1;
+    }
+}
+
+
+/* ============ Stdout/stderr output */
+
+static void
+outstr(const char *p, FILE *file)
+{
+    INT_OFF;
+    fputs(p, file);
+    INT_ON;
+}
+
+static void
+flush_stdout_stderr(void)
+{
+    INT_OFF;
+    fflush(stdout);
+    fflush(stderr);
+    INT_ON;
+}
+
+static void
+flush_stderr(void)
+{
+    INT_OFF;
+    fflush(stderr);
+    INT_ON;
+}
+
+static void
+outcslow(int c, FILE *dest)
+{
+    INT_OFF;
+    putc(c, dest);
+    fflush(dest);
+    INT_ON;
+}
+
+static int out1fmt(const char *, ...) __attribute__((__format__(__printf__,1,2)));
+static int
+out1fmt(const char *fmt, ...)
+{
+    va_list ap;
+    int r;
+
+    INT_OFF;
+    va_start(ap, fmt);
+    r = vprintf(fmt, ap);
+    va_end(ap);
+    INT_ON;
+    return r;
+}
+
+static int fmtstr(char *, size_t, const char *, ...) __attribute__((__format__(__printf__,3,4)));
+static int
+fmtstr(char *outbuf, size_t length, const char *fmt, ...)
+{
+    va_list ap;
+    int ret;
+
+    va_start(ap, fmt);
+    INT_OFF;
+    ret = vsnprintf(outbuf, length, fmt, ap);
+    va_end(ap);
+    INT_ON;
+    return ret;
+}
+
+static void
+out1str(const char *p)
+{
+    outstr(p, stdout);
+}
+
+static void
+out2str(const char *p)
+{
+    outstr(p, stderr);
+    flush_stderr();
+}
+
+
+/* ============ Parser structures */
+
+/* control characters in argument strings */
+#define CTLESC '\201'           /* escape next character */
+#define CTLVAR '\202'           /* variable defn */
+#define CTLENDVAR '\203'
+#define CTLBACKQ '\204'
+#define CTLQUOTE 01             /* ored with CTLBACKQ code if in quotes */
+/*      CTLBACKQ | CTLQUOTE == '\205' */
+#define CTLARI  '\206'          /* arithmetic expression */
+#define CTLENDARI '\207'
+#define CTLQUOTEMARK '\210'
+
+/* variable substitution byte (follows CTLVAR) */
+#define VSTYPE  0x0f            /* type of variable substitution */
+#define VSNUL   0x10            /* colon--treat the empty string as unset */
+#define VSQUOTE 0x80            /* inside double quotes--suppress splitting */
+
+/* values of VSTYPE field */
+#define VSNORMAL        0x1             /* normal variable:  $var or ${var} */
+#define VSMINUS         0x2             /* ${var-text} */
+#define VSPLUS          0x3             /* ${var+text} */
+#define VSQUESTION      0x4             /* ${var?message} */
+#define VSASSIGN        0x5             /* ${var=text} */
+#define VSTRIMRIGHT     0x6             /* ${var%pattern} */
+#define VSTRIMRIGHTMAX  0x7             /* ${var%%pattern} */
+#define VSTRIMLEFT      0x8             /* ${var#pattern} */
+#define VSTRIMLEFTMAX   0x9             /* ${var##pattern} */
+#define VSLENGTH        0xa             /* ${#var} */
+
+static const char dolatstr[] ALIGN1 = {
+    CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'
 };
-
-
-struct arglist {
-    struct strlist *list;
-    struct strlist **lastp;
-};
-
-/*
- * expandarg() flags
- */
-#define EXP_FULL        0x1     /* perform word splitting & file globbing */
-#define EXP_TILDE       0x2     /* do normal tilde expansion */
-#define EXP_VARTILDE    0x4     /* expand tildes in an assignment */
-#define EXP_REDIR       0x8     /* file glob for a redirection (1 match only) */
-#define EXP_CASE        0x10    /* keeps quotes around for CASE pattern */
-#define EXP_RECORD      0x20    /* need to record arguments for ifs breakup */
-#define EXP_VARTILDE2   0x40    /* expand tildes after colons only */
-#define EXP_WORD        0x80    /* expand word in parameter expansion */
-#define EXP_QWORD       0x100   /* expand word in quoted parameter expansion */
-
-
-union node;
-static void expandarg(union node *, struct arglist *, int);
-#define rmescapes(p) _rmescapes((p), 0)
-static char *_rmescapes(char *, int);
-static int casematch(union node *, char *);
-
-#ifdef CONFIG_ASH_MATH_SUPPORT
-static void expari(int);
-#endif
-
-/*      eval.h       */
-
-static char *commandname;              /* currently executing command */
-static struct strlist *cmdenviron;     /* environment for builtin command */
-static int exitstatus;                 /* exit status of last command */
-static int back_exitstatus;            /* exit status of backquoted command */
-
-
-struct backcmd {                /* result of evalbackcmd */
-    int fd;                 /* file descriptor to read from */
-    char *buf;              /* buffer */
-    int nleft;              /* number of chars in buffer */
-    struct job *jp;         /* job structure for command */
-};
-
-/*
- * This file was generated by the mknodes program.
- */
 
 #define NCMD 0
@@ -342 +479 @@
 #define NNOT 25
 
-
+union node;
 
 struct ncmd {
-      int type;
-      union node *assign;
-      union node *args;
-      union node *redirect;
+    int type;
+    union node *assign;
+    union node *args;
+    union node *redirect;
 };
 
-
 struct npipe {
-      int type;
-      int backgnd;
-      struct nodelist *cmdlist;
+    int type;
+    int backgnd;
+    struct nodelist *cmdlist;
 };
 
-
 struct nredir {
-      int type;
-      union node *n;
-      union node *redirect;
+    int type;
+    union node *n;
+    union node *redirect;
 };
 
-
 struct nbinary {
-      int type;
-      union node *ch1;
-      union node *ch2;
+    int type;
+    union node *ch1;
+    union node *ch2;
 };
 
-
 struct nif {
-      int type;
-      union node *test;
-      union node *ifpart;
-      union node *elsepart;
+    int type;
+    union node *test;
+    union node *ifpart;
+    union node *elsepart;
 };
 
-
 struct nfor {
-      int type;
-      union node *args;
-      union node *body;
-      char *var;
+    int type;
+    union node *args;
+    union node *body;
+    char *var;
 };
 
-
 struct ncase {
-      int type;
-      union node *expr;
-      union node *cases;
+    int type;
+    union node *expr;
+    union node *cases;
 };
 
-
 struct nclist {
-      int type;
-      union node *next;
-      union node *pattern;
-      union node *body;
+    int type;
+    union node *next;
+    union node *pattern;
+    union node *body;
 };
 
-
 struct narg {
-      int type;
-      union node *next;
-      char *text;
-      struct nodelist *backquote;
+    int type;
+    union node *next;
+    char *text;
+    struct nodelist *backquote;
 };
 
-
 struct nfile {
-      int type;
-      union node *next;
-      int fd;
-      union node *fname;
-      char *expfname;
+    int type;
+    union node *next;
+    int fd;
+    union node *fname;
+    char *expfname;
 };
 
-
 struct ndup {
-      int type;
-      union node *next;
-      int fd;
-      int dupfd;
-      union node *vname;
+    int type;
+    union node *next;
+    int fd;
+    int dupfd;
+    union node *vname;
 };
 
-
 struct nhere {
-      int type;
-      union node *next;
-      int fd;
-      union node *doc;
+    int type;
+    union node *next;
+    int fd;
+    union node *doc;
 };
 
-
 struct nnot {
-      int type;
-      union node *com;
+    int type;
+    union node *com;
 };
 
-
 union node {
-      int type;
-      struct ncmd ncmd;
-      struct npipe npipe;
-      struct nredir nredir;
-      struct nbinary nbinary;
-      struct nif nif;
-      struct nfor nfor;
-      struct ncase ncase;
-      struct nclist nclist;
-      struct narg narg;
-      struct nfile nfile;
-      struct ndup ndup;
-      struct nhere nhere;
-      struct nnot nnot;
+    int type;
+    struct ncmd ncmd;
+    struct npipe npipe;
+    struct nredir nredir;
+    struct nbinary nbinary;
+    struct nif nif;
+    struct nfor nfor;
+    struct ncase ncase;
+    struct nclist nclist;
+    struct narg narg;
+    struct nfile nfile;
+    struct ndup ndup;
+    struct nhere nhere;
+    struct nnot nnot;
 };
-
 
 struct nodelist {
@@ -467 +590 @@
 };
 
-
 struct funcnode {
     int count;
@@ -473 +595 @@
 };
 
-
-static void freefunc(struct funcnode *);
-/*      parser.h     */
-
-/* control characters in argument strings */
-#define CTL_FIRST '\201'        /* first 'special' character */
-#define CTLESC '\201'           /* escape next character */
-#define CTLVAR '\202'           /* variable defn */
-#define CTLENDVAR '\203'
-#define CTLBACKQ '\204'
-#define CTLQUOTE 01             /* ored with CTLBACKQ code if in quotes */
-/*      CTLBACKQ | CTLQUOTE == '\205' */
-#define CTLARI  '\206'          /* arithmetic expression */
-#define CTLENDARI '\207'
-#define CTLQUOTEMARK '\210'
-#define CTL_LAST '\210'         /* last 'special' character */
-
-/* variable substitution byte (follows CTLVAR) */
-#define VSTYPE  0x0f            /* type of variable substitution */
-#define VSNUL   0x10            /* colon--treat the empty string as unset */
-#define VSQUOTE 0x80            /* inside double quotes--suppress splitting */
-
-/* values of VSTYPE field */
-#define VSNORMAL        0x1             /* normal variable:  $var or ${var} */
-#define VSMINUS         0x2             /* ${var-text} */
-#define VSPLUS          0x3             /* ${var+text} */
-#define VSQUESTION      0x4             /* ${var?message} */
-#define VSASSIGN        0x5             /* ${var=text} */
-#define VSTRIMRIGHT     0x6             /* ${var%pattern} */
-#define VSTRIMRIGHTMAX  0x7             /* ${var%%pattern} */
-#define VSTRIMLEFT      0x8             /* ${var#pattern} */
-#define VSTRIMLEFTMAX   0x9             /* ${var##pattern} */
-#define VSLENGTH        0xa             /* ${#var} */
-
-/* values of checkkwd variable */
-#define CHKALIAS        0x1
-#define CHKKWD          0x2
-#define CHKNL           0x4
-
-#define IBUFSIZ (BUFSIZ + 1)
-
-/*
- * NEOF is returned by parsecmd when it encounters an end of file.  It
- * must be distinct from NULL, so we use the address of a variable that
- * happens to be handy.
- */
-static int plinno = 1;                  /* input line number */
-
-/* number of characters left in input buffer */
-static int parsenleft;                  /* copy of parsefile->nleft */
-static int parselleft;                  /* copy of parsefile->lleft */
-
-/* next character in input buffer */
-static char *parsenextc;                /* copy of parsefile->nextc */
+/*
+ * Free a parse tree.
+ */
+static void
+freefunc(struct funcnode *f)
+{
+    if (f && --f->count < 0)
+        free(f);
+}
+
+
+/* ============ Debugging output */
+
+#if DEBUG
+
+static FILE *tracefile;
+
+static void
+trace_printf(const char *fmt, ...)
+{
+    va_list va;
+
+    if (debug != 1)
+        return;
+    va_start(va, fmt);
+    vfprintf(tracefile, fmt, va);
+    va_end(va);
+}
+
+static void
+trace_vprintf(const char *fmt, va_list va)
+{
+    if (debug != 1)
+        return;
+    vfprintf(tracefile, fmt, va);
+}
+
+static void
+trace_puts(const char *s)
+{
+    if (debug != 1)
+        return;
+    fputs(s, tracefile);
+}
+
+static void
+trace_puts_quoted(char *s)
+{
+    char *p;
+    char c;
+
+    if (debug != 1)
+        return;
+    putc('"', tracefile);
+    for (p = s; *p; p++) {
+        switch (*p) {
+        case '\n':  c = 'n';  goto backslash;
+        case '\t':  c = 't';  goto backslash;
+        case '\r':  c = 'r';  goto backslash;
+        case '"':  c = '"';  goto backslash;
+        case '\\':  c = '\\';  goto backslash;
+        case CTLESC:  c = 'e';  goto backslash;
+        case CTLVAR:  c = 'v';  goto backslash;
+        case CTLVAR+CTLQUOTE:  c = 'V'; goto backslash;
+        case CTLBACKQ:  c = 'q';  goto backslash;
+        case CTLBACKQ+CTLQUOTE:  c = 'Q'; goto backslash;
+ backslash:
+            putc('\\', tracefile);
+            putc(c, tracefile);
+            break;
+        default:
+            if (*p >= ' ' && *p <= '~')
+                putc(*p, tracefile);
+            else {
+                putc('\\', tracefile);
+                putc(*p >> 6 & 03, tracefile);
+                putc(*p >> 3 & 07, tracefile);
+                putc(*p & 07, tracefile);
+            }
+            break;
+        }
+    }
+    putc('"', tracefile);
+}
+
+static void
+trace_puts_args(char **ap)
+{
+    if (debug != 1)
+        return;
+    if (!*ap)
+        return;
+    while (1) {
+        trace_puts_quoted(*ap);
+        if (!*++ap) {
+            putc('\n', tracefile);
+            break;
+        }
+        putc(' ', tracefile);
+    }
+}
+
+static void
+opentrace(void)
+{
+    char s[100];
+#ifdef O_APPEND
+    int flags;
+#endif
+
+    if (debug != 1) {
+        if (tracefile)
+            fflush(tracefile);
+        /* leave open because libedit might be using it */
+        return;
+    }
+    strcpy(s, "./trace");
+    if (tracefile) {
+        if (!freopen(s, "a", tracefile)) {
+            fprintf(stderr, "Can't re-open %s\n", s);
+            debug = 0;
+            return;
+        }
+    } else {
+        tracefile = fopen(s, "a");
+        if (tracefile == NULL) {
+            fprintf(stderr, "Can't open %s\n", s);
+            debug = 0;
+            return;
+        }
+    }
+#ifdef O_APPEND
+    flags = fcntl(fileno(tracefile), F_GETFL);
+    if (flags >= 0)
+        fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
+#endif
+    setlinebuf(tracefile);
+    fputs("\nTracing started.\n", tracefile);
+}
+
+static void
+indent(int amount, char *pfx, FILE *fp)
+{
+    int i;
+
+    for (i = 0; i < amount; i++) {
+        if (pfx && i == amount - 1)
+            fputs(pfx, fp);
+        putc('\t', fp);
+    }
+}
+
+/* little circular references here... */
+static void shtree(union node *n, int ind, char *pfx, FILE *fp);
+
+static void
+sharg(union node *arg, FILE *fp)
+{
+    char *p;
+    struct nodelist *bqlist;
+    int subtype;
+
+    if (arg->type != NARG) {
+        out1fmt("<node type %d>\n", arg->type);
+        abort();
+    }
+    bqlist = arg->narg.backquote;
+    for (p = arg->narg.text; *p; p++) {
+        switch (*p) {
+        case CTLESC:
+            putc(*++p, fp);
+            break;
+        case CTLVAR:
+            putc('$', fp);
+            putc('{', fp);
+            subtype = *++p;
+            if (subtype == VSLENGTH)
+                putc('#', fp);
+
+            while (*p != '=')
+                putc(*p++, fp);
+
+            if (subtype & VSNUL)
+                putc(':', fp);
+
+            switch (subtype & VSTYPE) {
+            case VSNORMAL:
+                putc('}', fp);
+                break;
+            case VSMINUS:
+                putc('-', fp);
+                break;
+            case VSPLUS:
+                putc('+', fp);
+                break;
+            case VSQUESTION:
+                putc('?', fp);
+                break;
+            case VSASSIGN:
+                putc('=', fp);
+                break;
+            case VSTRIMLEFT:
+                putc('#', fp);
+                break;
+            case VSTRIMLEFTMAX:
+                putc('#', fp);
+                putc('#', fp);
+                break;
+            case VSTRIMRIGHT:
+                putc('%', fp);
+                break;
+            case VSTRIMRIGHTMAX:
+                putc('%', fp);
+                putc('%', fp);
+                break;
+            case VSLENGTH:
+                break;
+            default:
+                out1fmt("<subtype %d>", subtype);
+            }
+            break;
+        case CTLENDVAR:
+            putc('}', fp);
+            break;
+        case CTLBACKQ:
+        case CTLBACKQ|CTLQUOTE:
+            putc('$', fp);
+            putc('(', fp);
+            shtree(bqlist->n, -1, NULL, fp);
+            putc(')', fp);
+            break;
+        default:
+            putc(*p, fp);
+            break;
+        }
+    }
+}
+
+static void
+shcmd(union node *cmd, FILE *fp)
+{
+    union node *np;
+    int first;
+    const char *s;
+    int dftfd;
+
+    first = 1;
+    for (np = cmd->ncmd.args; np; np = np->narg.next) {
+        if (!first)
+            putc(' ', fp);
+        sharg(np, fp);
+        first = 0;
+    }
+    for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
+        if (!first)
+            putc(' ', fp);
+        dftfd = 0;
+        switch (np->nfile.type) {
+        case NTO:      s = ">>"+1; dftfd = 1; break;
+        case NCLOBBER: s = ">|"; dftfd = 1; break;
+        case NAPPEND:  s = ">>"; dftfd = 1; break;
+        case NTOFD:    s = ">&"; dftfd = 1; break;
+        case NFROM:    s = "<";  break;
+        case NFROMFD:  s = "<&"; break;
+        case NFROMTO:  s = "<>"; break;
+        default:       s = "*error*"; break;
+        }
+        if (np->nfile.fd != dftfd)
+            fprintf(fp, "%d", np->nfile.fd);
+        fputs(s, fp);
+        if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
+            fprintf(fp, "%d", np->ndup.dupfd);
+        } else {
+            sharg(np->nfile.fname, fp);
+        }
+        first = 0;
+    }
+}
+
+static void
+shtree(union node *n, int ind, char *pfx, FILE *fp)
+{
+    struct nodelist *lp;
+    const char *s;
+
+    if (n == NULL)
+        return;
+
+    indent(ind, pfx, fp);
+    switch (n->type) {
+    case NSEMI:
+        s = "; ";
+        goto binop;
+    case NAND:
+        s = " && ";
+        goto binop;
+    case NOR:
+        s = " || ";
+ binop:
+        shtree(n->nbinary.ch1, ind, NULL, fp);
+        /* if (ind < 0) */
+            fputs(s, fp);
+        shtree(n->nbinary.ch2, ind, NULL, fp);
+        break;
+    case NCMD:
+        shcmd(n, fp);
+        if (ind >= 0)
+            putc('\n', fp);
+        break;
+    case NPIPE:
+        for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
+            shcmd(lp->n, fp);
+            if (lp->next)
+                fputs(" | ", fp);
+        }
+        if (n->npipe.backgnd)
+            fputs(" &", fp);
+        if (ind >= 0)
+            putc('\n', fp);
+        break;
+    default:
+        fprintf(fp, "<node type %d>", n->type);
+        if (ind >= 0)
+            putc('\n', fp);
+        break;
+    }
+}
+
+static void
+showtree(union node *n)
+{
+    trace_puts("showtree called\n");
+    shtree(n, 1, NULL, stdout);
+}
+
+#define TRACE(param)    trace_printf param
+#define TRACEV(param)   trace_vprintf param
+
+#else
+
+#define TRACE(param)
+#define TRACEV(param)
+
+#endif /* DEBUG */
+
+
+/* ============ Parser data */
+
+/*
+ * ash_vmsg() needs parsefile->fd, hence parsefile definition is moved up.
+ */
+struct strlist {
+    struct strlist *next;
+    char *text;
+};
+
+#if ENABLE_ASH_ALIAS
+struct alias;
+#endif
 
 struct strpush {
@@ -532 +959 @@
     char *prevstring;
     int prevnleft;
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
     struct alias *ap;       /* if push was associated with an alias */
 #endif
@@ -551 +978 @@
 
 static struct parsefile basepf;         /* top level input file */
-#define basebuf bb_common_bufsiz1       /* buffer for top level input file */
 static struct parsefile *parsefile = &basepf;  /* current input file */
-
-
-static int tokpushback;                 /* last token pushed back */
-#define NEOF ((union node *)&tokpushback)
-static int parsebackquote;             /* nonzero if we are inside backquotes */
+static int startlinno;                 /* line # where last token started */
+static char *commandname;              /* currently executing command */
+static struct strlist *cmdenviron;     /* environment for builtin command */
+static int exitstatus;                 /* exit status of last command */
+
+
+/* ============ Message printing */
+
+static void
+ash_vmsg(const char *msg, va_list ap)
+{
+    fprintf(stderr, "%s: ", arg0);
+    if (commandname) {
+        if (strcmp(arg0, commandname))
+            fprintf(stderr, "%s: ", commandname);
+        if (!iflag || parsefile->fd)
+            fprintf(stderr, "line %d: ", startlinno);
+    }
+    vfprintf(stderr, msg, ap);
+    outcslow('\n', stderr);
+}
+
+/*
+ * Exverror is called to raise the error exception.  If the second argument
+ * is not NULL then error prints an error message using printf style
+ * formatting.  It then raises the error exception.
+ */
+static void ash_vmsg_and_raise(int, const char *, va_list) ATTRIBUTE_NORETURN;
+static void
+ash_vmsg_and_raise(int cond, const char *msg, va_list ap)
+{
+#if DEBUG
+    if (msg) {
+        TRACE(("ash_vmsg_and_raise(%d, \"", cond));
+        TRACEV((msg, ap));
+        TRACE(("\") pid=%d\n", getpid()));
+    } else
+        TRACE(("ash_vmsg_and_raise(%d, NULL) pid=%d\n", cond, getpid()));
+    if (msg)
+#endif
+        ash_vmsg(msg, ap);
+
+    flush_stdout_stderr();
+    raise_exception(cond);
+    /* NOTREACHED */
+}
+
+static void ash_msg_and_raise_error(const char *, ...) ATTRIBUTE_NORETURN;
+static void
+ash_msg_and_raise_error(const char *msg, ...)
+{
+    va_list ap;
+
+    va_start(ap, msg);
+    ash_vmsg_and_raise(EXERROR, msg, ap);
+    /* NOTREACHED */
+    va_end(ap);
+}
+
+static void ash_msg_and_raise(int, const char *, ...) ATTRIBUTE_NORETURN;
+static void
+ash_msg_and_raise(int cond, const char *msg, ...)
+{
+    va_list ap;
+
+    va_start(ap, msg);
+    ash_vmsg_and_raise(cond, msg, ap);
+    /* NOTREACHED */
+    va_end(ap);
+}
+
+/*
+ * error/warning routines for external builtins
+ */
+static void
+ash_msg(const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    ash_vmsg(fmt, ap);
+    va_end(ap);
+}
+
+/*
+ * Return a string describing an error.  The returned string may be a
+ * pointer to a static buffer that will be overwritten on the next call.
+ * Action describes the operation that got the error.
+ */
+static const char *
+errmsg(int e, const char *em)
+{
+    if (e == ENOENT || e == ENOTDIR) {
+        return em;
+    }
+    return strerror(e);
+}
+
+
+/* ============ Memory allocation */
+
+/*
+ * It appears that grabstackstr() will barf with such alignments
+ * because stalloc() will return a string allocated in a new stackblock.
+ */
+#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
+enum {
+    /* Most machines require the value returned from malloc to be aligned
+     * in some way.  The following macro will get this right
+     * on many machines.  */
+    SHELL_SIZE = sizeof(union {int i; char *cp; double d; }) - 1,
+    /* Minimum size of a block */
+    MINSIZE  = SHELL_ALIGN(504),
+};
+
+struct stack_block {
+    struct stack_block *prev;
+    char space[MINSIZE];
+};
+
+struct stackmark {
+    struct stack_block *stackp;
+    char *stacknxt;
+    size_t stacknleft;
+    struct stackmark *marknext;
+};
+
+static struct stack_block stackbase;
+static struct stack_block *stackp = &stackbase;
+static struct stackmark *markp;
+static char *stacknxt = stackbase.space;
+static size_t stacknleft = MINSIZE;
+static char *sstrend = stackbase.space + MINSIZE;
+static int herefd = -1;
+
+#define stackblock() ((void *)stacknxt)
+#define stackblocksize() stacknleft
+
+static void *
+ckrealloc(void * p, size_t nbytes)
+{
+    p = realloc(p, nbytes);
+    if (!p)
+        ash_msg_and_raise_error(bb_msg_memory_exhausted);
+    return p;
+}
+
+static void *
+ckmalloc(size_t nbytes)
+{
+    return ckrealloc(NULL, nbytes);
+}
+
+/*
+ * Make a copy of a string in safe storage.
+ */
+static char *
+ckstrdup(const char *s)
+{
+    char *p = strdup(s);
+    if (!p)
+        ash_msg_and_raise_error(bb_msg_memory_exhausted);
+    return p;
+}
+
+/*
+ * Parse trees for commands are allocated in lifo order, so we use a stack
+ * to make this more efficient, and also to avoid all sorts of exception
+ * handling code to handle interrupts in the middle of a parse.
+ *
+ * The size 504 was chosen because the Ultrix malloc handles that size
+ * well.
+ */
+static void *
+stalloc(size_t nbytes)
+{
+    char *p;
+    size_t aligned;
+
+    aligned = SHELL_ALIGN(nbytes);
+    if (aligned > stacknleft) {
+        size_t len;
+        size_t blocksize;
+        struct stack_block *sp;
+
+        blocksize = aligned;
+        if (blocksize < MINSIZE)
+            blocksize = MINSIZE;
+        len = sizeof(struct stack_block) - MINSIZE + blocksize;
+        if (len < blocksize)
+            ash_msg_and_raise_error(bb_msg_memory_exhausted);
+        INT_OFF;
+        sp = ckmalloc(len);
+        sp->prev = stackp;
+        stacknxt = sp->space;
+        stacknleft = blocksize;
+        sstrend = stacknxt + blocksize;
+        stackp = sp;
+        INT_ON;
+    }
+    p = stacknxt;
+    stacknxt += aligned;
+    stacknleft -= aligned;
+    return p;
+}
+
+static void
+stunalloc(void *p)
+{
+#if DEBUG
+    if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) {
+        write(2, "stunalloc\n", 10);
+        abort();
+    }
+#endif
+    stacknleft += stacknxt - (char *)p;
+    stacknxt = p;
+}
+
+/*
+ * Like strdup but works with the ash stack.
+ */
+static char *
+ststrdup(const char *p)
+{
+    size_t len = strlen(p) + 1;
+    return memcpy(stalloc(len), p, len);
+}
+
+static void
+setstackmark(struct stackmark *mark)
+{
+    mark->stackp = stackp;
+    mark->stacknxt = stacknxt;
+    mark->stacknleft = stacknleft;
+    mark->marknext = markp;
+    markp = mark;
+}
+
+static void
+popstackmark(struct stackmark *mark)
+{
+    struct stack_block *sp;
+
+    if (!mark->stackp)
+        return;
+
+    INT_OFF;
+    markp = mark->marknext;
+    while (stackp != mark->stackp) {
+        sp = stackp;
+        stackp = sp->prev;
+        free(sp);
+    }
+    stacknxt = mark->stacknxt;
+    stacknleft = mark->stacknleft;
+    sstrend = mark->stacknxt + mark->stacknleft;
+    INT_ON;
+}
+
+/*
+ * When the parser reads in a string, it wants to stick the string on the
+ * stack and only adjust the stack pointer when it knows how big the
+ * string is.  Stackblock (defined in stack.h) returns a pointer to a block
+ * of space on top of the stack and stackblocklen returns the length of
+ * this block.  Growstackblock will grow this space by at least one byte,
+ * possibly moving it (like realloc).  Grabstackblock actually allocates the
+ * part of the block that has been used.
+ */
+static void
+growstackblock(void)
+{
+    size_t newlen;
+
+    newlen = stacknleft * 2;
+    if (newlen < stacknleft)
+        ash_msg_and_raise_error(bb_msg_memory_exhausted);
+    if (newlen < 128)
+        newlen += 128;
+
+    if (stacknxt == stackp->space && stackp != &stackbase) {
+        struct stack_block *oldstackp;
+        struct stackmark *xmark;
+        struct stack_block *sp;
+        struct stack_block *prevstackp;
+        size_t grosslen;
+
+        INT_OFF;
+        oldstackp = stackp;
+        sp = stackp;
+        prevstackp = sp->prev;
+        grosslen = newlen + sizeof(struct stack_block) - MINSIZE;
+        sp = ckrealloc(sp, grosslen);
+        sp->prev = prevstackp;
+        stackp = sp;
+        stacknxt = sp->space;
+        stacknleft = newlen;
+        sstrend = sp->space + newlen;
+
+        /*
+         * Stack marks pointing to the start of the old block
+         * must be relocated to point to the new block
+         */
+        xmark = markp;
+        while (xmark != NULL && xmark->stackp == oldstackp) {
+            xmark->stackp = stackp;
+            xmark->stacknxt = stacknxt;
+            xmark->stacknleft = stacknleft;
+            xmark = xmark->marknext;
+        }
+        INT_ON;
+    } else {
+        char *oldspace = stacknxt;
+        int oldlen = stacknleft;
+        char *p = stalloc(newlen);
+
+        /* free the space we just allocated */
+        stacknxt = memcpy(p, oldspace, oldlen);
+        stacknleft += newlen;
+    }
+}
+
+static void
+grabstackblock(size_t len)
+{
+    len = SHELL_ALIGN(len);
+    stacknxt += len;
+    stacknleft -= len;
+}
+
+/*
+ * The following routines are somewhat easier to use than the above.
+ * The user declares a variable of type STACKSTR, which may be declared
+ * to be a register.  The macro STARTSTACKSTR initializes things.  Then
+ * the user uses the macro STPUTC to add characters to the string.  In
+ * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
+ * grown as necessary.  When the user is done, she can just leave the
+ * string there and refer to it using stackblock().  Or she can allocate
+ * the space for it using grabstackstr().  If it is necessary to allow
+ * someone else to use the stack temporarily and then continue to grow
+ * the string, the user should use grabstack to allocate the space, and
+ * then call ungrabstr(p) to return to the previous mode of operation.
+ *
+ * USTPUTC is like STPUTC except that it doesn't check for overflow.
+ * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
+ * is space for at least one character.
+ */
+static void *
+growstackstr(void)
+{
+    size_t len = stackblocksize();
+    if (herefd >= 0 && len >= 1024) {
+        full_write(herefd, stackblock(), len);
+        return stackblock();
+    }
+    growstackblock();
+    return stackblock() + len;
+}
+
+/*
+ * Called from CHECKSTRSPACE.
+ */
+static char *
+makestrspace(size_t newlen, char *p)
+{
+    size_t len = p - stacknxt;
+    size_t size = stackblocksize();
+
+    for (;;) {
+        size_t nleft;
+
+        size = stackblocksize();
+        nleft = size - len;
+        if (nleft >= newlen)
+            break;
+        growstackblock();
+    }
+    return stackblock() + len;
+}
+
+static char *
+stack_nputstr(const char *s, size_t n, char *p)
+{
+    p = makestrspace(n, p);
+    p = memcpy(p, s, n) + n;
+    return p;
+}
+
+static char *
+stack_putstr(const char *s, char *p)
+{
+    return stack_nputstr(s, strlen(s), p);
+}
+
+static char *
+_STPUTC(int c, char *p)
+{
+    if (p == sstrend)
+        p = growstackstr();
+    *p++ = c;
+    return p;
+}
+
+#define STARTSTACKSTR(p)        ((p) = stackblock())
+#define STPUTC(c, p)            ((p) = _STPUTC((c), (p)))
+#define CHECKSTRSPACE(n, p) \
+    do { \
+        char *q = (p); \
+        size_t l = (n); \
+        size_t m = sstrend - q; \
+        if (l > m) \
+            (p) = makestrspace(l, q); \
+    } while (0)
+#define USTPUTC(c, p)           (*p++ = (c))
+#define STACKSTRNUL(p) \
+    do { \
+        if ((p) == sstrend) \
+            p = growstackstr(); \
+        *p = '\0'; \
+    } while (0)
+#define STUNPUTC(p)             (--p)
+#define STTOPC(p)               (p[-1])
+#define STADJUST(amount, p)     (p += (amount))
+
+#define grabstackstr(p)         stalloc((char *)(p) - (char *)stackblock())
+#define ungrabstackstr(s, p)    stunalloc((s))
+#define stackstrend()           ((void *)sstrend)
+
+
+/* ============ String helpers */
+
+/*
+ * prefix -- see if pfx is a prefix of string.
+ */
+static char *
+prefix(const char *string, const char *pfx)
+{
+    while (*pfx) {
+        if (*pfx++ != *string++)
+            return 0;
+    }
+    return (char *) string;
+}
+
+/*
+ * Check for a valid number.  This should be elsewhere.
+ */
+static int
+is_number(const char *p)
+{
+    do {
+        if (!isdigit(*p))
+            return 0;
+    } while (*++p != '\0');
+    return 1;
+}
+
+/*
+ * Convert a string of digits to an integer, printing an error message on
+ * failure.
+ */
+static int
+number(const char *s)
+{
+    if (!is_number(s))
+        ash_msg_and_raise_error(illnum, s);
+    return atoi(s);
+}
+
+/*
+ * Produce a possibly single quoted string suitable as input to the shell.
+ * The return string is allocated on the stack.
+ */
+static char *
+single_quote(const char *s)
+{
+    char *p;
+
+    STARTSTACKSTR(p);
+
+    do {
+        char *q;
+        size_t len;
+
+        len = strchrnul(s, '\'') - s;
+
+        q = p = makestrspace(len + 3, p);
+
+        *q++ = '\'';
+        q = memcpy(q, s, len) + len;
+        *q++ = '\'';
+        s += len;
+
+        STADJUST(q - p, p);
+
+        len = strspn(s, "'");
+        if (!len)
+            break;
+
+        q = p = makestrspace(len + 3, p);
+
+        *q++ = '"';
+        q = memcpy(q, s, len) + len;
+        *q++ = '"';
+        s += len;
+
+        STADJUST(q - p, p);
+    } while (*s);
+
+    USTPUTC(0, p);
+
+    return stackblock();
+}
+
+
+/* ============ nextopt */
+
+static char **argptr;                  /* argument list for builtin commands */
+static char *optionarg;                /* set by nextopt (like getopt) */
+static char *optptr;                   /* used by nextopt */
+
+/*
+ * XXX - should get rid of.  have all builtins use getopt(3).  the
+ * library getopt must have the BSD extension static variable "optreset"
+ * otherwise it can't be used within the shell safely.
+ *
+ * Standard option processing (a la getopt) for builtin routines.  The
+ * only argument that is passed to nextopt is the option string; the
+ * other arguments are unnecessary.  It return the character, or '\0' on
+ * end of input.
+ */
+static int
+nextopt(const char *optstring)
+{
+    char *p;
+    const char *q;
+    char c;
+
+    p = optptr;
+    if (p == NULL || *p == '\0') {
+        p = *argptr;
+        if (p == NULL || *p != '-' || *++p == '\0')
+            return '\0';
+        argptr++;
+        if (LONE_DASH(p))        /* check for "--" */
+            return '\0';
+    }
+    c = *p++;
+    for (q = optstring; *q != c; ) {
+        if (*q == '\0')
+            ash_msg_and_raise_error("illegal option -%c", c);
+        if (*++q == ':')
+            q++;
+    }
+    if (*++q == ':') {
+        if (*p == '\0' && (p = *argptr++) == NULL)
+            ash_msg_and_raise_error("no arg for -%c option", c);
+        optionarg = p;
+        p = NULL;
+    }
+    optptr = p;
+    return c;
+}
+
+
+/* ============ Math support definitions */
+
+#if ENABLE_ASH_MATH_SUPPORT_64
+typedef int64_t arith_t;
+#define arith_t_type long long
+#else
+typedef long arith_t;
+#define arith_t_type long
+#endif
+
+#if ENABLE_ASH_MATH_SUPPORT
+static arith_t dash_arith(const char *);
+static arith_t arith(const char *expr, int *perrcode);
+#endif
+
+#if ENABLE_ASH_RANDOM_SUPPORT
+static unsigned long rseed;
+#ifndef DYNAMIC_VAR
+#define DYNAMIC_VAR
+#endif
+#endif
+
+
+/* ============ Shell variables */
+
+/* flags */
+#define VEXPORT         0x01    /* variable is exported */
+#define VREADONLY       0x02    /* variable cannot be modified */
+#define VSTRFIXED       0x04    /* variable struct is statically allocated */
+#define VTEXTFIXED      0x08    /* text is statically allocated */
+#define VSTACK          0x10    /* text is allocated on the stack */
+#define VUNSET          0x20    /* the variable is not set */
+#define VNOFUNC         0x40    /* don't call the callback function */
+#define VNOSET          0x80    /* do not set variable - just readonly test */
+#define VNOSAVE         0x100   /* when text is on the heap before setvareq */
+#ifdef DYNAMIC_VAR
+# define VDYNAMIC       0x200   /* dynamic variable */
+#else
+# define VDYNAMIC       0
+#endif
+
+#ifdef IFS_BROKEN
+static const char defifsvar[] ALIGN1 = "IFS= \t\n";
+#define defifs (defifsvar + 4)
+#else
+static const char defifs[] ALIGN1 = " \t\n";
+#endif
+
+struct shparam {
+    int nparam;             /* # of positional parameters (without $0) */
+    unsigned char malloc;   /* if parameter list dynamically allocated */
+    char **p;               /* parameter list */
+#if ENABLE_ASH_GETOPTS
+    int optind;             /* next parameter to be processed by getopts */
+    int optoff;             /* used by getopts */
+#endif
+};
+
+static struct shparam shellparam;      /* $@ current positional parameters */
+
+/*
+ * Free the list of positional parameters.
+ */
+static void
+freeparam(volatile struct shparam *param)
+{
+    char **ap;
+
+    if (param->malloc) {
+        for (ap = param->p; *ap; ap++)
+            free(*ap);
+        free(param->p);
+    }
+}
+
+#if ENABLE_ASH_GETOPTS
+static void
+getoptsreset(const char *value)
+{
+    shellparam.optind = number(value);
+    shellparam.optoff = -1;
+}
+#endif
+
+struct var {
+    struct var *next;               /* next entry in hash list */
+    int flags;                      /* flags are defined above */
+    const char *text;               /* name=value */
+    void (*func)(const char *);     /* function to be called when  */
+                    /* the variable gets set/unset */
+};
+
+struct localvar {
+    struct localvar *next;          /* next local variable in list */
+    struct var *vp;                 /* the variable that was made local */
+    int flags;                      /* saved flags */
+    const char *text;               /* saved text */
+};
+
+/* Forward decls for varinit[] */
+#if ENABLE_LOCALE_SUPPORT
+static void
+change_lc_all(const char *value)
+{
+    if (value && *value != '\0')
+        setlocale(LC_ALL, value);
+}
+static void
+change_lc_ctype(const char *value)
+{
+    if (value && *value != '\0')
+        setlocale(LC_CTYPE, value);
+}
+#endif
+#if ENABLE_ASH_MAIL
+static void chkmail(void);
+static void changemail(const char *);
+#endif
+static void changepath(const char *);
+#if ENABLE_ASH_RANDOM_SUPPORT
+static void change_random(const char *);
+#endif
+
+static struct var varinit[] = {
+#ifdef IFS_BROKEN
+    { NULL, VSTRFIXED|VTEXTFIXED,           defifsvar,      NULL },
+#else
+    { NULL, VSTRFIXED|VTEXTFIXED|VUNSET,    "IFS\0",        NULL },
+#endif
+#if ENABLE_ASH_MAIL
+    { NULL, VSTRFIXED|VTEXTFIXED|VUNSET,    "MAIL\0",       changemail },
+    { NULL, VSTRFIXED|VTEXTFIXED|VUNSET,    "MAILPATH\0",   changemail },
+#endif
+    { NULL, VSTRFIXED|VTEXTFIXED,           bb_PATH_root_path, changepath },
+    { NULL, VSTRFIXED|VTEXTFIXED,           "PS1=$ ",       NULL },
+    { NULL, VSTRFIXED|VTEXTFIXED,           "PS2=> ",       NULL },
+    { NULL, VSTRFIXED|VTEXTFIXED,           "PS4=+ ",       NULL },
+#if ENABLE_ASH_GETOPTS
+    { NULL, VSTRFIXED|VTEXTFIXED,           "OPTIND=1",     getoptsreset },
+#endif
+#if ENABLE_ASH_RANDOM_SUPPORT
+    { NULL, VSTRFIXED|VTEXTFIXED|VUNSET|VDYNAMIC, "RANDOM\0", change_random },
+#endif
+#if ENABLE_LOCALE_SUPPORT
+    { NULL, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL\0",    change_lc_all },
+    { NULL, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE\0",  change_lc_ctype },
+#endif
+#if ENABLE_FEATURE_EDITING_SAVEHISTORY
+    { NULL, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE\0",  NULL },
+#endif
+};
+
+#define vifs varinit[0]
+#if ENABLE_ASH_MAIL
+#define vmail (&vifs)[1]
+#define vmpath (&vmail)[1]
+#else
+#define vmpath vifs
+#endif
+#define vpath (&vmpath)[1]
+#define vps1 (&vpath)[1]
+#define vps2 (&vps1)[1]
+#define vps4 (&vps2)[1]
+#define voptind (&vps4)[1]
+#if ENABLE_ASH_GETOPTS
+#define vrandom (&voptind)[1]
+#else
+#define vrandom (&vps4)[1]
+#endif
+
+/*
+ * The following macros access the values of the above variables.
+ * They have to skip over the name.  They return the null string
+ * for unset variables.
+ */
+#define ifsval()        (vifs.text + 4)
+#define ifsset()        ((vifs.flags & VUNSET) == 0)
+#define mailval()       (vmail.text + 5)
+#define mpathval()      (vmpath.text + 9)
+#define pathval()       (vpath.text + 5)
+#define ps1val()        (vps1.text + 4)
+#define ps2val()        (vps2.text + 4)
+#define ps4val()        (vps4.text + 4)
+#define optindval()     (voptind.text + 7)
+
+#define mpathset()      ((vmpath.flags & VUNSET) == 0)
+
+/*
+ * The parsefile structure pointed to by the global variable parsefile
+ * contains information about the current file being read.
+ */
+struct redirtab {
+    struct redirtab *next;
+    int renamed[10];
+    int nullredirs;
+};
+
+static struct redirtab *redirlist;
+static int nullredirs;
+static int preverrout_fd;   /* save fd2 before print debug if xflag is set. */
+
+#define VTABSIZE 39
+
+static struct var *vartab[VTABSIZE];
+
+#define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
+#define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
+
+/*
+ * Return of a legal variable name (a letter or underscore followed by zero or
+ * more letters, underscores, and digits).
+ */
+static char *
+endofname(const char *name)
+{
+    char *p;
+
+    p = (char *) name;
+    if (!is_name(*p))
+        return p;
+    while (*++p) {
+        if (!is_in_name(*p))
+            break;
+    }
+    return p;
+}
+
+/*
+ * Compares two strings up to the first = or '\0'.  The first
+ * string must be terminated by '='; the second may be terminated by
+ * either '=' or '\0'.
+ */
+static int
+varcmp(const char *p, const char *q)
+{
+    int c, d;
+
+    while ((c = *p) == (d = *q)) {
+        if (!c || c == '=')
+            goto out;
+        p++;
+        q++;
+    }
+    if (c == '=')
+        c = '\0';
+    if (d == '=')
+        d = '\0';
+ out:
+    return c - d;
+}
+
+static int
+varequal(const char *a, const char *b)
+{
+    return !varcmp(a, b);
+}
+
+/*
+ * Find the appropriate entry in the hash table from the name.
+ */
+static struct var **
+hashvar(const char *p)
+{
+    unsigned hashval;
+
+    hashval = ((unsigned char) *p) << 4;
+    while (*p && *p != '=')
+        hashval += (unsigned char) *p++;
+    return &vartab[hashval % VTABSIZE];
+}
+
+static int
+vpcmp(const void *a, const void *b)
+{
+    return varcmp(*(const char **)a, *(const char **)b);
+}
+
+/*
+ * This routine initializes the builtin variables.
+ */
+static void
+initvar(void)
+{
+    struct var *vp;
+    struct var *end;
+    struct var **vpp;
+
+    /*
+     * PS1 depends on uid
+     */
+#if ENABLE_FEATURE_EDITING && ENABLE_FEATURE_EDITING_FANCY_PROMPT
+    vps1.text = "PS1=\\w \\$ ";
+#else
+    if (!geteuid())
+        vps1.text = "PS1=# ";
+#endif
+    vp = varinit;
+    end = vp + ARRAY_SIZE(varinit);
+    do {
+        vpp = hashvar(vp->text);
+        vp->next = *vpp;
+        *vpp = vp;
+    } while (++vp < end);
+}
+
+static struct var **
+findvar(struct var **vpp, const char *name)
+{
+    for (; *vpp; vpp = &(*vpp)->next) {
+        if (varequal((*vpp)->text, name)) {
+            break;
+        }
+    }
+    return vpp;
+}
+
+/*
+ * Find the value of a variable.  Returns NULL if not set.
+ */
+static char *
+lookupvar(const char *name)
+{
+    struct var *v;
+
+    v = *findvar(hashvar(name), name);
+    if (v) {
+#ifdef DYNAMIC_VAR
+    /*
+     * Dynamic variables are implemented roughly the same way they are
+     * in bash. Namely, they're "special" so long as they aren't unset.
+     * As soon as they're unset, they're no longer dynamic, and dynamic
+     * lookup will no longer happen at that point. -- PFM.
+     */
+        if ((v->flags & VDYNAMIC))
+            (*v->func)(NULL);
+#endif
+        if (!(v->flags & VUNSET))
+            return strchrnul(v->text, '=') + 1;
+    }
+    return NULL;
+}
+
+/*
+ * Search the environment of a builtin command.
+ */
+static char *
+bltinlookup(const char *name)
+{
+    struct strlist *sp;
+
+    for (sp = cmdenviron; sp; sp = sp->next) {
+        if (varequal(sp->text, name))
+            return strchrnul(sp->text, '=') + 1;
+    }
+    return lookupvar(name);
+}
+
+/*
+ * Same as setvar except that the variable and value are passed in
+ * the first argument as name=value.  Since the first argument will
+ * be actually stored in the table, it should not be a string that
+ * will go away.
+ * Called with interrupts off.
+ */
+static void
+setvareq(char *s, int flags)
+{
+    struct var *vp, **vpp;
+
+    vpp = hashvar(s);
+    flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
+    vp = *findvar(vpp, s);
+    if (vp) {
+        if ((vp->flags & (VREADONLY|VDYNAMIC)) == VREADONLY) {
+            const char *n;
+
+            if (flags & VNOSAVE)
+                free(s);
+            n = vp->text;
+            ash_msg_and_raise_error("%.*s: is read only", strchrnul(n, '=') - n, n);
+        }
+
+        if (flags & VNOSET)
+            return;
+
+        if (vp->func && (flags & VNOFUNC) == 0)
+            (*vp->func)(strchrnul(s, '=') + 1);
+
+        if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
+            free((char*)vp->text);
+
+        flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET);
+    } else {
+        if (flags & VNOSET)
+            return;
+        /* not found */
+        vp = ckmalloc(sizeof(*vp));
+        vp->next = *vpp;
+        vp->func = NULL;
+        *vpp = vp;
+    }
+    if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE)))
+        s = ckstrdup(s);
+    vp->text = s;
+    vp->flags = flags;
+}
+
+/*
+ * Set the value of a variable.  The flags argument is ored with the
+ * flags of the variable.  If val is NULL, the variable is unset.
+ */
+static void
+setvar(const char *name, const char *val, int flags)
+{
+    char *p, *q;
+    size_t namelen;
+    char *nameeq;
+    size_t vallen;
+
+    q = endofname(name);
+    p = strchrnul(q, '=');
+    namelen = p - name;
+    if (!namelen || p != q)
+        ash_msg_and_raise_error("%.*s: bad variable name", namelen, name);
+    vallen = 0;
+    if (val == NULL) {
+        flags |= VUNSET;
+    } else {
+        vallen = strlen(val);
+    }
+    INT_OFF;
+    nameeq = ckmalloc(namelen + vallen + 2);
+    p = memcpy(nameeq, name, namelen) + namelen;
+    if (val) {
+        *p++ = '=';
+        p = memcpy(p, val, vallen) + vallen;
+    }
+    *p = '\0';
+    setvareq(nameeq, flags | VNOSAVE);
+    INT_ON;
+}
+
+#if ENABLE_ASH_GETOPTS
+/*
+ * Safe version of setvar, returns 1 on success 0 on failure.
+ */
+static int
+setvarsafe(const char *name, const char *val, int flags)
+{
+    int err;
+    volatile int saveint;
+    struct jmploc *volatile savehandler = exception_handler;
+    struct jmploc jmploc;
+
+    SAVE_INT(saveint);
+    if (setjmp(jmploc.loc))
+        err = 1;
+    else {
+        exception_handler = &jmploc;
+        setvar(name, val, flags);
+        err = 0;
+    }
+    exception_handler = savehandler;
+    RESTORE_INT(saveint);
+    return err;
+}
+#endif
+
+/*
+ * Unset the specified variable.
+ */
+static int
+unsetvar(const char *s)
+{
+    struct var **vpp;
+    struct var *vp;
+    int retval;
+
+    vpp = findvar(hashvar(s), s);
+    vp = *vpp;
+    retval = 2;
+    if (vp) {
+        int flags = vp->flags;
+
+        retval = 1;
+        if (flags & VREADONLY)
+            goto out;
+#ifdef DYNAMIC_VAR
+        vp->flags &= ~VDYNAMIC;
+#endif
+        if (flags & VUNSET)
+            goto ok;
+        if ((flags & VSTRFIXED) == 0) {
+            INT_OFF;
+            if ((flags & (VTEXTFIXED|VSTACK)) == 0)
+                free((char*)vp->text);
+            *vpp = vp->next;
+            free(vp);
+            INT_ON;
+        } else {
+            setvar(s, 0, 0);
+            vp->flags &= ~VEXPORT;
+        }
+ ok:
+        retval = 0;
+    }
+ out:
+    return retval;
+}
+
+/*
+ * 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.
+ */
+static char **
+listvars(int on, int off, char ***end)
+{
+    struct var **vpp;
+    struct var *vp;
+    char **ep;
+    int mask;
+
+    STARTSTACKSTR(ep);
+    vpp = vartab;
+    mask = on | off;
+    do {
+        for (vp = *vpp; vp; vp = vp->next) {
+            if ((vp->flags & mask) == on) {
+                if (ep == stackstrend())
+                    ep = growstackstr();
+                *ep++ = (char *) vp->text;
+            }
+        }
+    } while (++vpp < vartab + VTABSIZE);
+    if (ep == stackstrend())
+        ep = growstackstr();
+    if (end)
+        *end = ep;
+    *ep++ = NULL;
+    return grabstackstr(ep);
+}
+
+
+/* ============ Path search helper
+ *
+ * The variable path (passed by reference) should be set to the start
+ * of the path before the first call; padvance will update
+ * this value as it proceeds.  Successive calls to padvance will return
+ * the possible path expansions in sequence.  If an option (indicated by
+ * a percent sign) appears in the path entry then the global variable
+ * pathopt will be set to point to it; otherwise pathopt will be set to
+ * NULL.
+ */
+static const char *pathopt;     /* set by padvance */
+
+static char *
+padvance(const char **path, const char *name)
+{
+    const char *p;
+    char *q;
+    const char *start;
+    size_t len;
+
+    if (*path == NULL)
+        return NULL;
+    start = *path;
+    for (p = start; *p && *p != ':' && *p != '%'; p++);
+    len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
+    while (stackblocksize() < len)
+        growstackblock();
+    q = stackblock();
+    if (p != start) {
+        memcpy(q, start, p - start);
+        q += p - start;
+        *q++ = '/';
+    }
+    strcpy(q, name);
+    pathopt = NULL;
+    if (*p == '%') {
+        pathopt = ++p;
+        while (*p && *p != ':') p++;
+    }
+    if (*p == ':')
+        *path = p + 1;
+    else
+        *path = NULL;
+    return stalloc(len);
+}
+
+
+/* ============ Prompt */
+
 static int doprompt;                   /* if set, prompt the user */
 static int needprompt;                 /* true if interactive and at start of line */
-static int lasttoken;                  /* last token read */
-static char *wordtext;                 /* text of last word returned by readtoken */
-static int checkkwd;
-static struct nodelist *backquotelist;
-static union node *redirnode;
-static struct heredoc *heredoc;
-static int quoteflag;                  /* set if (part of) last token was quoted */
-static int startlinno;                 /* line # where last token started */
-
-static union node *parsecmd(int);
-static void fixredir(union node *, const char *, int);
-static const char *const *findkwd(const char *);
-static char *endofname(const char *);
-
-/*      shell.h   */
-
-typedef void *pointer;
-
-static char nullstr[1];                /* zero length string */
-static const char spcstr[] = " ";
-static const char snlfmt[] = "%s\n";
-static const char dolatstr[] = { CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0' };
-static const char illnum[] = "Illegal number: %s";
-static const char homestr[] = "HOME";
-
-#ifdef DEBUG
-#define TRACE(param)    trace param
-#define TRACEV(param)   tracev param
+
+#if ENABLE_FEATURE_EDITING
+static line_input_t *line_input_state;
+static const char *cmdedit_prompt;
+static void
+putprompt(const char *s)
+{
+    if (ENABLE_ASH_EXPAND_PRMT) {
+        free((char*)cmdedit_prompt);
+        cmdedit_prompt = ckstrdup(s);
+        return;
+    }
+    cmdedit_prompt = s;
+}
 #else
-#define TRACE(param)
-#define TRACEV(param)
-#endif
-
-#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
-#define __builtin_expect(x, expected_value) (x)
-#endif
-
-#define xlikely(x)       __builtin_expect((x),1)
-
-
-#define TEOF 0
-#define TNL 1
-#define TREDIR 2
-#define TWORD 3
-#define TSEMI 4
-#define TBACKGND 5
-#define TAND 6
-#define TOR 7
-#define TPIPE 8
-#define TLP 9
-#define TRP 10
-#define TENDCASE 11
-#define TENDBQUOTE 12
-#define TNOT 13
-#define TCASE 14
-#define TDO 15
-#define TDONE 16
-#define TELIF 17
-#define TELSE 18
-#define TESAC 19
-#define TFI 20
-#define TFOR 21
-#define TIF 22
-#define TIN 23
-#define TTHEN 24
-#define TUNTIL 25
-#define TWHILE 26
-#define TBEGIN 27
-#define TEND 28
-
-/* first char is indicating which tokens mark the end of a list */
-static const char *const tokname_array[] = {
-    "\1end of file",
-    "\0newline",
-    "\0redirection",
-    "\0word",
-    "\0;",
-    "\0&",
-    "\0&&",
-    "\0||",
-    "\0|",
-    "\0(",
-    "\1)",
-    "\1;;",
-    "\1`",
-#define KWDOFFSET 13
-    /* the following are keywords */
-    "\0!",
-    "\0case",
-    "\1do",
-    "\1done",
-    "\1elif",
-    "\1else",
-    "\1esac",
-    "\1fi",
-    "\0for",
-    "\0if",
-    "\0in",
-    "\1then",
-    "\0until",
-    "\0while",
-    "\0{",
-    "\1}",
-};
-
-static const char *tokname(int tok)
-{
-    static char buf[16];
-
-    if (tok >= TSEMI)
-        buf[0] = '"';
-    sprintf(buf + (tok >= TSEMI), "%s%c",
-            tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
-    return buf;
-}
-
-/*      machdep.h    */
-
-/*
- * Most machines require the value returned from malloc to be aligned
- * in some way.  The following macro will get this right on many machines.
- */
-
-#define SHELL_SIZE (sizeof(union {int i; char *cp; double d; }) - 1)
-/*
- * It appears that grabstackstr() will barf with such alignments
- * because stalloc() will return a string allocated in a new stackblock.
- */
-#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
-
-/*
- * This file was generated by the mksyntax program.
- */
-
+static void
+putprompt(const char *s)
+{
+    out2str(s);
+}
+#endif
+
+#if ENABLE_ASH_EXPAND_PRMT
+/* expandstr() needs parsing machinery, so it is far away ahead... */
+static const char *expandstr(const char *ps);
+#else
+#define expandstr(s) s
+#endif
+
+static void
+setprompt(int whichprompt)
+{
+    const char *prompt;
+#if ENABLE_ASH_EXPAND_PRMT
+    struct stackmark smark;
+#endif
+
+    needprompt = 0;
+
+    switch (whichprompt) {
+    case 1:
+        prompt = ps1val();
+        break;
+    case 2:
+        prompt = ps2val();
+        break;
+    default:                        /* 0 */
+        prompt = nullstr;
+    }
+#if ENABLE_ASH_EXPAND_PRMT
+    setstackmark(&smark);
+    stalloc(stackblocksize());
+#endif
+    putprompt(expandstr(prompt));
+#if ENABLE_ASH_EXPAND_PRMT
+    popstackmark(&smark);
+#endif
+}
+
+
+/* ============ The cd and pwd commands */
+
+#define CD_PHYSICAL 1
+#define CD_PRINT 2
+
+static int docd(const char *, int);
+
+static char *curdir = nullstr;          /* current working directory */
+static char *physdir = nullstr;         /* physical working directory */
+
+static int
+cdopt(void)
+{
+    int flags = 0;
+    int i, j;
+
+    j = 'L';
+    while ((i = nextopt("LP"))) {
+        if (i != j) {
+            flags ^= CD_PHYSICAL;
+            j = i;
+        }
+    }
+
+    return flags;
+}
+
+/*
+ * Update curdir (the name of the current directory) in response to a
+ * cd command.
+ */
+static const char *
+updatepwd(const char *dir)
+{
+    char *new;
+    char *p;
+    char *cdcomppath;
+    const char *lim;
+
+    cdcomppath = ststrdup(dir);
+    STARTSTACKSTR(new);
+    if (*dir != '/') {
+        if (curdir == nullstr)
+            return 0;
+        new = stack_putstr(curdir, new);
+    }
+    new = makestrspace(strlen(dir) + 2, new);
+    lim = stackblock() + 1;
+    if (*dir != '/') {
+        if (new[-1] != '/')
+            USTPUTC('/', new);
+        if (new > lim && *lim == '/')
+            lim++;
+    } else {
+        USTPUTC('/', new);
+        cdcomppath++;
+        if (dir[1] == '/' && dir[2] != '/') {
+            USTPUTC('/', new);
+            cdcomppath++;
+            lim++;
+        }
+    }
+    p = strtok(cdcomppath, "/");
+    while (p) {
+        switch (*p) {
+        case '.':
+            if (p[1] == '.' && p[2] == '\0') {
+                while (new > lim) {
+                    STUNPUTC(new);
+                    if (new[-1] == '/')
+                        break;
+                }
+                break;
+            }
+            if (p[1] == '\0')
+                break;
+            /* fall through */
+        default:
+            new = stack_putstr(p, new);
+            USTPUTC('/', new);
+        }
+        p = strtok(0, "/");
+    }
+    if (new > lim)
+        STUNPUTC(new);
+    *new = 0;
+    return stackblock();
+}
+
+/*
+ * Find out what the current directory is. If we already know the current
+ * directory, this routine returns immediately.
+ */
+static char *
+getpwd(void)
+{
+    char *dir = getcwd(0, 0);
+    return dir ? dir : nullstr;
+}
+
+static void
+setpwd(const char *val, int setold)
+{
+    char *oldcur, *dir;
+
+    oldcur = dir = curdir;
+
+    if (setold) {
+        setvar("OLDPWD", oldcur, VEXPORT);
+    }
+    INT_OFF;
+    if (physdir != nullstr) {
+        if (physdir != oldcur)
+            free(physdir);
+        physdir = nullstr;
+    }
+    if (oldcur == val || !val) {
+        char *s = getpwd();
+        physdir = s;
+        if (!val)
+            dir = s;
+    } else
+        dir = ckstrdup(val);
+    if (oldcur != dir && oldcur != nullstr) {
+        free(oldcur);
+    }
+    curdir = dir;
+    INT_ON;
+    setvar("PWD", dir, VEXPORT);
+}
+
+static void hashcd(void);
+
+/*
+ * Actually do the chdir.  We also call hashcd to let the routines in exec.c
+ * know that the current directory has changed.
+ */
+static int
+docd(const char *dest, int flags)
+{
+    const char *dir = 0;
+    int err;
+
+    TRACE(("docd(\"%s\", %d) called\n", dest, flags));
+
+    INT_OFF;
+    if (!(flags & CD_PHYSICAL)) {
+        dir = updatepwd(dest);
+        if (dir)
+            dest = dir;
+    }
+    err = chdir(dest);
+    if (err)
+        goto out;
+    setpwd(dir, 1);
+    hashcd();
+ out:
+    INT_ON;
+    return err;
+}
+
+static int
+cdcmd(int argc, char **argv)
+{
+    const char *dest;
+    const char *path;
+    const char *p;
+    char c;
+    struct stat statb;
+    int flags;
+
+    flags = cdopt();
+    dest = *argptr;
+    if (!dest)
+        dest = bltinlookup(homestr);
+    else if (LONE_DASH(dest)) {
+        dest = bltinlookup("OLDPWD");
+        flags |= CD_PRINT;
+    }
+    if (!dest)
+        dest = nullstr;
+    if (*dest == '/')
+        goto step7;
+    if (*dest == '.') {
+        c = dest[1];
+ dotdot:
+        switch (c) {
+        case '\0':
+        case '/':
+            goto step6;
+        case '.':
+            c = dest[2];
+            if (c != '.')
+                goto dotdot;
+        }
+    }
+    if (!*dest)
+        dest = ".";
+    path = bltinlookup("CDPATH");
+    if (!path) {
+ step6:
+ step7:
+        p = dest;
+        goto docd;
+    }
+    do {
+        c = *path;
+        p = padvance(&path, dest);
+        if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
+            if (c && c != ':')
+                flags |= CD_PRINT;
+ docd:
+            if (!docd(p, flags))
+                goto out;
+            break;
+        }
+    } while (path);
+    ash_msg_and_raise_error("can't cd to %s", dest);
+    /* NOTREACHED */
+ out:
+    if (flags & CD_PRINT)
+        out1fmt(snlfmt, curdir);
+    return 0;
+}
+
+static int
+pwdcmd(int argc, char **argv)
+{
+    int flags;
+    const char *dir = curdir;
+
+    flags = cdopt();
+    if (flags) {
+        if (physdir == nullstr)
+            setpwd(dir, 0);
+        dir = physdir;
+    }
+    out1fmt(snlfmt, dir);
+    return 0;
+}
+
+
+/* ============ ... */
+
+#define IBUFSIZ (BUFSIZ + 1)
+#define basebuf bb_common_bufsiz1       /* buffer for top level input file */
 
 /* Syntax classes */
@@ -712 +2479 @@
 #define CIGN 14                 /* character should be ignored */
 
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
 #define SYNBASE 130
 #define PEOF -130
@@ -723 +2490 @@
 #endif
 
-#define is_digit(c)     ((unsigned)((c) - '0') <= 9)
-#define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
-#define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
-
-/* C99 say: "char" declaration may be signed or unsigned default */
-#define SC2INT(chr2may_be_negative_int) (int)((signed char)chr2may_be_negative_int)
-
-/*
- * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
- * (assuming ascii char codes, as the original implementation did)
- */
-#define is_special(c) \
-    ( (((unsigned int)c) - 33 < 32) \
-             && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
-
-#define digit_val(c)    ((c) - '0')
-
-/*
- * This file was generated by the mksyntax program.
- */
-
-#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
+/* number syntax index */
+#define BASESYNTAX 0    /* not in quotes */
+#define DQSYNTAX   1    /* in double quotes */
+#define SQSYNTAX   2    /* in single quotes */
+#define ARISYNTAX  3    /* in arithmetic */
+
+#if ENABLE_ASH_OPTIMIZE_FOR_SIZE
 #define USE_SIT_FUNCTION
 #endif
 
-/* number syntax index */
-#define  BASESYNTAX  0  /* not in quotes */
-#define  DQSYNTAX    1  /* in double quotes */
-#define  SQSYNTAX    2  /* in single quotes */
-#define  ARISYNTAX   3  /* in arithmetic */
-
-#ifdef CONFIG_ASH_MATH_SUPPORT
+#if ENABLE_ASH_MATH_SUPPORT
 static const char S_I_T[][4] = {
-#ifdef CONFIG_ASH_ALIAS
-    {CSPCL, CIGN, CIGN, CIGN},              /* 0, PEOA */
-#endif
-    {CSPCL, CWORD, CWORD, CWORD},           /* 1, ' ' */
-    {CNL, CNL, CNL, CNL},                   /* 2, \n */
-    {CWORD, CCTL, CCTL, CWORD},             /* 3, !*-/:=?[]~ */
-    {CDQUOTE, CENDQUOTE, CWORD, CWORD},     /* 4, '"' */
-    {CVAR, CVAR, CWORD, CVAR},              /* 5, $ */
-    {CSQUOTE, CWORD, CENDQUOTE, CWORD},     /* 6, "'" */
-    {CSPCL, CWORD, CWORD, CLP},             /* 7, ( */
-    {CSPCL, CWORD, CWORD, CRP},             /* 8, ) */
-    {CBACK, CBACK, CCTL, CBACK},            /* 9, \ */
-    {CBQUOTE, CBQUOTE, CWORD, CBQUOTE},     /* 10, ` */
-    {CENDVAR, CENDVAR, CWORD, CENDVAR},     /* 11, } */
+#if ENABLE_ASH_ALIAS
+    { CSPCL, CIGN, CIGN, CIGN },            /* 0, PEOA */
+#endif
+    { CSPCL, CWORD, CWORD, CWORD },         /* 1, ' ' */
+    { CNL, CNL, CNL, CNL },                 /* 2, \n */
+    { CWORD, CCTL, CCTL, CWORD },           /* 3, !*-/:=?[]~ */
+    { CDQUOTE, CENDQUOTE, CWORD, CWORD },   /* 4, '"' */
+    { CVAR, CVAR, CWORD, CVAR },            /* 5, $ */
+    { CSQUOTE, CWORD, CENDQUOTE, CWORD },   /* 6, "'" */
+    { CSPCL, CWORD, CWORD, CLP },           /* 7, ( */
+    { CSPCL, CWORD, CWORD, CRP },           /* 8, ) */
+    { CBACK, CBACK, CCTL, CBACK },          /* 9, \ */
+    { CBQUOTE, CBQUOTE, CWORD, CBQUOTE },   /* 10, ` */
+    { CENDVAR, CENDVAR, CWORD, CENDVAR },   /* 11, } */
 #ifndef USE_SIT_FUNCTION
-    {CENDFILE, CENDFILE, CENDFILE, CENDFILE},       /* 12, PEOF */
-    {CWORD, CWORD, CWORD, CWORD},           /* 13, 0-9A-Za-z */
-    {CCTL, CCTL, CCTL, CCTL}                /* 14, CTLESC ... */
+    { CENDFILE, CENDFILE, CENDFILE, CENDFILE }, /* 12, PEOF */
+    { CWORD, CWORD, CWORD, CWORD },         /* 13, 0-9A-Za-z */
+    { CCTL, CCTL, CCTL, CCTL }              /* 14, CTLESC ... */
 #endif
 };
 #else
 static const char S_I_T[][3] = {
-#ifdef CONFIG_ASH_ALIAS
-    {CSPCL, CIGN, CIGN},                    /* 0, PEOA */
-#endif
-    {CSPCL, CWORD, CWORD},                  /* 1, ' ' */
-    {CNL, CNL, CNL},                        /* 2, \n */
-    {CWORD, CCTL, CCTL},                    /* 3, !*-/:=?[]~ */
-    {CDQUOTE, CENDQUOTE, CWORD},            /* 4, '"' */
-    {CVAR, CVAR, CWORD},                    /* 5, $ */
-    {CSQUOTE, CWORD, CENDQUOTE},            /* 6, "'" */
-    {CSPCL, CWORD, CWORD},                  /* 7, ( */
-    {CSPCL, CWORD, CWORD},                  /* 8, ) */
-    {CBACK, CBACK, CCTL},                   /* 9, \ */
-    {CBQUOTE, CBQUOTE, CWORD},              /* 10, ` */
-    {CENDVAR, CENDVAR, CWORD},              /* 11, } */
+#if ENABLE_ASH_ALIAS
+    { CSPCL, CIGN, CIGN },                  /* 0, PEOA */
+#endif
+    { CSPCL, CWORD, CWORD },                /* 1, ' ' */
+    { CNL, CNL, CNL },                      /* 2, \n */
+    { CWORD, CCTL, CCTL },                  /* 3, !*-/:=?[]~ */
+    { CDQUOTE, CENDQUOTE, CWORD },          /* 4, '"' */
+    { CVAR, CVAR, CWORD },                  /* 5, $ */
+    { CSQUOTE, CWORD, CENDQUOTE },          /* 6, "'" */
+    { CSPCL, CWORD, CWORD },                /* 7, ( */
+    { CSPCL, CWORD, CWORD },                /* 8, ) */
+    { CBACK, CBACK, CCTL },                 /* 9, \ */
+    { CBQUOTE, CBQUOTE, CWORD },            /* 10, ` */
+    { CENDVAR, CENDVAR, CWORD },            /* 11, } */
 #ifndef USE_SIT_FUNCTION
-    {CENDFILE, CENDFILE, CENDFILE},         /* 12, PEOF */
-    {CWORD, CWORD, CWORD},                  /* 13, 0-9A-Za-z */
-    {CCTL, CCTL, CCTL}                      /* 14, CTLESC ... */
+    { CENDFILE, CENDFILE, CENDFILE },       /* 12, PEOF */
+    { CWORD, CWORD, CWORD },                /* 13, 0-9A-Za-z */
+    { CCTL, CCTL, CCTL }                    /* 14, CTLESC ... */
 #endif
 };
-#endif /* CONFIG_ASH_MATH_SUPPORT */
+#endif /* ASH_MATH_SUPPORT */
 
 #ifdef USE_SIT_FUNCTION
 
-#define U_C(c) ((unsigned char)(c))
-
-static int SIT(int c, int syntax)
-{
-    static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
-#ifdef CONFIG_ASH_ALIAS
-    static const char syntax_index_table[] = {
+static int
+SIT(int c, int syntax)
+{
+    static const char spec_symbls[] ALIGN1 = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
+#if ENABLE_ASH_ALIAS
+    static const char syntax_index_table[] ALIGN1 = {
         1, 2, 1, 3, 4, 5, 1, 6,         /* "\t\n !\"$&'" */
         7, 8, 3, 3, 3, 3, 1, 1,         /* "()*-/:;<" */
@@ -815 +2560 @@
     };
 #else
-    static const char syntax_index_table[] = {
+    static const char syntax_index_table[] ALIGN1 = {
         0, 1, 0, 2, 3, 4, 0, 5,         /* "\t\n !\"$&'" */
         6, 7, 2, 2, 2, 2, 0, 0,         /* "()*-/:;<" */
@@ -827 +2572 @@
     if (c == PEOF)          /* 2^8+2 */
         return CENDFILE;
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
     if (c == PEOA)          /* 2^8+1 */
         indx = 0;
     else
 #endif
-        if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK))
-            return CCTL;
-    else {
+#define U_C(c) ((unsigned char)(c))
+
+    if ((unsigned char)c >= (unsigned char)(CTLESC)
+     && (unsigned char)c <= (unsigned char)(CTLQUOTEMARK)
+    ) {
+        return CCTL;
+    } else {
         s = strchr(spec_symbls, c);
-        if (s == 0 || *s == 0)
+        if (s == NULL || *s == '\0')
             return CWORD;
         indx = syntax_index_table[(s - spec_symbls)];
@@ -843 +2592 @@
 }
 
-#else   /* USE_SIT_FUNCTION */
-
-#define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax]
-
-#ifdef CONFIG_ASH_ALIAS
-#define CSPCL_CIGN_CIGN_CIGN                           0
-#define CSPCL_CWORD_CWORD_CWORD                        1
-#define CNL_CNL_CNL_CNL                                2
-#define CWORD_CCTL_CCTL_CWORD                          3
-#define CDQUOTE_CENDQUOTE_CWORD_CWORD                  4
-#define CVAR_CVAR_CWORD_CVAR                           5
-#define CSQUOTE_CWORD_CENDQUOTE_CWORD                  6
-#define CSPCL_CWORD_CWORD_CLP                          7
-#define CSPCL_CWORD_CWORD_CRP                          8
-#define CBACK_CBACK_CCTL_CBACK                         9
-#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE                 10
-#define CENDVAR_CENDVAR_CWORD_CENDVAR                 11
-#define CENDFILE_CENDFILE_CENDFILE_CENDFILE           12
-#define CWORD_CWORD_CWORD_CWORD                       13
-#define CCTL_CCTL_CCTL_CCTL                           14
+#else   /* !USE_SIT_FUNCTION */
+
+#if ENABLE_ASH_ALIAS
+#define CSPCL_CIGN_CIGN_CIGN                     0
+#define CSPCL_CWORD_CWORD_CWORD                  1
+#define CNL_CNL_CNL_CNL                          2
+#define CWORD_CCTL_CCTL_CWORD                    3
+#define CDQUOTE_CENDQUOTE_CWORD_CWORD            4
+#define CVAR_CVAR_CWORD_CVAR                     5
+#define CSQUOTE_CWORD_CENDQUOTE_CWORD            6
+#define CSPCL_CWORD_CWORD_CLP                    7
+#define CSPCL_CWORD_CWORD_CRP                    8
+#define CBACK_CBACK_CCTL_CBACK                   9
+#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE           10
+#define CENDVAR_CENDVAR_CWORD_CENDVAR           11
+#define CENDFILE_CENDFILE_CENDFILE_CENDFILE     12
+#define CWORD_CWORD_CWORD_CWORD                 13
+#define CCTL_CCTL_CCTL_CCTL                     14
 #else
-#define CSPCL_CWORD_CWORD_CWORD                        0
-#define CNL_CNL_CNL_CNL                                1
-#define CWORD_CCTL_CCTL_CWORD                          2
-#define CDQUOTE_CENDQUOTE_CWORD_CWORD                  3
-#define CVAR_CVAR_CWORD_CVAR                           4
-#define CSQUOTE_CWORD_CENDQUOTE_CWORD                  5
-#define CSPCL_CWORD_CWORD_CLP                          6
-#define CSPCL_CWORD_CWORD_CRP                          7
-#define CBACK_CBACK_CCTL_CBACK                         8
-#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE                  9
-#define CENDVAR_CENDVAR_CWORD_CENDVAR                 10
-#define CENDFILE_CENDFILE_CENDFILE_CENDFILE           11
-#define CWORD_CWORD_CWORD_CWORD                       12
-#define CCTL_CCTL_CCTL_CCTL                           13
+#define CSPCL_CWORD_CWORD_CWORD                  0
+#define CNL_CNL_CNL_CNL                          1
+#define CWORD_CCTL_CCTL_CWORD                    2
+#define CDQUOTE_CENDQUOTE_CWORD_CWORD            3
+#define CVAR_CVAR_CWORD_CVAR                     4
+#define CSQUOTE_CWORD_CENDQUOTE_CWORD            5
+#define CSPCL_CWORD_CWORD_CLP                    6
+#define CSPCL_CWORD_CWORD_CRP                    7
+#define CBACK_CBACK_CCTL_CBACK                   8
+#define CBQUOTE_CBQUOTE_CWORD_CBQUOTE            9
+#define CENDVAR_CENDVAR_CWORD_CENDVAR           10
+#define CENDFILE_CENDFILE_CENDFILE_CENDFILE     11
+#define CWORD_CWORD_CWORD_CWORD                 12
+#define CCTL_CCTL_CCTL_CCTL                     13
 #endif
 
@@ -883 +2630 @@
     /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
     /*   0  PEOF */      CENDFILE_CENDFILE_CENDFILE_CENDFILE,
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
     /*   1  PEOA */      CSPCL_CIGN_CIGN_CIGN,
 #endif
@@ -1144 +2891 @@
 };
 
+#define SIT(c, syntax) (S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax])
+
 #endif  /* USE_SIT_FUNCTION */
 
-/*      alias.c      */
-
+
+/* ============ Alias handling */
+
+#if ENABLE_ASH_ALIAS
+
+#define ALIASINUSE 1
+#define ALIASDEAD  2
 
 #define ATABSIZE 39
 
-static int     funcblocksize;          /* size of structures in function */
-static int     funcstringsize;         /* size of strings in node */
-static pointer funcblock;              /* block to allocate function from */
-static char   *funcstring;             /* block to allocate strings from */
-
-static const short nodesize[26] = {
-      SHELL_ALIGN(sizeof (struct ncmd)),
-      SHELL_ALIGN(sizeof (struct npipe)),
-      SHELL_ALIGN(sizeof (struct nredir)),
-      SHELL_ALIGN(sizeof (struct nredir)),
-      SHELL_ALIGN(sizeof (struct nredir)),
-      SHELL_ALIGN(sizeof (struct nbinary)),
-      SHELL_ALIGN(sizeof (struct nbinary)),
-      SHELL_ALIGN(sizeof (struct nbinary)),
-      SHELL_ALIGN(sizeof (struct nif)),
-      SHELL_ALIGN(sizeof (struct nbinary)),
-      SHELL_ALIGN(sizeof (struct nbinary)),
-      SHELL_ALIGN(sizeof (struct nfor)),
-      SHELL_ALIGN(sizeof (struct ncase)),
-      SHELL_ALIGN(sizeof (struct nclist)),
-      SHELL_ALIGN(sizeof (struct narg)),
-      SHELL_ALIGN(sizeof (struct narg)),
-      SHELL_ALIGN(sizeof (struct nfile)),
-      SHELL_ALIGN(sizeof (struct nfile)),
-      SHELL_ALIGN(sizeof (struct nfile)),
-      SHELL_ALIGN(sizeof (struct nfile)),
-      SHELL_ALIGN(sizeof (struct nfile)),
-      SHELL_ALIGN(sizeof (struct ndup)),
-      SHELL_ALIGN(sizeof (struct ndup)),
-      SHELL_ALIGN(sizeof (struct nhere)),
-      SHELL_ALIGN(sizeof (struct nhere)),
-      SHELL_ALIGN(sizeof (struct nnot)),
+struct alias {
+    struct alias *next;
+    char *name;
+    char *val;
+    int flag;
 };
 
-
-static void calcsize(union node *);
-static void sizenodelist(struct nodelist *);
-static union node *copynode(union node *);
-static struct nodelist *copynodelist(struct nodelist *);
-static char *nodesavestr(char *);
-
-
-static int evalstring(char *, int mask);
-union node;     /* BLETCH for ansi C */
-static void evaltree(union node *, int);
-static void evalbackcmd(union node *, struct backcmd *);
-
-static int evalskip;                   /* set if we are skipping commands */
-static int skipcount;           /* number of levels to skip */
-static int funcnest;                   /* depth of function calls */
-
-/* reasons for skipping commands (see comment on breakcmd routine) */
-#define SKIPBREAK      (1 << 0)
-#define SKIPCONT       (1 << 1)
-#define SKIPFUNC       (1 << 2)
-#define SKIPFILE       (1 << 3)
-#define SKIPEVAL       (1 << 4)
-
-/*
- * This file was generated by the mkbuiltins program.
- */
-
-#if JOBS
-static int bgcmd(int, char **);
-#endif
-static int breakcmd(int, char **);
-static int cdcmd(int, char **);
-#ifdef CONFIG_ASH_CMDCMD
-static int commandcmd(int, char **);
-#endif
-static int dotcmd(int, char **);
-static int evalcmd(int, char **);
-#ifdef CONFIG_ASH_BUILTIN_ECHO
-static int echocmd(int, char **);
-#endif
-#ifdef CONFIG_ASH_BUILTIN_TEST
-static int testcmd(int, char **);
-#endif
-static int execcmd(int, char **);
-static int exitcmd(int, char **);
-static int exportcmd(int, char **);
-static int falsecmd(int, char **);
-#if JOBS
-static int fgcmd(int, char **);
-#endif
-#ifdef CONFIG_ASH_GETOPTS
-static int getoptscmd(int, char **);
-#endif
-static int hashcmd(int, char **);
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
-static int helpcmd(int argc, char **argv);
-#endif
-#if JOBS
-static int jobscmd(int, char **);
-#endif
-#ifdef CONFIG_ASH_MATH_SUPPORT
-static int letcmd(int, char **);
-#endif
-static int localcmd(int, char **);
-static int pwdcmd(int, char **);
-static int readcmd(int, char **);
-static int returncmd(int, char **);
-static int setcmd(int, char **);
-static int shiftcmd(int, char **);
-static int timescmd(int, char **);
-static int trapcmd(int, char **);
-static int truecmd(int, char **);
-static int typecmd(int, char **);
-static int umaskcmd(int, char **);
-static int unsetcmd(int, char **);
-static int waitcmd(int, char **);
-static int ulimitcmd(int, char **);
-#if JOBS
-static int killcmd(int, char **);
-#endif
-
-/*      mail.h        */
-
-#ifdef CONFIG_ASH_MAIL
-static void chkmail(void);
-static void changemail(const char *);
-#endif
-
-/*      exec.h    */
-
-/* values of cmdtype */
-#define CMDUNKNOWN      -1      /* no entry in table for command */
-#define CMDNORMAL       0       /* command is an executable program */
-#define CMDFUNCTION     1       /* command is a shell function */
-#define CMDBUILTIN      2       /* command is a shell builtin */
-
-struct builtincmd {
-    const char *name;
-    int (*builtin)(int, char **);
-    /* unsigned flags; */
-};
-
-
-#define COMMANDCMD (builtincmd + 5 + \
-    2 * ENABLE_ASH_BUILTIN_TEST + \
-    ENABLE_ASH_ALIAS + \
-    ENABLE_ASH_JOB_CONTROL)
-#define EXECCMD (builtincmd + 7 + \
-    2 * ENABLE_ASH_BUILTIN_TEST + \
-    ENABLE_ASH_ALIAS + \
-    ENABLE_ASH_JOB_CONTROL + \
-    ENABLE_ASH_CMDCMD + \
-    ENABLE_ASH_BUILTIN_ECHO)
-
-#define BUILTIN_NOSPEC  "0"
-#define BUILTIN_SPECIAL "1"
-#define BUILTIN_REGULAR "2"
-#define BUILTIN_SPEC_REG "3"
-#define BUILTIN_ASSIGN  "4"
-#define BUILTIN_SPEC_ASSG  "5"
-#define BUILTIN_REG_ASSG   "6"
-#define BUILTIN_SPEC_REG_ASSG   "7"
-
-#define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
-#define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
-#define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4)
-
-/* make sure to keep these in proper order since it is searched via bsearch() */
-static const struct builtincmd builtincmd[] = {
-    { BUILTIN_SPEC_REG      ".", dotcmd },
-    { BUILTIN_SPEC_REG      ":", truecmd },
-#ifdef CONFIG_ASH_BUILTIN_TEST
-    { BUILTIN_REGULAR   "[", testcmd },
-    { BUILTIN_REGULAR   "[[", testcmd },
-#endif
-#ifdef CONFIG_ASH_ALIAS
-    { BUILTIN_REG_ASSG      "alias", aliascmd },
-#endif
-#if JOBS
-    { BUILTIN_REGULAR       "bg", bgcmd },
-#endif
-    { BUILTIN_SPEC_REG      "break", breakcmd },
-    { BUILTIN_REGULAR       "cd", cdcmd },
-    { BUILTIN_NOSPEC        "chdir", cdcmd },
-#ifdef CONFIG_ASH_CMDCMD
-    { BUILTIN_REGULAR       "command", commandcmd },
-#endif
-    { BUILTIN_SPEC_REG      "continue", breakcmd },
-#ifdef CONFIG_ASH_BUILTIN_ECHO
-    { BUILTIN_REGULAR       "echo", echocmd },
-#endif
-    { BUILTIN_SPEC_REG      "eval", evalcmd },
-    { BUILTIN_SPEC_REG      "exec", execcmd },
-    { BUILTIN_SPEC_REG      "exit", exitcmd },
-    { BUILTIN_SPEC_REG_ASSG "export", exportcmd },
-    { BUILTIN_REGULAR       "false", falsecmd },
-#if JOBS
-    { BUILTIN_REGULAR       "fg", fgcmd },
-#endif
-#ifdef CONFIG_ASH_GETOPTS
-    { BUILTIN_REGULAR       "getopts", getoptscmd },
-#endif
-    { BUILTIN_NOSPEC        "hash", hashcmd },
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
-    { BUILTIN_NOSPEC        "help", helpcmd },
-#endif
-#if JOBS
-    { BUILTIN_REGULAR       "jobs", jobscmd },
-    { BUILTIN_REGULAR       "kill", killcmd },
-#endif
-#ifdef CONFIG_ASH_MATH_SUPPORT
-    { BUILTIN_NOSPEC        "let", letcmd },
-#endif
-    { BUILTIN_ASSIGN        "local", localcmd },
-    { BUILTIN_NOSPEC        "pwd", pwdcmd },
-    { BUILTIN_REGULAR       "read", readcmd },
-    { BUILTIN_SPEC_REG_ASSG "readonly", exportcmd },
-    { BUILTIN_SPEC_REG      "return", returncmd },
-    { BUILTIN_SPEC_REG      "set", setcmd },
-    { BUILTIN_SPEC_REG      "shift", shiftcmd },
-    { BUILTIN_SPEC_REG      "source", dotcmd },
-#ifdef CONFIG_ASH_BUILTIN_TEST
-    { BUILTIN_REGULAR   "test", testcmd },
-#endif
-    { BUILTIN_SPEC_REG      "times", timescmd },
-    { BUILTIN_SPEC_REG      "trap", trapcmd },
-    { BUILTIN_REGULAR       "true", truecmd },
-    { BUILTIN_NOSPEC        "type", typecmd },
-    { BUILTIN_NOSPEC        "ulimit", ulimitcmd },
-    { BUILTIN_REGULAR       "umask", umaskcmd },
-#ifdef CONFIG_ASH_ALIAS
-    { BUILTIN_REGULAR       "unalias", unaliascmd },
-#endif
-    { BUILTIN_SPEC_REG      "unset", unsetcmd },
-    { BUILTIN_REGULAR       "wait", waitcmd },
-};
-
-#define NUMBUILTINS  (sizeof (builtincmd) / sizeof (struct builtincmd) )
-
-
-
-struct cmdentry {
-    int cmdtype;
-    union param {
-        int index;
-        const struct builtincmd *cmd;
-        struct funcnode *func;
-    } u;
-};
-
-
-/* action to find_command() */
-#define DO_ERR          0x01    /* prints errors */
-#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 */
-
-static const char *pathopt;     /* set by padvance */
-
-static void shellexec(char **, const char *, int)
-    ATTRIBUTE_NORETURN;
-static char *padvance(const char **, const char *);
-static void find_command(char *, struct cmdentry *, int, const char *);
-static struct builtincmd *find_builtin(const char *);
-static void hashcd(void);
-static void changepath(const char *);
-static void defun(char *, union node *);
-static void unsetfunc(const char *);
-
-#ifdef CONFIG_ASH_MATH_SUPPORT_64
-typedef int64_t arith_t;
-#define arith_t_type (long long)
-#else
-typedef long arith_t;
-#define arith_t_type (long)
-#endif
-
-#ifdef CONFIG_ASH_MATH_SUPPORT
-static arith_t dash_arith(const char *);
-static arith_t arith(const char *expr, int *perrcode);
-#endif
-
-#ifdef CONFIG_ASH_RANDOM_SUPPORT
-static unsigned long rseed;
-static void change_random(const char *);
-# ifndef DYNAMIC_VAR
-#  define DYNAMIC_VAR
-# endif
-#endif
-
-/*      init.h        */
-
-static void reset(void);
-
-/*      var.h     */
-
-/*
- * Shell variables.
- */
-
-/* flags */
-#define VEXPORT         0x01    /* variable is exported */
-#define VREADONLY       0x02    /* variable cannot be modified */
-#define VSTRFIXED       0x04    /* variable struct is statically allocated */
-#define VTEXTFIXED      0x08    /* text is statically allocated */
-#define VSTACK          0x10    /* text is allocated on the stack */
-#define VUNSET          0x20    /* the variable is not set */
-#define VNOFUNC         0x40    /* don't call the callback function */
-#define VNOSET          0x80    /* do not set variable - just readonly test */
-#define VNOSAVE         0x100   /* when text is on the heap before setvareq */
-#ifdef DYNAMIC_VAR
-# define VDYNAMIC        0x200   /* dynamic variable */
-# else
-# define VDYNAMIC        0
-#endif
-
-struct var {
-    struct var *next;               /* next entry in hash list */
-    int flags;                      /* flags are defined above */
-    const char *text;               /* name=value */
-    void (*func)(const char *);     /* function to be called when  */
-                    /* the variable gets set/unset */
-};
-
-struct localvar {
-    struct localvar *next;          /* next local variable in list */
-    struct var *vp;                 /* the variable that was made local */
-    int flags;                      /* saved flags */
-    const char *text;               /* saved text */
-};
-
-
-static struct localvar *localvars;
-
-/*
- * Shell variables.
- */
-
-#ifdef CONFIG_ASH_GETOPTS
-static void getoptsreset(const char *);
-#endif
-
-#ifdef CONFIG_LOCALE_SUPPORT
-#include <locale.h>
-static void change_lc_all(const char *value);
-static void change_lc_ctype(const char *value);
-#endif
-
-
-#define VTABSIZE 39
-
-static const char defpathvar[] = "PATH=/usr/local/bin:/usr/bin:/sbin:/bin";
-#ifdef IFS_BROKEN
-static const char defifsvar[] = "IFS= \t\n";
-#define defifs (defifsvar + 4)
-#else
-static const char defifs[] = " \t\n";
-#endif
-
-
-static struct var varinit[] = {
-#ifdef IFS_BROKEN
-    { 0,    VSTRFIXED|VTEXTFIXED,           defifsvar,      0 },
-#else
-    { 0,    VSTRFIXED|VTEXTFIXED|VUNSET,    "IFS\0",        0 },
-#endif
-
-#ifdef CONFIG_ASH_MAIL
-    { 0,    VSTRFIXED|VTEXTFIXED|VUNSET,    "MAIL\0",       changemail },
-    { 0,    VSTRFIXED|VTEXTFIXED|VUNSET,    "MAILPATH\0",   changemail },
-#endif
-
-    { 0,    VSTRFIXED|VTEXTFIXED,           defpathvar,     changepath },
-    { 0,    VSTRFIXED|VTEXTFIXED,           "PS1=$ ",       0          },
-    { 0,    VSTRFIXED|VTEXTFIXED,           "PS2=> ",       0          },
-    { 0,    VSTRFIXED|VTEXTFIXED,           "PS4=+ ",       0          },
-#ifdef CONFIG_ASH_GETOPTS
-    { 0,    VSTRFIXED|VTEXTFIXED,           "OPTIND=1",     getoptsreset },
-#endif
-#ifdef CONFIG_ASH_RANDOM_SUPPORT
-    {0, VSTRFIXED|VTEXTFIXED|VUNSET|VDYNAMIC, "RANDOM\0", change_random },
-#endif
-#ifdef CONFIG_LOCALE_SUPPORT
-    {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL\0", change_lc_all },
-    {0, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE\0", change_lc_ctype },
-#endif
-#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
-    {0, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE\0", NULL },
-#endif
-};
-
-#define vifs varinit[0]
-#ifdef CONFIG_ASH_MAIL
-#define vmail (&vifs)[1]
-#define vmpath (&vmail)[1]
-#else
-#define vmpath vifs
-#endif
-#define vpath (&vmpath)[1]
-#define vps1 (&vpath)[1]
-#define vps2 (&vps1)[1]
-#define vps4 (&vps2)[1]
-#define voptind (&vps4)[1]
-#ifdef CONFIG_ASH_GETOPTS
-#define vrandom (&voptind)[1]
-#else
-#define vrandom (&vps4)[1]
-#endif
-#define defpath (defpathvar + 5)
-
-/*
- * The following macros access the values of the above variables.
- * They have to skip over the name.  They return the null string
- * for unset variables.
- */
-
-#define ifsval()        (vifs.text + 4)
-#define ifsset()        ((vifs.flags & VUNSET) == 0)
-#define mailval()       (vmail.text + 5)
-#define mpathval()      (vmpath.text + 9)
-#define pathval()       (vpath.text + 5)
-#define ps1val()        (vps1.text + 4)
-#define ps2val()        (vps2.text + 4)
-#define ps4val()        (vps4.text + 4)
-#define optindval()     (voptind.text + 7)
-
-#define mpathset()      ((vmpath.flags & VUNSET) == 0)
-
-static void setvar(const char *, const char *, int);
-static void setvareq(char *, int);
-static void listsetvar(struct strlist *, int);
-static char *lookupvar(const char *);
-static char *bltinlookup(const char *);
-static char **listvars(int, int, char ***);
-#define environment() listvars(VEXPORT, VUNSET, 0)
-static int showvars(const char *, int, int);
-static void poplocalvars(void);
-static int unsetvar(const char *);
-#ifdef CONFIG_ASH_GETOPTS
-static int setvarsafe(const char *, const char *, int);
-#endif
-static int varcmp(const char *, const char *);
-static struct var **hashvar(const char *);
-
-
-static inline int varequal(const char *a, const char *b) {
-    return !varcmp(a, b);
-}
-
-
-static int loopnest;            /* current loop nesting level */
-
-/*
- * The parsefile structure pointed to by the global variable parsefile
- * contains information about the current file being read.
- */
-
-
-struct redirtab {
-    struct redirtab *next;
-    int renamed[10];
-    int nullredirs;
-};
-
-static struct redirtab *redirlist;
-static int nullredirs;
-
-extern char **environ;
-
-/*      output.h     */
-
-
-static void outstr(const char *, FILE *);
-static void outcslow(int, FILE *);
-static void flushall(void);
-static void flusherr(void);
-static int  out1fmt(const char *, ...)
-    __attribute__((__format__(__printf__,1,2)));
-static int fmtstr(char *, size_t, const char *, ...)
-    __attribute__((__format__(__printf__,3,4)));
-
-static int preverrout_fd;   /* save fd2 before print debug if xflag is set. */
-
-
-static void out1str(const char *p)
-{
-    outstr(p, stdout);
-}
-
-static void out2str(const char *p)
-{
-    outstr(p, stderr);
-    flusherr();
-}
-
-/*
- * Initialization code.
- */
-
-/*
- * This routine initializes the builtin variables.
- */
-
-static inline void
-initvar(void)
-{
-    struct var *vp;
-    struct var *end;
-    struct var **vpp;
-
-    /*
-     * PS1 depends on uid
-     */
-#if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
-    vps1.text = "PS1=\\w \\$ ";
-#else
-    if (!geteuid())
-        vps1.text = "PS1=# ";
-#endif
-    vp = varinit;
-    end = vp + sizeof(varinit) / sizeof(varinit[0]);
-    do {
-        vpp = hashvar(vp->text);
-        vp->next = *vpp;
-        *vpp = vp;
-    } while (++vp < end);
-}
-
-static inline void
-init(void)
-{
-
-      /* from input.c: */
-      {
-          basepf.nextc = basepf.buf = basebuf;
-      }
-
-      /* from trap.c: */
-      {
-          signal(SIGCHLD, SIG_DFL);
-      }
-
-      /* from var.c: */
-      {
-          char **envp;
-          char ppid[32];
-          const char *p;
-          struct stat st1, st2;
-
-          initvar();
-          for (envp = environ ; envp && *envp ; envp++) {
-              if (strchr(*envp, '=')) {
-                  setvareq(*envp, VEXPORT|VTEXTFIXED);
-              }
-          }
-
-          snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
-          setvar("PPID", ppid, 0);
-
-          p = lookupvar("PWD");
-          if (p)
-          if (*p != '/' || stat(p, &st1) || stat(".", &st2) ||
-          st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino)
-              p = 0;
-          setpwd(p, 0);
-      }
-}
-
-/* PEOF (the end of file marker) */
-
-enum {
-    INPUT_PUSH_FILE = 1,
-    INPUT_NOFILE_OK = 2,
-};
-
-/*
- * The input line number.  Input.c just defines this variable, and saves
- * and restores it when files are pushed and popped.  The user of this
- * package must set its value.
- */
-
-static int pgetc(void);
-static int pgetc2(void);
-static int preadbuffer(void);
-static void pungetc(void);
-static void pushstring(char *, void *);
-static void popstring(void);
-static void setinputfd(int, int);
-static void setinputstring(char *);
-static void popfile(void);
-static void popallfiles(void);
-static void closescript(void);
-
-
-/*      jobs.h    */
-
+static struct alias *atab[ATABSIZE];
+
+static struct alias **
+__lookupalias(const char *name) {
+    unsigned int hashval;
+    struct alias **app;
+    const char *p;
+    unsigned int ch;
+
+    p = name;
+
+    ch = (unsigned char)*p;
+    hashval = ch << 4;
+    while (ch) {
+        hashval += ch;
+        ch = (unsigned char)*++p;
+    }
+    app = &atab[hashval % ATABSIZE];
+
+    for (; *app; app = &(*app)->next) {
+        if (strcmp(name, (*app)->name) == 0) {
+            break;
+        }
+    }
+
+    return app;
+}
+
+static struct alias *
+lookupalias(const char *name, int check)
+{
+    struct alias *ap = *__lookupalias(name);
+
+    if (check && ap && (ap->flag & ALIASINUSE))
+        return NULL;
+    return ap;
+}
+
+static struct alias *
+freealias(struct alias *ap)
+{
+    struct alias *next;
+
+    if (ap->flag & ALIASINUSE) {
+        ap->flag |= ALIASDEAD;
+        return ap;
+    }
+
+    next = ap->next;
+    free(ap->name);
+    free(ap->val);
+    free(ap);
+    return next;
+}
+
+static void
+setalias(const char *name, const char *val)
+{
+    struct alias *ap, **app;
+
+    app = __lookupalias(name);
+    ap = *app;
+    INT_OFF;
+    if (ap) {
+        if (!(ap->flag & ALIASINUSE)) {
+            free(ap->val);
+        }
+        ap->val = ckstrdup(val);
+        ap->flag &= ~ALIASDEAD;
+    } else {
+        /* not found */
+        ap = ckmalloc(sizeof(struct alias));
+        ap->name = ckstrdup(name);
+        ap->val = ckstrdup(val);
+        ap->flag = 0;
+        ap->next = 0;
+        *app = ap;
+    }
+    INT_ON;
+}
+
+static int
+unalias(const char *name)
+{
+    struct alias **app;
+
+    app = __lookupalias(name);
+
+    if (*app) {
+        INT_OFF;
+        *app = freealias(*app);
+        INT_ON;
+        return 0;
+    }
+
+    return 1;
+}
+
+static void
+rmaliases(void)
+{
+    struct alias *ap, **app;
+    int i;
+
+    INT_OFF;
+    for (i = 0; i < ATABSIZE; i++) {
+        app = &atab[i];
+        for (ap = *app; ap; ap = *app) {
+            *app = freealias(*app);
+            if (ap == *app) {
+                app = &ap->next;
+            }
+        }
+    }
+    INT_ON;
+}
+
+static void
+printalias(const struct alias *ap)
+{
+    out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
+}
+
+/*
+ * TODO - sort output
+ */
+static int
+aliascmd(int argc, char **argv)
+{
+    char *n, *v;
+    int ret = 0;
+    struct alias *ap;
+
+    if (argc == 1) {
+        int i;
+
+        for (i = 0; i < ATABSIZE; i++)
+            for (ap = atab[i]; ap; ap = ap->next) {
+                printalias(ap);
+            }
+        return 0;
+    }
+    while ((n = *++argv) != NULL) {
+        v = strchr(n+1, '=');
+        if (v == NULL) { /* n+1: funny ksh stuff */
+            ap = *__lookupalias(n);
+            if (ap == NULL) {
+                fprintf(stderr, "%s: %s not found\n", "alias", n);
+                ret = 1;
+            } else
+                printalias(ap);
+        } else {
+            *v++ = '\0';
+            setalias(n, v);
+        }
+    }
+
+    return ret;
+}
+
+static int
+unaliascmd(int argc, char **argv)
+{
+    int i;
+
+    while ((i = nextopt("a")) != '\0') {
+        if (i == 'a') {
+            rmaliases();
+            return 0;
+        }
+    }
+    for (i = 0; *argptr; argptr++) {
+        if (unalias(*argptr)) {
+            fprintf(stderr, "%s: %s not found\n", "unalias", *argptr);
+            i = 1;
+        }
+    }
+
+    return i;
+}
+
+#endif /* ASH_ALIAS */
+
+
+/* ============ jobs.c */
 
 /* Mode argument to forkshell.  Don't change FORK_FG or FORK_BG. */
@@ -1753 +3107 @@
 #define SHOW_PID        0x04    /* include process pid */
 #define SHOW_CHANGED    0x08    /* only jobs whose state has changed */
-
 
 /*
@@ -1791 +3144 @@
 
 static pid_t backgndpid;        /* pid of last background process */
-static int job_warning;         /* user was warned about stopped jobs */
-#if JOBS
-static int jobctl;              /* true if doing job control */
-#endif
+static smallint job_warning;    /* user was warned about stopped jobs (can be 2, 1 or 0). */
 
 static struct job *makejob(union node *, int);
 static int forkshell(struct job *, union node *, int);
 static int waitforjob(struct job *);
-static int stoppedjobs(void);
-
-#if ! JOBS
-#define setjobctl(on)   /* do nothing */
+
+#if !JOBS
+enum { jobctl = 0 };
+#define setjobctl(on) do {} while (0)
 #else
+static smallint jobctl;              /* true if doing job control */
 static void setjobctl(int);
-static void showjobs(FILE *, int);
-#endif
-
-/*      main.h        */
-
-
-/* pid of main shell */
-static int rootpid;
-/* shell level: 0 for the main shell, 1 for its children, and so on */
-static int shlvl;
-#define rootshell (!shlvl)
-
-static void readcmdfile(char *);
-static int cmdloop(int);
-
-/*      memalloc.h        */
-
-
-struct stackmark {
-    struct stack_block *stackp;
-    char *stacknxt;
-    size_t stacknleft;
-    struct stackmark *marknext;
-};
-
-/* minimum size of a block */
-#define MINSIZE SHELL_ALIGN(504)
-
-struct stack_block {
-    struct stack_block *prev;
-    char space[MINSIZE];
-};
-
-static struct stack_block stackbase;
-static struct stack_block *stackp = &stackbase;
-static struct stackmark *markp;
-static char *stacknxt = stackbase.space;
-static size_t stacknleft = MINSIZE;
-static char *sstrend = stackbase.space + MINSIZE;
-static int herefd = -1;
-
-
-static pointer ckmalloc(size_t);
-static pointer ckrealloc(pointer, size_t);
-static char *savestr(const char *);
-static pointer stalloc(size_t);
-static void stunalloc(pointer);
-static void setstackmark(struct stackmark *);
-static void popstackmark(struct stackmark *);
-static void growstackblock(void);
-static void *growstackstr(void);
-static char *makestrspace(size_t, char *);
-static char *stnputs(const char *, size_t, char *);
-static char *stputs(const char *, char *);
-
-
-static inline char *_STPUTC(int c, char *p) {
-    if (p == sstrend)
-        p = growstackstr();
-    *p++ = c;
-    return p;
-}
-
-#define stackblock() ((void *)stacknxt)
-#define stackblocksize() stacknleft
-#define STARTSTACKSTR(p) ((p) = stackblock())
-#define STPUTC(c, p) ((p) = _STPUTC((c), (p)))
-#define CHECKSTRSPACE(n, p) \
-    ({ \
-        char *q = (p); \
-        size_t l = (n); \
-        size_t m = sstrend - q; \
-        if (l > m) \
-            (p) = makestrspace(l, q); \
-        0; \
-    })
-#define USTPUTC(c, p)   (*p++ = (c))
-#define STACKSTRNUL(p)  ((p) == sstrend? (p = growstackstr(), *p = '\0') : (*p = '\0'))
-#define STUNPUTC(p)     (--p)
-#define STTOPC(p)       p[-1]
-#define STADJUST(amount, p)     (p += (amount))
-
-#define grabstackstr(p) stalloc((char *)(p) - (char *)stackblock())
-#define ungrabstackstr(s, p) stunalloc((s))
-#define stackstrend() ((void *)sstrend)
-
-#define ckfree(p)       free((pointer)(p))
-
-/*      mystring.h   */
-
-
-#define DOLATSTRLEN 4
-
-static char *prefix(const char *, const char *);
-static int number(const char *);
-static int is_number(const char *);
-static char *single_quote(const char *);
-static char *sstrdup(const char *);
-
-#define equal(s1, s2)   (strcmp(s1, s2) == 0)
-#define scopy(s1, s2)   ((void)strcpy(s2, s1))
-
-/*      options.h */
-
-struct shparam {
-    int nparam;             /* # of positional parameters (without $0) */
-    unsigned char malloc;   /* if parameter list dynamically allocated */
-    char **p;               /* parameter list */
-#ifdef CONFIG_ASH_GETOPTS
-    int optind;             /* next parameter to be processed by getopts */
-    int optoff;             /* used by getopts */
-#endif
-};
-
-
-#define eflag optlist[0]
-#define fflag optlist[1]
-#define Iflag optlist[2]
-#define iflag optlist[3]
-#define mflag optlist[4]
-#define nflag optlist[5]
-#define sflag optlist[6]
-#define xflag optlist[7]
-#define vflag optlist[8]
-#define Cflag optlist[9]
-#define aflag optlist[10]
-#define bflag optlist[11]
-#define uflag optlist[12]
-#define viflag optlist[13]
-
-#ifdef DEBUG
-#define nolog optlist[14]
-#define debug optlist[15]
-#endif
-
-#ifndef CONFIG_FEATURE_COMMAND_EDITING_VI
-#define setvimode(on) viflag = 0   /* forcibly keep the option off */
-#endif
-
-/*      options.c */
-
-
-static const char *const optletters_optnames[] = {
-    "e"   "errexit",
-    "f"   "noglob",
-    "I"   "ignoreeof",
-    "i"   "interactive",
-    "m"   "monitor",
-    "n"   "noexec",
-    "s"   "stdin",
-    "x"   "xtrace",
-    "v"   "verbose",
-    "C"   "noclobber",
-    "a"   "allexport",
-    "b"   "notify",
-    "u"   "nounset",
-    "\0"  "vi",
-#ifdef DEBUG
-    "\0"  "nolog",
-    "\0"  "debug",
-#endif
-};
-
-#define optletters(n) optletters_optnames[(n)][0]
-#define optnames(n) (&optletters_optnames[(n)][1])
-
-#define NOPTS (sizeof(optletters_optnames)/sizeof(optletters_optnames[0]))
-
-static char optlist[NOPTS];
-
-
-static char *arg0;                     /* value of $0 */
-static struct shparam shellparam;      /* $@ current positional parameters */
-static char **argptr;                  /* argument list for builtin commands */
-static char *optionarg;                /* set by nextopt (like getopt) */
-static char *optptr;                   /* used by nextopt */
-
-static char *minusc;                   /* argument to -c option */
-
-
-static void procargs(int, char **);
-static void optschanged(void);
-static void setparam(char **);
-static void freeparam(volatile struct shparam *);
-static int shiftcmd(int, char **);
-static int setcmd(int, char **);
-static int nextopt(const char *);
-
-/*      redir.h      */
-
-/* flags passed to redirect */
-#define REDIR_PUSH 01           /* save previous values of file descriptors */
-#define REDIR_SAVEFD2 03       /* set preverrout */
-
-union node;
-static void redirect(union node *, int);
-static void popredir(int);
-static void clearredir(int);
-static int copyfd(int, int);
-static int redirectsafe(union node *, int);
-
-/*      show.h     */
-
-
-#ifdef DEBUG
-static void showtree(union node *);
-static void trace(const char *, ...);
-static void tracev(const char *, va_list);
-static void trargs(char **);
-static void trputc(int);
-static void trputs(const char *);
-static void opentrace(void);
-#endif
-
-/*      trap.h       */
-
-
-/* trap handler commands */
-static char *trap[NSIG];
-/* current value of signal */
-static char sigmode[NSIG - 1];
-/* indicates specified signal received */
-static char gotsig[NSIG - 1];
-
-static void clear_traps(void);
-static void setsignal(int);
-static void ignoresig(int);
-static void onsig(int);
-static int dotrap(void);
-static void setinteractive(int);
-static void exitshell(void) ATTRIBUTE_NORETURN;
-static int decode_signal(const char *, int);
-
-/*
- * This routine is called when an error or an interrupt occurs in an
- * interactive shell and control is returned to the main command loop.
- */
-
-static void
-reset(void)
-{
-      /* from eval.c: */
-      {
-          evalskip = 0;
-          loopnest = 0;
-      }
-
-      /* from input.c: */
-      {
-          parselleft = parsenleft = 0;      /* clear input buffer */
-          popallfiles();
-      }
-
-      /* from parser.c: */
-      {
-          tokpushback = 0;
-          checkkwd = 0;
-      }
-
-      /* from redir.c: */
-      {
-          clearredir(0);
-      }
-
-}
-
-#ifdef CONFIG_ASH_ALIAS
-static struct alias *atab[ATABSIZE];
-
-static void setalias(const char *, const char *);
-static struct alias *freealias(struct alias *);
-static struct alias **__lookupalias(const char *);
-
-static void
-setalias(const char *name, const char *val)
-{
-    struct alias *ap, **app;
-
-    app = __lookupalias(name);
-    ap = *app;
-    INTOFF;
-    if (ap) {
-        if (!(ap->flag & ALIASINUSE)) {
-            ckfree(ap->val);
-        }
-        ap->val = savestr(val);
-        ap->flag &= ~ALIASDEAD;
-    } else {
-        /* not found */
-        ap = ckmalloc(sizeof (struct alias));
-        ap->name = savestr(name);
-        ap->val = savestr(val);
-        ap->flag = 0;
-        ap->next = 0;
-        *app = ap;
-    }
-    INTON;
-}
-
-static int
-unalias(const char *name)
-{
-    struct alias **app;
-
-    app = __lookupalias(name);
-
-    if (*app) {
-        INTOFF;
-        *app = freealias(*app);
-        INTON;
-        return (0);
-    }
-
-    return (1);
-}
-
-static void
-rmaliases(void)
-{
-    struct alias *ap, **app;
-    int i;
-
-    INTOFF;
-    for (i = 0; i < ATABSIZE; i++) {
-        app = &atab[i];
-        for (ap = *app; ap; ap = *app) {
-            *app = freealias(*app);
-            if (ap == *app) {
-                app = &ap->next;
-            }
-        }
-    }
-    INTON;
-}
-
-static struct alias *
-lookupalias(const char *name, int check)
-{
-    struct alias *ap = *__lookupalias(name);
-
-    if (check && ap && (ap->flag & ALIASINUSE))
-        return (NULL);
-    return (ap);
-}
-
-/*
- * TODO - sort output
- */
-static int
-aliascmd(int argc, char **argv)
-{
-    char *n, *v;
-    int ret = 0;
-    struct alias *ap;
-
-    if (argc == 1) {
-        int i;
-
-        for (i = 0; i < ATABSIZE; i++)
-            for (ap = atab[i]; ap; ap = ap->next) {
-                printalias(ap);
-            }
-        return (0);
-    }
-    while ((n = *++argv) != NULL) {
-        if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
-            if ((ap = *__lookupalias(n)) == NULL) {
-                fprintf(stderr, "%s: %s not found\n", "alias", n);
-                ret = 1;
+#endif
+
+/*
+ * Set the signal handler for the specified signal.  The routine figures
+ * out what it should be set to.
+ */
+static void
+setsignal(int signo)
+{
+    int action;
+    char *t, tsig;
+    struct sigaction act;
+
+    t = trap[signo];
+    if (t == NULL)
+        action = S_DFL;
+    else if (*t != '\0')
+        action = S_CATCH;
+    else
+        action = S_IGN;
+    if (rootshell && action == S_DFL) {
+        switch (signo) {
+        case SIGINT:
+            if (iflag || minusc || sflag == 0)
+                action = S_CATCH;
+            break;
+        case SIGQUIT:
+#if DEBUG
+            if (debug)
+                break;
+#endif
+            /* FALLTHROUGH */
+        case SIGTERM:
+            if (iflag)
+                action = S_IGN;
+            break;
+#if JOBS
+        case SIGTSTP:
+        case SIGTTOU:
+            if (mflag)
+                action = S_IGN;
+            break;
+#endif
+        }
+    }
+
+    t = &sigmode[signo - 1];
+    tsig = *t;
+    if (tsig == 0) {
+        /*
+         * current setting unknown
+         */
+        if (sigaction(signo, 0, &act) == -1) {
+            /*
+             * Pretend it worked; maybe we should give a warning
+             * here, but other shells don't. We don't alter
+             * sigmode, so that we retry every time.
+             */
+            return;
+        }
+        if (act.sa_handler == SIG_IGN) {
+            if (mflag
+             && (signo == SIGTSTP || signo == SIGTTIN || signo == SIGTTOU)
+            ) {
+                tsig = S_IGN;   /* don't hard ignore these */
             } else
-                printalias(ap);
+                tsig = S_HARD_IGN;
         } else {
-            *v++ = '\0';
-            setalias(n, v);
-        }
-    }
-
-    return (ret);
-}
-
-static int
-unaliascmd(int argc, char **argv)
-{
-    int i;
-
-    while ((i = nextopt("a")) != '\0') {
-        if (i == 'a') {
-            rmaliases();
-            return (0);
-        }
-    }
-    for (i = 0; *argptr; argptr++) {
-        if (unalias(*argptr)) {
-            fprintf(stderr, "%s: %s not found\n", "unalias", *argptr);
-            i = 1;
-        }
-    }
-
-    return (i);
-}
-
-static struct alias *
-freealias(struct alias *ap) {
-    struct alias *next;
-
-    if (ap->flag & ALIASINUSE) {
-        ap->flag |= ALIASDEAD;
-        return ap;
-    }
-
-    next = ap->next;
-    ckfree(ap->name);
-    ckfree(ap->val);
-    ckfree(ap);
-    return next;
-}
-
-static void
-printalias(const struct alias *ap) {
-    out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
-}
-
-static struct alias **
-__lookupalias(const char *name) {
-    unsigned int hashval;
-    struct alias **app;
-    const char *p;
-    unsigned int ch;
-
-    p = name;
-
-    ch = (unsigned char)*p;
-    hashval = ch << 4;
-    while (ch) {
-        hashval += ch;
-        ch = (unsigned char)*++p;
-    }
-    app = &atab[hashval % ATABSIZE];
-
-    for (; *app; app = &(*app)->next) {
-        if (equal(name, (*app)->name)) {
-            break;
-        }
-    }
-
-    return app;
-}
-#endif /* CONFIG_ASH_ALIAS */
-
-
-/*      cd.c      */
-
-/*
- * The cd and pwd commands.
- */
-
-#define CD_PHYSICAL 1
-#define CD_PRINT 2
-
-static int docd(const char *, int);
-static int cdopt(void);
-
-static char *curdir = nullstr;          /* current working directory */
-static char *physdir = nullstr;         /* physical working directory */
-
-static int
-cdopt(void)
-{
-    int flags = 0;
-    int i, j;
-
-    j = 'L';
-    while ((i = nextopt("LP"))) {
-        if (i != j) {
-            flags ^= CD_PHYSICAL;
-            j = i;
-        }
-    }
-
-    return flags;
-}
-
-static int
-cdcmd(int argc, char **argv)
-{
-    const char *dest;
-    const char *path;
-    const char *p;
-    char c;
-    struct stat statb;
-    int flags;
-
-    flags = cdopt();
-    dest = *argptr;
-    if (!dest)
-        dest = bltinlookup(homestr);
-    else if (dest[0] == '-' && dest[1] == '\0') {
-        dest = bltinlookup("OLDPWD");
-        flags |= CD_PRINT;
-    }
-    if (!dest)
-        dest = nullstr;
-    if (*dest == '/')
-        goto step7;
-    if (*dest == '.') {
-        c = dest[1];
-dotdot:
-        switch (c) {
-        case '\0':
-        case '/':
-            goto step6;
-        case '.':
-            c = dest[2];
-            if (c != '.')
-                goto dotdot;
-        }
-    }
-    if (!*dest)
-        dest = ".";
-    if (!(path = bltinlookup("CDPATH"))) {
-step6:
-step7:
-        p = dest;
-        goto docd;
-    }
-    do {
-        c = *path;
-        p = padvance(&path, dest);
-        if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
-            if (c && c != ':')
-                flags |= CD_PRINT;
-docd:
-            if (!docd(p, flags))
-                goto out;
-            break;
-        }
-    } while (path);
-    sh_error("can't cd to %s", dest);
-    /* NOTREACHED */
-out:
-    if (flags & CD_PRINT)
-        out1fmt(snlfmt, curdir);
-    return 0;
-}
-
-
-/*
- * Update curdir (the name of the current directory) in response to a
- * cd command.
- */
-
-static inline const char *
-updatepwd(const char *dir)
-{
-    char *new;
-    char *p;
-    char *cdcomppath;
-    const char *lim;
-
-    cdcomppath = sstrdup(dir);
-    STARTSTACKSTR(new);
-    if (*dir != '/') {
-        if (curdir == nullstr)
-            return 0;
-        new = stputs(curdir, new);
-    }
-    new = makestrspace(strlen(dir) + 2, new);
-    lim = stackblock() + 1;
-    if (*dir != '/') {
-        if (new[-1] != '/')
-            USTPUTC('/', new);
-        if (new > lim && *lim == '/')
-            lim++;
-    } else {
-        USTPUTC('/', new);
-        cdcomppath++;
-        if (dir[1] == '/' && dir[2] != '/') {
-            USTPUTC('/', new);
-            cdcomppath++;
-            lim++;
-        }
-    }
-    p = strtok(cdcomppath, "/");
-    while (p) {
-        switch(*p) {
-        case '.':
-            if (p[1] == '.' && p[2] == '\0') {
-                while (new > lim) {
-                    STUNPUTC(new);
-                    if (new[-1] == '/')
-                        break;
-                }
-                break;
-            } else if (p[1] == '\0')
-                break;
-            /* fall through */
-        default:
-            new = stputs(p, new);
-            USTPUTC('/', new);
-        }
-        p = strtok(0, "/");
-    }
-    if (new > lim)
-        STUNPUTC(new);
-    *new = 0;
-    return stackblock();
-}
-
-/*
- * Actually do the chdir.  We also call hashcd to let the routines in exec.c
- * know that the current directory has changed.
- */
-
-static int
-docd(const char *dest, int flags)
-{
-    const char *dir = 0;
-    int err;
-
-    TRACE(("docd(\"%s\", %d) called\n", dest, flags));
-
-    INTOFF;
-    if (!(flags & CD_PHYSICAL)) {
-        dir = updatepwd(dest);
-        if (dir)
-            dest = dir;
-    }
-    err = chdir(dest);
-    if (err)
-        goto out;
-    setpwd(dir, 1);
-    hashcd();
-out:
-    INTON;
-    return err;
-}
-
-/*
- * Find out what the current directory is. If we already know the current
- * directory, this routine returns immediately.
- */
-static inline char *
-getpwd(void)
-{
-    char *dir = getcwd(0, 0);
-    return dir ? dir : nullstr;
-}
-
-static int
-pwdcmd(int argc, char **argv)
-{
-    int flags;
-    const char *dir = curdir;
-
-    flags = cdopt();
-    if (flags) {
-        if (physdir == nullstr)
-            setpwd(dir, 0);
-        dir = physdir;
-    }
-    out1fmt(snlfmt, dir);
-    return 0;
-}
-
-static void
-setpwd(const char *val, int setold)
-{
-    char *oldcur, *dir;
-
-    oldcur = dir = curdir;
-
-    if (setold) {
-        setvar("OLDPWD", oldcur, VEXPORT);
-    }
-    INTOFF;
-    if (physdir != nullstr) {
-        if (physdir != oldcur)
-            free(physdir);
-        physdir = nullstr;
-    }
-    if (oldcur == val || !val) {
-        char *s = getpwd();
-        physdir = s;
-        if (!val)
-            dir = s;
-    } else
-        dir = savestr(val);
-    if (oldcur != dir && oldcur != nullstr) {
-        free(oldcur);
-    }
-    curdir = dir;
-    INTON;
-    setvar("PWD", dir, VEXPORT);
-}
-
-/*      error.c   */
-
-/*
- * Errors and exceptions.
- */
-
-/*
- * Code to handle exceptions in C.
- */
-
-
-
-static void exverror(int, const char *, va_list)
-    ATTRIBUTE_NORETURN;
-
-/*
- * Called to raise an exception.  Since C doesn't include exceptions, we
- * just do a longjmp to the exception handler.  The type of exception is
- * stored in the global variable "exception".
- */
-
-static void
-exraise(int e)
-{
-#ifdef DEBUG
-    if (handler == NULL)
-        abort();
-#endif
-    INTOFF;
-
-    exception = e;
-    longjmp(handler->loc, 1);
-}
-
-
-/*
- * Called from trap.c when a SIGINT is received.  (If the user specifies
- * that SIGINT is to be trapped or ignored using the trap builtin, then
- * this routine is not called.)  Suppressint is nonzero when interrupts
- * are held using the INTOFF macro.  (The test for iflag is just
- * defensive programming.)
- */
-
-static void
-onint(void) {
-    int i;
-
-    intpending = 0;
-#if 0
-    /* comment by vodz: its strange for me, this programm don`t use other
-       signal block */
-    sigsetmask(0);
-#endif
-    i = EXSIG;
-    if (gotsig[SIGINT - 1] && !trap[SIGINT]) {
-        if (!(rootshell && iflag)) {
-            signal(SIGINT, SIG_DFL);
-            raise(SIGINT);
-        }
-        i = EXINT;
-    }
-    exraise(i);
-    /* NOTREACHED */
-}
-
-static void
-exvwarning(const char *msg, va_list ap)
-{
-     FILE *errs;
-
-     errs = stderr;
-     fprintf(errs, "%s: ", arg0);
-     if (commandname) {
-         const char *fmt = (!iflag || parsefile->fd) ?
-                    "%s: %d: " : "%s: ";
-         fprintf(errs, fmt, commandname, startlinno);
-     }
-     vfprintf(errs, msg, ap);
-     outcslow('\n', errs);
-}
-
-/*
- * Exverror is called to raise the error exception.  If the second argument
- * is not NULL then error prints an error message using printf style
- * formatting.  It then raises the error exception.
- */
-static void
-exverror(int cond, const char *msg, va_list ap)
-{
-#ifdef DEBUG
-    if (msg) {
-        TRACE(("exverror(%d, \"", cond));
-        TRACEV((msg, ap));
-        TRACE(("\") pid=%d\n", getpid()));
-    } else
-        TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
-    if (msg)
-#endif
-        exvwarning(msg, ap);
-
-    flushall();
-    exraise(cond);
-    /* NOTREACHED */
-}
-
-
-static void
-sh_error(const char *msg, ...)
-{
-    va_list ap;
-
-    va_start(ap, msg);
-    exverror(EXERROR, msg, ap);
-    /* NOTREACHED */
-    va_end(ap);
-}
-
-
-static void
-exerror(int cond, const char *msg, ...)
-{
-    va_list ap;
-
-    va_start(ap, msg);
-    exverror(cond, msg, ap);
-    /* NOTREACHED */
-    va_end(ap);
-}
-
-/*
- * error/warning routines for external builtins
- */
-
-static void
-sh_warnx(const char *fmt, ...)
-{
-    va_list ap;
-
-    va_start(ap, fmt);
-    exvwarning(fmt, ap);
-    va_end(ap);
-}
-
-
-/*
- * Return a string describing an error.  The returned string may be a
- * pointer to a static buffer that will be overwritten on the next call.
- * Action describes the operation that got the error.
- */
-
-static const char *
-errmsg(int e, const char *em)
-{
-    if(e == ENOENT || e == ENOTDIR) {
-
-        return em;
-    }
-    return strerror(e);
-}
-
-
-/*      eval.c  */
-
-/*
- * Evaluate a command.
- */
-
-/* flags in argument to evaltree */
-#define EV_EXIT 01              /* exit after evaluating tree */
-#define EV_TESTED 02            /* exit status is checked; ignore -e flag */
-#define EV_BACKCMD 04           /* command executing within back quotes */
-
-
-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 evalpipe(union node *, int);
-static void evalcommand(union node *, int);
-static int evalbltin(const struct builtincmd *, int, char **);
-static int evalfun(struct funcnode *, int, char **, int);
-static void prehash(union node *);
-static int bltincmd(int, char **);
-
-
-static const struct builtincmd bltin = {
-    "\0\0", bltincmd
-};
-
-
-/*
- * Called to reset things after an exception.
- */
-
-/*
- * The eval command.
- */
-
-static 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 (;;) {
-                concat = stputs(p, concat);
-                if ((p = *ap++) == NULL)
-                    break;
-                STPUTC(' ', concat);
-            }
-            STPUTC('\0', concat);
-            p = grabstackstr(concat);
-        }
-        evalstring(p, ~SKIPEVAL);
-
-    }
-    return exitstatus;
-}
-
-
-/*
- * Execute a command or commands contained in a string.
- */
-
-static int
-evalstring(char *s, int mask)
-{
-    union node *n;
-    struct stackmark smark;
-    int skip;
-
-    setinputstring(s);
-    setstackmark(&smark);
-
-    skip = 0;
-    while ((n = parsecmd(0)) != NEOF) {
-        evaltree(n, 0);
-        popstackmark(&smark);
-        skip = evalskip;
-        if (skip)
-            break;
-    }
-    popfile();
-
-    skip &= mask;
-    evalskip = skip;
-    return skip;
-}
-
-
-
-/*
- * Evaluate a parse tree.  The value is left in the global variable
- * exitstatus.
- */
-
-static void
-evaltree(union node *n, int flags)
-{
-    int checkexit = 0;
-    void (*evalfn)(union node *, int);
-    unsigned isor;
-    int status;
-    if (n == NULL) {
-        TRACE(("evaltree(NULL) called\n"));
-        goto out;
-    }
-    TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
-        getpid(), n, n->type, flags));
-    switch (n->type) {
-    default:
-#ifdef DEBUG
-        out1fmt("Node type = %d\n", n->type);
-        fflush(stdout);
+            tsig = S_RESET; /* force to be set */
+        }
+    }
+    if (tsig == S_HARD_IGN || tsig == action)
+        return;
+    switch (action) {
+    case S_CATCH:
+        act.sa_handler = onsig;
         break;
-#endif
-    case NNOT:
-        evaltree(n->nnot.com, EV_TESTED);
-        status = !exitstatus;
-        goto setstatus;
-    case NREDIR:
-        expredir(n->nredir.redirect);
-        status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
-        if (!status) {
-            evaltree(n->nredir.n, flags & EV_TESTED);
-            status = exitstatus;
-        }
-        popredir(0);
-        goto setstatus;
-    case NCMD:
-        evalfn = evalcommand;
-checkexit:
-        if (eflag && !(flags & EV_TESTED))
-            checkexit = ~0;
-        goto calleval;
-    case NFOR:
-        evalfn = evalfor;
-        goto calleval;
-    case NWHILE:
-    case NUNTIL:
-        evalfn = evalloop;
-        goto calleval;
-    case NSUBSHELL:
-    case NBACKGND:
-        evalfn = evalsubshell;
-        goto calleval;
-    case NPIPE:
-        evalfn = evalpipe;
-        goto checkexit;
-    case NCASE:
-        evalfn = evalcase;
-        goto calleval;
-    case NAND:
-    case NOR:
-    case NSEMI:
-#if NAND + 1 != NOR
-#error NAND + 1 != NOR
-#endif
-#if NOR + 1 != NSEMI
-#error NOR + 1 != NSEMI
-#endif
-        isor = n->type - NAND;
-        evaltree(
-            n->nbinary.ch1,
-            (flags | ((isor >> 1) - 1)) & EV_TESTED
-        );
-        if (!exitstatus == isor)
-            break;
-        if (!evalskip) {
-            n = n->nbinary.ch2;
-evaln:
-            evalfn = evaltree;
-calleval:
-            evalfn(n, flags);
-            break;
-        }
-        break;
-    case NIF:
-        evaltree(n->nif.test, EV_TESTED);
-        if (evalskip)
-            break;
-        if (exitstatus == 0) {
-            n = n->nif.ifpart;
-            goto evaln;
-        } else if (n->nif.elsepart) {
-            n = n->nif.elsepart;
-            goto evaln;
-        }
-        goto success;
-    case NDEFUN:
-        defun(n->narg.text, n->narg.next);
-success:
-        status = 0;
-setstatus:
-        exitstatus = status;
-        break;
-    }
-out:
-    if ((checkexit & exitstatus))
-        evalskip |= SKIPEVAL;
-    else if (pendingsigs && dotrap())
-        goto exexit;
-
-    if (flags & EV_EXIT) {
-exexit:
-        exraise(EXEXIT);
-    }
-}
-
-
-#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
-static
-#endif
-void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__));
-
-
-static void
-evalloop(union node *n, int flags)
-{
-    int status;
-
-    loopnest++;
-    status = 0;
-    flags &= EV_TESTED;
-    for (;;) {
-        int i;
-
-        evaltree(n->nbinary.ch1, EV_TESTED);
-        if (evalskip) {
-skipping:         if (evalskip == SKIPCONT && --skipcount <= 0) {
-                evalskip = 0;
-                continue;
-            }
-            if (evalskip == SKIPBREAK && --skipcount <= 0)
-                evalskip = 0;
-            break;
-        }
-        i = exitstatus;
-        if (n->type != NWHILE)
-            i = !i;
-        if (i != 0)
-            break;
-        evaltree(n->nbinary.ch2, flags);
-        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;
-
-    setstackmark(&smark);
-    arglist.lastp = &arglist.list;
-    for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
-        expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
-        /* XXX */
-        if (evalskip)
-            goto out;
-    }
-    *arglist.lastp = NULL;
-
-    exitstatus = 0;
-    loopnest++;
-    flags &= EV_TESTED;
-    for (sp = arglist.list ; sp ; sp = sp->next) {
-        setvar(n->nfor.var, sp->text, 0);
-        evaltree(n->nfor.body, flags);
-        if (evalskip) {
-            if (evalskip == SKIPCONT && --skipcount <= 0) {
-                evalskip = 0;
-                continue;
-            }
-            if (evalskip == SKIPBREAK && --skipcount <= 0)
-                evalskip = 0;
-            break;
-        }
-    }
-    loopnest--;
-out:
-    popstackmark(&smark);
-}
-
-
-
-static void
-evalcase(union node *n, int flags)
-{
-    union node *cp;
-    union node *patp;
-    struct arglist arglist;
-    struct stackmark smark;
-
-    setstackmark(&smark);
-    arglist.lastp = &arglist.list;
-    expandarg(n->ncase.expr, &arglist, EXP_TILDE);
-    exitstatus = 0;
-    for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
-        for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
-            if (casematch(patp, arglist.list->text)) {
-                if (evalskip == 0) {
-                    evaltree(cp->nclist.body, flags);
-                }
-                goto out;
-            }
-        }
-    }
-out:
-    popstackmark(&smark);
-}
-
-
-
-/*
- * Kick off a subshell to evaluate a tree.
- */
-
-static void
-evalsubshell(union node *n, int flags)
-{
-    struct job *jp;
-    int backgnd = (n->type == NBACKGND);
-    int status;
-
-    expredir(n->nredir.redirect);
-    if (!backgnd && flags & EV_EXIT && !trap[0])
-        goto nofork;
-    INTOFF;
-    jp = makejob(n, 1);
-    if (forkshell(jp, n, backgnd) == 0) {
-        INTON;
-        flags |= EV_EXIT;
-        if (backgnd)
-            flags &=~ EV_TESTED;
-nofork:
-        redirect(n->nredir.redirect, 0);
-        evaltreenr(n->nredir.n, flags);
-        /* never returns */
-    }
-    status = 0;
-    if (! backgnd)
-        status = waitforjob(jp);
-    exitstatus = status;
-    INTON;
-}
-
-
-
-/*
- * 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_FULL | EXP_TILDE);
-                fixredir(redir, fn.list->text, 1);
-            }
-            break;
-        }
-    }
-}
-
-
-
-/*
- * 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, int flags)
-{
-    struct job *jp;
-    struct nodelist *lp;
-    int pipelen;
-    int prevfd;
-    int pip[2];
-
-    TRACE(("evalpipe(0x%lx) called\n", (long)n));
-    pipelen = 0;
-    for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
-        pipelen++;
-    flags |= EV_EXIT;
-    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 (pipe(pip) < 0) {
-                close(prevfd);
-                sh_error("Pipe call failed");
-            }
-        }
-        if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
-            INTON;
-            if (pip[1] >= 0) {
-                close(pip[0]);
-            }
-            if (prevfd > 0) {
-                dup2(prevfd, 0);
-                close(prevfd);
-            }
-            if (pip[1] > 1) {
-                dup2(pip[1], 1);
-                close(pip[1]);
-            }
-            evaltreenr(lp->n, flags);
-            /* never returns */
-        }
-        if (prevfd >= 0)
-            close(prevfd);
-        prevfd = pip[0];
-        close(pip[1]);
-    }
-    if (n->npipe.backgnd == 0) {
-        exitstatus = waitforjob(jp);
-        TRACE(("evalpipe:  job done exit status %d\n", exitstatus));
-    }
-    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.
- */
-
-static void
-evalbackcmd(union node *n, struct backcmd *result)
-{
-    int saveherefd;
-
-    result->fd = -1;
-    result->buf = NULL;
-    result->nleft = 0;
-    result->jp = NULL;
-    if (n == NULL) {
-        goto out;
-    }
-
-    saveherefd = herefd;
-    herefd = -1;
-
-    {
-        int pip[2];
-        struct job *jp;
-
-        if (pipe(pip) < 0)
-            sh_error("Pipe call failed");
-        jp = makejob(n, 1);
-        if (forkshell(jp, n, FORK_NOJOB) == 0) {
-            FORCEINTON;
-            close(pip[0]);
-            if (pip[1] != 1) {
-                close(1);
-                copyfd(pip[1], 1);
-                close(pip[1]);
-            }
-            eflag = 0;
-            evaltreenr(n, EV_EXIT);
-            /* NOTREACHED */
-        }
-        close(pip[1]);
-        result->fd = pip[0];
-        result->jp = jp;
-    }
-    herefd = saveherefd;
-out:
-    TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
-        result->fd, result->buf, result->nleft, result->jp));
-}
-
-#ifdef CONFIG_ASH_CMDCMD
-static inline char **
-parse_command_args(char **argv, const char **path)
-{
-    char *cp, c;
-
-    for (;;) {
-        cp = *++argv;
-        if (!cp)
-            return 0;
-        if (*cp++ != '-')
-            break;
-        if (!(c = *cp++))
-            break;
-        if (c == '-' && !*cp) {
-            argv++;
-            break;
-        }
-        do {
-            switch (c) {
-            case 'p':
-                *path = defpath;
-                break;
-            default:
-                /* run 'typecmd' for other options */
-                return 0;
-            }
-        } while ((c = *cp++));
-    }
-    return argv;
-}
-#endif
-
-static inline int
-isassignment(const char *p)
-{
-    const char *q = endofname(p);
-    if (p == q)
-        return 0;
-    return *q == '=';
-}
-
-#ifdef CONFIG_ASH_EXPAND_PRMT
-static const char *expandstr(const char *ps);
-#else
-#define expandstr(s) s
-#endif
-
-/*
- * Execute a simple command.
- */
-
-static void
-evalcommand(union node *cmd, int flags)
-{
-    struct stackmark smark;
-    union node *argp;
-    struct arglist arglist;
-    struct arglist varlist;
-    char **argv;
-    int argc;
-    const struct strlist *sp;
-    struct cmdentry cmdentry;
-    struct job *jp;
-    char *lastarg;
-    const char *path;
-    int spclbltin;
-    int cmd_is_exec;
-    int status;
-    char **nargv;
-    struct builtincmd *bcmd;
-    int pseudovarflag = 0;
-
-    /* First expand the arguments. */
-    TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
-    setstackmark(&smark);
-    back_exitstatus = 0;
-
-    cmdentry.cmdtype = CMDBUILTIN;
-    cmdentry.u.cmd = &bltin;
-    varlist.lastp = &varlist.list;
-    *varlist.lastp = NULL;
-    arglist.lastp = &arglist.list;
-    *arglist.lastp = NULL;
-
-    argc = 0;
-    if (cmd->ncmd.args)
-    {
-        bcmd = find_builtin(cmd->ncmd.args->narg.text);
-        pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
-    }
-
-    for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
-        struct strlist **spp;
-
-        spp = arglist.lastp;
-        if (pseudovarflag && isassignment(argp->narg.text))
-            expandarg(argp, &arglist, EXP_VARTILDE);
-        else
-            expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
-
-        for (sp = *spp; sp; sp = sp->next)
-            argc++;
-    }
-
-    argv = nargv = stalloc(sizeof (char *) * (argc + 1));
-    for (sp = arglist.list ; sp ; sp = sp->next) {
-        TRACE(("evalcommand arg: %s\n", sp->text));
-        *nargv++ = sp->text;
-    }
-    *nargv = NULL;
-
-    lastarg = NULL;
-    if (iflag && funcnest == 0 && argc > 0)
-        lastarg = nargv[-1];
-
-    preverrout_fd = 2;
-    expredir(cmd->ncmd.redirect);
-    status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH|REDIR_SAVEFD2);
-
-    path = vpath.text;
-    for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
-        struct strlist **spp;
-        char *p;
-
-        spp = varlist.lastp;
-        expandarg(argp, &varlist, EXP_VARTILDE);
-
-        /*
-         * Modify the command lookup path, if a PATH= assignment
-         * is present
-         */
-        p = (*spp)->text;
-        if (varequal(p, path))
-            path = p;
-    }
-
-    /* Print the command if xflag is set. */
-    if (xflag) {
-        int n;
-        const char *p = " %s";
-
-        p++;
-        dprintf(preverrout_fd, p, expandstr(ps4val()));
-
-        sp = varlist.list;
-        for(n = 0; n < 2; n++) {
-            while (sp) {
-                dprintf(preverrout_fd, p, sp->text);
-                sp = sp->next;
-                if(*p == '%') {
-                    p--;
-                }
-            }
-            sp = arglist.list;
-        }
-        bb_full_write(preverrout_fd, "\n", 1);
-    }
-
-    cmd_is_exec = 0;
-    spclbltin = -1;
-
-    /* Now locate the command. */
-    if (argc) {
-        const char *oldpath;
-        int cmd_flag = DO_ERR;
-
-        path += 5;
-        oldpath = path;
-        for (;;) {
-            find_command(argv[0], &cmdentry, cmd_flag, path);
-            if (cmdentry.cmdtype == CMDUNKNOWN) {
-                status = 127;
-                flusherr();
-                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++;
-#ifdef CONFIG_ASH_CMDCMD
-            if (cmdentry.u.cmd == COMMANDCMD) {
-
-                path = oldpath;
-                nargv = parse_command_args(argv, &path);
-                if (!nargv)
-                    break;
-                argc -= nargv - argv;
-                argv = nargv;
-                cmd_flag |= DO_NOFUNC;
-            } else
-#endif
-                break;
-        }
-    }
-
-    if (status) {
-        /* We have a redirection error. */
-        if (spclbltin > 0)
-            exraise(EXERROR);
-bail:
-        exitstatus = status;
-        goto out;
-    }
-
-    /* Execute the command. */
-    switch (cmdentry.cmdtype) {
-    default:
-        /* Fork off a child process if necessary. */
-        if (!(flags & EV_EXIT) || trap[0]) {
-            INTOFF;
-            jp = makejob(cmd, 1);
-            if (forkshell(jp, cmd, FORK_FG) != 0) {
-                exitstatus = waitforjob(jp);
-                INTON;
-                break;
-            }
-            FORCEINTON;
-        }
-        listsetvar(varlist.list, VEXPORT|VSTACK);
-        shellexec(argv, path, cmdentry.u.index);
-        /* NOTREACHED */
-
-    case CMDBUILTIN:
-        cmdenviron = varlist.list;
-        if (cmdenviron) {
-            struct strlist *list = cmdenviron;
-            int i = VNOSET;
-            if (spclbltin > 0 || argc == 0) {
-                i = 0;
-                if (cmd_is_exec && argc > 1)
-                    i = VEXPORT;
-            }
-            listsetvar(list, i);
-        }
-        if (evalbltin(cmdentry.u.cmd, argc, argv)) {
-            int exit_status;
-            int i, j;
-
-            i = exception;
-            if (i == EXEXIT)
-                goto raise;
-
-            exit_status = 2;
-            j = 0;
-            if (i == EXINT)
-                j = SIGINT;
-            if (i == EXSIG)
-                j = pendingsigs;
-            if (j)
-                exit_status = j + 128;
-            exitstatus = exit_status;
-
-            if (i == EXINT || spclbltin > 0) {
-raise:
-                longjmp(handler->loc, 1);
-            }
-            FORCEINTON;
-        }
-        break;
-
-    case CMDFUNCTION:
-        listsetvar(varlist.list, 0);
-        if (evalfun(cmdentry.u.func, argc, argv, flags))
-            goto raise;
-        break;
-    }
-
-out:
-    popredir(cmd_is_exec);
-    if (lastarg)
-        /* dsl: I think this is intended to be used to support
-         * '_' in 'vi' command mode during line editing...
-         * However I implemented that within libedit itself.
-         */
-        setvar("_", lastarg, 0);
-    popstackmark(&smark);
-}
-
-static int
-evalbltin(const struct builtincmd *cmd, int argc, char **argv) {
-    char *volatile savecmdname;
-    struct jmploc *volatile savehandler;
-    struct jmploc jmploc;
-    int i;
-
-    savecmdname = commandname;
-    if ((i = setjmp(jmploc.loc)))
-        goto cmddone;
-    savehandler = handler;
-    handler = &jmploc;
-    commandname = argv[0];
-    argptr = argv + 1;
-    optptr = NULL;                  /* initialize nextopt */
-    exitstatus = (*cmd->builtin)(argc, argv);
-    flushall();
-cmddone:
-    exitstatus |= ferror(stdout);
-    clearerr(stdout);
-    commandname = savecmdname;
-    exsig = 0;
-    handler = savehandler;
-
-    return i;
-}
-
-static int
-evalfun(struct funcnode *func, int argc, char **argv, int flags)
-{
-    volatile struct shparam saveparam;
-    struct localvar *volatile savelocalvars;
-    struct jmploc *volatile savehandler;
-    struct jmploc jmploc;
-    int e;
-
-    saveparam = shellparam;
-    savelocalvars = localvars;
-    if ((e = setjmp(jmploc.loc))) {
-        goto funcdone;
-    }
-    INTOFF;
-    savehandler = handler;
-    handler = &jmploc;
-    localvars = NULL;
-    shellparam.malloc = 0;
-    func->count++;
-    funcnest++;
-    INTON;
-    shellparam.nparam = argc - 1;
-    shellparam.p = argv + 1;
-#ifdef CONFIG_ASH_GETOPTS
-    shellparam.optind = 1;
-    shellparam.optoff = -1;
-#endif
-    evaltree(&func->n, flags & EV_TESTED);
-funcdone:
-    INTOFF;
-    funcnest--;
-    freefunc(func);
-    poplocalvars();
-    localvars = savelocalvars;
-    freeparam(&shellparam);
-    shellparam = saveparam;
-    handler = savehandler;
-    INTON;
-    evalskip &= ~SKIPFUNC;
-    return e;
-}
-
-
-static inline int
-goodname(const char *p)
-{
-    return !*endofname(p);
-}
-
-/*
- * 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->type == NCMD && n->ncmd.args)
-        if (goodname(n->ncmd.args->narg.text))
-            find_command(n->ncmd.args->narg.text, &entry, 0,
-                     pathval());
-}
-
-
-
-/*
- * Builtin commands.  Builtin commands whose functions are closely
- * tied to evaluation are implemented here.
- */
-
-/*
- * No command given.
- */
-
-static 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.
- */
-
-static int
-breakcmd(int argc, char **argv)
-{
-    int n = argc > 1 ? number(argv[1]) : 1;
-
-    if (n <= 0)
-        sh_error(illnum, argv[1]);
-    if (n > loopnest)
-        n = loopnest;
-    if (n > 0) {
-        evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
-        skipcount = n;
-    }
-    return 0;
-}
-
-
-/*
- * The return command.
- */
-
-static int
-returncmd(int argc, char **argv)
-{
-    /*
-     * If called outside a function, do what ksh does;
-     * skip the rest of the file.
-     */
-    evalskip = funcnest ? SKIPFUNC : SKIPFILE;
-    return argv[1] ? number(argv[1]) : exitstatus;
-}
-
-
-static int
-falsecmd(int argc, char **argv)
-{
-    return 1;
-}
-
-
-static int
-truecmd(int argc, char **argv)
-{
-    return 0;
-}
-
-
-static int
-execcmd(int argc, char **argv)
-{
-    if (argc > 1) {
-        iflag = 0;              /* exit on error */
-        mflag = 0;
-        optschanged();
-        shellexec(argv + 1, pathval(), 0);
-    }
-    return 0;
-}
-
-
-/*      exec.c    */
-
-/*
- * When commands are first encountered, they are entered in a hash table.
- * This ensures that a full path search will not have to be done for them
- * on each invocation.
- *
- * We should investigate converting to a linear search, even though that
- * would make the command name "hash" a misnomer.
- */
-
-#define CMDTABLESIZE 31         /* should be prime */
-#define ARB 1                   /* actual size determined at run time */
-
-
-
-struct tblentry {
-    struct tblentry *next;  /* next entry in hash chain */
-    union param param;      /* definition of builtin function */
-    short cmdtype;          /* index identifying command */
-    char rehash;            /* if set, cd done since entry created */
-    char cmdname[ARB];      /* name of command */
-};
-
-
-static struct tblentry *cmdtable[CMDTABLESIZE];
-static int builtinloc = -1;             /* index in path of %builtin, or -1 */
-
-
-static void tryexec(char *, char **, char **);
-static void clearcmdentry(int);
-static struct tblentry *cmdlookup(const char *, int);
-static void delete_cmd_entry(void);
-
-
-/*
- * Exec a program.  Never returns.  If you change this routine, you may
- * have to change the find_command routine as well.
- */
-
-static void
-shellexec(char **argv, const char *path, int idx)
-{
-    char *cmdname;
-    int e;
-    char **envp;
-    int exerrno;
-
-    clearredir(1);
-    envp = environment();
-    if (strchr(argv[0], '/') != NULL
-#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
-        || find_applet_by_name(argv[0])
-#endif
-                        ) {
-        tryexec(argv[0], argv, envp);
-        e = errno;
-    } else {
-        e = ENOENT;
-        while ((cmdname = padvance(&path, argv[0])) != NULL) {
-            if (--idx < 0 && pathopt == NULL) {
-                tryexec(cmdname, argv, envp);
-                if (errno != ENOENT && errno != ENOTDIR)
-                    e = errno;
-            }
-            stunalloc(cmdname);
-        }
-    }
-
-    /* Map to POSIX errors */
-    switch (e) {
-    case EACCES:
-        exerrno = 126;
-        break;
-    case ENOENT:
-        exerrno = 127;
+    case S_IGN:
+        act.sa_handler = SIG_IGN;
         break;
     default:
-        exerrno = 2;
-        break;
-    }
-    exitstatus = exerrno;
-    TRACE(("shellexec failed for %s, errno %d, suppressint %d\n",
-        argv[0], e, suppressint ));
-    exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
-    /* NOTREACHED */
-}
-
-
-static void
-tryexec(char *cmd, char **argv, char **envp)
-{
-    int repeated = 0;
-#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
-    if(find_applet_by_name(cmd) != NULL) {
-        /* re-exec ourselves with the new arguments */
-        execve(CONFIG_BUSYBOX_EXEC_PATH,argv,envp);
-        /* If they called chroot or otherwise made the binary no longer
-         * executable, fall through */
-    }
-#endif
-
-repeat:
-#ifdef SYSV
-    do {
-        execve(cmd, argv, envp);
-    } while (errno == EINTR);
-#else
-    execve(cmd, argv, envp);
-#endif
-    if (repeated++) {
-        ckfree(argv);
-    } else if (errno == ENOEXEC) {
-        char **ap;
-        char **new;
-
-        for (ap = argv; *ap; ap++)
-            ;
-        ap = new = ckmalloc((ap - argv + 2) * sizeof(char *));
-        ap[1] = cmd;
-        *ap = cmd = (char *)DEFAULT_SHELL;
-        ap += 2;
-        argv++;
-        while ((*ap++ = *argv++))
-            ;
-        argv = new;
-        goto repeat;
-    }
-}
-
-
-
-/*
- * Do a path search.  The variable path (passed by reference) should be
- * set to the start of the path before the first call; padvance will update
- * this value as it proceeds.  Successive calls to padvance will return
- * the possible path expansions in sequence.  If an option (indicated by
- * a percent sign) appears in the path entry then the global variable
- * pathopt will be set to point to it; otherwise pathopt will be set to
- * NULL.
- */
-
-static char *
-padvance(const char **path, const char *name)
-{
-    const char *p;
-    char *q;
-    const char *start;
-    size_t len;
-
-    if (*path == NULL)
-        return NULL;
-    start = *path;
-    for (p = start ; *p && *p != ':' && *p != '%' ; p++);
-    len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
-    while (stackblocksize() < len)
-        growstackblock();
-    q = stackblock();
-    if (p != start) {
-        memcpy(q, start, p - start);
-        q += p - start;
-        *q++ = '/';
-    }
-    strcpy(q, name);
-    pathopt = NULL;
-    if (*p == '%') {
-        pathopt = ++p;
-        while (*p && *p != ':')  p++;
-    }
-    if (*p == ':')
-        *path = p + 1;
-    else
-        *path = NULL;
-    return stalloc(len);
-}
-
-
-/*** Command hashing code ***/
-
-static void
-printentry(struct tblentry *cmdp)
-{
-    int idx;
-    const char *path;
-    char *name;
-
-    idx = cmdp->param.index;
-    path = pathval();
-    do {
-        name = padvance(&path, cmdp->cmdname);
-        stunalloc(name);
-    } while (--idx >= 0);
-    out1fmt("%s%s\n", name, (cmdp->rehash ? "*" : nullstr));
-}
-
-
-static int
-hashcmd(int argc, char **argv)
-{
-    struct tblentry **pp;
-    struct tblentry *cmdp;
-    int c;
-    struct cmdentry entry;
-    char *name;
-
-    while ((c = nextopt("r")) != '\0') {
-        clearcmdentry(0);
-        return 0;
-    }
-    if (*argptr == NULL) {
-        for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
-            for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
-                if (cmdp->cmdtype == CMDNORMAL)
-                    printentry(cmdp);
-            }
-        }
-        return 0;
-    }
-    c = 0;
-    while ((name = *argptr) != NULL) {
-        if ((cmdp = cmdlookup(name, 0)) != NULL
-         && (cmdp->cmdtype == CMDNORMAL
-             || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
-            delete_cmd_entry();
-        find_command(name, &entry, DO_ERR, pathval());
-        if (entry.cmdtype == CMDUNKNOWN)
-            c = 1;
-        argptr++;
-    }
-    return c;
-}
-
-
-/*
- * Resolve a command name.  If you change this routine, you may have to
- * change the shellexec routine as well.
- */
-
-static void
-find_command(char *name, struct cmdentry *entry, int act, const char *path)
-{
-    struct tblentry *cmdp;
-    int idx;
-    int prev;
-    char *fullname;
-    struct stat statb;
-    int e;
-    int updatetbl;
-    struct builtincmd *bcmd;
-
-    /* If name contains a slash, don't use PATH or hash table */
-    if (strchr(name, '/') != NULL) {
-        entry->u.index = -1;
-        if (act & DO_ABS) {
-            while (stat(name, &statb) < 0) {
-#ifdef SYSV
-                if (errno == EINTR)
-                    continue;
-#endif
-                entry->cmdtype = CMDUNKNOWN;
-                return;
-            }
-        }
-        entry->cmdtype = CMDNORMAL;
-        return;
-    }
-
-#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
-    if (find_applet_by_name(name)) {
-        entry->cmdtype = CMDNORMAL;
-        entry->u.index = -1;
-        return;
-    }
-#endif
-
-    updatetbl = (path == pathval());
-    if (!updatetbl) {
-        act |= DO_ALTPATH;
-        if (strstr(path, "%builtin") != NULL)
-            act |= DO_ALTBLTIN;
-    }
-
-    /* If name is in the table, check answer will be ok */
-    if ((cmdp = cmdlookup(name, 0)) != NULL) {
-        int bit;
-
-        switch (cmdp->cmdtype) {
-        default:
-#if DEBUG
-            abort();
-#endif
-        case CMDNORMAL:
-            bit = DO_ALTPATH;
-            break;
-        case CMDFUNCTION:
-            bit = DO_NOFUNC;
-            break;
-        case CMDBUILTIN:
-            bit = DO_ALTBLTIN;
-            break;
-        }
-        if (act & bit) {
-            updatetbl = 0;
-            cmdp = NULL;
-        } else if (cmdp->rehash == 0)
-            /* if not invalidated by cd, we're done */
-            goto success;
-    }
-
-    /* If %builtin not in path, check for builtin next */
-    bcmd = find_builtin(name);
-    if (bcmd && (IS_BUILTIN_REGULAR(bcmd) || (
-        act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : builtinloc <= 0
-    )))
-        goto builtin_success;
-
-    /* We have to search path. */
-    prev = -1;              /* where to start */
-    if (cmdp && cmdp->rehash) {     /* doing a rehash */
-        if (cmdp->cmdtype == CMDBUILTIN)
-            prev = builtinloc;
-        else
-            prev = cmdp->param.index;
-    }
-
-    e = ENOENT;
-    idx = -1;
-loop:
-    while ((fullname = padvance(&path, name)) != NULL) {
-        stunalloc(fullname);
-        idx++;
-        if (pathopt) {
-            if (prefix(pathopt, "builtin")) {
-                if (bcmd)
-                    goto builtin_success;
-                continue;
-            } else if (!(act & DO_NOFUNC) &&
-                   prefix(pathopt, "func")) {
-                /* handled below */
-            } else {
-                /* ignore unimplemented options */
-                continue;
-            }
-        }
-        /* if rehash, don't redo absolute path names */
-        if (fullname[0] == '/' && idx <= prev) {
-            if (idx < prev)
-                continue;
-            TRACE(("searchexec \"%s\": no change\n", name));
-            goto success;
-        }
-        while (stat(fullname, &statb) < 0) {
-#ifdef SYSV
-            if (errno == EINTR)
-                continue;
-#endif
-            if (errno != ENOENT && errno != ENOTDIR)
-                e = errno;
-            goto loop;
-        }
-        e = EACCES;     /* if we fail, this will be the error */
-        if (!S_ISREG(statb.st_mode))
-            continue;
-        if (pathopt) {          /* this is a %func directory */
-            stalloc(strlen(fullname) + 1);
-            readcmdfile(fullname);
-            if ((cmdp = cmdlookup(name, 0)) == NULL ||
-                cmdp->cmdtype != CMDFUNCTION)
-                sh_error("%s not defined in %s", name, fullname);
-            stunalloc(fullname);
-            goto success;
-        }
-        TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
-        if (!updatetbl) {
-            entry->cmdtype = CMDNORMAL;
-            entry->u.index = idx;
-            return;
-        }
-        INTOFF;
-        cmdp = cmdlookup(name, 1);
-        cmdp->cmdtype = CMDNORMAL;
-        cmdp->param.index = idx;
-        INTON;
-        goto success;
-    }
-
-    /* We failed.  If there was an entry for this command, delete it */
-    if (cmdp && updatetbl)
-        delete_cmd_entry();
-    if (act & DO_ERR)
-        sh_warnx("%s: %s", name, errmsg(e, E_EXEC));
-    entry->cmdtype = CMDUNKNOWN;
-    return;
-
-builtin_success:
-    if (!updatetbl) {
-        entry->cmdtype = CMDBUILTIN;
-        entry->u.cmd = bcmd;
-        return;
-    }
-    INTOFF;
-    cmdp = cmdlookup(name, 1);
-    cmdp->cmdtype = CMDBUILTIN;
-    cmdp->param.cmd = bcmd;
-    INTON;
-success:
-    cmdp->rehash = 0;
-    entry->cmdtype = cmdp->cmdtype;
-    entry->u = cmdp->param;
-}
-
-
-/*
- * Wrapper around strcmp for qsort/bsearch/...
- */
-static int pstrcmp(const void *a, const void *b)
-{
-    return strcmp((const char *) a, (*(const char *const *) b) + 1);
-}
-
-/*
- * Search the table of builtin commands.
- */
-
-static struct builtincmd *
-find_builtin(const char *name)
-{
-    struct builtincmd *bp;
-
-    bp = bsearch(
-        name, builtincmd, NUMBUILTINS, sizeof(struct builtincmd),
-        pstrcmp
-    );
-    return bp;
-}
-
-
-
-/*
- * Called when a cd is done.  Marks all commands so the next time they
- * are executed they will be rehashed.
- */
-
-static void
-hashcd(void)
-{
-    struct tblentry **pp;
-    struct tblentry *cmdp;
-
-    for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
-        for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
-            if (cmdp->cmdtype == CMDNORMAL || (
-                cmdp->cmdtype == CMDBUILTIN &&
-                !(IS_BUILTIN_REGULAR(cmdp->param.cmd)) &&
-                builtinloc > 0
-            ))
-                cmdp->rehash = 1;
-        }
-    }
-}
-
-
-
-/*
- * Fix command hash table when PATH changed.
- * Called before PATH is changed.  The argument is the new value of PATH;
- * pathval() still returns the old value at this point.
- * Called with interrupts off.
- */
-
-static void
-changepath(const char *newval)
-{
-    const char *old, *new;
-    int idx;
-    int firstchange;
-    int idx_bltin;
-
-    old = pathval();
-    new = newval;
-    firstchange = 9999;     /* assume no change */
-    idx = 0;
-    idx_bltin = -1;
-    for (;;) {
-        if (*old != *new) {
-            firstchange = idx;
-            if ((*old == '\0' && *new == ':')
-             || (*old == ':' && *new == '\0'))
-                firstchange++;
-            old = new;      /* ignore subsequent differences */
-        }
-        if (*new == '\0')
-            break;
-        if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin"))
-            idx_bltin = idx;
-        if (*new == ':') {
-            idx++;
-        }
-        new++, old++;
-    }
-    if (builtinloc < 0 && idx_bltin >= 0)
-        builtinloc = idx_bltin;             /* zap builtins */
-    if (builtinloc >= 0 && idx_bltin < 0)
-        firstchange = 0;
-    clearcmdentry(firstchange);
-    builtinloc = idx_bltin;
-}
-
-
-/*
- * Clear out command entries.  The argument specifies the first entry in
- * PATH which has changed.
- */
-
-static void
-clearcmdentry(int firstchange)
-{
-    struct tblentry **tblp;
-    struct tblentry **pp;
-    struct tblentry *cmdp;
-
-    INTOFF;
-    for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
-        pp = tblp;
-        while ((cmdp = *pp) != NULL) {
-            if ((cmdp->cmdtype == CMDNORMAL &&
-                 cmdp->param.index >= firstchange)
-             || (cmdp->cmdtype == CMDBUILTIN &&
-                 builtinloc >= firstchange)) {
-                *pp = cmdp->next;
-                ckfree(cmdp);
-            } else {
-                pp = &cmdp->next;
-            }
-        }
-    }
-    INTON;
-}
-
-
-
-/*
- * Locate a command in the command hash table.  If "add" is nonzero,
- * add the command to the table if it is not already present.  The
- * variable "lastcmdentry" is set to point to the address of the link
- * pointing to the entry, so that delete_cmd_entry can delete the
- * entry.
- *
- * Interrupts must be off if called with add != 0.
- */
-
-static struct tblentry **lastcmdentry;
-
-
-static struct tblentry *
-cmdlookup(const char *name, int add)
-{
-    unsigned int hashval;
-    const char *p;
-    struct tblentry *cmdp;
-    struct tblentry **pp;
-
-    p = name;
-    hashval = (unsigned char)*p << 4;
-    while (*p)
-        hashval += (unsigned char)*p++;
-    hashval &= 0x7FFF;
-    pp = &cmdtable[hashval % CMDTABLESIZE];
-    for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
-        if (equal(cmdp->cmdname, name))
-            break;
-        pp = &cmdp->next;
-    }
-    if (add && cmdp == NULL) {
-        cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
-                    + strlen(name) + 1);
-        cmdp->next = NULL;
-        cmdp->cmdtype = CMDUNKNOWN;
-        strcpy(cmdp->cmdname, name);
-    }
-    lastcmdentry = pp;
-    return cmdp;
-}
-
-/*
- * Delete the command entry returned on the last lookup.
- */
-
-static void
-delete_cmd_entry(void)
-{
-    struct tblentry *cmdp;
-
-    INTOFF;
-    cmdp = *lastcmdentry;
-    *lastcmdentry = cmdp->next;
-    if (cmdp->cmdtype == CMDFUNCTION)
-        freefunc(cmdp->param.func);
-    ckfree(cmdp);
-    INTON;
-}
-
-
-/*
- * Add a new command entry, replacing any existing command entry for
- * the same name - except special builtins.
- */
-
-static inline void
-addcmdentry(char *name, struct cmdentry *entry)
-{
-    struct tblentry *cmdp;
-
-    cmdp = cmdlookup(name, 1);
-    if (cmdp->cmdtype == CMDFUNCTION) {
-        freefunc(cmdp->param.func);
-    }
-    cmdp->cmdtype = entry->cmdtype;
-    cmdp->param = entry->u;
-    cmdp->rehash = 0;
-}
-
-/*
- * Make a copy of a parse tree.
- */
-
-static inline struct funcnode *
-copyfunc(union node *n)
-{
-    struct funcnode *f;
-    size_t blocksize;
-
-    funcblocksize = offsetof(struct funcnode, n);
-    funcstringsize = 0;
-    calcsize(n);
-    blocksize = funcblocksize;
-    f = ckmalloc(blocksize + funcstringsize);
-    funcblock = (char *) f + offsetof(struct funcnode, n);
-    funcstring = (char *) f + blocksize;
-    copynode(n);
-    f->count = 0;
-    return f;
-}
-
-/*
- * Define a shell function.
- */
-
-static void
-defun(char *name, union node *func)
-{
-    struct cmdentry entry;
-
-    INTOFF;
-    entry.cmdtype = CMDFUNCTION;
-    entry.u.func = copyfunc(func);
-    addcmdentry(name, &entry);
-    INTON;
-}
-
-
-/*
- * Delete a function if it exists.
- */
-
-static void
-unsetfunc(const char *name)
-{
-    struct tblentry *cmdp;
-
-    if ((cmdp = cmdlookup(name, 0)) != NULL &&
-        cmdp->cmdtype == CMDFUNCTION)
-        delete_cmd_entry();
-}
-
-/*
- * Locate and print what a word is...
- */
-
-
-#ifdef CONFIG_ASH_CMDCMD
-static int
-describe_command(char *command, int describe_command_verbose)
-#else
-#define describe_command_verbose 1
-static int
-describe_command(char *command)
-#endif
-{
-    struct cmdentry entry;
-    struct tblentry *cmdp;
-#ifdef CONFIG_ASH_ALIAS
-    const struct alias *ap;
-#endif
-    const char *path = pathval();
-
-    if (describe_command_verbose) {
-        out1str(command);
-    }
-
-    /* First look at the keywords */
-    if (findkwd(command)) {
-        out1str(describe_command_verbose ? " is a shell keyword" : command);
-        goto out;
-    }
-
-#ifdef CONFIG_ASH_ALIAS
-    /* Then look at the aliases */
-    if ((ap = lookupalias(command, 0)) != NULL) {
-        if (describe_command_verbose) {
-            out1fmt(" is an alias for %s", ap->val);
-        } else {
-            out1str("alias ");
-            printalias(ap);
-            return 0;
-        }
-        goto out;
-    }
-#endif
-    /* Then check if it is a tracked alias */
-    if ((cmdp = cmdlookup(command, 0)) != NULL) {
-        entry.cmdtype = cmdp->cmdtype;
-        entry.u = cmdp->param;
-    } else {
-        /* Finally use brute force */
-        find_command(command, &entry, DO_ABS, path);
-    }
-
-    switch (entry.cmdtype) {
-    case CMDNORMAL: {
-        int j = entry.u.index;
-        char *p;
-        if (j == -1) {
-            p = command;
-        } else {
-            do {
-                p = padvance(&path, command);
-                stunalloc(p);
-            } while (--j >= 0);
-        }
-        if (describe_command_verbose) {
-            out1fmt(" is%s %s",
-                (cmdp ? " a tracked alias for" : nullstr), p
-            );
-        } else {
-            out1str(p);
-        }
-        break;
-    }
-
-    case CMDFUNCTION:
-        if (describe_command_verbose) {
-            out1str(" is a shell function");
-        } else {
-            out1str(command);
-        }
-        break;
-
-    case CMDBUILTIN:
-        if (describe_command_verbose) {
-            out1fmt(" is a %sshell builtin",
-                IS_BUILTIN_SPECIAL(entry.u.cmd) ?
-                    "special " : nullstr
-            );
-        } else {
-            out1str(command);
-        }
-        break;
-
-    default:
-        if (describe_command_verbose) {
-            out1str(": not found\n");
-        }
-        return 127;
-    }
-
-out:
-    outstr("\n", stdout);
-    return 0;
-}
-
-static int
-typecmd(int argc, char **argv)
-{
-    int i;
-    int err = 0;
-
-    for (i = 1; i < argc; i++) {
-#ifdef CONFIG_ASH_CMDCMD
-        err |= describe_command(argv[i], 1);
-#else
-        err |= describe_command(argv[i]);
-#endif
-    }
-    return err;
-}
-
-#ifdef CONFIG_ASH_CMDCMD
-static int
-commandcmd(int argc, char **argv)
-{
-    int c;
-    enum {
-        VERIFY_BRIEF = 1,
-        VERIFY_VERBOSE = 2,
-    } verify = 0;
-
-    while ((c = nextopt("pvV")) != '\0')
-        if (c == 'V')
-            verify |= VERIFY_VERBOSE;
-        else if (c == 'v')
-            verify |= VERIFY_BRIEF;
-#ifdef DEBUG
-        else if (c != 'p')
-            abort();
-#endif
-    if (verify)
-        return describe_command(*argptr, verify - VERIFY_BRIEF);
-
-    return 0;
-}
-#endif
-
-/*      expand.c     */
-
-/*
- * Routines to expand arguments to commands.  We have to deal with
- * backquotes, shell variables, and file metacharacters.
- */
-
-/*
- * _rmescape() flags
- */
-#define RMESCAPE_ALLOC  0x1     /* Allocate a new string */
-#define RMESCAPE_GLOB   0x2     /* Add backslashes for glob */
-#define RMESCAPE_QUOTED 0x4     /* Remove CTLESC unless in quotes */
-#define RMESCAPE_GROW   0x8     /* Grow strings instead of stalloc */
-#define RMESCAPE_HEAP   0x10    /* Malloc strings instead of stalloc */
-
-/*
- * Structure specifying which parts of the string should be searched
- * for IFS characters.
- */
-
-struct ifsregion {
-    struct ifsregion *next; /* next region in list */
-    int begoff;             /* offset of start of region */
-    int endoff;             /* offset of end of region */
-    int nulonly;            /* search for nul bytes only */
-};
-
-/* output of current string */
-static char *expdest;
-/* list of back quote expressions */
-static struct nodelist *argbackq;
-/* first struct in list of ifs regions */
-static struct ifsregion ifsfirst;
-/* last struct in list */
-static struct ifsregion *ifslastp;
-/* holds expanded arg list */
-static struct arglist exparg;
-
-static void argstr(char *, int);
-static char *exptilde(char *, char *, int);
-static void expbackq(union node *, int, int);
-static const char *subevalvar(char *, char *, int, int, int, int, int);
-static char *evalvar(char *, int);
-static void strtodest(const char *, int, int);
-static void memtodest(const char *p, size_t len, int syntax, int quotes);
-static ssize_t varvalue(char *, int, int);
-static void recordregion(int, int, int);
-static void removerecordregions(int);
-static void ifsbreakup(char *, struct arglist *);
-static void ifsfree(void);
-static void expandmeta(struct strlist *, int);
-static int patmatch(char *, const char *);
-
-static int cvtnum(arith_t);
-static size_t esclen(const char *, const char *);
-static char *scanleft(char *, char *, char *, char *, int, int);
-static char *scanright(char *, char *, char *, char *, int, int);
-static void varunset(const char *, const char *, const char *, int)
-    ATTRIBUTE_NORETURN;
-
-
-#define pmatch(a, b) !fnmatch((a), (b), 0)
-/*
- * Prepare a pattern for a expmeta (internal glob(3)) call.
- *
- * Returns an stalloced string.
- */
-
-static inline char *
-preglob(const char *pattern, int quoted, int flag) {
-    flag |= RMESCAPE_GLOB;
-    if (quoted) {
-        flag |= RMESCAPE_QUOTED;
-    }
-    return _rmescapes((char *)pattern, flag);
-}
-
-
-static size_t
-esclen(const char *start, const char *p) {
-    size_t esc = 0;
-
-    while (p > start && *--p == CTLESC) {
-        esc++;
-    }
-    return esc;
-}
-
-
-/*
- * Expand shell variables and backquotes inside a here document.
- */
-
-static inline void
-expandhere(union node *arg, int fd)
-{
-    herefd = fd;
-    expandarg(arg, (struct arglist *)NULL, 0);
-    bb_full_write(fd, stackblock(), expdest - (char *)stackblock());
-}
-
-
-/*
- * Perform variable substitution and command substitution on an argument,
- * placing the resulting list of arguments in arglist.  If EXP_FULL is true,
- * perform splitting and file name expansion.  When arglist is NULL, perform
- * here document expansion.
- */
-
-void
-expandarg(union node *arg, struct arglist *arglist, int flag)
-{
-    struct strlist *sp;
-    char *p;
-
-    argbackq = arg->narg.backquote;
-    STARTSTACKSTR(expdest);
-    ifsfirst.next = NULL;
-    ifslastp = NULL;
-    argstr(arg->narg.text, flag);
-    p = _STPUTC('\0', expdest);
-    expdest = p - 1;
-    if (arglist == NULL) {
-        return;                 /* here document expanded */
-    }
-    p = grabstackstr(p);
-    exparg.lastp = &exparg.list;
-    /*
-     * TODO - EXP_REDIR
-     */
-    if (flag & EXP_FULL) {
-        ifsbreakup(p, &exparg);
-        *exparg.lastp = NULL;
-        exparg.lastp = &exparg.list;
-        expandmeta(exparg.list, flag);
-    } else {
-        if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
-            rmescapes(p);
-        sp = (struct strlist *)stalloc(sizeof (struct strlist));
-        sp->text = p;
-        *exparg.lastp = sp;
-        exparg.lastp = &sp->next;
-    }
-    if (ifsfirst.next)
-        ifsfree();
-    *exparg.lastp = NULL;
-    if (exparg.list) {
-        *arglist->lastp = exparg.list;
-        arglist->lastp = exparg.lastp;
-    }
-}
-
-
-/*
- * Perform variable and command substitution.  If EXP_FULL is set, output CTLESC
- * characters to allow for further processing.  Otherwise treat
- * $@ like $* since no splitting will be performed.
- */
-
-static void
-argstr(char *p, int flag)
-{
-    static const char spclchars[] = {
-        '=',
-        ':',
-        CTLQUOTEMARK,
-        CTLENDVAR,
-        CTLESC,
-        CTLVAR,
-        CTLBACKQ,
-        CTLBACKQ | CTLQUOTE,
-#ifdef CONFIG_ASH_MATH_SUPPORT
-        CTLENDARI,
-#endif
-        0
-    };
-    const char *reject = spclchars;
-    int c;
-    int quotes = flag & (EXP_FULL | EXP_CASE);      /* do CTLESC */
-    int breakall = flag & EXP_WORD;
-    int inquotes;
-    size_t length;
-    int startloc;
-
-    if (!(flag & EXP_VARTILDE)) {
-        reject += 2;
-    } else if (flag & EXP_VARTILDE2) {
-        reject++;
-    }
-    inquotes = 0;
-    length = 0;
-    if (flag & EXP_TILDE) {
-        char *q;
-
-        flag &= ~EXP_TILDE;
-tilde:
-        q = p;
-        if (*q == CTLESC && (flag & EXP_QWORD))
-            q++;
-        if (*q == '~')
-            p = exptilde(p, q, flag);
-    }
-start:
-    startloc = expdest - (char *)stackblock();
-    for (;;) {
-        length += strcspn(p + length, reject);
-        c = p[length];
-        if (c && (!(c & 0x80)
-#ifdef CONFIG_ASH_MATH_SUPPORT
-                    || c == CTLENDARI
-#endif
-           )) {
-            /* c == '=' || c == ':' || c == CTLENDARI */
-            length++;
-        }
-        if (length > 0) {
-            int newloc;
-            expdest = stnputs(p, length, expdest);
-            newloc = expdest - (char *)stackblock();
-            if (breakall && !inquotes && newloc > startloc) {
-                recordregion(startloc, newloc, 0);
-            }
-            startloc = newloc;
-        }
-        p += length + 1;
-        length = 0;
-
-        switch (c) {
-        case '\0':
-            goto breakloop;
-        case '=':
-            if (flag & EXP_VARTILDE2) {
-                p--;
-                continue;
-            }
-            flag |= EXP_VARTILDE2;
-            reject++;
-            /* fall through */
-        case ':':
-            /*
-             * sort of a hack - expand tildes in variable
-             * assignments (after the first '=' and after ':'s).
-             */
-            if (*--p == '~') {
-                goto tilde;
-            }
-            continue;
-        }
-
-        switch (c) {
-        case CTLENDVAR: /* ??? */
-            goto breakloop;
-        case CTLQUOTEMARK:
-            /* "$@" syntax adherence hack */
-            if (
-                !inquotes &&
-                !memcmp(p, dolatstr, DOLATSTRLEN) &&
-                (p[4] == CTLQUOTEMARK || (
-                    p[4] == CTLENDVAR &&
-                    p[5] == CTLQUOTEMARK
-                ))
-            ) {
-                p = evalvar(p + 1, flag) + 1;
-                goto start;
-            }
-            inquotes = !inquotes;
-addquote:
-            if (quotes) {
-                p--;
-                length++;
-                startloc++;
-            }
-            break;
-        case CTLESC:
-            startloc++;
-            length++;
-            goto addquote;
-        case CTLVAR:
-            p = evalvar(p, flag);
-            goto start;
-        case CTLBACKQ:
-            c = 0;
-        case CTLBACKQ|CTLQUOTE:
-            expbackq(argbackq->n, c, quotes);
-            argbackq = argbackq->next;
-            goto start;
-#ifdef CONFIG_ASH_MATH_SUPPORT
-        case CTLENDARI:
-            p--;
-            expari(quotes);
-            goto start;
-#endif
-        }
-    }
-breakloop:
-    ;
-}
-
-static char *
-exptilde(char *startp, char *p, int flag)
-{
-    char c;
-    char *name;
-    struct passwd *pw;
-    const char *home;
-    int quotes = flag & (EXP_FULL | EXP_CASE);
-    int startloc;
-
-    name = p + 1;
-
-    while ((c = *++p) != '\0') {
-        switch(c) {
-        case CTLESC:
-            return (startp);
-        case CTLQUOTEMARK:
-            return (startp);
-        case ':':
-            if (flag & EXP_VARTILDE)
-                goto done;
-            break;
-        case '/':
-        case CTLENDVAR:
-            goto done;
-        }
-    }
-done:
-    *p = '\0';
-    if (*name == '\0') {
-        home = lookupvar(homestr);
-    } else {
-        if ((pw = getpwnam(name)) == NULL)
-            goto lose;
-        home = pw->pw_dir;
-    }
-    if (!home || !*home)
-        goto lose;
-    *p = c;
-    startloc = expdest - (char *)stackblock();
-    strtodest(home, SQSYNTAX, quotes);
-    recordregion(startloc, expdest - (char *)stackblock(), 0);
-    return (p);
-lose:
-    *p = c;
-    return (startp);
-}
-
-
-static void
-removerecordregions(int endoff)
-{
-    if (ifslastp == NULL)
-        return;
-
-    if (ifsfirst.endoff > endoff) {
-        while (ifsfirst.next != NULL) {
-            struct ifsregion *ifsp;
-            INTOFF;
-            ifsp = ifsfirst.next->next;
-            ckfree(ifsfirst.next);
-            ifsfirst.next = ifsp;
-            INTON;
-        }
-        if (ifsfirst.begoff > endoff)
-            ifslastp = NULL;
-        else {
-            ifslastp = &ifsfirst;
-            ifsfirst.endoff = endoff;
-        }
-        return;
-    }
-
-    ifslastp = &ifsfirst;
-    while (ifslastp->next && ifslastp->next->begoff < endoff)
-        ifslastp=ifslastp->next;
-    while (ifslastp->next != NULL) {
-        struct ifsregion *ifsp;
-        INTOFF;
-        ifsp = ifslastp->next->next;
-        ckfree(ifslastp->next);
-        ifslastp->next = ifsp;
-        INTON;
-    }
-    if (ifslastp->endoff > endoff)
-        ifslastp->endoff = endoff;
-}
-
-
-#ifdef CONFIG_ASH_MATH_SUPPORT
-/*
- * Expand arithmetic expression.  Backup to start of expression,
- * evaluate, place result in (backed up) result, adjust string position.
- */
-void
-expari(int quotes)
-{
-    char *p, *start;
-    int begoff;
-    int flag;
-    int len;
-
-    /*      ifsfree(); */
-
-    /*
-     * This routine is slightly over-complicated for
-     * efficiency.  Next we scan backwards looking for the
-     * start of arithmetic.
-     */
-    start = stackblock();
-    p = expdest - 1;
-    *p = '\0';
-    p--;
-    do {
-        int esc;
-
-        while (*p != CTLARI) {
-            p--;
-#ifdef DEBUG
-            if (p < start) {
-                sh_error("missing CTLARI (shouldn't happen)");
-            }
-#endif
-        }
-
-        esc = esclen(start, p);
-        if (!(esc % 2)) {
-            break;
-        }
-
-        p -= esc + 1;
-    } while (1);
-
-    begoff = p - start;
-
-    removerecordregions(begoff);
-
-    flag = p[1];
-
-    expdest = p;
-
-    if (quotes)
-        rmescapes(p + 2);
-
-    len = cvtnum(dash_arith(p + 2));
-
-    if (flag != '"')
-        recordregion(begoff, begoff + len, 0);
-}
-#endif
-
-/*
- * Expand stuff in backwards quotes.
- */
-
-static void
-expbackq(union node *cmd, int quoted, int quotes)
-{
-    struct backcmd in;
-    int i;
-    char buf[128];
-    char *p;
-    char *dest;
-    int startloc;
-    int syntax = quoted? DQSYNTAX : BASESYNTAX;
-    struct stackmark smark;
-
-    INTOFF;
-    setstackmark(&smark);
-    dest = expdest;
-    startloc = dest - (char *)stackblock();
-    grabstackstr(dest);
-    evalbackcmd(cmd, (struct backcmd *) &in);
-    popstackmark(&smark);
-
-    p = in.buf;
-    i = in.nleft;
-    if (i == 0)
-        goto read;
-    for (;;) {
-        memtodest(p, i, syntax, quotes);
-read:
-        if (in.fd < 0)
-            break;
-        i = safe_read(in.fd, buf, sizeof buf);
-        TRACE(("expbackq: read returns %d\n", i));
-        if (i <= 0)
-            break;
-        p = buf;
-    }
-
-    if (in.buf)
-        ckfree(in.buf);
-    if (in.fd >= 0) {
-        close(in.fd);
-        back_exitstatus = waitforjob(in.jp);
-    }
-    INTON;
-
-    /* Eat all trailing newlines */
-    dest = expdest;
-    for (; dest > (char *)stackblock() && dest[-1] == '\n';)
-        STUNPUTC(dest);
-    expdest = dest;
-
-    if (quoted == 0)
-        recordregion(startloc, dest - (char *)stackblock(), 0);
-    TRACE(("evalbackq: size=%d: \"%.*s\"\n",
-        (dest - (char *)stackblock()) - startloc,
-        (dest - (char *)stackblock()) - startloc,
-        stackblock() + startloc));
-}
-
-
-static char *
-scanleft(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
-    int zero)
-{
-    char *loc;
-    char *loc2;
-    char c;
-
-    loc = startp;
-    loc2 = rmesc;
-    do {
-        int match;
-        const char *s = loc2;
-        c = *loc2;
-        if (zero) {
-            *loc2 = '\0';
-            s = rmesc;
-        }
-        match = pmatch(str, s);
-        *loc2 = c;
-        if (match)
-            return loc;
-        if (quotes && *loc == CTLESC)
-            loc++;
-        loc++;
-        loc2++;
-    } while (c);
-    return 0;
-}
-
-
-static char *
-scanright(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
-    int zero)
-{
-    int esc = 0;
-    char *loc;
-    char *loc2;
-
-    for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
-        int match;
-        char c = *loc2;
-        const char *s = loc2;
-        if (zero) {
-            *loc2 = '\0';
-            s = rmesc;
-        }
-        match = pmatch(str, s);
-        *loc2 = c;
-        if (match)
-            return loc;
-        loc--;
-        if (quotes) {
-            if (--esc < 0) {
-                esc = esclen(startp, loc);
-            }
-            if (esc % 2) {
-                esc--;
-                loc--;
-            }
-        }
-    }
-    return 0;
-}
-
-static const char *
-subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes)
-{
-    char *startp;
-    char *loc;
-    int saveherefd = herefd;
-    struct nodelist *saveargbackq = argbackq;
-    int amount;
-    char *rmesc, *rmescend;
-    int zero;
-    char *(*scan)(char *, char *, char *, char *, int , int);
-
-    herefd = -1;
-    argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
-    STPUTC('\0', expdest);
-    herefd = saveherefd;
-    argbackq = saveargbackq;
-    startp = stackblock() + startloc;
-
-    switch (subtype) {
-    case VSASSIGN:
-        setvar(str, startp, 0);
-        amount = startp - expdest;
-        STADJUST(amount, expdest);
-        return startp;
-
-    case VSQUESTION:
-        varunset(p, str, startp, varflags);
-        /* NOTREACHED */
-    }
-
-    subtype -= VSTRIMRIGHT;
-#ifdef DEBUG
-    if (subtype < 0 || subtype > 3)
-        abort();
-#endif
-
-    rmesc = startp;
-    rmescend = stackblock() + strloc;
-    if (quotes) {
-        rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
-        if (rmesc != startp) {
-            rmescend = expdest;
-            startp = stackblock() + startloc;
-        }
-    }
-    rmescend--;
-    str = stackblock() + strloc;
-    preglob(str, varflags & VSQUOTE, 0);
-
-    /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
-    zero = subtype >> 1;
-    /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
-    scan = (subtype & 1) ^ zero ? scanleft : scanright;
-
-    loc = scan(startp, rmesc, rmescend, str, quotes, zero);
-    if (loc) {
-        if (zero) {
-            memmove(startp, loc, str - loc);
-            loc = startp + (str - loc) - 1;
-        }
-        *loc = '\0';
-        amount = loc - expdest;
-        STADJUST(amount, expdest);
-    }
-    return loc;
-}
-
-
-/*
- * Expand a variable, and return a pointer to the next character in the
- * input string.
- */
-static char *
-evalvar(char *p, int flag)
-{
-    int subtype;
-    int varflags;
-    char *var;
-    int patloc;
-    int c;
-    int startloc;
-    ssize_t varlen;
-    int easy;
-    int quotes;
-    int quoted;
-
-    quotes = flag & (EXP_FULL | EXP_CASE);
-    varflags = *p++;
-    subtype = varflags & VSTYPE;
-    quoted = varflags & VSQUOTE;
-    var = p;
-    easy = (!quoted || (*var == '@' && shellparam.nparam));
-    startloc = expdest - (char *)stackblock();
-    p = strchr(p, '=') + 1;
-
-again:
-    varlen = varvalue(var, varflags, flag);
-    if (varflags & VSNUL)
-        varlen--;
-
-    if (subtype == VSPLUS) {
-        varlen = -1 - varlen;
-        goto vsplus;
-    }
-
-    if (subtype == VSMINUS) {
-vsplus:
-        if (varlen < 0) {
-            argstr(
-                p, flag | EXP_TILDE |
-                    (quoted ?  EXP_QWORD : EXP_WORD)
-            );
-            goto end;
-        }
-        if (easy)
-            goto record;
-        goto end;
-    }
-
-    if (subtype == VSASSIGN || subtype == VSQUESTION) {
-        if (varlen < 0) {
-            if (subevalvar(p, var, 0, subtype, startloc,
-                       varflags, 0)) {
-                varflags &= ~VSNUL;
-                /*
-                 * Remove any recorded regions beyond
-                 * start of variable
-                 */
-                removerecordregions(startloc);
-                goto again;
-            }
-            goto end;
-        }
-        if (easy)
-            goto record;
-        goto end;
-    }
-
-    if (varlen < 0 && uflag)
-        varunset(p, var, 0, 0);
-
-    if (subtype == VSLENGTH) {
-        cvtnum(varlen > 0 ? varlen : 0);
-        goto record;
-    }
-
-    if (subtype == VSNORMAL) {
-        if (!easy)
-            goto end;
-record:
-        recordregion(startloc, expdest - (char *)stackblock(), quoted);
-        goto end;
-    }
-
-#ifdef DEBUG
-    switch (subtype) {
-    case VSTRIMLEFT:
-    case VSTRIMLEFTMAX:
-    case VSTRIMRIGHT:
-    case VSTRIMRIGHTMAX:
-        break;
-    default:
-        abort();
-    }
-#endif
-
-    if (varlen >= 0) {
-        /*
-         * Terminate the string and start recording the pattern
-         * right after it
-         */
-        STPUTC('\0', expdest);
-        patloc = expdest - (char *)stackblock();
-        if (subevalvar(p, NULL, patloc, subtype,
-                   startloc, varflags, quotes) == 0) {
-            int amount = expdest - (
-                (char *)stackblock() + patloc - 1
-            );
-            STADJUST(-amount, expdest);
-        }
-        /* Remove any recorded regions beyond start of variable */
-        removerecordregions(startloc);
-        goto record;
-    }
-
-end:
-    if (subtype != VSNORMAL) {      /* skip to end of alternative */
-        int nesting = 1;
-        for (;;) {
-            if ((c = *p++) == CTLESC)
-                p++;
-            else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
-                if (varlen >= 0)
-                    argbackq = argbackq->next;
-            } else if (c == CTLVAR) {
-                if ((*p++ & VSTYPE) != VSNORMAL)
-                    nesting++;
-            } else if (c == CTLENDVAR) {
-                if (--nesting == 0)
-                    break;
-            }
-        }
-    }
-    return p;
-}
-
-
-/*
- * Put a string on the stack.
- */
-
-static void
-memtodest(const char *p, size_t len, int syntax, int quotes) {
-    char *q = expdest;
-
-    q = makestrspace(len * 2, q);
-
-    while (len--) {
-        int c = SC2INT(*p++);
-        if (!c)
-            continue;
-        if (quotes && (SIT(c, syntax) == CCTL || SIT(c, syntax) == CBACK))
-            USTPUTC(CTLESC, q);
-        USTPUTC(c, q);
-    }
-
-    expdest = q;
-}
-
-
-static void
-strtodest(const char *p, int syntax, int quotes)
-{
-    memtodest(p, strlen(p), syntax, quotes);
-}
-
-
-/*
- * Add the value of a specialized variable to the stack string.
- */
-
-static ssize_t
-varvalue(char *name, int varflags, int flags)
-{
-    int num;
-    char *p;
-    int i;
-    int sep = 0;
-    int sepq = 0;
-    ssize_t len = 0;
-    char **ap;
-    int syntax;
-    int quoted = varflags & VSQUOTE;
-    int subtype = varflags & VSTYPE;
-    int quotes = flags & (EXP_FULL | EXP_CASE);
-
-    if (quoted && (flags & EXP_FULL))
-        sep = 1 << CHAR_BIT;
-
-    syntax = quoted ? DQSYNTAX : BASESYNTAX;
-    switch (*name) {
-    case '$':
-        num = rootpid;
-        goto numvar;
-    case '?':
-        num = exitstatus;
-        goto numvar;
-    case '#':
-        num = shellparam.nparam;
-        goto numvar;
-    case '!':
-        num = backgndpid;
-        if (num == 0)
-            return -1;
-numvar:
-        len = cvtnum(num);
-        break;
-    case '-':
-        p = makestrspace(NOPTS, expdest);
-        for (i = NOPTS - 1; i >= 0; i--) {
-            if (optlist[i]) {
-                USTPUTC(optletters(i), p);
-                len++;
-            }
-        }
-        expdest = p;
-        break;
-    case '@':
-        if (sep)
-            goto param;
-        /* fall through */
-    case '*':
-        sep = ifsset() ? SC2INT(ifsval()[0]) : ' ';
-        if (quotes && (SIT(sep, syntax) == CCTL || SIT(sep, syntax) == CBACK))
-            sepq = 1;
-param:
-        if (!(ap = shellparam.p))
-            return -1;
-        while ((p = *ap++)) {
-            size_t partlen;
-
-            partlen = strlen(p);
-            len += partlen;
-
-            if (!(subtype == VSPLUS || subtype == VSLENGTH))
-                memtodest(p, partlen, syntax, quotes);
-
-            if (*ap && sep) {
-                char *q;
-
-                len++;
-                if (subtype == VSPLUS || subtype == VSLENGTH) {
-                    continue;
-                }
-                q = expdest;
-                if (sepq)
-                    STPUTC(CTLESC, q);
-                STPUTC(sep, q);
-                expdest = q;
-            }
-        }
-        return len;
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-        num = atoi(name);
-        if (num < 0 || num > shellparam.nparam)
-            return -1;
-        p = num ? shellparam.p[num - 1] : arg0;
-        goto value;
-    default:
-        p = lookupvar(name);
-value:
-        if (!p)
-            return -1;
-
-        len = strlen(p);
-        if (!(subtype == VSPLUS || subtype == VSLENGTH))
-            memtodest(p, len, syntax, quotes);
-        return len;
-    }
-
-    if (subtype == VSPLUS || subtype == VSLENGTH)
-        STADJUST(-len, expdest);
-    return len;
-}
-
-
-/*
- * Record the fact that we have to scan this region of the
- * string for IFS characters.
- */
-
-static void
-recordregion(int start, int end, int nulonly)
-{
-    struct ifsregion *ifsp;
-
-    if (ifslastp == NULL) {
-        ifsp = &ifsfirst;
-    } else {
-        INTOFF;
-        ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));
-        ifsp->next = NULL;
-        ifslastp->next = ifsp;
-        INTON;
-    }
-    ifslastp = ifsp;
-    ifslastp->begoff = start;
-    ifslastp->endoff = end;
-    ifslastp->nulonly = nulonly;
-}
-
-
-/*
- * Break the argument string into pieces based upon IFS and add the
- * strings to the argument list.  The regions of the string to be
- * searched for IFS characters have been stored by recordregion.
- */
-static void
-ifsbreakup(char *string, struct arglist *arglist)
-{
-    struct ifsregion *ifsp;
-    struct strlist *sp;
-    char *start;
-    char *p;
-    char *q;
-    const char *ifs, *realifs;
-    int ifsspc;
-    int nulonly;
-
-
-    start = string;
-    if (ifslastp != NULL) {
-        ifsspc = 0;
-        nulonly = 0;
-        realifs = ifsset() ? ifsval() : defifs;
-        ifsp = &ifsfirst;
-        do {
-            p = string + ifsp->begoff;
-            nulonly = ifsp->nulonly;
-            ifs = nulonly ? nullstr : realifs;
-            ifsspc = 0;
-            while (p < string + ifsp->endoff) {
-                q = p;
-                if (*p == CTLESC)
-                    p++;
-                if (strchr(ifs, *p)) {
-                    if (!nulonly)
-                        ifsspc = (strchr(defifs, *p) != NULL);
-                    /* Ignore IFS whitespace at start */
-                    if (q == start && ifsspc) {
-                        p++;
-                        start = p;
-                        continue;
-                    }
-                    *q = '\0';
-                    sp = (struct strlist *)stalloc(sizeof *sp);
-                    sp->text = start;
-                    *arglist->lastp = sp;
-                    arglist->lastp = &sp->next;
-                    p++;
-                    if (!nulonly) {
-                        for (;;) {
-                            if (p >= string + ifsp->endoff) {
-                                break;
-                            }
-                            q = p;
-                            if (*p == CTLESC)
-                                p++;
-                            if (strchr(ifs, *p) == NULL ) {
-                                p = q;
-                                break;
-                            } else if (strchr(defifs, *p) == NULL) {
-                                if (ifsspc) {
-                                    p++;
-                                    ifsspc = 0;
-                                } else {
-                                    p = q;
-                                    break;
-                                }
-                            } else
-                                p++;
-                        }
-                    }
-                    start = p;
-                } else
-                    p++;
-            }
-        } while ((ifsp = ifsp->next) != NULL);
-        if (nulonly)
-            goto add;
-    }
-
-    if (!*start)
-        return;
-
-add:
-    sp = (struct strlist *)stalloc(sizeof *sp);
-    sp->text = start;
-    *arglist->lastp = sp;
-    arglist->lastp = &sp->next;
-}
-
-static void
-ifsfree(void)
-{
-    struct ifsregion *p;
-
-    INTOFF;
-    p = ifsfirst.next;
-    do {
-        struct ifsregion *ifsp;
-        ifsp = p->next;
-        ckfree(p);
-        p = ifsp;
-    } while (p);
-    ifslastp = NULL;
-    ifsfirst.next = NULL;
-    INTON;
-}
-
-static void expmeta(char *, char *);
-static struct strlist *expsort(struct strlist *);
-static struct strlist *msort(struct strlist *, int);
-
-static char *expdir;
-
-
-static void
-expandmeta(struct strlist *str, int flag)
-{
-    static const char metachars[] = {
-        '*', '?', '[', 0
-    };
-    /* TODO - EXP_REDIR */
-
-    while (str) {
-        struct strlist **savelastp;
-        struct strlist *sp;
-        char *p;
-
-        if (fflag)
-            goto nometa;
-        if (!strpbrk(str->text, metachars))
-            goto nometa;
-        savelastp = exparg.lastp;
-
-        INTOFF;
-        p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
-        {
-            int i = strlen(str->text);
-            expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
-        }
-
-        expmeta(expdir, p);
-        ckfree(expdir);
-        if (p != str->text)
-            ckfree(p);
-        INTON;
-        if (exparg.lastp == savelastp) {
-            /*
-             * no matches
-             */
-nometa:
-            *exparg.lastp = str;
-            rmescapes(str->text);
-            exparg.lastp = &str->next;
-        } else {
-            *exparg.lastp = NULL;
-            *savelastp = sp = expsort(*savelastp);
-            while (sp->next != NULL)
-                sp = sp->next;
-            exparg.lastp = &sp->next;
-        }
-        str = str->next;
-    }
-}
-
-/*
- * Add a file name to the list.
- */
-
-static void
-addfname(const char *name)
-{
-    struct strlist *sp;
-
-    sp = (struct strlist *)stalloc(sizeof *sp);
-    sp->text = sstrdup(name);
-    *exparg.lastp = sp;
-    exparg.lastp = &sp->next;
-}
-
-
-/*
- * Do metacharacter (i.e. *, ?, [...]) expansion.
- */
-
-static void
-expmeta(char *enddir, char *name)
-{
-    char *p;
-    const char *cp;
-    char *start;
-    char *endname;
-    int metaflag;
-    struct stat statb;
-    DIR *dirp;
-    struct dirent *dp;
-    int atend;
-    int matchdot;
-
-    metaflag = 0;
-    start = name;
-    for (p = name; *p; p++) {
-        if (*p == '*' || *p == '?')
-            metaflag = 1;
-        else if (*p == '[') {
-            char *q = p + 1;
-            if (*q == '!')
-                q++;
-            for (;;) {
-                if (*q == '\\')
-                    q++;
-                if (*q == '/' || *q == '\0')
-                    break;
-                if (*++q == ']') {
-                    metaflag = 1;
-                    break;
-                }
-            }
-        } else if (*p == '\\')
-            p++;
-        else if (*p == '/') {
-            if (metaflag)
-                goto out;
-            start = p + 1;
-        }
-    }
-out:
-    if (metaflag == 0) {    /* we've reached the end of the file name */
-        if (enddir != expdir)
-            metaflag++;
-        p = name;
-        do {
-            if (*p == '\\')
-                p++;
-            *enddir++ = *p;
-        } while (*p++);
-        if (metaflag == 0 || lstat(expdir, &statb) >= 0)
-            addfname(expdir);
-        return;
-    }
-    endname = p;
-    if (name < start) {
-        p = name;
-        do {
-            if (*p == '\\')
-                p++;
-            *enddir++ = *p++;
-        } while (p < start);
-    }
-    if (enddir == expdir) {
-        cp = ".";
-    } else if (enddir == expdir + 1 && *expdir == '/') {
-        cp = "/";
-    } else {
-        cp = expdir;
-        enddir[-1] = '\0';
-    }
-    if ((dirp = opendir(cp)) == NULL)
-        return;
-    if (enddir != expdir)
-        enddir[-1] = '/';
-    if (*endname == 0) {
-        atend = 1;
-    } else {
-        atend = 0;
-        *endname++ = '\0';
-    }
-    matchdot = 0;
-    p = start;
-    if (*p == '\\')
-        p++;
-    if (*p == '.')
-        matchdot++;
-    while (! intpending && (dp = readdir(dirp)) != NULL) {
-        if (dp->d_name[0] == '.' && ! matchdot)
-            continue;
-        if (pmatch(start, dp->d_name)) {
-            if (atend) {
-                scopy(dp->d_name, enddir);
-                addfname(expdir);
-            } else {
-                for (p = enddir, cp = dp->d_name;
-                     (*p++ = *cp++) != '\0';)
-                    continue;
-                p[-1] = '/';
-                expmeta(p, endname);
-            }
-        }
-    }
-    closedir(dirp);
-    if (! atend)
-        endname[-1] = '/';
-}
-
-/*
- * Sort the results of file name expansion.  It calculates the number of
- * strings to sort and then calls msort (short for merge sort) to do the
- * work.
- */
-
-static struct strlist *
-expsort(struct strlist *str)
-{
-    int len;
-    struct strlist *sp;
-
-    len = 0;
-    for (sp = str ; sp ; sp = sp->next)
-        len++;
-    return msort(str, len);
-}
-
-
-static struct strlist *
-msort(struct strlist *list, int len)
-{
-    struct strlist *p, *q = NULL;
-    struct strlist **lpp;
-    int half;
-    int n;
-
-    if (len <= 1)
-        return list;
-    half = len >> 1;
-    p = list;
-    for (n = half ; --n >= 0 ; ) {
-        q = p;
-        p = p->next;
-    }
-    q->next = NULL;                 /* terminate first half of list */
-    q = msort(list, half);          /* sort first half of list */
-    p = msort(p, len - half);               /* sort second half */
-    lpp = &list;
-    for (;;) {
-#ifdef CONFIG_LOCALE_SUPPORT
-        if (strcoll(p->text, q->text) < 0)
-#else
-        if (strcmp(p->text, q->text) < 0)
-#endif
-                        {
-            *lpp = p;
-            lpp = &p->next;
-            if ((p = *lpp) == NULL) {
-                *lpp = q;
-                break;
-            }
-        } else {
-            *lpp = q;
-            lpp = &q->next;
-            if ((q = *lpp) == NULL) {
-                *lpp = p;
-                break;
-            }
-        }
-    }
-    return list;
-}
-
-
-/*
- * Returns true if the pattern matches the string.
- */
-
-static inline int
-patmatch(char *pattern, const char *string)
-{
-    return pmatch(preglob(pattern, 0, 0), string);
-}
-
-
-/*
- * Remove any CTLESC characters from a string.
- */
-
-static char *
-_rmescapes(char *str, int flag)
-{
-    char *p, *q, *r;
-    static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
-    unsigned inquotes;
-    int notescaped;
-    int globbing;
-
-    p = strpbrk(str, qchars);
-    if (!p) {
-        return str;
-    }
-    q = p;
-    r = str;
-    if (flag & RMESCAPE_ALLOC) {
-        size_t len = p - str;
-        size_t fulllen = len + strlen(p) + 1;
-
-        if (flag & RMESCAPE_GROW) {
-            r = makestrspace(fulllen, expdest);
-        } else if (flag & RMESCAPE_HEAP) {
-            r = ckmalloc(fulllen);
-        } else {
-            r = stalloc(fulllen);
-        }
-        q = r;
-        if (len > 0) {
-            q = mempcpy(q, str, len);
-        }
-    }
-    inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED;
-    globbing = flag & RMESCAPE_GLOB;
-    notescaped = globbing;
-    while (*p) {
-        if (*p == CTLQUOTEMARK) {
-            inquotes = ~inquotes;
-            p++;
-            notescaped = globbing;
-            continue;
-        }
-        if (*p == '\\') {
-            /* naked back slash */
-            notescaped = 0;
-            goto copy;
-        }
-        if (*p == CTLESC) {
-            p++;
-            if (notescaped && inquotes && *p != '/') {
-                *q++ = '\\';
-            }
-        }
-        notescaped = globbing;
-copy:
-        *q++ = *p++;
-    }
-    *q = '\0';
-    if (flag & RMESCAPE_GROW) {
-        expdest = r;
-        STADJUST(q - r + 1, expdest);
-    }
-    return r;
-}
-
-
-/*
- * See if a pattern matches in a case statement.
- */
-
-int
-casematch(union node *pattern, char *val)
-{
-    struct stackmark smark;
-    int result;
-
-    setstackmark(&smark);
-    argbackq = pattern->narg.backquote;
-    STARTSTACKSTR(expdest);
-    ifslastp = NULL;
-    argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
-    STACKSTRNUL(expdest);
-    result = patmatch(stackblock(), val);
-    popstackmark(&smark);
-    return result;
-}
-
-/*
- * Our own itoa().
- */
-
-static int
-cvtnum(arith_t num)
-{
-    int len;
-
-    expdest = makestrspace(32, expdest);
-#ifdef CONFIG_ASH_MATH_SUPPORT_64
-    len = fmtstr(expdest, 32, "%lld", (long long) num);
-#else
-    len = fmtstr(expdest, 32, "%ld", num);
-#endif
-    STADJUST(len, expdest);
-    return len;
-}
-
-static void
-varunset(const char *end, const char *var, const char *umsg, int varflags)
-{
-    const char *msg;
-    const char *tail;
-
-    tail = nullstr;
-    msg = "parameter not set";
-    if (umsg) {
-        if (*end == CTLENDVAR) {
-            if (varflags & VSNUL)
-                tail = " or null";
-        } else
-            msg = umsg;
-    }
-    sh_error("%.*s: %s%s", end - var - 1, var, msg, tail);
-}
-
-
-/*      input.c      */
-
-/*
- * This implements the input routines used by the parser.
- */
-
-#define EOF_NLEFT -99           /* value of parsenleft when EOF pushed back */
-
-static void pushfile(void);
-
-/*
- * Read a character from the script, returning PEOF on end of file.
- * Nul characters in the input are silently discarded.
- */
-
-
-#define pgetc_as_macro()   (--parsenleft >= 0? SC2INT(*parsenextc++) : preadbuffer())
-
-#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
-#define pgetc_macro() pgetc()
-static int
-pgetc(void)
-{
-    return pgetc_as_macro();
-}
-#else
-#define pgetc_macro()   pgetc_as_macro()
-static int
-pgetc(void)
-{
-    return pgetc_macro();
-}
-#endif
-
-
-/*
- * Same as pgetc(), but ignores PEOA.
- */
-#ifdef CONFIG_ASH_ALIAS
-static int pgetc2(void)
-{
-    int c;
-
-    do {
-        c = pgetc_macro();
-    } while (c == PEOA);
-    return c;
-}
-#else
-static inline int pgetc2(void)
-{
-    return pgetc_macro();
-}
-#endif
-
-/*
- * Read a line from the script.
- */
-
-static inline char *
-pfgets(char *line, int len)
-{
-    char *p = line;
-    int nleft = len;
-    int c;
-
-    while (--nleft > 0) {
-        c = pgetc2();
-        if (c == PEOF) {
-            if (p == line)
-                return NULL;
-            break;
-        }
-        *p++ = c;
-        if (c == '\n')
-            break;
-    }
-    *p = '\0';
-    return line;
-}
-
-
-
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
-#ifdef CONFIG_ASH_EXPAND_PRMT
-static char *cmdedit_prompt;
-#else
-static const char *cmdedit_prompt;
-#endif
-static inline void putprompt(const char *s)
-{
-#ifdef CONFIG_ASH_EXPAND_PRMT
-    free(cmdedit_prompt);
-    cmdedit_prompt = bb_xstrdup(s);
-#else
-    cmdedit_prompt = s;
-#endif
-}
-#else
-static inline void putprompt(const char *s)
-{
-    out2str(s);
-}
-#endif
-
-static inline int
-preadfd(void)
-{
-    int nr;
-    char *buf =  parsefile->buf;
-    parsenextc = buf;
-
-retry:
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
-    if (!iflag || parsefile->fd)
-        nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
-    else {
-#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
-        cmdedit_path_lookup = pathval();
-#endif
-        nr = cmdedit_read_input((char *) cmdedit_prompt, buf);
-        if(nr == 0) {
-            /* Ctrl+C presend */
-            if(trap[SIGINT]) {
-                buf[0] = '\n';
-                buf[1] = 0;
-                raise(SIGINT);
-                return 1;
-            }
-            goto retry;
-        }
-        if(nr < 0 && errno == 0) {
-            /* Ctrl+D presend */
-            nr = 0;
-        }
-    }
-#else
-    nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
-#endif
-
-    if (nr < 0) {
-        if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
-            int flags = fcntl(0, F_GETFL, 0);
-            if (flags >= 0 && flags & O_NONBLOCK) {
-                flags &=~ O_NONBLOCK;
-                if (fcntl(0, F_SETFL, flags) >= 0) {
-                    out2str("sh: turning off NDELAY mode\n");
-                    goto retry;
-                }
-            }
-        }
-    }
-    return nr;
-}
-
-/*
- * Refill the input buffer and return the next input character:
- *
- * 1) If a string was pushed back on the input, pop it;
- * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
- *    from a string so we can't refill the buffer, return EOF.
- * 3) If the is more stuff in this buffer, use it else call read to fill it.
- * 4) Process input up to the next newline, deleting nul characters.
- */
-
-int
-preadbuffer(void)
-{
-    char *q;
-    int more;
-    char savec;
-
-    while (parsefile->strpush) {
-#ifdef CONFIG_ASH_ALIAS
-        if (parsenleft == -1 && parsefile->strpush->ap &&
-            parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
-            return PEOA;
-        }
-#endif
-        popstring();
-        if (--parsenleft >= 0)
-            return SC2INT(*parsenextc++);
-    }
-    if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
-        return PEOF;
-    flushall();
-
-    more = parselleft;
-    if (more <= 0) {
-again:
-        if ((more = preadfd()) <= 0) {
-            parselleft = parsenleft = EOF_NLEFT;
-            return PEOF;
-        }
-    }
-
-    q = parsenextc;
-
-    /* delete nul characters */
-    for (;;) {
-        int c;
-
-        more--;
-        c = *q;
-
-        if (!c)
-            memmove(q, q + 1, more);
-        else {
-            q++;
-            if (c == '\n') {
-                parsenleft = q - parsenextc - 1;
-                break;
-            }
-        }
-
-        if (more <= 0) {
-            parsenleft = q - parsenextc - 1;
-            if (parsenleft < 0)
-                goto again;
-            break;
-        }
-    }
-    parselleft = more;
-
-    savec = *q;
-    *q = '\0';
-
-    if (vflag) {
-        out2str(parsenextc);
-    }
-
-    *q = savec;
-
-    return SC2INT(*parsenextc++);
-}
-
-/*
- * Undo the last call to pgetc.  Only one character may be pushed back.
- * PEOF may be pushed back.
- */
-
-void
-pungetc(void)
-{
-    parsenleft++;
-    parsenextc--;
-}
-
-/*
- * Push a string back onto the input at this current parsefile level.
- * We handle aliases this way.
- */
-void
-pushstring(char *s, void *ap)
-{
-    struct strpush *sp;
-    size_t len;
-
-    len = strlen(s);
-    INTOFF;
-/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
-    if (parsefile->strpush) {
-        sp = ckmalloc(sizeof (struct strpush));
-        sp->prev = parsefile->strpush;
-        parsefile->strpush = sp;
-    } else
-        sp = parsefile->strpush = &(parsefile->basestrpush);
-    sp->prevstring = parsenextc;
-    sp->prevnleft = parsenleft;
-#ifdef CONFIG_ASH_ALIAS
-    sp->ap = (struct alias *)ap;
-    if (ap) {
-        ((struct alias *)ap)->flag |= ALIASINUSE;
-        sp->string = s;
-    }
-#endif
-    parsenextc = s;
-    parsenleft = len;
-    INTON;
-}
-
-void
-popstring(void)
-{
-    struct strpush *sp = parsefile->strpush;
-
-    INTOFF;
-#ifdef CONFIG_ASH_ALIAS
-    if (sp->ap) {
-        if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
-            checkkwd |= CHKALIAS;
-        }
-        if (sp->string != sp->ap->val) {
-            ckfree(sp->string);
-        }
-        sp->ap->flag &= ~ALIASINUSE;
-        if (sp->ap->flag & ALIASDEAD) {
-            unalias(sp->ap->name);
-        }
-    }
-#endif
-    parsenextc = sp->prevstring;
-    parsenleft = sp->prevnleft;
-/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
-    parsefile->strpush = sp->prev;
-    if (sp != &(parsefile->basestrpush))
-        ckfree(sp);
-    INTON;
-}
-
-/*
- * Set the input to take input from a file.  If push is set, push the
- * old input onto the stack first.
- */
-
-static int
-setinputfile(const char *fname, int flags)
-{
-    int fd;
-    int fd2;
-
-    INTOFF;
-    if ((fd = open(fname, O_RDONLY)) < 0) {
-        if (flags & INPUT_NOFILE_OK)
-            goto out;
-        sh_error("Can't open %s", fname);
-    }
-    if (fd < 10) {
-        fd2 = copyfd(fd, 10);
-        close(fd);
-        if (fd2 < 0)
-            sh_error("Out of file descriptors");
-        fd = fd2;
-    }
-    setinputfd(fd, flags & INPUT_PUSH_FILE);
-out:
-    INTON;
-    return fd;
-}
-
-
-/*
- * Like setinputfile, but takes an open file descriptor.  Call this with
- * interrupts off.
- */
-
-static void
-setinputfd(int fd, int push)
-{
-    (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
-    if (push) {
-        pushfile();
-        parsefile->buf = 0;
-    }
-    parsefile->fd = fd;
-    if (parsefile->buf == NULL)
-        parsefile->buf = ckmalloc(IBUFSIZ);
-    parselleft = parsenleft = 0;
-    plinno = 1;
-}
-
-
-/*
- * Like setinputfile, but takes input from a string.
- */
-
-static void
-setinputstring(char *string)
-{
-    INTOFF;
-    pushfile();
-    parsenextc = string;
-    parsenleft = strlen(string);
-    parsefile->buf = NULL;
-    plinno = 1;
-    INTON;
-}
-
-
-/*
- * To handle the "." command, a stack of input files is used.  Pushfile
- * adds a new entry to the stack and popfile restores the previous level.
- */
-
-static void
-pushfile(void)
-{
-    struct parsefile *pf;
-
-    parsefile->nleft = parsenleft;
-    parsefile->lleft = parselleft;
-    parsefile->nextc = parsenextc;
-    parsefile->linno = plinno;
-    pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
-    pf->prev = parsefile;
-    pf->fd = -1;
-    pf->strpush = NULL;
-    pf->basestrpush.prev = NULL;
-    parsefile = pf;
-}
-
-
-static void
-popfile(void)
-{
-    struct parsefile *pf = parsefile;
-
-    INTOFF;
-    if (pf->fd >= 0)
-        close(pf->fd);
-    if (pf->buf)
-        ckfree(pf->buf);
-    while (pf->strpush)
-        popstring();
-    parsefile = pf->prev;
-    ckfree(pf);
-    parsenleft = parsefile->nleft;
-    parselleft = parsefile->lleft;
-    parsenextc = parsefile->nextc;
-    plinno = parsefile->linno;
-    INTON;
-}
-
-
-/*
- * Return to top level.
- */
-
-static void
-popallfiles(void)
-{
-    while (parsefile != &basepf)
-        popfile();
-}
-
-
-/*
- * Close the file(s) that the shell is reading commands from.  Called
- * after a fork is done.
- */
-
-static void
-closescript(void)
-{
-    popallfiles();
-    if (parsefile->fd > 0) {
-        close(parsefile->fd);
-        parsefile->fd = 0;
-    }
-}
-
-/*      jobs.c    */
+        act.sa_handler = SIG_DFL;
+    }
+    *t = action;
+    act.sa_flags = 0;
+    sigfillset(&act.sa_mask);
+    sigaction(signo, &act, 0);
+}
 
 /* mode flags for set_curjob */
@@ -6387 +3254 @@
 #define DOWAIT_BLOCK 1
 
+#if JOBS
+/* pgrp of shell on invocation */
+static int initialpgrp;
+static int ttyfd = -1;
+#endif
 /* array of jobs */
 static struct job *jobtab;
 /* size of array */
 static unsigned njobs;
-#if JOBS
-/* pgrp of shell on invocation */
-static int initialpgrp;
-static int ttyfd = -1;
-#endif
 /* current job */
 static struct job *curjob;
 /* number of presumed living untracked jobs */
 static int jobless;
-
-static void set_curjob(struct job *, unsigned);
-#if JOBS
-static int restartjob(struct job *, int);
-static void xtcsetpgrp(int, pid_t);
-static char *commandtext(union node *);
-static void cmdlist(union node *, int);
-static void cmdtxt(union node *);
-static void cmdputs(const char *);
-static void showpipe(struct job *, FILE *);
-#endif
-static int sprint_status(char *, int, int);
-static void freejob(struct job *);
-static struct job *getjob(const char *, int);
-static struct job *growjobtab(void);
-static void forkchild(struct job *, union node *, int);
-static void forkparent(struct job *, union node *, int, pid_t);
-static int dowait(int, struct job *);
-static int getstatus(struct job *);
 
 static void
@@ -6440 +3288 @@
     switch (mode) {
     default:
-#ifdef DEBUG
+#if DEBUG
         abort();
 #endif
@@ -6468 +3316 @@
 }
 
+#if JOBS || DEBUG
+static int
+jobno(const struct job *jp)
+{
+    return jp - jobtab + 1;
+}
+#endif
+
+/*
+ * Convert a job name to a job structure.
+ */
+static struct job *
+getjob(const char *name, int getctl)
+{
+    struct job *jp;
+    struct job *found;
+    const char *err_msg = "No such job: %s";
+    unsigned num;
+    int c;
+    const char *p;
+    char *(*match)(const char *, const char *);
+
+    jp = curjob;
+    p = name;
+    if (!p)
+        goto currentjob;
+
+    if (*p != '%')
+        goto err;
+
+    c = *++p;
+    if (!c)
+        goto currentjob;
+
+    if (!p[1]) {
+        if (c == '+' || c == '%') {
+ currentjob:
+            err_msg = "No current job";
+            goto check;
+        }
+        if (c == '-') {
+            if (jp)
+                jp = jp->prev_job;
+            err_msg = "No previous job";
+ check:
+            if (!jp)
+                goto err;
+            goto gotit;
+        }
+    }
+
+    if (is_number(p)) {
+        num = atoi(p);
+        if (num < njobs) {
+            jp = jobtab + num - 1;
+            if (jp->used)
+                goto gotit;
+            goto err;
+        }
+    }
+
+    match = prefix;
+    if (*p == '?') {
+        match = strstr;
+        p++;
+    }
+
+    found = 0;
+    while (1) {
+        if (!jp)
+            goto err;
+        if (match(jp->ps[0].cmd, p)) {
+            if (found)
+                goto err;
+            found = jp;
+            err_msg = "%s: ambiguous";
+        }
+        jp = jp->prev_job;
+    }
+
+ gotit:
 #if JOBS
+    err_msg = "job %s not created under job control";
+    if (getctl && jp->jobctl == 0)
+        goto err;
+#endif
+    return jp;
+ err:
+    ash_msg_and_raise_error(err_msg, name);
+}
+
+/*
+ * Mark a job structure as unused.
+ */
+static void
+freejob(struct job *jp)
+{
+    struct procstat *ps;
+    int i;
+
+    INT_OFF;
+    for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
+        if (ps->cmd != nullstr)
+            free(ps->cmd);
+    }
+    if (jp->ps != &jp->ps0)
+        free(jp->ps);
+    jp->used = 0;
+    set_curjob(jp, CUR_DELETE);
+    INT_ON;
+}
+
+#if JOBS
+static void
+xtcsetpgrp(int fd, pid_t pgrp)
+{
+    if (tcsetpgrp(fd, pgrp))
+        ash_msg_and_raise_error("cannot set tty process group (%m)");
+}
+
 /*
  * Turn job control on and off.
@@ -6478 +3445 @@
  * Called with interrupts off.
  */
-
-void
+static void
 setjobctl(int on)
 {
@@ -6491 +3457 @@
         ofd = fd = open(_PATH_TTY, O_RDWR);
         if (fd < 0) {
+    /* BTW, bash will try to open(ttyname(0)) if open("/dev/tty") fails.
+     * That sometimes helps to acquire controlling tty.
+     * Obviously, a workaround for bugs when someone
+     * failed to provide a controlling tty to bash! :) */
             fd += 3;
             while (!isatty(fd) && --fd >= 0)
@@ -6501 +3471 @@
         fcntl(fd, F_SETFD, FD_CLOEXEC);
         do { /* while we are in the background */
-            if ((pgrp = tcgetpgrp(fd)) < 0) {
-out:
-                sh_warnx("can't access tty; job control turned off");
+            pgrp = tcgetpgrp(fd);
+            if (pgrp < 0) {
+ out:
+                ash_msg("can't access tty; job control turned off");
                 mflag = on = 0;
                 goto close;
@@ -6523 +3494 @@
         fd = ttyfd;
         pgrp = initialpgrp;
-        xtcsetpgrp(fd, pgrp);
+        /* was xtcsetpgrp, but this can make exiting ash
+         * with pty already deleted loop forever */
+        tcsetpgrp(fd, pgrp);
         setpgid(0, pgrp);
         setsignal(SIGTSTP);
         setsignal(SIGTTOU);
         setsignal(SIGTTIN);
-close:
+ close:
         close(fd);
         fd = -1;
@@ -6539 +3512 @@
 killcmd(int argc, char **argv)
 {
-    int signo = -1;
-    int list = 0;
-    int i;
-    pid_t pid;
-    struct job *jp;
-
-    if (argc <= 1) {
-usage:
-        sh_error(
-"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
-"kill -l [exitstatus]"
-        );
-    }
-
-    if (**++argv == '-') {
-        signo = decode_signal(*argv + 1, 1);
-        if (signo < 0) {
-            int c;
-
-            while ((c = nextopt("ls:")) != '\0')
-                switch (c) {
-                default:
-#ifdef DEBUG
-                    abort();
-#endif
-                case 'l':
-                    list = 1;
-                    break;
-                case 's':
-                    signo = decode_signal(optionarg, 1);
-                    if (signo < 0) {
-                        sh_error(
-                            "invalid signal number or name: %s",
-                            optionarg
-                        );
-                    }
-                    break;
-                }
-            argv = argptr;
-        } else
-            argv++;
-    }
-
-    if (!list && signo < 0)
-        signo = SIGTERM;
-
-    if ((signo < 0 || !*argv) ^ list) {
-        goto usage;
-    }
-
-    if (list) {
-        const char *name;
-
-        if (!*argv) {
-            for (i = 1; i < NSIG; i++) {
-                name = u_signal_names(0, &i, 1);
-                if (name)
-                    out1fmt(snlfmt, name);
+    if (argv[1] && strcmp(argv[1], "-l") != 0) {
+        int i = 1;
+        do {
+            if (argv[i][0] == '%') {
+                struct job *jp = getjob(argv[i], 0);
+                unsigned pid = jp->ps[0].pid;
+                /* Enough space for ' -NNN<nul>' */
+                argv[i] = alloca(sizeof(int)*3 + 3);
+                /* kill_main has matching code to expect
+                 * leading space. Needed to not confuse
+                 * negative pids with "kill -SIGNAL_NO" syntax */
+                sprintf(argv[i], " -%u", pid);
             }
-            return 0;
-        }
-        name = u_signal_names(*argptr, &signo, -1);
-        if (name)
-            out1fmt(snlfmt, name);
-        else
-            sh_error("invalid signal number or exit status: %s", *argptr);
-        return 0;
-    }
-
-    i = 0;
-    do {
-        if (**argv == '%') {
-            jp = getjob(*argv, 0);
-            pid = -jp->ps[0].pid;
-        } else {
-            pid = **argv == '-' ?
-                -number(*argv + 1) : number(*argv);
-        }
-        if (kill(pid, signo) != 0) {
-            sh_warnx("(%d) - %m", pid);
-            i = 1;
-        }
-    } while (*++argv);
-
-    return i;
-}
-#endif /* JOBS */
-
-#if defined(JOBS) || defined(DEBUG)
-static int
-jobno(const struct job *jp)
-{
-    return jp - jobtab + 1;
-}
-#endif
-
-#if JOBS
-static int
-fgcmd(int argc, char **argv)
-{
-    struct job *jp;
-    FILE *out;
-    int mode;
-    int retval;
-
-    mode = (**argv == 'f') ? FORK_FG : FORK_BG;
-    nextopt(nullstr);
-    argv = argptr;
-    out = stdout;
-    do {
-        jp = getjob(*argv, 1);
-        if (mode == FORK_BG) {
-            set_curjob(jp, CUR_RUNNING);
-            fprintf(out, "[%d] ", jobno(jp));
-        }
-        outstr(jp->ps->cmd, out);
-        showpipe(jp, out);
-        retval = restartjob(jp, mode);
-    } while (*argv && *++argv);
-    return retval;
-}
-
-static int bgcmd(int, char **) __attribute__((__alias__("fgcmd")));
+        } while (argv[++i]);
+    }
+    return kill_main(argc, argv);
+}
+
+static void
+showpipe(struct job *jp, FILE *out)
+{
+    struct procstat *sp;
+    struct procstat *spend;
+
+    spend = jp->ps + jp->nprocs;
+    for (sp = jp->ps + 1; sp < spend; sp++)
+        fprintf(out, " | %s", sp->cmd);
+    outcslow('\n', out);
+    flush_stdout_stderr();
+}
 
 
@@ -6672 +3552 @@
     pid_t pgid;
 
-    INTOFF;
+    INT_OFF;
     if (jp->state == JOBDONE)
         goto out;
@@ -6686 +3566 @@
             ps->status = -1;
         }
-    } while (ps++, --i);
-out:
+        ps++;
+    } while (--i);
+ out:
     status = (mode == FORK_FG) ? waitforjob(jp) : 0;
-    INTON;
+    INT_ON;
     return status;
+}
+
+static int
+fg_bgcmd(int argc, char **argv)
+{
+    struct job *jp;
+    FILE *out;
+    int mode;
+    int retval;
+
+    mode = (**argv == 'f') ? FORK_FG : FORK_BG;
+    nextopt(nullstr);
+    argv = argptr;
+    out = stdout;
+    do {
+        jp = getjob(*argv, 1);
+        if (mode == FORK_BG) {
+            set_curjob(jp, CUR_RUNNING);
+            fprintf(out, "[%d] ", jobno(jp));
+        }
+        outstr(jp->ps->cmd, out);
+        showpipe(jp, out);
+        retval = restartjob(jp, mode);
+    } while (*argv && *++argv);
+    return retval;
 }
 #endif
@@ -6728 +3634 @@
             col = fmtstr(s, 16, "Done");
     }
-
-out:
+ out:
     return col;
 }
-
-#if JOBS
-static void
-showjob(FILE *out, struct job *jp, int mode)
-{
-    struct procstat *ps;
-    struct procstat *psend;
-    int col;
-    int indent;
-    char s[80];
-
-    ps = jp->ps;
-
-    if (mode & SHOW_PGID) {
-        /* just output process (group) id of pipeline */
-        fprintf(out, "%d\n", ps->pid);
-        return;
-    }
-
-    col = fmtstr(s, 16, "[%d]   ", jobno(jp));
-    indent = col;
-
-    if (jp == curjob)
-        s[col - 2] = '+';
-    else if (curjob && jp == curjob->prev_job)
-        s[col - 2] = '-';
-
-    if (mode & SHOW_PID)
-        col += fmtstr(s + col, 16, "%d ", ps->pid);
-
-    psend = ps + jp->nprocs;
-
-    if (jp->state == JOBRUNNING) {
-        scopy("Running", s + col);
-        col += strlen("Running");
-    } else {
-        int status = psend[-1].status;
-#if JOBS
-        if (jp->state == JOBSTOPPED)
-            status = jp->stopstatus;
-#endif
-        col += sprint_status(s + col, status, 0);
-    }
-
-    goto start;
-
-    do {
-        /* for each process */
-        col = fmtstr(s, 48, " |\n%*c%d ", indent, ' ', ps->pid) - 3;
-
-start:
-        fprintf(out, "%s%*c%s",
-            s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd
-        );
-        if (!(mode & SHOW_PID)) {
-            showpipe(jp, out);
-            break;
-        }
-        if (++ps == psend) {
-            outcslow('\n', out);
-            break;
-        }
-    } while (1);
-
-    jp->changed = 0;
-
-    if (jp->state == JOBDONE) {
-        TRACE(("showjob: freeing job %d\n", jobno(jp)));
-        freejob(jp);
-    }
-}
-
-
-static int
-jobscmd(int argc, char **argv)
-{
-    int mode, m;
-    FILE *out;
-
-    mode = 0;
-    while ((m = nextopt("lp")))
-        if (m == 'l')
-            mode = SHOW_PID;
-        else
-            mode = SHOW_PGID;
-
-    out = stdout;
-    argv = argptr;
-    if (*argv)
-        do
-            showjob(out, getjob(*argv,0), mode);
-        while (*++argv);
-    else
-        showjobs(out, mode);
-
-    return 0;
-}
-
-
-/*
- * Print a list of jobs.  If "change" is nonzero, only print jobs whose
- * statuses have changed since the last call to showjobs.
- */
-
-static void
-showjobs(FILE *out, int mode)
-{
-    struct job *jp;
-
-    TRACE(("showjobs(%x) called\n", mode));
-
-    /* If not even one one job changed, there is nothing to do */
-    while (dowait(DOWAIT_NORMAL, NULL) > 0)
-        continue;
-
-    for (jp = curjob; jp; jp = jp->prev_job) {
-        if (!(mode & SHOW_CHANGED) || jp->changed)
-            showjob(out, jp, mode);
-    }
-}
-#endif /* JOBS */
-
-/*
- * Mark a job structure as unused.
- */
-
-static void
-freejob(struct job *jp)
-{
-    struct procstat *ps;
-    int i;
-
-    INTOFF;
-    for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
-        if (ps->cmd != nullstr)
-            ckfree(ps->cmd);
-    }
-    if (jp->ps != &jp->ps0)
-        ckfree(jp->ps);
-    jp->used = 0;
-    set_curjob(jp, CUR_DELETE);
-    INTON;
-}
-
-
-static int
-waitcmd(int argc, char **argv)
-{
-    struct job *job;
-    int retval;
-    struct job *jp;
-
-    EXSIGON();
-
-    nextopt(nullstr);
-    retval = 0;
-
-    argv = argptr;
-    if (!*argv) {
-        /* wait for all jobs */
-        for (;;) {
-            jp = curjob;
-            while (1) {
-                if (!jp) {
-                    /* no running procs */
-                    goto out;
-                }
-                if (jp->state == JOBRUNNING)
-                    break;
-                jp->waited = 1;
-                jp = jp->prev_job;
-            }
-            dowait(DOWAIT_BLOCK, 0);
-        }
-    }
-
-    retval = 127;
-    do {
-        if (**argv != '%') {
-            pid_t pid = number(*argv);
-            job = curjob;
-            goto start;
-            do {
-                if (job->ps[job->nprocs - 1].pid == pid)
-                    break;
-                job = job->prev_job;
-start:
-                if (!job)
-                    goto repeat;
-            } while (1);
-        } else
-            job = getjob(*argv, 0);
-        /* loop until process terminated or stopped */
-        while (job->state == JOBRUNNING)
-            dowait(DOWAIT_BLOCK, 0);
-        job->waited = 1;
-        retval = getstatus(job);
-repeat:
-        ;
-    } while (*++argv);
-
-out:
-    return retval;
-}
-
-
-/*
- * Convert a job name to a job structure.
- */
-
-static struct job *
-getjob(const char *name, int getctl)
-{
-    struct job *jp;
-    struct job *found;
-    const char *err_msg = "No such job: %s";
-    unsigned num;
-    int c;
-    const char *p;
-    char *(*match)(const char *, const char *);
-
-    jp = curjob;
-    p = name;
-    if (!p)
-        goto currentjob;
-
-    if (*p != '%')
-        goto err;
-
-    c = *++p;
-    if (!c)
-        goto currentjob;
-
-    if (!p[1]) {
-        if (c == '+' || c == '%') {
-currentjob:
-            err_msg = "No current job";
-            goto check;
-        } else if (c == '-') {
-            if (jp)
-                jp = jp->prev_job;
-            err_msg = "No previous job";
-check:
-            if (!jp)
-                goto err;
-            goto gotit;
-        }
-    }
-
-    if (is_number(p)) {
-        num = atoi(p);
-        if (num < njobs) {
-            jp = jobtab + num - 1;
-            if (jp->used)
-                goto gotit;
-            goto err;
-        }
-    }
-
-    match = prefix;
-    if (*p == '?') {
-        match = strstr;
-        p++;
-    }
-
-    found = 0;
-    while (1) {
-        if (!jp)
-            goto err;
-        if (match(jp->ps[0].cmd, p)) {
-            if (found)
-                goto err;
-            found = jp;
-            err_msg = "%s: ambiguous";
-        }
-        jp = jp->prev_job;
-    }
-
-gotit:
-#if JOBS
-    err_msg = "job %s not created under job control";
-    if (getctl && jp->jobctl == 0)
-        goto err;
-#endif
-    return jp;
-err:
-    sh_error(err_msg, name);
-}
-
-
-/*
- * Return a new job structure.
- * Called with interrupts off.
- */
-
-static struct job *
-makejob(union node *node, int nprocs)
-{
-    int i;
-    struct job *jp;
-
-    for (i = njobs, jp = jobtab ; ; jp++) {
-        if (--i < 0) {
-            jp = growjobtab();
-            break;
-        }
-        if (jp->used == 0)
-            break;
-        if (jp->state != JOBDONE || !jp->waited)
-            continue;
-#if JOBS
-        if (jobctl)
-            continue;
-#endif
-        freejob(jp);
-        break;
-    }
-    memset(jp, 0, sizeof(*jp));
-#if JOBS
-    if (jobctl)
-        jp->jobctl = 1;
-#endif
-    jp->prev_job = curjob;
-    curjob = jp;
-    jp->used = 1;
-    jp->ps = &jp->ps0;
-    if (nprocs > 1) {
-        jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
-    }
-    TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
-        jobno(jp)));
-    return jp;
-}
-
-static struct job *
-growjobtab(void)
-{
-    size_t len;
-    ptrdiff_t offset;
-    struct job *jp, *jq;
-
-    len = njobs * sizeof(*jp);
-    jq = jobtab;
-    jp = ckrealloc(jq, len + 4 * sizeof(*jp));
-
-    offset = (char *)jp - (char *)jq;
-    if (offset) {
-        /* Relocate pointers */
-        size_t l = len;
-
-        jq = (struct job *)((char *)jq + l);
-        while (l) {
-            l -= sizeof(*jp);
-            jq--;
-#define joff(p) ((struct job *)((char *)(p) + l))
-#define jmove(p) (p) = (void *)((char *)(p) + offset)
-            if (xlikely(joff(jp)->ps == &jq->ps0))
-                jmove(joff(jp)->ps);
-            if (joff(jp)->prev_job)
-                jmove(joff(jp)->prev_job);
-        }
-        if (curjob)
-            jmove(curjob);
-#undef joff
-#undef jmove
-    }
-
-    njobs += 4;
-    jobtab = jp;
-    jp = (struct job *)((char *)jp + len);
-    jq = jp + 3;
-    do {
-        jq->used = 0;
-    } while (--jq >= jp);
-    return jp;
-}
-
-
-/*
- * Fork off a subshell.  If we are doing job control, give the subshell its
- * own process group.  Jp is a job structure that the job is to be added to.
- * N is the command that will be evaluated by the child.  Both jp and n may
- * be NULL.  The mode parameter can be one of the following:
- *      FORK_FG - Fork off a foreground process.
- *      FORK_BG - Fork off a background process.
- *      FORK_NOJOB - Like FORK_FG, but don't give the process its own
- *                   process group even if job control is on.
- *
- * When job control is turned off, background processes have their standard
- * input redirected to /dev/null (except for the second and later processes
- * in a pipeline).
- *
- * Called with interrupts off.
- */
-
-static inline void
-forkchild(struct job *jp, union node *n, int mode)
-{
-    int oldlvl;
-
-    TRACE(("Child shell %d\n", getpid()));
-    oldlvl = shlvl;
-    shlvl++;
-
-    closescript();
-    clear_traps();
-#if JOBS
-    /* do job control only in root shell */
-    jobctl = 0;
-    if (mode != FORK_NOJOB && jp->jobctl && !oldlvl) {
-        pid_t pgrp;
-
-        if (jp->nprocs == 0)
-            pgrp = getpid();
-        else
-            pgrp = jp->ps[0].pid;
-        /* This can fail because we are doing it in the parent also */
-        (void)setpgid(0, pgrp);
-        if (mode == FORK_FG)
-            xtcsetpgrp(ttyfd, pgrp);
-        setsignal(SIGTSTP);
-        setsignal(SIGTTOU);
-    } else
-#endif
-    if (mode == FORK_BG) {
-        ignoresig(SIGINT);
-        ignoresig(SIGQUIT);
-        if (jp->nprocs == 0) {
-            close(0);
-            if (open(bb_dev_null, O_RDONLY) != 0)
-                sh_error("Can't open %s", bb_dev_null);
-        }
-    }
-    if (!oldlvl && iflag) {
-        setsignal(SIGINT);
-        setsignal(SIGQUIT);
-        setsignal(SIGTERM);
-    }
-    for (jp = curjob; jp; jp = jp->prev_job)
-        freejob(jp);
-    jobless = 0;
-}
-
-static inline void
-forkparent(struct job *jp, union node *n, int mode, pid_t pid)
-{
-    TRACE(("In parent shell:  child = %d\n", pid));
-    if (!jp) {
-        while (jobless && dowait(DOWAIT_NORMAL, 0) > 0);
-        jobless++;
-        return;
-    }
-#if JOBS
-    if (mode != FORK_NOJOB && jp->jobctl) {
-        int pgrp;
-
-        if (jp->nprocs == 0)
-            pgrp = pid;
-        else
-            pgrp = jp->ps[0].pid;
-        /* This can fail because we are doing it in the child also */
-        (void)setpgid(pid, pgrp);
-    }
-#endif
-    if (mode == FORK_BG) {
-        backgndpid = pid;               /* set $! */
-        set_curjob(jp, CUR_RUNNING);
-    }
-    if (jp) {
-        struct procstat *ps = &jp->ps[jp->nprocs++];
-        ps->pid = pid;
-        ps->status = -1;
-        ps->cmd = nullstr;
-#if JOBS
-        if (jobctl && n)
-            ps->cmd = commandtext(n);
-#endif
-    }
-}
-
-static int
-forkshell(struct job *jp, union node *n, int mode)
-{
-    int pid;
-
-    TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
-    pid = fork();
-    if (pid < 0) {
-        TRACE(("Fork failed, errno=%d", errno));
-        if (jp)
-            freejob(jp);
-        sh_error("Cannot fork");
-    }
-    if (pid == 0)
-        forkchild(jp, n, mode);
-    else
-        forkparent(jp, n, mode, pid);
-    return pid;
-}
-
-/*
- * Wait for job to finish.
- *
- * Under job control we have the problem that while a child process is
- * running interrupts generated by the user are sent to the child but not
- * to the shell.  This means that an infinite loop started by an inter-
- * active user may be hard to kill.  With job control turned off, an
- * interactive user may place an interactive program inside a loop.  If
- * the interactive program catches interrupts, the user doesn't want
- * these interrupts to also abort the loop.  The approach we take here
- * is to have the shell ignore interrupt signals while waiting for a
- * foreground process to terminate, and then send itself an interrupt
- * signal if the child process was terminated by an interrupt signal.
- * Unfortunately, some programs want to do a bit of cleanup and then
- * exit on interrupt; unless these processes terminate themselves by
- * sending a signal to themselves (instead of calling exit) they will
- * confuse this approach.
- *
- * Called with interrupts off.
- */
-
-int
-waitforjob(struct job *jp)
-{
-    int st;
-
-    TRACE(("waitforjob(%%%d) called\n", jobno(jp)));
-    while (jp->state == JOBRUNNING) {
-        dowait(DOWAIT_BLOCK, jp);
-    }
-    st = getstatus(jp);
-#if JOBS
-    if (jp->jobctl) {
-        xtcsetpgrp(ttyfd, rootpid);
-        /*
-         * This is truly gross.
-         * If we're doing job control, then we did a TIOCSPGRP which
-         * caused us (the shell) to no longer be in the controlling
-         * session -- so we wouldn't have seen any ^C/SIGINT.  So, we
-         * intuit from the subprocess exit status whether a SIGINT
-         * occurred, and if so interrupt ourselves.  Yuck.  - mycroft
-         */
-        if (jp->sigint)
-            raise(SIGINT);
-    }
-    if (jp->state == JOBDONE)
-#endif
-        freejob(jp);
-    return st;
-}
-
 
 /*
@@ -7312 +3666 @@
  * and the jobs command may give out of date information.
  */
-
-static inline int
+static int
 waitproc(int block, int *status)
 {
@@ -7330 +3683 @@
  * Wait for a process to terminate.
  */
-
 static int
 dowait(int block, struct job *job)
@@ -7345 +3697 @@
     if (pid <= 0)
         return pid;
-    INTOFF;
+    INT_OFF;
     thisjob = NULL;
     for (jp = curjob; jp; jp = jp->prev_job) {
@@ -7357 +3709 @@
         do {
             if (sp->pid == pid) {
-                TRACE(("Job %d: changing status of proc %d from 0x%x to 0x%x\n", jobno(jp), pid, sp->status, status));
+                TRACE(("Job %d: changing status of proc %d "
+                    "from 0x%x to 0x%x\n",
+                    jobno(jp), pid, sp->status, status));
                 sp->status = status;
                 thisjob = jp;
@@ -7382 +3736 @@
     goto out;
 
-gotjob:
+ gotjob:
     if (state != JOBRUNNING) {
         thisjob->changed = 1;
 
         if (thisjob->state != state) {
-            TRACE(("Job %d: changing state from %d to %d\n", jobno(thisjob), thisjob->state, state));
+            TRACE(("Job %d: changing state from %d to %d\n",
+                jobno(thisjob), thisjob->state, state));
             thisjob->state = state;
 #if JOBS
@@ -7397 +3752 @@
     }
 
-out:
-    INTON;
+ out:
+    INT_ON;
 
     if (thisjob && thisjob == job) {
@@ -7414 +3769 @@
 }
 
-
-/*
- * return 1 if there are stopped jobs, otherwise 0
- */
-
-int
-stoppedjobs(void)
+#if JOBS
+static void
+showjob(FILE *out, struct job *jp, int mode)
+{
+    struct procstat *ps;
+    struct procstat *psend;
+    int col;
+    int indent_col;
+    char s[80];
+
+    ps = jp->ps;
+
+    if (mode & SHOW_PGID) {
+        /* just output process (group) id of pipeline */
+        fprintf(out, "%d\n", ps->pid);
+        return;
+    }
+
+    col = fmtstr(s, 16, "[%d]   ", jobno(jp));
+    indent_col = col;
+
+    if (jp == curjob)
+        s[col - 2] = '+';
+    else if (curjob && jp == curjob->prev_job)
+        s[col - 2] = '-';
+
+    if (mode & SHOW_PID)
+        col += fmtstr(s + col, 16, "%d ", ps->pid);
+
+    psend = ps + jp->nprocs;
+
+    if (jp->state == JOBRUNNING) {
+        strcpy(s + col, "Running");
+        col += sizeof("Running") - 1;
+    } else {
+        int status = psend[-1].status;
+        if (jp->state == JOBSTOPPED)
+            status = jp->stopstatus;
+        col += sprint_status(s + col, status, 0);
+    }
+
+    goto start;
+
+    do {
+        /* for each process */
+        col = fmtstr(s, 48, " |\n%*c%d ", indent_col, ' ', ps->pid) - 3;
+ start:
+        fprintf(out, "%s%*c%s",
+            s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd
+        );
+        if (!(mode & SHOW_PID)) {
+            showpipe(jp, out);
+            break;
+        }
+        if (++ps == psend) {
+            outcslow('\n', out);
+            break;
+        }
+    } while (1);
+
+    jp->changed = 0;
+
+    if (jp->state == JOBDONE) {
+        TRACE(("showjob: freeing job %d\n", jobno(jp)));
+        freejob(jp);
+    }
+}
+
+/*
+ * Print a list of jobs.  If "change" is nonzero, only print jobs whose
+ * statuses have changed since the last call to showjobs.
+ */
+static void
+showjobs(FILE *out, int mode)
 {
     struct job *jp;
+
+    TRACE(("showjobs(%x) called\n", mode));
+
+    /* If not even one one job changed, there is nothing to do */
+    while (dowait(DOWAIT_NORMAL, NULL) > 0)
+        continue;
+
+    for (jp = curjob; jp; jp = jp->prev_job) {
+        if (!(mode & SHOW_CHANGED) || jp->changed) {
+            showjob(out, jp, mode);
+        }
+    }
+}
+
+static int
+jobscmd(int argc, char **argv)
+{
+    int mode, m;
+
+    mode = 0;
+    while ((m = nextopt("lp"))) {
+        if (m == 'l')
+            mode = SHOW_PID;
+        else
+            mode = SHOW_PGID;
+    }
+
+    argv = argptr;
+    if (*argv) {
+        do
+            showjob(stdout, getjob(*argv,0), mode);
+        while (*++argv);
+    } else
+        showjobs(stdout, mode);
+
+    return 0;
+}
+#endif /* JOBS */
+
+static int
+getstatus(struct job *job)
+{
+    int status;
     int retval;
 
+    status = job->ps[job->nprocs - 1].status;
+    retval = WEXITSTATUS(status);
+    if (!WIFEXITED(status)) {
+#if JOBS
+        retval = WSTOPSIG(status);
+        if (!WIFSTOPPED(status))
+#endif
+        {
+            /* XXX: limits number of signals */
+            retval = WTERMSIG(status);
+#if JOBS
+            if (retval == SIGINT)
+                job->sigint = 1;
+#endif
+        }
+        retval += 128;
+    }
+    TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
+        jobno(job), job->nprocs, status, retval));
+    return retval;
+}
+
+static int
+waitcmd(int argc, char **argv)
+{
+    struct job *job;
+    int retval;
+    struct job *jp;
+
+    EXSIGON;
+
+    nextopt(nullstr);
     retval = 0;
-    if (job_warning)
-        goto out;
-    jp = curjob;
-    if (jp && jp->state == JOBSTOPPED) {
-        out2str("You have stopped jobs.\n");
-        job_warning = 2;
-        retval++;
-    }
-
-out:
+
+    argv = argptr;
+    if (!*argv) {
+        /* wait for all jobs */
+        for (;;) {
+            jp = curjob;
+            while (1) {
+                if (!jp) {
+                    /* no running procs */
+                    goto out;
+                }
+                if (jp->state == JOBRUNNING)
+                    break;
+                jp->waited = 1;
+                jp = jp->prev_job;
+            }
+            dowait(DOWAIT_BLOCK, 0);
+        }
+    }
+
+    retval = 127;
+    do {
+        if (**argv != '%') {
+            pid_t pid = number(*argv);
+            job = curjob;
+            goto start;
+            do {
+                if (job->ps[job->nprocs - 1].pid == pid)
+                    break;
+                job = job->prev_job;
+ start:
+                if (!job)
+                    goto repeat;
+            } while (1);
+        } else
+            job = getjob(*argv, 0);
+        /* loop until process terminated or stopped */
+        while (job->state == JOBRUNNING)
+            dowait(DOWAIT_BLOCK, 0);
+        job->waited = 1;
+        retval = getstatus(job);
+ repeat:
+        ;
+    } while (*++argv);
+
+ out:
     return retval;
 }
 
+static struct job *
+growjobtab(void)
+{
+    size_t len;
+    ptrdiff_t offset;
+    struct job *jp, *jq;
+
+    len = njobs * sizeof(*jp);
+    jq = jobtab;
+    jp = ckrealloc(jq, len + 4 * sizeof(*jp));
+
+    offset = (char *)jp - (char *)jq;
+    if (offset) {
+        /* Relocate pointers */
+        size_t l = len;
+
+        jq = (struct job *)((char *)jq + l);
+        while (l) {
+            l -= sizeof(*jp);
+            jq--;
+#define joff(p) ((struct job *)((char *)(p) + l))
+#define jmove(p) (p) = (void *)((char *)(p) + offset)
+            if (joff(jp)->ps == &jq->ps0)
+                jmove(joff(jp)->ps);
+            if (joff(jp)->prev_job)
+                jmove(joff(jp)->prev_job);
+        }
+        if (curjob)
+            jmove(curjob);
+#undef joff
+#undef jmove
+    }
+
+    njobs += 4;
+    jobtab = jp;
+    jp = (struct job *)((char *)jp + len);
+    jq = jp + 3;
+    do {
+        jq->used = 0;
+    } while (--jq >= jp);
+    return jp;
+}
+
+/*
+ * Return a new job structure.
+ * Called with interrupts off.
+ */
+static struct job *
+makejob(union node *node, int nprocs)
+{
+    int i;
+    struct job *jp;
+
+    for (i = njobs, jp = jobtab; ; jp++) {
+        if (--i < 0) {
+            jp = growjobtab();
+            break;
+        }
+        if (jp->used == 0)
+            break;
+        if (jp->state != JOBDONE || !jp->waited)
+            continue;
+#if JOBS
+        if (jobctl)
+            continue;
+#endif
+        freejob(jp);
+        break;
+    }
+    memset(jp, 0, sizeof(*jp));
+#if JOBS
+    /* jp->jobctl is a bitfield.
+     * "jp->jobctl |= jobctl" likely to give awful code */
+    if (jobctl)
+        jp->jobctl = 1;
+#endif
+    jp->prev_job = curjob;
+    curjob = jp;
+    jp->used = 1;
+    jp->ps = &jp->ps0;
+    if (nprocs > 1) {
+        jp->ps = ckmalloc(nprocs * sizeof(struct procstat));
+    }
+    TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
+                jobno(jp)));
+    return jp;
+}
+
+#if JOBS
 /*
  * Return a string identifying a command (to be printed by the
  * jobs command).
  */
-
-#if JOBS
 static char *cmdnextc;
-
-static char *
-commandtext(union node *n)
-{
-    char *name;
-
-    STARTSTACKSTR(cmdnextc);
-    cmdtxt(n);
-    name = stackblock();
-    TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
-        name, cmdnextc, cmdnextc));
-    return savestr(name);
-}
-
-static void
-cmdtxt(union node *n)
-{
-    union node *np;
-    struct nodelist *lp;
-    const char *p;
-    char s[2];
-
-    if (!n)
-        return;
-    switch (n->type) {
-    default:
-#if DEBUG
-        abort();
-#endif
-    case NPIPE:
-        lp = n->npipe.cmdlist;
-        for (;;) {
-            cmdtxt(lp->n);
-            lp = lp->next;
-            if (!lp)
-                break;
-            cmdputs(" | ");
-        }
-        break;
-    case NSEMI:
-        p = "; ";
-        goto binop;
-    case NAND:
-        p = " && ";
-        goto binop;
-    case NOR:
-        p = " || ";
-binop:
-        cmdtxt(n->nbinary.ch1);
-        cmdputs(p);
-        n = n->nbinary.ch2;
-        goto donode;
-    case NREDIR:
-    case NBACKGND:
-        n = n->nredir.n;
-        goto donode;
-    case NNOT:
-        cmdputs("!");
-        n = n->nnot.com;
-donode:
-        cmdtxt(n);
-        break;
-    case NIF:
-        cmdputs("if ");
-        cmdtxt(n->nif.test);
-        cmdputs("; then ");
-        n = n->nif.ifpart;
-        if (n->nif.elsepart) {
-            cmdtxt(n);
-            cmdputs("; else ");
-            n = n->nif.elsepart;
-        }
-        p = "; fi";
-        goto dotail;
-    case NSUBSHELL:
-        cmdputs("(");
-        n = n->nredir.n;
-        p = ")";
-        goto dotail;
-    case NWHILE:
-        p = "while ";
-        goto until;
-    case NUNTIL:
-        p = "until ";
-until:
-        cmdputs(p);
-        cmdtxt(n->nbinary.ch1);
-        n = n->nbinary.ch2;
-        p = "; done";
-dodo:
-        cmdputs("; do ");
-dotail:
-        cmdtxt(n);
-        goto dotail2;
-    case NFOR:
-        cmdputs("for ");
-        cmdputs(n->nfor.var);
-        cmdputs(" in ");
-        cmdlist(n->nfor.args, 1);
-        n = n->nfor.body;
-        p = "; done";
-        goto dodo;
-    case NDEFUN:
-        cmdputs(n->narg.text);
-        p = "() { ... }";
-        goto dotail2;
-    case NCMD:
-        cmdlist(n->ncmd.args, 1);
-        cmdlist(n->ncmd.redirect, 0);
-        break;
-    case NARG:
-        p = n->narg.text;
-dotail2:
-        cmdputs(p);
-        break;
-    case NHERE:
-    case NXHERE:
-        p = "<<...";
-        goto dotail2;
-    case NCASE:
-        cmdputs("case ");
-        cmdputs(n->ncase.expr->narg.text);
-        cmdputs(" in ");
-        for (np = n->ncase.cases; np; np = np->nclist.next) {
-            cmdtxt(np->nclist.pattern);
-            cmdputs(") ");
-            cmdtxt(np->nclist.body);
-            cmdputs(";; ");
-        }
-        p = "esac";
-        goto dotail2;
-    case NTO:
-        p = ">";
-        goto redir;
-    case NCLOBBER:
-        p = ">|";
-        goto redir;
-    case NAPPEND:
-        p = ">>";
-        goto redir;
-    case NTOFD:
-        p = ">&";
-        goto redir;
-    case NFROM:
-        p = "<";
-        goto redir;
-    case NFROMFD:
-        p = "<&";
-        goto redir;
-    case NFROMTO:
-        p = "<>";
-redir:
-        s[0] = n->nfile.fd + '0';
-        s[1] = '\0';
-        cmdputs(s);
-        cmdputs(p);
-        if (n->type == NTOFD || n->type == NFROMFD) {
-            s[0] = n->ndup.dupfd + '0';
-            p = s;
-            goto dotail2;
-        } else {
-            n = n->nfile.fname;
-            goto donode;
-        }
-    }
-}
-
-static void
-cmdlist(union node *np, int sep)
-{
-    for (; np; np = np->narg.next) {
-        if (!sep)
-            cmdputs(spcstr);
-        cmdtxt(np);
-        if (sep && np->narg.next)
-            cmdputs(spcstr);
-    }
-}
 
 static void
@@ -7637 +4079 @@
         "%", "%%", "#", "##"
     };
+
     nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc);
     p = s;
@@ -7651 +4094 @@
             else
                 str = "${";
-            if (!(subtype & VSQUOTE) != !(quoted & 1)) {
-                quoted ^= 1;
-                c = '"';
-            } else
+            if (!(subtype & VSQUOTE) == !(quoted & 1))
                 goto dostr;
+            quoted ^= 1;
+            c = '"';
             break;
         case CTLENDVAR:
@@ -7668 +4110 @@
             str = "\"$(...)\"";
             goto dostr;
-#ifdef CONFIG_ASH_MATH_SUPPORT
+#if ENABLE_ASH_MATH_SUPPORT
         case CTLARI:
             str = "$((";
@@ -7704 +4146 @@
         }
         USTPUTC(c, nextc);
-checkstr:
+ checkstr:
         if (!str)
             continue;
-dostr:
+ dostr:
         while ((c = *str++)) {
             USTPUTC(c, nextc);
@@ -7719 +4161 @@
 }
 
-
-static void
-showpipe(struct job *jp, FILE *out)
-{
-    struct procstat *sp;
-    struct procstat *spend;
-
-    spend = jp->ps + jp->nprocs;
-    for (sp = jp->ps + 1; sp < spend; sp++)
-        fprintf(out, " | %s", sp->cmd);
-    outcslow('\n', out);
-    flushall();
-}
-
-static void
-xtcsetpgrp(int fd, pid_t pgrp)
-{
-    if (tcsetpgrp(fd, pgrp))
-        sh_error("Cannot set tty process group (%m)");
+/* cmdtxt() and cmdlist() call each other */
+static void cmdtxt(union node *n);
+
+static void
+cmdlist(union node *np, int sep)
+{
+    for (; np; np = np->narg.next) {
+        if (!sep)
+            cmdputs(" ");
+        cmdtxt(np);
+        if (sep && np->narg.next)
+            cmdputs(" ");
+    }
+}
+
+static void
+cmdtxt(union node *n)
+{
+    union node *np;
+    struct nodelist *lp;
+    const char *p;
+    char s[2];
+
+    if (!n)
+        return;
+    switch (n->type) {
+    default:
+#if DEBUG
+        abort();
+#endif
+    case NPIPE:
+        lp = n->npipe.cmdlist;
+        for (;;) {
+            cmdtxt(lp->n);
+            lp = lp->next;
+            if (!lp)
+                break;
+            cmdputs(" | ");
+        }
+        break;
+    case NSEMI:
+        p = "; ";
+        goto binop;
+    case NAND:
+        p = " && ";
+        goto binop;
+    case NOR:
+        p = " || ";
+ binop:
+        cmdtxt(n->nbinary.ch1);
+        cmdputs(p);
+        n = n->nbinary.ch2;
+        goto donode;
+    case NREDIR:
+    case NBACKGND:
+        n = n->nredir.n;
+        goto donode;
+    case NNOT:
+        cmdputs("!");
+        n = n->nnot.com;
+ donode:
+        cmdtxt(n);
+        break;
+    case NIF:
+        cmdputs("if ");
+        cmdtxt(n->nif.test);
+        cmdputs("; then ");
+        n = n->nif.ifpart;
+        if (n->nif.elsepart) {
+            cmdtxt(n);
+            cmdputs("; else ");
+            n = n->nif.elsepart;
+        }
+        p = "; fi";
+        goto dotail;
+    case NSUBSHELL:
+        cmdputs("(");
+        n = n->nredir.n;
+        p = ")";
+        goto dotail;
+    case NWHILE:
+        p = "while ";
+        goto until;
+    case NUNTIL:
+        p = "until ";
+ until:
+        cmdputs(p);
+        cmdtxt(n->nbinary.ch1);
+        n = n->nbinary.ch2;
+        p = "; done";
+ dodo:
+        cmdputs("; do ");
+ dotail:
+        cmdtxt(n);
+        goto dotail2;
+    case NFOR:
+        cmdputs("for ");
+        cmdputs(n->nfor.var);
+        cmdputs(" in ");
+        cmdlist(n->nfor.args, 1);
+        n = n->nfor.body;
+        p = "; done";
+        goto dodo;
+    case NDEFUN:
+        cmdputs(n->narg.text);
+        p = "() { ... }";
+        goto dotail2;
+    case NCMD:
+        cmdlist(n->ncmd.args, 1);
+        cmdlist(n->ncmd.redirect, 0);
+        break;
+    case NARG:
+        p = n->narg.text;
+ dotail2:
+        cmdputs(p);
+        break;
+    case NHERE:
+    case NXHERE:
+        p = "<<...";
+        goto dotail2;
+    case NCASE:
+        cmdputs("case ");
+        cmdputs(n->ncase.expr->narg.text);
+        cmdputs(" in ");
+        for (np = n->ncase.cases; np; np = np->nclist.next) {
+            cmdtxt(np->nclist.pattern);
+            cmdputs(") ");
+            cmdtxt(np->nclist.body);
+            cmdputs(";; ");
+        }
+        p = "esac";
+        goto dotail2;
+    case NTO:
+        p = ">";
+        goto redir;
+    case NCLOBBER:
+        p = ">|";
+        goto redir;
+    case NAPPEND:
+        p = ">>";
+        goto redir;
+    case NTOFD:
+        p = ">&";
+        goto redir;
+    case NFROM:
+        p = "<";
+        goto redir;
+    case NFROMFD:
+        p = "<&";
+        goto redir;
+    case NFROMTO:
+        p = "<>";
+ redir:
+        s[0] = n->nfile.fd + '0';
+        s[1] = '\0';
+        cmdputs(s);
+        cmdputs(p);
+        if (n->type == NTOFD || n->type == NFROMFD) {
+            s[0] = n->ndup.dupfd + '0';
+            p = s;
+            goto dotail2;
+        }
+        n = n->nfile.fname;
+        goto donode;
+    }
+}
+
+static char *
+commandtext(union node *n)
+{
+    char *name;
+
+    STARTSTACKSTR(cmdnextc);
+    cmdtxt(n);
+    name = stackblock();
+    TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
+            name, cmdnextc, cmdnextc));
+    return ckstrdup(name);
 }
 #endif /* JOBS */
 
+/*
+ * Fork off a subshell.  If we are doing job control, give the subshell its
+ * own process group.  Jp is a job structure that the job is to be added to.
+ * N is the command that will be evaluated by the child.  Both jp and n may
+ * be NULL.  The mode parameter can be one of the following:
+ *      FORK_FG - Fork off a foreground process.
+ *      FORK_BG - Fork off a background process.
+ *      FORK_NOJOB - Like FORK_FG, but don't give the process its own
+ *                   process group even if job control is on.
+ *
+ * When job control is turned off, background processes have their standard
+ * input redirected to /dev/null (except for the second and later processes
+ * in a pipeline).
+ *
+ * Called with interrupts off.
+ */
+/*
+ * Clear traps on a fork.
+ */
+static void
+clear_traps(void)
+{
+    char **tp;
+
+    for (tp = trap; tp < &trap[NSIG]; tp++) {
+        if (*tp && **tp) {      /* trap not NULL or SIG_IGN */
+            INT_OFF;
+            free(*tp);
+            *tp = NULL;
+            if (tp != &trap[0])
+                setsignal(tp - trap);
+            INT_ON;
+        }
+    }
+}
+
+/* Lives far away from here, needed for forkchild */
+static void closescript(void);
+/* Called after fork(), in child */
+static void
+forkchild(struct job *jp, union node *n, int mode)
+{
+    int oldlvl;
+
+    TRACE(("Child shell %d\n", getpid()));
+    oldlvl = shlvl;
+    shlvl++;
+
+    closescript();
+    clear_traps();
+#if JOBS
+    /* do job control only in root shell */
+    jobctl = 0;
+    if (mode != FORK_NOJOB && jp->jobctl && !oldlvl) {
+        pid_t pgrp;
+
+        if (jp->nprocs == 0)
+            pgrp = getpid();
+        else
+            pgrp = jp->ps[0].pid;
+        /* This can fail because we are doing it in the parent also */
+        (void)setpgid(0, pgrp);
+        if (mode == FORK_FG)
+            xtcsetpgrp(ttyfd, pgrp);
+        setsignal(SIGTSTP);
+        setsignal(SIGTTOU);
+    } else
+#endif
+    if (mode == FORK_BG) {
+        ignoresig(SIGINT);
+        ignoresig(SIGQUIT);
+        if (jp->nprocs == 0) {
+            close(0);
+            if (open(bb_dev_null, O_RDONLY) != 0)
+                ash_msg_and_raise_error("can't open %s", bb_dev_null);
+        }
+    }
+    if (!oldlvl && iflag) {
+        setsignal(SIGINT);
+        setsignal(SIGQUIT);
+        setsignal(SIGTERM);
+    }
+#if JOBS
+    /* For "jobs | cat" to work like in bash, we must retain list of jobs
+     * in child, but we do need to remove ourself */
+    if (jp)
+        freejob(jp);
+#else
+    for (jp = curjob; jp; jp = jp->prev_job)
+        freejob(jp);
+#endif
+    jobless = 0;
+}
+
+/* Called after fork(), in parent */
+static void
+forkparent(struct job *jp, union node *n, int mode, pid_t pid)
+{
+    TRACE(("In parent shell: child = %d\n", pid));
+    if (!jp) {
+        while (jobless && dowait(DOWAIT_NORMAL, 0) > 0);
+        jobless++;
+        return;
+    }
+#if JOBS
+    if (mode != FORK_NOJOB && jp->jobctl) {
+        int pgrp;
+
+        if (jp->nprocs == 0)
+            pgrp = pid;
+        else
+            pgrp = jp->ps[0].pid;
+        /* This can fail because we are doing it in the child also */
+        setpgid(pid, pgrp);
+    }
+#endif
+    if (mode == FORK_BG) {
+        backgndpid = pid;               /* set $! */
+        set_curjob(jp, CUR_RUNNING);
+    }
+    if (jp) {
+        struct procstat *ps = &jp->ps[jp->nprocs++];
+        ps->pid = pid;
+        ps->status = -1;
+        ps->cmd = nullstr;
+#if JOBS
+        if (jobctl && n)
+            ps->cmd = commandtext(n);
+#endif
+    }
+}
+
 static int
-getstatus(struct job *job) {
+forkshell(struct job *jp, union node *n, int mode)
+{
+    int pid;
+
+    TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
+    pid = fork();
+    if (pid < 0) {
+        TRACE(("Fork failed, errno=%d", errno));
+        if (jp)
+            freejob(jp);
+        ash_msg_and_raise_error("cannot fork");
+    }
+    if (pid == 0)
+        forkchild(jp, n, mode);
+    else
+        forkparent(jp, n, mode, pid);
+    return pid;
+}
+
+/*
+ * Wait for job to finish.
+ *
+ * Under job control we have the problem that while a child process is
+ * running interrupts generated by the user are sent to the child but not
+ * to the shell.  This means that an infinite loop started by an inter-
+ * active user may be hard to kill.  With job control turned off, an
+ * interactive user may place an interactive program inside a loop.  If
+ * the interactive program catches interrupts, the user doesn't want
+ * these interrupts to also abort the loop.  The approach we take here
+ * is to have the shell ignore interrupt signals while waiting for a
+ * foreground process to terminate, and then send itself an interrupt
+ * signal if the child process was terminated by an interrupt signal.
+ * Unfortunately, some programs want to do a bit of cleanup and then
+ * exit on interrupt; unless these processes terminate themselves by
+ * sending a signal to themselves (instead of calling exit) they will
+ * confuse this approach.
+ *
+ * Called with interrupts off.
+ */
+static int
+waitforjob(struct job *jp)
+{
+    int st;
+
+    TRACE(("waitforjob(%%%d) called\n", jobno(jp)));
+    while (jp->state == JOBRUNNING) {
+        dowait(DOWAIT_BLOCK, jp);
+    }
+    st = getstatus(jp);
+#if JOBS
+    if (jp->jobctl) {
+        xtcsetpgrp(ttyfd, rootpid);
+        /*
+         * This is truly gross.
+         * If we're doing job control, then we did a TIOCSPGRP which
+         * caused us (the shell) to no longer be in the controlling
+         * session -- so we wouldn't have seen any ^C/SIGINT.  So, we
+         * intuit from the subprocess exit status whether a SIGINT
+         * occurred, and if so interrupt ourselves.  Yuck.  - mycroft
+         */
+        if (jp->sigint)
+            raise(SIGINT);
+    }
+    if (jp->state == JOBDONE)
+#endif
+        freejob(jp);
+    return st;
+}
+
+/*
+ * return 1 if there are stopped jobs, otherwise 0
+ */
+static int
+stoppedjobs(void)
+{
+    struct job *jp;
+    int retval;
+
+    retval = 0;
+    if (job_warning)
+        goto out;
+    jp = curjob;
+    if (jp && jp->state == JOBSTOPPED) {
+        out2str("You have stopped jobs.\n");
+        job_warning = 2;
+        retval++;
+    }
+ out:
+    return retval;
+}
+
+
+/* ============ redir.c
+ *
+ * Code for dealing with input/output redirection.
+ */
+
+#define EMPTY -2                /* marks an unused slot in redirtab */
+#ifndef PIPE_BUF
+# define PIPESIZE 4096          /* amount of buffering in a pipe */
+#else
+# define PIPESIZE PIPE_BUF
+#endif
+
+/*
+ * Open a file in noclobber mode.
+ * The code was copied from bash.
+ */
+static int
+noclobberopen(const char *fname)
+{
+    int r, fd;
+    struct stat finfo, finfo2;
+
+    /*
+     * If the file exists and is a regular file, return an error
+     * immediately.
+     */
+    r = stat(fname, &finfo);
+    if (r == 0 && S_ISREG(finfo.st_mode)) {
+        errno = EEXIST;
+        return -1;
+    }
+
+    /*
+     * If the file was not present (r != 0), make sure we open it
+     * exclusively so that if it is created before we open it, our open
+     * will fail.  Make sure that we do not truncate an existing file.
+     * Note that we don't turn on O_EXCL unless the stat failed -- if the
+     * file was not a regular file, we leave O_EXCL off.
+     */
+    if (r != 0)
+        return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
+    fd = open(fname, O_WRONLY|O_CREAT, 0666);
+
+    /* If the open failed, return the file descriptor right away. */
+    if (fd < 0)
+        return fd;
+
+    /*
+     * OK, the open succeeded, but the file may have been changed from a
+     * non-regular file to a regular file between the stat and the open.
+     * We are assuming that the O_EXCL open handles the case where FILENAME
+     * did not exist and is symlinked to an existing file between the stat
+     * and open.
+     */
+
+    /*
+     * If we can open it and fstat the file descriptor, and neither check
+     * revealed that it was a regular file, and the file has not been
+     * replaced, return the file descriptor.
+     */
+    if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode)
+     && finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
+        return fd;
+
+    /* The file has been replaced.  badness. */
+    close(fd);
+    errno = EEXIST;
+    return -1;
+}
+
+/*
+ * Handle here documents.  Normally we fork off a process to write the
+ * data to a pipe.  If the document is short, we can stuff the data in
+ * the pipe without forking.
+ */
+/* openhere needs this forward reference */
+static void expandhere(union node *arg, int fd);
+static int
+openhere(union node *redir)
+{
+    int pip[2];
+    size_t len = 0;
+
+    if (pipe(pip) < 0)
+        ash_msg_and_raise_error("pipe call failed");
+    if (redir->type == NHERE) {
+        len = strlen(redir->nhere.doc->narg.text);
+        if (len <= PIPESIZE) {
+            full_write(pip[1], redir->nhere.doc->narg.text, len);
+            goto out;
+        }
+    }
+    if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
+        close(pip[0]);
+        signal(SIGINT, SIG_IGN);
+        signal(SIGQUIT, SIG_IGN);
+        signal(SIGHUP, SIG_IGN);
+#ifdef SIGTSTP
+        signal(SIGTSTP, SIG_IGN);
+#endif
+        signal(SIGPIPE, SIG_DFL);
+        if (redir->type == NHERE)
+            full_write(pip[1], redir->nhere.doc->narg.text, len);
+        else
+            expandhere(redir->nhere.doc, pip[1]);
+        _exit(0);
+    }
+ out:
+    close(pip[1]);
+    return pip[0];
+}
+
+static int
+openredirect(union node *redir)
+{
+    char *fname;
+    int f;
+
+    switch (redir->nfile.type) {
+    case NFROM:
+        fname = redir->nfile.expfname;
+        f = open(fname, O_RDONLY);
+        if (f < 0)
+            goto eopen;
+        break;
+    case NFROMTO:
+        fname = redir->nfile.expfname;
+        f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666);
+        if (f < 0)
+            goto ecreate;
+        break;
+    case NTO:
+        /* Take care of noclobber mode. */
+        if (Cflag) {
+            fname = redir->nfile.expfname;
+            f = noclobberopen(fname);
+            if (f < 0)
+                goto ecreate;
+            break;
+        }
+        /* FALLTHROUGH */
+    case NCLOBBER:
+        fname = redir->nfile.expfname;
+        f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+        if (f < 0)
+            goto ecreate;
+        break;
+    case NAPPEND:
+        fname = redir->nfile.expfname;
+        f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666);
+        if (f < 0)
+            goto ecreate;
+        break;
+    default:
+#if DEBUG
+        abort();
+#endif
+        /* Fall through to eliminate warning. */
+    case NTOFD:
+    case NFROMFD:
+        f = -1;
+        break;
+    case NHERE:
+    case NXHERE:
+        f = openhere(redir);
+        break;
+    }
+
+    return f;
+ ecreate:
+    ash_msg_and_raise_error("cannot create %s: %s", fname, errmsg(errno, "nonexistent directory"));
+ eopen:
+    ash_msg_and_raise_error("cannot open %s: %s", fname, errmsg(errno, "no such file"));
+}
+
+/*
+ * Copy a file descriptor to be >= to.  Returns -1
+ * if the source file descriptor is closed, EMPTY if there are no unused
+ * file descriptors left.
+ */
+static int
+copyfd(int from, int to)
+{
+    int newfd;
+
+    newfd = fcntl(from, F_DUPFD, to);
+    if (newfd < 0) {
+        if (errno == EMFILE)
+            return EMPTY;
+        ash_msg_and_raise_error("%d: %m", from);
+    }
+    return newfd;
+}
+
+static void
+dupredirect(union node *redir, int f)
+{
+    int fd = redir->nfile.fd;
+
+    if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
+        if (redir->ndup.dupfd >= 0) {   /* if not ">&-" */
+            copyfd(redir->ndup.dupfd, fd);
+        }
+        return;
+    }
+
+    if (f != fd) {
+        copyfd(f, fd);
+        close(f);
+    }
+}
+
+/*
+ * Process a list of redirection commands.  If the REDIR_PUSH flag is set,
+ * old file descriptors are stashed away so that the redirection can be
+ * undone by calling popredir.  If the REDIR_BACKQ flag is set, then the
+ * standard output, and the standard error if it becomes a duplicate of
+ * stdout, is saved in memory.
+ */
+/* flags passed to redirect */
+#define REDIR_PUSH    01        /* save previous values of file descriptors */
+#define REDIR_SAVEFD2 03        /* set preverrout */
+static void
+redirect(union node *redir, int flags)
+{
+    union node *n;
+    struct redirtab *sv;
+    int i;
+    int fd;
+    int newfd;
+    int *p;
+    nullredirs++;
+    if (!redir) {
+        return;
+    }
+    sv = NULL;
+    INT_OFF;
+    if (flags & REDIR_PUSH) {
+        struct redirtab *q;
+        q = ckmalloc(sizeof(struct redirtab));
+        q->next = redirlist;
+        redirlist = q;
+        q->nullredirs = nullredirs - 1;
+        for (i = 0; i < 10; i++)
+            q->renamed[i] = EMPTY;
+        nullredirs = 0;
+        sv = q;
+    }
+    n = redir;
+    do {
+        fd = n->nfile.fd;
+        if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD)
+         && n->ndup.dupfd == fd)
+            continue; /* redirect from/to same file descriptor */
+
+        newfd = openredirect(n);
+        if (fd == newfd)
+            continue;
+        if (sv && *(p = &sv->renamed[fd]) == EMPTY) {
+            i = fcntl(fd, F_DUPFD, 10);
+
+            if (i == -1) {
+                i = errno;
+                if (i != EBADF) {
+                    close(newfd);
+                    errno = i;
+                    ash_msg_and_raise_error("%d: %m", fd);
+                    /* NOTREACHED */
+                }
+            } else {
+                *p = i;
+                close(fd);
+            }
+        } else {
+            close(fd);
+        }
+        dupredirect(n, newfd);
+    } while ((n = n->nfile.next));
+    INT_ON;
+    if (flags & REDIR_SAVEFD2 && sv && sv->renamed[2] >= 0)
+        preverrout_fd = sv->renamed[2];
+}
+
+/*
+ * Undo the effects of the last redirection.
+ */
+static void
+popredir(int drop)
+{
+    struct redirtab *rp;
+    int i;
+
+    if (--nullredirs >= 0)
+        return;
+    INT_OFF;
+    rp = redirlist;
+    for (i = 0; i < 10; i++) {
+        if (rp->renamed[i] != EMPTY) {
+            if (!drop) {
+                close(i);
+                copyfd(rp->renamed[i], i);
+            }
+            close(rp->renamed[i]);
+        }
+    }
+    redirlist = rp->next;
+    nullredirs = rp->nullredirs;
+    free(rp);
+    INT_ON;
+}
+
+/*
+ * Undo all redirections.  Called on error or interrupt.
+ */
+
+/*
+ * Discard all saved file descriptors.
+ */
+static void
+clearredir(int drop)
+{
+    for (;;) {
+        nullredirs = 0;
+        if (!redirlist)
+            break;
+        popredir(drop);
+    }
+}
+
+static int
+redirectsafe(union node *redir, int flags)
+{
+    int err;
+    volatile int saveint;
+    struct jmploc *volatile savehandler = exception_handler;
+    struct jmploc jmploc;
+
+    SAVE_INT(saveint);
+    err = setjmp(jmploc.loc) * 2;
+    if (!err) {
+        exception_handler = &jmploc;
+        redirect(redir, flags);
+    }
+    exception_handler = savehandler;
+    if (err && exception != EXERROR)
+        longjmp(exception_handler->loc, 1);
+    RESTORE_INT(saveint);
+    return err;
+}
+
+
+/* ============ Routines to expand arguments to commands
+ *
+ * We have to deal with backquotes, shell variables, and file metacharacters.
+ */
+
+/*
+ * expandarg flags
+ */
+#define EXP_FULL        0x1     /* perform word splitting & file globbing */
+#define EXP_TILDE       0x2     /* do normal tilde expansion */
+#define EXP_VARTILDE    0x4     /* expand tildes in an assignment */
+#define EXP_REDIR       0x8     /* file glob for a redirection (1 match only) */
+#define EXP_CASE        0x10    /* keeps quotes around for CASE pattern */
+#define EXP_RECORD      0x20    /* need to record arguments for ifs breakup */
+#define EXP_VARTILDE2   0x40    /* expand tildes after colons only */
+#define EXP_WORD        0x80    /* expand word in parameter expansion */
+#define EXP_QWORD       0x100   /* expand word in quoted parameter expansion */
+/*
+ * _rmescape() flags
+ */
+#define RMESCAPE_ALLOC  0x1     /* Allocate a new string */
+#define RMESCAPE_GLOB   0x2     /* Add backslashes for glob */
+#define RMESCAPE_QUOTED 0x4     /* Remove CTLESC unless in quotes */
+#define RMESCAPE_GROW   0x8     /* Grow strings instead of stalloc */
+#define RMESCAPE_HEAP   0x10    /* Malloc strings instead of stalloc */
+
+/*
+ * Structure specifying which parts of the string should be searched
+ * for IFS characters.
+ */
+struct ifsregion {
+    struct ifsregion *next; /* next region in list */
+    int begoff;             /* offset of start of region */
+    int endoff;             /* offset of end of region */
+    int nulonly;            /* search for nul bytes only */
+};
+
+struct arglist {
+    struct strlist *list;
+    struct strlist **lastp;
+};
+
+/* output of current string */
+static char *expdest;
+/* list of back quote expressions */
+static struct nodelist *argbackq;
+/* first struct in list of ifs regions */
+static struct ifsregion ifsfirst;
+/* last struct in list */
+static struct ifsregion *ifslastp;
+/* holds expanded arg list */
+static struct arglist exparg;
+
+/*
+ * Our own itoa().
+ */
+static int
+cvtnum(arith_t num)
+{
+    int len;
+
+    expdest = makestrspace(32, expdest);
+#if ENABLE_ASH_MATH_SUPPORT_64
+    len = fmtstr(expdest, 32, "%lld", (long long) num);
+#else
+    len = fmtstr(expdest, 32, "%ld", num);
+#endif
+    STADJUST(len, expdest);
+    return len;
+}
+
+static size_t
+esclen(const char *start, const char *p)
+{
+    size_t esc = 0;
+
+    while (p > start && *--p == CTLESC) {
+        esc++;
+    }
+    return esc;
+}
+
+/*
+ * Remove any CTLESC characters from a string.
+ */
+static char *
+_rmescapes(char *str, int flag)
+{
+    static const char qchars[] ALIGN1 = { CTLESC, CTLQUOTEMARK, '\0' };
+
+    char *p, *q, *r;
+    unsigned inquotes;
+    int notescaped;
+    int globbing;
+
+    p = strpbrk(str, qchars);
+    if (!p) {
+        return str;
+    }
+    q = p;
+    r = str;
+    if (flag & RMESCAPE_ALLOC) {
+        size_t len = p - str;
+        size_t fulllen = len + strlen(p) + 1;
+
+        if (flag & RMESCAPE_GROW) {
+            r = makestrspace(fulllen, expdest);
+        } else if (flag & RMESCAPE_HEAP) {
+            r = ckmalloc(fulllen);
+        } else {
+            r = stalloc(fulllen);
+        }
+        q = r;
+        if (len > 0) {
+            q = memcpy(q, str, len) + len;
+        }
+    }
+    inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED;
+    globbing = flag & RMESCAPE_GLOB;
+    notescaped = globbing;
+    while (*p) {
+        if (*p == CTLQUOTEMARK) {
+            inquotes = ~inquotes;
+            p++;
+            notescaped = globbing;
+            continue;
+        }
+        if (*p == '\\') {
+            /* naked back slash */
+            notescaped = 0;
+            goto copy;
+        }
+        if (*p == CTLESC) {
+            p++;
+            if (notescaped && inquotes && *p != '/') {
+                *q++ = '\\';
+            }
+        }
+        notescaped = globbing;
+ copy:
+        *q++ = *p++;
+    }
+    *q = '\0';
+    if (flag & RMESCAPE_GROW) {
+        expdest = r;
+        STADJUST(q - r + 1, expdest);
+    }
+    return r;
+}
+#define rmescapes(p) _rmescapes((p), 0)
+
+#define pmatch(a, b) !fnmatch((a), (b), 0)
+
+/*
+ * Prepare a pattern for a expmeta (internal glob(3)) call.
+ *
+ * Returns an stalloced string.
+ */
+static char *
+preglob(const char *pattern, int quoted, int flag)
+{
+    flag |= RMESCAPE_GLOB;
+    if (quoted) {
+        flag |= RMESCAPE_QUOTED;
+    }
+    return _rmescapes((char *)pattern, flag);
+}
+
+/*
+ * Put a string on the stack.
+ */
+static void
+memtodest(const char *p, size_t len, int syntax, int quotes)
+{
+    char *q = expdest;
+
+    q = makestrspace(len * 2, q);
+
+    while (len--) {
+        int c = signed_char2int(*p++);
+        if (!c)
+            continue;
+        if (quotes && (SIT(c, syntax) == CCTL || SIT(c, syntax) == CBACK))
+            USTPUTC(CTLESC, q);
+        USTPUTC(c, q);
+    }
+
+    expdest = q;
+}
+
+static void
+strtodest(const char *p, int syntax, int quotes)
+{
+    memtodest(p, strlen(p), syntax, quotes);
+}
+
+/*
+ * Record the fact that we have to scan this region of the
+ * string for IFS characters.
+ */
+static void
+recordregion(int start, int end, int nulonly)
+{
+    struct ifsregion *ifsp;
+
+    if (ifslastp == NULL) {
+        ifsp = &ifsfirst;
+    } else {
+        INT_OFF;
+        ifsp = ckmalloc(sizeof(*ifsp));
+        ifsp->next = NULL;
+        ifslastp->next = ifsp;
+        INT_ON;
+    }
+    ifslastp = ifsp;
+    ifslastp->begoff = start;
+    ifslastp->endoff = end;
+    ifslastp->nulonly = nulonly;
+}
+
+static void
+removerecordregions(int endoff)
+{
+    if (ifslastp == NULL)
+        return;
+
+    if (ifsfirst.endoff > endoff) {
+        while (ifsfirst.next != NULL) {
+            struct ifsregion *ifsp;
+            INT_OFF;
+            ifsp = ifsfirst.next->next;
+            free(ifsfirst.next);
+            ifsfirst.next = ifsp;
+            INT_ON;
+        }
+        if (ifsfirst.begoff > endoff)
+            ifslastp = NULL;
+        else {
+            ifslastp = &ifsfirst;
+            ifsfirst.endoff = endoff;
+        }
+        return;
+    }
+
+    ifslastp = &ifsfirst;
+    while (ifslastp->next && ifslastp->next->begoff < endoff)
+        ifslastp=ifslastp->next;
+    while (ifslastp->next != NULL) {
+        struct ifsregion *ifsp;
+        INT_OFF;
+        ifsp = ifslastp->next->next;
+        free(ifslastp->next);
+        ifslastp->next = ifsp;
+        INT_ON;
+    }
+    if (ifslastp->endoff > endoff)
+        ifslastp->endoff = endoff;
+}
+
+static char *
+exptilde(char *startp, char *p, int flag)
+{
+    char c;
+    char *name;
+    struct passwd *pw;
+    const char *home;
+    int quotes = flag & (EXP_FULL | EXP_CASE);
+    int startloc;
+
+    name = p + 1;
+
+    while ((c = *++p) != '\0') {
+        switch (c) {
+        case CTLESC:
+            return startp;
+        case CTLQUOTEMARK:
+            return startp;
+        case ':':
+            if (flag & EXP_VARTILDE)
+                goto done;
+            break;
+        case '/':
+        case CTLENDVAR:
+            goto done;
+        }
+    }
+ done:
+    *p = '\0';
+    if (*name == '\0') {
+        home = lookupvar(homestr);
+    } else {
+        pw = getpwnam(name);
+        if (pw == NULL)
+            goto lose;
+        home = pw->pw_dir;
+    }
+    if (!home || !*home)
+        goto lose;
+    *p = c;
+    startloc = expdest - (char *)stackblock();
+    strtodest(home, SQSYNTAX, quotes);
+    recordregion(startloc, expdest - (char *)stackblock(), 0);
+    return p;
+ lose:
+    *p = c;
+    return startp;
+}
+
+/*
+ * 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.
+ */
+struct backcmd {                /* result of evalbackcmd */
+    int fd;                 /* file descriptor to read from */
+    char *buf;              /* buffer */
+    int nleft;              /* number of chars in buffer */
+    struct job *jp;         /* job structure for command */
+};
+
+/* These forward decls are needed to use "eval" code for backticks handling: */
+static int back_exitstatus; /* exit status of backquoted command */
+#define EV_EXIT 01              /* exit after evaluating tree */
+static void evaltree(union node *, int);
+
+static void
+evalbackcmd(union node *n, struct backcmd *result)
+{
+    int saveherefd;
+
+    result->fd = -1;
+    result->buf = NULL;
+    result->nleft = 0;
+    result->jp = NULL;
+    if (n == NULL) {
+        goto out;
+    }
+
+    saveherefd = herefd;
+    herefd = -1;
+
+    {
+        int pip[2];
+        struct job *jp;
+
+        if (pipe(pip) < 0)
+            ash_msg_and_raise_error("pipe call failed");
+        jp = makejob(n, 1);
+        if (forkshell(jp, n, FORK_NOJOB) == 0) {
+            FORCE_INT_ON;
+            close(pip[0]);
+            if (pip[1] != 1) {
+                close(1);
+                copyfd(pip[1], 1);
+                close(pip[1]);
+            }
+            eflag = 0;
+            evaltree(n, EV_EXIT); /* actually evaltreenr... */
+            /* NOTREACHED */
+        }
+        close(pip[1]);
+        result->fd = pip[0];
+        result->jp = jp;
+    }
+    herefd = saveherefd;
+ out:
+    TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
+        result->fd, result->buf, result->nleft, result->jp));
+}
+
+/*
+ * Expand stuff in backwards quotes.
+ */
+static void
+expbackq(union node *cmd, int quoted, int quotes)
+{
+    struct backcmd in;
+    int i;
+    char buf[128];
+    char *p;
+    char *dest;
+    int startloc;
+    int syntax = quoted? DQSYNTAX : BASESYNTAX;
+    struct stackmark smark;
+
+    INT_OFF;
+    setstackmark(&smark);
+    dest = expdest;
+    startloc = dest - (char *)stackblock();
+    grabstackstr(dest);
+    evalbackcmd(cmd, &in);
+    popstackmark(&smark);
+
+    p = in.buf;
+    i = in.nleft;
+    if (i == 0)
+        goto read;
+    for (;;) {
+        memtodest(p, i, syntax, quotes);
+ read:
+        if (in.fd < 0)
+            break;
+        i = safe_read(in.fd, buf, sizeof(buf));
+        TRACE(("expbackq: read returns %d\n", i));
+        if (i <= 0)
+            break;
+        p = buf;
+    }
+
+    if (in.buf)
+        free(in.buf);
+    if (in.fd >= 0) {
+        close(in.fd);
+        back_exitstatus = waitforjob(in.jp);
+    }
+    INT_ON;
+
+    /* Eat all trailing newlines */
+    dest = expdest;
+    for (; dest > (char *)stackblock() && dest[-1] == '\n';)
+        STUNPUTC(dest);
+    expdest = dest;
+
+    if (quoted == 0)
+        recordregion(startloc, dest - (char *)stackblock(), 0);
+    TRACE(("evalbackq: size=%d: \"%.*s\"\n",
+        (dest - (char *)stackblock()) - startloc,
+        (dest - (char *)stackblock()) - startloc,
+        stackblock() + startloc));
+}
+
+#if ENABLE_ASH_MATH_SUPPORT
+/*
+ * Expand arithmetic expression.  Backup to start of expression,
+ * evaluate, place result in (backed up) result, adjust string position.
+ */
+static void
+expari(int quotes)
+{
+    char *p, *start;
+    int begoff;
+    int flag;
+    int len;
+
+    /*      ifsfree(); */
+
+    /*
+     * This routine is slightly over-complicated for
+     * efficiency.  Next we scan backwards looking for the
+     * start of arithmetic.
+     */
+    start = stackblock();
+    p = expdest - 1;
+    *p = '\0';
+    p--;
+    do {
+        int esc;
+
+        while (*p != CTLARI) {
+            p--;
+#if DEBUG
+            if (p < start) {
+                ash_msg_and_raise_error("missing CTLARI (shouldn't happen)");
+            }
+#endif
+        }
+
+        esc = esclen(start, p);
+        if (!(esc % 2)) {
+            break;
+        }
+
+        p -= esc + 1;
+    } while (1);
+
+    begoff = p - start;
+
+    removerecordregions(begoff);
+
+    flag = p[1];
+
+    expdest = p;
+
+    if (quotes)
+        rmescapes(p + 2);
+
+    len = cvtnum(dash_arith(p + 2));
+
+    if (flag != '"')
+        recordregion(begoff, begoff + len, 0);
+}
+#endif
+
+/* argstr needs it */
+static char *evalvar(char *p, int flag);
+
+/*
+ * Perform variable and command substitution.  If EXP_FULL is set, output CTLESC
+ * characters to allow for further processing.  Otherwise treat
+ * $@ like $* since no splitting will be performed.
+ */
+static void
+argstr(char *p, int flag)
+{
+    static const char spclchars[] ALIGN1 = {
+        '=',
+        ':',
+        CTLQUOTEMARK,
+        CTLENDVAR,
+        CTLESC,
+        CTLVAR,
+        CTLBACKQ,
+        CTLBACKQ | CTLQUOTE,
+#if ENABLE_ASH_MATH_SUPPORT
+        CTLENDARI,
+#endif
+        0
+    };
+    const char *reject = spclchars;
+    int c;
+    int quotes = flag & (EXP_FULL | EXP_CASE);      /* do CTLESC */
+    int breakall = flag & EXP_WORD;
+    int inquotes;
+    size_t length;
+    int startloc;
+
+    if (!(flag & EXP_VARTILDE)) {
+        reject += 2;
+    } else if (flag & EXP_VARTILDE2) {
+        reject++;
+    }
+    inquotes = 0;
+    length = 0;
+    if (flag & EXP_TILDE) {
+        char *q;
+
+        flag &= ~EXP_TILDE;
+ tilde:
+        q = p;
+        if (*q == CTLESC && (flag & EXP_QWORD))
+            q++;
+        if (*q == '~')
+            p = exptilde(p, q, flag);
+    }
+ start:
+    startloc = expdest - (char *)stackblock();
+    for (;;) {
+        length += strcspn(p + length, reject);
+        c = p[length];
+        if (c && (!(c & 0x80)
+#if ENABLE_ASH_MATH_SUPPORT
+                    || c == CTLENDARI
+#endif
+           )) {
+            /* c == '=' || c == ':' || c == CTLENDARI */
+            length++;
+        }
+        if (length > 0) {
+            int newloc;
+            expdest = stack_nputstr(p, length, expdest);
+            newloc = expdest - (char *)stackblock();
+            if (breakall && !inquotes && newloc > startloc) {
+                recordregion(startloc, newloc, 0);
+            }
+            startloc = newloc;
+        }
+        p += length + 1;
+        length = 0;
+
+        switch (c) {
+        case '\0':
+            goto breakloop;
+        case '=':
+            if (flag & EXP_VARTILDE2) {
+                p--;
+                continue;
+            }
+            flag |= EXP_VARTILDE2;
+            reject++;
+            /* fall through */
+        case ':':
+            /*
+             * sort of a hack - expand tildes in variable
+             * assignments (after the first '=' and after ':'s).
+             */
+            if (*--p == '~') {
+                goto tilde;
+            }
+            continue;
+        }
+
+        switch (c) {
+        case CTLENDVAR: /* ??? */
+            goto breakloop;
+        case CTLQUOTEMARK:
+            /* "$@" syntax adherence hack */
+            if (
+                !inquotes &&
+                !memcmp(p, dolatstr, 4) &&
+                (p[4] == CTLQUOTEMARK || (
+                    p[4] == CTLENDVAR &&
+                    p[5] == CTLQUOTEMARK
+                ))
+            ) {
+                p = evalvar(p + 1, flag) + 1;
+                goto start;
+            }
+            inquotes = !inquotes;
+ addquote:
+            if (quotes) {
+                p--;
+                length++;
+                startloc++;
+            }
+            break;
+        case CTLESC:
+            startloc++;
+            length++;
+            goto addquote;
+        case CTLVAR:
+            p = evalvar(p, flag);
+            goto start;
+        case CTLBACKQ:
+            c = 0;
+        case CTLBACKQ|CTLQUOTE:
+            expbackq(argbackq->n, c, quotes);
+            argbackq = argbackq->next;
+            goto start;
+#if ENABLE_ASH_MATH_SUPPORT
+        case CTLENDARI:
+            p--;
+            expari(quotes);
+            goto start;
+#endif
+        }
+    }
+ breakloop:
+    ;
+}
+
+static char *
+scanleft(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
+    int zero)
+{
+    char *loc;
+    char *loc2;
+    char c;
+
+    loc = startp;
+    loc2 = rmesc;
+    do {
+        int match;
+        const char *s = loc2;
+        c = *loc2;
+        if (zero) {
+            *loc2 = '\0';
+            s = rmesc;
+        }
+        match = pmatch(str, s);
+        *loc2 = c;
+        if (match)
+            return loc;
+        if (quotes && *loc == CTLESC)
+            loc++;
+        loc++;
+        loc2++;
+    } while (c);
+    return 0;
+}
+
+static char *
+scanright(char *startp, char *rmesc, char *rmescend, char *str, int quotes,
+    int zero)
+{
+    int esc = 0;
+    char *loc;
+    char *loc2;
+
+    for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
+        int match;
+        char c = *loc2;
+        const char *s = loc2;
+        if (zero) {
+            *loc2 = '\0';
+            s = rmesc;
+        }
+        match = pmatch(str, s);
+        *loc2 = c;
+        if (match)
+            return loc;
+        loc--;
+        if (quotes) {
+            if (--esc < 0) {
+                esc = esclen(startp, loc);
+            }
+            if (esc % 2) {
+                esc--;
+                loc--;
+            }
+        }
+    }
+    return 0;
+}
+
+static void varunset(const char *, const char *, const char *, int) ATTRIBUTE_NORETURN;
+static void
+varunset(const char *end, const char *var, const char *umsg, int varflags)
+{
+    const char *msg;
+    const char *tail;
+
+    tail = nullstr;
+    msg = "parameter not set";
+    if (umsg) {
+        if (*end == CTLENDVAR) {
+            if (varflags & VSNUL)
+                tail = " or null";
+        } else
+            msg = umsg;
+    }
+    ash_msg_and_raise_error("%.*s: %s%s", end - var - 1, var, msg, tail);
+}
+
+static const char *
+subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes)
+{
+    char *startp;
+    char *loc;
+    int saveherefd = herefd;
+    struct nodelist *saveargbackq = argbackq;
+    int amount;
+    char *rmesc, *rmescend;
+    int zero;
+    char *(*scan)(char *, char *, char *, char *, int , int);
+
+    herefd = -1;
+    argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
+    STPUTC('\0', expdest);
+    herefd = saveherefd;
+    argbackq = saveargbackq;
+    startp = stackblock() + startloc;
+
+    switch (subtype) {
+    case VSASSIGN:
+        setvar(str, startp, 0);
+        amount = startp - expdest;
+        STADJUST(amount, expdest);
+        return startp;
+
+    case VSQUESTION:
+        varunset(p, str, startp, varflags);
+        /* NOTREACHED */
+    }
+
+    subtype -= VSTRIMRIGHT;
+#if DEBUG
+    if (subtype < 0 || subtype > 3)
+        abort();
+#endif
+
+    rmesc = startp;
+    rmescend = stackblock() + strloc;
+    if (quotes) {
+        rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
+        if (rmesc != startp) {
+            rmescend = expdest;
+            startp = stackblock() + startloc;
+        }
+    }
+    rmescend--;
+    str = stackblock() + strloc;
+    preglob(str, varflags & VSQUOTE, 0);
+
+    /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
+    zero = subtype >> 1;
+    /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
+    scan = (subtype & 1) ^ zero ? scanleft : scanright;
+
+    loc = scan(startp, rmesc, rmescend, str, quotes, zero);
+    if (loc) {
+        if (zero) {
+            memmove(startp, loc, str - loc);
+            loc = startp + (str - loc) - 1;
+        }
+        *loc = '\0';
+        amount = loc - expdest;
+        STADJUST(amount, expdest);
+    }
+    return loc;
+}
+
+/*
+ * Add the value of a specialized variable to the stack string.
+ */
+static ssize_t
+varvalue(char *name, int varflags, int flags)
+{
+    int num;
+    char *p;
+    int i;
+    int sep = 0;
+    int sepq = 0;
+    ssize_t len = 0;
+    char **ap;
+    int syntax;
+    int quoted = varflags & VSQUOTE;
+    int subtype = varflags & VSTYPE;
+    int quotes = flags & (EXP_FULL | EXP_CASE);
+
+    if (quoted && (flags & EXP_FULL))
+        sep = 1 << CHAR_BIT;
+
+    syntax = quoted ? DQSYNTAX : BASESYNTAX;
+    switch (*name) {
+    case '$':
+        num = rootpid;
+        goto numvar;
+    case '?':
+        num = exitstatus;
+        goto numvar;
+    case '#':
+        num = shellparam.nparam;
+        goto numvar;
+    case '!':
+        num = backgndpid;
+        if (num == 0)
+            return -1;
+ numvar:
+        len = cvtnum(num);
+        break;
+    case '-':
+        p = makestrspace(NOPTS, expdest);
+        for (i = NOPTS - 1; i >= 0; i--) {
+            if (optlist[i]) {
+                USTPUTC(optletters(i), p);
+                len++;
+            }
+        }
+        expdest = p;
+        break;
+    case '@':
+        if (sep)
+            goto param;
+        /* fall through */
+    case '*':
+        sep = ifsset() ? signed_char2int(ifsval()[0]) : ' ';
+        if (quotes && (SIT(sep, syntax) == CCTL || SIT(sep, syntax) == CBACK))
+            sepq = 1;
+ param:
+        ap = shellparam.p;
+        if (!ap)
+            return -1;
+        while ((p = *ap++)) {
+            size_t partlen;
+
+            partlen = strlen(p);
+            len += partlen;
+
+            if (!(subtype == VSPLUS || subtype == VSLENGTH))
+                memtodest(p, partlen, syntax, quotes);
+
+            if (*ap && sep) {
+                char *q;
+
+                len++;
+                if (subtype == VSPLUS || subtype == VSLENGTH) {
+                    continue;
+                }
+                q = expdest;
+                if (sepq)
+                    STPUTC(CTLESC, q);
+                STPUTC(sep, q);
+                expdest = q;
+            }
+        }
+        return len;
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+        num = atoi(name);
+        if (num < 0 || num > shellparam.nparam)
+            return -1;
+        p = num ? shellparam.p[num - 1] : arg0;
+        goto value;
+    default:
+        p = lookupvar(name);
+ value:
+        if (!p)
+            return -1;
+
+        len = strlen(p);
+        if (!(subtype == VSPLUS || subtype == VSLENGTH))
+            memtodest(p, len, syntax, quotes);
+        return len;
+    }
+
+    if (subtype == VSPLUS || subtype == VSLENGTH)
+        STADJUST(-len, expdest);
+    return len;
+}
+
+/*
+ * Expand a variable, and return a pointer to the next character in the
+ * input string.
+ */
+static char *
+evalvar(char *p, int flag)
+{
+    int subtype;
+    int varflags;
+    char *var;
+    int patloc;
+    int c;
+    int startloc;
+    ssize_t varlen;
+    int easy;
+    int quotes;
+    int quoted;
+
+    quotes = flag & (EXP_FULL | EXP_CASE);
+    varflags = *p++;
+    subtype = varflags & VSTYPE;
+    quoted = varflags & VSQUOTE;
+    var = p;
+    easy = (!quoted || (*var == '@' && shellparam.nparam));
+    startloc = expdest - (char *)stackblock();
+    p = strchr(p, '=') + 1;
+
+ again:
+    varlen = varvalue(var, varflags, flag);
+    if (varflags & VSNUL)
+        varlen--;
+
+    if (subtype == VSPLUS) {
+        varlen = -1 - varlen;
+        goto vsplus;
+    }
+
+    if (subtype == VSMINUS) {
+ vsplus:
+        if (varlen < 0) {
+            argstr(
+                p, flag | EXP_TILDE |
+                    (quoted ?  EXP_QWORD : EXP_WORD)
+            );
+            goto end;
+        }
+        if (easy)
+            goto record;
+        goto end;
+    }
+
+    if (subtype == VSASSIGN || subtype == VSQUESTION) {
+        if (varlen < 0) {
+            if (subevalvar(p, var, 0, subtype, startloc, varflags, 0)) {
+                varflags &= ~VSNUL;
+                /*
+                 * Remove any recorded regions beyond
+                 * start of variable
+                 */
+                removerecordregions(startloc);
+                goto again;
+            }
+            goto end;
+        }
+        if (easy)
+            goto record;
+        goto end;
+    }
+
+    if (varlen < 0 && uflag)
+        varunset(p, var, 0, 0);
+
+    if (subtype == VSLENGTH) {
+        cvtnum(varlen > 0 ? varlen : 0);
+        goto record;
+    }
+
+    if (subtype == VSNORMAL) {
+        if (!easy)
+            goto end;
+ record:
+        recordregion(startloc, expdest - (char *)stackblock(), quoted);
+        goto end;
+    }
+
+#if DEBUG
+    switch (subtype) {
+    case VSTRIMLEFT:
+    case VSTRIMLEFTMAX:
+    case VSTRIMRIGHT:
+    case VSTRIMRIGHTMAX:
+        break;
+    default:
+        abort();
+    }
+#endif
+
+    if (varlen >= 0) {
+        /*
+         * Terminate the string and start recording the pattern
+         * right after it
+         */
+        STPUTC('\0', expdest);
+        patloc = expdest - (char *)stackblock();
+        if (subevalvar(p, NULL, patloc, subtype,
+                startloc, varflags, quotes) == 0) {
+            int amount = expdest - (
+                (char *)stackblock() + patloc - 1
+            );
+            STADJUST(-amount, expdest);
+        }
+        /* Remove any recorded regions beyond start of variable */
+        removerecordregions(startloc);
+        goto record;
+    }
+
+ end:
+    if (subtype != VSNORMAL) {      /* skip to end of alternative */
+        int nesting = 1;
+        for (;;) {
+            c = *p++;
+            if (c == CTLESC)
+                p++;
+            else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
+                if (varlen >= 0)
+                    argbackq = argbackq->next;
+            } else if (c == CTLVAR) {
+                if ((*p++ & VSTYPE) != VSNORMAL)
+                    nesting++;
+            } else if (c == CTLENDVAR) {
+                if (--nesting == 0)
+                    break;
+            }
+        }
+    }
+    return p;
+}
+
+/*
+ * Break the argument string into pieces based upon IFS and add the
+ * strings to the argument list.  The regions of the string to be
+ * searched for IFS characters have been stored by recordregion.
+ */
+static void
+ifsbreakup(char *string, struct arglist *arglist)
+{
+    struct ifsregion *ifsp;
+    struct strlist *sp;
+    char *start;
+    char *p;
+    char *q;
+    const char *ifs, *realifs;
+    int ifsspc;
+    int nulonly;
+
+    start = string;
+    if (ifslastp != NULL) {
+        ifsspc = 0;
+        nulonly = 0;
+        realifs = ifsset() ? ifsval() : defifs;
+        ifsp = &ifsfirst;
+        do {
+            p = string + ifsp->begoff;
+            nulonly = ifsp->nulonly;
+            ifs = nulonly ? nullstr : realifs;
+            ifsspc = 0;
+            while (p < string + ifsp->endoff) {
+                q = p;
+                if (*p == CTLESC)
+                    p++;
+                if (!strchr(ifs, *p)) {
+                    p++;
+                    continue;
+                }
+                if (!nulonly)
+                    ifsspc = (strchr(defifs, *p) != NULL);
+                /* Ignore IFS whitespace at start */
+                if (q == start && ifsspc) {
+                    p++;
+                    start = p;
+                    continue;
+                }
+                *q = '\0';
+                sp = stalloc(sizeof(*sp));
+                sp->text = start;
+                *arglist->lastp = sp;
+                arglist->lastp = &sp->next;
+                p++;
+                if (!nulonly) {
+                    for (;;) {
+                        if (p >= string + ifsp->endoff) {
+                            break;
+                        }
+                        q = p;
+                        if (*p == CTLESC)
+                            p++;
+                        if (strchr(ifs, *p) == NULL ) {
+                            p = q;
+                            break;
+                        } else if (strchr(defifs, *p) == NULL) {
+                            if (ifsspc) {
+                                p++;
+                                ifsspc = 0;
+                            } else {
+                                p = q;
+                                break;
+                            }
+                        } else
+                            p++;
+                    }
+                }
+                start = p;
+            } /* while */
+            ifsp = ifsp->next;
+        } while (ifsp != NULL);
+        if (nulonly)
+            goto add;
+    }
+
+    if (!*start)
+        return;
+
+ add:
+    sp = stalloc(sizeof(*sp));
+    sp->text = start;
+    *arglist->lastp = sp;
+    arglist->lastp = &sp->next;
+}
+
+static void
+ifsfree(void)
+{
+    struct ifsregion *p;
+
+    INT_OFF;
+    p = ifsfirst.next;
+    do {
+        struct ifsregion *ifsp;
+        ifsp = p->next;
+        free(p);
+        p = ifsp;
+    } while (p);
+    ifslastp = NULL;
+    ifsfirst.next = NULL;
+    INT_ON;
+}
+
+/*
+ * Add a file name to the list.
+ */
+static void
+addfname(const char *name)
+{
+    struct strlist *sp;
+
+    sp = stalloc(sizeof(*sp));
+    sp->text = ststrdup(name);
+    *exparg.lastp = sp;
+    exparg.lastp = &sp->next;
+}
+
+static char *expdir;
+
+/*
+ * Do metacharacter (i.e. *, ?, [...]) expansion.
+ */
+static void
+expmeta(char *enddir, char *name)
+{
+    char *p;
+    const char *cp;
+    char *start;
+    char *endname;
+    int metaflag;
+    struct stat statb;
+    DIR *dirp;
+    struct dirent *dp;
+    int atend;
+    int matchdot;
+
+    metaflag = 0;
+    start = name;
+    for (p = name; *p; p++) {
+        if (*p == '*' || *p == '?')
+            metaflag = 1;
+        else if (*p == '[') {
+            char *q = p + 1;
+            if (*q == '!')
+                q++;
+            for (;;) {
+                if (*q == '\\')
+                    q++;
+                if (*q == '/' || *q == '\0')
+                    break;
+                if (*++q == ']') {
+                    metaflag = 1;
+                    break;
+                }
+            }
+        } else if (*p == '\\')
+            p++;
+        else if (*p == '/') {
+            if (metaflag)
+                goto out;
+            start = p + 1;
+        }
+    }
+ out:
+    if (metaflag == 0) {    /* we've reached the end of the file name */
+        if (enddir != expdir)
+            metaflag++;
+        p = name;
+        do {
+            if (*p == '\\')
+                p++;
+            *enddir++ = *p;
+        } while (*p++);
+        if (metaflag == 0 || lstat(expdir, &statb) >= 0)
+            addfname(expdir);
+        return;
+    }
+    endname = p;
+    if (name < start) {
+        p = name;
+        do {
+            if (*p == '\\')
+                p++;
+            *enddir++ = *p++;
+        } while (p < start);
+    }
+    if (enddir == expdir) {
+        cp = ".";
+    } else if (enddir == expdir + 1 && *expdir == '/') {
+        cp = "/";
+    } else {
+        cp = expdir;
+        enddir[-1] = '\0';
+    }
+    dirp = opendir(cp);
+    if (dirp == NULL)
+        return;
+    if (enddir != expdir)
+        enddir[-1] = '/';
+    if (*endname == 0) {
+        atend = 1;
+    } else {
+        atend = 0;
+        *endname++ = '\0';
+    }
+    matchdot = 0;
+    p = start;
+    if (*p == '\\')
+        p++;
+    if (*p == '.')
+        matchdot++;
+    while (! intpending && (dp = readdir(dirp)) != NULL) {
+        if (dp->d_name[0] == '.' && ! matchdot)
+            continue;
+        if (pmatch(start, dp->d_name)) {
+            if (atend) {
+                strcpy(enddir, dp->d_name);
+                addfname(expdir);
+            } else {
+                for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
+                    continue;
+                p[-1] = '/';
+                expmeta(p, endname);
+            }
+        }
+    }
+    closedir(dirp);
+    if (! atend)
+        endname[-1] = '/';
+}
+
+static struct strlist *
+msort(struct strlist *list, int len)
+{
+    struct strlist *p, *q = NULL;
+    struct strlist **lpp;
+    int half;
+    int n;
+
+    if (len <= 1)
+        return list;
+    half = len >> 1;
+    p = list;
+    for (n = half; --n >= 0; ) {
+        q = p;
+        p = p->next;
+    }
+    q->next = NULL;                 /* terminate first half of list */
+    q = msort(list, half);          /* sort first half of list */
+    p = msort(p, len - half);               /* sort second half */
+    lpp = &list;
+    for (;;) {
+#if ENABLE_LOCALE_SUPPORT
+        if (strcoll(p->text, q->text) < 0)
+#else
+        if (strcmp(p->text, q->text) < 0)
+#endif
+                        {
+            *lpp = p;
+            lpp = &p->next;
+            p = *lpp;
+            if (p == NULL) {
+                *lpp = q;
+                break;
+            }
+        } else {
+            *lpp = q;
+            lpp = &q->next;
+            q = *lpp;
+            if (q == NULL) {
+                *lpp = p;
+                break;
+            }
+        }
+    }
+    return list;
+}
+
+/*
+ * Sort the results of file name expansion.  It calculates the number of
+ * strings to sort and then calls msort (short for merge sort) to do the
+ * work.
+ */
+static struct strlist *
+expsort(struct strlist *str)
+{
+    int len;
+    struct strlist *sp;
+
+    len = 0;
+    for (sp = str; sp; sp = sp->next)
+        len++;
+    return msort(str, len);
+}
+
+static void
+expandmeta(struct strlist *str, int flag)
+{
+    static const char metachars[] ALIGN1 = {
+        '*', '?', '[', 0
+    };
+    /* TODO - EXP_REDIR */
+
+    while (str) {
+        struct strlist **savelastp;
+        struct strlist *sp;
+        char *p;
+
+        if (fflag)
+            goto nometa;
+        if (!strpbrk(str->text, metachars))
+            goto nometa;
+        savelastp = exparg.lastp;
+
+        INT_OFF;
+        p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+        {
+            int i = strlen(str->text);
+            expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
+        }
+
+        expmeta(expdir, p);
+        free(expdir);
+        if (p != str->text)
+            free(p);
+        INT_ON;
+        if (exparg.lastp == savelastp) {
+            /*
+             * no matches
+             */
+ nometa:
+            *exparg.lastp = str;
+            rmescapes(str->text);
+            exparg.lastp = &str->next;
+        } else {
+            *exparg.lastp = NULL;
+            *savelastp = sp = expsort(*savelastp);
+            while (sp->next != NULL)
+                sp = sp->next;
+            exparg.lastp = &sp->next;
+        }
+        str = str->next;
+    }
+}
+
+/*
+ * Perform variable substitution and command substitution on an argument,
+ * placing the resulting list of arguments in arglist.  If EXP_FULL is true,
+ * perform splitting and file name expansion.  When arglist is NULL, perform
+ * here document expansion.
+ */
+static void
+expandarg(union node *arg, struct arglist *arglist, int flag)
+{
+    struct strlist *sp;
+    char *p;
+
+    argbackq = arg->narg.backquote;
+    STARTSTACKSTR(expdest);
+    ifsfirst.next = NULL;
+    ifslastp = NULL;
+    argstr(arg->narg.text, flag);
+    p = _STPUTC('\0', expdest);
+    expdest = p - 1;
+    if (arglist == NULL) {
+        return;                 /* here document expanded */
+    }
+    p = grabstackstr(p);
+    exparg.lastp = &exparg.list;
+    /*
+     * TODO - EXP_REDIR
+     */
+    if (flag & EXP_FULL) {
+        ifsbreakup(p, &exparg);
+        *exparg.lastp = NULL;
+        exparg.lastp = &exparg.list;
+        expandmeta(exparg.list, flag);
+    } else {
+        if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
+            rmescapes(p);
+        sp = stalloc(sizeof(*sp));
+        sp->text = p;
+        *exparg.lastp = sp;
+        exparg.lastp = &sp->next;
+    }
+    if (ifsfirst.next)
+        ifsfree();
+    *exparg.lastp = NULL;
+    if (exparg.list) {
+        *arglist->lastp = exparg.list;
+        arglist->lastp = exparg.lastp;
+    }
+}
+
+/*
+ * Expand shell variables and backquotes inside a here document.
+ */
+static void
+expandhere(union node *arg, int fd)
+{
+    herefd = fd;
+    expandarg(arg, (struct arglist *)NULL, 0);
+    full_write(fd, stackblock(), expdest - (char *)stackblock());
+}
+
+/*
+ * Returns true if the pattern matches the string.
+ */
+static int
+patmatch(char *pattern, const char *string)
+{
+    return pmatch(preglob(pattern, 0, 0), string);
+}
+
+/*
+ * See if a pattern matches in a case statement.
+ */
+static int
+casematch(union node *pattern, char *val)
+{
+    struct stackmark smark;
+    int result;
+
+    setstackmark(&smark);
+    argbackq = pattern->narg.backquote;
+    STARTSTACKSTR(expdest);
+    ifslastp = NULL;
+    argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
+    STACKSTRNUL(expdest);
+    result = patmatch(stackblock(), val);
+    popstackmark(&smark);
+    return result;
+}
+
+
+/* ============ find_command */
+
+struct builtincmd {
+    const char *name;
+    int (*builtin)(int, char **);
+    /* unsigned flags; */
+};
+#define IS_BUILTIN_SPECIAL(b) ((b)->name[0] & 1)
+#define IS_BUILTIN_REGULAR(b) ((b)->name[0] & 2)
+#define IS_BUILTIN_ASSIGN(b) ((b)->name[0] & 4)
+
+struct cmdentry {
+    int cmdtype;
+    union param {
+        int index;
+        const struct builtincmd *cmd;
+        struct funcnode *func;
+    } u;
+};
+/* values of cmdtype */
+#define CMDUNKNOWN      -1      /* no entry in table for command */
+#define CMDNORMAL       0       /* command is an executable program */
+#define CMDFUNCTION     1       /* command is a shell function */
+#define CMDBUILTIN      2       /* command is a shell builtin */
+
+/* action to find_command() */
+#define DO_ERR          0x01    /* prints errors */
+#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 */
+
+static void find_command(char *, struct cmdentry *, int, const char *);
+
+
+/* ============ Hashing commands */
+
+/*
+ * When commands are first encountered, they are entered in a hash table.
+ * This ensures that a full path search will not have to be done for them
+ * on each invocation.
+ *
+ * We should investigate converting to a linear search, even though that
+ * would make the command name "hash" a misnomer.
+ */
+
+#define CMDTABLESIZE 31         /* should be prime */
+#define ARB 1                   /* actual size determined at run time */
+
+struct tblentry {
+    struct tblentry *next;  /* next entry in hash chain */
+    union param param;      /* definition of builtin function */
+    short cmdtype;          /* index identifying command */
+    char rehash;            /* if set, cd done since entry created */
+    char cmdname[ARB];      /* name of command */
+};
+
+static struct tblentry *cmdtable[CMDTABLESIZE];
+static int builtinloc = -1;             /* index in path of %builtin, or -1 */
+
+static void
+tryexec(char *cmd, char **argv, char **envp)
+{
+    int repeated = 0;
+
+#if ENABLE_FEATURE_SH_STANDALONE
+    if (strchr(cmd, '/') == NULL) {
+        const struct bb_applet *a;
+
+        a = find_applet_by_name(cmd);
+        if (a) {
+            if (a->noexec) {
+                current_applet = a;
+                run_current_applet_and_exit(argv);
+            }
+            /* re-exec ourselves with the new arguments */
+            execve(bb_busybox_exec_path, argv, envp);
+            /* If they called chroot or otherwise made the binary no longer
+             * executable, fall through */
+        }
+    }
+#endif
+
+ repeat:
+#ifdef SYSV
+    do {
+        execve(cmd, argv, envp);
+    } while (errno == EINTR);
+#else
+    execve(cmd, argv, envp);
+#endif
+    if (repeated++) {
+        free(argv);
+    } else if (errno == ENOEXEC) {
+        char **ap;
+        char **new;
+
+        for (ap = argv; *ap; ap++)
+            ;
+        ap = new = ckmalloc((ap - argv + 2) * sizeof(char *));
+        ap[1] = cmd;
+        ap[0] = cmd = (char *)DEFAULT_SHELL;
+        ap += 2;
+        argv++;
+        while ((*ap++ = *argv++))
+            ;
+        argv = new;
+        goto repeat;
+    }
+}
+
+/*
+ * Exec a program.  Never returns.  If you change this routine, you may
+ * have to change the find_command routine as well.
+ */
+#define environment() listvars(VEXPORT, VUNSET, 0)
+static void shellexec(char **, const char *, int) ATTRIBUTE_NORETURN;
+static void
+shellexec(char **argv, const char *path, int idx)
+{
+    char *cmdname;
+    int e;
+    char **envp;
+    int exerrno;
+
+    clearredir(1);
+    envp = environment();
+    if (strchr(argv[0], '/')
+#if ENABLE_FEATURE_SH_STANDALONE
+     || find_applet_by_name(argv[0])
+#endif
+    ) {
+        tryexec(argv[0], argv, envp);
+        e = errno;
+    } else {
+        e = ENOENT;
+        while ((cmdname = padvance(&path, argv[0])) != NULL) {
+            if (--idx < 0 && pathopt == NULL) {
+                tryexec(cmdname, argv, envp);
+                if (errno != ENOENT && errno != ENOTDIR)
+                    e = errno;
+            }
+            stunalloc(cmdname);
+        }
+    }
+
+    /* Map to POSIX errors */
+    switch (e) {
+    case EACCES:
+        exerrno = 126;
+        break;
+    case ENOENT:
+        exerrno = 127;
+        break;
+    default:
+        exerrno = 2;
+        break;
+    }
+    exitstatus = exerrno;
+    TRACE(("shellexec failed for %s, errno %d, suppressint %d\n",
+        argv[0], e, suppressint ));
+    ash_msg_and_raise(EXEXEC, "%s: %s", argv[0], errmsg(e, "not found"));
+    /* NOTREACHED */
+}
+
+static void
+printentry(struct tblentry *cmdp)
+{
+    int idx;
+    const char *path;
+    char *name;
+
+    idx = cmdp->param.index;
+    path = pathval();
+    do {
+        name = padvance(&path, cmdp->cmdname);
+        stunalloc(name);
+    } while (--idx >= 0);
+    out1fmt("%s%s\n", name, (cmdp->rehash ? "*" : nullstr));
+}
+
+/*
+ * Clear out command entries.  The argument specifies the first entry in
+ * PATH which has changed.
+ */
+static void
+clearcmdentry(int firstchange)
+{
+    struct tblentry **tblp;
+    struct tblentry **pp;
+    struct tblentry *cmdp;
+
+    INT_OFF;
+    for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
+        pp = tblp;
+        while ((cmdp = *pp) != NULL) {
+            if ((cmdp->cmdtype == CMDNORMAL &&
+                 cmdp->param.index >= firstchange)
+             || (cmdp->cmdtype == CMDBUILTIN &&
+                 builtinloc >= firstchange)
+            ) {
+                *pp = cmdp->next;
+                free(cmdp);
+            } else {
+                pp = &cmdp->next;
+            }
+        }
+    }
+    INT_ON;
+}
+
+/*
+ * Locate a command in the command hash table.  If "add" is nonzero,
+ * add the command to the table if it is not already present.  The
+ * variable "lastcmdentry" is set to point to the address of the link
+ * pointing to the entry, so that delete_cmd_entry can delete the
+ * entry.
+ *
+ * Interrupts must be off if called with add != 0.
+ */
+static struct tblentry **lastcmdentry;
+
+static struct tblentry *
+cmdlookup(const char *name, int add)
+{
+    unsigned int hashval;
+    const char *p;
+    struct tblentry *cmdp;
+    struct tblentry **pp;
+
+    p = name;
+    hashval = (unsigned char)*p << 4;
+    while (*p)
+        hashval += (unsigned char)*p++;
+    hashval &= 0x7FFF;
+    pp = &cmdtable[hashval % CMDTABLESIZE];
+    for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
+        if (strcmp(cmdp->cmdname, name) == 0)
+            break;
+        pp = &cmdp->next;
+    }
+    if (add && cmdp == NULL) {
+        cmdp = *pp = ckmalloc(sizeof(struct tblentry) - ARB
+                    + strlen(name) + 1);
+        cmdp->next = NULL;
+        cmdp->cmdtype = CMDUNKNOWN;
+        strcpy(cmdp->cmdname, name);
+    }
+    lastcmdentry = pp;
+    return cmdp;
+}
+
+/*
+ * Delete the command entry returned on the last lookup.
+ */
+static void
+delete_cmd_entry(void)
+{
+    struct tblentry *cmdp;
+
+    INT_OFF;
+    cmdp = *lastcmdentry;
+    *lastcmdentry = cmdp->next;
+    if (cmdp->cmdtype == CMDFUNCTION)
+        freefunc(cmdp->param.func);
+    free(cmdp);
+    INT_ON;
+}
+
+/*
+ * Add a new command entry, replacing any existing command entry for
+ * the same name - except special builtins.
+ */
+static void
+addcmdentry(char *name, struct cmdentry *entry)
+{
+    struct tblentry *cmdp;
+
+    cmdp = cmdlookup(name, 1);
+    if (cmdp->cmdtype == CMDFUNCTION) {
+        freefunc(cmdp->param.func);
+    }
+    cmdp->cmdtype = entry->cmdtype;
+    cmdp->param = entry->u;
+    cmdp->rehash = 0;
+}
+
+static int
+hashcmd(int argc, char **argv)
+{
+    struct tblentry **pp;
+    struct tblentry *cmdp;
+    int c;
+    struct cmdentry entry;
+    char *name;
+
+    while ((c = nextopt("r")) != '\0') {
+        clearcmdentry(0);
+        return 0;
+    }
+    if (*argptr == NULL) {
+        for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
+            for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
+                if (cmdp->cmdtype == CMDNORMAL)
+                    printentry(cmdp);
+            }
+        }
+        return 0;
+    }
+    c = 0;
+    while ((name = *argptr) != NULL) {
+        cmdp = cmdlookup(name, 0);
+        if (cmdp != NULL
+         && (cmdp->cmdtype == CMDNORMAL
+             || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
+            delete_cmd_entry();
+        find_command(name, &entry, DO_ERR, pathval());
+        if (entry.cmdtype == CMDUNKNOWN)
+            c = 1;
+        argptr++;
+    }
+    return c;
+}
+
+/*
+ * Called when a cd is done.  Marks all commands so the next time they
+ * are executed they will be rehashed.
+ */
+static void
+hashcd(void)
+{
+    struct tblentry **pp;
+    struct tblentry *cmdp;
+
+    for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
+        for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
+            if (cmdp->cmdtype == CMDNORMAL || (
+                cmdp->cmdtype == CMDBUILTIN &&
+                !(IS_BUILTIN_REGULAR(cmdp->param.cmd)) &&
+                builtinloc > 0
+            ))
+                cmdp->rehash = 1;
+        }
+    }
+}
+
+/*
+ * Fix command hash table when PATH changed.
+ * Called before PATH is changed.  The argument is the new value of PATH;
+ * pathval() still returns the old value at this point.
+ * Called with interrupts off.
+ */
+static void
+changepath(const char *newval)
+{
+    const char *old, *new;
+    int idx;
+    int firstchange;
+    int idx_bltin;
+
+    old = pathval();
+    new = newval;
+    firstchange = 9999;     /* assume no change */
+    idx = 0;
+    idx_bltin = -1;
+    for (;;) {
+        if (*old != *new) {
+            firstchange = idx;
+            if ((*old == '\0' && *new == ':')
+             || (*old == ':' && *new == '\0'))
+                firstchange++;
+            old = new;      /* ignore subsequent differences */
+        }
+        if (*new == '\0')
+            break;
+        if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin"))
+            idx_bltin = idx;
+        if (*new == ':') {
+            idx++;
+        }
+        new++, old++;
+    }
+    if (builtinloc < 0 && idx_bltin >= 0)
+        builtinloc = idx_bltin;             /* zap builtins */
+    if (builtinloc >= 0 && idx_bltin < 0)
+        firstchange = 0;
+    clearcmdentry(firstchange);
+    builtinloc = idx_bltin;
+}
+
+#define TEOF 0
+#define TNL 1
+#define TREDIR 2
+#define TWORD 3
+#define TSEMI 4
+#define TBACKGND 5
+#define TAND 6
+#define TOR 7
+#define TPIPE 8
+#define TLP 9
+#define TRP 10
+#define TENDCASE 11
+#define TENDBQUOTE 12
+#define TNOT 13
+#define TCASE 14
+#define TDO 15
+#define TDONE 16
+#define TELIF 17
+#define TELSE 18
+#define TESAC 19
+#define TFI 20
+#define TFOR 21
+#define TIF 22
+#define TIN 23
+#define TTHEN 24
+#define TUNTIL 25
+#define TWHILE 26
+#define TBEGIN 27
+#define TEND 28
+
+/* first char is indicating which tokens mark the end of a list */
+static const char *const tokname_array[] = {
+    "\1end of file",
+    "\0newline",
+    "\0redirection",
+    "\0word",
+    "\0;",
+    "\0&",
+    "\0&&",
+    "\0||",
+    "\0|",
+    "\0(",
+    "\1)",
+    "\1;;",
+    "\1`",
+#define KWDOFFSET 13
+    /* the following are keywords */
+    "\0!",
+    "\0case",
+    "\1do",
+    "\1done",
+    "\1elif",
+    "\1else",
+    "\1esac",
+    "\1fi",
+    "\0for",
+    "\0if",
+    "\0in",
+    "\1then",
+    "\0until",
+    "\0while",
+    "\0{",
+    "\1}",
+};
+
+static const char *
+tokname(int tok)
+{
+    static char buf[16];
+
+//try this:
+//if (tok < TSEMI) return tokname_array[tok] + 1;
+//sprintf(buf, "\"%s\"", tokname_array[tok] + 1);
+//return buf;
+
+    if (tok >= TSEMI)
+        buf[0] = '"';
+    sprintf(buf + (tok >= TSEMI), "%s%c",
+            tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
+    return buf;
+}
+
+/* Wrapper around strcmp for qsort/bsearch/... */
+static int
+pstrcmp(const void *a, const void *b)
+{
+    return strcmp((char*) a, (*(char**) b) + 1);
+}
+
+static const char *const *
+findkwd(const char *s)
+{
+    return bsearch(s, tokname_array + KWDOFFSET,
+            ARRAY_SIZE(tokname_array) - KWDOFFSET,
+            sizeof(tokname_array[0]), pstrcmp);
+}
+
+/*
+ * Locate and print what a word is...
+ */
+static int
+describe_command(char *command, int describe_command_verbose)
+{
+    struct cmdentry entry;
+    struct tblentry *cmdp;
+#if ENABLE_ASH_ALIAS
+    const struct alias *ap;
+#endif
+    const char *path = pathval();
+
+    if (describe_command_verbose) {
+        out1str(command);
+    }
+
+    /* First look at the keywords */
+    if (findkwd(command)) {
+        out1str(describe_command_verbose ? " is a shell keyword" : command);
+        goto out;
+    }
+
+#if ENABLE_ASH_ALIAS
+    /* Then look at the aliases */
+    ap = lookupalias(command, 0);
+    if (ap != NULL) {
+        if (!describe_command_verbose) {
+            out1str("alias ");
+            printalias(ap);
+            return 0;
+        }
+        out1fmt(" is an alias for %s", ap->val);
+        goto out;
+    }
+#endif
+    /* Then check if it is a tracked alias */
+    cmdp = cmdlookup(command, 0);
+    if (cmdp != NULL) {
+        entry.cmdtype = cmdp->cmdtype;
+        entry.u = cmdp->param;
+    } else {
+        /* Finally use brute force */
+        find_command(command, &entry, DO_ABS, path);
+    }
+
+    switch (entry.cmdtype) {
+    case CMDNORMAL: {
+        int j = entry.u.index;
+        char *p;
+        if (j == -1) {
+            p = command;
+        } else {
+            do {
+                p = padvance(&path, command);
+                stunalloc(p);
+            } while (--j >= 0);
+        }
+        if (describe_command_verbose) {
+            out1fmt(" is%s %s",
+                (cmdp ? " a tracked alias for" : nullstr), p
+            );
+        } else {
+            out1str(p);
+        }
+        break;
+    }
+
+    case CMDFUNCTION:
+        if (describe_command_verbose) {
+            out1str(" is a shell function");
+        } else {
+            out1str(command);
+        }
+        break;
+
+    case CMDBUILTIN:
+        if (describe_command_verbose) {
+            out1fmt(" is a %sshell builtin",
+                IS_BUILTIN_SPECIAL(entry.u.cmd) ?
+                    "special " : nullstr
+            );
+        } else {
+            out1str(command);
+        }
+        break;
+
+    default:
+        if (describe_command_verbose) {
+            out1str(": not found\n");
+        }
+        return 127;
+    }
+ out:
+    outstr("\n", stdout);
+    return 0;
+}
+
+static int
+typecmd(int argc, char **argv)
+{
+    int i = 1;
+    int err = 0;
+    int verbose = 1;
+
+    /* type -p ... ? (we don't bother checking for 'p') */
+    if (argv[1] && argv[1][0] == '-') {
+        i++;
+        verbose = 0;
+    }
+    while (i < argc) {
+        err |= describe_command(argv[i++], verbose);
+    }
+    return err;
+}
+
+#if ENABLE_ASH_CMDCMD
+static int
+commandcmd(int argc, char **argv)
+{
+    int c;
+    enum {
+        VERIFY_BRIEF = 1,
+        VERIFY_VERBOSE = 2,
+    } verify = 0;
+
+    while ((c = nextopt("pvV")) != '\0')
+        if (c == 'V')
+            verify |= VERIFY_VERBOSE;
+        else if (c == 'v')
+            verify |= VERIFY_BRIEF;
+#if DEBUG
+        else if (c != 'p')
+            abort();
+#endif
+    if (verify)
+        return describe_command(*argptr, verify - VERIFY_BRIEF);
+
+    return 0;
+}
+#endif
+
+
+/* ============ eval.c */
+
+static int funcblocksize;          /* size of structures in function */
+static int funcstringsize;         /* size of strings in node */
+static void *funcblock;            /* block to allocate function from */
+static char *funcstring;           /* block to allocate strings from */
+
+/* flags in argument to evaltree */
+#define EV_EXIT 01              /* exit after evaluating tree */
+#define EV_TESTED 02            /* exit status is checked; ignore -e flag */
+#define EV_BACKCMD 04           /* command executing within back quotes */
+
+static const short nodesize[26] = {
+    SHELL_ALIGN(sizeof(struct ncmd)),
+    SHELL_ALIGN(sizeof(struct npipe)),
+    SHELL_ALIGN(sizeof(struct nredir)),
+    SHELL_ALIGN(sizeof(struct nredir)),
+    SHELL_ALIGN(sizeof(struct nredir)),
+    SHELL_ALIGN(sizeof(struct nbinary)),
+    SHELL_ALIGN(sizeof(struct nbinary)),
+    SHELL_ALIGN(sizeof(struct nbinary)),
+    SHELL_ALIGN(sizeof(struct nif)),
+    SHELL_ALIGN(sizeof(struct nbinary)),
+    SHELL_ALIGN(sizeof(struct nbinary)),
+    SHELL_ALIGN(sizeof(struct nfor)),
+    SHELL_ALIGN(sizeof(struct ncase)),
+    SHELL_ALIGN(sizeof(struct nclist)),
+    SHELL_ALIGN(sizeof(struct narg)),
+    SHELL_ALIGN(sizeof(struct narg)),
+    SHELL_ALIGN(sizeof(struct nfile)),
+    SHELL_ALIGN(sizeof(struct nfile)),
+    SHELL_ALIGN(sizeof(struct nfile)),
+    SHELL_ALIGN(sizeof(struct nfile)),
+    SHELL_ALIGN(sizeof(struct nfile)),
+    SHELL_ALIGN(sizeof(struct ndup)),
+    SHELL_ALIGN(sizeof(struct ndup)),
+    SHELL_ALIGN(sizeof(struct nhere)),
+    SHELL_ALIGN(sizeof(struct nhere)),
+    SHELL_ALIGN(sizeof(struct nnot)),
+};
+
+static void calcsize(union node *n);
+
+static void
+sizenodelist(struct nodelist *lp)
+{
+    while (lp) {
+        funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
+        calcsize(lp->n);
+        lp = lp->next;
+    }
+}
+
+static void
+calcsize(union node *n)
+{
+    if (n == NULL)
+        return;
+    funcblocksize += nodesize[n->type];
+    switch (n->type) {
+    case NCMD:
+        calcsize(n->ncmd.redirect);
+        calcsize(n->ncmd.args);
+        calcsize(n->ncmd.assign);
+        break;
+    case NPIPE:
+        sizenodelist(n->npipe.cmdlist);
+        break;
+    case NREDIR:
+    case NBACKGND:
+    case NSUBSHELL:
+        calcsize(n->nredir.redirect);
+        calcsize(n->nredir.n);
+        break;
+    case NAND:
+    case NOR:
+    case NSEMI:
+    case NWHILE:
+    case NUNTIL:
+        calcsize(n->nbinary.ch2);
+        calcsize(n->nbinary.ch1);
+        break;
+    case NIF:
+        calcsize(n->nif.elsepart);
+        calcsize(n->nif.ifpart);
+        calcsize(n->nif.test);
+        break;
+    case NFOR:
+        funcstringsize += strlen(n->nfor.var) + 1;
+        calcsize(n->nfor.body);
+        calcsize(n->nfor.args);
+        break;
+    case NCASE:
+        calcsize(n->ncase.cases);
+        calcsize(n->ncase.expr);
+        break;
+    case NCLIST:
+        calcsize(n->nclist.body);
+        calcsize(n->nclist.pattern);
+        calcsize(n->nclist.next);
+        break;
+    case NDEFUN:
+    case NARG:
+        sizenodelist(n->narg.backquote);
+        funcstringsize += strlen(n->narg.text) + 1;
+        calcsize(n->narg.next);
+        break;
+    case NTO:
+    case NCLOBBER:
+    case NFROM:
+    case NFROMTO:
+    case NAPPEND:
+        calcsize(n->nfile.fname);
+        calcsize(n->nfile.next);
+        break;
+    case NTOFD:
+    case NFROMFD:
+        calcsize(n->ndup.vname);
+        calcsize(n->ndup.next);
+    break;
+    case NHERE:
+    case NXHERE:
+        calcsize(n->nhere.doc);
+        calcsize(n->nhere.next);
+        break;
+    case NNOT:
+        calcsize(n->nnot.com);
+        break;
+    };
+}
+
+static char *
+nodeckstrdup(char *s)
+{
+    char *rtn = funcstring;
+
+    strcpy(funcstring, s);
+    funcstring += strlen(s) + 1;
+    return rtn;
+}
+
+static union node *copynode(union node *);
+
+static struct nodelist *
+copynodelist(struct nodelist *lp)
+{
+    struct nodelist *start;
+    struct nodelist **lpp;
+
+    lpp = &start;
+    while (lp) {
+        *lpp = funcblock;
+        funcblock = (char *) funcblock + SHELL_ALIGN(sizeof(struct nodelist));
+        (*lpp)->n = copynode(lp->n);
+        lp = lp->next;
+        lpp = &(*lpp)->next;
+    }
+    *lpp = NULL;
+    return start;
+}
+
+static union node *
+copynode(union node *n)
+{
+    union node *new;
+
+    if (n == NULL)
+        return NULL;
+    new = funcblock;
+    funcblock = (char *) funcblock + nodesize[n->type];
+
+    switch (n->type) {
+    case NCMD:
+        new->ncmd.redirect = copynode(n->ncmd.redirect);
+        new->ncmd.args = copynode(n->ncmd.args);
+        new->ncmd.assign = copynode(n->ncmd.assign);
+        break;
+    case NPIPE:
+        new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
+        new->npipe.backgnd = n->npipe.backgnd;
+        break;
+    case NREDIR:
+    case NBACKGND:
+    case NSUBSHELL:
+        new->nredir.redirect = copynode(n->nredir.redirect);
+        new->nredir.n = copynode(n->nredir.n);
+        break;
+    case NAND:
+    case NOR:
+    case NSEMI:
+    case NWHILE:
+    case NUNTIL:
+        new->nbinary.ch2 = copynode(n->nbinary.ch2);
+        new->nbinary.ch1 = copynode(n->nbinary.ch1);
+        break;
+    case NIF:
+        new->nif.elsepart = copynode(n->nif.elsepart);
+        new->nif.ifpart = copynode(n->nif.ifpart);
+        new->nif.test = copynode(n->nif.test);
+        break;
+    case NFOR:
+        new->nfor.var = nodeckstrdup(n->nfor.var);
+        new->nfor.body = copynode(n->nfor.body);
+        new->nfor.args = copynode(n->nfor.args);
+        break;
+    case NCASE:
+        new->ncase.cases = copynode(n->ncase.cases);
+        new->ncase.expr = copynode(n->ncase.expr);
+        break;
+    case NCLIST:
+        new->nclist.body = copynode(n->nclist.body);
+        new->nclist.pattern = copynode(n->nclist.pattern);
+        new->nclist.next = copynode(n->nclist.next);
+        break;
+    case NDEFUN:
+    case NARG:
+        new->narg.backquote = copynodelist(n->narg.backquote);
+        new->narg.text = nodeckstrdup(n->narg.text);
+        new->narg.next = copynode(n->narg.next);
+        break;
+    case NTO:
+    case NCLOBBER:
+    case NFROM:
+    case NFROMTO:
+    case NAPPEND:
+        new->nfile.fname = copynode(n->nfile.fname);
+        new->nfile.fd = n->nfile.fd;
+        new->nfile.next = copynode(n->nfile.next);
+        break;
+    case NTOFD:
+    case NFROMFD:
+        new->ndup.vname = copynode(n->ndup.vname);
+        new->ndup.dupfd = n->ndup.dupfd;
+        new->ndup.fd = n->ndup.fd;
+        new->ndup.next = copynode(n->ndup.next);
+        break;
+    case NHERE:
+    case NXHERE:
+        new->nhere.doc = copynode(n->nhere.doc);
+        new->nhere.fd = n->nhere.fd;
+        new->nhere.next = copynode(n->nhere.next);
+        break;
+    case NNOT:
+        new->nnot.com = copynode(n->nnot.com);
+        break;
+    };
+    new->type = n->type;
+    return new;
+}
+
+/*
+ * Make a copy of a parse tree.
+ */
+static struct funcnode *
+copyfunc(union node *n)
+{
+    struct funcnode *f;
+    size_t blocksize;
+
+    funcblocksize = offsetof(struct funcnode, n);
+    funcstringsize = 0;
+    calcsize(n);
+    blocksize = funcblocksize;
+    f = ckmalloc(blocksize + funcstringsize);
+    funcblock = (char *) f + offsetof(struct funcnode, n);
+    funcstring = (char *) f + blocksize;
+    copynode(n);
+    f->count = 0;
+    return f;
+}
+
+/*
+ * Define a shell function.
+ */
+static void
+defun(char *name, union node *func)
+{
+    struct cmdentry entry;
+
+    INT_OFF;
+    entry.cmdtype = CMDFUNCTION;
+    entry.u.func = copyfunc(func);
+    addcmdentry(name, &entry);
+    INT_ON;
+}
+
+static int evalskip;            /* set if we are skipping commands */
+/* reasons for skipping commands (see comment on breakcmd routine) */
+#define SKIPBREAK      (1 << 0)
+#define SKIPCONT       (1 << 1)
+#define SKIPFUNC       (1 << 2)
+#define SKIPFILE       (1 << 3)
+#define SKIPEVAL       (1 << 4)
+static int skipcount;           /* number of levels to skip */
+static int funcnest;            /* depth of function calls */
+
+/* forward decl way out to parsing code - dotrap needs it */
+static int evalstring(char *s, int mask);
+
+/*
+ * Called to execute a trap.  Perhaps we should avoid entering new trap
+ * handlers while we are executing a trap handler.
+ */
+static int
+dotrap(void)
+{
+    char *p;
+    char *q;
+    int i;
+    int savestatus;
+    int skip = 0;
+
+    savestatus = exitstatus;
+    pendingsig = 0;
+    xbarrier();
+
+    for (i = 0, q = gotsig; i < NSIG - 1; i++, q++) {
+        if (!*q)
+            continue;
+        *q = '\0';
+
+        p = trap[i + 1];
+        if (!p)
+            continue;
+        skip = evalstring(p, SKIPEVAL);
+        exitstatus = savestatus;
+        if (skip)
+            break;
+    }
+
+    return skip;
+}
+
+/* forward declarations - evaluation is fairly recursive business... */
+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 evalpipe(union node *, int);
+static void evalcommand(union node *, int);
+static int evalbltin(const struct builtincmd *, int, char **);
+static void prehash(union node *);
+
+/*
+ * Evaluate a parse tree.  The value is left in the global variable
+ * exitstatus.
+ */
+static void
+evaltree(union node *n, int flags)
+{
+    int checkexit = 0;
+    void (*evalfn)(union node *, int);
+    unsigned isor;
     int status;
-    int retval;
-
-    status = job->ps[job->nprocs - 1].status;
-    retval = WEXITSTATUS(status);
-    if (!WIFEXITED(status)) {
+    if (n == NULL) {
+        TRACE(("evaltree(NULL) called\n"));
+        goto out;
+    }
+    TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
+            getpid(), n, n->type, flags));
+    switch (n->type) {
+    default:
+#if DEBUG
+        out1fmt("Node type = %d\n", n->type);
+        fflush(stdout);
+        break;
+#endif
+    case NNOT:
+        evaltree(n->nnot.com, EV_TESTED);
+        status = !exitstatus;
+        goto setstatus;
+    case NREDIR:
+        expredir(n->nredir.redirect);
+        status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
+        if (!status) {
+            evaltree(n->nredir.n, flags & EV_TESTED);
+            status = exitstatus;
+        }
+        popredir(0);
+        goto setstatus;
+    case NCMD:
+        evalfn = evalcommand;
+ checkexit:
+        if (eflag && !(flags & EV_TESTED))
+            checkexit = ~0;
+        goto calleval;
+    case NFOR:
+        evalfn = evalfor;
+        goto calleval;
+    case NWHILE:
+    case NUNTIL:
+        evalfn = evalloop;
+        goto calleval;
+    case NSUBSHELL:
+    case NBACKGND:
+        evalfn = evalsubshell;
+        goto calleval;
+    case NPIPE:
+        evalfn = evalpipe;
+        goto checkexit;
+    case NCASE:
+        evalfn = evalcase;
+        goto calleval;
+    case NAND:
+    case NOR:
+    case NSEMI:
+#if NAND + 1 != NOR
+#error NAND + 1 != NOR
+#endif
+#if NOR + 1 != NSEMI
+#error NOR + 1 != NSEMI
+#endif
+        isor = n->type - NAND;
+        evaltree(
+            n->nbinary.ch1,
+            (flags | ((isor >> 1) - 1)) & EV_TESTED
+        );
+        if (!exitstatus == isor)
+            break;
+        if (!evalskip) {
+            n = n->nbinary.ch2;
+ evaln:
+            evalfn = evaltree;
+ calleval:
+            evalfn(n, flags);
+            break;
+        }
+        break;
+    case NIF:
+        evaltree(n->nif.test, EV_TESTED);
+        if (evalskip)
+            break;
+        if (exitstatus == 0) {
+            n = n->nif.ifpart;
+            goto evaln;
+        } else if (n->nif.elsepart) {
+            n = n->nif.elsepart;
+            goto evaln;
+        }
+        goto success;
+    case NDEFUN:
+        defun(n->narg.text, n->narg.next);
+ success:
+        status = 0;
+ setstatus:
+        exitstatus = status;
+        break;
+    }
+ out:
+    if ((checkexit & exitstatus))
+        evalskip |= SKIPEVAL;
+    else if (pendingsig && dotrap())
+        goto exexit;
+
+    if (flags & EV_EXIT) {
+ exexit:
+        raise_exception(EXEXIT);
+    }
+}
+
+#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
+static
+#endif
+void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__));
+
+static int loopnest;            /* current loop nesting level */
+
+static void
+evalloop(union node *n, int flags)
+{
+    int status;
+
+    loopnest++;
+    status = 0;
+    flags &= EV_TESTED;
+    for (;;) {
+        int i;
+
+        evaltree(n->nbinary.ch1, EV_TESTED);
+        if (evalskip) {
+ skipping:
+            if (evalskip == SKIPCONT && --skipcount <= 0) {
+                evalskip = 0;
+                continue;
+            }
+            if (evalskip == SKIPBREAK && --skipcount <= 0)
+                evalskip = 0;
+            break;
+        }
+        i = exitstatus;
+        if (n->type != NWHILE)
+            i = !i;
+        if (i != 0)
+            break;
+        evaltree(n->nbinary.ch2, flags);
+        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;
+
+    setstackmark(&smark);
+    arglist.lastp = &arglist.list;
+    for (argp = n->nfor.args; argp; argp = argp->narg.next) {
+        expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
+        /* XXX */
+        if (evalskip)
+            goto out;
+    }
+    *arglist.lastp = NULL;
+
+    exitstatus = 0;
+    loopnest++;
+    flags &= EV_TESTED;
+    for (sp = arglist.list; sp; sp = sp->next) {
+        setvar(n->nfor.var, sp->text, 0);
+        evaltree(n->nfor.body, flags);
+        if (evalskip) {
+            if (evalskip == SKIPCONT && --skipcount <= 0) {
+                evalskip = 0;
+                continue;
+            }
+            if (evalskip == SKIPBREAK && --skipcount <= 0)
+                evalskip = 0;
+            break;
+        }
+    }
+    loopnest--;
+ out:
+    popstackmark(&smark);
+}
+
+static void
+evalcase(union node *n, int flags)
+{
+    union node *cp;
+    union node *patp;
+    struct arglist arglist;
+    struct stackmark smark;
+
+    setstackmark(&smark);
+    arglist.lastp = &arglist.list;
+    expandarg(n->ncase.expr, &arglist, EXP_TILDE);
+    exitstatus = 0;
+    for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
+        for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
+            if (casematch(patp, arglist.list->text)) {
+                if (evalskip == 0) {
+                    evaltree(cp->nclist.body, flags);
+                }
+                goto out;
+            }
+        }
+    }
+ out:
+    popstackmark(&smark);
+}
+
+/*
+ * Kick off a subshell to evaluate a tree.
+ */
+static void
+evalsubshell(union node *n, int flags)
+{
+    struct job *jp;
+    int backgnd = (n->type == NBACKGND);
+    int status;
+
+    expredir(n->nredir.redirect);
+    if (!backgnd && flags & EV_EXIT && !trap[0])
+        goto nofork;
+    INT_OFF;
+    jp = makejob(n, 1);
+    if (forkshell(jp, n, backgnd) == 0) {
+        INT_ON;
+        flags |= EV_EXIT;
+        if (backgnd)
+            flags &=~ EV_TESTED;
+ nofork:
+        redirect(n->nredir.redirect, 0);
+        evaltreenr(n->nredir.n, flags);
+        /* never returns */
+    }
+    status = 0;
+    if (! backgnd)
+        status = waitforjob(jp);
+    exitstatus = status;
+    INT_ON;
+}
+
+/*
+ * Compute the names of the files in a redirection list.
+ */
+static void fixredir(union node *, const char *, int);
+static void
+expredir(union node *n)
+{
+    union node *redir;
+
+    for (redir = n; redir; redir = redir->nfile.next) {
+        struct arglist fn;
+
+        memset(&fn, 0, sizeof(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_FULL | EXP_TILDE);
+                if (fn.list == NULL)
+                    ash_msg_and_raise_error("redir error");
+                fixredir(redir, fn.list->text, 1);
+            }
+            break;
+        }
+    }
+}
+
+/*
+ * 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, int flags)
+{
+    struct job *jp;
+    struct nodelist *lp;
+    int pipelen;
+    int prevfd;
+    int pip[2];
+
+    TRACE(("evalpipe(0x%lx) called\n", (long)n));
+    pipelen = 0;
+    for (lp = n->npipe.cmdlist; lp; lp = lp->next)
+        pipelen++;
+    flags |= EV_EXIT;
+    INT_OFF;
+    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 (pipe(pip) < 0) {
+                close(prevfd);
+                ash_msg_and_raise_error("pipe call failed");
+            }
+        }
+        if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
+            INT_ON;
+            if (pip[1] >= 0) {
+                close(pip[0]);
+            }
+            if (prevfd > 0) {
+                dup2(prevfd, 0);
+                close(prevfd);
+            }
+            if (pip[1] > 1) {
+                dup2(pip[1], 1);
+                close(pip[1]);
+            }
+            evaltreenr(lp->n, flags);
+            /* never returns */
+        }
+        if (prevfd >= 0)
+            close(prevfd);
+        prevfd = pip[0];
+        close(pip[1]);
+    }
+    if (n->npipe.backgnd == 0) {
+        exitstatus = waitforjob(jp);
+        TRACE(("evalpipe:  job done exit status %d\n", exitstatus));
+    }
+    INT_ON;
+}
+
+/*
+ * Controls whether the shell is interactive or not.
+ */
+static void
+setinteractive(int on)
+{
+    static int is_interactive;
+
+    if (++on == is_interactive)
+        return;
+    is_interactive = on;
+    setsignal(SIGINT);
+    setsignal(SIGQUIT);
+    setsignal(SIGTERM);
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+    if (is_interactive > 1) {
+        /* Looks like they want an interactive shell */
+        static smallint did_banner;
+
+        if (!did_banner) {
+            out1fmt(
+                "\n\n"
+                "%s built-in shell (ash)\n"
+                "Enter 'help' for a list of built-in commands."
+                "\n\n",
+                bb_banner);
+            did_banner = 1;
+        }
+    }
+#endif
+}
+
+#if ENABLE_FEATURE_EDITING_VI
+#define setvimode(on) do { \
+    if (on) line_input_state->flags |= VI_MODE; \
+    else line_input_state->flags &= ~VI_MODE; \
+} while (0)
+#else
+#define setvimode(on) viflag = 0   /* forcibly keep the option off */
+#endif
+
+static void
+optschanged(void)
+{
+#if DEBUG
+    opentrace();
+#endif
+    setinteractive(iflag);
+    setjobctl(mflag);
+    setvimode(viflag);
+}
+
+static struct localvar *localvars;
+
+/*
+ * Called after a function returns.
+ * Interrupts must be off.
+ */
+static void
+poplocalvars(void)
+{
+    struct localvar *lvp;
+    struct var *vp;
+
+    while ((lvp = localvars) != NULL) {
+        localvars = lvp->next;
+        vp = lvp->vp;
+        TRACE(("poplocalvar %s", vp ? vp->text : "-"));
+        if (vp == NULL) {       /* $- saved */
+            memcpy(optlist, lvp->text, sizeof(optlist));
+            free((char*)lvp->text);
+            optschanged();
+        } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
+            unsetvar(vp->text);
+        } else {
+            if (vp->func)
+                (*vp->func)(strchrnul(lvp->text, '=') + 1);
+            if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
+                free((char*)vp->text);
+            vp->flags = lvp->flags;
+            vp->text = lvp->text;
+        }
+        free(lvp);
+    }
+}
+
+static int
+evalfun(struct funcnode *func, int argc, char **argv, int flags)
+{
+    volatile struct shparam saveparam;
+    struct localvar *volatile savelocalvars;
+    struct jmploc *volatile savehandler;
+    struct jmploc jmploc;
+    int e;
+
+    saveparam = shellparam;
+    savelocalvars = localvars;
+    e = setjmp(jmploc.loc);
+    if (e) {
+        goto funcdone;
+    }
+    INT_OFF;
+    savehandler = exception_handler;
+    exception_handler = &jmploc;
+    localvars = NULL;
+    shellparam.malloc = 0;
+    func->count++;
+    funcnest++;
+    INT_ON;
+    shellparam.nparam = argc - 1;
+    shellparam.p = argv + 1;
+#if ENABLE_ASH_GETOPTS
+    shellparam.optind = 1;
+    shellparam.optoff = -1;
+#endif
+    evaltree(&func->n, flags & EV_TESTED);
+funcdone:
+    INT_OFF;
+    funcnest--;
+    freefunc(func);
+    poplocalvars();
+    localvars = savelocalvars;
+    freeparam(&shellparam);
+    shellparam = saveparam;
+    exception_handler = savehandler;
+    INT_ON;
+    evalskip &= ~SKIPFUNC;
+    return e;
+}
+
+#if ENABLE_ASH_CMDCMD
+static char **
+parse_command_args(char **argv, const char **path)
+{
+    char *cp, c;
+
+    for (;;) {
+        cp = *++argv;
+        if (!cp)
+            return 0;
+        if (*cp++ != '-')
+            break;
+        c = *cp++;
+        if (!c)
+            break;
+        if (c == '-' && !*cp) {
+            argv++;
+            break;
+        }
+        do {
+            switch (c) {
+            case 'p':
+                *path = bb_default_path;
+                break;
+            default:
+                /* run 'typecmd' for other options */
+                return 0;
+            }
+            c = *cp++;
+        } while (c);
+    }
+    return argv;
+}
+#endif
+
+/*
+ * Make a variable a local variable.  When a variable is made local, it's
+ * value and flags are saved in a localvar structure.  The saved values
+ * will be restored when the shell function returns.  We handle the name
+ * "-" as a special case.
+ */
+static void
+mklocal(char *name)
+{
+    struct localvar *lvp;
+    struct var **vpp;
+    struct var *vp;
+
+    INT_OFF;
+    lvp = ckmalloc(sizeof(struct localvar));
+    if (LONE_DASH(name)) {
+        char *p;
+        p = ckmalloc(sizeof(optlist));
+        lvp->text = memcpy(p, optlist, sizeof(optlist));
+        vp = NULL;
+    } else {
+        char *eq;
+
+        vpp = hashvar(name);
+        vp = *findvar(vpp, name);
+        eq = strchr(name, '=');
+        if (vp == NULL) {
+            if (eq)
+                setvareq(name, VSTRFIXED);
+            else
+                setvar(name, NULL, VSTRFIXED);
+            vp = *vpp;      /* the new variable */
+            lvp->flags = VUNSET;
+        } else {
+            lvp->text = vp->text;
+            lvp->flags = vp->flags;
+            vp->flags |= VSTRFIXED|VTEXTFIXED;
+            if (eq)
+                setvareq(name, 0);
+        }
+    }
+    lvp->vp = vp;
+    lvp->next = localvars;
+    localvars = lvp;
+    INT_ON;
+}
+
+/*
+ * The "local" command.
+ */
+static int
+localcmd(int argc, char **argv)
+{
+    char *name;
+
+    argv = argptr;
+    while ((name = *argv++) != NULL) {
+        mklocal(name);
+    }
+    return 0;
+}
+
+static int
+falsecmd(int argc, char **argv)
+{
+    return 1;
+}
+
+static int
+truecmd(int argc, char **argv)
+{
+    return 0;
+}
+
+static int
+execcmd(int argc, char **argv)
+{
+    if (argc > 1) {
+        iflag = 0;              /* exit on error */
+        mflag = 0;
+        optschanged();
+        shellexec(argv + 1, pathval(), 0);
+    }
+    return 0;
+}
+
+/*
+ * The return command.
+ */
+static int
+returncmd(int argc, char **argv)
+{
+    /*
+     * If called outside a function, do what ksh does;
+     * skip the rest of the file.
+     */
+    evalskip = funcnest ? SKIPFUNC : SKIPFILE;
+    return argv[1] ? number(argv[1]) : exitstatus;
+}
+
+/* Forward declarations for builtintab[] */
+static int breakcmd(int, char **);
+static int dotcmd(int, char **);
+static int evalcmd(int, char **);
+#if ENABLE_ASH_BUILTIN_ECHO
+static int echocmd(int, char **);
+#endif
+#if ENABLE_ASH_BUILTIN_TEST
+static int testcmd(int, char **);
+#endif
+static int exitcmd(int, char **);
+static int exportcmd(int, char **);
+#if ENABLE_ASH_GETOPTS
+static int getoptscmd(int, char **);
+#endif
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+static int helpcmd(int argc, char **argv);
+#endif
+#if ENABLE_ASH_MATH_SUPPORT
+static int letcmd(int, char **);
+#endif
+static int readcmd(int, char **);
+static int setcmd(int, char **);
+static int shiftcmd(int, char **);
+static int timescmd(int, char **);
+static int trapcmd(int, char **);
+static int umaskcmd(int, char **);
+static int unsetcmd(int, char **);
+static int ulimitcmd(int, char **);
+
+#define BUILTIN_NOSPEC          "0"
+#define BUILTIN_SPECIAL         "1"
+#define BUILTIN_REGULAR         "2"
+#define BUILTIN_SPEC_REG        "3"
+#define BUILTIN_ASSIGN          "4"
+#define BUILTIN_SPEC_ASSG       "5"
+#define BUILTIN_REG_ASSG        "6"
+#define BUILTIN_SPEC_REG_ASSG   "7"
+
+/* make sure to keep these in proper order since it is searched via bsearch() */
+static const struct builtincmd builtintab[] = {
+    { BUILTIN_SPEC_REG      ".", dotcmd },
+    { BUILTIN_SPEC_REG      ":", truecmd },
+#if ENABLE_ASH_BUILTIN_TEST
+    { BUILTIN_REGULAR   "[", testcmd },
+    { BUILTIN_REGULAR   "[[", testcmd },
+#endif
+#if ENABLE_ASH_ALIAS
+    { BUILTIN_REG_ASSG      "alias", aliascmd },
+#endif
 #if JOBS
-        retval = WSTOPSIG(status);
-        if (!WIFSTOPPED(status))
-#endif
-        {
-            /* XXX: limits number of signals */
-            retval = WTERMSIG(status);
+    { BUILTIN_REGULAR       "bg", fg_bgcmd },
+#endif
+    { BUILTIN_SPEC_REG      "break", breakcmd },
+    { BUILTIN_REGULAR       "cd", cdcmd },
+    { BUILTIN_NOSPEC        "chdir", cdcmd },
+#if ENABLE_ASH_CMDCMD
+    { BUILTIN_REGULAR       "command", commandcmd },
+#endif
+    { BUILTIN_SPEC_REG      "continue", breakcmd },
+#if ENABLE_ASH_BUILTIN_ECHO
+    { BUILTIN_REGULAR       "echo", echocmd },
+#endif
+    { BUILTIN_SPEC_REG      "eval", evalcmd },
+    { BUILTIN_SPEC_REG      "exec", execcmd },
+    { BUILTIN_SPEC_REG      "exit", exitcmd },
+    { BUILTIN_SPEC_REG_ASSG "export", exportcmd },
+    { BUILTIN_REGULAR       "false", falsecmd },
 #if JOBS
-            if (retval == SIGINT)
-                job->sigint = 1;
-#endif
-        }
-        retval += 128;
-    }
-    TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
-        jobno(job), job->nprocs, status, retval));
-    return retval;
-}
-
-#ifdef CONFIG_ASH_MAIL
-/*      mail.c       */
-
-/*
- * Routines to check for mail.  (Perhaps make part of main.c?)
- */
+    { BUILTIN_REGULAR       "fg", fg_bgcmd },
+#endif
+#if ENABLE_ASH_GETOPTS
+    { BUILTIN_REGULAR       "getopts", getoptscmd },
+#endif
+    { BUILTIN_NOSPEC        "hash", hashcmd },
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+    { BUILTIN_NOSPEC        "help", helpcmd },
+#endif
+#if JOBS
+    { BUILTIN_REGULAR       "jobs", jobscmd },
+    { BUILTIN_REGULAR       "kill", killcmd },
+#endif
+#if ENABLE_ASH_MATH_SUPPORT
+    { BUILTIN_NOSPEC        "let", letcmd },
+#endif
+    { BUILTIN_ASSIGN        "local", localcmd },
+    { BUILTIN_NOSPEC        "pwd", pwdcmd },
+    { BUILTIN_REGULAR       "read", readcmd },
+    { BUILTIN_SPEC_REG_ASSG "readonly", exportcmd },
+    { BUILTIN_SPEC_REG      "return", returncmd },
+    { BUILTIN_SPEC_REG      "set", setcmd },
+    { BUILTIN_SPEC_REG      "shift", shiftcmd },
+    { BUILTIN_SPEC_REG      "source", dotcmd },
+#if ENABLE_ASH_BUILTIN_TEST
+    { BUILTIN_REGULAR   "test", testcmd },
+#endif
+    { BUILTIN_SPEC_REG      "times", timescmd },
+    { BUILTIN_SPEC_REG      "trap", trapcmd },
+    { BUILTIN_REGULAR       "true", truecmd },
+    { BUILTIN_NOSPEC        "type", typecmd },
+    { BUILTIN_NOSPEC        "ulimit", ulimitcmd },
+    { BUILTIN_REGULAR       "umask", umaskcmd },
+#if ENABLE_ASH_ALIAS
+    { BUILTIN_REGULAR       "unalias", unaliascmd },
+#endif
+    { BUILTIN_SPEC_REG      "unset", unsetcmd },
+    { BUILTIN_REGULAR       "wait", waitcmd },
+};
+
+
+#define COMMANDCMD (builtintab + 5 + \
+    2 * ENABLE_ASH_BUILTIN_TEST + \
+    ENABLE_ASH_ALIAS + \
+    ENABLE_ASH_JOB_CONTROL)
+#define EXECCMD (builtintab + 7 + \
+    2 * ENABLE_ASH_BUILTIN_TEST + \
+    ENABLE_ASH_ALIAS + \
+    ENABLE_ASH_JOB_CONTROL + \
+    ENABLE_ASH_CMDCMD + \
+    ENABLE_ASH_BUILTIN_ECHO)
+
+/*
+ * Search the table of builtin commands.
+ */
+static struct builtincmd *
+find_builtin(const char *name)
+{
+    struct builtincmd *bp;
+
+    bp = bsearch(
+        name, builtintab, ARRAY_SIZE(builtintab), sizeof(builtintab[0]),
+        pstrcmp
+    );
+    return bp;
+}
+
+/*
+ * Execute a simple command.
+ */
+static int back_exitstatus; /* exit status of backquoted command */
+static int
+isassignment(const char *p)
+{
+    const char *q = endofname(p);
+    if (p == q)
+        return 0;
+    return *q == '=';
+}
+static int
+bltincmd(int argc, char **argv)
+{
+    /* Preserve exitstatus of a previous possible redirection
+     * as POSIX mandates */
+    return back_exitstatus;
+}
+static void
+evalcommand(union node *cmd, int flags)
+{
+    static const struct builtincmd bltin = {
+        "\0\0", bltincmd
+    };
+    struct stackmark smark;
+    union node *argp;
+    struct arglist arglist;
+    struct arglist varlist;
+    char **argv;
+    int argc;
+    const struct strlist *sp;
+    struct cmdentry cmdentry;
+    struct job *jp;
+    char *lastarg;
+    const char *path;
+    int spclbltin;
+    int cmd_is_exec;
+    int status;
+    char **nargv;
+    struct builtincmd *bcmd;
+    int pseudovarflag = 0;
+
+    /* First expand the arguments. */
+    TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
+    setstackmark(&smark);
+    back_exitstatus = 0;
+
+    cmdentry.cmdtype = CMDBUILTIN;
+    cmdentry.u.cmd = &bltin;
+    varlist.lastp = &varlist.list;
+    *varlist.lastp = NULL;
+    arglist.lastp = &arglist.list;
+    *arglist.lastp = NULL;
+
+    argc = 0;
+    if (cmd->ncmd.args) {
+        bcmd = find_builtin(cmd->ncmd.args->narg.text);
+        pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
+    }
+
+    for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
+        struct strlist **spp;
+
+        spp = arglist.lastp;
+        if (pseudovarflag && isassignment(argp->narg.text))
+            expandarg(argp, &arglist, EXP_VARTILDE);
+        else
+            expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
+
+        for (sp = *spp; sp; sp = sp->next)
+            argc++;
+    }
+
+    argv = nargv = stalloc(sizeof(char *) * (argc + 1));
+    for (sp = arglist.list; sp; sp = sp->next) {
+        TRACE(("evalcommand arg: %s\n", sp->text));
+        *nargv++ = sp->text;
+    }
+    *nargv = NULL;
+
+    lastarg = NULL;
+    if (iflag && funcnest == 0 && argc > 0)
+        lastarg = nargv[-1];
+
+    preverrout_fd = 2;
+    expredir(cmd->ncmd.redirect);
+    status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH | REDIR_SAVEFD2);
+
+    path = vpath.text;
+    for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
+        struct strlist **spp;
+        char *p;
+
+        spp = varlist.lastp;
+        expandarg(argp, &varlist, EXP_VARTILDE);
+
+        /*
+         * Modify the command lookup path, if a PATH= assignment
+         * is present
+         */
+        p = (*spp)->text;
+        if (varequal(p, path))
+            path = p;
+    }
+
+    /* Print the command if xflag is set. */
+    if (xflag) {
+        int n;
+        const char *p = " %s";
+
+        p++;
+        dprintf(preverrout_fd, p, expandstr(ps4val()));
+
+        sp = varlist.list;
+        for (n = 0; n < 2; n++) {
+            while (sp) {
+                dprintf(preverrout_fd, p, sp->text);
+                sp = sp->next;
+                if (*p == '%') {
+                    p--;
+                }
+            }
+            sp = arglist.list;
+        }
+        full_write(preverrout_fd, "\n", 1);
+    }
+
+    cmd_is_exec = 0;
+    spclbltin = -1;
+
+    /* Now locate the command. */
+    if (argc) {
+        const char *oldpath;
+        int cmd_flag = DO_ERR;
+
+        path += 5;
+        oldpath = path;
+        for (;;) {
+            find_command(argv[0], &cmdentry, cmd_flag, path);
+            if (cmdentry.cmdtype == CMDUNKNOWN) {
+                status = 127;
+                flush_stderr();
+                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++;
+#if ENABLE_ASH_CMDCMD
+            if (cmdentry.u.cmd == COMMANDCMD) {
+                path = oldpath;
+                nargv = parse_command_args(argv, &path);
+                if (!nargv)
+                    break;
+                argc -= nargv - argv;
+                argv = nargv;
+                cmd_flag |= DO_NOFUNC;
+            } else
+#endif
+                break;
+        }
+    }
+
+    if (status) {
+        /* We have a redirection error. */
+        if (spclbltin > 0)
+            raise_exception(EXERROR);
+ bail:
+        exitstatus = status;
+        goto out;
+    }
+
+    /* Execute the command. */
+    switch (cmdentry.cmdtype) {
+    default:
+        /* Fork off a child process if necessary. */
+        if (!(flags & EV_EXIT) || trap[0]) {
+            INT_OFF;
+            jp = makejob(cmd, 1);
+            if (forkshell(jp, cmd, FORK_FG) != 0) {
+                exitstatus = waitforjob(jp);
+                INT_ON;
+                break;
+            }
+            FORCE_INT_ON;
+        }
+        listsetvar(varlist.list, VEXPORT|VSTACK);
+        shellexec(argv, path, cmdentry.u.index);
+        /* NOTREACHED */
+
+    case CMDBUILTIN:
+        cmdenviron = varlist.list;
+        if (cmdenviron) {
+            struct strlist *list = cmdenviron;
+            int i = VNOSET;
+            if (spclbltin > 0 || argc == 0) {
+                i = 0;
+                if (cmd_is_exec && argc > 1)
+                    i = VEXPORT;
+            }
+            listsetvar(list, i);
+        }
+        if (evalbltin(cmdentry.u.cmd, argc, argv)) {
+            int exit_status;
+            int i, j;
+
+            i = exception;
+            if (i == EXEXIT)
+                goto raise;
+
+            exit_status = 2;
+            j = 0;
+            if (i == EXINT)
+                j = SIGINT;
+            if (i == EXSIG)
+                j = pendingsig;
+            if (j)
+                exit_status = j + 128;
+            exitstatus = exit_status;
+
+            if (i == EXINT || spclbltin > 0) {
+ raise:
+                longjmp(exception_handler->loc, 1);
+            }
+            FORCE_INT_ON;
+        }
+        break;
+
+    case CMDFUNCTION:
+        listsetvar(varlist.list, 0);
+        if (evalfun(cmdentry.u.func, argc, argv, flags))
+            goto raise;
+        break;
+    }
+
+ out:
+    popredir(cmd_is_exec);
+    if (lastarg)
+        /* dsl: I think this is intended to be used to support
+         * '_' in 'vi' command mode during line editing...
+         * However I implemented that within libedit itself.
+         */
+        setvar("_", lastarg, 0);
+    popstackmark(&smark);
+}
+
+static int
+evalbltin(const struct builtincmd *cmd, int argc, char **argv)
+{
+    char *volatile savecmdname;
+    struct jmploc *volatile savehandler;
+    struct jmploc jmploc;
+    int i;
+
+    savecmdname = commandname;
+    i = setjmp(jmploc.loc);
+    if (i)
+        goto cmddone;
+    savehandler = exception_handler;
+    exception_handler = &jmploc;
+    commandname = argv[0];
+    argptr = argv + 1;
+    optptr = NULL;                  /* initialize nextopt */
+    exitstatus = (*cmd->builtin)(argc, argv);
+    flush_stdout_stderr();
+ cmddone:
+    exitstatus |= ferror(stdout);
+    clearerr(stdout);
+    commandname = savecmdname;
+    exsig = 0;
+    exception_handler = savehandler;
+
+    return i;
+}
+
+static int
+goodname(const char *p)
+{
+    return !*endofname(p);
+}
+
+
+/*
+ * 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->type == NCMD && n->ncmd.args && goodname(n->ncmd.args->narg.text))
+        find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
+}
+
+
+/* ============ Builtin commands
+ *
+ * Builtin commands whose functions are closely tied to evaluation
+ * are implemented here.
+ */
+
+/*
+ * 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.
+ */
+static int
+breakcmd(int argc, char **argv)
+{
+    int n = argc > 1 ? number(argv[1]) : 1;
+
+    if (n <= 0)
+        ash_msg_and_raise_error(illnum, argv[1]);
+    if (n > loopnest)
+        n = loopnest;
+    if (n > 0) {
+        evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
+        skipcount = n;
+    }
+    return 0;
+}
+
+
+/* ============ input.c
+ *
+ * This implements the input routines used by the parser.
+ */
+
+#define EOF_NLEFT -99           /* value of parsenleft when EOF pushed back */
+
+enum {
+    INPUT_PUSH_FILE = 1,
+    INPUT_NOFILE_OK = 2,
+};
+
+/*
+ * NEOF is returned by parsecmd when it encounters an end of file.  It
+ * must be distinct from NULL, so we use the address of a variable that
+ * happens to be handy.
+ */
+static int plinno = 1;                  /* input line number */
+/* number of characters left in input buffer */
+static int parsenleft;                  /* copy of parsefile->nleft */
+static int parselleft;                  /* copy of parsefile->lleft */
+/* next character in input buffer */
+static char *parsenextc;                /* copy of parsefile->nextc */
+
+static int checkkwd;
+/* values of checkkwd variable */
+#define CHKALIAS        0x1
+#define CHKKWD          0x2
+#define CHKNL           0x4
+
+static void
+popstring(void)
+{
+    struct strpush *sp = parsefile->strpush;
+
+    INT_OFF;
+#if ENABLE_ASH_ALIAS
+    if (sp->ap) {
+        if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
+            checkkwd |= CHKALIAS;
+        }
+        if (sp->string != sp->ap->val) {
+            free(sp->string);
+        }
+        sp->ap->flag &= ~ALIASINUSE;
+        if (sp->ap->flag & ALIASDEAD) {
+            unalias(sp->ap->name);
+        }
+    }
+#endif
+    parsenextc = sp->prevstring;
+    parsenleft = sp->prevnleft;
+/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
+    parsefile->strpush = sp->prev;
+    if (sp != &(parsefile->basestrpush))
+        free(sp);
+    INT_ON;
+}
+
+static int
+preadfd(void)
+{
+    int nr;
+    char *buf =  parsefile->buf;
+    parsenextc = buf;
+
+ retry:
+#if ENABLE_FEATURE_EDITING
+    if (!iflag || parsefile->fd)
+        nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
+    else {
+#if ENABLE_FEATURE_TAB_COMPLETION
+        line_input_state->path_lookup = pathval();
+#endif
+        nr = read_line_input(cmdedit_prompt, buf, BUFSIZ, line_input_state);
+        if (nr == 0) {
+            /* Ctrl+C pressed */
+            if (trap[SIGINT]) {
+                buf[0] = '\n';
+                buf[1] = '\0';
+                raise(SIGINT);
+                return 1;
+            }
+            goto retry;
+        }
+        if (nr < 0 && errno == 0) {
+            /* Ctrl+D presend */
+            nr = 0;
+        }
+    }
+#else
+    nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
+#endif
+
+    if (nr < 0) {
+        if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
+            int flags = fcntl(0, F_GETFL);
+            if (flags >= 0 && flags & O_NONBLOCK) {
+                flags &=~ O_NONBLOCK;
+                if (fcntl(0, F_SETFL, flags) >= 0) {
+                    out2str("sh: turning off NDELAY mode\n");
+                    goto retry;
+                }
+            }
+        }
+    }
+    return nr;
+}
+
+/*
+ * Refill the input buffer and return the next input character:
+ *
+ * 1) If a string was pushed back on the input, pop it;
+ * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
+ *    from a string so we can't refill the buffer, return EOF.
+ * 3) If the is more stuff in this buffer, use it else call read to fill it.
+ * 4) Process input up to the next newline, deleting nul characters.
+ */
+static int
+preadbuffer(void)
+{
+    char *q;
+    int more;
+    char savec;
+
+    while (parsefile->strpush) {
+#if ENABLE_ASH_ALIAS
+        if (parsenleft == -1 && parsefile->strpush->ap &&
+            parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
+            return PEOA;
+        }
+#endif
+        popstring();
+        if (--parsenleft >= 0)
+            return signed_char2int(*parsenextc++);
+    }
+    if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
+        return PEOF;
+    flush_stdout_stderr();
+
+    more = parselleft;
+    if (more <= 0) {
+ again:
+        more = preadfd();
+        if (more <= 0) {
+            parselleft = parsenleft = EOF_NLEFT;
+            return PEOF;
+        }
+    }
+
+    q = parsenextc;
+
+    /* delete nul characters */
+    for (;;) {
+        int c;
+
+        more--;
+        c = *q;
+
+        if (!c)
+            memmove(q, q + 1, more);
+        else {
+            q++;
+            if (c == '\n') {
+                parsenleft = q - parsenextc - 1;
+                break;
+            }
+        }
+
+        if (more <= 0) {
+            parsenleft = q - parsenextc - 1;
+            if (parsenleft < 0)
+                goto again;
+            break;
+        }
+    }
+    parselleft = more;
+
+    savec = *q;
+    *q = '\0';
+
+    if (vflag) {
+        out2str(parsenextc);
+    }
+
+    *q = savec;
+
+    return signed_char2int(*parsenextc++);
+}
+
+#define pgetc_as_macro() (--parsenleft >= 0? signed_char2int(*parsenextc++) : preadbuffer())
+static int
+pgetc(void)
+{
+    return pgetc_as_macro();
+}
+
+#if ENABLE_ASH_OPTIMIZE_FOR_SIZE
+#define pgetc_macro() pgetc()
+#else
+#define pgetc_macro() pgetc_as_macro()
+#endif
+
+/*
+ * Same as pgetc(), but ignores PEOA.
+ */
+#if ENABLE_ASH_ALIAS
+static int
+pgetc2(void)
+{
+    int c;
+
+    do {
+        c = pgetc_macro();
+    } while (c == PEOA);
+    return c;
+}
+#else
+static int
+pgetc2(void)
+{
+    return pgetc_macro();
+}
+#endif
+
+/*
+ * Read a line from the script.
+ */
+static char *
+pfgets(char *line, int len)
+{
+    char *p = line;
+    int nleft = len;
+    int c;
+
+    while (--nleft > 0) {
+        c = pgetc2();
+        if (c == PEOF) {
+            if (p == line)
+                return NULL;
+            break;
+        }
+        *p++ = c;
+        if (c == '\n')
+            break;
+    }
+    *p = '\0';
+    return line;
+}
+
+/*
+ * Undo the last call to pgetc.  Only one character may be pushed back.
+ * PEOF may be pushed back.
+ */
+static void
+pungetc(void)
+{
+    parsenleft++;
+    parsenextc--;
+}
+
+/*
+ * Push a string back onto the input at this current parsefile level.
+ * We handle aliases this way.
+ */
+static void
+pushstring(char *s, void *ap)
+{
+    struct strpush *sp;
+    size_t len;
+
+    len = strlen(s);
+    INT_OFF;
+/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
+    if (parsefile->strpush) {
+        sp = ckmalloc(sizeof(struct strpush));
+        sp->prev = parsefile->strpush;
+        parsefile->strpush = sp;
+    } else
+        sp = parsefile->strpush = &(parsefile->basestrpush);
+    sp->prevstring = parsenextc;
+    sp->prevnleft = parsenleft;
+#if ENABLE_ASH_ALIAS
+    sp->ap = (struct alias *)ap;
+    if (ap) {
+        ((struct alias *)ap)->flag |= ALIASINUSE;
+        sp->string = s;
+    }
+#endif
+    parsenextc = s;
+    parsenleft = len;
+    INT_ON;
+}
+
+/*
+ * To handle the "." command, a stack of input files is used.  Pushfile
+ * adds a new entry to the stack and popfile restores the previous level.
+ */
+static void
+pushfile(void)
+{
+    struct parsefile *pf;
+
+    parsefile->nleft = parsenleft;
+    parsefile->lleft = parselleft;
+    parsefile->nextc = parsenextc;
+    parsefile->linno = plinno;
+    pf = ckmalloc(sizeof(*pf));
+    pf->prev = parsefile;
+    pf->fd = -1;
+    pf->strpush = NULL;
+    pf->basestrpush.prev = NULL;
+    parsefile = pf;
+}
+
+static void
+popfile(void)
+{
+    struct parsefile *pf = parsefile;
+
+    INT_OFF;
+    if (pf->fd >= 0)
+        close(pf->fd);
+    if (pf->buf)
+        free(pf->buf);
+    while (pf->strpush)
+        popstring();
+    parsefile = pf->prev;
+    free(pf);
+    parsenleft = parsefile->nleft;
+    parselleft = parsefile->lleft;
+    parsenextc = parsefile->nextc;
+    plinno = parsefile->linno;
+    INT_ON;
+}
+
+/*
+ * Return to top level.
+ */
+static void
+popallfiles(void)
+{
+    while (parsefile != &basepf)
+        popfile();
+}
+
+/*
+ * Close the file(s) that the shell is reading commands from.  Called
+ * after a fork is done.
+ */
+static void
+closescript(void)
+{
+    popallfiles();
+    if (parsefile->fd > 0) {
+        close(parsefile->fd);
+        parsefile->fd = 0;
+    }
+}
+
+/*
+ * Like setinputfile, but takes an open file descriptor.  Call this with
+ * interrupts off.
+ */
+static void
+setinputfd(int fd, int push)
+{
+    fcntl(fd, F_SETFD, FD_CLOEXEC);
+    if (push) {
+        pushfile();
+        parsefile->buf = 0;
+    }
+    parsefile->fd = fd;
+    if (parsefile->buf == NULL)
+        parsefile->buf = ckmalloc(IBUFSIZ);
+    parselleft = parsenleft = 0;
+    plinno = 1;
+}
+
+/*
+ * Set the input to take input from a file.  If push is set, push the
+ * old input onto the stack first.
+ */
+static int
+setinputfile(const char *fname, int flags)
+{
+    int fd;
+    int fd2;
+
+    INT_OFF;
+    fd = open(fname, O_RDONLY);
+    if (fd < 0) {
+        if (flags & INPUT_NOFILE_OK)
+            goto out;
+        ash_msg_and_raise_error("can't open %s", fname);
+    }
+    if (fd < 10) {
+        fd2 = copyfd(fd, 10);
+        close(fd);
+        if (fd2 < 0)
+            ash_msg_and_raise_error("out of file descriptors");
+        fd = fd2;
+    }
+    setinputfd(fd, flags & INPUT_PUSH_FILE);
+ out:
+    INT_ON;
+    return fd;
+}
+
+/*
+ * Like setinputfile, but takes input from a string.
+ */
+static void
+setinputstring(char *string)
+{
+    INT_OFF;
+    pushfile();
+    parsenextc = string;
+    parsenleft = strlen(string);
+    parsefile->buf = NULL;
+    plinno = 1;
+    INT_ON;
+}
+
+
+/* ============ mail.c
+ *
+ * Routines to check for mail.
+ */
+
+#if ENABLE_ASH_MAIL
 
 #define MAXMBOXES 10
@@ -7782 +8909 @@
 static int mail_var_path_changed;
 
-
-
 /*
  * Print appropriate message(s) if mail has arrived.
@@ -7790 +8915 @@
  * so we just update the values.
  */
-
 static void
 chkmail(void)
@@ -7809 +8933 @@
         if (*p == '\0')
             continue;
-        for (q = p ; *q ; q++);
-#ifdef DEBUG
+        for (q = p; *q; q++);
+#if DEBUG
         if (q[-1] != '/')
             abort();
@@ -7831 +8955 @@
 }
 
-
 static void
 changemail(const char *val)
@@ -7838 +8961 @@
 }
 
-#endif /* CONFIG_ASH_MAIL */
-
-/*      main.c       */
-
-
-#if PROFILE
-static short profile_buf[16384];
-extern int etext();
-#endif
-
-static int isloginsh;
-
-static void read_profile(const char *);
-
-/*
- * Main routine.  We initialize things, parse the arguments, execute
- * profiles if we're a login shell, and then call cmdloop to execute
- * commands.  The setjmp call sets up the location to jump to when an
- * exception occurs.  When an exception occurs the variable "state"
- * is used to figure out how far we had gotten.
- */
-
-int
-ash_main(int argc, char **argv)
-{
-    char *shinit;
-    volatile int state;
-    struct jmploc jmploc;
-    struct stackmark smark;
-
-#ifdef __GLIBC__
-    dash_errno = __errno_location();
-#endif
-
-#if PROFILE
-    monitor(4, etext, profile_buf, sizeof profile_buf, 50);
-#endif
-    state = 0;
-    if (setjmp(jmploc.loc)) {
-        int e;
-        int s;
-
-        reset();
-
-        e = exception;
-        if (e == EXERROR)
-            exitstatus = 2;
-        s = state;
-        if (e == EXEXIT || s == 0 || iflag == 0 || shlvl)
-            exitshell();
-
-        if (e == EXINT) {
-            outcslow('\n', stderr);
-        }
-        popstackmark(&smark);
-        FORCEINTON;                             /* enable interrupts */
-        if (s == 1)
-            goto state1;
-        else if (s == 2)
-            goto state2;
-        else if (s == 3)
-            goto state3;
-        else
-            goto state4;
-    }
-    handler = &jmploc;
-#ifdef DEBUG
-    opentrace();
-    trputs("Shell args:  ");  trargs(argv);
-#endif
-    rootpid = getpid();
-
-#ifdef CONFIG_ASH_RANDOM_SUPPORT
-    rseed = rootpid + ((time_t)time((time_t *)0));
-#endif
-    init();
-    setstackmark(&smark);
-    procargs(argc, argv);
-#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
-    if ( iflag ) {
-        const char *hp = lookupvar("HISTFILE");
-
-        if(hp == NULL ) {
-            hp = lookupvar("HOME");
-            if(hp != NULL) {
-                char *defhp = concat_path_file(hp, ".ash_history");
-                setvar("HISTFILE", defhp, 0);
-                free(defhp);
-            }
-        }
-    }
-#endif
-    if (argv[0] && argv[0][0] == '-')
-        isloginsh = 1;
-    if (isloginsh) {
-        state = 1;
-        read_profile("/etc/profile");
-state1:
-        state = 2;
-        read_profile(".profile");
-    }
-state2:
-    state = 3;
-    if (
-#ifndef linux
-        getuid() == geteuid() && getgid() == getegid() &&
-#endif
-        iflag
-    ) {
-        if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
-            read_profile(shinit);
-        }
-    }
-state3:
-    state = 4;
-    if (minusc)
-        evalstring(minusc, 0);
-
-    if (sflag || minusc == NULL) {
-#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
-        if ( iflag ) {
-        const char *hp = lookupvar("HISTFILE");
-
-        if(hp != NULL )
-            load_history ( hp );
-        }
-#endif
-state4: /* XXX ??? - why isn't this before the "if" statement */
-        cmdloop(1);
-    }
-#if PROFILE
-    monitor(0);
-#endif
-#if GPROF
-    {
-        extern void _mcleanup(void);
-        _mcleanup();
-    }
-#endif
-    exitshell();
-    /* NOTREACHED */
-}
-
-
-/*
- * Read and execute commands.  "Top" is nonzero for the top level command
- * loop; it turns on prompting if the shell is interactive.
- */
-
-static int
-cmdloop(int top)
-{
-    union node *n;
-    struct stackmark smark;
-    int inter;
-    int numeof = 0;
-
-    TRACE(("cmdloop(%d) called\n", top));
-    for (;;) {
-        int skip;
-
-        setstackmark(&smark);
-#if JOBS
-        if (jobctl)
-            showjobs(stderr, SHOW_CHANGED);
-#endif
-        inter = 0;
-        if (iflag && top) {
-            inter++;
-#ifdef CONFIG_ASH_MAIL
-            chkmail();
-#endif
-        }
-        n = parsecmd(inter);
-        /* showtree(n); DEBUG */
-        if (n == NEOF) {
-            if (!top || numeof >= 50)
-                break;
-            if (!stoppedjobs()) {
-                if (!Iflag)
-                    break;
-                out2str("\nUse \"exit\" to leave shell.\n");
-            }
-            numeof++;
-        } else if (nflag == 0) {
-            job_warning = (job_warning == 2) ? 1 : 0;
-            numeof = 0;
-            evaltree(n, 0);
-        }
-        popstackmark(&smark);
-        skip = evalskip;
-
-        if (skip) {
-            evalskip = 0;
-            return skip & SKIPEVAL;
-        }
-    }
-
-    return 0;
-}
-
-
-/*
- * Read /etc/profile or .profile.  Return on error.
- */
-
-static void
-read_profile(const char *name)
-{
-    int skip;
-
-    if (setinputfile(name, INPUT_PUSH_FILE | INPUT_NOFILE_OK) < 0)
-        return;
-
-    skip = cmdloop(0);
-    popfile();
-
-    if (skip)
-        exitshell();
-}
-
-
-/*
- * Read a file containing shell functions.
- */
-
-static void
-readcmdfile(char *name)
-{
-    setinputfile(name, INPUT_PUSH_FILE);
-    cmdloop(0);
-    popfile();
-}
-
-
-/*
- * 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 inline char *
-find_dot_file(char *name)
-{
-    char *fullname;
-    const char *path = pathval();
-    struct stat statb;
-
-    /* don't try this for absolute or relative paths */
-    if (strchr(name, '/'))
-        return name;
-
-    while ((fullname = padvance(&path, name)) != NULL) {
-        if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
-            /*
-             * Don't bother freeing here, since it will
-             * be freed by the caller.
-             */
-            return fullname;
-        }
-        stunalloc(fullname);
-    }
-
-    /* not found in the PATH */
-    sh_error(not_found_msg, name);
-    /* NOTREACHED */
-}
-
-static int dotcmd(int argc, char **argv)
-{
-    struct strlist *sp;
-    volatile struct shparam saveparam;
-    int status = 0;
-
-    for (sp = cmdenviron; sp; sp = sp->next)
-        setvareq(bb_xstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
-
-    if (argc >= 2) {        /* That's what SVR2 does */
-        char *fullname;
-
-        fullname = find_dot_file(argv[1]);
-
-        if (argc > 2) {
-            saveparam = shellparam;
-            shellparam.malloc = 0;
-            shellparam.nparam = argc - 2;
-            shellparam.p = argv + 2;
-        };
-
-        setinputfile(fullname, INPUT_PUSH_FILE);
-        commandname = fullname;
-        cmdloop(0);
-        popfile();
-
-        if (argc > 2) {
-            freeparam(&shellparam);
-            shellparam = saveparam;
-        };
-        status = exitstatus;
-    }
-    return status;
-}
-
-
-static int
-exitcmd(int argc, char **argv)
-{
-    if (stoppedjobs())
-        return 0;
-    if (argc > 1)
-        exitstatus = number(argv[1]);
-    exraise(EXEXIT);
-    /* NOTREACHED */
-}
-
-#ifdef CONFIG_ASH_BUILTIN_ECHO
-static int
-echocmd(int argc, char **argv)
-{
-    return bb_echo(argc, argv);
-}
-#endif
-
-#ifdef CONFIG_ASH_BUILTIN_TEST
-static int
-testcmd(int argc, char **argv)
-{
-    return bb_test(argc, argv);
-}
-#endif
-
-/*      memalloc.c        */
-
-/*
- * Same for malloc, realloc, but returns an error when out of space.
- */
-
-static pointer
-ckrealloc(pointer p, size_t nbytes)
-{
-    p = realloc(p, nbytes);
-    if (p == NULL)
-        sh_error(bb_msg_memory_exhausted);
-    return p;
-}
-
-static pointer
-ckmalloc(size_t nbytes)
-{
-    return ckrealloc(NULL, nbytes);
-}
-
-/*
- * Make a copy of a string in safe storage.
- */
-
-static char *
-savestr(const char *s)
-{
-    char *p = strdup(s);
-    if (!p)
-        sh_error(bb_msg_memory_exhausted);
-    return p;
-}
-
-
-/*
- * Parse trees for commands are allocated in lifo order, so we use a stack
- * to make this more efficient, and also to avoid all sorts of exception
- * handling code to handle interrupts in the middle of a parse.
- *
- * The size 504 was chosen because the Ultrix malloc handles that size
- * well.
- */
-
-
-static pointer
-stalloc(size_t nbytes)
-{
-    char *p;
-    size_t aligned;
-
-    aligned = SHELL_ALIGN(nbytes);
-    if (aligned > stacknleft) {
-        size_t len;
-        size_t blocksize;
-        struct stack_block *sp;
-
-        blocksize = aligned;
-        if (blocksize < MINSIZE)
-            blocksize = MINSIZE;
-        len = sizeof(struct stack_block) - MINSIZE + blocksize;
-        if (len < blocksize)
-            sh_error(bb_msg_memory_exhausted);
-        INTOFF;
-        sp = ckmalloc(len);
-        sp->prev = stackp;
-        stacknxt = sp->space;
-        stacknleft = blocksize;
-        sstrend = stacknxt + blocksize;
-        stackp = sp;
-        INTON;
-    }
-    p = stacknxt;
-    stacknxt += aligned;
-    stacknleft -= aligned;
-    return p;
-}
-
-
-void
-stunalloc(pointer p)
-{
-#ifdef DEBUG
-    if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) {
-        write(2, "stunalloc\n", 10);
-        abort();
-    }
-#endif
-    stacknleft += stacknxt - (char *)p;
-    stacknxt = p;
-}
-
-
-void
-setstackmark(struct stackmark *mark)
-{
-    mark->stackp = stackp;
-    mark->stacknxt = stacknxt;
-    mark->stacknleft = stacknleft;
-    mark->marknext = markp;
-    markp = mark;
-}
-
-
-void
-popstackmark(struct stackmark *mark)
-{
-    struct stack_block *sp;
-
-    INTOFF;
-    markp = mark->marknext;
-    while (stackp != mark->stackp) {
-        sp = stackp;
-        stackp = sp->prev;
-        ckfree(sp);
-    }
-    stacknxt = mark->stacknxt;
-    stacknleft = mark->stacknleft;
-    sstrend = mark->stacknxt + mark->stacknleft;
-    INTON;
-}
-
-
-/*
- * When the parser reads in a string, it wants to stick the string on the
- * stack and only adjust the stack pointer when it knows how big the
- * string is.  Stackblock (defined in stack.h) returns a pointer to a block
- * of space on top of the stack and stackblocklen returns the length of
- * this block.  Growstackblock will grow this space by at least one byte,
- * possibly moving it (like realloc).  Grabstackblock actually allocates the
- * part of the block that has been used.
- */
-
-void
-growstackblock(void)
-{
-    size_t newlen;
-
-    newlen = stacknleft * 2;
-    if (newlen < stacknleft)
-        sh_error(bb_msg_memory_exhausted);
-    if (newlen < 128)
-        newlen += 128;
-
-    if (stacknxt == stackp->space && stackp != &stackbase) {
-        struct stack_block *oldstackp;
-        struct stackmark *xmark;
-        struct stack_block *sp;
-        struct stack_block *prevstackp;
-        size_t grosslen;
-
-        INTOFF;
-        oldstackp = stackp;
-        sp = stackp;
-        prevstackp = sp->prev;
-        grosslen = newlen + sizeof(struct stack_block) - MINSIZE;
-        sp = ckrealloc((pointer)sp, grosslen);
-        sp->prev = prevstackp;
-        stackp = sp;
-        stacknxt = sp->space;
-        stacknleft = newlen;
-        sstrend = sp->space + newlen;
-
-        /*
-         * Stack marks pointing to the start of the old block
-         * must be relocated to point to the new block
-         */
-        xmark = markp;
-        while (xmark != NULL && xmark->stackp == oldstackp) {
-            xmark->stackp = stackp;
-            xmark->stacknxt = stacknxt;
-            xmark->stacknleft = stacknleft;
-            xmark = xmark->marknext;
-        }
-        INTON;
-    } else {
-        char *oldspace = stacknxt;
-        int oldlen = stacknleft;
-        char *p = stalloc(newlen);
-
-        /* free the space we just allocated */
-        stacknxt = memcpy(p, oldspace, oldlen);
-        stacknleft += newlen;
-    }
-}
-
-static inline void
-grabstackblock(size_t len)
-{
-    len = SHELL_ALIGN(len);
-    stacknxt += len;
-    stacknleft -= len;
-}
-
-/*
- * The following routines are somewhat easier to use than the above.
- * The user declares a variable of type STACKSTR, which may be declared
- * to be a register.  The macro STARTSTACKSTR initializes things.  Then
- * the user uses the macro STPUTC to add characters to the string.  In
- * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
- * grown as necessary.  When the user is done, she can just leave the
- * string there and refer to it using stackblock().  Or she can allocate
- * the space for it using grabstackstr().  If it is necessary to allow
- * someone else to use the stack temporarily and then continue to grow
- * the string, the user should use grabstack to allocate the space, and
- * then call ungrabstr(p) to return to the previous mode of operation.
- *
- * USTPUTC is like STPUTC except that it doesn't check for overflow.
- * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
- * is space for at least one character.
- */
-
-void *
-growstackstr(void)
-{
-    size_t len = stackblocksize();
-    if (herefd >= 0 && len >= 1024) {
-        bb_full_write(herefd, stackblock(), len);
-        return stackblock();
-    }
-    growstackblock();
-    return stackblock() + len;
-}
-
-/*
- * Called from CHECKSTRSPACE.
- */
-
-char *
-makestrspace(size_t newlen, char *p)
-{
-    size_t len = p - stacknxt;
-    size_t size = stackblocksize();
-
-    for (;;) {
-        size_t nleft;
-
-        size = stackblocksize();
-        nleft = size - len;
-        if (nleft >= newlen)
-            break;
-        growstackblock();
-    }
-    return stackblock() + len;
-}
-
-char *
-stnputs(const char *s, size_t n, char *p)
-{
-    p = makestrspace(n, p);
-    p = mempcpy(p, s, n);
-    return p;
-}
-
-char *
-stputs(const char *s, char *p)
-{
-    return stnputs(s, strlen(s), p);
-}
-
-/*      mystring.c   */
-
-/*
- * String functions.
- *
- *      number(s)               Convert a string of digits to an integer.
- *      is_number(s)            Return true if s is a string of digits.
- */
-
-/*
- * prefix -- see if pfx is a prefix of string.
- */
-
-char *
-prefix(const char *string, const char *pfx)
-{
-    while (*pfx) {
-        if (*pfx++ != *string++)
-            return 0;
-    }
-    return (char *) string;
-}
-
-
-/*
- * Convert a string of digits to an integer, printing an error message on
- * failure.
- */
-
-int
-number(const char *s)
-{
-
-    if (! is_number(s))
-        sh_error(illnum, s);
-    return atoi(s);
-}
-
-
-/*
- * Check for a valid number.  This should be elsewhere.
- */
-
-int
-is_number(const char *p)
-{
-    do {
-        if (! is_digit(*p))
-            return 0;
-    } while (*++p != '\0');
-    return 1;
-}
-
-
-/*
- * Produce a possibly single quoted string suitable as input to the shell.
- * The return string is allocated on the stack.
- */
-
-char *
-single_quote(const char *s) {
-    char *p;
-
-    STARTSTACKSTR(p);
-
-    do {
-        char *q;
-        size_t len;
-
-        len = strchrnul(s, '\'') - s;
-
-        q = p = makestrspace(len + 3, p);
-
-        *q++ = '\'';
-        q = mempcpy(q, s, len);
-        *q++ = '\'';
-        s += len;
-
-        STADJUST(q - p, p);
-
-        len = strspn(s, "'");
-        if (!len)
-            break;
-
-        q = p = makestrspace(len + 3, p);
-
-        *q++ = '"';
-        q = mempcpy(q, s, len);
-        *q++ = '"';
-        s += len;
-
-        STADJUST(q - p, p);
-    } while (*s);
-
-    USTPUTC(0, p);
-
-    return stackblock();
-}
-
-/*
- * Like strdup but works with the ash stack.
- */
-
-char *
-sstrdup(const char *p)
-{
-    size_t len = strlen(p) + 1;
-    return memcpy(stalloc(len), p, len);
-}
-
-
-static void
-calcsize(union node *n)
-{
-      if (n == NULL)
-        return;
-      funcblocksize += nodesize[n->type];
-      switch (n->type) {
-      case NCMD:
-        calcsize(n->ncmd.redirect);
-        calcsize(n->ncmd.args);
-        calcsize(n->ncmd.assign);
-        break;
-      case NPIPE:
-        sizenodelist(n->npipe.cmdlist);
-        break;
-      case NREDIR:
-      case NBACKGND:
-      case NSUBSHELL:
-        calcsize(n->nredir.redirect);
-        calcsize(n->nredir.n);
-        break;
-      case NAND:
-      case NOR:
-      case NSEMI:
-      case NWHILE:
-      case NUNTIL:
-        calcsize(n->nbinary.ch2);
-        calcsize(n->nbinary.ch1);
-        break;
-      case NIF:
-        calcsize(n->nif.elsepart);
-        calcsize(n->nif.ifpart);
-        calcsize(n->nif.test);
-        break;
-      case NFOR:
-        funcstringsize += strlen(n->nfor.var) + 1;
-        calcsize(n->nfor.body);
-        calcsize(n->nfor.args);
-        break;
-      case NCASE:
-        calcsize(n->ncase.cases);
-        calcsize(n->ncase.expr);
-        break;
-      case NCLIST:
-        calcsize(n->nclist.body);
-        calcsize(n->nclist.pattern);
-        calcsize(n->nclist.next);
-        break;
-      case NDEFUN:
-      case NARG:
-        sizenodelist(n->narg.backquote);
-        funcstringsize += strlen(n->narg.text) + 1;
-        calcsize(n->narg.next);
-        break;
-      case NTO:
-      case NCLOBBER:
-      case NFROM:
-      case NFROMTO:
-      case NAPPEND:
-        calcsize(n->nfile.fname);
-        calcsize(n->nfile.next);
-        break;
-      case NTOFD:
-      case NFROMFD:
-        calcsize(n->ndup.vname);
-        calcsize(n->ndup.next);
-        break;
-      case NHERE:
-      case NXHERE:
-        calcsize(n->nhere.doc);
-        calcsize(n->nhere.next);
-        break;
-      case NNOT:
-        calcsize(n->nnot.com);
-        break;
-      };
-}
-
-
-static void
-sizenodelist(struct nodelist *lp)
-{
-    while (lp) {
-        funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
-        calcsize(lp->n);
-        lp = lp->next;
-    }
-}
-
-
-static union node *
-copynode(union node *n)
-{
-      union node *new;
-
-      if (n == NULL)
-        return NULL;
-      new = funcblock;
-      funcblock = (char *) funcblock + nodesize[n->type];
-      switch (n->type) {
-      case NCMD:
-        new->ncmd.redirect = copynode(n->ncmd.redirect);
-        new->ncmd.args = copynode(n->ncmd.args);
-        new->ncmd.assign = copynode(n->ncmd.assign);
-        break;
-      case NPIPE:
-        new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
-        new->npipe.backgnd = n->npipe.backgnd;
-        break;
-      case NREDIR:
-      case NBACKGND:
-      case NSUBSHELL:
-        new->nredir.redirect = copynode(n->nredir.redirect);
-        new->nredir.n = copynode(n->nredir.n);
-        break;
-      case NAND:
-      case NOR:
-      case NSEMI:
-      case NWHILE:
-      case NUNTIL:
-        new->nbinary.ch2 = copynode(n->nbinary.ch2);
-        new->nbinary.ch1 = copynode(n->nbinary.ch1);
-        break;
-      case NIF:
-        new->nif.elsepart = copynode(n->nif.elsepart);
-        new->nif.ifpart = copynode(n->nif.ifpart);
-        new->nif.test = copynode(n->nif.test);
-        break;
-      case NFOR:
-        new->nfor.var = nodesavestr(n->nfor.var);
-        new->nfor.body = copynode(n->nfor.body);
-        new->nfor.args = copynode(n->nfor.args);
-        break;
-      case NCASE:
-        new->ncase.cases = copynode(n->ncase.cases);
-        new->ncase.expr = copynode(n->ncase.expr);
-        break;
-      case NCLIST:
-        new->nclist.body = copynode(n->nclist.body);
-        new->nclist.pattern = copynode(n->nclist.pattern);
-        new->nclist.next = copynode(n->nclist.next);
-        break;
-      case NDEFUN:
-      case NARG:
-        new->narg.backquote = copynodelist(n->narg.backquote);
-        new->narg.text = nodesavestr(n->narg.text);
-        new->narg.next = copynode(n->narg.next);
-        break;
-      case NTO:
-      case NCLOBBER:
-      case NFROM:
-      case NFROMTO:
-      case NAPPEND:
-        new->nfile.fname = copynode(n->nfile.fname);
-        new->nfile.fd = n->nfile.fd;
-        new->nfile.next = copynode(n->nfile.next);
-        break;
-      case NTOFD:
-      case NFROMFD:
-        new->ndup.vname = copynode(n->ndup.vname);
-        new->ndup.dupfd = n->ndup.dupfd;
-        new->ndup.fd = n->ndup.fd;
-        new->ndup.next = copynode(n->ndup.next);
-        break;
-      case NHERE:
-      case NXHERE:
-        new->nhere.doc = copynode(n->nhere.doc);
-        new->nhere.fd = n->nhere.fd;
-        new->nhere.next = copynode(n->nhere.next);
-        break;
-      case NNOT:
-        new->nnot.com = copynode(n->nnot.com);
-        break;
-      };
-      new->type = n->type;
-    return new;
-}
-
-
-static struct nodelist *
-copynodelist(struct nodelist *lp)
-{
-    struct nodelist *start;
-    struct nodelist **lpp;
-
-    lpp = &start;
-    while (lp) {
-        *lpp = funcblock;
-        funcblock = (char *) funcblock +
-            SHELL_ALIGN(sizeof(struct nodelist));
-        (*lpp)->n = copynode(lp->n);
-        lp = lp->next;
-        lpp = &(*lpp)->next;
-    }
-    *lpp = NULL;
-    return start;
-}
-
-
-static char *
-nodesavestr(char   *s)
-{
-    char   *rtn = funcstring;
-
-    funcstring = stpcpy(funcstring, s) + 1;
-    return rtn;
-}
-
-
-/*
- * Free a parse tree.
- */
-
-static void
-freefunc(struct funcnode *f)
-{
-    if (f && --f->count < 0)
-        ckfree(f);
-}
-
-
-static void options(int);
-static void setoption(int, int);
-
-
-/*
- * Process the shell command line arguments.
- */
-
-void
-procargs(int argc, char **argv)
-{
-    int i;
-    const char *xminusc;
-    char **xargv;
-
-    xargv = argv;
-    arg0 = xargv[0];
-    if (argc > 0)
-        xargv++;
-    for (i = 0; i < NOPTS; i++)
-        optlist[i] = 2;
-    argptr = xargv;
-    options(1);
-    xargv = argptr;
-    xminusc = minusc;
-    if (*xargv == NULL) {
-        if (xminusc)
-            sh_error(bb_msg_requires_arg, "-c");
-        sflag = 1;
-    }
-    if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
-        iflag = 1;
-    if (mflag == 2)
-        mflag = iflag;
-    for (i = 0; i < NOPTS; i++)
-        if (optlist[i] == 2)
-            optlist[i] = 0;
-#if DEBUG == 2
-    debug = 1;
-#endif
-    /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
-    if (xminusc) {
-        minusc = *xargv++;
-        if (*xargv)
-            goto setarg0;
-    } else if (!sflag) {
-        setinputfile(*xargv, 0);
-setarg0:
-        arg0 = *xargv++;
-        commandname = arg0;
-    }
-
-    shellparam.p = xargv;
-#ifdef CONFIG_ASH_GETOPTS
+#endif /* ASH_MAIL */
+
+
+/* ============ ??? */
+
+/*
+ * Set the shell parameters.
+ */
+static void
+setparam(char **argv)
+{
+    char **newparam;
+    char **ap;
+    int nparam;
+
+    for (nparam = 0; argv[nparam]; nparam++);
+    ap = newparam = ckmalloc((nparam + 1) * sizeof(*ap));
+    while (*argv) {
+        *ap++ = ckstrdup(*argv++);
+    }
+    *ap = NULL;
+    freeparam(&shellparam);
+    shellparam.malloc = 1;
+    shellparam.nparam = nparam;
+    shellparam.p = newparam;
+#if ENABLE_ASH_GETOPTS
     shellparam.optind = 1;
     shellparam.optoff = -1;
 #endif
-    /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
-    while (*xargv) {
-        shellparam.nparam++;
-        xargv++;
-    }
-    optschanged();
-}
-
-
-void
-optschanged(void)
-{
-#ifdef DEBUG
-    opentrace();
-#endif
-    setinteractive(iflag);
-    setjobctl(mflag);
-    setvimode(viflag);
-}
-
-static inline void
+}
+
+/*
+ * Process shell options.  The global variable argptr contains a pointer
+ * to the argument list; we advance it past the options.
+ */
+static void
 minus_o(char *name, int val)
 {
     int i;
 
-    if (name == NULL) {
-        out1str("Current option settings\n");
-        for (i = 0; i < NOPTS; i++)
-            out1fmt("%-16s%s\n", optnames(i),
-                optlist[i] ? "on" : "off");
-    } else {
-        for (i = 0; i < NOPTS; i++)
-            if (equal(name, optnames(i))) {
+    if (name) {
+        for (i = 0; i < NOPTS; i++) {
+            if (strcmp(name, optnames(i)) == 0) {
                 optlist[i] = val;
                 return;
             }
-        sh_error("Illegal option -o %s", name);
-    }
-}
-
-/*
- * Process shell options.  The global variable argptr contains a pointer
- * to the argument list; we advance it past the options.
- */
-
+        }
+        ash_msg_and_raise_error("illegal option -o %s", name);
+    }
+    out1str("Current option settings\n");
+    for (i = 0; i < NOPTS; i++)
+        out1fmt("%-16s%s\n", optnames(i),
+                optlist[i] ? "on" : "off");
+}
+static void
+setoption(int flag, int val)
+{
+    int i;
+
+    for (i = 0; i < NOPTS; i++) {
+        if (optletters(i) == flag) {
+            optlist[i] = val;
+            return;
+        }
+    }
+    ash_msg_and_raise_error("illegal option -%c", flag);
+    /* NOTREACHED */
+}
 static void
 options(int cmdline)
@@ -8872 +9039 @@
         minusc = NULL;
     while ((p = *argptr) != NULL) {
+        c = *p++;
+        if (c != '-' && c != '+')
+            break;
         argptr++;
-        if ((c = *p++) == '-') {
+        val = 0; /* val = 0 if c == '+' */
+        if (c == '-') {
             val = 1;
-            if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
+            if (p[0] == '\0' || LONE_DASH(p)) {
                 if (!cmdline) {
                     /* "-" means turn off -x and -v */
@@ -8886 +9057 @@
                 break;    /* "-" or  "--" terminates options */
             }
-        } else if (c == '+') {
-            val = 0;
-        } else {
-            argptr--;
-            break;
-        }
+        }
+        /* first char was + or - */
         while ((c = *p++) != '\0') {
+            /* bash 3.2 indeed handles -c CMD and +c CMD the same */
             if (c == 'c' && cmdline) {
-                minusc = p;     /* command is after shell args*/
+                minusc = p;     /* command is after shell args */
             } else if (c == 'o') {
                 minus_o(*argptr, val);
                 if (*argptr)
                     argptr++;
-            } else if (cmdline && (c == '-')) {     // long options
+            } else if (cmdline && (c == 'l')) { /* -l or +l == --login */
+                isloginsh = 1;
+            /* bash does not accept +-login, we also won't */
+            } else if (cmdline && val && (c == '-')) { /* long options */
                 if (strcmp(p, "login") == 0)
                     isloginsh = 1;
@@ -8910 +9081 @@
 }
 
-
-static void
-setoption(int flag, int val)
-{
-    int i;
-
-    for (i = 0; i < NOPTS; i++)
-        if (optletters(i) == flag) {
-            optlist[i] = val;
-            return;
-        }
-    sh_error("Illegal option -%c", flag);
-    /* NOTREACHED */
-}
-
-
-
-/*
- * Set the shell parameters.
- */
-
-void
-setparam(char **argv)
-{
-    char **newparam;
-    char **ap;
-    int nparam;
-
-    for (nparam = 0 ; argv[nparam] ; nparam++);
-    ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
-    while (*argv) {
-        *ap++ = savestr(*argv++);
-    }
-    *ap = NULL;
-    freeparam(&shellparam);
-    shellparam.malloc = 1;
-    shellparam.nparam = nparam;
-    shellparam.p = newparam;
-#ifdef CONFIG_ASH_GETOPTS
-    shellparam.optind = 1;
-    shellparam.optoff = -1;
-#endif
-}
-
-
-/*
- * Free the list of positional parameters.
- */
-
-void
-freeparam(volatile struct shparam *param)
-{
-    char **ap;
-
-    if (param->malloc) {
-        for (ap = param->p ; *ap ; ap++)
-            ckfree(*ap);
-        ckfree(param->p);
-    }
-}
-
-
-
 /*
  * The shift builtin command.
  */
-
-int
+static int
 shiftcmd(int argc, char **argv)
 {
@@ -8987 +9094 @@
         n = number(argv[1]);
     if (n > shellparam.nparam)
-        sh_error("can't shift that many");
-    INTOFF;
+        ash_msg_and_raise_error("can't shift that many");
+    INT_OFF;
     shellparam.nparam -= n;
-    for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
+    for (ap1 = shellparam.p; --n >= 0; ap1++) {
         if (shellparam.malloc)
-            ckfree(*ap1);
+            free(*ap1);
     }
     ap2 = shellparam.p;
     while ((*ap2++ = *ap1++) != NULL);
-#ifdef CONFIG_ASH_GETOPTS
+#if ENABLE_ASH_GETOPTS
     shellparam.optind = 1;
     shellparam.optoff = -1;
 #endif
-    INTON;
+    INT_ON;
     return 0;
 }
 
-
+/*
+ * POSIX requires that 'set' (but not export or readonly) output the
+ * variables in lexicographic order - by the locale's collating order (sigh).
+ * Maybe we could keep them in an ordered balanced binary tree
+ * instead of hashed lists.
+ * For now just roll 'em through qsort for printing...
+ */
+static int
+showvars(const char *sep_prefix, int on, int off)
+{
+    const char *sep;
+    char **ep, **epend;
+
+    ep = listvars(on, off, &epend);
+    qsort(ep, epend - ep, sizeof(char *), vpcmp);
+
+    sep = *sep_prefix ? " " : sep_prefix;
+
+    for (; ep < epend; ep++) {
+        const char *p;
+        const char *q;
+
+        p = strchrnul(*ep, '=');
+        q = nullstr;
+        if (*p)
+            q = single_quote(++p);
+        out1fmt("%s%s%.*s%s\n", sep_prefix, sep, (int)(p - *ep), *ep, q);
+    }
+    return 0;
+}
 
 /*
  * The set command builtin.
  */
-
-int
+static int
 setcmd(int argc, char **argv)
 {
     if (argc == 1)
         return showvars(nullstr, 0, VUNSET);
-    INTOFF;
+    INT_OFF;
     options(0);
     optschanged();
@@ -9021 +9156 @@
         setparam(argptr);
     }
-    INTON;
+    INT_ON;
     return 0;
 }
 
-
-#ifdef CONFIG_ASH_GETOPTS
-static void
-getoptsreset(const char *value)
-{
-    shellparam.optind = number(value);
-    shellparam.optoff = -1;
-}
-#endif
-
-#ifdef CONFIG_LOCALE_SUPPORT
-static void change_lc_all(const char *value)
-{
-    if (value != 0 && *value != 0)
-        setlocale(LC_ALL, value);
-}
-
-static void change_lc_ctype(const char *value)
-{
-    if (value != 0 && *value != 0)
-        setlocale(LC_CTYPE, value);
-}
-
-#endif
-
-#ifdef CONFIG_ASH_RANDOM_SUPPORT
+#if ENABLE_ASH_RANDOM_SUPPORT
 /* Roughly copied from bash.. */
-static void change_random(const char *value)
-{
-    if(value == NULL) {
+static void
+change_random(const char *value)
+{
+    if (value == NULL) {
         /* "get", generate */
         char buf[16];
@@ -9070 +9181 @@
 #endif
 
-
-#ifdef CONFIG_ASH_GETOPTS
+#if ENABLE_ASH_GETOPTS
 static int
 getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *optoff)
@@ -9082 +9192 @@
     char **optnext;
 
-    if(*param_optind < 1)
+    if (*param_optind < 1)
         return 1;
     optnext = optfirst + *param_optind - 1;
@@ -9094 +9204 @@
         p = *optnext;
         if (p == NULL || *p != '-' || *++p == '\0') {
-atend:
+ atend:
             p = NULL;
             done = 1;
@@ -9100 +9210 @@
         }
         optnext++;
-        if (p[0] == '-' && p[1] == '\0')        /* check for "--" */
+        if (LONE_DASH(p))        /* check for "--" */
             goto atend;
     }
@@ -9113 +9223 @@
             } else {
                 fprintf(stderr, "Illegal option -%c\n", c);
-                (void) unsetvar("OPTARG");
+                unsetvar("OPTARG");
             }
             c = '?';
@@ -9131 +9241 @@
             } else {
                 fprintf(stderr, "No arg for -%c option\n", c);
-                (void) unsetvar("OPTARG");
+                unsetvar("OPTARG");
                 c = '?';
             }
@@ -9143 +9253 @@
     } else
         err |= setvarsafe("OPTARG", nullstr, 0);
-
-out:
+ out:
     *optoff = p ? p - *(optnext - 1) : -1;
     *param_optind = optnext - optfirst + 1;
@@ -9155 +9264 @@
         *param_optind = 1;
         *optoff = -1;
-        flushall();
-        exraise(EXERROR);
+        flush_stdout_stderr();
+        raise_exception(EXERROR);
     }
     return done;
@@ -9167 +9276 @@
  * then it's the first time getopts has been called.
  */
-
-int
+static int
 getoptscmd(int argc, char **argv)
 {
@@ -9174 +9282 @@
 
     if (argc < 3)
-        sh_error("Usage: getopts optstring var [arg]");
-    else if (argc == 3) {
+        ash_msg_and_raise_error("usage: getopts optstring var [arg]");
+    if (argc == 3) {
         optbase = shellparam.p;
         if (shellparam.optind > shellparam.nparam + 1) {
@@ -9181 +9289 @@
             shellparam.optoff = -1;
         }
-    }
-    else {
+    } else {
         optbase = &argv[3];
         if (shellparam.optind > argc - 2) {
@@ -9191 +9298 @@
 
     return getopts(argv[1], argv[2], optbase, &shellparam.optind,
-               &shellparam.optoff);
-}
-#endif /* CONFIG_ASH_GETOPTS */
-
-/*
- * XXX - should get rid of.  have all builtins use getopt(3).  the
- * library getopt must have the BSD extension static variable "optreset"
- * otherwise it can't be used within the shell safely.
- *
- * Standard option processing (a la getopt) for builtin routines.  The
- * only argument that is passed to nextopt is the option string; the
- * other arguments are unnecessary.  It return the character, or '\0' on
- * end of input.
- */
-
-static int
-nextopt(const char *optstring)
-{
-    char *p;
-    const char *q;
-    char c;
-
-    if ((p = optptr) == NULL || *p == '\0') {
-        p = *argptr;
-        if (p == NULL || *p != '-' || *++p == '\0')
-            return '\0';
-        argptr++;
-        if (p[0] == '-' && p[1] == '\0')        /* check for "--" */
-            return '\0';
-    }
-    c = *p++;
-    for (q = optstring ; *q != c ; ) {
-        if (*q == '\0')
-            sh_error("Illegal option -%c", c);
-        if (*++q == ':')
-            q++;
-    }
-    if (*++q == ':') {
-        if (*p == '\0' && (p = *argptr++) == NULL)
-            sh_error("No arg for -%c option", c);
-        optionarg = p;
-        p = NULL;
-    }
-    optptr = p;
-    return c;
-}
-
-
-/*      output.c     */
-
-void
-outstr(const char *p, FILE *file)
-{
-    INTOFF;
-    fputs(p, file);
-    INTON;
-}
-
-void
-flushall(void)
-{
-    INTOFF;
-    fflush(stdout);
-    fflush(stderr);
-    INTON;
-}
-
-void
-flusherr(void)
-{
-    INTOFF;
-    fflush(stderr);
-    INTON;
-}
-
-static void
-outcslow(int c, FILE *dest)
-{
-    INTOFF;
-    putc(c, dest);
-    fflush(dest);
-    INTON;
-}
-
-
-static int
-out1fmt(const char *fmt, ...)
-{
-    va_list ap;
-    int r;
-
-    INTOFF;
-    va_start(ap, fmt);
-    r = vprintf(fmt, ap);
-    va_end(ap);
-    INTON;
-    return r;
-}
-
-
-int
-fmtstr(char *outbuf, size_t length, const char *fmt, ...)
-{
-    va_list ap;
-    int ret;
-
-    va_start(ap, fmt);
-    INTOFF;
-    ret = vsnprintf(outbuf, length, fmt, ap);
-    va_end(ap);
-    INTON;
-    return ret;
-}
-
-
-
-/*      parser.c     */
-
-
-/*
- * Shell command parser.
- */
+            &shellparam.optoff);
+}
+#endif /* ASH_GETOPTS */
+
+
+/* ============ Shell parser */
+
+static int tokpushback;                /* last token pushed back */
+#define NEOF ((union node *)&tokpushback)
+static int parsebackquote;             /* nonzero if we are inside backquotes */
+static int lasttoken;                  /* last token read */
+static char *wordtext;                 /* text of last word returned by readtoken */
+static struct nodelist *backquotelist;
+static union node *redirnode;
+static struct heredoc *heredoc;
+static int quoteflag;                  /* set if (part of) last token was quoted */
+
+static void raise_error_syntax(const char *) ATTRIBUTE_NORETURN;
+static void
+raise_error_syntax(const char *msg)
+{
+    ash_msg_and_raise_error("syntax error: %s", msg);
+    /* NOTREACHED */
+}
+
+/*
+ * Called when an unexpected token is read during the parse.  The argument
+ * is the token that is expected, or -1 if more than one type of token can
+ * occur at this point.
+ */
+static void raise_error_unexpected_syntax(int) ATTRIBUTE_NORETURN;
+static void
+raise_error_unexpected_syntax(int token)
+{
+    char msg[64];
+    int l;
+
+    l = sprintf(msg, "%s unexpected", tokname(lasttoken));
+    if (token >= 0)
+        sprintf(msg + l, " (expecting %s)", tokname(token));
+    raise_error_syntax(msg);
+    /* NOTREACHED */
+}
 
 #define EOFMARKLEN 79
-
 
 struct heredoc {
@@ -9324 +9351 @@
 };
 
-
-
 static struct heredoc *heredoclist;    /* list of here documents to read */
 
-
-static union node *list(int);
+/* parsing is heavily cross-recursive, need these forward decls */
 static union node *andor(void);
 static union node *pipeline(void);
-static union node *command(void);
-static union node *simplecmd(void);
-static union node *makename(void);
-static void parsefname(void);
+static union node *parse_command(void);
 static void parseheredoc(void);
 static char peektoken(void);
 static int readtoken(void);
-static int xxreadtoken(void);
-static int readtoken1(int firstc, int syntax, char *eofmark, int striptabs);
-static int noexpand(char *);
-static void synexpect(int) ATTRIBUTE_NORETURN;
-static void synerror(const char *) ATTRIBUTE_NORETURN;
-static void setprompt(int);
-
-
-
-
-/*
- * Read and parse a command.  Returns NEOF on end of file.  (NULL is a
- * valid parse tree indicating a blank line.)
- */
-
-union node *
-parsecmd(int interact)
-{
-    int t;
-
-    tokpushback = 0;
-    doprompt = interact;
-    if (doprompt)
-        setprompt(doprompt);
-    needprompt = 0;
-    t = readtoken();
-    if (t == TEOF)
-        return NEOF;
-    if (t == TNL)
-        return NULL;
-    tokpushback++;
-    return list(1);
-}
-
 
 static union node *
@@ -9402 +9389 @@
         if (n1 == NULL) {
             n1 = n2;
-        }
-        else {
-            n3 = (union node *)stalloc(sizeof (struct nbinary));
+        } else {
+            n3 = stalloc(sizeof(struct nbinary));
             n3->type = NSEMI;
             n3->nbinary.ch1 = n1;
@@ -9435 +9421 @@
         default:
             if (nlflag == 1)
-                synexpect(-1);
+                raise_error_unexpected_syntax(-1);
             tokpushback++;
             return n1;
@@ -9442 +9428 @@
 }
 
-
-
 static union node *
 andor(void)
@@ -9452 +9436 @@
     n1 = pipeline();
     for (;;) {
-        if ((t = readtoken()) == TAND) {
+        t = readtoken();
+        if (t == TAND) {
             t = NAND;
         } else if (t == TOR) {
@@ -9462 +9447 @@
         checkkwd = CHKNL | CHKKWD | CHKALIAS;
         n2 = pipeline();
-        n3 = (union node *)stalloc(sizeof (struct nbinary));
+        n3 = stalloc(sizeof(struct nbinary));
         n3->type = t;
         n3->nbinary.ch1 = n1;
@@ -9469 +9454 @@
     }
 }
-
-
 
 static union node *
@@ -9486 +9469 @@
     } else
         tokpushback++;
-    n1 = command();
+    n1 = parse_command();
     if (readtoken() == TPIPE) {
-        pipenode = (union node *)stalloc(sizeof (struct npipe));
+        pipenode = stalloc(sizeof(struct npipe));
         pipenode->type = NPIPE;
         pipenode->npipe.backgnd = 0;
-        lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+        lp = stalloc(sizeof(struct nodelist));
         pipenode->npipe.cmdlist = lp;
         lp->n = n1;
         do {
             prev = lp;
-            lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+            lp = stalloc(sizeof(struct nodelist));
             checkkwd = CHKNL | CHKKWD | CHKALIAS;
-            lp->n = command();
+            lp->n = parse_command();
             prev->next = lp;
         } while (readtoken() == TPIPE);
@@ -9506 +9489 @@
     tokpushback++;
     if (negate) {
-        n2 = (union node *)stalloc(sizeof (struct nnot));
+        n2 = stalloc(sizeof(struct nnot));
         n2->type = NNOT;
         n2->nnot.com = n1;
         return n2;
-    } else
-        return n1;
-}
-
-
+    }
+    return n1;
+}
 
 static union node *
-command(void)
-{
-    union node *n1, *n2;
-    union node *ap, **app;
-    union node *cp, **cpp;
-    union node *redir, **rpp;
-    union node **rpp2;
-    int t;
-
-    redir = NULL;
-    rpp2 = &redir;
-
-    switch (readtoken()) {
-    default:
-        synexpect(-1);
-        /* NOTREACHED */
-    case TIF:
-        n1 = (union node *)stalloc(sizeof (struct nif));
-        n1->type = NIF;
-        n1->nif.test = list(0);
-        if (readtoken() != TTHEN)
-            synexpect(TTHEN);
-        n1->nif.ifpart = list(0);
-        n2 = n1;
-        while (readtoken() == TELIF) {
-            n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
-            n2 = n2->nif.elsepart;
-            n2->type = NIF;
-            n2->nif.test = list(0);
-            if (readtoken() != TTHEN)
-                synexpect(TTHEN);
-            n2->nif.ifpart = list(0);
-        }
-        if (lasttoken == TELSE)
-            n2->nif.elsepart = list(0);
+makename(void)
+{
+    union node *n;
+
+    n = stalloc(sizeof(struct narg));
+    n->type = NARG;
+    n->narg.next = NULL;
+    n->narg.text = wordtext;
+    n->narg.backquote = backquotelist;
+    return n;
+}
+
+static void
+fixredir(union node *n, const char *text, int err)
+{
+    TRACE(("Fix redir %s %d\n", text, err));
+    if (!err)
+        n->ndup.vname = NULL;
+
+    if (isdigit(text[0]) && text[1] == '\0')
+        n->ndup.dupfd = text[0] - '0';
+    else if (LONE_DASH(text))
+        n->ndup.dupfd = -1;
+    else {
+        if (err)
+            raise_error_syntax("Bad fd number");
+        n->ndup.vname = makename();
+    }
+}
+
+/*
+ * Returns true if the text contains nothing to expand (no dollar signs
+ * or backquotes).
+ */
+static int
+noexpand(char *text)
+{
+    char *p;
+    char c;
+
+    p = text;
+    while ((c = *p++) != '\0') {
+        if (c == CTLQUOTEMARK)
+            continue;
+        if (c == CTLESC)
+            p++;
+        else if (SIT(c, BASESYNTAX) == CCTL)
+            return 0;
+    }
+    return 1;
+}
+
+static void
+parsefname(void)
+{
+    union node *n = redirnode;
+
+    if (readtoken() != TWORD)
+        raise_error_unexpected_syntax(-1);
+    if (n->type == NHERE) {
+        struct heredoc *here = heredoc;
+        struct heredoc *p;
+        int i;
+
+        if (quoteflag == 0)
+            n->type = NXHERE;
+        TRACE(("Here document %d\n", n->type));
+        if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
+            raise_error_syntax("Illegal eof marker for << redirection");
+        rmescapes(wordtext);
+        here->eofmark = wordtext;
+        here->next = NULL;
+        if (heredoclist == NULL)
+            heredoclist = here;
         else {
-            n2->nif.elsepart = NULL;
-            tokpushback++;
-        }
-        t = TFI;
-        break;
-    case TWHILE:
-    case TUNTIL: {
-        int got;
-        n1 = (union node *)stalloc(sizeof (struct nbinary));
-        n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
-        n1->nbinary.ch1 = list(0);
-        if ((got=readtoken()) != TDO) {
-TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
-            synexpect(TDO);
-        }
-        n1->nbinary.ch2 = list(0);
-        t = TDONE;
-        break;
-    }
-    case TFOR:
-        if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
-            synerror("Bad for loop variable");
-        n1 = (union node *)stalloc(sizeof (struct nfor));
-        n1->type = NFOR;
-        n1->nfor.var = wordtext;
-        checkkwd = CHKKWD | CHKALIAS;
-        if (readtoken() == TIN) {
-            app = &ap;
-            while (readtoken() == TWORD) {
-                n2 = (union node *)stalloc(sizeof (struct narg));
-                n2->type = NARG;
-                n2->narg.text = wordtext;
-                n2->narg.backquote = backquotelist;
-                *app = n2;
-                app = &n2->narg.next;
-            }
-            *app = NULL;
-            n1->nfor.args = ap;
-            if (lasttoken != TNL && lasttoken != TSEMI)
-                synexpect(-1);
-        } else {
-            n2 = (union node *)stalloc(sizeof (struct narg));
-            n2->type = NARG;
-            n2->narg.text = (char *)dolatstr;
-            n2->narg.backquote = NULL;
-            n2->narg.next = NULL;
-            n1->nfor.args = n2;
-            /*
-             * Newline or semicolon here is optional (but note
-             * that the original Bourne shell only allowed NL).
-             */
-            if (lasttoken != TNL && lasttoken != TSEMI)
-                tokpushback++;
-        }
-        checkkwd = CHKNL | CHKKWD | CHKALIAS;
-        if (readtoken() != TDO)
-            synexpect(TDO);
-        n1->nfor.body = list(0);
-        t = TDONE;
-        break;
-    case TCASE:
-        n1 = (union node *)stalloc(sizeof (struct ncase));
-        n1->type = NCASE;
-        if (readtoken() != TWORD)
-            synexpect(TWORD);
-        n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
-        n2->type = NARG;
-        n2->narg.text = wordtext;
-        n2->narg.backquote = backquotelist;
-        n2->narg.next = NULL;
-        do {
-            checkkwd = CHKKWD | CHKALIAS;
-        } while (readtoken() == TNL);
-        if (lasttoken != TIN)
-            synexpect(TIN);
-        cpp = &n1->ncase.cases;
-next_case:
-        checkkwd = CHKNL | CHKKWD;
-        t = readtoken();
-        while(t != TESAC) {
-            if (lasttoken == TLP)
-                readtoken();
-            *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
-            cp->type = NCLIST;
-            app = &cp->nclist.pattern;
-            for (;;) {
-                *app = ap = (union node *)stalloc(sizeof (struct narg));
-                ap->type = NARG;
-                ap->narg.text = wordtext;
-                ap->narg.backquote = backquotelist;
-                if (readtoken() != TPIPE)
-                    break;
-                app = &ap->narg.next;
-                readtoken();
-            }
-            ap->narg.next = NULL;
-            if (lasttoken != TRP)
-                synexpect(TRP);
-            cp->nclist.body = list(2);
-
-            cpp = &cp->nclist.next;
-
-            checkkwd = CHKNL | CHKKWD;
-            if ((t = readtoken()) != TESAC) {
-                if (t != TENDCASE)
-                    synexpect(TENDCASE);
-                else
-                    goto next_case;
-            }
-        }
-        *cpp = NULL;
-        goto redir;
-    case TLP:
-        n1 = (union node *)stalloc(sizeof (struct nredir));
-        n1->type = NSUBSHELL;
-        n1->nredir.n = list(0);
-        n1->nredir.redirect = NULL;
-        t = TRP;
-        break;
-    case TBEGIN:
-        n1 = list(0);
-        t = TEND;
-        break;
-    case TWORD:
-    case TREDIR:
-        tokpushback++;
-        return simplecmd();
-    }
-
-    if (readtoken() != t)
-        synexpect(t);
-
-redir:
-    /* Now check for redirection which may follow command */
-    checkkwd = CHKKWD | CHKALIAS;
-    rpp = rpp2;
-    while (readtoken() == TREDIR) {
-        *rpp = n2 = redirnode;
-        rpp = &n2->nfile.next;
-        parsefname();
-    }
-    tokpushback++;
-    *rpp = NULL;
-    if (redir) {
-        if (n1->type != NSUBSHELL) {
-            n2 = (union node *)stalloc(sizeof (struct nredir));
-            n2->type = NREDIR;
-            n2->nredir.n = n1;
-            n1 = n2;
-        }
-        n1->nredir.redirect = redir;
-    }
-
-    return n1;
-}
-
+            for (p = heredoclist; p->next; p = p->next);
+            p->next = here;
+        }
+    } else if (n->type == NTOFD || n->type == NFROMFD) {
+        fixredir(n, wordtext, 0);
+    } else {
+        n->nfile.fname = makename();
+    }
+}
 
 static union node *
-simplecmd(void) {
+simplecmd(void)
+{
     union node *args, **app;
     union node *n = NULL;
@@ -9730 +9604 @@
         switch (readtoken()) {
         case TWORD:
-            n = (union node *)stalloc(sizeof (struct narg));
+            n = stalloc(sizeof(struct narg));
             n->type = NARG;
             n->narg.text = wordtext;
@@ -9749 +9623 @@
             break;
         case TLP:
-            if (
-                args && app == &args->narg.next &&
-                !vars && !redir
+            if (args && app == &args->narg.next
+             && !vars && !redir
             ) {
                 struct builtincmd *bcmd;
@@ -9758 +9631 @@
                 /* We have a function */
                 if (readtoken() != TRP)
-                    synexpect(TRP);
+                    raise_error_unexpected_syntax(TRP);
                 name = n->narg.text;
-                if (
-                    !goodname(name) || (
-                        (bcmd = find_builtin(name)) &&
-                        IS_BUILTIN_SPECIAL(bcmd)
-                    )
-                )
-                    synerror("Bad function name");
+                if (!goodname(name)
+                 || ((bcmd = find_builtin(name)) && IS_BUILTIN_SPECIAL(bcmd))
+                ) {
+                    raise_error_syntax("Bad function name");
+                }
                 n->type = NDEFUN;
                 checkkwd = CHKNL | CHKKWD | CHKALIAS;
-                n->narg.next = command();
+                n->narg.next = parse_command();
                 return n;
             }
@@ -9778 +9649 @@
         }
     }
-out:
+ out:
     *app = NULL;
     *vpp = NULL;
     *rpp = NULL;
-    n = (union node *)stalloc(sizeof (struct ncmd));
+    n = stalloc(sizeof(struct ncmd));
     n->type = NCMD;
     n->ncmd.args = args;
@@ -9791 +9662 @@
 
 static union node *
-makename(void)
-{
-    union node *n;
-
-    n = (union node *)stalloc(sizeof (struct narg));
-    n->type = NARG;
-    n->narg.next = NULL;
-    n->narg.text = wordtext;
-    n->narg.backquote = backquotelist;
-    return n;
-}
-
-void fixredir(union node *n, const char *text, int err)
-{
-    TRACE(("Fix redir %s %d\n", text, err));
-    if (!err)
-        n->ndup.vname = NULL;
-
-    if (is_digit(text[0]) && text[1] == '\0')
-        n->ndup.dupfd = digit_val(text[0]);
-    else if (text[0] == '-' && text[1] == '\0')
-        n->ndup.dupfd = -1;
-    else {
-
-        if (err)
-            synerror("Bad fd number");
-        else
-            n->ndup.vname = makename();
-    }
-}
-
-
-static void
-parsefname(void)
-{
-    union node *n = redirnode;
-
-    if (readtoken() != TWORD)
-        synexpect(-1);
-    if (n->type == NHERE) {
-        struct heredoc *here = heredoc;
-        struct heredoc *p;
-        int i;
-
-        if (quoteflag == 0)
-            n->type = NXHERE;
-        TRACE(("Here document %d\n", n->type));
-        if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
-            synerror("Illegal eof marker for << redirection");
-        rmescapes(wordtext);
-        here->eofmark = wordtext;
-        here->next = NULL;
-        if (heredoclist == NULL)
-            heredoclist = here;
+parse_command(void)
+{
+    union node *n1, *n2;
+    union node *ap, **app;
+    union node *cp, **cpp;
+    union node *redir, **rpp;
+    union node **rpp2;
+    int t;
+
+    redir = NULL;
+    rpp2 = &redir;
+
+    switch (readtoken()) {
+    default:
+        raise_error_unexpected_syntax(-1);
+        /* NOTREACHED */
+    case TIF:
+        n1 = stalloc(sizeof(struct nif));
+        n1->type = NIF;
+        n1->nif.test = list(0);
+        if (readtoken() != TTHEN)
+            raise_error_unexpected_syntax(TTHEN);
+        n1->nif.ifpart = list(0);
+        n2 = n1;
+        while (readtoken() == TELIF) {
+            n2->nif.elsepart = stalloc(sizeof(struct nif));
+            n2 = n2->nif.elsepart;
+            n2->type = NIF;
+            n2->nif.test = list(0);
+            if (readtoken() != TTHEN)
+                raise_error_unexpected_syntax(TTHEN);
+            n2->nif.ifpart = list(0);
+        }
+        if (lasttoken == TELSE)
+            n2->nif.elsepart = list(0);
         else {
-            for (p = heredoclist ; p->next ; p = p->next);
-            p->next = here;
-        }
-    } else if (n->type == NTOFD || n->type == NFROMFD) {
-        fixredir(n, wordtext, 0);
-    } else {
-        n->nfile.fname = makename();
-    }
-}
-
-
-/*
- * Input any here documents.
- */
-
-static void
-parseheredoc(void)
-{
-    struct heredoc *here;
-    union node *n;
-
-    here = heredoclist;
-    heredoclist = 0;
-
-    while (here) {
-        if (needprompt) {
-            setprompt(2);
-        }
-        readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
-                here->eofmark, here->striptabs);
-        n = (union node *)stalloc(sizeof (struct narg));
-        n->narg.type = NARG;
-        n->narg.next = NULL;
-        n->narg.text = wordtext;
-        n->narg.backquote = backquotelist;
-        here->here->nhere.doc = n;
-        here = here->next;
-    }
-}
-
-static char peektoken(void)
-{
-    int t;
-
-    t = readtoken();
+            n2->nif.elsepart = NULL;
+            tokpushback++;
+        }
+        t = TFI;
+        break;
+    case TWHILE:
+    case TUNTIL: {
+        int got;
+        n1 = stalloc(sizeof(struct nbinary));
+        n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
+        n1->nbinary.ch1 = list(0);
+        got = readtoken();
+        if (got != TDO) {
+            TRACE(("expecting DO got %s %s\n", tokname(got),
+                    got == TWORD ? wordtext : ""));
+            raise_error_unexpected_syntax(TDO);
+        }
+        n1->nbinary.ch2 = list(0);
+        t = TDONE;
+        break;
+    }
+    case TFOR:
+        if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
+            raise_error_syntax("Bad for loop variable");
+        n1 = stalloc(sizeof(struct nfor));
+        n1->type = NFOR;
+        n1->nfor.var = wordtext;
+        checkkwd = CHKKWD | CHKALIAS;
+        if (readtoken() == TIN) {
+            app = &ap;
+            while (readtoken() == TWORD) {
+                n2 = stalloc(sizeof(struct narg));
+                n2->type = NARG;
+                n2->narg.text = wordtext;
+                n2->narg.backquote = backquotelist;
+                *app = n2;
+                app = &n2->narg.next;
+            }
+            *app = NULL;
+            n1->nfor.args = ap;
+            if (lasttoken != TNL && lasttoken != TSEMI)
+                raise_error_unexpected_syntax(-1);
+        } else {
+            n2 = stalloc(sizeof(struct narg));
+            n2->type = NARG;
+            n2->narg.text = (char *)dolatstr;
+            n2->narg.backquote = NULL;
+            n2->narg.next = NULL;
+            n1->nfor.args = n2;
+            /*
+             * Newline or semicolon here is optional (but note
+             * that the original Bourne shell only allowed NL).
+             */
+            if (lasttoken != TNL && lasttoken != TSEMI)
+                tokpushback++;
+        }
+        checkkwd = CHKNL | CHKKWD | CHKALIAS;
+        if (readtoken() != TDO)
+            raise_error_unexpected_syntax(TDO);
+        n1->nfor.body = list(0);
+        t = TDONE;
+        break;
+    case TCASE:
+        n1 = stalloc(sizeof(struct ncase));
+        n1->type = NCASE;
+        if (readtoken() != TWORD)
+            raise_error_unexpected_syntax(TWORD);
+        n1->ncase.expr = n2 = stalloc(sizeof(struct narg));
+        n2->type = NARG;
+        n2->narg.text = wordtext;
+        n2->narg.backquote = backquotelist;
+        n2->narg.next = NULL;
+        do {
+            checkkwd = CHKKWD | CHKALIAS;
+        } while (readtoken() == TNL);
+        if (lasttoken != TIN)
+            raise_error_unexpected_syntax(TIN);
+        cpp = &n1->ncase.cases;
+ next_case:
+        checkkwd = CHKNL | CHKKWD;
+        t = readtoken();
+        while (t != TESAC) {
+            if (lasttoken == TLP)
+                readtoken();
+            *cpp = cp = stalloc(sizeof(struct nclist));
+            cp->type = NCLIST;
+            app = &cp->nclist.pattern;
+            for (;;) {
+                *app = ap = stalloc(sizeof(struct narg));
+                ap->type = NARG;
+                ap->narg.text = wordtext;
+                ap->narg.backquote = backquotelist;
+                if (readtoken() != TPIPE)
+                    break;
+                app = &ap->narg.next;
+                readtoken();
+            }
+            ap->narg.next = NULL;
+            if (lasttoken != TRP)
+                raise_error_unexpected_syntax(TRP);
+            cp->nclist.body = list(2);
+
+            cpp = &cp->nclist.next;
+
+            checkkwd = CHKNL | CHKKWD;
+            t = readtoken();
+            if (t != TESAC) {
+                if (t != TENDCASE)
+                    raise_error_unexpected_syntax(TENDCASE);
+                goto next_case;
+            }
+        }
+        *cpp = NULL;
+        goto redir;
+    case TLP:
+        n1 = stalloc(sizeof(struct nredir));
+        n1->type = NSUBSHELL;
+        n1->nredir.n = list(0);
+        n1->nredir.redirect = NULL;
+        t = TRP;
+        break;
+    case TBEGIN:
+        n1 = list(0);
+        t = TEND;
+        break;
+    case TWORD:
+    case TREDIR:
+        tokpushback++;
+        return simplecmd();
+    }
+
+    if (readtoken() != t)
+        raise_error_unexpected_syntax(t);
+
+ redir:
+    /* Now check for redirection which may follow command */
+    checkkwd = CHKKWD | CHKALIAS;
+    rpp = rpp2;
+    while (readtoken() == TREDIR) {
+        *rpp = n2 = redirnode;
+        rpp = &n2->nfile.next;
+        parsefname();
+    }
     tokpushback++;
-    return tokname_array[t][0];
-}
-
-static int
-readtoken(void)
-{
-    int t;
-#ifdef DEBUG
-    int alreadyseen = tokpushback;
-#endif
-
-#ifdef CONFIG_ASH_ALIAS
-top:
-#endif
-
-    t = xxreadtoken();
-
-    /*
-     * eat newlines
-     */
-    if (checkkwd & CHKNL) {
-        while (t == TNL) {
-            parseheredoc();
-            t = xxreadtoken();
-        }
-    }
-
-    if (t != TWORD || quoteflag) {
-        goto out;
-    }
-
-    /*
-     * check for keywords
-     */
-    if (checkkwd & CHKKWD) {
-        const char *const *pp;
-
-        if ((pp = findkwd(wordtext))) {
-            lasttoken = t = pp - tokname_array;
-            TRACE(("keyword %s recognized\n", tokname(t)));
-            goto out;
-        }
-    }
-
-    if (checkkwd & CHKALIAS) {
-#ifdef CONFIG_ASH_ALIAS
-        struct alias *ap;
-        if ((ap = lookupalias(wordtext, 1)) != NULL) {
-            if (*ap->val) {
-                pushstring(ap->val, ap);
-            }
-            goto top;
-        }
-#endif
-    }
-out:
-    checkkwd = 0;
-#ifdef DEBUG
-    if (!alreadyseen)
-        TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
-    else
-        TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
-#endif
-    return (t);
-}
-
-
-/*
- * Read the next input token.
- * If the token is a word, we set backquotelist to the list of cmds in
- *      backquotes.  We set quoteflag to true if any part of the word was
- *      quoted.
- * If the token is TREDIR, then we set redirnode to a structure containing
- *      the redirection.
- * In all cases, the variable startlinno is set to the number of the line
- *      on which the token starts.
- *
- * [Change comment:  here documents and internal procedures]
- * [Readtoken shouldn't have any arguments.  Perhaps we should make the
- *  word parsing code into a separate routine.  In this case, readtoken
- *  doesn't need to have any internal procedures, but parseword does.
- *  We could also make parseoperator in essence the main routine, and
- *  have parseword (readtoken1?) handle both words and redirection.]
- */
-
-#define NEW_xxreadtoken
-#ifdef NEW_xxreadtoken
-
-/* singles must be first! */
-static const char xxreadtoken_chars[7] = { '\n', '(', ')', '&', '|', ';', 0 };
-
-static const char xxreadtoken_tokens[] = {
-    TNL, TLP, TRP,          /* only single occurrence allowed */
-    TBACKGND, TPIPE, TSEMI, /* if single occurrence */
-    TEOF,                   /* corresponds to trailing nul */
-    TAND, TOR, TENDCASE,    /* if double occurrence */
-};
-
-#define xxreadtoken_doubles \
-    (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
-#define xxreadtoken_singles \
-    (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
-
-static int xxreadtoken(void)
-{
-    int c;
-
-    if (tokpushback) {
-        tokpushback = 0;
-        return lasttoken;
-    }
-    if (needprompt) {
-        setprompt(2);
-    }
-    startlinno = plinno;
-    for (;;) {                      /* until token or start of word found */
-        c = pgetc_macro();
-
-        if ((c != ' ') && (c != '\t')
-#ifdef CONFIG_ASH_ALIAS
-            && (c != PEOA)
-#endif
-            ) {
-            if (c == '#') {
-                while ((c = pgetc()) != '\n' && c != PEOF);
-                pungetc();
-            } else if (c == '\\') {
-                if (pgetc() != '\n') {
-                    pungetc();
-                    goto READTOKEN1;
-                }
-                startlinno = ++plinno;
-                if (doprompt)
-                    setprompt(2);
-            } else {
-                const char *p
-                    = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
-
-                if (c != PEOF) {
-                    if (c == '\n') {
-                        plinno++;
-                        needprompt = doprompt;
-                    }
-
-                    p = strchr(xxreadtoken_chars, c);
-                    if (p == NULL) {
-                      READTOKEN1:
-                        return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
-                    }
-
-                    if (p - xxreadtoken_chars >= xxreadtoken_singles) {
-                        if (pgetc() == *p) {    /* double occurrence? */
-                            p += xxreadtoken_doubles + 1;
-                        } else {
-                            pungetc();
-                        }
-                    }
-                }
-
-                return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
-            }
-        }
-    }
-}
-
-
-#else
-#define RETURN(token)   return lasttoken = token
-
-static int
-xxreadtoken(void)
-{
-    int c;
-
-    if (tokpushback) {
-        tokpushback = 0;
-        return lasttoken;
-    }
-    if (needprompt) {
-        setprompt(2);
-    }
-    startlinno = plinno;
-    for (;;) {      /* until token or start of word found */
-        c = pgetc_macro();
-        switch (c) {
-        case ' ': case '\t':
-#ifdef CONFIG_ASH_ALIAS
-        case PEOA:
-#endif
-            continue;
-        case '#':
-            while ((c = pgetc()) != '\n' && c != PEOF);
-            pungetc();
-            continue;
-        case '\\':
-            if (pgetc() == '\n') {
-                startlinno = ++plinno;
-                if (doprompt)
-                    setprompt(2);
-                continue;
-            }
-            pungetc();
-            goto breakloop;
-        case '\n':
-            plinno++;
-            needprompt = doprompt;
-            RETURN(TNL);
-        case PEOF:
-            RETURN(TEOF);
-        case '&':
-            if (pgetc() == '&')
-                RETURN(TAND);
-            pungetc();
-            RETURN(TBACKGND);
-        case '|':
-            if (pgetc() == '|')
-                RETURN(TOR);
-            pungetc();
-            RETURN(TPIPE);
-        case ';':
-            if (pgetc() == ';')
-                RETURN(TENDCASE);
-            pungetc();
-            RETURN(TSEMI);
-        case '(':
-            RETURN(TLP);
-        case ')':
-            RETURN(TRP);
-        default:
-            goto breakloop;
-        }
-    }
-breakloop:
-    return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
-#undef RETURN
-}
-#endif /* NEW_xxreadtoken */
-
+    *rpp = NULL;
+    if (redir) {
+        if (n1->type != NSUBSHELL) {
+            n2 = stalloc(sizeof(struct nredir));
+            n2->type = NREDIR;
+            n2->nredir.n = n1;
+            n1 = n2;
+        }
+        n1->nredir.redirect = redir;
+    }
+    return n1;
+}
 
 /*
@@ -10142 +9866 @@
  * will run code that appears at the end of readtoken1.
  */
+
+static int parsebackquote;             /* nonzero if we are inside backquotes */
 
 #define CHECKEND()      {goto checkend; checkend_return:;}
@@ -10196 +9922 @@
         for (;;) {      /* until end of line or end of word */
             CHECKSTRSPACE(4, out);  /* permit 4 calls to USTPUTC */
-            switch(SIT(c, syntax)) {
+            switch (SIT(c, syntax)) {
             case CNL:       /* '\n' */
                 if (syntax == BASESYNTAX)
@@ -10241 +9967 @@
             case CSQUOTE:
                 syntax = SQSYNTAX;
-quotemark:
+ quotemark:
                 if (eofmark == NULL) {
                     USTPUTC(CTLQUOTEMARK, out);
@@ -10251 +9977 @@
                 goto quotemark;
             case CENDQUOTE:
-                if (eofmark != NULL && arinest == 0 &&
-                    varnest == 0) {
+                if (eofmark != NULL && arinest == 0
+                 && varnest == 0
+                ) {
                     USTPUTC(c, out);
                 } else {
@@ -10277 +10004 @@
                 }
                 break;
-#ifdef CONFIG_ASH_MATH_SUPPORT
+#if ENABLE_ASH_MATH_SUPPORT
             case CLP:       /* '(' in arithmetic */
                 parenlevel++;
@@ -10318 +10045 @@
                 if (varnest == 0)
                     goto endword;   /* exit outer loop */
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
                 if (c != PEOA)
 #endif
@@ -10327 +10054 @@
         }
     }
-endword:
-#ifdef CONFIG_ASH_MATH_SUPPORT
+ endword:
+#if ENABLE_ASH_MATH_SUPPORT
     if (syntax == ARISYNTAX)
-        synerror("Missing '))'");
-#endif
-    if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
-        synerror("Unterminated quoted string");
+        raise_error_syntax("Missing '))'");
+#endif
+    if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
+        raise_error_syntax("Unterminated quoted string");
     if (varnest != 0) {
         startlinno = plinno;
         /* { */
-        synerror("Missing '}'");
+        raise_error_syntax("Missing '}'");
     }
     USTPUTC('\0', out);
@@ -10346 +10073 @@
          && quotef == 0
          && len <= 2
-         && (*out == '\0' || is_digit(*out))) {
+         && (*out == '\0' || isdigit(*out))) {
             PARSEREDIR();
             return lasttoken = TREDIR;
@@ -10357 +10084 @@
     grabstackblock(len);
     wordtext = out;
-    return lasttoken = TWORD;
+    lasttoken = TWORD;
+    return lasttoken;
 /* end of readtoken routine */
-
-
 
 /*
@@ -10367 +10093 @@
  * we are at the end of the here document, this routine sets the c to PEOF.
  */
-
 checkend: {
     if (eofmark) {
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
         if (c == PEOA) {
             c = pgetc2();
@@ -10381 +10106 @@
         }
         if (c == *eofmark) {
-            if (pfgets(line, sizeof line) != NULL) {
+            if (pfgets(line, sizeof(line)) != NULL) {
                 char *p, *q;
 
                 p = line;
-                for (q = eofmark + 1 ; *q && *p == *q ; p++, q++);
+                for (q = eofmark + 1; *q && *p == *q; p++, q++);
                 if (*p == '\n' && *q == '\0') {
                     c = PEOF;
@@ -10399 +10124 @@
 }
 
-
 /*
  * Parse a redirection operator.  The variable "out" points to a string
@@ -10405 +10129 @@
  * first character of the redirection operator.
  */
-
 parseredir: {
     char fd = *out;
     union node *np;
 
-    np = (union node *)stalloc(sizeof (struct nfile));
+    np = stalloc(sizeof(struct nfile));
     if (c == '>') {
         np->nfile.fd = 1;
@@ -10426 +10149 @@
     } else {        /* c == '<' */
         np->nfile.fd = 0;
-        switch (c = pgetc()) {
+        c = pgetc();
+        switch (c) {
         case '<':
-            if (sizeof (struct nfile) != sizeof (struct nhere)) {
-                np = (union node *)stalloc(sizeof (struct nhere));
+            if (sizeof(struct nfile) != sizeof(struct nhere)) {
+                np = stalloc(sizeof(struct nhere));
                 np->nfile.fd = 0;
             }
             np->type = NHERE;
-            heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
+            heredoc = stalloc(sizeof(struct heredoc));
             heredoc->here = np;
-            if ((c = pgetc()) == '-') {
+            c = pgetc();
+            if (c == '-') {
                 heredoc->striptabs = 1;
             } else {
@@ -10458 +10183 @@
     }
     if (fd != '\0')
-        np->nfile.fd = digit_val(fd);
+        np->nfile.fd = fd - '0';
     redirnode = np;
     goto parseredir_return;
 }
 
-
 /*
  * Parse a substitution.  At this point, we have read the dollar sign
@@ -10469 +10193 @@
  */
 
+/* is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
+ * (assuming ascii char codes, as the original implementation did) */
+#define is_special(c) \
+    ((((unsigned int)c) - 33 < 32) \
+            && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
 parsesub: {
     int subtype;
@@ -10474 +10203 @@
     int flags;
     char *p;
-    static const char types[] = "}-+?=";
+    static const char types[] ALIGN1 = "}-+?=";
 
     c = pgetc();
@@ -10485 +10214 @@
     } else if (c == '(') {  /* $(command) or $((arith)) */
         if (pgetc() == '(') {
-#ifdef CONFIG_ASH_MATH_SUPPORT
+#if ENABLE_ASH_MATH_SUPPORT
             PARSEARITH();
 #else
-            synerror("We unsupport $((arith))");
+            raise_error_syntax("We unsupport $((arith))");
 #endif
         } else {
@@ -10502 +10231 @@
             c = pgetc();
             if (c == '#') {
-                if ((c = pgetc()) == '}')
+                c = pgetc();
+                if (c == '}')
                     c = '#';
                 else
                     subtype = VSLENGTH;
-            }
-            else
+            } else
                 subtype = 0;
         }
@@ -10515 +10244 @@
                 c = pgetc();
             } while (c > PEOA_OR_PEOF && is_in_name(c));
-        } else if (is_digit(c)) {
+        } else if (isdigit(c)) {
             do {
                 STPUTC(c, out);
                 c = pgetc();
-            } while (is_digit(c));
-        }
-        else if (is_special(c)) {
+            } while (isdigit(c));
+        } else if (is_special(c)) {
             USTPUTC(c, out);
             c = pgetc();
-        }
-        else
-badsub:                 synerror("Bad substitution");
+        } else
+ badsub:        raise_error_syntax("Bad substitution");
 
         STPUTC('=', out);
@@ -10547 +10274 @@
                     int cc = c;
                     subtype = c == '#' ? VSTRIMLEFT :
-                                 VSTRIMRIGHT;
+                                         VSTRIMRIGHT;
                     c = pgetc();
                     if (c == cc)
@@ -10572 +10299 @@
 }
 
-
 /*
  * Called to parse command substitutions.  Newstyle is set if the command
@@ -10579 +10305 @@
  * characters on the top of the stack which must be preserved.
  */
-
 parsebackq: {
     struct nodelist **nlpp;
@@ -10596 +10321 @@
     if (setjmp(jmploc.loc)) {
         if (str)
-            ckfree(str);
+            free(str);
         parsebackquote = 0;
-        handler = savehandler;
-        longjmp(handler->loc, 1);
-    }
-    INTOFF;
+        exception_handler = savehandler;
+        longjmp(exception_handler->loc, 1);
+    }
+    INT_OFF;
     str = NULL;
     savelen = out - (char *)stackblock();
@@ -10608 +10333 @@
         memcpy(str, stackblock(), savelen);
     }
-    savehandler = handler;
-    handler = &jmploc;
-    INTON;
+    savehandler = exception_handler;
+    exception_handler = &jmploc;
+    INT_ON;
     if (oldstyle) {
         /* We must read until the closing backquote, giving special
@@ -10626 +10351 @@
                 setprompt(2);
             }
-            switch (pc = pgetc()) {
+            pc = pgetc();
+            switch (pc) {
             case '`':
                 goto done;
 
             case '\\':
-                if ((pc = pgetc()) == '\n') {
+                pc = pgetc();
+                if (pc == '\n') {
                     plinno++;
                     if (doprompt)
@@ -10644 +10371 @@
                 }
                 if (pc != '\\' && pc != '`' && pc != '$'
-                    && (!dblquote || pc != '"'))
+                 && (!dblquote || pc != '"'))
                     STPUTC('\\', pout);
                 if (pc > PEOA_OR_PEOF) {
@@ -10652 +10379 @@
 
             case PEOF:
-#ifdef CONFIG_ASH_ALIAS
+#if ENABLE_ASH_ALIAS
             case PEOA:
 #endif
                 startlinno = plinno;
-                synerror("EOF in backquote substitution");
+                raise_error_syntax("EOF in backquote substitution");
 
             case '\n':
@@ -10668 +10395 @@
             STPUTC(pc, pout);
         }
-done:
+ done:
         STPUTC('\0', pout);
         psavelen = pout - (char *)stackblock();
@@ -10679 +10406 @@
     while (*nlpp)
         nlpp = &(*nlpp)->next;
-    *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+    *nlpp = stalloc(sizeof(**nlpp));
     (*nlpp)->next = NULL;
     parsebackquote = oldstyle;
@@ -10692 +10419 @@
     if (oldstyle)
         doprompt = saveprompt;
-    else {
-        if (readtoken() != TRP)
-            synexpect(TRP);
-    }
+    else if (readtoken() != TRP)
+        raise_error_unexpected_syntax(TRP);
 
     (*nlpp)->n = n;
@@ -10712 +10437 @@
         memcpy(out, str, savelen);
         STADJUST(savelen, out);
-        INTOFF;
-        ckfree(str);
+        INT_OFF;
+        free(str);
         str = NULL;
-        INTON;
+        INT_ON;
     }
     parsebackquote = savepbq;
-    handler = savehandler;
+    exception_handler = savehandler;
     if (arinest || dblquote)
         USTPUTC(CTLBACKQ | CTLQUOTE, out);
@@ -10725 +10450 @@
     if (oldstyle)
         goto parsebackq_oldreturn;
-    else
-        goto parsebackq_newreturn;
-}
-
-#ifdef CONFIG_ASH_MATH_SUPPORT
+    goto parsebackq_newreturn;
+}
+
+#if ENABLE_ASH_MATH_SUPPORT
 /*
  * Parse an arithmetic expansion (indicate start of one and set state)
  */
 parsearith: {
-
     if (++arinest == 1) {
         prevsyntax = syntax;
@@ -10740 +10463 @@
         USTPUTC(CTLARI, out);
         if (dblquote)
-            USTPUTC('"',out);
+            USTPUTC('"', out);
         else
-            USTPUTC(' ',out);
+            USTPUTC(' ', out);
     } else {
         /*
@@ -10756 +10479 @@
 } /* end of readtoken */
 
-
-
-/*
- * Returns true if the text contains nothing to expand (no dollar signs
- * or backquotes).
- */
+/*
+ * Read the next input token.
+ * If the token is a word, we set backquotelist to the list of cmds in
+ *      backquotes.  We set quoteflag to true if any part of the word was
+ *      quoted.
+ * If the token is TREDIR, then we set redirnode to a structure containing
+ *      the redirection.
+ * In all cases, the variable startlinno is set to the number of the line
+ *      on which the token starts.
+ *
+ * [Change comment:  here documents and internal procedures]
+ * [Readtoken shouldn't have any arguments.  Perhaps we should make the
+ *  word parsing code into a separate routine.  In this case, readtoken
+ *  doesn't need to have any internal procedures, but parseword does.
+ *  We could also make parseoperator in essence the main routine, and
+ *  have parseword (readtoken1?) handle both words and redirection.]
+ */
+#define NEW_xxreadtoken
+#ifdef NEW_xxreadtoken
+/* singles must be first! */
+static const char xxreadtoken_chars[7] ALIGN1 = {
+    '\n', '(', ')', '&', '|', ';', 0
+};
+
+static const char xxreadtoken_tokens[] ALIGN1 = {
+    TNL, TLP, TRP,          /* only single occurrence allowed */
+    TBACKGND, TPIPE, TSEMI, /* if single occurrence */
+    TEOF,                   /* corresponds to trailing nul */
+    TAND, TOR, TENDCASE     /* if double occurrence */
+};
+
+#define xxreadtoken_doubles \
+    (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
+#define xxreadtoken_singles \
+    (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
 
 static int
-noexpand(char *text)
-{
-    char *p;
-    char c;
-
-    p = text;
-    while ((c = *p++) != '\0') {
-        if (c == CTLQUOTEMARK)
+xxreadtoken(void)
+{
+    int c;
+
+    if (tokpushback) {
+        tokpushback = 0;
+        return lasttoken;
+    }
+    if (needprompt) {
+        setprompt(2);
+    }
+    startlinno = plinno;
+    for (;;) {                      /* until token or start of word found */
+        c = pgetc_macro();
+
+        if ((c != ' ') && (c != '\t')
+#if ENABLE_ASH_ALIAS
+         && (c != PEOA)
+#endif
+        ) {
+            if (c == '#') {
+                while ((c = pgetc()) != '\n' && c != PEOF);
+                pungetc();
+            } else if (c == '\\') {
+                if (pgetc() != '\n') {
+                    pungetc();
+                    goto READTOKEN1;
+                }
+                startlinno = ++plinno;
+                if (doprompt)
+                    setprompt(2);
+            } else {
+                const char *p
+                    = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
+
+                if (c != PEOF) {
+                    if (c == '\n') {
+                        plinno++;
+                        needprompt = doprompt;
+                    }
+
+                    p = strchr(xxreadtoken_chars, c);
+                    if (p == NULL) {
+ READTOKEN1:
+                        return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
+                    }
+
+                    if (p - xxreadtoken_chars >= xxreadtoken_singles) {
+                        if (pgetc() == *p) {    /* double occurrence? */
+                            p += xxreadtoken_doubles + 1;
+                        } else {
+                            pungetc();
+                        }
+                    }
+                }
+                return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
+            }
+        }
+    } /* for */
+}
+#else
+#define RETURN(token)   return lasttoken = token
+static int
+xxreadtoken(void)
+{
+    int c;
+
+    if (tokpushback) {
+        tokpushback = 0;
+        return lasttoken;
+    }
+    if (needprompt) {
+        setprompt(2);
+    }
+    startlinno = plinno;
+    for (;;) {      /* until token or start of word found */
+        c = pgetc_macro();
+        switch (c) {
+        case ' ': case '\t':
+#if ENABLE_ASH_ALIAS
+        case PEOA:
+#endif
             continue;
-        if (c == CTLESC)
-            p++;
-        else if (SIT(c, BASESYNTAX) == CCTL)
-            return 0;
-    }
-    return 1;
-}
-
-
-/*
- * Return of a legal variable name (a letter or underscore followed by zero or
- * more letters, underscores, and digits).
- */
-
-static char *
-endofname(const char *name)
-{
-    char *p;
-
-    p = (char *) name;
-    if (! is_name(*p))
-        return p;
-    while (*++p) {
-        if (! is_in_name(*p))
-            break;
-    }
-    return p;
-}
-
-
-/*
- * Called when an unexpected token is read during the parse.  The argument
- * is the token that is expected, or -1 if more than one type of token can
- * occur at this point.
- */
-
-static void synexpect(int token)
-{
-    char msg[64];
-    int l;
-
-    l = sprintf(msg, "%s unexpected", tokname(lasttoken));
-    if (token >= 0)
-        sprintf(msg + l, " (expecting %s)", tokname(token));
-    synerror(msg);
-    /* NOTREACHED */
-}
-
-static void
-synerror(const char *msg)
-{
-    sh_error("Syntax error: %s", msg);
-    /* NOTREACHED */
-}
-
-
-/*
- * called by editline -- any expansions to the prompt
- *    should be added here.
- */
-
-#ifdef CONFIG_ASH_EXPAND_PRMT
+        case '#':
+            while ((c = pgetc()) != '\n' && c != PEOF);
+            pungetc();
+            continue;
+        case '\\':
+            if (pgetc() == '\n') {
+                startlinno = ++plinno;
+                if (doprompt)
+                    setprompt(2);
+                continue;
+            }
+            pungetc();
+            goto breakloop;
+        case '\n':
+            plinno++;
+            needprompt = doprompt;
+            RETURN(TNL);
+        case PEOF:
+            RETURN(TEOF);
+        case '&':
+            if (pgetc() == '&')
+                RETURN(TAND);
+            pungetc();
+            RETURN(TBACKGND);
+        case '|':
+            if (pgetc() == '|')
+                RETURN(TOR);
+            pungetc();
+            RETURN(TPIPE);
+        case ';':
+            if (pgetc() == ';')
+                RETURN(TENDCASE);
+            pungetc();
+            RETURN(TSEMI);
+        case '(':
+            RETURN(TLP);
+        case ')':
+            RETURN(TRP);
+        default:
+            goto breakloop;
+        }
+    }
+ breakloop:
+    return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
+#undef RETURN
+}
+#endif /* NEW_xxreadtoken */
+
+static int
+readtoken(void)
+{
+    int t;
+#if DEBUG
+    int alreadyseen = tokpushback;
+#endif
+
+#if ENABLE_ASH_ALIAS
+ top:
+#endif
+
+    t = xxreadtoken();
+
+    /*
+     * eat newlines
+     */
+    if (checkkwd & CHKNL) {
+        while (t == TNL) {
+            parseheredoc();
+            t = xxreadtoken();
+        }
+    }
+
+    if (t != TWORD || quoteflag) {
+        goto out;
+    }
+
+    /*
+     * check for keywords
+     */
+    if (checkkwd & CHKKWD) {
+        const char *const *pp;
+
+        pp = findkwd(wordtext);
+        if (pp) {
+            lasttoken = t = pp - tokname_array;
+            TRACE(("keyword %s recognized\n", tokname(t)));
+            goto out;
+        }
+    }
+
+    if (checkkwd & CHKALIAS) {
+#if ENABLE_ASH_ALIAS
+        struct alias *ap;
+        ap = lookupalias(wordtext, 1);
+        if (ap != NULL) {
+            if (*ap->val) {
+                pushstring(ap->val, ap);
+            }
+            goto top;
+        }
+#endif
+    }
+ out:
+    checkkwd = 0;
+#if DEBUG
+    if (!alreadyseen)
+        TRACE(("token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
+    else
+        TRACE(("reread token %s %s\n", tokname(t), t == TWORD ? wordtext : ""));
+#endif
+    return t;
+}
+
+static char
+peektoken(void)
+{
+    int t;
+
+    t = readtoken();
+    tokpushback++;
+    return tokname_array[t][0];
+}
+
+/*
+ * Read and parse a command.  Returns NEOF on end of file.  (NULL is a
+ * valid parse tree indicating a blank line.)
+ */
+static union node *
+parsecmd(int interact)
+{
+    int t;
+
+    tokpushback = 0;
+    doprompt = interact;
+    if (doprompt)
+        setprompt(doprompt);
+    needprompt = 0;
+    t = readtoken();
+    if (t == TEOF)
+        return NEOF;
+    if (t == TNL)
+        return NULL;
+    tokpushback++;
+    return list(1);
+}
+
+/*
+ * Input any here documents.
+ */
+static void
+parseheredoc(void)
+{
+    struct heredoc *here;
+    union node *n;
+
+    here = heredoclist;
+    heredoclist = 0;
+
+    while (here) {
+        if (needprompt) {
+            setprompt(2);
+        }
+        readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
+                here->eofmark, here->striptabs);
+        n = stalloc(sizeof(struct narg));
+        n->narg.type = NARG;
+        n->narg.next = NULL;
+        n->narg.text = wordtext;
+        n->narg.backquote = backquotelist;
+        here->here->nhere.doc = n;
+        here = here->next;
+    }
+}
+
+
+/*
+ * called by editline -- any expansions to the prompt should be added here.
+ */
+#if ENABLE_ASH_EXPAND_PRMT
 static const char *
 expandstr(const char *ps)
@@ -10855 +10798 @@
 #endif
 
-static void setprompt(int whichprompt)
-{
-    const char *prompt;
-#ifdef CONFIG_ASH_EXPAND_PRMT
+/*
+ * Execute a command or commands contained in a string.
+ */
+static int
+evalstring(char *s, int mask)
+{
+    union node *n;
     struct stackmark smark;
-#endif
-
-    needprompt = 0;
-
-    switch (whichprompt) {
-    case 1:
-        prompt = ps1val();
-        break;
-    case 2:
-        prompt = ps2val();
-        break;
-    default:                        /* 0 */
-        prompt = nullstr;
-    }
-#ifdef CONFIG_ASH_EXPAND_PRMT
+    int skip;
+
+    setinputstring(s);
     setstackmark(&smark);
-    stalloc(stackblocksize());
-#endif
-    putprompt(expandstr(prompt));
-#ifdef CONFIG_ASH_EXPAND_PRMT
-    popstackmark(&smark);
-#endif
-}
-
-
-static const char *const *findkwd(const char *s)
-{
-    return bsearch(s, tokname_array + KWDOFFSET,
-               (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
-                   sizeof(const char *), pstrcmp);
-}
-
-/*      redir.c      */
-
-/*
- * Code for dealing with input/output redirection.
- */
-
-#define EMPTY -2                /* marks an unused slot in redirtab */
-#ifndef PIPE_BUF
-# define PIPESIZE 4096          /* amount of buffering in a pipe */
-#else
-# define PIPESIZE PIPE_BUF
-#endif
-
-/*
- * Open a file in noclobber mode.
- * The code was copied from bash.
- */
-static inline int
-noclobberopen(const char *fname)
-{
-    int r, fd;
-    struct stat finfo, finfo2;
-
-    /*
-     * If the file exists and is a regular file, return an error
-     * immediately.
-     */
-    r = stat(fname, &finfo);
-    if (r == 0 && S_ISREG(finfo.st_mode)) {
-        errno = EEXIST;
-        return -1;
-    }
-
-    /*
-     * If the file was not present (r != 0), make sure we open it
-     * exclusively so that if it is created before we open it, our open
-     * will fail.  Make sure that we do not truncate an existing file.
-     * Note that we don't turn on O_EXCL unless the stat failed -- if the
-     * file was not a regular file, we leave O_EXCL off.
-     */
-    if (r != 0)
-        return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
-    fd = open(fname, O_WRONLY|O_CREAT, 0666);
-
-    /* If the open failed, return the file descriptor right away. */
-    if (fd < 0)
-        return fd;
-
-    /*
-     * OK, the open succeeded, but the file may have been changed from a
-     * non-regular file to a regular file between the stat and the open.
-     * We are assuming that the O_EXCL open handles the case where FILENAME
-     * did not exist and is symlinked to an existing file between the stat
-     * and open.
-     */
-
-    /*
-     * If we can open it and fstat the file descriptor, and neither check
-     * revealed that it was a regular file, and the file has not been
-     * replaced, return the file descriptor.
-     */
-     if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
-         finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
-        return fd;
-
-    /* The file has been replaced.  badness. */
-    close(fd);
-    errno = EEXIST;
-    return -1;
-}
-
-/*
- * Handle here documents.  Normally we fork off a process to write the
- * data to a pipe.  If the document is short, we can stuff the data in
- * the pipe without forking.
- */
-
-static inline int
-openhere(union node *redir)
-{
-    int pip[2];
-    size_t len = 0;
-
-    if (pipe(pip) < 0)
-        sh_error("Pipe call failed");
-    if (redir->type == NHERE) {
-        len = strlen(redir->nhere.doc->narg.text);
-        if (len <= PIPESIZE) {
-            bb_full_write(pip[1], redir->nhere.doc->narg.text, len);
-            goto out;
-        }
-    }
-    if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
-        close(pip[0]);
-        signal(SIGINT, SIG_IGN);
-        signal(SIGQUIT, SIG_IGN);
-        signal(SIGHUP, SIG_IGN);
-#ifdef SIGTSTP
-        signal(SIGTSTP, SIG_IGN);
-#endif
-        signal(SIGPIPE, SIG_DFL);
-        if (redir->type == NHERE)
-            bb_full_write(pip[1], redir->nhere.doc->narg.text, len);
+
+    skip = 0;
+    while ((n = parsecmd(0)) != NEOF) {
+        evaltree(n, 0);
+        popstackmark(&smark);
+        skip = evalskip;
+        if (skip)
+            break;
+    }
+    popfile();
+
+    skip &= mask;
+    evalskip = skip;
+    return skip;
+}
+
+/*
+ * The eval command.
+ */
+static 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 (;;) {
+                concat = stack_putstr(p, concat);
+                p = *ap++;
+                if (p == NULL)
+                    break;
+                STPUTC(' ', concat);
+            }
+            STPUTC('\0', concat);
+            p = grabstackstr(concat);
+        }
+        evalstring(p, ~SKIPEVAL);
+
+    }
+    return exitstatus;
+}
+
+/*
+ * Read and execute commands.  "Top" is nonzero for the top level command
+ * loop; it turns on prompting if the shell is interactive.
+ */
+static int
+cmdloop(int top)
+{
+    union node *n;
+    struct stackmark smark;
+    int inter;
+    int numeof = 0;
+
+    TRACE(("cmdloop(%d) called\n", top));
+    for (;;) {
+        int skip;
+
+        setstackmark(&smark);
+#if JOBS
+        if (jobctl)
+            showjobs(stderr, SHOW_CHANGED);
+#endif
+        inter = 0;
+        if (iflag && top) {
+            inter++;
+#if ENABLE_ASH_MAIL
+            chkmail();
+#endif
+        }
+        n = parsecmd(inter);
+        /* showtree(n); DEBUG */
+        if (n == NEOF) {
+            if (!top || numeof >= 50)
+                break;
+            if (!stoppedjobs()) {
+                if (!Iflag)
+                    break;
+                out2str("\nUse \"exit\" to leave shell.\n");
+            }
+            numeof++;
+        } else if (nflag == 0) {
+            /* job_warning can only be 2,1,0. Here 2->1, 1/0->0 */
+            job_warning >>= 1;
+            numeof = 0;
+            evaltree(n, 0);
+        }
+        popstackmark(&smark);
+        skip = evalskip;
+
+        if (skip) {
+            evalskip = 0;
+            return skip & SKIPEVAL;
+        }
+    }
+    return 0;
+}
+
+/*
+ * 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 *name)
+{
+    char *fullname;
+    const char *path = pathval();
+    struct stat statb;
+
+    /* don't try this for absolute or relative paths */
+    if (strchr(name, '/'))
+        return name;
+
+    while ((fullname = padvance(&path, name)) != NULL) {
+        if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
+            /*
+             * Don't bother freeing here, since it will
+             * be freed by the caller.
+             */
+            return fullname;
+        }
+        stunalloc(fullname);
+    }
+
+    /* not found in the PATH */
+    ash_msg_and_raise_error("%s: not found", name);
+    /* NOTREACHED */
+}
+
+static int
+dotcmd(int argc, char **argv)
+{
+    struct strlist *sp;
+    volatile struct shparam saveparam;
+    int status = 0;
+
+    for (sp = cmdenviron; sp; sp = sp->next)
+        setvareq(ckstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
+
+    if (argc >= 2) {        /* That's what SVR2 does */
+        char *fullname;
+
+        fullname = find_dot_file(argv[1]);
+
+        if (argc > 2) {
+            saveparam = shellparam;
+            shellparam.malloc = 0;
+            shellparam.nparam = argc - 2;
+            shellparam.p = argv + 2;
+        };
+
+        setinputfile(fullname, INPUT_PUSH_FILE);
+        commandname = fullname;
+        cmdloop(0);
+        popfile();
+
+        if (argc > 2) {
+            freeparam(&shellparam);
+            shellparam = saveparam;
+        };
+        status = exitstatus;
+    }
+    return status;
+}
+
+static int
+exitcmd(int argc, char **argv)
+{
+    if (stoppedjobs())
+        return 0;
+    if (argc > 1)
+        exitstatus = number(argv[1]);
+    raise_exception(EXEXIT);
+    /* NOTREACHED */
+}
+
+#if ENABLE_ASH_BUILTIN_ECHO
+static int
+echocmd(int argc, char **argv)
+{
+    return bb_echo(argv);
+}
+#endif
+
+#if ENABLE_ASH_BUILTIN_TEST
+static int
+testcmd(int argc, char **argv)
+{
+    return test_main(argc, argv);
+}
+#endif
+
+/*
+ * Read a file containing shell functions.
+ */
+static void
+readcmdfile(char *name)
+{
+    setinputfile(name, INPUT_PUSH_FILE);
+    cmdloop(0);
+    popfile();
+}
+
+
+/* ============ find_command inplementation */
+
+/*
+ * Resolve a command name.  If you change this routine, you may have to
+ * change the shellexec routine as well.
+ */
+static void
+find_command(char *name, struct cmdentry *entry, int act, const char *path)
+{
+    struct tblentry *cmdp;
+    int idx;
+    int prev;
+    char *fullname;
+    struct stat statb;
+    int e;
+    int updatetbl;
+    struct builtincmd *bcmd;
+
+    /* If name contains a slash, don't use PATH or hash table */
+    if (strchr(name, '/') != NULL) {
+        entry->u.index = -1;
+        if (act & DO_ABS) {
+            while (stat(name, &statb) < 0) {
+#ifdef SYSV
+                if (errno == EINTR)
+                    continue;
+#endif
+                entry->cmdtype = CMDUNKNOWN;
+                return;
+            }
+        }
+        entry->cmdtype = CMDNORMAL;
+        return;
+    }
+
+/* #if ENABLE_FEATURE_SH_STANDALONE... moved after builtin check */
+
+    updatetbl = (path == pathval());
+    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);
+    if (cmdp != NULL) {
+        int bit;
+
+        switch (cmdp->cmdtype) {
+        default:
+#if DEBUG
+            abort();
+#endif
+        case CMDNORMAL:
+            bit = DO_ALTPATH;
+            break;
+        case CMDFUNCTION:
+            bit = DO_NOFUNC;
+            break;
+        case CMDBUILTIN:
+            bit = DO_ALTBLTIN;
+            break;
+        }
+        if (act & bit) {
+            updatetbl = 0;
+            cmdp = NULL;
+        } else if (cmdp->rehash == 0)
+            /* if not invalidated by cd, we're done */
+            goto success;
+    }
+
+    /* If %builtin not in path, check for builtin next */
+    bcmd = find_builtin(name);
+    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) {
+            goto builtin_success;
+        }
+    }
+
+#if ENABLE_FEATURE_SH_STANDALONE
+    if (find_applet_by_name(name)) {
+        entry->cmdtype = CMDNORMAL;
+        entry->u.index = -1;
+        return;
+    }
+#endif
+
+    /* We have to search path. */
+    prev = -1;              /* where to start */
+    if (cmdp && cmdp->rehash) {     /* doing a rehash */
+        if (cmdp->cmdtype == CMDBUILTIN)
+            prev = builtinloc;
         else
-            expandhere(redir->nhere.doc, pip[1]);
-        _exit(0);
-    }
-out:
-    close(pip[1]);
-    return pip[0];
-}
-
+            prev = cmdp->param.index;
+    }
+
+    e = ENOENT;
+    idx = -1;
+ loop:
+    while ((fullname = padvance(&path, name)) != NULL) {
+        stunalloc(fullname);
+        /* NB: code below will still use fullname
+         * despite it being "unallocated" */
+        idx++;
+        if (pathopt) {
+            if (prefix(pathopt, "builtin")) {
+                if (bcmd)
+                    goto builtin_success;
+                continue;
+            } else if (!(act & DO_NOFUNC)
+             && prefix(pathopt, "func")) {
+                /* handled below */
+            } else {
+                /* ignore unimplemented options */
+                continue;
+            }
+        }
+        /* if rehash, don't redo absolute path names */
+        if (fullname[0] == '/' && idx <= prev) {
+            if (idx < prev)
+                continue;
+            TRACE(("searchexec \"%s\": no change\n", name));
+            goto success;
+        }
+        while (stat(fullname, &statb) < 0) {
+#ifdef SYSV
+            if (errno == EINTR)
+                continue;
+#endif
+            if (errno != ENOENT && errno != ENOTDIR)
+                e = errno;
+            goto loop;
+        }
+        e = EACCES;     /* if we fail, this will be the error */
+        if (!S_ISREG(statb.st_mode))
+            continue;
+        if (pathopt) {          /* this is a %func directory */
+            stalloc(strlen(fullname) + 1);
+            /* NB: stalloc will return space pointed by fullname
+             * (because we don't have any intervening allocations
+             * between stunalloc above and this stalloc) */
+            readcmdfile(fullname);
+            cmdp = cmdlookup(name, 0);
+            if (cmdp == NULL || cmdp->cmdtype != CMDFUNCTION)
+                ash_msg_and_raise_error("%s not defined in %s", name, fullname);
+            stunalloc(fullname);
+            goto success;
+        }
+        TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
+        if (!updatetbl) {
+            entry->cmdtype = CMDNORMAL;
+            entry->u.index = idx;
+            return;
+        }
+        INT_OFF;
+        cmdp = cmdlookup(name, 1);
+        cmdp->cmdtype = CMDNORMAL;
+        cmdp->param.index = idx;
+        INT_ON;
+        goto success;
+    }
+
+    /* We failed.  If there was an entry for this command, delete it */
+    if (cmdp && updatetbl)
+        delete_cmd_entry();
+    if (act & DO_ERR)
+        ash_msg("%s: %s", name, errmsg(e, "not found"));
+    entry->cmdtype = CMDUNKNOWN;
+    return;
+
+ builtin_success:
+    if (!updatetbl) {
+        entry->cmdtype = CMDBUILTIN;
+        entry->u.cmd = bcmd;
+        return;
+    }
+    INT_OFF;
+    cmdp = cmdlookup(name, 1);
+    cmdp->cmdtype = CMDBUILTIN;
+    cmdp->param.cmd = bcmd;
+    INT_ON;
+ success:
+    cmdp->rehash = 0;
+    entry->cmdtype = cmdp->cmdtype;
+    entry->u = cmdp->param;
+}
+
+
+/* ============ trap.c */
+
+/*
+ * The trap builtin.
+ */
 static int
-openredirect(union node *redir)
-{
-    char *fname;
-    int f;
-
-    switch (redir->nfile.type) {
-    case NFROM:
-        fname = redir->nfile.expfname;
-        if ((f = open(fname, O_RDONLY)) < 0)
-            goto eopen;
-        break;
-    case NFROMTO:
-        fname = redir->nfile.expfname;
-        if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
-            goto ecreate;
-        break;
-    case NTO:
-        /* Take care of noclobber mode. */
-        if (Cflag) {
-            fname = redir->nfile.expfname;
-            if ((f = noclobberopen(fname)) < 0)
-                goto ecreate;
-            break;
-        }
-        /* FALLTHROUGH */
-    case NCLOBBER:
-        fname = redir->nfile.expfname;
-        if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
-            goto ecreate;
-        break;
-    case NAPPEND:
-        fname = redir->nfile.expfname;
-        if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
-            goto ecreate;
-        break;
-    default:
-#ifdef DEBUG
-        abort();
-#endif
-        /* Fall through to eliminate warning. */
-    case NTOFD:
-    case NFROMFD:
-        f = -1;
-        break;
-    case NHERE:
-    case NXHERE:
-        f = openhere(redir);
-        break;
-    }
-
-    return f;
-ecreate:
-    sh_error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
-eopen:
-    sh_error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
-}
-
-static inline void
-dupredirect(union node *redir, int f)
-{
-    int fd = redir->nfile.fd;
-
-    if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
-        if (redir->ndup.dupfd >= 0) {   /* if not ">&-" */
-                copyfd(redir->ndup.dupfd, fd);
-        }
-        return;
-    }
-
-    if (f != fd) {
-        copyfd(f, fd);
-        close(f);
-    }
-    return;
-}
-
-/*
- * Process a list of redirection commands.  If the REDIR_PUSH flag is set,
- * old file descriptors are stashed away so that the redirection can be
- * undone by calling popredir.  If the REDIR_BACKQ flag is set, then the
- * standard output, and the standard error if it becomes a duplicate of
- * stdout, is saved in memory.
- */
-
-static void
-redirect(union node *redir, int flags)
-{
-    union node *n;
-    struct redirtab *sv;
-    int i;
-    int fd;
-    int newfd;
-    int *p;
-    nullredirs++;
-    if (!redir) {
-        return;
-    }
-    sv = NULL;
-    INTOFF;
-    if (flags & REDIR_PUSH) {
-        struct redirtab *q;
-        q = ckmalloc(sizeof (struct redirtab));
-        q->next = redirlist;
-        redirlist = q;
-        q->nullredirs = nullredirs - 1;
-        for (i = 0 ; i < 10 ; i++)
-            q->renamed[i] = EMPTY;
-        nullredirs = 0;
-        sv = q;
-    }
-    n = redir;
-    do {
-        fd = n->nfile.fd;
-        if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
-            n->ndup.dupfd == fd)
-            continue; /* redirect from/to same file descriptor */
-
-        newfd = openredirect(n);
-        if (fd == newfd)
-            continue;
-        if (sv && *(p = &sv->renamed[fd]) == EMPTY) {
-            i = fcntl(fd, F_DUPFD, 10);
-
-            if (i == -1) {
-                i = errno;
-                if (i != EBADF) {
-                    close(newfd);
-                    errno = i;
-                    sh_error("%d: %m", fd);
-                    /* NOTREACHED */
-                }
-            } else {
-                *p = i;
-                close(fd);
-            }
-        } else {
-            close(fd);
-        }
-        dupredirect(n, newfd);
-    } while ((n = n->nfile.next));
-    INTON;
-    if (flags & REDIR_SAVEFD2 && sv && sv->renamed[2] >= 0)
-        preverrout_fd = sv->renamed[2];
-}
-
-
-/*
- * Undo the effects of the last redirection.
- */
-
-void
-popredir(int drop)
-{
-    struct redirtab *rp;
-    int i;
-
-    if (--nullredirs >= 0)
-        return;
-    INTOFF;
-    rp = redirlist;
-    for (i = 0 ; i < 10 ; i++) {
-        if (rp->renamed[i] != EMPTY) {
-            if (!drop) {
-                close(i);
-                copyfd(rp->renamed[i], i);
-            }
-            close(rp->renamed[i]);
-        }
-    }
-    redirlist = rp->next;
-    nullredirs = rp->nullredirs;
-    ckfree(rp);
-    INTON;
-}
-
-/*
- * Undo all redirections.  Called on error or interrupt.
- */
-
-/*
- * Discard all saved file descriptors.
- */
-
-void
-clearredir(int drop)
-{
-    for (;;) {
-        nullredirs = 0;
-        if (!redirlist)
-            break;
-        popredir(drop);
-    }
-}
-
-
-/*
- * Copy a file descriptor to be >= to.  Returns -1
- * if the source file descriptor is closed, EMPTY if there are no unused
- * file descriptors left.
- */
-
-int
-copyfd(int from, int to)
-{
-    int newfd;
-
-    newfd = fcntl(from, F_DUPFD, to);
-    if (newfd < 0) {
-        if (errno == EMFILE)
-            return EMPTY;
-        else
-            sh_error("%d: %m", from);
-    }
-    return newfd;
-}
-
-
-int
-redirectsafe(union node *redir, int flags)
-{
-    int err;
-    volatile int saveint;
-    struct jmploc *volatile savehandler = handler;
-    struct jmploc jmploc;
-
-    SAVEINT(saveint);
-    if (!(err = setjmp(jmploc.loc) * 2)) {
-        handler = &jmploc;
-        redirect(redir, flags);
-    }
-    handler = savehandler;
-    if (err && exception != EXERROR)
-        longjmp(handler->loc, 1);
-    RESTOREINT(saveint);
-    return err;
-}
-
-/*      show.c    */
-
-#ifdef DEBUG
-static void shtree(union node *, int, char *, FILE*);
-static void shcmd(union node *, FILE *);
-static void sharg(union node *, FILE *);
-static void indent(int, char *, FILE *);
-static void trstring(char *);
-
-
-void
-showtree(union node *n)
-{
-    trputs("showtree called\n");
-    shtree(n, 1, NULL, stdout);
-}
-
-
-static void
-shtree(union node *n, int ind, char *pfx, FILE *fp)
-{
-    struct nodelist *lp;
-    const char *s;
-
-    if (n == NULL)
-        return;
-
-    indent(ind, pfx, fp);
-    switch(n->type) {
-    case NSEMI:
-        s = "; ";
-        goto binop;
-    case NAND:
-        s = " && ";
-        goto binop;
-    case NOR:
-        s = " || ";
-binop:
-        shtree(n->nbinary.ch1, ind, NULL, fp);
-       /*    if (ind < 0) */
-            fputs(s, fp);
-        shtree(n->nbinary.ch2, ind, NULL, fp);
-        break;
-    case NCMD:
-        shcmd(n, fp);
-        if (ind >= 0)
-            putc('\n', fp);
-        break;
-    case NPIPE:
-        for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
-            shcmd(lp->n, fp);
-            if (lp->next)
-                fputs(" | ", fp);
-        }
-        if (n->npipe.backgnd)
-            fputs(" &", fp);
-        if (ind >= 0)
-            putc('\n', fp);
-        break;
-    default:
-        fprintf(fp, "<node type %d>", n->type);
-        if (ind >= 0)
-            putc('\n', fp);
-        break;
-    }
-}
-
-
-static void
-shcmd(union node *cmd, FILE *fp)
-{
-    union node *np;
-    int first;
-    const char *s;
-    int dftfd;
-
-    first = 1;
-    for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
-        if (! first)
-            putchar(' ');
-        sharg(np, fp);
-        first = 0;
-    }
-    for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
-        if (! first)
-            putchar(' ');
-        switch (np->nfile.type) {
-            case NTO:       s = ">";  dftfd = 1; break;
-            case NCLOBBER:  s = ">|"; dftfd = 1; break;
-            case NAPPEND:   s = ">>"; dftfd = 1; break;
-            case NTOFD:     s = ">&"; dftfd = 1; break;
-            case NFROM:     s = "<";  dftfd = 0; break;
-            case NFROMFD:   s = "<&"; dftfd = 0; break;
-            case NFROMTO:   s = "<>"; dftfd = 0; break;
-            default:        s = "*error*"; dftfd = 0; break;
-        }
-        if (np->nfile.fd != dftfd)
-            fprintf(fp, "%d", np->nfile.fd);
-        fputs(s, fp);
-        if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
-            fprintf(fp, "%d", np->ndup.dupfd);
-        } else {
-            sharg(np->nfile.fname, fp);
-        }
-        first = 0;
-    }
-}
-
-
-
-static void
-sharg(union node *arg, FILE *fp)
-{
-    char *p;
-    struct nodelist *bqlist;
-    int subtype;
-
-    if (arg->type != NARG) {
-        out1fmt("<node type %d>\n", arg->type);
-        abort();
-    }
-    bqlist = arg->narg.backquote;
-    for (p = arg->narg.text ; *p ; p++) {
-        switch (*p) {
-        case CTLESC:
-            putc(*++p, fp);
-            break;
-        case CTLVAR:
-            putc('$', fp);
-            putc('{', fp);
-            subtype = *++p;
-            if (subtype == VSLENGTH)
-                putc('#', fp);
-
-            while (*p != '=')
-                putc(*p++, fp);
-
-            if (subtype & VSNUL)
-                putc(':', fp);
-
-            switch (subtype & VSTYPE) {
-            case VSNORMAL:
-                putc('}', fp);
-                break;
-            case VSMINUS:
-                putc('-', fp);
-                break;
-            case VSPLUS:
-                putc('+', fp);
-                break;
-            case VSQUESTION:
-                putc('?', fp);
-                break;
-            case VSASSIGN:
-                putc('=', fp);
-                break;
-            case VSTRIMLEFT:
-                putc('#', fp);
-                break;
-            case VSTRIMLEFTMAX:
-                putc('#', fp);
-                putc('#', fp);
-                break;
-            case VSTRIMRIGHT:
-                putc('%', fp);
-                break;
-            case VSTRIMRIGHTMAX:
-                putc('%', fp);
-                putc('%', fp);
-                break;
-            case VSLENGTH:
-                break;
-            default:
-                out1fmt("<subtype %d>", subtype);
-            }
-            break;
-        case CTLENDVAR:
-             putc('}', fp);
-             break;
-        case CTLBACKQ:
-        case CTLBACKQ|CTLQUOTE:
-            putc('$', fp);
-            putc('(', fp);
-            shtree(bqlist->n, -1, NULL, fp);
-            putc(')', fp);
-            break;
-        default:
-            putc(*p, fp);
-            break;
-        }
-    }
-}
-
-
-static void
-indent(int amount, char *pfx, FILE *fp)
-{
-    int i;
-
-    for (i = 0 ; i < amount ; i++) {
-        if (pfx && i == amount - 1)
-            fputs(pfx, fp);
-        putc('\t', fp);
-    }
-}
-
-
-
-/*
- * Debugging stuff.
- */
-
-
-FILE *tracefile;
-
-
-void
-trputc(int c)
-{
-    if (debug != 1)
-        return;
-    putc(c, tracefile);
-}
-
-void
-trace(const char *fmt, ...)
-{
-    va_list va;
-
-    if (debug != 1)
-        return;
-    va_start(va, fmt);
-    (void) vfprintf(tracefile, fmt, va);
-    va_end(va);
-}
-
-void
-tracev(const char *fmt, va_list va)
-{
-    if (debug != 1)
-        return;
-    (void) vfprintf(tracefile, fmt, va);
-}
-
-
-void
-trputs(const char *s)
-{
-    if (debug != 1)
-        return;
-    fputs(s, tracefile);
-}
-
-
-static void
-trstring(char *s)
-{
-    char *p;
-    char c;
-
-    if (debug != 1)
-        return;
-    putc('"', tracefile);
-    for (p = s ; *p ; p++) {
-        switch (*p) {
-        case '\n':  c = 'n';  goto backslash;
-        case '\t':  c = 't';  goto backslash;
-        case '\r':  c = 'r';  goto backslash;
-        case '"':  c = '"';  goto backslash;
-        case '\\':  c = '\\';  goto backslash;
-        case CTLESC:  c = 'e';  goto backslash;
-        case CTLVAR:  c = 'v';  goto backslash;
-        case CTLVAR+CTLQUOTE:  c = 'V';  goto backslash;
-        case CTLBACKQ:  c = 'q';  goto backslash;
-        case CTLBACKQ+CTLQUOTE:  c = 'Q';  goto backslash;
-backslash:        putc('\\', tracefile);
-            putc(c, tracefile);
-            break;
-        default:
-            if (*p >= ' ' && *p <= '~')
-                putc(*p, tracefile);
-            else {
-                putc('\\', tracefile);
-                putc(*p >> 6 & 03, tracefile);
-                putc(*p >> 3 & 07, tracefile);
-                putc(*p & 07, tracefile);
-            }
-            break;
-        }
-    }
-    putc('"', tracefile);
-}
-
-
-void
-trargs(char **ap)
-{
-    if (debug != 1)
-        return;
-    while (*ap) {
-        trstring(*ap++);
-        if (*ap)
-            putc(' ', tracefile);
-        else
-            putc('\n', tracefile);
-    }
-}
-
-
-void
-opentrace(void)
-{
-    char s[100];
-#ifdef O_APPEND
-    int flags;
-#endif
-
-    if (debug != 1) {
-        if (tracefile)
-            fflush(tracefile);
-        /* leave open because libedit might be using it */
-        return;
-    }
-    scopy("./trace", s);
-    if (tracefile) {
-        if (!freopen(s, "a", tracefile)) {
-            fprintf(stderr, "Can't re-open %s\n", s);
-            debug = 0;
-            return;
-        }
-    } else {
-        if ((tracefile = fopen(s, "a")) == NULL) {
-            fprintf(stderr, "Can't open %s\n", s);
-            debug = 0;
-            return;
-        }
-    }
-#ifdef O_APPEND
-    if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
-        fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
-#endif
-    setlinebuf(tracefile);
-    fputs("\nTracing started.\n", tracefile);
-}
-#endif /* DEBUG */
-
-
-/*      trap.c       */
-
-/*
- * Sigmode records the current value of the signal handlers for the various
- * modes.  A value of zero means that the current handler is not known.
- * S_HARD_IGN indicates that the signal was ignored on entry to the shell,
- */
-
-#define S_DFL 1                 /* default signal handling (SIG_DFL) */
-#define S_CATCH 2               /* signal is caught */
-#define S_IGN 3                 /* signal is ignored (SIG_IGN) */
-#define S_HARD_IGN 4            /* signal is ignored permenantly */
-#define S_RESET 5               /* temporary - to reset a hard ignored sig */
-
-
-
-/*
- * The trap builtin.
- */
-
-int
 trapcmd(int argc, char **argv)
 {
@@ -11619 +11228 @@
     ap = argptr;
     if (!*ap) {
-        for (signo = 0 ; signo < NSIG ; signo++) {
+        for (signo = 0; signo < NSIG; signo++) {
             if (trap[signo] != NULL) {
                 const char *sn;
 
-                sn = u_signal_names(0, &signo, 0);
-                if (sn == NULL)
-                    sn = "???";
+                sn = get_signame(signo);
                 out1fmt("trap -- %s %s\n",
                     single_quote(trap[signo]), sn);
@@ -11637 +11244 @@
         action = *ap++;
     while (*ap) {
-        if ((signo = decode_signal(*ap, 0)) < 0)
-            sh_error("%s: bad trap", *ap);
-        INTOFF;
+        signo = get_signum(*ap);
+        if (signo < 0)
+            ash_msg_and_raise_error("%s: bad trap", *ap);
+        INT_OFF;
         if (action) {
-            if (action[0] == '-' && action[1] == '\0')
+            if (LONE_DASH(action))
                 action = NULL;
             else
-                action = savestr(action);
+                action = ckstrdup(action);
         }
         if (trap[signo])
-            ckfree(trap[signo]);
+            free(trap[signo]);
         trap[signo] = action;
         if (signo != 0)
             setsignal(signo);
-        INTON;
+        INT_ON;
         ap++;
     }
@@ -11658 +11266 @@
 
 
-/*
- * Clear traps on a fork.
- */
-
-void
-clear_traps(void)
-{
-    char **tp;
-
-    for (tp = trap ; tp < &trap[NSIG] ; tp++) {
-        if (*tp && **tp) {      /* trap not NULL or SIG_IGN */
-            INTOFF;
-            ckfree(*tp);
-            *tp = NULL;
-            if (tp != &trap[0])
-                setsignal(tp - trap);
-            INTON;
-        }
-    }
-}
-
-
-/*
- * Set the signal handler for the specified signal.  The routine figures
- * out what it should be set to.
- */
-
-void
-setsignal(int signo)
-{
-    int action;
-    char *t, tsig;
-    struct sigaction act;
-
-    if ((t = trap[signo]) == NULL)
-        action = S_DFL;
-    else if (*t != '\0')
-        action = S_CATCH;
-    else
-        action = S_IGN;
-    if (rootshell && action == S_DFL) {
-        switch (signo) {
-        case SIGINT:
-            if (iflag || minusc || sflag == 0)
-                action = S_CATCH;
-            break;
-        case SIGQUIT:
-#ifdef DEBUG
-            if (debug)
-                break;
-#endif
-            /* FALLTHROUGH */
-        case SIGTERM:
-            if (iflag)
-                action = S_IGN;
-            break;
-#if JOBS
-        case SIGTSTP:
-        case SIGTTOU:
-            if (mflag)
-                action = S_IGN;
-            break;
-#endif
-        }
-    }
-
-    t = &sigmode[signo - 1];
-    tsig = *t;
-    if (tsig == 0) {
-        /*
-         * current setting unknown
-         */
-        if (sigaction(signo, 0, &act) == -1) {
-            /*
-             * Pretend it worked; maybe we should give a warning
-             * here, but other shells don't. We don't alter
-             * sigmode, so that we retry every time.
-             */
-            return;
-        }
-        if (act.sa_handler == SIG_IGN) {
-            if (mflag && (signo == SIGTSTP ||
-                 signo == SIGTTIN || signo == SIGTTOU)) {
-                tsig = S_IGN;   /* don't hard ignore these */
-            } else
-                tsig = S_HARD_IGN;
-        } else {
-            tsig = S_RESET; /* force to be set */
-        }
-    }
-    if (tsig == S_HARD_IGN || tsig == action)
-        return;
-    switch (action) {
-    case S_CATCH:
-        act.sa_handler = onsig;
-        break;
-    case S_IGN:
-        act.sa_handler = SIG_IGN;
-        break;
-    default:
-        act.sa_handler = SIG_DFL;
-    }
-    *t = action;
-    act.sa_flags = 0;
-    sigfillset(&act.sa_mask);
-    sigaction(signo, &act, 0);
-}
-
-/*
- * Ignore a signal.
- */
-
-void
-ignoresig(int signo)
-{
-    if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
-        signal(signo, SIG_IGN);
-    }
-    sigmode[signo - 1] = S_HARD_IGN;
-}
-
-
-/*
- * Signal handler.
- */
-
-void
-onsig(int signo)
-{
-    gotsig[signo - 1] = 1;
-    pendingsigs = signo;
-
-    if (exsig || (signo == SIGINT && !trap[SIGINT])) {
-        if (!suppressint)
-            onint();
-        intpending = 1;
-    }
-}
-
-
-/*
- * Called to execute a trap.  Perhaps we should avoid entering new trap
- * handlers while we are executing a trap handler.
- */
-
-int
-dotrap(void)
-{
-    char *p;
-    char *q;
-    int i;
-    int savestatus;
-    int skip = 0;
-
-    savestatus = exitstatus;
-    pendingsigs = 0;
-    xbarrier();
-
-    for (i = 0, q = gotsig; i < NSIG - 1; i++, q++) {
-        if (!*q)
-            continue;
-        *q = 0;
-
-        p = trap[i + 1];
-        if (!p)
-            continue;
-        skip = evalstring(p, SKIPEVAL);
-        exitstatus = savestatus;
-        if (skip)
-            break;
-    }
-
-    return skip;
-}
-
-
-/*
- * Controls whether the shell is interactive or not.
- */
-
-void
-setinteractive(int on)
-{
-    static int is_interactive;
-
-    if (++on == is_interactive)
-        return;
-    is_interactive = on;
-    setsignal(SIGINT);
-    setsignal(SIGQUIT);
-    setsignal(SIGTERM);
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
-        if(is_interactive > 1) {
-            /* Looks like they want an interactive shell */
-            static int do_banner;
-
-                if(!do_banner) {
-                    out1fmt(
-            "\n\n%s Built-in shell (ash)\n"
-            "Enter 'help' for a list of built-in commands.\n\n",
-                    BB_BANNER);
-                    do_banner++;
-                }
-        }
-#endif
-}
-
-
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
-/*** List the available builtins ***/
-
-static int helpcmd(int argc, char **argv)
+/* ============ Builtins */
+
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+/*
+ * Lists available builtins
+ */
+static int
+helpcmd(int argc, char **argv)
 {
     int col, i;
 
     out1fmt("\nBuilt-in commands:\n-------------------\n");
-    for (col = 0, i = 0; i < NUMBUILTINS; i++) {
+    for (col = 0, i = 0; i < ARRAY_SIZE(builtintab); i++) {
         col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '),
-                      builtincmd[i].name + 1);
+                    builtintab[i].name + 1);
         if (col > 60) {
             out1fmt("\n");
@@ -11882 +11286 @@
         }
     }
-#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
-    {
-        extern const struct BB_applet applets[];
-        extern const size_t NUM_APPLETS;
-
-        for (i = 0; i < NUM_APPLETS; i++) {
-
-            col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
-            if (col > 60) {
-                out1fmt("\n");
-                col = 0;
-            }
+#if ENABLE_FEATURE_SH_STANDALONE
+    for (i = 0; i < NUM_APPLETS; i++) {
+        col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
+        if (col > 60) {
+            out1fmt("\n");
+            col = 0;
         }
     }
@@ -11900 +11298 @@
     return EXIT_SUCCESS;
 }
-#endif /* CONFIG_FEATURE_SH_EXTRA_QUIET */
-
-/*
- * Called to exit the shell.
- */
-
-void
-exitshell(void)
-{
-    struct jmploc loc;
-    char *p;
-    int status;
-
-    status = exitstatus;
-    TRACE(("pid %d, exitshell(%d)\n", getpid(), status));
-    if (setjmp(loc.loc)) {
-        if (exception == EXEXIT)
-            _exit(exitstatus);
-        goto out;
-    }
-    handler = &loc;
-    if ((p = trap[0])) {
-        trap[0] = NULL;
-        evalstring(p, 0);
-    }
-    flushall();
-    setjobctl(0);
-#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
-    if (iflag && rootshell) {
-        const char *hp = lookupvar("HISTFILE");
-
-        if(hp != NULL )
-            save_history ( hp );
-    }
-#endif
-out:
-    _exit(status);
-    /* NOTREACHED */
-}
-
-static int decode_signal(const char *string, int minsig)
-{
-    int signo;
-    const char *name = u_signal_names(string, &signo, minsig);
-
-    return name ? signo : -1;
-}
-
-/*      var.c     */
-
-static struct var *vartab[VTABSIZE];
-
-static int vpcmp(const void *, const void *);
-static struct var **findvar(struct var **, const char *);
-
-/*
- * Initialize the variable symbol tables and import the environment
- */
-
-
-#ifdef CONFIG_ASH_GETOPTS
-/*
- * Safe version of setvar, returns 1 on success 0 on failure.
- */
-
-int
-setvarsafe(const char *name, const char *val, int flags)
-{
-    int err;
-    volatile int saveint;
-    struct jmploc *volatile savehandler = handler;
-    struct jmploc jmploc;
-
-    SAVEINT(saveint);
-    if (setjmp(jmploc.loc))
-        err = 1;
-    else {
-        handler = &jmploc;
-        setvar(name, val, flags);
-        err = 0;
-    }
-    handler = savehandler;
-    RESTOREINT(saveint);
-    return err;
-}
-#endif
-
-/*
- * Set the value of a variable.  The flags argument is ored with the
- * flags of the variable.  If val is NULL, the variable is unset.
- */
-
-static void
-setvar(const char *name, const char *val, int flags)
-{
-    char *p, *q;
-    size_t namelen;
-    char *nameeq;
-    size_t vallen;
-
-    q = endofname(name);
-    p = strchrnul(q, '=');
-    namelen = p - name;
-    if (!namelen || p != q)
-        sh_error("%.*s: bad variable name", namelen, name);
-    vallen = 0;
-    if (val == NULL) {
-        flags |= VUNSET;
-    } else {
-        vallen = strlen(val);
-    }
-    INTOFF;
-    p = mempcpy(nameeq = ckmalloc(namelen + vallen + 2), name, namelen);
-    if (val) {
-        *p++ = '=';
-        p = mempcpy(p, val, vallen);
-    }
-    *p = '\0';
-    setvareq(nameeq, flags | VNOSAVE);
-    INTON;
-}
-
-
-/*
- * Same as setvar except that the variable and value are passed in
- * the first argument as name=value.  Since the first argument will
- * be actually stored in the table, it should not be a string that
- * will go away.
- * Called with interrupts off.
- */
-
-void
-setvareq(char *s, int flags)
-{
-    struct var *vp, **vpp;
-
-    vpp = hashvar(s);
-    flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
-    vp = *findvar(vpp, s);
-    if (vp) {
-        if ((vp->flags & (VREADONLY|VDYNAMIC)) == VREADONLY) {
-            const char *n;
-
-            if (flags & VNOSAVE)
-                free(s);
-            n = vp->text;
-            sh_error("%.*s: is read only", strchrnul(n, '=') - n, n);
-        }
-
-        if (flags & VNOSET)
-            return;
-
-        if (vp->func && (flags & VNOFUNC) == 0)
-            (*vp->func)(strchrnul(s, '=') + 1);
-
-        if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
-            ckfree(vp->text);
-
-        flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET);
-    } else {
-        if (flags & VNOSET)
-            return;
-        /* not found */
-        vp = ckmalloc(sizeof (*vp));
-        vp->next = *vpp;
-        vp->func = NULL;
-        *vpp = vp;
-    }
-    if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE)))
-        s = savestr(s);
-    vp->text = s;
-    vp->flags = flags;
-}
-
-
-/*
- * 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;
-    INTOFF;
-    do {
-        setvareq(lp->text, flags);
-    } while ((lp = lp->next));
-    INTON;
-}
-
-
-/*
- * Find the value of a variable.  Returns NULL if not set.
- */
-
-static char *
-lookupvar(const char *name)
-{
-    struct var *v;
-
-    if ((v = *findvar(hashvar(name), name))) {
-#ifdef DYNAMIC_VAR
-    /*
-     * Dynamic variables are implemented roughly the same way they are
-     * in bash. Namely, they're "special" so long as they aren't unset.
-     * As soon as they're unset, they're no longer dynamic, and dynamic
-     * lookup will no longer happen at that point. -- PFM.
-     */
-        if((v->flags & VDYNAMIC))
-            (*v->func)(NULL);
-#endif
-        if(!(v->flags & VUNSET))
-            return strchrnul(v->text, '=') + 1;
-    }
-
-    return NULL;
-}
-
-
-/*
- * Search the environment of a builtin command.
- */
-
-static char *
-bltinlookup(const char *name)
-{
-    struct strlist *sp;
-
-    for (sp = cmdenviron ; sp ; sp = sp->next) {
-        if (varequal(sp->text, name))
-            return strchrnul(sp->text, '=') + 1;
-    }
-    return lookupvar(name);
-}
-
-
-/*
- * Generate a list of variables satisfying the given conditions.
- */
-
-static char **
-listvars(int on, int off, char ***end)
-{
-    struct var **vpp;
-    struct var *vp;
-    char **ep;
-    int mask;
-
-    STARTSTACKSTR(ep);
-    vpp = vartab;
-    mask = on | off;
-    do {
-        for (vp = *vpp ; vp ; vp = vp->next)
-            if ((vp->flags & mask) == on) {
-                if (ep == stackstrend())
-                    ep = growstackstr();
-                *ep++ = (char *) vp->text;
-            }
-    } while (++vpp < vartab + VTABSIZE);
-    if (ep == stackstrend())
-        ep = growstackstr();
-    if (end)
-        *end = ep;
-    *ep++ = NULL;
-    return grabstackstr(ep);
-}
-
-
-/*
- * POSIX requires that 'set' (but not export or readonly) output the
- * variables in lexicographic order - by the locale's collating order (sigh).
- * Maybe we could keep them in an ordered balanced binary tree
- * instead of hashed lists.
- * For now just roll 'em through qsort for printing...
- */
-
-static int
-showvars(const char *sep_prefix, int on, int off)
-{
-    const char *sep;
-    char **ep, **epend;
-
-    ep = listvars(on, off, &epend);
-    qsort(ep, epend - ep, sizeof(char *), vpcmp);
-
-    sep = *sep_prefix ? spcstr : sep_prefix;
-
-    for (; ep < epend; ep++) {
-        const char *p;
-        const char *q;
-
-        p = strchrnul(*ep, '=');
-        q = nullstr;
-        if (*p)
-            q = single_quote(++p);
-
-        out1fmt("%s%s%.*s%s\n", sep_prefix, sep, (int)(p - *ep), *ep, q);
-    }
-
-    return 0;
-}
-
-
+#endif /* FEATURE_SH_EXTRA_QUIET */
 
 /*
  * The export and readonly commands.
  */
-
 static int
 exportcmd(int argc, char **argv)
@@ -12219 +11311 @@
     char **aptr;
     int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
-    int notp;
-
-    notp = nextopt("p") - 'p';
-    if (notp && ((name = *(aptr = argptr)))) {
-        do {
-            if ((p = strchr(name, '=')) != NULL) {
-                p++;
-            } else {
-                if ((vp = *findvar(hashvar(name), name))) {
-                    vp->flags |= flag;
-                    continue;
+
+    if (nextopt("p") != 'p') {
+        aptr = argptr;
+        name = *aptr;
+        if (name) {
+            do {
+                p = strchr(name, '=');
+                if (p != NULL) {
+                    p++;
+                } else {
+                    vp = *findvar(hashvar(name), name);
+                    if (vp) {
+                        vp->flags |= flag;
+                        continue;
+                    }
                 }
-            }
-            setvar(name, p, flag);
-        } while ((name = *++aptr) != NULL);
-    } else {
-        showvars(argv[0], flag, 0);
-    }
+                setvar(name, p, flag);
+            } while ((name = *++aptr) != NULL);
+            return 0;
+        }
+    }
+    showvars(argv[0], flag, 0);
     return 0;
 }
 
-
-/*
- * Make a variable a local variable.  When a variable is made local, it's
- * value and flags are saved in a localvar structure.  The saved values
- * will be restored when the shell function returns.  We handle the name
- * "-" as a special case.
- */
-
-static inline void
-mklocal(char *name)
-{
-    struct localvar *lvp;
-    struct var **vpp;
-    struct var *vp;
-
-    INTOFF;
-    lvp = ckmalloc(sizeof (struct localvar));
-    if (name[0] == '-' && name[1] == '\0') {
-        char *p;
-        p = ckmalloc(sizeof(optlist));
-        lvp->text = memcpy(p, optlist, sizeof(optlist));
-        vp = NULL;
-    } else {
-        char *eq;
-
-        vpp = hashvar(name);
-        vp = *findvar(vpp, name);
-        eq = strchr(name, '=');
-        if (vp == NULL) {
-            if (eq)
-                setvareq(name, VSTRFIXED);
-            else
-                setvar(name, NULL, VSTRFIXED);
-            vp = *vpp;      /* the new variable */
-            lvp->flags = VUNSET;
-        } else {
-            lvp->text = vp->text;
-            lvp->flags = vp->flags;
-            vp->flags |= VSTRFIXED|VTEXTFIXED;
-            if (eq)
-                setvareq(name, 0);
-        }
-    }
-    lvp->vp = vp;
-    lvp->next = localvars;
-    localvars = lvp;
-    INTON;
-}
-
-/*
- * The "local" command.
- */
-
-static int
-localcmd(int argc, char **argv)
-{
-    char *name;
-
-    argv = argptr;
-    while ((name = *argv++) != NULL) {
-        mklocal(name);
-    }
-    return 0;
-}
-
-
-/*
- * Called after a function returns.
- * Interrupts must be off.
- */
-
-static void
-poplocalvars(void)
-{
-    struct localvar *lvp;
-    struct var *vp;
-
-    while ((lvp = localvars) != NULL) {
-        localvars = lvp->next;
-        vp = lvp->vp;
-        TRACE(("poplocalvar %s", vp ? vp->text : "-"));
-        if (vp == NULL) {       /* $- saved */
-            memcpy(optlist, lvp->text, sizeof(optlist));
-            ckfree(lvp->text);
-            optschanged();
-        } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
-            unsetvar(vp->text);
-        } else {
-            if (vp->func)
-                (*vp->func)(strchrnul(lvp->text, '=') + 1);
-            if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
-                ckfree(vp->text);
-            vp->flags = lvp->flags;
-            vp->text = lvp->text;
-        }
-        ckfree(lvp);
-    }
-}
-
+/*
+ * Delete a function if it exists.
+ */
+static void
+unsetfunc(const char *name)
+{
+    struct tblentry *cmdp;
+
+    cmdp = cmdlookup(name, 0);
+    if (cmdp!= NULL && cmdp->cmdtype == CMDFUNCTION)
+        delete_cmd_entry();
+}
 
 /*
@@ -12345 +11354 @@
  * with the same name.
  */
-
-int
+static int
 unsetcmd(int argc, char **argv)
 {
@@ -12358 +11366 @@
     }
 
-    for (ap = argptr; *ap ; ap++) {
+    for (ap = argptr; *ap; ap++) {
         if (flag != 'f') {
             i = unsetvar(*ap);
@@ -12372 +11380 @@
 
 
-/*
- * Unset the specified variable.
- */
-
-int
-unsetvar(const char *s)
-{
-    struct var **vpp;
-    struct var *vp;
-    int retval;
-
-    vpp = findvar(hashvar(s), s);
-    vp = *vpp;
-    retval = 2;
-    if (vp) {
-        int flags = vp->flags;
-
-        retval = 1;
-        if (flags & VREADONLY)
-            goto out;
-#ifdef DYNAMIC_VAR
-        vp->flags &= ~VDYNAMIC;
-#endif
-        if (flags & VUNSET)
-            goto ok;
-        if ((flags & VSTRFIXED) == 0) {
-            INTOFF;
-            if ((flags & (VTEXTFIXED|VSTACK)) == 0)
-                ckfree(vp->text);
-            *vpp = vp->next;
-            ckfree(vp);
-            INTON;
-        } else {
-            setvar(s, 0, 0);
-            vp->flags &= ~VEXPORT;
-        }
-ok:
-        retval = 0;
-    }
-
-out:
-    return retval;
-}
-
-
-
-/*
- * Find the appropriate entry in the hash table from the name.
- */
-
-static struct var **
-hashvar(const char *p)
-{
-    unsigned int hashval;
-
-    hashval = ((unsigned char) *p) << 4;
-    while (*p && *p != '=')
-        hashval += (unsigned char) *p++;
-    return &vartab[hashval % VTABSIZE];
-}
-
-
-
-/*
- * Compares two strings up to the first = or '\0'.  The first
- * string must be terminated by '='; the second may be terminated by
- * either '=' or '\0'.
- */
-
-int
-varcmp(const char *p, const char *q)
-{
-    int c, d;
-
-    while ((c = *p) == (d = *q)) {
-        if (!c || c == '=')
-            goto out;
-        p++;
-        q++;
-    }
-    if (c == '=')
-        c = 0;
-    if (d == '=')
-        d = 0;
-out:
-    return c - d;
-}
-
-static int
-vpcmp(const void *a, const void *b)
-{
-    return varcmp(*(const char **)a, *(const char **)b);
-}
-
-static struct var **
-findvar(struct var **vpp, const char *name)
-{
-    for (; *vpp; vpp = &(*vpp)->next) {
-        if (varequal((*vpp)->text, name)) {
-            break;
-        }
-    }
-    return vpp;
-}
 /*      setmode.c      */
 
 #include <sys/times.h>
 
-static const unsigned char timescmd_str[] = {
+static const unsigned char timescmd_str[] ALIGN1 = {
     ' ',  offsetof(struct tms, tms_utime),
     '\n', offsetof(struct tms, tms_stime),
@@ -12488 +11392 @@
 };
 
-static int timescmd(int ac, char **av)
-{
-    long int clk_tck, s, t;
+static int
+timescmd(int ac, char **av)
+{
+    long clk_tck, s, t;
     const unsigned char *p;
     struct tms buf;
@@ -12510 +11415 @@
 }
 
-#ifdef CONFIG_ASH_MATH_SUPPORT
+#if ENABLE_ASH_MATH_SUPPORT
 static arith_t
 dash_arith(const char *s)
@@ -12517 +11422 @@
     int errcode = 0;
 
-    INTOFF;
+    INT_OFF;
     result = arith(s, &errcode);
     if (errcode < 0) {
         if (errcode == -3)
-            sh_error("exponent less than 0");
-        else if (errcode == -2)
-            sh_error("divide by zero");
-        else if (errcode == -5)
-            sh_error("expression recursion loop detected");
-        else
-            synerror(s);
-    }
-    INTON;
-
-    return (result);
-}
-
+            ash_msg_and_raise_error("exponent less than 0");
+        if (errcode == -2)
+            ash_msg_and_raise_error("divide by zero");
+        if (errcode == -5)
+            ash_msg_and_raise_error("expression recursion loop detected");
+        raise_error_syntax(s);
+    }
+    INT_ON;
+
+    return result;
+}
 
 /*
@@ -12541 +11444 @@
  *  Copyright (C) 2003 Vladimir Oleynik <dzo@simtreas.ru>
  */
-
 static int
 letcmd(int argc, char **argv)
 {
     char **ap;
-    arith_t i;
+    arith_t i = 0;
 
     ap = argv + 1;
-    if(!*ap)
-        sh_error("expression expected");
+    if (!*ap)
+        ash_msg_and_raise_error("expression expected");
     for (ap = argv + 1; *ap; ap++) {
         i = dash_arith(*ap);
     }
 
-    return (!i);
-}
-#endif /* CONFIG_ASH_MATH_SUPPORT */
-
-/*      miscbltin.c  */
-
-/*
+    return !i;
+}
+#endif /* ASH_MATH_SUPPORT */
+
+
+/* ============ miscbltin.c
+ *
  * Miscellaneous builtins.
  */
@@ -12567 +11469 @@
 #undef rflag
 
-#ifdef __GLIBC__
-#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
+#if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
 typedef enum __rlimit_resource rlim_t;
 #endif
-#endif
-
 
 /*
@@ -12580 +11479 @@
  * This uses unbuffered input, which may be avoidable in some cases.
  */
-
 static int
 readcmd(int argc, char **argv)
@@ -12594 +11492 @@
     int status;
     int i;
-#if defined(CONFIG_ASH_READ_NCHARS)
+#if ENABLE_ASH_READ_NCHARS
     int nch_flag = 0;
     int nchars = 0;
@@ -12600 +11498 @@
     struct termios tty, old_tty;
 #endif
-#if defined(CONFIG_ASH_READ_TIMEOUT)
+#if ENABLE_ASH_READ_TIMEOUT
     fd_set set;
     struct timeval ts;
@@ -12609 +11507 @@
     rflag = 0;
     prompt = NULL;
-#if defined(CONFIG_ASH_READ_NCHARS) && defined(CONFIG_ASH_READ_TIMEOUT)
+#if ENABLE_ASH_READ_NCHARS && ENABLE_ASH_READ_TIMEOUT
     while ((i = nextopt("p:rt:n:s")) != '\0')
-#elif defined(CONFIG_ASH_READ_NCHARS)
+#elif ENABLE_ASH_READ_NCHARS
     while ((i = nextopt("p:rn:s")) != '\0')
-#elif defined(CONFIG_ASH_READ_TIMEOUT)
+#elif ENABLE_ASH_READ_TIMEOUT
     while ((i = nextopt("p:rt:")) != '\0')
 #else
@@ -12619 +11517 @@
 #endif
     {
-        switch(i) {
+        switch (i) {
         case 'p':
             prompt = optionarg;
             break;
-#if defined(CONFIG_ASH_READ_NCHARS)
+#if ENABLE_ASH_READ_NCHARS
         case 'n':
             nchars = strtol(optionarg, &p, 10);
             if (*p)
-                sh_error("invalid count");
+                ash_msg_and_raise_error("invalid count");
             nch_flag = (nchars > 0);
             break;
@@ -12634 +11532 @@
             break;
 #endif
-#if defined(CONFIG_ASH_READ_TIMEOUT)
+#if ENABLE_ASH_READ_TIMEOUT
         case 't':
             ts.tv_sec = strtol(optionarg, &p, 10);
@@ -12644 +11542 @@
                     ts.tv_usec = strtol(p, &p2, 10);
                     if (*p2)
-                        sh_error("invalid timeout");
+                        ash_msg_and_raise_error("invalid timeout");
                     scale = p2 - p;
                     /* normalize to usec */
                     if (scale > 6)
-                        sh_error("invalid timeout");
+                        ash_msg_and_raise_error("invalid timeout");
                     while (scale++ < 6)
                         ts.tv_usec *= 10;
                 }
             } else if (*p) {
-                sh_error("invalid timeout");
+                ash_msg_and_raise_error("invalid timeout");
             }
             if ( ! ts.tv_sec && ! ts.tv_usec)
-                sh_error("invalid timeout");
+                ash_msg_and_raise_error("invalid timeout");
             break;
 #endif
@@ -12669 +11567 @@
         out2str(prompt);
     }
-    if (*(ap = argptr) == NULL)
-        sh_error("arg count");
-    if ((ifs = bltinlookup("IFS")) == NULL)
+    ap = argptr;
+    if (*ap == NULL)
+        ash_msg_and_raise_error("arg count");
+    ifs = bltinlookup("IFS");
+    if (ifs == NULL)
         ifs = defifs;
-#if defined(CONFIG_ASH_READ_NCHARS)
+#if ENABLE_ASH_READ_NCHARS
     if (nch_flag || silent) {
         tcgetattr(0, &tty);
         old_tty = tty;
         if (nch_flag) {
-            tty.c_lflag &= ~ICANON;
-            tty.c_cc[VMIN] = nchars;
+            tty.c_lflag &= ~ICANON;
+            tty.c_cc[VMIN] = nchars;
         }
         if (silent) {
-            tty.c_lflag &= ~(ECHO|ECHOK|ECHONL);
+            tty.c_lflag &= ~(ECHO|ECHOK|ECHONL);
 
         }
@@ -12688 +11588 @@
     }
 #endif
-#if defined(CONFIG_ASH_READ_TIMEOUT)
+#if ENABLE_ASH_READ_TIMEOUT
     if (ts.tv_sec || ts.tv_usec) {
-        FD_ZERO (&set);
-        FD_SET (0, &set);
-
-        i = select (FD_SETSIZE, &set, NULL, NULL, &ts);
+        FD_ZERO(&set);
+        FD_SET(0, &set);
+
+        i = select(FD_SETSIZE, &set, NULL, NULL, &ts);
         if (!i) {
-#if defined(CONFIG_ASH_READ_NCHARS)
+#if ENABLE_ASH_READ_NCHARS
             if (nch_flag)
                 tcsetattr(0, TCSANOW, &old_tty);
@@ -12707 +11607 @@
     backslash = 0;
     STARTSTACKSTR(p);
-#if defined(CONFIG_ASH_READ_NCHARS)
+#if ENABLE_ASH_READ_NCHARS
     while (!nch_flag || nchars--)
 #else
@@ -12742 +11642 @@
             STARTSTACKSTR(p);
         } else {
-put:
+ put:
             STPUTC(c, p);
         }
     }
-#if defined(CONFIG_ASH_READ_NCHARS)
+#if ENABLE_ASH_READ_NCHARS
     if (nch_flag || silent)
         tcsetattr(0, TCSANOW, &old_tty);
@@ -12761 +11661 @@
 }
 
-
-static int umaskcmd(int argc, char **argv)
-{
-    static const char permuser[3] = "ugo";
-    static const char permmode[3] = "rwx";
-    static const short int permmask[] = {
+static int
+umaskcmd(int argc, char **argv)
+{
+    static const char permuser[3] ALIGN1 = "ugo";
+    static const char permmode[3] ALIGN1 = "rwx";
+    static const short permmask[] ALIGN2 = {
         S_IRUSR, S_IWUSR, S_IXUSR,
         S_IRGRP, S_IWGRP, S_IXGRP,
@@ -12781 +11681 @@
     }
 
-    INTOFF;
+    INT_OFF;
     mask = umask(0);
     umask(mask);
-    INTON;
-
-    if ((ap = *argptr) == NULL) {
+    INT_ON;
+
+    ap = *argptr;
+    if (ap == NULL) {
         if (symbolic_mode) {
             char buf[18];
@@ -12809 +11710 @@
         }
     } else {
-        if (is_digit((unsigned char) *ap)) {
+        if (isdigit((unsigned char) *ap)) {
             mask = 0;
             do {
                 if (*ap >= '8' || *ap < '0')
-                    sh_error(illnum, argv[1]);
+                    ash_msg_and_raise_error(illnum, argv[1]);
                 mask = (mask << 3) + (*ap - '0');
             } while (*++ap != '\0');
@@ -12820 +11721 @@
             mask = ~mask & 0777;
             if (!bb_parse_mode(ap, &mask)) {
-                sh_error("Illegal mode: %s", ap);
+                ash_msg_and_raise_error("illegal mode: %s", ap);
             }
             umask(~mask & 0777);
@@ -12879 +11780 @@
     { "locks",                      RLIMIT_LOCKS,      1, 'w' },
 #endif
-    { (char *) 0,                   0,                 0,  '\0' }
+    { NULL,                         0,                 0,  '\0' }
 };
 
 enum limtype { SOFT = 0x1, HARD = 0x2 };
 
-static void printlim(enum limtype how, const struct rlimit *limit,
+static void
+printlim(enum limtype how, const struct rlimit *limit,
             const struct limits *l)
 {
@@ -12901 +11803 @@
 }
 
-int
+static int
 ulimitcmd(int argc, char **argv)
 {
-    int     c;
+    int c;
     rlim_t val = 0;
     enum limtype how = SOFT | HARD;
-    const struct limits     *l;
-    int             set, all = 0;
-    int             optc, what;
-    struct rlimit   limit;
+    const struct limits *l;
+    int set, all = 0;
+    int optc, what;
+    struct rlimit limit;
 
     what = 'f';
@@ -12947 +11849 @@
                 "w"
 #endif
-                        )) != '\0')
+                    )) != '\0')
         switch (optc) {
         case 'H':
@@ -12970 +11872 @@
 
         if (all || argptr[1])
-            sh_error("too many arguments");
+            ash_msg_and_raise_error("too many arguments");
         if (strncmp(p, "unlimited\n", 9) == 0)
             val = RLIM_INFINITY;
@@ -12976 +11878 @@
             val = (rlim_t) 0;
 
-            while ((c = *p++) >= '0' && c <= '9')
-            {
+            while ((c = *p++) >= '0' && c <= '9') {
                 val = (val * 10) + (long)(c - '0');
                 if (val < (rlim_t) 0)
@@ -12983 +11884 @@
             }
             if (c)
-                sh_error("bad number");
+                ash_msg_and_raise_error("bad number");
             val *= l->factor;
         }
@@ -13003 +11904 @@
             limit.rlim_cur = val;
         if (setrlimit(l->cmd, &limit) < 0)
-            sh_error("error setting limit (%m)");
+            ash_msg_and_raise_error("error setting limit (%m)");
     } else {
         printlim(how, &limit, l);
@@ -13011 +11912 @@
 
 
-#ifdef CONFIG_ASH_MATH_SUPPORT
+/* ============ Math support */
+
+#if ENABLE_ASH_MATH_SUPPORT
 
 /* Copyright (c) 2001 Aaron Lehmann <aaronl@vitelus.com>
@@ -13107 +12010 @@
  */
 
-
 #define arith_isspace(arithval) \
     (arithval == ' ' || arithval == '\n' || arithval == '\t')
-
 
 typedef unsigned char operator;
@@ -13141 +12042 @@
 
 /* all assign is right associativity and precedence eq, but (7+3)<<5 > 256 */
-#define convert_prec_is_assing(prec) do { if(prec == 3) prec = 2; } while(0)
+#define convert_prec_is_assing(prec) do { if (prec == 3) prec = 2; } while (0)
 
 /* conditional is right associativity too */
@@ -13203 +12104 @@
 #define NUMPTR (*numstackptr)
 
-static inline int tok_have_assign(operator op)
+static int
+tok_have_assign(operator op)
 {
     operator prec = PREC(op);
@@ -13212 +12114 @@
 }
 
-static inline int is_right_associativity(operator prec)
-{
-    return (prec == PREC(TOK_ASSIGN) || prec == PREC(TOK_EXPONENT) ||
-        prec == PREC(TOK_CONDITIONAL));
-}
-
+static int
+is_right_associativity(operator prec)
+{
+    return (prec == PREC(TOK_ASSIGN) || prec == PREC(TOK_EXPONENT)
+            || prec == PREC(TOK_CONDITIONAL));
+}
 
 typedef struct ARITCH_VAR_NUM {
@@ -13227 +12129 @@
 } v_n_t;
 
-
 typedef struct CHK_VAR_RECURSIVE_LOOPED {
     const char *var;
@@ -13235 +12136 @@
 static chk_var_recursive_looped_t *prev_chk_var_recursive;
 
-
-static int arith_lookup_val(v_n_t *t)
-{
-    if(t->var) {
-    const char * p = lookupvar(t->var);
-
-    if(p) {
-        int errcode;
-
-        /* recursive try as expression */
-        chk_var_recursive_looped_t *cur;
-        chk_var_recursive_looped_t cur_save;
-
-        for(cur = prev_chk_var_recursive; cur; cur = cur->next) {
-        if(strcmp(cur->var, t->var) == 0) {
-            /* expression recursion loop detected */
-            return -5;
-        }
-        }
-        /* save current lookuped var name */
-        cur = prev_chk_var_recursive;
-        cur_save.var = t->var;
-        cur_save.next = cur;
-        prev_chk_var_recursive = &cur_save;
-
-        t->val = arith (p, &errcode);
-        /* restore previous ptr after recursiving */
-        prev_chk_var_recursive = cur;
-        return errcode;
-    } else {
-        /* allow undefined var as 0 */
-        t->val = 0;
-    }
-    }
-    return 0;
+static int
+arith_lookup_val(v_n_t *t)
+{
+    if (t->var) {
+        const char * p = lookupvar(t->var);
+
+        if (p) {
+            int errcode;
+
+            /* recursive try as expression */
+            chk_var_recursive_looped_t *cur;
+            chk_var_recursive_looped_t cur_save;
+
+            for (cur = prev_chk_var_recursive; cur; cur = cur->next) {
+                if (strcmp(cur->var, t->var) == 0) {
+                    /* expression recursion loop detected */
+                    return -5;
+                }
+            }
+            /* save current lookuped var name */
+            cur = prev_chk_var_recursive;
+            cur_save.var = t->var;
+            cur_save.next = cur;
+            prev_chk_var_recursive = &cur_save;
+
+            t->val = arith (p, &errcode);
+            /* restore previous ptr after recursiving */
+            prev_chk_var_recursive = cur;
+            return errcode;
+        }
+        /* allow undefined var as 0 */
+        t->val = 0;
+    }
+    return 0;
 }
 
@@ -13275 +12175 @@
  * stack. For a unary operator it will only change the top element, but a
  * binary operator will pop two arguments and push a result */
-static inline int
+static int
 arith_apply(operator op, v_n_t *numstack, v_n_t **numstackptr)
 {
@@ -13282 +12182 @@
     int ret_arith_lookup_val;
 
-    if (NUMPTR == numstack) goto err; /* There is no operator that can work
-                                         without arguments */
+    /* There is no operator that can work without arguments */
+    if (NUMPTR == numstack) goto err;
     numptr_m1 = NUMPTR - 1;
 
     /* check operand is var with noninteger value */
     ret_arith_lookup_val = arith_lookup_val(numptr_m1);
-    if(ret_arith_lookup_val)
+    if (ret_arith_lookup_val)
         return ret_arith_lookup_val;
 
@@ -13305 +12205 @@
         /* Binary operators */
 
-        /* check and binary operators need two arguments */
-        if (numptr_m1 == numstack) goto err;
-
-        /* ... and they pop one */
-        --NUMPTR;
-        numptr_val = rez;
-        if (op == TOK_CONDITIONAL) {
-        if(! numptr_m1->contidional_second_val_initialized) {
-            /* protect $((expr1 ? expr2)) without ": expr" */
-            goto err;
-        }
-        rez = numptr_m1->contidional_second_val;
-        } else if(numptr_m1->contidional_second_val_initialized) {
-            /* protect $((expr1 : expr2)) without "expr ? " */
-            goto err;
-        }
-        numptr_m1 = NUMPTR - 1;
-        if(op != TOK_ASSIGN) {
-        /* check operand is var with noninteger value for not '=' */
-        ret_arith_lookup_val = arith_lookup_val(numptr_m1);
-        if(ret_arith_lookup_val)
-            return ret_arith_lookup_val;
-        }
-        if (op == TOK_CONDITIONAL) {
-            numptr_m1->contidional_second_val = rez;
-        }
-        rez = numptr_m1->val;
-        if (op == TOK_BOR || op == TOK_OR_ASSIGN)
+        /* check and binary operators need two arguments */
+        if (numptr_m1 == numstack) goto err;
+
+        /* ... and they pop one */
+        --NUMPTR;
+        numptr_val = rez;
+        if (op == TOK_CONDITIONAL) {
+            if (! numptr_m1->contidional_second_val_initialized) {
+                /* protect $((expr1 ? expr2)) without ": expr" */
+                goto err;
+            }
+            rez = numptr_m1->contidional_second_val;
+        } else if (numptr_m1->contidional_second_val_initialized) {
+            /* protect $((expr1 : expr2)) without "expr ? " */
+            goto err;
+        }
+        numptr_m1 = NUMPTR - 1;
+        if (op != TOK_ASSIGN) {
+            /* check operand is var with noninteger value for not '=' */
+            ret_arith_lookup_val = arith_lookup_val(numptr_m1);
+            if (ret_arith_lookup_val)
+                return ret_arith_lookup_val;
+        }
+        if (op == TOK_CONDITIONAL) {
+            numptr_m1->contidional_second_val = rez;
+        }
+        rez = numptr_m1->val;
+        if (op == TOK_BOR || op == TOK_OR_ASSIGN)
             rez |= numptr_val;
-        else if (op == TOK_OR)
+        else if (op == TOK_OR)
             rez = numptr_val || rez;
-        else if (op == TOK_BAND || op == TOK_AND_ASSIGN)
+        else if (op == TOK_BAND || op == TOK_AND_ASSIGN)
             rez &= numptr_val;
-        else if (op == TOK_BXOR || op == TOK_XOR_ASSIGN)
+        else if (op == TOK_BXOR || op == TOK_XOR_ASSIGN)
             rez ^= numptr_val;
-        else if (op == TOK_AND)
+        else if (op == TOK_AND)
             rez = rez && numptr_val;
-        else if (op == TOK_EQ)
+        else if (op == TOK_EQ)
             rez = (rez == numptr_val);
-        else if (op == TOK_NE)
+        else if (op == TOK_NE)
             rez = (rez != numptr_val);
-        else if (op == TOK_GE)
+        else if (op == TOK_GE)
             rez = (rez >= numptr_val);
-        else if (op == TOK_RSHIFT || op == TOK_RSHIFT_ASSIGN)
+        else if (op == TOK_RSHIFT || op == TOK_RSHIFT_ASSIGN)
             rez >>= numptr_val;
-        else if (op == TOK_LSHIFT || op == TOK_LSHIFT_ASSIGN)
+        else if (op == TOK_LSHIFT || op == TOK_LSHIFT_ASSIGN)
             rez <<= numptr_val;
-        else if (op == TOK_GT)
+        else if (op == TOK_GT)
             rez = (rez > numptr_val);
-        else if (op == TOK_LT)
+        else if (op == TOK_LT)
             rez = (rez < numptr_val);
-        else if (op == TOK_LE)
+        else if (op == TOK_LE)
             rez = (rez <= numptr_val);
-        else if (op == TOK_MUL || op == TOK_MUL_ASSIGN)
+        else if (op == TOK_MUL || op == TOK_MUL_ASSIGN)
             rez *= numptr_val;
-        else if (op == TOK_ADD || op == TOK_PLUS_ASSIGN)
+        else if (op == TOK_ADD || op == TOK_PLUS_ASSIGN)
             rez += numptr_val;
-        else if (op == TOK_SUB || op == TOK_MINUS_ASSIGN)
+        else if (op == TOK_SUB || op == TOK_MINUS_ASSIGN)
             rez -= numptr_val;
-        else if (op == TOK_ASSIGN || op == TOK_COMMA)
+        else if (op == TOK_ASSIGN || op == TOK_COMMA)
             rez = numptr_val;
-        else if (op == TOK_CONDITIONAL_SEP) {
+        else if (op == TOK_CONDITIONAL_SEP) {
             if (numptr_m1 == numstack) {
-                /* protect $((expr : expr)) without "expr ? " */
-                goto err;
+                /* protect $((expr : expr)) without "expr ? " */
+                goto err;
             }
             numptr_m1->contidional_second_val_initialized = op;
             numptr_m1->contidional_second_val = numptr_val;
-        }
-        else if (op == TOK_CONDITIONAL) {
+        } else if (op == TOK_CONDITIONAL) {
             rez = rez ?
-                  numptr_val : numptr_m1->contidional_second_val;
-        }
-        else if(op == TOK_EXPONENT) {
-            if(numptr_val < 0)
+                numptr_val : numptr_m1->contidional_second_val;
+        } else if (op == TOK_EXPONENT) {
+            if (numptr_val < 0)
                 return -3;      /* exponent less than 0 */
             else {
                 arith_t c = 1;
 
-                if(numptr_val)
-                    while(numptr_val--)
+                if (numptr_val)
+                    while (numptr_val--)
                         c *= rez;
                 rez = c;
             }
-        }
-        else if(numptr_val==0)          /* zero divisor check */
+        } else if (numptr_val==0)          /* zero divisor check */
             return -2;
-        else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
+        else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
             rez /= numptr_val;
-        else if (op == TOK_REM || op == TOK_REM_ASSIGN)
+        else if (op == TOK_REM || op == TOK_REM_ASSIGN)
             rez %= numptr_val;
     }
-    if(tok_have_assign(op)) {
-        char buf[32];
-
-        if(numptr_m1->var == NULL) {
+    if (tok_have_assign(op)) {
+        char buf[sizeof(arith_t_type)*3 + 2];
+
+        if (numptr_m1->var == NULL) {
             /* Hmm, 1=2 ? */
             goto err;
         }
         /* save to shell variable */
-#ifdef CONFIG_ASH_MATH_SUPPORT_64
-        snprintf(buf, sizeof(buf), "%lld", arith_t_type rez);
+#if ENABLE_ASH_MATH_SUPPORT_64
+        snprintf(buf, sizeof(buf), "%lld", (arith_t_type) rez);
 #else
-        snprintf(buf, sizeof(buf), "%ld", arith_t_type rez);
+        snprintf(buf, sizeof(buf), "%ld", (arith_t_type) rez);
 #endif
         setvar(numptr_m1->var, buf, 0);
         /* after saving, make previous value for v++ or v-- */
-        if(op == TOK_POST_INC)
+        if (op == TOK_POST_INC)
             rez--;
-        else if(op == TOK_POST_DEC)
+        else if (op == TOK_POST_DEC)
             rez++;
     }
@@ -13421 +12318 @@
     numptr_m1->var = NULL;
     return 0;
-err: return(-1);
-}
-
-/* longest must first */
-static const char op_tokens[] = {
+ err:
+    return -1;
+}
+
+/* longest must be first */
+static const char op_tokens[] ALIGN1 = {
     '<','<','=',0, TOK_LSHIFT_ASSIGN,
     '>','>','=',0, TOK_RSHIFT_ASSIGN,
@@ -13471 +12369 @@
 #define endexpression &op_tokens[sizeof(op_tokens)-7]
 
-
-static arith_t arith (const char *expr, int *perrcode)
-{
-    register char arithval; /* Current character under analysis */
-    operator lasttok, op;
-    operator prec;
-
-    const char *p = endexpression;
-    int errcode;
-
-    size_t datasizes = strlen(expr) + 2;
-
-    /* Stack of integers */
-    /* The proof that there can be no more than strlen(startbuf)/2+1 integers
-     * in any given correct or incorrect expression is left as an exercise to
-     * the reader. */
-    v_n_t *numstack = alloca(((datasizes)/2)*sizeof(v_n_t)),
-        *numstackptr = numstack;
-    /* Stack of operator tokens */
-    operator *stack = alloca((datasizes) * sizeof(operator)),
-        *stackptr = stack;
-
-    *stackptr++ = lasttok = TOK_LPAREN;     /* start off with a left paren */
-    *perrcode = errcode = 0;
-
-    while(1) {
-    if ((arithval = *expr) == 0) {
-        if (p == endexpression) {
-            /* Null expression. */
-            return 0;
-        }
-
-        /* This is only reached after all tokens have been extracted from the
-         * input stream. If there are still tokens on the operator stack, they
-         * are to be applied in order. At the end, there should be a final
-         * result on the integer stack */
-
-        if (expr != endexpression + 1) {
-            /* If we haven't done so already, */
-            /* append a closing right paren */
-            expr = endexpression;
-            /* and let the loop process it. */
-            continue;
-        }
-        /* At this point, we're done with the expression. */
-        if (numstackptr != numstack+1) {
-            /* ... but if there isn't, it's bad */
-          err:
-            return (*perrcode = -1);
-        }
-        if(numstack->var) {
-            /* expression is $((var)) only, lookup now */
-            errcode = arith_lookup_val(numstack);
-        }
-    ret:
-        *perrcode = errcode;
-        return numstack->val;
-    } else {
+static arith_t
+arith(const char *expr, int *perrcode)
+{
+    char arithval; /* Current character under analysis */
+    operator lasttok, op;
+    operator prec;
+
+    const char *p = endexpression;
+    int errcode;
+
+    size_t datasizes = strlen(expr) + 2;
+
+    /* Stack of integers */
+    /* The proof that there can be no more than strlen(startbuf)/2+1 integers
+     * in any given correct or incorrect expression is left as an exercise to
+     * the reader. */
+    v_n_t *numstack = alloca(((datasizes)/2)*sizeof(v_n_t)),
+                *numstackptr = numstack;
+    /* Stack of operator tokens */
+    operator *stack = alloca((datasizes) * sizeof(operator)),
+                *stackptr = stack;
+
+    *stackptr++ = lasttok = TOK_LPAREN;     /* start off with a left paren */
+    *perrcode = errcode = 0;
+
+    while (1) {
+        arithval = *expr;
+        if (arithval == 0) {
+            if (p == endexpression) {
+                /* Null expression. */
+                return 0;
+            }
+
+            /* This is only reached after all tokens have been extracted from the
+             * input stream. If there are still tokens on the operator stack, they
+             * are to be applied in order. At the end, there should be a final
+             * result on the integer stack */
+
+            if (expr != endexpression + 1) {
+                /* If we haven't done so already, */
+                /* append a closing right paren */
+                expr = endexpression;
+                /* and let the loop process it. */
+                continue;
+            }
+            /* At this point, we're done with the expression. */
+            if (numstackptr != numstack+1) {
+                /* ... but if there isn't, it's bad */
+ err:
+                return (*perrcode = -1);
+            }
+            if (numstack->var) {
+                /* expression is $((var)) only, lookup now */
+                errcode = arith_lookup_val(numstack);
+            }
+ ret:
+            *perrcode = errcode;
+            return numstack->val;
+        }
+
         /* Continue processing the expression. */
         if (arith_isspace(arithval)) {
@@ -13534 +12434 @@
             goto prologue;
         }
-        if((p = endofname(expr)) != expr) {
+        p = endofname(expr);
+        if (p != expr) {
             size_t var_name_size = (p-expr) + 1;  /* trailing zero */
 
@@ -13540 +12441 @@
             safe_strncpy(numstackptr->var, expr, var_name_size);
             expr = p;
-        num:
+ num:
             numstackptr->contidional_second_val_initialized = 0;
             numstackptr++;
             lasttok = TOK_NUM;
             continue;
-        } else if (is_digit(arithval)) {
+        }
+        if (isdigit(arithval)) {
             numstackptr->var = NULL;
-#ifdef CONFIG_ASH_MATH_SUPPORT_64
+#if ENABLE_ASH_MATH_SUPPORT_64
             numstackptr->val = strtoll(expr, (char **) &expr, 0);
 #else
@@ -13554 +12456 @@
             goto num;
         }
-        for(p = op_tokens; ; p++) {
+        for (p = op_tokens; ; p++) {
             const char *o;
 
-            if(*p == 0) {
+            if (*p == 0) {
                 /* strange operator not found */
                 goto err;
             }
-            for(o = expr; *p && *o == *p; p++)
+            for (o = expr; *p && *o == *p; p++)
                 o++;
-            if(! *p) {
+            if (! *p) {
                 /* found */
                 expr = o - 1;
@@ -13569 +12471 @@
             }
             /* skip tail uncompared token */
-            while(*p)
+            while (*p)
                 p++;
             /* skip zero delim */
@@ -13577 +12479 @@
 
         /* post grammar: a++ reduce to num */
-        if(lasttok == TOK_POST_INC || lasttok == TOK_POST_DEC)
-            lasttok = TOK_NUM;
+        if (lasttok == TOK_POST_INC || lasttok == TOK_POST_DEC)
+            lasttok = TOK_NUM;
 
         /* Plus and minus are binary (not unary) _only_ if the last
@@ -13585 +12487 @@
          * It makes sense. */
         if (lasttok != TOK_NUM) {
-            switch(op) {
-                case TOK_ADD:
-                    op = TOK_UPLUS;
-                    break;
-                case TOK_SUB:
-                    op = TOK_UMINUS;
-                    break;
-                case TOK_POST_INC:
-                    op = TOK_PRE_INC;
-                    break;
-                case TOK_POST_DEC:
-                    op = TOK_PRE_DEC;
-                    break;
+            switch (op) {
+            case TOK_ADD:
+                op = TOK_UPLUS;
+                break;
+            case TOK_SUB:
+                op = TOK_UMINUS;
+                break;
+            case TOK_POST_INC:
+                op = TOK_PRE_INC;
+                break;
+            case TOK_POST_DEC:
+                op = TOK_PRE_DEC;
+                break;
             }
         }
@@ -13619 +12521 @@
             }
             while (stackptr != stack) {
-                if (op == TOK_RPAREN) {
-                /* The algorithm employed here is simple: while we don't
-                 * hit an open paren nor the bottom of the stack, pop
-                 * tokens and apply them */
-                if (stackptr[-1] == TOK_LPAREN) {
-                    --stackptr;
-                    /* Any operator directly after a */
-                    lasttok = TOK_NUM;
-                    /* close paren should consider itself binary */
-                    goto prologue;
+                if (op == TOK_RPAREN) {
+                    /* The algorithm employed here is simple: while we don't
+                     * hit an open paren nor the bottom of the stack, pop
+                     * tokens and apply them */
+                    if (stackptr[-1] == TOK_LPAREN) {
+                        --stackptr;
+                        /* Any operator directly after a */
+                        lasttok = TOK_NUM;
+                        /* close paren should consider itself binary */
+                        goto prologue;
+                    }
+                } else {
+                    operator prev_prec = PREC(stackptr[-1]);
+
+                    convert_prec_is_assing(prec);
+                    convert_prec_is_assing(prev_prec);
+                    if (prev_prec < prec)
+                        break;
+                    /* check right assoc */
+                    if (prev_prec == prec && is_right_associativity(prec))
+                        break;
                 }
-                } else {
-                operator prev_prec = PREC(stackptr[-1]);
-
-                convert_prec_is_assing(prec);
-                convert_prec_is_assing(prev_prec);
-                if (prev_prec < prec)
-                    break;
-                /* check right assoc */
-                if(prev_prec == prec && is_right_associativity(prec))
-                    break;
-                }
-                errcode = arith_apply(*--stackptr, numstack, &numstackptr);
-                if(errcode) goto ret;
+                errcode = arith_apply(*--stackptr, numstack, &numstackptr);
+                if (errcode) goto ret;
             }
             if (op == TOK_RPAREN) {
@@ -13651 +12553 @@
         /* Push this operator to the stack and remember it. */
         *stackptr++ = lasttok = op;
-
-      prologue:
+ prologue:
         ++expr;
-    }
-    }
-}
-#endif /* CONFIG_ASH_MATH_SUPPORT */
-
-
-#ifdef DEBUG
-const char *bb_applet_name = "debug stuff usage";
+    } /* while */
+}
+#endif /* ASH_MATH_SUPPORT */
+
+
+/* ============ main() and helpers */
+
+/*
+ * Called to exit the shell.
+ */
+static void exitshell(void) ATTRIBUTE_NORETURN;
+static void
+exitshell(void)
+{
+    struct jmploc loc;
+    char *p;
+    int status;
+
+    status = exitstatus;
+    TRACE(("pid %d, exitshell(%d)\n", getpid(), status));
+    if (setjmp(loc.loc)) {
+        if (exception == EXEXIT)
+/* dash bug: it just does _exit(exitstatus) here
+ * but we have to do setjobctl(0) first!
+ * (bug is still not fixed in dash-0.5.3 - if you run dash
+ * under Midnight Commander, on exit from dash MC is backgrounded) */
+            status = exitstatus;
+        goto out;
+    }
+    exception_handler = &loc;
+    p = trap[0];
+    if (p) {
+        trap[0] = NULL;
+        evalstring(p, 0);
+    }
+    flush_stdout_stderr();
+ out:
+    setjobctl(0);
+    _exit(status);
+    /* NOTREACHED */
+}
+
+static void
+init(void)
+{
+    /* from input.c: */
+    basepf.nextc = basepf.buf = basebuf;
+
+    /* from trap.c: */
+    signal(SIGCHLD, SIG_DFL);
+
+    /* from var.c: */
+    {
+        char **envp;
+        char ppid[sizeof(int)*3 + 1];
+        const char *p;
+        struct stat st1, st2;
+
+        initvar();
+        for (envp = environ; envp && *envp; envp++) {
+            if (strchr(*envp, '=')) {
+                setvareq(*envp, VEXPORT|VTEXTFIXED);
+            }
+        }
+
+        snprintf(ppid, sizeof(ppid), "%u", (unsigned) getppid());
+        setvar("PPID", ppid, 0);
+
+        p = lookupvar("PWD");
+        if (p)
+            if (*p != '/' || stat(p, &st1) || stat(".", &st2)
+             || st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino)
+                p = '\0';
+        setpwd(p, 0);
+    }
+}
+
+/*
+ * Process the shell command line arguments.
+ */
+static void
+procargs(int argc, char **argv)
+{
+    int i;
+    const char *xminusc;
+    char **xargv;
+
+    xargv = argv;
+    arg0 = xargv[0];
+    if (argc > 0)
+        xargv++;
+    for (i = 0; i < NOPTS; i++)
+        optlist[i] = 2;
+    argptr = xargv;
+    options(1);
+    xargv = argptr;
+    xminusc = minusc;
+    if (*xargv == NULL) {
+        if (xminusc)
+            ash_msg_and_raise_error(bb_msg_requires_arg, "-c");
+        sflag = 1;
+    }
+    if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
+        iflag = 1;
+    if (mflag == 2)
+        mflag = iflag;
+    for (i = 0; i < NOPTS; i++)
+        if (optlist[i] == 2)
+            optlist[i] = 0;
+#if DEBUG == 2
+    debug = 1;
+#endif
+    /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
+    if (xminusc) {
+        minusc = *xargv++;
+        if (*xargv)
+            goto setarg0;
+    } else if (!sflag) {
+        setinputfile(*xargv, 0);
+ setarg0:
+        arg0 = *xargv++;
+        commandname = arg0;
+    }
+
+    shellparam.p = xargv;
+#if ENABLE_ASH_GETOPTS
+    shellparam.optind = 1;
+    shellparam.optoff = -1;
+#endif
+    /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
+    while (*xargv) {
+        shellparam.nparam++;
+        xargv++;
+    }
+    optschanged();
+}
+
+/*
+ * Read /etc/profile or .profile.
+ */
+static void
+read_profile(const char *name)
+{
+    int skip;
+
+    if (setinputfile(name, INPUT_PUSH_FILE | INPUT_NOFILE_OK) < 0)
+        return;
+    skip = cmdloop(0);
+    popfile();
+    if (skip)
+        exitshell();
+}
+
+/*
+ * This routine is called when an error or an interrupt occurs in an
+ * interactive shell and control is returned to the main command loop.
+ */
+static void
+reset(void)
+{
+    /* from eval.c: */
+    evalskip = 0;
+    loopnest = 0;
+    /* from input.c: */
+    parselleft = parsenleft = 0;      /* clear input buffer */
+    popallfiles();
+    /* from parser.c: */
+    tokpushback = 0;
+    checkkwd = 0;
+    /* from redir.c: */
+    clearredir(0);
+}
+
+#if PROFILE
+static short profile_buf[16384];
+extern int etext();
+#endif
+
+/*
+ * Main routine.  We initialize things, parse the arguments, execute
+ * profiles if we're a login shell, and then call cmdloop to execute
+ * commands.  The setjmp call sets up the location to jump to when an
+ * exception occurs.  When an exception occurs the variable "state"
+ * is used to figure out how far we had gotten.
+ */
+int ash_main(int argc, char **argv);
+int ash_main(int argc, char **argv)
+{
+    char *shinit;
+    volatile int state;
+    struct jmploc jmploc;
+    struct stackmark smark;
+
+#if PROFILE
+    monitor(4, etext, profile_buf, sizeof(profile_buf), 50);
+#endif
+
+#if ENABLE_FEATURE_EDITING
+    line_input_state = new_line_input_t(FOR_SHELL | WITH_PATH_LOOKUP);
+#endif
+    state = 0;
+    if (setjmp(jmploc.loc)) {
+        int e;
+        int s;
+
+        reset();
+
+        e = exception;
+        if (e == EXERROR)
+            exitstatus = 2;
+        s = state;
+        if (e == EXEXIT || s == 0 || iflag == 0 || shlvl)
+            exitshell();
+
+        if (e == EXINT) {
+            outcslow('\n', stderr);
+        }
+        popstackmark(&smark);
+        FORCE_INT_ON; /* enable interrupts */
+        if (s == 1)
+            goto state1;
+        if (s == 2)
+            goto state2;
+        if (s == 3)
+            goto state3;
+        goto state4;
+    }
+    exception_handler = &jmploc;
+#if DEBUG
+    opentrace();
+    trace_puts("Shell args: ");
+    trace_puts_args(argv);
+#endif
+    rootpid = getpid();
+
+#if ENABLE_ASH_RANDOM_SUPPORT
+    rseed = rootpid + time(NULL);
+#endif
+    init();
+    setstackmark(&smark);
+    procargs(argc, argv);
+#if ENABLE_FEATURE_EDITING_SAVEHISTORY
+    if (iflag) {
+        const char *hp = lookupvar("HISTFILE");
+
+        if (hp == NULL) {
+            hp = lookupvar("HOME");
+            if (hp != NULL) {
+                char *defhp = concat_path_file(hp, ".ash_history");
+                setvar("HISTFILE", defhp, 0);
+                free(defhp);
+            }
+        }
+    }
+#endif
+    if (argv[0] && argv[0][0] == '-')
+        isloginsh = 1;
+    if (isloginsh) {
+        state = 1;
+        read_profile("/etc/profile");
+ state1:
+        state = 2;
+        read_profile(".profile");
+    }
+ state2:
+    state = 3;
+    if (
+#ifndef linux
+     getuid() == geteuid() && getgid() == getegid() &&
+#endif
+     iflag
+    ) {
+        shinit = lookupvar("ENV");
+        if (shinit != NULL && *shinit != '\0') {
+            read_profile(shinit);
+        }
+    }
+ state3:
+    state = 4;
+    if (minusc)
+        evalstring(minusc, 0);
+
+    if (sflag || minusc == NULL) {
+#if ENABLE_FEATURE_EDITING_SAVEHISTORY
+        if ( iflag ) {
+            const char *hp = lookupvar("HISTFILE");
+
+            if (hp != NULL)
+                line_input_state->hist_file = hp;
+        }
+#endif
+ state4: /* XXX ??? - why isn't this before the "if" statement */
+        cmdloop(1);
+    }
+#if PROFILE
+    monitor(0);
+#endif
+#ifdef GPROF
+    {
+        extern void _mcleanup(void);
+        _mcleanup();
+    }
+#endif
+    exitshell();
+    /* NOTREACHED */
+}
+
+#if DEBUG
+const char *applet_name = "debug stuff usage";
 int main(int argc, char **argv)
 {
@@ -13667 +12869 @@
 }
 #endif
+
 
 /*-

branches/2.2.5/mindi-busybox/shell/hush.c

@@ -21 +21 @@
  *
  * Other credits:
- *      simple_itoa() was lifted from boa-0.93.15
  *      b_addchr() derived from similar w_addchar function in glibc-2.2
  *      setup_redirect(), redirect_opt_num(), and big chunks of main()
- *        and many builtins derived from contributions by Erik Andersen
+ *      and many builtins derived from contributions by Erik Andersen
  *      miscellaneous bugfixes from Matt Kraai
  *
@@ -39 +38 @@
  *
  * Bash grammar not implemented: (how many of these were in original sh?)
- *      $@ (those sure look like weird quoting rules)
  *      $_
  *      ! negation operator for pipes
@@ -53 +51 @@
  *      Functions
  * Major bugs:
- *      job handling woefully incomplete and buggy
+ *      job handling woefully incomplete and buggy (improved --vda)
  *      reserved word execution woefully incomplete and buggy
  * to-do:
@@ -73 +71 @@
  *      more testing, especially quoting rules and redirection
  *      document how quoting rules not precisely followed for variable assignments
- *      maybe change map[] to use 2-bit entries
+ *      maybe change charmap[] to use 2-bit entries
  *      (eventually) remove all the printf's
  *
@@ -79 +77 @@
  */
 
-#include "busybox.h"
-#include <ctype.h>     /* isalpha, isdigit */
-#include <unistd.h>    /* getpid */
-#include <stdlib.h>    /* getenv, atoi */
-#include <string.h>    /* strchr */
-#include <stdio.h>     /* popen etc. */
+
 #include <glob.h>      /* glob, of course */
-#include <stdarg.h>    /* va_list */
-#include <errno.h>
-#include <fcntl.h>
 #include <getopt.h>    /* should be pretty obvious */
-
-#include <sys/stat.h>  /* ulimit */
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <signal.h>
-
 /* #include <dmalloc.h> */
-/* #define DEBUG_SHELL */
-
-#if 1
-#include "cmdedit.h"
-#else
-#define bb_applet_name "hush"
-//#include "standalone.h"
-#define hush_main main
-#undef CONFIG_FEATURE_SH_FANCY_PROMPT
-#define BB_BANNER ""
-#endif
-#define SPECIAL_VAR_SYMBOL 03
-#define FLAG_EXIT_FROM_LOOP 1
-#define FLAG_PARSE_SEMICOLON (1 << 1)       /* symbol ';' is special for parser */
-#define FLAG_REPARSING       (1 << 2)       /* >=2nd pass */
+
+extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */
+
+#include "busybox.h" /* for struct bb_applet */
+
+
+/* If you comment out one of these below, it will be #defined later
+ * to perform debug printfs to stderr: */
+#define debug_printf(...)        do {} while (0)
+/* Finer-grained debug switches */
+#define debug_printf_parse(...)  do {} while (0)
+#define debug_print_tree(a, b)   do {} while (0)
+#define debug_printf_exec(...)   do {} while (0)
+#define debug_printf_jobs(...)   do {} while (0)
+#define debug_printf_expand(...) do {} while (0)
+#define debug_printf_clean(...)  do {} while (0)
+
+#ifndef debug_printf
+#define debug_printf(...) fprintf(stderr, __VA_ARGS__)
+#endif
+
+#ifndef debug_printf_parse
+#define debug_printf_parse(...) fprintf(stderr, __VA_ARGS__)
+#endif
+
+#ifndef debug_printf_exec
+#define debug_printf_exec(...) fprintf(stderr, __VA_ARGS__)
+#endif
+
+#ifndef debug_printf_jobs
+#define debug_printf_jobs(...) fprintf(stderr, __VA_ARGS__)
+#define DEBUG_SHELL_JOBS 1
+#endif
+
+#ifndef debug_printf_expand
+#define debug_printf_expand(...) fprintf(stderr, __VA_ARGS__)
+#define DEBUG_EXPAND 1
+#endif
+
+/* Keep unconditionally on for now */
+#define ENABLE_HUSH_DEBUG 1
+
+#ifndef debug_printf_clean
+/* broken, of course, but OK for testing */
+static const char *indenter(int i)
+{
+    static const char blanks[] ALIGN1 =
+        "                                    ";
+    return &blanks[sizeof(blanks) - i - 1];
+}
+#define debug_printf_clean(...) fprintf(stderr, __VA_ARGS__)
+#define DEBUG_CLEAN 1
+#endif
+
+
+#if !ENABLE_HUSH_INTERACTIVE
+#undef ENABLE_FEATURE_EDITING
+#define ENABLE_FEATURE_EDITING 0
+#undef ENABLE_FEATURE_EDITING_FANCY_PROMPT
+#define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0
+#endif
+
+#define SPECIAL_VAR_SYMBOL   3
+
+#define PARSEFLAG_EXIT_FROM_LOOP 1
+#define PARSEFLAG_SEMICOLON      (1 << 1)  /* symbol ';' is special for parser */
+#define PARSEFLAG_REPARSING      (1 << 2)  /* >= 2nd pass */
 
 typedef enum {
@@ -123 +159 @@
 /* The descrip member of this structure is only used to make debugging
  * output pretty */
-static const struct {int mode; int default_fd; const char *descrip;} redir_table[] = {
+static const struct {
+    int mode;
+    signed char default_fd;
+    char descrip[3];
+} redir_table[] = {
     { 0,                         0, "()" },
     { O_RDONLY,                  0, "<"  },
@@ -142 +182 @@
 typedef enum {
     RES_NONE  = 0,
+#if ENABLE_HUSH_IF
     RES_IF    = 1,
     RES_THEN  = 2,
@@ -147 +188 @@
     RES_ELSE  = 4,
     RES_FI    = 5,
+#endif
+#if ENABLE_HUSH_LOOPS
     RES_FOR   = 6,
     RES_WHILE = 7,
@@ -152 +195 @@
     RES_DO    = 9,
     RES_DONE  = 10,
-    RES_XXXX  = 11,
-    RES_IN    = 12,
+    RES_IN    = 11,
+#endif
+    RES_XXXX  = 12,
     RES_SNTX  = 13
 } reserved_style;
-#define FLAG_END   (1<<RES_NONE)
-#define FLAG_IF    (1<<RES_IF)
-#define FLAG_THEN  (1<<RES_THEN)
-#define FLAG_ELIF  (1<<RES_ELIF)
-#define FLAG_ELSE  (1<<RES_ELSE)
-#define FLAG_FI    (1<<RES_FI)
-#define FLAG_FOR   (1<<RES_FOR)
-#define FLAG_WHILE (1<<RES_WHILE)
-#define FLAG_UNTIL (1<<RES_UNTIL)
-#define FLAG_DO    (1<<RES_DO)
-#define FLAG_DONE  (1<<RES_DONE)
-#define FLAG_IN    (1<<RES_IN)
-#define FLAG_START (1<<RES_XXXX)
+enum {
+    FLAG_END   = (1 << RES_NONE ),
+#if ENABLE_HUSH_IF
+    FLAG_IF    = (1 << RES_IF   ),
+    FLAG_THEN  = (1 << RES_THEN ),
+    FLAG_ELIF  = (1 << RES_ELIF ),
+    FLAG_ELSE  = (1 << RES_ELSE ),
+    FLAG_FI    = (1 << RES_FI   ),
+#endif
+#if ENABLE_HUSH_LOOPS
+    FLAG_FOR   = (1 << RES_FOR  ),
+    FLAG_WHILE = (1 << RES_WHILE),
+    FLAG_UNTIL = (1 << RES_UNTIL),
+    FLAG_DO    = (1 << RES_DO   ),
+    FLAG_DONE  = (1 << RES_DONE ),
+    FLAG_IN    = (1 << RES_IN   ),
+#endif
+    FLAG_START = (1 << RES_XXXX ),
+};
 
 /* This holds pointers to the various results of parsing */
@@ -176 +226 @@
     struct pipe *pipe;
     struct redir_struct *pending_redirect;
-    reserved_style w;
-    int old_flag;               /* for figuring out valid reserved words */
+    smallint res_w;
+    smallint parse_type;        /* bitmask of PARSEFLAG_xxx, defines type of parser : ";$" common or special symbol */
+    int old_flag;               /* bitmask of FLAG_xxx, for figuring out valid reserved words */
     struct p_context *stack;
-    int type;           /* define type of parser : ";$" common or special symbol */
     /* How about quoting status? */
 };
 
 struct redir_struct {
-    redir_type type;            /* type of redirection */
-    int fd;                     /* file descriptor being redirected */
-    int dup;                    /* -1, or file descriptor being duplicated */
-    struct redir_struct *next;  /* pointer to the next redirect in the list */
-    glob_t word;                /* *word.gl_pathv is the filename */
+    struct redir_struct *next;  /* pointer to the next redirect in the list */
+    redir_type type;            /* type of redirection */
+    int fd;                     /* file descriptor being redirected */
+    int dup;                    /* -1, or file descriptor being duplicated */
+    glob_t word;                /* *word.gl_pathv is the filename */
 };
 
 struct child_prog {
-    pid_t pid;                  /* 0 if exited */
-    char **argv;                /* program name and arguments */
-    struct pipe *group;         /* if non-NULL, first in group or subshell */
-    int subshell;               /* flag, non-zero if group must be forked */
-    struct redir_struct *redirects; /* I/O redirections */
-    glob_t glob_result;         /* result of parameter globbing */
-    int is_stopped;             /* is the program currently running? */
-    struct pipe *family;        /* pointer back to the child's parent pipe */
-    int sp;             /* number of SPECIAL_VAR_SYMBOL */
-    int type;
+    pid_t pid;                  /* 0 if exited */
+    char **argv;                /* program name and arguments */
+    struct pipe *group;         /* if non-NULL, first in group or subshell */
+    smallint subshell;          /* flag, non-zero if group must be forked */
+    smallint is_stopped;        /* is the program currently running? */
+    struct redir_struct *redirects; /* I/O redirections */
+    glob_t glob_result;         /* result of parameter globbing */
+    struct pipe *family;        /* pointer back to the child's parent pipe */
+    //sp counting seems to be broken... so commented out, grep for '//sp:'
+    //sp: int sp;               /* number of SPECIAL_VAR_SYMBOL */
+    //seems to be unused, grep for '//pt:'
+    //pt: int parse_type;
 };
+/* argv vector may contain variable references (^Cvar^C, ^C0^C etc)
+ * and on execution these are substituted with their values.
+ * Substitution can make _several_ words out of one argv[n]!
+ * Example: argv[0]=='.^C*^C.' here: echo .$*.
+ */
 
 struct pipe {
-    int jobid;                  /* job number */
-    int num_progs;              /* total number of programs in job */
-    int running_progs;          /* number of programs running */
-    char *text;                 /* name of job */
-    char *cmdbuf;               /* buffer various argv's point into */
-    pid_t pgrp;                 /* process group ID for the job */
-    struct child_prog *progs;   /* array of commands in pipe */
-    struct pipe *next;          /* to track background commands */
-    int stopped_progs;          /* number of programs alive, but stopped */
-    int job_context;            /* bitmask defining current context */
-    pipe_style followup;        /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
-    reserved_style r_mode;      /* supports if, for, while, until */
+    struct pipe *next;
+    int num_progs;              /* total number of programs in job */
+    int running_progs;          /* number of programs running (not exited) */
+    int stopped_progs;          /* number of programs alive, but stopped */
+#if ENABLE_HUSH_JOB
+    int jobid;                  /* job number */
+    pid_t pgrp;                 /* process group ID for the job */
+    char *cmdtext;              /* name of job */
+#endif
+    char *cmdbuf;               /* buffer various argv's point into */
+    struct child_prog *progs;   /* array of commands in pipe */
+    int job_context;            /* bitmask defining current context */
+    smallint followup;          /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
+    smallint res_word;          /* needed for if, for, while, until... */
 };
 
 struct close_me {
+    struct close_me *next;
     int fd;
-    struct close_me *next;
 };
 
-struct variables {
-    char *name;
-    char *value;
-    int flg_export;
-    int flg_read_only;
-    struct variables *next;
+/* On program start, environ points to initial environment.
+ * putenv adds new pointers into it, unsetenv removes them.
+ * Neither of these (de)allocates the strings.
+ * setenv allocates new strings in malloc space and does putenv,
+ * and thus setenv is unusable (leaky) for shell's purposes */
+#define setenv(...) setenv_is_leaky_dont_use()
+struct variable {
+    struct variable *next;
+    char *varstr;        /* points to "name=" portion */
+    int max_len;         /* if > 0, name is part of initial env; else name is malloced */
+    smallint flg_export; /* putenv should be done on this var */
+    smallint flg_read_only;
 };
-
-/* globals, connect us to the outside world
- * the first three support $?, $#, and $1 */
-static char **global_argv;
-static int global_argc;
-static int last_return_code;
-extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */
-
-/* "globals" within this file */
-static char *ifs;
-static unsigned char map[256];
-static int fake_mode;
-static int interactive;
-static struct close_me *close_me_head;
-static const char *cwd;
-static struct pipe *job_list;
-static unsigned int last_bg_pid;
-static int last_jobid;
-static unsigned int shell_terminal;
-static char *PS1;
-static char *PS2;
-static struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 };
-static struct variables *top_vars = &shell_ver;
-
-
-#define B_CHUNK (100)
-#define B_NOSPAC 1
 
 typedef struct {
@@ -267 +305 @@
 } o_string;
 #define NULL_O_STRING {NULL,0,0,0,0}
-/* used for initialization:
-    o_string foo = NULL_O_STRING; */
+/* used for initialization: o_string foo = NULL_O_STRING; */
 
 /* I can almost use ordinary FILE *.  Is open_memstream() universally
@@ -274 +311 @@
 struct in_str {
     const char *p;
+    /* eof_flag=1: last char in ->p is really an EOF */
+    char eof_flag; /* meaningless if ->p == NULL */
     char peek_buf[2];
-    int __promptme;
-    int promptmode;
+#if ENABLE_HUSH_INTERACTIVE
+    smallint promptme;
+    smallint promptmode; /* 0: PS1, 1: PS2 */
+#endif
     FILE *file;
     int (*get) (struct in_str *);
@@ -284 +325 @@
 #define b_peek(input) ((input)->peek(input))
 
+enum {
+    CHAR_ORDINARY           = 0,
+    CHAR_ORDINARY_IF_QUOTED = 1, /* example: *, # */
+    CHAR_IFS                = 2, /* treated as ordinary if quoted */
+    CHAR_SPECIAL            = 3, /* example: $ */
+};
+
+#define HUSH_VER_STR "0.02"
+
+/* "Globals" within this file */
+
+/* Sorted roughly by size (smaller offsets == smaller code) */
+struct globals {
+#if ENABLE_HUSH_INTERACTIVE
+    /* 'interactive_fd' is a fd# open to ctty, if we have one
+     * _AND_ if we decided to act interactively */
+    int interactive_fd;
+    const char *PS1;
+    const char *PS2;
+#endif
+#if ENABLE_FEATURE_EDITING
+    line_input_t *line_input_state;
+#endif
+#if ENABLE_HUSH_JOB
+    int run_list_level;
+    pid_t saved_task_pgrp;
+    pid_t saved_tty_pgrp;
+    int last_jobid;
+    struct pipe *job_list;
+    struct pipe *toplevel_list;
+    smallint ctrl_z_flag;
+#endif
+    smallint fake_mode;
+    /* these three support $?, $#, and $1 */
+    char **global_argv;
+    int global_argc;
+    int last_return_code;
+    const char *ifs;
+    struct close_me *close_me_head;
+    const char *cwd;
+    unsigned last_bg_pid;
+    struct variable *top_var; /* = &shell_ver (set in main()) */
+    struct variable shell_ver;
+#if ENABLE_FEATURE_SH_STANDALONE
+    struct nofork_save_area nofork_save;
+#endif
+#if ENABLE_HUSH_JOB
+    sigjmp_buf toplevel_jb;
+#endif
+    unsigned char charmap[256];
+    char user_input_buf[ENABLE_FEATURE_EDITING ? BUFSIZ : 2];
+};
+
+#define G (*ptr_to_globals)
+
+#if !ENABLE_HUSH_INTERACTIVE
+enum { interactive_fd = 0 };
+#endif
+#if !ENABLE_HUSH_JOB
+enum { run_list_level = 0 };
+#endif
+
+#if ENABLE_HUSH_INTERACTIVE
+#define interactive_fd   (G.interactive_fd  )
+#define PS1              (G.PS1             )
+#define PS2              (G.PS2             )
+#endif
+#if ENABLE_FEATURE_EDITING
+#define line_input_state (G.line_input_state)
+#endif
+#if ENABLE_HUSH_JOB
+#define run_list_level   (G.run_list_level  )
+#define saved_task_pgrp  (G.saved_task_pgrp )
+#define saved_tty_pgrp   (G.saved_tty_pgrp  )
+#define last_jobid       (G.last_jobid      )
+#define job_list         (G.job_list        )
+#define toplevel_list    (G.toplevel_list   )
+#define toplevel_jb      (G.toplevel_jb     )
+#define ctrl_z_flag      (G.ctrl_z_flag     )
+#endif /* JOB */
+#define global_argv      (G.global_argv     )
+#define global_argc      (G.global_argc     )
+#define last_return_code (G.last_return_code)
+#define ifs              (G.ifs             )
+#define fake_mode        (G.fake_mode       )
+#define close_me_head    (G.close_me_head   )
+#define cwd              (G.cwd             )
+#define last_bg_pid      (G.last_bg_pid     )
+#define top_var          (G.top_var         )
+#define shell_ver        (G.shell_ver       )
+#if ENABLE_FEATURE_SH_STANDALONE
+#define nofork_save      (G.nofork_save     )
+#endif
+#if ENABLE_HUSH_JOB
+#define toplevel_jb      (G.toplevel_jb     )
+#endif
+#define charmap          (G.charmap         )
+#define user_input_buf   (G.user_input_buf  )
+
+
+#define B_CHUNK  100
+#define B_NOSPAC 1
 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
 
-struct built_in_command {
-    const char *cmd;            /* name */
-    const char *descr;          /* description */
-    int (*function) (struct child_prog *);  /* function ptr */
-};
-
-/* belongs in busybox.h */
-static inline int max(int a, int b) {
-    return (a>b)?a:b;
-}
-
-/* This should be in utility.c */
-#ifdef DEBUG_SHELL
-static void debug_printf(const char *format, ...)
-{
-    va_list args;
-    va_start(args, format);
-    vfprintf(stderr, format, args);
-    va_end(args);
-}
+#if 1
+/* Normal */
+static void syntax(const char *msg)
+{
+    /* Was using fancy stuff:
+     * (interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
+     * but it SEGVs. ?! Oh well... explicit temp ptr works around that */
+    void (*fp)(const char *s, ...);
+
+    fp = (interactive_fd ? bb_error_msg : bb_error_msg_and_die);
+    fp(msg ? "%s: %s" : "syntax error", "syntax error", msg);
+}
+
 #else
-static inline void debug_printf(const char *format ATTRIBUTE_UNUSED, ...) { }
-#endif
-#define final_printf debug_printf
-
-static void __syntax(char *file, int line) {
-    bb_error_msg("syntax error %s:%d", file, line);
-}
-#define syntax() __syntax(__FILE__, __LINE__)
+/* Debug */
+static void syntax_lineno(int line)
+{
+    void (*fp)(const char *s, ...);
+
+    fp = (interactive_fd ? bb_error_msg : bb_error_msg_and_die);
+    fp("syntax error hush.c:%d", line);
+}
+#define syntax(str) syntax_lineno(__LINE__)
+#endif
 
 /* Index of subroutines: */
 /*   function prototypes for builtins */
-static int builtin_cd(struct child_prog *child);
-static int builtin_env(struct child_prog *child);
-static int builtin_eval(struct child_prog *child);
-static int builtin_exec(struct child_prog *child);
-static int builtin_exit(struct child_prog *child);
-static int builtin_export(struct child_prog *child);
-static int builtin_fg_bg(struct child_prog *child);
-static int builtin_help(struct child_prog *child);
-static int builtin_jobs(struct child_prog *child);
-static int builtin_pwd(struct child_prog *child);
-static int builtin_read(struct child_prog *child);
-static int builtin_set(struct child_prog *child);
-static int builtin_shift(struct child_prog *child);
-static int builtin_source(struct child_prog *child);
-static int builtin_umask(struct child_prog *child);
-static int builtin_unset(struct child_prog *child);
-static int builtin_not_written(struct child_prog *child);
+static int builtin_cd(char **argv);
+static int builtin_eval(char **argv);
+static int builtin_exec(char **argv);
+static int builtin_exit(char **argv);
+static int builtin_export(char **argv);
+#if ENABLE_HUSH_JOB
+static int builtin_fg_bg(char **argv);
+static int builtin_jobs(char **argv);
+#endif
+#if ENABLE_HUSH_HELP
+static int builtin_help(char **argv);
+#endif
+static int builtin_pwd(char **argv);
+static int builtin_read(char **argv);
+static int builtin_set(char **argv);
+static int builtin_shift(char **argv);
+static int builtin_source(char **argv);
+static int builtin_umask(char **argv);
+static int builtin_unset(char **argv);
+//static int builtin_not_written(char **argv);
 /*   o_string manipulation: */
 static int b_check_space(o_string *o, int len);
@@ -340 +481 @@
 static void b_reset(o_string *o);
 static int b_addqchr(o_string *o, int ch, int quote);
-static int b_adduint(o_string *o, unsigned int i);
 /*  in_str manipulations: */
 static int static_get(struct in_str *i);
@@ -353 +493 @@
 static void close_all(void);
 /*  "run" the final data structures: */
-static char *indenter(int i);
+#if !defined(DEBUG_CLEAN)
+#define free_pipe_list(head, indent) free_pipe_list(head)
+#define free_pipe(pi, indent)        free_pipe(pi)
+#endif
 static int free_pipe_list(struct pipe *head, int indent);
 static int free_pipe(struct pipe *pi, int indent);
@@ -359 +502 @@
 static int setup_redirects(struct child_prog *prog, int squirrel[]);
 static int run_list_real(struct pipe *pi);
+static void pseudo_exec_argv(char **argv) ATTRIBUTE_NORETURN;
 static void pseudo_exec(struct child_prog *child) ATTRIBUTE_NORETURN;
 static int run_pipe_real(struct pipe *pi);
@@ -376 +520 @@
 static int redirect_dup_num(struct in_str *input);
 static int redirect_opt_num(o_string *o);
-static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end);
+#if ENABLE_HUSH_TICK
+static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, const char *subst_end);
+#endif
 static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch);
-static char *lookup_param(char *src);
-static char *make_string(char **inp);
+static const char *lookup_param(const char *src);
 static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input);
-static int parse_string(o_string *dest, struct p_context *ctx, const char *src);
-static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, int end_trigger);
+static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, const char *end_trigger);
 /*   setup: */
-static int parse_stream_outer(struct in_str *inp, int flag);
-static int parse_string_outer(const char *s, int flag);
-static int parse_file_outer(FILE *f);
+static int parse_and_run_stream(struct in_str *inp, int parse_flag);
+static int parse_and_run_string(const char *s, int parse_flag);
+static int parse_and_run_file(FILE *f);
 /*   job management: */
 static int checkjobs(struct pipe* fg_pipe);
+#if ENABLE_HUSH_JOB
+static int checkjobs_and_fg_shell(struct pipe* fg_pipe);
 static void insert_bg_job(struct pipe *pi);
 static void remove_bg_job(struct pipe *pi);
+static void delete_finished_bg_job(struct pipe *pi);
+#else
+int checkjobs_and_fg_shell(struct pipe* fg_pipe); /* never called */
+#endif
 /*     local variable support */
-static char **make_list_in(char **inp, char *name);
-static char *insert_var_value(char *inp);
-static char *get_local_var(const char *var);
-static void  unset_local_var(const char *name);
-static int set_local_var(const char *s, int flg_export);
+static char **expand_strvec_to_strvec(char **argv);
+/* used for eval */
+static char *expand_strvec_to_string(char **argv);
+/* used for expansion of right hand of assignments */
+static char *expand_string_to_string(const char *str);
+static struct variable *get_local_var(const char *name);
+static int set_local_var(char *str, int flg_export);
+static void unset_local_var(const char *name);
 
 /* Table of built-in functions.  They can be forked or not, depending on
  * context: within pipes, they fork.  As simple commands, they do not.
  * When used in non-forking context, they can change global variables
- * in the parent shell process.  If forked, of course they can not.
+ * in the parent shell process.  If forked, of course they cannot.
  * For example, 'unset foo | whatever' will parse and run, but foo will
  * still be set at the end. */
+struct built_in_command {
+    const char *cmd;                /* name */
+    int (*function) (char **argv);  /* function ptr */
+#if ENABLE_HUSH_HELP
+    const char *descr;              /* description */
+#define BLTIN(cmd, func, help) { cmd, func, help }
+#else
+#define BLTIN(cmd, func, help) { cmd, func }
+#endif
+};
+
 static const struct built_in_command bltins[] = {
-    {"bg", "Resume a job in the background", builtin_fg_bg},
-    {"break", "Exit for, while or until loop", builtin_not_written},
-    {"cd", "Change working directory", builtin_cd},
-    {"continue", "Continue for, while or until loop", builtin_not_written},
-    {"env", "Print all environment variables", builtin_env},
-    {"eval", "Construct and run shell command", builtin_eval},
-    {"exec", "Exec command, replacing this shell with the exec'd process",
-        builtin_exec},
-    {"exit", "Exit from shell()", builtin_exit},
-    {"export", "Set environment variable", builtin_export},
-    {"fg", "Bring job into the foreground", builtin_fg_bg},
-    {"jobs", "Lists the active jobs", builtin_jobs},
-    {"pwd", "Print current directory", builtin_pwd},
-    {"read", "Input environment variable", builtin_read},
-    {"return", "Return from a function", builtin_not_written},
-    {"set", "Set/unset shell local variables", builtin_set},
-    {"shift", "Shift positional parameters", builtin_shift},
-    {"trap", "Trap signals", builtin_not_written},
-    {"ulimit","Controls resource limits", builtin_not_written},
-    {"umask","Sets file creation mask", builtin_umask},
-    {"unset", "Unset environment variable", builtin_unset},
-    {".", "Source-in and run commands in a file", builtin_source},
-    {"help", "List shell built-in commands", builtin_help},
-    {NULL, NULL, NULL}
+#if ENABLE_HUSH_JOB
+    BLTIN("bg"    , builtin_fg_bg, "Resume a job in the background"),
+#endif
+//  BLTIN("break" , builtin_not_written, "Exit for, while or until loop"),
+    BLTIN("cd"    , builtin_cd, "Change working directory"),
+//  BLTIN("continue", builtin_not_written, "Continue for, while or until loop"),
+    BLTIN("eval"  , builtin_eval, "Construct and run shell command"),
+    BLTIN("exec"  , builtin_exec, "Exec command, replacing this shell with the exec'd process"),
+    BLTIN("exit"  , builtin_exit, "Exit from shell"),
+    BLTIN("export", builtin_export, "Set environment variable"),
+#if ENABLE_HUSH_JOB
+    BLTIN("fg"    , builtin_fg_bg, "Bring job into the foreground"),
+    BLTIN("jobs"  , builtin_jobs, "Lists the active jobs"),
+#endif
+// TODO: remove pwd? we have it as an applet...
+    BLTIN("pwd"   , builtin_pwd, "Print current directory"),
+    BLTIN("read"  , builtin_read, "Input environment variable"),
+//  BLTIN("return", builtin_not_written, "Return from a function"),
+    BLTIN("set"   , builtin_set, "Set/unset shell local variables"),
+    BLTIN("shift" , builtin_shift, "Shift positional parameters"),
+//  BLTIN("trap"  , builtin_not_written, "Trap signals"),
+//  BLTIN("ulimit", builtin_not_written, "Controls resource limits"),
+    BLTIN("umask" , builtin_umask, "Sets file creation mask"),
+    BLTIN("unset" , builtin_unset, "Unset environment variable"),
+    BLTIN("."     , builtin_source, "Source-in and run commands in a file"),
+#if ENABLE_HUSH_HELP
+    BLTIN("help"  , builtin_help, "List shell built-in commands"),
+#endif
+    BLTIN(NULL, NULL, NULL)
 };
 
+#if ENABLE_HUSH_JOB
+
+/* move to libbb? */
+static void signal_SA_RESTART(int sig, void (*handler)(int))
+{
+    struct sigaction sa;
+    sa.sa_handler = handler;
+    sa.sa_flags = SA_RESTART;
+    sigemptyset(&sa.sa_mask);
+    sigaction(sig, &sa, NULL);
+}
+
+/* Signals are grouped, we handle them in batches */
+static void set_fatal_sighandler(void (*handler)(int))
+{
+    signal(SIGILL , handler);
+    signal(SIGTRAP, handler);
+    signal(SIGABRT, handler);
+    signal(SIGFPE , handler);
+    signal(SIGBUS , handler);
+    signal(SIGSEGV, handler);
+    /* bash 3.2 seems to handle these just like 'fatal' ones */
+    signal(SIGHUP , handler);
+    signal(SIGPIPE, handler);
+    signal(SIGALRM, handler);
+}
+static void set_jobctrl_sighandler(void (*handler)(int))
+{
+    signal(SIGTSTP, handler);
+    signal(SIGTTIN, handler);
+    signal(SIGTTOU, handler);
+}
+static void set_misc_sighandler(void (*handler)(int))
+{
+    signal(SIGINT , handler);
+    signal(SIGQUIT, handler);
+    signal(SIGTERM, handler);
+}
+/* SIGCHLD is special and handled separately */
+
+static void set_every_sighandler(void (*handler)(int))
+{
+    set_fatal_sighandler(handler);
+    set_jobctrl_sighandler(handler);
+    set_misc_sighandler(handler);
+    signal(SIGCHLD, handler);
+}
+
+static void handler_ctrl_c(int sig)
+{
+    debug_printf_jobs("got sig %d\n", sig);
+// as usual we can have all kinds of nasty problems with leaked malloc data here
+    siglongjmp(toplevel_jb, 1);
+}
+
+static void handler_ctrl_z(int sig)
+{
+    pid_t pid;
+
+    debug_printf_jobs("got tty sig %d in pid %d\n", sig, getpid());
+    pid = fork();
+    if (pid < 0) /* can't fork. Pretend there was no ctrl-Z */
+        return;
+    ctrl_z_flag = 1;
+    if (!pid) { /* child */
+        setpgrp();
+        debug_printf_jobs("set pgrp for child %d ok\n", getpid());
+        set_every_sighandler(SIG_DFL);
+        raise(SIGTSTP); /* resend TSTP so that child will be stopped */
+        debug_printf_jobs("returning in child\n");
+        /* return to nofork, it will eventually exit now,
+         * not return back to shell */
+        return;
+    }
+    /* parent */
+    /* finish filling up pipe info */
+    toplevel_list->pgrp = pid; /* child is in its own pgrp */
+    toplevel_list->progs[0].pid = pid;
+    /* parent needs to longjmp out of running nofork.
+     * we will "return" exitcode 0, with child put in background */
+// as usual we can have all kinds of nasty problems with leaked malloc data here
+    debug_printf_jobs("siglongjmp in parent\n");
+    siglongjmp(toplevel_jb, 1);
+}
+
+/* Restores tty foreground process group, and exits.
+ * May be called as signal handler for fatal signal
+ * (will faithfully resend signal to itself, producing correct exit state)
+ * or called directly with -EXITCODE.
+ * We also call it if xfunc is exiting. */
+static void sigexit(int sig) ATTRIBUTE_NORETURN;
+static void sigexit(int sig)
+{
+    sigset_t block_all;
+
+    /* Disable all signals: job control, SIGPIPE, etc. */
+    sigfillset(&block_all);
+    sigprocmask(SIG_SETMASK, &block_all, NULL);
+
+    if (interactive_fd)
+        tcsetpgrp(interactive_fd, saved_tty_pgrp);
+
+    /* Not a signal, just exit */
+    if (sig <= 0)
+        _exit(- sig);
+
+    /* Enable only this sig and kill ourself with it */
+    signal(sig, SIG_DFL);
+    sigdelset(&block_all, sig);
+    sigprocmask(SIG_SETMASK, &block_all, NULL);
+    raise(sig);
+    _exit(1); /* Should not reach it */
+}
+
+/* Restores tty foreground process group, and exits. */
+static void hush_exit(int exitcode) ATTRIBUTE_NORETURN;
+static void hush_exit(int exitcode)
+{
+    fflush(NULL); /* flush all streams */
+    sigexit(- (exitcode & 0xff));
+}
+
+#else /* !JOB */
+
+#define set_fatal_sighandler(handler)   ((void)0)
+#define set_jobctrl_sighandler(handler) ((void)0)
+#define set_misc_sighandler(handler)    ((void)0)
+#define hush_exit(e)                    exit(e)
+
+#endif /* JOB */
+
+
 static const char *set_cwd(void)
 {
-    if(cwd==bb_msg_unknown)
-        cwd = NULL;     /* xgetcwd(arg) called free(arg) */
-    cwd = xgetcwd((char *)cwd);
+    if (cwd == bb_msg_unknown)
+        cwd = NULL;     /* xrealloc_getcwd_or_warn(arg) calls free(arg)! */
+    cwd = xrealloc_getcwd_or_warn((char *)cwd);
     if (!cwd)
         cwd = bb_msg_unknown;
@@ -442 +743 @@
 
 /* built-in 'eval' handler */
-static int builtin_eval(struct child_prog *child)
-{
-    char *str = NULL;
+static int builtin_eval(char **argv)
+{
     int rcode = EXIT_SUCCESS;
 
-    if (child->argv[1]) {
-        str = make_string(child->argv + 1);
-        parse_string_outer(str, FLAG_EXIT_FROM_LOOP |
-                    FLAG_PARSE_SEMICOLON);
+    if (argv[1]) {
+        char *str = expand_strvec_to_string(argv + 1);
+        parse_and_run_string(str, PARSEFLAG_EXIT_FROM_LOOP |
+                    PARSEFLAG_SEMICOLON);
         free(str);
         rcode = last_return_code;
@@ -458 +758 @@
 
 /* built-in 'cd <path>' handler */
-static int builtin_cd(struct child_prog *child)
-{
-    char *newdir;
-    if (child->argv[1] == NULL)
-        newdir = getenv("HOME");
+static int builtin_cd(char **argv)
+{
+    const char *newdir;
+    if (argv[1] == NULL)
+        newdir = getenv("HOME") ? : "/";
     else
-        newdir = child->argv[1];
+        newdir = argv[1];
     if (chdir(newdir)) {
         printf("cd: %s: %s\n", newdir, strerror(errno));
@@ -473 +773 @@
 }
 
-/* built-in 'env' handler */
-static int builtin_env(struct child_prog *dummy ATTRIBUTE_UNUSED)
-{
-    char **e = environ;
-    if (e == NULL) return EXIT_FAILURE;
-    for (; *e; e++) {
-        puts(*e);
-    }
+/* built-in 'exec' handler */
+static int builtin_exec(char **argv)
+{
+    if (argv[1] == NULL)
+        return EXIT_SUCCESS;   /* Really? */
+    pseudo_exec_argv(argv + 1);
+    /* never returns */
+}
+
+/* built-in 'exit' handler */
+static int builtin_exit(char **argv)
+{
+// TODO: bash does it ONLY on top-level sh exit (+interacive only?)
+    //puts("exit"); /* bash does it */
+// TODO: warn if we have background jobs: "There are stopped jobs"
+// On second consecutive 'exit', exit anyway.
+
+    if (argv[1] == NULL)
+        hush_exit(last_return_code);
+    /* mimic bash: exit 123abc == exit 255 + error msg */
+    xfunc_error_retval = 255;
+    /* bash: exit -2 == exit 254, no error msg */
+    hush_exit(xatoi(argv[1]) & 0xff);
+}
+
+/* built-in 'export VAR=value' handler */
+static int builtin_export(char **argv)
+{
+    const char *value;
+    char *name = argv[1];
+
+    if (name == NULL) {
+        // TODO:
+        // ash emits: export VAR='VAL'
+        // bash: declare -x VAR="VAL"
+        // (both also escape as needed (quotes, $, etc))
+        char **e = environ;
+        if (e)
+            while (*e)
+                puts(*e++);
+        return EXIT_SUCCESS;
+    }
+
+    value = strchr(name, '=');
+    if (!value) {
+        /* They are exporting something without a =VALUE */
+        struct variable *var;
+
+        var = get_local_var(name);
+        if (var) {
+            var->flg_export = 1;
+            putenv(var->varstr);
+        }
+        /* bash does not return an error when trying to export
+         * an undefined variable.  Do likewise. */
+        return EXIT_SUCCESS;
+    }
+
+    set_local_var(xstrdup(name), 1);
     return EXIT_SUCCESS;
 }
 
-/* built-in 'exec' handler */
-static int builtin_exec(struct child_prog *child)
-{
-    if (child->argv[1] == NULL)
-        return EXIT_SUCCESS;   /* Really? */
-    child->argv++;
-    pseudo_exec(child);
-    /* never returns */
-}
-
-/* built-in 'exit' handler */
-static int builtin_exit(struct child_prog *child)
-{
-    if (child->argv[1] == NULL)
-        exit(last_return_code);
-    exit (atoi(child->argv[1]));
-}
-
-/* built-in 'export VAR=value' handler */
-static int builtin_export(struct child_prog *child)
-{
-    int res = 0;
-    char *name = child->argv[1];
-
-    if (name == NULL) {
-        return (builtin_env(child));
-    }
-
-    name = strdup(name);
-
-    if(name) {
-        char *value = strchr(name, '=');
-
-        if (!value) {
-            char *tmp;
-            /* They are exporting something without an =VALUE */
-
-            value = get_local_var(name);
-            if (value) {
-                size_t ln = strlen(name);
-
-                tmp = realloc(name, ln+strlen(value)+2);
-                if(tmp==NULL)
-                    res = -1;
-                else {
-                    sprintf(tmp+ln, "=%s", value);
-                    name = tmp;
-                }
-            } else {
-                /* bash does not return an error when trying to export
-                 * an undefined variable.  Do likewise. */
-                res = 1;
-            }
-        }
-    }
-    if (res<0)
-        bb_perror_msg("export");
-    else if(res==0)
-        res = set_local_var(name, 1);
-    else
-        res = 0;
-    free(name);
-    return res;
-}
-
+#if ENABLE_HUSH_JOB
 /* built-in 'fg' and 'bg' handler */
-static int builtin_fg_bg(struct child_prog *child)
+static int builtin_fg_bg(char **argv)
 {
     int i, jobnum;
-    struct pipe *pi=NULL;
-
-    if (!interactive)
+    struct pipe *pi;
+
+    if (!interactive_fd)
         return EXIT_FAILURE;
     /* If they gave us no args, assume they want the last backgrounded task */
-    if (!child->argv[1]) {
+    if (!argv[1]) {
         for (pi = job_list; pi; pi = pi->next) {
             if (pi->jobid == last_jobid) {
-                break;
-            }
-        }
-        if (!pi) {
-            bb_error_msg("%s: no current job", child->argv[0]);
-            return EXIT_FAILURE;
-        }
-    } else {
-        if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
-            bb_error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
-            return EXIT_FAILURE;
-        }
-        for (pi = job_list; pi; pi = pi->next) {
-            if (pi->jobid == jobnum) {
-                break;
-            }
-        }
-        if (!pi) {
-            bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
-            return EXIT_FAILURE;
-        }
-    }
-
-    if (*child->argv[0] == 'f') {
+                goto found;
+            }
+        }
+        bb_error_msg("%s: no current job", argv[0]);
+        return EXIT_FAILURE;
+    }
+    if (sscanf(argv[1], "%%%d", &jobnum) != 1) {
+        bb_error_msg("%s: bad argument '%s'", argv[0], argv[1]);
+        return EXIT_FAILURE;
+    }
+    for (pi = job_list; pi; pi = pi->next) {
+        if (pi->jobid == jobnum) {
+            goto found;
+        }
+    }
+    bb_error_msg("%s: %d: no such job", argv[0], jobnum);
+    return EXIT_FAILURE;
+ found:
+    // TODO: bash prints a string representation
+    // of job being foregrounded (like "sleep 1 | cat")
+    if (*argv[0] == 'f') {
         /* Put the job into the foreground.  */
-        tcsetpgrp(shell_terminal, pi->pgrp);
+        tcsetpgrp(interactive_fd, pi->pgrp);
     }
 
     /* Restart the processes in the job */
-    for (i = 0; i < pi->num_progs; i++)
+    debug_printf_jobs("reviving %d procs, pgrp %d\n", pi->num_progs, pi->pgrp);
+    for (i = 0; i < pi->num_progs; i++) {
+        debug_printf_jobs("reviving pid %d\n", pi->progs[i].pid);
         pi->progs[i].is_stopped = 0;
-
-    if ( (i=kill(- pi->pgrp, SIGCONT)) < 0) {
-        if (i == ESRCH) {
-            remove_bg_job(pi);
+    }
+    pi->stopped_progs = 0;
+
+    i = kill(- pi->pgrp, SIGCONT);
+    if (i < 0) {
+        if (errno == ESRCH) {
+            delete_finished_bg_job(pi);
+            return EXIT_SUCCESS;
         } else {
             bb_perror_msg("kill (SIGCONT)");
@@ -601 +891 @@
     }
 
-    pi->stopped_progs = 0;
+    if (*argv[0] == 'f') {
+        remove_bg_job(pi);
+        return checkjobs_and_fg_shell(pi);
+    }
     return EXIT_SUCCESS;
 }
+#endif
 
 /* built-in 'help' handler */
-static int builtin_help(struct child_prog *dummy ATTRIBUTE_UNUSED)
+#if ENABLE_HUSH_HELP
+static int builtin_help(char **argv ATTRIBUTE_UNUSED)
 {
     const struct built_in_command *x;
@@ -613 +908 @@
     printf("-------------------\n");
     for (x = bltins; x->cmd; x++) {
-        if (x->descr==NULL)
-            continue;
         printf("%s\t%s\n", x->cmd, x->descr);
     }
@@ -620 +913 @@
     return EXIT_SUCCESS;
 }
-
+#endif
+
+#if ENABLE_HUSH_JOB
 /* built-in 'jobs' handler */
-static int builtin_jobs(struct child_prog *child ATTRIBUTE_UNUSED)
+static int builtin_jobs(char **argv ATTRIBUTE_UNUSED)
 {
     struct pipe *job;
-    char *status_string;
+    const char *status_string;
 
     for (job = job_list; job; job = job->next) {
@@ -633 +928 @@
             status_string = "Running";
 
-        printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
+        printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->cmdtext);
     }
     return EXIT_SUCCESS;
 }
-
+#endif
 
 /* built-in 'pwd' handler */
-static int builtin_pwd(struct child_prog *dummy ATTRIBUTE_UNUSED)
+static int builtin_pwd(char **argv ATTRIBUTE_UNUSED)
 {
     puts(set_cwd());
@@ -647 +942 @@
 
 /* built-in 'read VAR' handler */
-static int builtin_read(struct child_prog *child)
-{
-    int res;
-
-    if (child->argv[1]) {
-        char string[BUFSIZ];
-        char *var = 0;
-
-        string[0] = 0;  /* In case stdin has only EOF */
-        /* read string */
-        fgets(string, sizeof(string), stdin);
-        chomp(string);
-        var = malloc(strlen(child->argv[1])+strlen(string)+2);
-        if(var) {
-            sprintf(var, "%s=%s", child->argv[1], string);
-            res = set_local_var(var, 0);
-        } else
-            res = -1;
-        if (res)
-            bb_perror_msg("read");
-        free(var);      /* So not move up to avoid breaking errno */
-        return res;
-    } else {
-        do res=getchar(); while(res!='\n' && res!=EOF);
-        return 0;
-    }
-}
-
-/* built-in 'set VAR=value' handler */
-static int builtin_set(struct child_prog *child)
-{
-    char *temp = child->argv[1];
-    struct variables *e;
+static int builtin_read(char **argv)
+{
+    char *string;
+    const char *name = argv[1] ? argv[1] : "REPLY";
+
+    string = xmalloc_reads(STDIN_FILENO, xasprintf("%s=", name));
+    return set_local_var(string, 0);
+}
+
+/* built-in 'set [VAR=value]' handler */
+static int builtin_set(char **argv)
+{
+    char *temp = argv[1];
+    struct variable *e;
 
     if (temp == NULL)
-        for(e = top_vars; e; e=e->next)
-            printf("%s=%s\n", e->name, e->value);
+        for (e = top_var; e; e = e->next)
+            puts(e->varstr);
     else
-        set_local_var(temp, 0);
-
-        return EXIT_SUCCESS;
+        set_local_var(xstrdup(temp), 0);
+
+    return EXIT_SUCCESS;
 }
 
 
 /* Built-in 'shift' handler */
-static int builtin_shift(struct child_prog *child)
-{
-    int n=1;
-    if (child->argv[1]) {
-        n=atoi(child->argv[1]);
-    }
-    if (n>=0 && n<global_argc) {
-        /* XXX This probably breaks $0 */
+static int builtin_shift(char **argv)
+{
+    int n = 1;
+    if (argv[1]) {
+        n = atoi(argv[1]);
+    }
+    if (n >= 0 && n < global_argc) {
+        global_argv[n] = global_argv[0];
         global_argc -= n;
         global_argv += n;
         return EXIT_SUCCESS;
-    } else {
-        return EXIT_FAILURE;
-    }
+    }
+    return EXIT_FAILURE;
 }
 
 /* Built-in '.' handler (read-in and execute commands from file) */
-static int builtin_source(struct child_prog *child)
+static int builtin_source(char **argv)
 {
     FILE *input;
     int status;
 
-    if (child->argv[1] == NULL)
+    if (argv[1] == NULL)
         return EXIT_FAILURE;
 
     /* XXX search through $PATH is missing */
-    input = fopen(child->argv[1], "r");
+    input = fopen(argv[1], "r");
     if (!input) {
-        bb_error_msg("Couldn't open file '%s'", child->argv[1]);
+        bb_error_msg("cannot open '%s'", argv[1]);
         return EXIT_FAILURE;
     }
@@ -727 +1002 @@
     /* XXX argv and argc are broken; need to save old global_argv
      * (pointer only is OK!) on this stack frame,
-     * set global_argv=child->argv+1, recurse, and restore. */
+     * set global_argv=argv+1, recurse, and restore. */
     mark_open(fileno(input));
-    status = parse_file_outer(input);
+    status = parse_and_run_file(input);
     mark_closed(fileno(input));
     fclose(input);
-    return (status);
-}
-
-static int builtin_umask(struct child_prog *child)
+    return status;
+}
+
+static int builtin_umask(char **argv)
 {
     mode_t new_umask;
-    const char *arg = child->argv[1];
+    const char *arg = argv[1];
     char *end;
     if (arg) {
-        new_umask=strtoul(arg, &end, 8);
-        if (*end!='\0' || end == arg) {
+        new_umask = strtoul(arg, &end, 8);
+        if (*end != '\0' || end == arg) {
             return EXIT_FAILURE;
         }
     } else {
-        printf("%.3o\n", (unsigned int) (new_umask=umask(0)));
+        new_umask = umask(0);
+        printf("%.3o\n", (unsigned) new_umask);
     }
     umask(new_umask);
@@ -753 +1029 @@
 
 /* built-in 'unset VAR' handler */
-static int builtin_unset(struct child_prog *child)
-{
-    /* bash returned already true */
-    unset_local_var(child->argv[1]);
+static int builtin_unset(char **argv)
+{
+    /* bash always returns true */
+    unset_local_var(argv[1]);
     return EXIT_SUCCESS;
 }
 
-static int builtin_not_written(struct child_prog *child)
-{
-    printf("builtin_%s not written\n",child->argv[0]);
-    return EXIT_FAILURE;
-}
+//static int builtin_not_written(char **argv)
+//{
+//  printf("builtin_%s not written\n", argv[0]);
+//  return EXIT_FAILURE;
+//}
 
 static int b_check_space(o_string *o, int len)
@@ -771 +1047 @@
      * in here, such as setting a maximum string length */
     if (o->length + len > o->maxlen) {
-        char *old_data = o->data;
-        /* assert (data == NULL || o->maxlen != 0); */
-        o->maxlen += max(2*len, B_CHUNK);
-        o->data = realloc(o->data, 1 + o->maxlen);
-        if (o->data == NULL) {
-            free(old_data);
-        }
+        /* assert(data == NULL || o->maxlen != 0); */
+        o->maxlen += (2*len > B_CHUNK ? 2*len : B_CHUNK);
+        o->data = xrealloc(o->data, 1 + o->maxlen);
     }
     return o->data == NULL;
@@ -784 +1056 @@
 static int b_addchr(o_string *o, int ch)
 {
-    debug_printf("b_addchr: %c %d %p\n", ch, o->length, o);
-    if (b_check_space(o, 1)) return B_NOSPAC;
+    debug_printf("b_addchr: '%c' o->length=%d o=%p\n", ch, o->length, o);
+    if (b_check_space(o, 1))
+        return B_NOSPAC;
     o->data[o->length] = ch;
     o->length++;
@@ -796 +1069 @@
     o->length = 0;
     o->nonnull = 0;
-    if (o->data != NULL) *o->data = '\0';
+    if (o->data != NULL)
+        *o->data = '\0';
 }
 
@@ -812 +1086 @@
 static int b_addqchr(o_string *o, int ch, int quote)
 {
-    if (quote && strchr("*?[\\",ch)) {
+    if (quote && strchr("*?[\\", ch)) {
         int rc;
         rc = b_addchr(o, '\\');
-        if (rc) return rc;
+        if (rc)
+            return rc;
     }
     return b_addchr(o, ch);
 }
 
-/* belongs in utility.c */
-static char *simple_itoa(unsigned int i)
-{
-    /* 21 digits plus null terminator, good for 64-bit or smaller ints */
-    static char local[22];
-    char *p = &local[21];
-    *p-- = '\0';
-    do {
-        *p-- = '0' + i % 10;
-        i /= 10;
-    } while (i > 0);
-    return p + 1;
-}
-
-static int b_adduint(o_string *o, unsigned int i)
-{
-    int r;
-    char *p = simple_itoa(i);
-    /* no escape checking necessary */
-    do r=b_addchr(o, *p++); while (r==0 && *p);
-    return r;
-}
-
 static int static_get(struct in_str *i)
 {
-    int ch=*i->p++;
-    if (ch=='\0') return EOF;
+    int ch = *i->p++;
+    if (ch == '\0') return EOF;
     return ch;
 }
@@ -855 +1107 @@
 }
 
-static inline void cmdedit_set_initial_prompt(void)
-{
-#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+#if ENABLE_HUSH_INTERACTIVE
+#if ENABLE_FEATURE_EDITING
+static void cmdedit_set_initial_prompt(void)
+{
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
     PS1 = NULL;
 #else
     PS1 = getenv("PS1");
-    if(PS1==0)
+    if (PS1 == NULL)
         PS1 = "\\w \\$ ";
 #endif
 }
-
-static inline void setup_prompt_string(int promptmode, char **prompt_str)
-{
-    debug_printf("setup_prompt_string %d ",promptmode);
-#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+#endif /* EDITING */
+
+static const char* setup_prompt_string(int promptmode)
+{
+    const char *prompt_str;
+    debug_printf("setup_prompt_string %d ", promptmode);
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
     /* Set up the prompt */
-    if (promptmode == 1) {
-        free(PS1);
-        PS1=xmalloc(strlen(cwd)+4);
-        sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ?  "$ ":"# ");
-        *prompt_str = PS1;
+    if (promptmode == 0) { /* PS1 */
+        free((char*)PS1);
+        PS1 = xasprintf("%s %c ", cwd, (geteuid() != 0) ? '$' : '#');
+        prompt_str = PS1;
     } else {
-        *prompt_str = PS2;
+        prompt_str = PS2;
     }
 #else
-    *prompt_str = (promptmode==1)? PS1 : PS2;
-#endif
-    debug_printf("result %s\n",*prompt_str);
+    prompt_str = (promptmode == 0) ? PS1 : PS2;
+#endif
+    debug_printf("result '%s'\n", prompt_str);
+    return prompt_str;
 }
 
 static void get_user_input(struct in_str *i)
 {
-    char *prompt_str;
-    static char the_command[BUFSIZ];
-
-    setup_prompt_string(i->promptmode, &prompt_str);
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
-    /*
-     ** enable command line editing only while a command line
-     ** is actually being read; otherwise, we'll end up bequeathing
-     ** atexit() handlers and other unwanted stuff to our
-     ** child processes (rob@sysgo.de)
-     */
-    cmdedit_read_input(prompt_str, the_command);
+    int r;
+    const char *prompt_str;
+
+    prompt_str = setup_prompt_string(i->promptmode);
+#if ENABLE_FEATURE_EDITING
+    /* Enable command line editing only while a command line
+     * is actually being read; otherwise, we'll end up bequeathing
+     * atexit() handlers and other unwanted stuff to our
+     * child processes (rob@sysgo.de) */
+    r = read_line_input(prompt_str, user_input_buf, BUFSIZ-1, line_input_state);
+    i->eof_flag = (r < 0);
+    if (i->eof_flag) { /* EOF/error detected */
+        user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
+        user_input_buf[1] = '\0';
+    }
 #else
     fputs(prompt_str, stdout);
     fflush(stdout);
-    the_command[0]=fgetc(i->file);
-    the_command[1]='\0';
-#endif
-    fflush(stdout);
-    i->p = the_command;
-}
+    user_input_buf[0] = r = fgetc(i->file);
+    /*user_input_buf[1] = '\0'; - already is and never changed */
+    i->eof_flag = (r == EOF);
+#endif
+    i->p = user_input_buf;
+}
+#endif  /* INTERACTIVE */
 
 /* This is the magic location that prints prompts
@@ -915 +1175 @@
     int ch;
 
-    ch = 0;
     /* If there is data waiting, eat it up */
     if (i->p && *i->p) {
-        ch=*i->p++;
+#if ENABLE_HUSH_INTERACTIVE
+ take_cached:
+#endif
+        ch = *i->p++;
+        if (i->eof_flag && !*i->p)
+            ch = EOF;
     } else {
         /* need to double check i->file because we might be doing something
          * more complicated by now, like sourcing or substituting. */
-        if (i->__promptme && interactive && i->file == stdin) {
-            while(! i->p || (interactive && strlen(i->p)==0) ) {
+#if ENABLE_HUSH_INTERACTIVE
+        if (interactive_fd && i->promptme && i->file == stdin) {
+            do {
                 get_user_input(i);
-            }
-            i->promptmode=2;
-            i->__promptme = 0;
-            if (i->p && *i->p) {
-                ch=*i->p++;
-            }
-        } else {
-            ch = fgetc(i->file);
-        }
-
-        debug_printf("b_getch: got a %d\n", ch);
-    }
-    if (ch == '\n') i->__promptme=1;
+            } while (!*i->p); /* need non-empty line */
+            i->promptmode = 1; /* PS2 */
+            i->promptme = 0;
+            goto take_cached;
+        }
+#endif
+        ch = fgetc(i->file);
+    }
+    debug_printf("file_get: got a '%c' %d\n", ch, ch);
+#if ENABLE_HUSH_INTERACTIVE
+    if (ch == '\n')
+        i->promptme = 1;
+#endif
     return ch;
 }
@@ -946 +1211 @@
 static int file_peek(struct in_str *i)
 {
+    int ch;
     if (i->p && *i->p) {
+        if (i->eof_flag && !i->p[1])
+            return EOF;
         return *i->p;
-    } else {
-        i->peek_buf[0] = fgetc(i->file);
-        i->peek_buf[1] = '\0';
-        i->p = i->peek_buf;
-        debug_printf("b_peek: got a %d\n", *i->p);
-        return *i->p;
-    }
+    }
+    ch = fgetc(i->file);
+    i->eof_flag = (ch == EOF);
+    i->peek_buf[0] = ch;
+    i->peek_buf[1] = '\0';
+    i->p = i->peek_buf;
+    debug_printf("file_peek: got a '%c' %d\n", *i->p, *i->p);
+    return ch;
 }
 
@@ -961 +1230 @@
     i->peek = file_peek;
     i->get = file_get;
-    i->__promptme=1;
-    i->promptmode=1;
+#if ENABLE_HUSH_INTERACTIVE
+    i->promptme = 1;
+    i->promptmode = 0; /* PS1 */
+#endif
     i->file = f;
     i->p = NULL;
@@ -971 +1242 @@
     i->peek = static_peek;
     i->get = static_get;
-    i->__promptme=1;
-    i->promptmode=1;
+#if ENABLE_HUSH_INTERACTIVE
+    i->promptme = 1;
+    i->promptmode = 0; /* PS1 */
+#endif
     i->p = s;
+    i->eof_flag = 0;
 }
 
@@ -997 +1271 @@
 {
     struct close_me *c;
-    for (c=close_me_head; c; c=c->next) {
+    for (c = close_me_head; c; c = c->next) {
         close(c->fd);
     }
@@ -1010 +1284 @@
     struct redir_struct *redir;
 
-    for (redir=prog->redirects; redir; redir=redir->next) {
+    for (redir = prog->redirects; redir; redir = redir->next) {
         if (redir->dup == -1 && redir->word.gl_pathv == NULL) {
             /* something went wrong in the parse.  Pretend it didn't happen */
@@ -1016 +1290 @@
         }
         if (redir->dup == -1) {
-            mode=redir_table[redir->type].mode;
-            openfd = open(redir->word.gl_pathv[0], mode, 0666);
+            mode = redir_table[redir->type].mode;
+            openfd = open_or_warn(redir->word.gl_pathv[0], mode);
             if (openfd < 0) {
             /* this could get lost if stderr has been redirected, but
                bash and ash both lose it as well (though zsh doesn't!) */
-                bb_perror_msg("error opening %s", redir->word.gl_pathv[0]);
                 return 1;
             }
@@ -1037 +1310 @@
                 dup2(openfd, redir->fd);
                 if (redir->dup == -1)
-                    close (openfd);
+                    close(openfd);
             }
         }
@@ -1047 +1320 @@
 {
     int i, fd;
-    for (i=0; i<3; i++) {
+    for (i = 0; i < 3; i++) {
         fd = squirrel[i];
         if (fd != -1) {
-            /* No error checking.  I sure wouldn't know what
-             * to do with an error if I found one! */
-            dup2(fd, i);
-            close(fd);
+            /* We simply die on error */
+            xmove_fd(fd, i);
         }
     }
@@ -1061 +1332 @@
 /* XXX no exit() here.  If you don't exec, use _exit instead.
  * The at_exit handlers apparently confuse the calling process,
- * in particular stdin handling.  Not sure why? */
-static void pseudo_exec(struct child_prog *child)
+ * in particular stdin handling.  Not sure why? -- because of vfork! (vda) */
+static void pseudo_exec_argv(char **argv)
 {
     int i, rcode;
     char *p;
     const struct built_in_command *x;
+
+    for (i = 0; is_assignment(argv[i]); i++) {
+        debug_printf_exec("pid %d environment modification: %s\n",
+                getpid(), argv[i]);
+// FIXME: vfork case??
+        p = expand_string_to_string(argv[i]);
+        putenv(p);
+    }
+    argv += i;
+    /* If a variable is assigned in a forest, and nobody listens,
+     * was it ever really set?
+     */
+    if (argv[0] == NULL) {
+        _exit(EXIT_SUCCESS);
+    }
+
+    argv = expand_strvec_to_strvec(argv);
+
+    /*
+     * Check if the command matches any of the builtins.
+     * Depending on context, this might be redundant.  But it's
+     * easier to waste a few CPU cycles than it is to figure out
+     * if this is one of those cases.
+     */
+    for (x = bltins; x->cmd; x++) {
+        if (strcmp(argv[0], x->cmd) == 0) {
+            debug_printf_exec("running builtin '%s'\n", argv[0]);
+            rcode = x->function(argv);
+            fflush(stdout);
+            _exit(rcode);
+        }
+    }
+
+    /* Check if the command matches any busybox applets */
+#if ENABLE_FEATURE_SH_STANDALONE
+    if (strchr(argv[0], '/') == NULL) {
+        const struct bb_applet *a = find_applet_by_name(argv[0]);
+        if (a) {
+            if (a->noexec) {
+                current_applet = a;
+                debug_printf_exec("running applet '%s'\n", argv[0]);
+// is it ok that run_current_applet_and_exit() does exit(), not _exit()?
+                run_current_applet_and_exit(argv);
+            }
+            /* re-exec ourselves with the new arguments */
+            debug_printf_exec("re-execing applet '%s'\n", argv[0]);
+            execvp(bb_busybox_exec_path, argv);
+            /* If they called chroot or otherwise made the binary no longer
+             * executable, fall through */
+        }
+    }
+#endif
+
+    debug_printf_exec("execing '%s'\n", argv[0]);
+    execvp(argv[0], argv);
+    bb_perror_msg("cannot exec '%s'", argv[0]);
+    _exit(1);
+}
+
+static void pseudo_exec(struct child_prog *child)
+{
+// FIXME: buggy wrt NOMMU! Must not modify any global data
+// until it does exec/_exit, but currently it does.
+    int rcode;
+
     if (child->argv) {
-        for (i=0; is_assignment(child->argv[i]); i++) {
-            debug_printf("pid %d environment modification: %s\n",getpid(),child->argv[i]);
-            p = insert_var_value(child->argv[i]);
-            putenv(strdup(p));
-            if (p != child->argv[i]) free(p);
-        }
-        child->argv+=i;  /* XXX this hack isn't so horrible, since we are about
-                                to exit, and therefore don't need to keep data
-                                structures consistent for free() use. */
-        /* If a variable is assigned in a forest, and nobody listens,
-         * was it ever really set?
-         */
-        if (child->argv[0] == NULL) {
-            _exit(EXIT_SUCCESS);
-        }
-
-        /*
-         * Check if the command matches any of the builtins.
-         * Depending on context, this might be redundant.  But it's
-         * easier to waste a few CPU cycles than it is to figure out
-         * if this is one of those cases.
-         */
-        for (x = bltins; x->cmd; x++) {
-            if (strcmp(child->argv[0], x->cmd) == 0 ) {
-                debug_printf("builtin exec %s\n", child->argv[0]);
-                rcode = x->function(child);
-                fflush(stdout);
-                _exit(rcode);
-            }
-        }
-
-        /* Check if the command matches any busybox internal commands
-         * ("applets") here.
-         * FIXME: This feature is not 100% safe, since
-         * BusyBox is not fully reentrant, so we have no guarantee the things
-         * from the .bss are still zeroed, or that things from .data are still
-         * at their defaults.  We could exec ourself from /proc/self/exe, but I
-         * really dislike relying on /proc for things.  We could exec ourself
-         * from global_argv[0], but if we are in a chroot, we may not be able
-         * to find ourself... */
-#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
-        {
-            int argc_l;
-            char** argv_l=child->argv;
-            char *name = child->argv[0];
-
-            /* Count argc for use in a second... */
-            for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
-            optind = 1;
-            debug_printf("running applet %s\n", name);
-            run_applet_by_name(name, argc_l, child->argv);
-        }
-#endif
-        debug_printf("exec of %s\n",child->argv[0]);
-        execvp(child->argv[0],child->argv);
-        bb_perror_msg("couldn't exec: %s",child->argv[0]);
-        _exit(1);
-    } else if (child->group) {
-        debug_printf("runtime nesting to group\n");
-        interactive=0;    /* crucial!!!! */
+        pseudo_exec_argv(child->argv);
+    }
+
+    if (child->group) {
+    // FIXME: do not modify globals! Think vfork!
+#if ENABLE_HUSH_INTERACTIVE
+        debug_printf_exec("pseudo_exec: setting interactive_fd=0\n");
+        interactive_fd = 0;    /* crucial!!!! */
+#endif
+        debug_printf_exec("pseudo_exec: run_list_real\n");
         rcode = run_list_real(child->group);
         /* OK to leak memory by not calling free_pipe_list,
          * since this process is about to exit */
         _exit(rcode);
-    } else {
-        /* Can happen.  See what bash does with ">foo" by itself. */
-        debug_printf("trying to pseudo_exec null command\n");
-        _exit(EXIT_SUCCESS);
-    }
+    }
+
+    /* Can happen.  See what bash does with ">foo" by itself. */
+    debug_printf("trying to pseudo_exec null command\n");
+    _exit(EXIT_SUCCESS);
+}
+
+#if ENABLE_HUSH_JOB
+static const char *get_cmdtext(struct pipe *pi)
+{
+    char **argv;
+    char *p;
+    int len;
+
+    /* This is subtle. ->cmdtext is created only on first backgrounding.
+     * (Think "cat, <ctrl-z>, fg, <ctrl-z>, fg, <ctrl-z>...." here...)
+     * On subsequent bg argv is trashed, but we won't use it */
+    if (pi->cmdtext)
+        return pi->cmdtext;
+    argv = pi->progs[0].argv;
+    if (!argv || !argv[0])
+        return (pi->cmdtext = xzalloc(1));
+
+    len = 0;
+    do len += strlen(*argv) + 1; while (*++argv);
+    pi->cmdtext = p = xmalloc(len);
+    argv = pi->progs[0].argv;
+    do {
+        len = strlen(*argv);
+        memcpy(p, *argv, len);
+        p += len;
+        *p++ = ' ';
+    } while (*++argv);
+    p[-1] = '\0';
+    return pi->cmdtext;
 }
 
@@ -1142 +1458 @@
 {
     struct pipe *thejob;
+    int i;
 
     /* Linear search for the ID of the job to use */
@@ -1149 +1466 @@
             pi->jobid = thejob->jobid + 1;
 
-    /* add thejob to the list of running jobs */
+    /* Add thejob to the list of running jobs */
     if (!job_list) {
         thejob = job_list = xmalloc(sizeof(*thejob));
     } else {
-        for (thejob = job_list; thejob->next; thejob = thejob->next) /* nothing */;
+        for (thejob = job_list; thejob->next; thejob = thejob->next)
+            continue;
         thejob->next = xmalloc(sizeof(*thejob));
         thejob = thejob->next;
     }
 
-    /* physically copy the struct job */
+    /* Physically copy the struct job */
     memcpy(thejob, pi, sizeof(struct pipe));
+    thejob->progs = xzalloc(sizeof(pi->progs[0]) * pi->num_progs);
+    /* We cannot copy entire pi->progs[] vector! Double free()s will happen */
+    for (i = 0; i < pi->num_progs; i++) {
+// TODO: do we really need to have so many fields which are just dead weight
+// at execution stage?
+        thejob->progs[i].pid = pi->progs[i].pid;
+        /* all other fields are not used and stay zero */
+    }
     thejob->next = NULL;
-    thejob->running_progs = thejob->num_progs;
-    thejob->stopped_progs = 0;
-    thejob->text = xmalloc(BUFSIZ); /* cmdedit buffer size */
-
-    //if (pi->progs[0] && pi->progs[0].argv && pi->progs[0].argv[0])
-    {
-        char *bar=thejob->text;
-        char **foo=pi->progs[0].argv;
-        while(foo && *foo) {
-            bar += sprintf(bar, "%s ", *foo++);
-        }
-    }
-
-    /* we don't wait for background thejobs to return -- append it
+    thejob->cmdtext = xstrdup(get_cmdtext(pi));
+
+    /* We don't wait for background thejobs to return -- append it
        to the list of backgrounded thejobs and leave it alone */
-    printf("[%d] %d\n", thejob->jobid, thejob->progs[0].pid);
+    printf("[%d] %d %s\n", thejob->jobid, thejob->progs[0].pid, thejob->cmdtext);
     last_bg_pid = thejob->progs[0].pid;
     last_jobid = thejob->jobid;
 }
 
-/* remove a backgrounded job */
 static void remove_bg_job(struct pipe *pi)
 {
@@ -1198 +1512 @@
     else
         last_jobid = 0;
-
+}
+
+/* remove a backgrounded job */
+static void delete_finished_bg_job(struct pipe *pi)
+{
+    remove_bg_job(pi);
     pi->stopped_progs = 0;
     free_pipe(pi, 0);
     free(pi);
 }
+#endif /* JOB */
 
 /* Checks to see if any processes have exited -- if they
@@ -1210 +1530 @@
     int attributes;
     int status;
+#if ENABLE_HUSH_JOB
     int prognum = 0;
     struct pipe *pi;
+#endif
     pid_t childpid;
+    int rcode = 0;
 
     attributes = WUNTRACED;
-    if (fg_pipe==NULL) {
+    if (fg_pipe == NULL) {
         attributes |= WNOHANG;
     }
 
+/* Do we do this right?
+ * bash-3.00# sleep 20 | false
+ * <ctrl-Z pressed>
+ * [3]+  Stopped          sleep 20 | false
+ * bash-3.00# echo $?
+ * 1   <========== bg pipe is not fully done, but exitcode is already known!
+ */
+
+//FIXME: non-interactive bash does not continue even if all processes in fg pipe
+//are stopped. Testcase: "cat | cat" in a script (not on command line)
+// + killall -STOP cat
+
+ wait_more:
     while ((childpid = waitpid(-1, &status, attributes)) > 0) {
+        const int dead = WIFEXITED(status) || WIFSIGNALED(status);
+
+#ifdef DEBUG_SHELL_JOBS
+        if (WIFSTOPPED(status))
+            debug_printf_jobs("pid %d stopped by sig %d (exitcode %d)\n",
+                    childpid, WSTOPSIG(status), WEXITSTATUS(status));
+        if (WIFSIGNALED(status))
+            debug_printf_jobs("pid %d killed by sig %d (exitcode %d)\n",
+                    childpid, WTERMSIG(status), WEXITSTATUS(status));
+        if (WIFEXITED(status))
+            debug_printf_jobs("pid %d exited, exitcode %d\n",
+                    childpid, WEXITSTATUS(status));
+#endif
+        /* Were we asked to wait for fg pipe? */
         if (fg_pipe) {
-            int i, rcode = 0;
-            for (i=0; i < fg_pipe->num_progs; i++) {
+            int i;
+            for (i = 0; i < fg_pipe->num_progs; i++) {
+                debug_printf_jobs("check pid %d\n", fg_pipe->progs[i].pid);
                 if (fg_pipe->progs[i].pid == childpid) {
-                    if (i==fg_pipe->num_progs-1)
-                        rcode=WEXITSTATUS(status);
-                    (fg_pipe->num_progs)--;
-                    return(rcode);
+                    /* printf("process %d exit %d\n", i, WEXITSTATUS(status)); */
+                    if (dead) {
+                        fg_pipe->progs[i].pid = 0;
+                        fg_pipe->running_progs--;
+                        if (i == fg_pipe->num_progs-1)
+                            /* last process gives overall exitstatus */
+                            rcode = WEXITSTATUS(status);
+                    } else {
+                        fg_pipe->progs[i].is_stopped = 1;
+                        fg_pipe->stopped_progs++;
+                    }
+                    debug_printf_jobs("fg_pipe: running_progs %d stopped_progs %d\n",
+                            fg_pipe->running_progs, fg_pipe->stopped_progs);
+                    if (fg_pipe->running_progs - fg_pipe->stopped_progs <= 0) {
+                        /* All processes in fg pipe have exited/stopped */
+#if ENABLE_HUSH_JOB
+                        if (fg_pipe->running_progs)
+                            insert_bg_job(fg_pipe);
+#endif
+                        return rcode;
+                    }
+                    /* There are still running processes in the fg pipe */
+                    goto wait_more;
                 }
             }
-        }
-
+            /* fall through to searching process in bg pipes */
+        }
+
+#if ENABLE_HUSH_JOB
+        /* We asked to wait for bg or orphaned children */
+        /* No need to remember exitcode in this case */
         for (pi = job_list; pi; pi = pi->next) {
             prognum = 0;
-            while (prognum < pi->num_progs && pi->progs[prognum].pid != childpid) {
+            while (prognum < pi->num_progs) {
+                if (pi->progs[prognum].pid == childpid)
+                    goto found_pi_and_prognum;
                 prognum++;
             }
-            if (prognum < pi->num_progs)
-                break;
-        }
-
-        if(pi==NULL) {
-            debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
-            continue;
-        }
-
-        if (WIFEXITED(status) || WIFSIGNALED(status)) {
+        }
+#endif
+
+        /* Happens when shell is used as init process (init=/bin/sh) */
+        debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
+        goto wait_more;
+
+#if ENABLE_HUSH_JOB
+ found_pi_and_prognum:
+        if (dead) {
             /* child exited */
+            pi->progs[prognum].pid = 0;
             pi->running_progs--;
-            pi->progs[prognum].pid = 0;
-
             if (!pi->running_progs) {
-                printf(JOB_STATUS_FORMAT, pi->jobid, "Done", pi->text);
-                remove_bg_job(pi);
+                printf(JOB_STATUS_FORMAT, pi->jobid,
+                            "Done", pi->cmdtext);
+                delete_finished_bg_job(pi);
             }
         } else {
@@ -1259 +1635 @@
             pi->stopped_progs++;
             pi->progs[prognum].is_stopped = 1;
-
-#if 0
-            /* Printing this stuff is a pain, since it tends to
-             * overwrite the prompt an inconveinient moments.  So
-             * don't do that.  */
-            if (pi->stopped_progs == pi->num_progs) {
-                printf("\n"JOB_STATUS_FORMAT, pi->jobid, "Stopped", pi->text);
-            }
-#endif
-        }
-    }
-
-    if (childpid == -1 && errno != ECHILD)
+        }
+#endif
+    }
+
+    /* wait found no children or failed */
+
+    if (childpid && errno != ECHILD)
         bb_perror_msg("waitpid");
-
-    /* move the shell to the foreground */
-    //if (interactive && tcsetpgrp(shell_terminal, getpgid(0)))
-    //  bb_perror_msg("tcsetpgrp-2");
-    return -1;
-}
-
-/* Figure out our controlling tty, checking in order stderr,
- * stdin, and stdout.  If check_pgrp is set, also check that
- * we belong to the foreground process group associated with
- * that tty.  The value of shell_terminal is needed in order to call
- * tcsetpgrp(shell_terminal, ...); */
-#if 0
-static void controlling_tty(int check_pgrp)
-{
-    pid_t curpgrp;
-
-    if ((curpgrp = tcgetpgrp(shell_terminal = 2)) < 0
-            && (curpgrp = tcgetpgrp(shell_terminal = 0)) < 0
-            && (curpgrp = tcgetpgrp(shell_terminal = 1)) < 0)
-        goto shell_terminal_error;
-
-    if (check_pgrp && curpgrp != getpgid(0))
-        goto shell_terminal_error;
-
-    return;
-
-shell_terminal_error:
-        shell_terminal = -1;
-        return;
+    return rcode;
+}
+
+#if ENABLE_HUSH_JOB
+static int checkjobs_and_fg_shell(struct pipe* fg_pipe)
+{
+    pid_t p;
+    int rcode = checkjobs(fg_pipe);
+    /* Job finished, move the shell to the foreground */
+    p = getpgid(0); /* pgid of our process */
+    debug_printf_jobs("fg'ing ourself: getpgid(0)=%d\n", (int)p);
+    if (tcsetpgrp(interactive_fd, p) && errno != ENOTTY)
+        bb_perror_msg("tcsetpgrp-4a");
+    return rcode;
 }
 #endif
@@ -1321 +1675 @@
  * now has its stdout directed to the input of the appropriate pipe,
  * so this routine is noticeably simpler.
+ *
+ * Returns -1 only if started some children. IOW: we have to
+ * mask out retvals of builtins etc with 0xff!
  */
 static int run_pipe_real(struct pipe *pi)
@@ -1330 +1687 @@
     const struct built_in_command *x;
     char *p;
+    /* it is not always needed, but we aim to smaller code */
+    int squirrel[] = { -1, -1, -1 };
+    int rcode;
+    const int single_fg = (pi->num_progs == 1 && pi->followup != PIPE_BG);
+
+    debug_printf_exec("run_pipe_real start: single_fg=%d\n", single_fg);
 
     nextin = 0;
+#if ENABLE_HUSH_JOB
     pi->pgrp = -1;
+#endif
+    pi->running_progs = 1;
+    pi->stopped_progs = 0;
 
     /* Check if this is a simple builtin (not part of a pipe).
@@ -1338 +1705 @@
      * pseudo_exec.  "echo foo | read bar" doesn't work on bash, either.
      */
-    if (pi->num_progs == 1) child = & (pi->progs[0]);
-    if (pi->num_progs == 1 && child->group && child->subshell == 0) {
-        int squirrel[] = {-1, -1, -1};
-        int rcode;
+    child = &(pi->progs[0]);
+    if (single_fg && child->group && child->subshell == 0) {
         debug_printf("non-subshell grouping\n");
         setup_redirects(child, squirrel);
-        /* XXX could we merge code with following builtin case,
-         * by creating a pseudo builtin that calls run_list_real? */
+        debug_printf_exec(": run_list_real\n");
         rcode = run_list_real(child->group);
         restore_redirects(squirrel);
-        return rcode;
-    } else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
-        for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ }
-        if (i!=0 && child->argv[i]==NULL) {
+        debug_printf_exec("run_pipe_real return %d\n", rcode);
+        return rcode; // do we need to add '... & 0xff' ?
+    }
+
+    if (single_fg && child->argv != NULL) {
+        char **argv_expanded;
+        char **argv = child->argv;
+
+        for (i = 0; is_assignment(argv[i]); i++)
+            continue;
+        if (i != 0 && argv[i] == NULL) {
             /* assignments, but no command: set the local environment */
-            for (i=0; child->argv[i]!=NULL; i++) {
-
-                /* Ok, this case is tricky.  We have to decide if this is a
-                 * local variable, or an already exported variable.  If it is
-                 * already exported, we have to export the new value.  If it is
-                 * not exported, we need only set this as a local variable.
-                 * This junk is all to decide whether or not to export this
-                 * variable. */
-                int export_me=0;
-                char *name, *value;
-                name = bb_xstrdup(child->argv[i]);
-                debug_printf("Local environment set: %s\n", name);
-                value = strchr(name, '=');
-                if (value)
-                    *value=0;
-                if ( get_local_var(name)) {
-                    export_me=1;
-                }
-                free(name);
-                p = insert_var_value(child->argv[i]);
-                set_local_var(p, export_me);
-                if (p != child->argv[i]) free(p);
+            for (i = 0; argv[i] != NULL; i++) {
+                debug_printf("local environment set: %s\n", argv[i]);
+                p = expand_string_to_string(argv[i]);
+                set_local_var(p, 0);
             }
             return EXIT_SUCCESS;   /* don't worry about errors in set_local_var() yet */
         }
-        for (i = 0; is_assignment(child->argv[i]); i++) {
-            p = insert_var_value(child->argv[i]);
-            putenv(strdup(p));
-            if (p != child->argv[i]) {
-                child->sp--;
-                free(p);
-            }
-        }
-        if (child->sp) {
-            char * str = NULL;
-
-            str = make_string((child->argv + i));
-            parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
-            free(str);
-            return last_return_code;
+        for (i = 0; is_assignment(argv[i]); i++) {
+            p = expand_string_to_string(argv[i]);
+            //sp: child->sp--;
+            putenv(p);
         }
         for (x = bltins; x->cmd; x++) {
-            if (strcmp(child->argv[i], x->cmd) == 0 ) {
-                int squirrel[] = {-1, -1, -1};
-                int rcode;
-                if (x->function == builtin_exec && child->argv[i+1]==NULL) {
+            if (strcmp(argv[i], x->cmd) == 0) {
+                if (x->function == builtin_exec && argv[i+1] == NULL) {
                     debug_printf("magic exec\n");
-                    setup_redirects(child,NULL);
+                    setup_redirects(child, NULL);
                     return EXIT_SUCCESS;
                 }
-                debug_printf("builtin inline %s\n", child->argv[0]);
+                debug_printf("builtin inline %s\n", argv[0]);
                 /* XXX setup_redirects acts on file descriptors, not FILEs.
                  * This is perfect for work that comes after exec().
@@ -1409 +1749 @@
                  * things seem to work with glibc. */
                 setup_redirects(child, squirrel);
-                child->argv+=i;  /* XXX horrible hack */
-                rcode = x->function(child);
-                child->argv-=i;  /* XXX restore hack so free() can work right */
+                debug_printf_exec(": builtin '%s' '%s'...\n", x->cmd, argv[i+1]);
+                //sp: if (child->sp) /* btw we can do it unconditionally... */
+                argv_expanded = expand_strvec_to_strvec(argv + i);
+                rcode = x->function(argv_expanded) & 0xff;
+                free(argv_expanded);
                 restore_redirects(squirrel);
+                debug_printf_exec("run_pipe_real return %d\n", rcode);
                 return rcode;
             }
         }
-    }
+#if ENABLE_FEATURE_SH_STANDALONE
+        {
+            const struct bb_applet *a = find_applet_by_name(argv[i]);
+            if (a && a->nofork) {
+                setup_redirects(child, squirrel);
+                save_nofork_data(&nofork_save);
+                argv_expanded = argv + i;
+                //sp: if (child->sp)
+                argv_expanded = expand_strvec_to_strvec(argv + i);
+                debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
+                rcode = run_nofork_applet_prime(&nofork_save, a, argv_expanded) & 0xff;
+                free(argv_expanded);
+                restore_redirects(squirrel);
+                debug_printf_exec("run_pipe_real return %d\n", rcode);
+                return rcode;
+            }
+        }
+#endif
+    }
+
+    /* Going to fork a child per each pipe member */
+    pi->running_progs = 0;
+
+    /* Disable job control signals for shell (parent) and
+     * for initial child code after fork */
+    set_jobctrl_sighandler(SIG_IGN);
 
     for (i = 0; i < pi->num_progs; i++) {
-        child = & (pi->progs[i]);
+        child = &(pi->progs[i]);
+        if (child->argv)
+            debug_printf_exec(": pipe member '%s' '%s'...\n", child->argv[0], child->argv[1]);
+        else
+            debug_printf_exec(": pipe member with no argv\n");
 
         /* pipes are inserted between pairs of commands */
         if ((i + 1) < pi->num_progs) {
-            if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
+            pipe(pipefds);
             nextout = pipefds[1];
         } else {
-            nextout=1;
+            nextout = 1;
             pipefds[0] = -1;
         }
 
         /* XXX test for failed fork()? */
-#if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
-        if (!(child->pid = fork()))
+#if BB_MMU
+        child->pid = fork();
 #else
-        if (!(child->pid = vfork()))
-#endif
-        {
-            /* Set the handling for job control signals back to the default.  */
-            signal(SIGINT, SIG_DFL);
-            signal(SIGQUIT, SIG_DFL);
-            signal(SIGTERM, SIG_DFL);
-            signal(SIGTSTP, SIG_DFL);
-            signal(SIGTTIN, SIG_DFL);
-            signal(SIGTTOU, SIG_DFL);
-            signal(SIGCHLD, SIG_DFL);
-
+        child->pid = vfork();
+#endif
+        if (!child->pid) { /* child */
+            /* Every child adds itself to new process group
+             * with pgid == pid of first child in pipe */
+#if ENABLE_HUSH_JOB
+            if (run_list_level == 1 && interactive_fd) {
+                /* Don't do pgrp restore anymore on fatal signals */
+                set_fatal_sighandler(SIG_DFL);
+                if (pi->pgrp < 0) /* true for 1st process only */
+                    pi->pgrp = getpid();
+                if (setpgid(0, pi->pgrp) == 0 && pi->followup != PIPE_BG) {
+                    /* We do it in *every* child, not just first,
+                     * to avoid races */
+                    tcsetpgrp(interactive_fd, pi->pgrp);
+                }
+            }
+#endif
+            /* in non-interactive case fatal sigs are already SIG_DFL */
             close_all();
-
             if (nextin != 0) {
                 dup2(nextin, 0);
@@ -1456 +1834 @@
                 close(nextout);
             }
-            if (pipefds[0]!=-1) {
+            if (pipefds[0] != -1) {
                 close(pipefds[0]);  /* opposite end of our output pipe */
             }
-
             /* Like bash, explicit redirects override pipes,
              * and the pipe fd is available for dup'ing. */
-            setup_redirects(child,NULL);
-
-            if (interactive && pi->followup!=PIPE_BG) {
-                /* If we (the child) win the race, put ourselves in the process
-                 * group whose leader is the first process in this pipe. */
-                if (pi->pgrp < 0) {
-                    pi->pgrp = getpid();
-                }
-                if (setpgid(0, pi->pgrp) == 0) {
-                    tcsetpgrp(2, pi->pgrp);
-                }
-            }
-
+            setup_redirects(child, NULL);
+
+            /* Restore default handlers just prior to exec */
+            set_jobctrl_sighandler(SIG_DFL);
+            set_misc_sighandler(SIG_DFL);
+            signal(SIGCHLD, SIG_DFL);
             pseudo_exec(child);
         }
 
-
-        /* put our child in the process group whose leader is the
-           first process in this pipe */
-        if (pi->pgrp < 0) {
+        pi->running_progs++;
+
+#if ENABLE_HUSH_JOB
+        /* Second and next children need to know pid of first one */
+        if (pi->pgrp < 0)
             pi->pgrp = child->pid;
-        }
-        /* Don't check for errors.  The child may be dead already,
-         * in which case setpgid returns error code EACCES. */
-        setpgid(child->pid, pi->pgrp);
-
+#endif
         if (nextin != 0)
             close(nextin);
@@ -1497 +1864 @@
         nextin = pipefds[0];
     }
+    debug_printf_exec("run_pipe_real return -1\n");
     return -1;
 }
 
+#ifndef debug_print_tree
+static void debug_print_tree(struct pipe *pi, int lvl)
+{
+    static const char *PIPE[] = {
+        [PIPE_SEQ] = "SEQ",
+        [PIPE_AND] = "AND",
+        [PIPE_OR ] = "OR" ,
+        [PIPE_BG ] = "BG" ,
+    };
+    static const char *RES[] = {
+        [RES_NONE ] = "NONE" ,
+#if ENABLE_HUSH_IF
+        [RES_IF   ] = "IF"   ,
+        [RES_THEN ] = "THEN" ,
+        [RES_ELIF ] = "ELIF" ,
+        [RES_ELSE ] = "ELSE" ,
+        [RES_FI   ] = "FI"   ,
+#endif
+#if ENABLE_HUSH_LOOPS
+        [RES_FOR  ] = "FOR"  ,
+        [RES_WHILE] = "WHILE",
+        [RES_UNTIL] = "UNTIL",
+        [RES_DO   ] = "DO"   ,
+        [RES_DONE ] = "DONE" ,
+        [RES_IN   ] = "IN"   ,
+#endif
+        [RES_XXXX ] = "XXXX" ,
+        [RES_SNTX ] = "SNTX" ,
+    };
+
+    int pin, prn;
+
+    pin = 0;
+    while (pi) {
+        fprintf(stderr, "%*spipe %d res_word=%s followup=%d %s\n", lvl*2, "",
+                pin, RES[pi->res_word], pi->followup, PIPE[pi->followup]);
+        prn = 0;
+        while (prn < pi->num_progs) {
+            struct child_prog *child = &pi->progs[prn];
+            char **argv = child->argv;
+
+            fprintf(stderr, "%*s prog %d", lvl*2, "", prn);
+            if (child->group) {
+                fprintf(stderr, " group %s: (argv=%p)\n",
+                        (child->subshell ? "()" : "{}"),
+                        argv);
+                debug_print_tree(child->group, lvl+1);
+                prn++;
+                continue;
+            }
+            if (argv) while (*argv) {
+                fprintf(stderr, " '%s'", *argv);
+                argv++;
+            }
+            fprintf(stderr, "\n");
+            prn++;
+        }
+        pi = pi->next;
+        pin++;
+    }
+}
+#endif
+
+/* NB: called by pseudo_exec, and therefore must not modify any
+ * global data until exec/_exit (we can be a child after vfork!) */
 static int run_list_real(struct pipe *pi)
 {
-    char *save_name = NULL;
-    char **list = NULL;
-    char **save_list = NULL;
     struct pipe *rpipe;
+#if ENABLE_HUSH_LOOPS
+    char *for_varname = NULL;
+    char **for_lcur = NULL;
+    char **for_list = NULL;
     int flag_rep = 0;
+#endif
     int save_num_progs;
-    int rcode=0, flag_skip=1;
+    int flag_skip = 1;
+    int rcode = 0; /* probably for gcc only */
     int flag_restore = 0;
-    int if_code=0, next_if_code=0;  /* need double-buffer to handle elif */
-    reserved_style rmode, skip_more_in_this_rmode=RES_XXXX;
+#if ENABLE_HUSH_IF
+    int if_code = 0, next_if_code = 0;  /* need double-buffer to handle elif */
+#else
+    enum { if_code = 0, next_if_code = 0 };
+#endif
+    reserved_style rword;
+    reserved_style skip_more_for_this_rword = RES_XXXX;
+
+    debug_printf_exec("run_list_real start lvl %d\n", run_list_level + 1);
+
+#if ENABLE_HUSH_LOOPS
     /* check syntax for "for" */
     for (rpipe = pi; rpipe; rpipe = rpipe->next) {
-        if ((rpipe->r_mode == RES_IN ||
-            rpipe->r_mode == RES_FOR) &&
-            (rpipe->next == NULL)) {
-                syntax();
-                return 1;
-        }
-        if ((rpipe->r_mode == RES_IN &&
-            (rpipe->next->r_mode == RES_IN &&
-            rpipe->next->progs->argv != NULL))||
-            (rpipe->r_mode == RES_FOR &&
-            rpipe->next->r_mode != RES_IN)) {
-                syntax();
-                return 1;
-        }
-    }
-    for (; pi; pi = (flag_restore != 0) ? rpipe : pi->next) {
-        if (pi->r_mode == RES_WHILE || pi->r_mode == RES_UNTIL ||
-            pi->r_mode == RES_FOR) {
-                flag_restore = 0;
-                if (!rpipe) {
-                    flag_rep = 0;
-                    rpipe = pi;
-                }
-        }
-        rmode = pi->r_mode;
-        debug_printf("rmode=%d  if_code=%d  next_if_code=%d skip_more=%d\n", rmode, if_code, next_if_code, skip_more_in_this_rmode);
-        if (rmode == skip_more_in_this_rmode && flag_skip) {
-            if (pi->followup == PIPE_SEQ) flag_skip=0;
+        if ((rpipe->res_word == RES_IN || rpipe->res_word == RES_FOR)
+         && (rpipe->next == NULL)
+        ) {
+            syntax("malformed for"); /* no IN or no commands after IN */
+            debug_printf_exec("run_list_real lvl %d return 1\n", run_list_level);
+            return 1;
+        }
+        if ((rpipe->res_word == RES_IN && rpipe->next->res_word == RES_IN && rpipe->next->progs[0].argv != NULL)
+         || (rpipe->res_word == RES_FOR && rpipe->next->res_word != RES_IN)
+        ) {
+            /* TODO: what is tested in the first condition? */
+            syntax("malformed for"); /* 2nd condition: not followed by IN */
+            debug_printf_exec("run_list_real lvl %d return 1\n", run_list_level);
+            return 1;
+        }
+    }
+#else
+    rpipe = NULL;
+#endif
+
+#if ENABLE_HUSH_JOB
+    /* Example of nested list: "while true; do { sleep 1 | exit 2; } done".
+     * We are saving state before entering outermost list ("while...done")
+     * so that ctrl-Z will correctly background _entire_ outermost list,
+     * not just a part of it (like "sleep 1 | exit 2") */
+    if (++run_list_level == 1 && interactive_fd) {
+        if (sigsetjmp(toplevel_jb, 1)) {
+            /* ctrl-Z forked and we are parent; or ctrl-C.
+             * Sighandler has longjmped us here */
+            signal(SIGINT, SIG_IGN);
+            signal(SIGTSTP, SIG_IGN);
+            /* Restore level (we can be coming from deep inside
+             * nested levels) */
+            run_list_level = 1;
+#if ENABLE_FEATURE_SH_STANDALONE
+            if (nofork_save.saved) { /* if save area is valid */
+                debug_printf_jobs("exiting nofork early\n");
+                restore_nofork_data(&nofork_save);
+            }
+#endif
+            if (ctrl_z_flag) {
+                /* ctrl-Z has forked and stored pid of the child in pi->pid.
+                 * Remember this child as background job */
+                insert_bg_job(pi);
+            } else {
+                /* ctrl-C. We just stop doing whatever we were doing */
+                putchar('\n');
+            }
+            rcode = 0;
+            goto ret;
+        }
+        /* ctrl-Z handler will store pid etc in pi */
+        toplevel_list = pi;
+        ctrl_z_flag = 0;
+#if ENABLE_FEATURE_SH_STANDALONE
+        nofork_save.saved = 0; /* in case we will run a nofork later */
+#endif
+        signal_SA_RESTART(SIGTSTP, handler_ctrl_z);
+        signal(SIGINT, handler_ctrl_c);
+    }
+#endif
+
+    for (; pi; pi = flag_restore ? rpipe : pi->next) {
+        rword = pi->res_word;
+#if ENABLE_HUSH_LOOPS
+        if (rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR) {
+            flag_restore = 0;
+            if (!rpipe) {
+                flag_rep = 0;
+                rpipe = pi;
+            }
+        }
+#endif
+        debug_printf_exec(": rword=%d if_code=%d next_if_code=%d skip_more=%d\n",
+                rword, if_code, next_if_code, skip_more_for_this_rword);
+        if (rword == skip_more_for_this_rword && flag_skip) {
+            if (pi->followup == PIPE_SEQ)
+                flag_skip = 0;
             continue;
         }
         flag_skip = 1;
-        skip_more_in_this_rmode = RES_XXXX;
-        if (rmode == RES_THEN || rmode == RES_ELSE) if_code = next_if_code;
-        if (rmode == RES_THEN &&  if_code) continue;
-        if (rmode == RES_ELSE && !if_code) continue;
-        if (rmode == RES_ELIF && !if_code) break;
-        if (rmode == RES_FOR && pi->num_progs) {
-            if (!list) {
+        skip_more_for_this_rword = RES_XXXX;
+#if ENABLE_HUSH_IF
+        if (rword == RES_THEN || rword == RES_ELSE)
+            if_code = next_if_code;
+        if (rword == RES_THEN && if_code)
+            continue;
+        if (rword == RES_ELSE && !if_code)
+            continue;
+        if (rword == RES_ELIF && !if_code)
+            break;
+#endif
+#if ENABLE_HUSH_LOOPS
+        if (rword == RES_FOR && pi->num_progs) {
+            if (!for_lcur) {
                 /* if no variable values after "in" we skip "for" */
-                if (!pi->next->progs->argv) continue;
+                if (!pi->next->progs->argv)
+                    continue;
                 /* create list of variable values */
-                list = make_list_in(pi->next->progs->argv,
-                    pi->progs->argv[0]);
-                save_list = list;
-                save_name = pi->progs->argv[0];
+                for_list = expand_strvec_to_strvec(pi->next->progs->argv);
+                for_lcur = for_list;
+                for_varname = pi->progs->argv[0];
                 pi->progs->argv[0] = NULL;
                 flag_rep = 1;
             }
-            if (!(*list)) {
-                free(pi->progs->argv[0]);
-                free(save_list);
-                list = NULL;
+            free(pi->progs->argv[0]);
+            if (!*for_lcur) {
+                free(for_list);
+                for_lcur = NULL;
                 flag_rep = 0;
-                pi->progs->argv[0] = save_name;
-                pi->progs->glob_result.gl_pathv[0] =
-                    pi->progs->argv[0];
+                pi->progs->argv[0] = for_varname;
+                pi->progs->glob_result.gl_pathv[0] = pi->progs->argv[0];
                 continue;
-            } else {
-                /* insert new value from list for variable */
-                if (pi->progs->argv[0])
-                    free(pi->progs->argv[0]);
-                pi->progs->argv[0] = *list++;
-                pi->progs->glob_result.gl_pathv[0] =
-                    pi->progs->argv[0];
-            }
-        }
-        if (rmode == RES_IN) continue;
-        if (rmode == RES_DO) {
-            if (!flag_rep) continue;
-        }
-        if ((rmode == RES_DONE)) {
+            }
+            /* insert next value from for_lcur */
+            /* vda: does it need escaping? */
+            pi->progs->argv[0] = xasprintf("%s=%s", for_varname, *for_lcur++);
+            pi->progs->glob_result.gl_pathv[0] = pi->progs->argv[0];
+        }
+        if (rword == RES_IN)
+            continue;
+        if (rword == RES_DO) {
+            if (!flag_rep)
+                continue;
+        }
+        if (rword == RES_DONE) {
             if (flag_rep) {
                 flag_restore = 1;
@@ -1591 +2091 @@
             }
         }
-        if (pi->num_progs == 0) continue;
+#endif
+        if (pi->num_progs == 0)
+            continue;
         save_num_progs = pi->num_progs; /* save number of programs */
+        debug_printf_exec(": run_pipe_real with %d members\n", pi->num_progs);
         rcode = run_pipe_real(pi);
-        debug_printf("run_pipe_real returned %d\n",rcode);
-        if (rcode!=-1) {
+        if (rcode != -1) {
             /* We only ran a builtin: rcode was set by the return value
              * of run_pipe_real(), and we don't need to wait for anything. */
-        } else if (pi->followup==PIPE_BG) {
-            /* XXX check bash's behavior with nontrivial pipes */
-            /* XXX compute jobid */
-            /* XXX what does bash do with attempts to background builtins? */
-            insert_bg_job(pi);
+        } else if (pi->followup == PIPE_BG) {
+            /* What does bash do with attempts to background builtins? */
+            /* Even bash 3.2 doesn't do that well with nested bg:
+             * try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
+             * I'm NOT treating inner &'s as jobs */
+#if ENABLE_HUSH_JOB
+            if (run_list_level == 1)
+                insert_bg_job(pi);
+#endif
             rcode = EXIT_SUCCESS;
         } else {
-            if (interactive) {
-                /* move the new process group into the foreground */
-                if (tcsetpgrp(shell_terminal, pi->pgrp) && errno != ENOTTY)
-                    bb_perror_msg("tcsetpgrp-3");
+#if ENABLE_HUSH_JOB
+            /* Paranoia, just "interactive_fd" should be enough? */
+            if (run_list_level == 1 && interactive_fd) {
+                /* waits for completion, then fg's main shell */
+                rcode = checkjobs_and_fg_shell(pi);
+            } else
+#endif
+            {
+                /* this one just waits for completion */
                 rcode = checkjobs(pi);
-                /* move the shell to the foreground */
-                if (tcsetpgrp(shell_terminal, getpgid(0)) && errno != ENOTTY)
-                    bb_perror_msg("tcsetpgrp-4");
-            } else {
-                rcode = checkjobs(pi);
-            }
-            debug_printf("checkjobs returned %d\n",rcode);
-        }
-        last_return_code=rcode;
+            }
+            debug_printf_exec(": checkjobs returned %d\n", rcode);
+        }
+        debug_printf_exec(": setting last_return_code=%d\n", rcode);
+        last_return_code = rcode;
         pi->num_progs = save_num_progs; /* restore number of programs */
-        if ( rmode == RES_IF || rmode == RES_ELIF )
-            next_if_code=rcode;  /* can be overwritten a number of times */
-        if (rmode == RES_WHILE)
+#if ENABLE_HUSH_IF
+        if (rword == RES_IF || rword == RES_ELIF)
+            next_if_code = rcode;  /* can be overwritten a number of times */
+#endif
+#if ENABLE_HUSH_LOOPS
+        if (rword == RES_WHILE)
             flag_rep = !last_return_code;
-        if (rmode == RES_UNTIL)
+        if (rword == RES_UNTIL)
             flag_rep = last_return_code;
-        if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) ||
-             (rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) )
-            skip_more_in_this_rmode=rmode;
+#endif
+        if ((rcode == EXIT_SUCCESS && pi->followup == PIPE_OR)
+         || (rcode != EXIT_SUCCESS && pi->followup == PIPE_AND)
+        ) {
+            skip_more_for_this_rword = rword;
+        }
         checkjobs(NULL);
     }
+
+#if ENABLE_HUSH_JOB
+    if (ctrl_z_flag) {
+        /* ctrl-Z forked somewhere in the past, we are the child,
+         * and now we completed running the list. Exit. */
+        exit(rcode);
+    }
+ ret:
+    if (!--run_list_level && interactive_fd) {
+        signal(SIGTSTP, SIG_IGN);
+        signal(SIGINT, SIG_IGN);
+    }
+#endif
+    debug_printf_exec("run_list_real lvl %d return %d\n", run_list_level + 1, rcode);
     return rcode;
-}
-
-/* broken, of course, but OK for testing */
-static char *indenter(int i)
-{
-    static char blanks[]="                                    ";
-    return &blanks[sizeof(blanks)-i-1];
 }
 
@@ -1647 +2167 @@
     struct child_prog *child;
     struct redir_struct *r, *rnext;
-    int a, i, ret_code=0;
-    char *ind = indenter(indent);
+    int a, i, ret_code = 0;
 
     if (pi->stopped_progs > 0)
         return ret_code;
-    final_printf("%s run pipe: (pid %d)\n",ind,getpid());
-    for (i=0; i<pi->num_progs; i++) {
+    debug_printf_clean("%s run pipe: (pid %d)\n", indenter(indent), getpid());
+    for (i = 0; i < pi->num_progs; i++) {
         child = &pi->progs[i];
-        final_printf("%s  command %d:\n",ind,i);
+        debug_printf_clean("%s  command %d:\n", indenter(indent), i);
         if (child->argv) {
-            for (a=0,p=child->argv; *p; a++,p++) {
-                final_printf("%s   argv[%d] = %s\n",ind,a,*p);
+            for (a = 0, p = child->argv; *p; a++, p++) {
+                debug_printf_clean("%s   argv[%d] = %s\n", indenter(indent), a, *p);
             }
             globfree(&child->glob_result);
-            child->argv=NULL;
+            child->argv = NULL;
         } else if (child->group) {
-            final_printf("%s   begin group (subshell:%d)\n",ind, child->subshell);
-            ret_code = free_pipe_list(child->group,indent+3);
-            final_printf("%s   end group\n",ind);
+            debug_printf_clean("%s   begin group (subshell:%d)\n", indenter(indent), child->subshell);
+            ret_code = free_pipe_list(child->group, indent+3);
+            debug_printf_clean("%s   end group\n", indenter(indent));
         } else {
-            final_printf("%s   (nil)\n",ind);
-        }
-        for (r=child->redirects; r; r=rnext) {
-            final_printf("%s   redirect %d%s", ind, r->fd, redir_table[r->type].descrip);
+            debug_printf_clean("%s   (nil)\n", indenter(indent));
+        }
+        for (r = child->redirects; r; r = rnext) {
+            debug_printf_clean("%s   redirect %d%s", indenter(indent), r->fd, redir_table[r->type].descrip);
             if (r->dup == -1) {
                 /* guard against the case >$FOO, where foo is unset or blank */
                 if (r->word.gl_pathv) {
-                    final_printf(" %s\n", *r->word.gl_pathv);
+                    debug_printf_clean(" %s\n", *r->word.gl_pathv);
                     globfree(&r->word);
                 }
             } else {
-                final_printf("&%d\n", r->dup);
-            }
-            rnext=r->next;
+                debug_printf_clean("&%d\n", r->dup);
+            }
+            rnext = r->next;
             free(r);
         }
-        child->redirects=NULL;
+        child->redirects = NULL;
     }
     free(pi->progs);   /* children are an array, they get freed all at once */
-    pi->progs=NULL;
+    pi->progs = NULL;
+#if ENABLE_HUSH_JOB
+    free(pi->cmdtext);
+    pi->cmdtext = NULL;
+#endif
     return ret_code;
 }
@@ -1692 +2215 @@
 static int free_pipe_list(struct pipe *head, int indent)
 {
-    int rcode=0;   /* if list has no members */
+    int rcode = 0;   /* if list has no members */
     struct pipe *pi, *next;
-    char *ind = indenter(indent);
-    for (pi=head; pi; pi=next) {
-        final_printf("%s pipe reserved mode %d\n", ind, pi->r_mode);
+
+    for (pi = head; pi; pi = next) {
+        debug_printf_clean("%s pipe reserved mode %d\n", indenter(indent), pi->res_word);
         rcode = free_pipe(pi, indent);
-        final_printf("%s pipe followup code %d\n", ind, pi->followup);
-        next=pi->next;
-        pi->next=NULL;
+        debug_printf_clean("%s pipe followup code %d\n", indenter(indent), pi->followup);
+        next = pi->next;
+        /*pi->next = NULL;*/
         free(pi);
     }
@@ -1709 +2232 @@
 static int run_list(struct pipe *pi)
 {
-    int rcode=0;
-    if (fake_mode==0) {
+    int rcode = 0;
+    debug_printf_exec("run_list entered\n");
+    if (fake_mode == 0) {
+        debug_printf_exec(": run_list_real with %d members\n", pi->num_progs);
         rcode = run_list_real(pi);
     }
-    /* free_pipe_list has the side effect of clearing memory
+    /* free_pipe_list has the side effect of clearing memory.
      * In the long run that function can be merged with run_list_real,
      * but doing that now would hobble the debugging effort. */
-    free_pipe_list(pi,0);
+    free_pipe_list(pi, 0);
+    debug_printf_exec("run_list return %d\n", rcode);
     return rcode;
 }
@@ -1729 +2255 @@
 static int globhack(const char *src, int flags, glob_t *pglob)
 {
-    int cnt=0, pathc;
+    int cnt = 0, pathc;
     const char *s;
     char *dest;
-    for (cnt=1, s=src; s && *s; s++) {
+    for (cnt = 1, s = src; s && *s; s++) {
         if (*s == '\\') s++;
         cnt++;
     }
-    dest = malloc(cnt);
-    if (!dest) return GLOB_NOSPACE;
+    dest = xmalloc(cnt);
     if (!(flags & GLOB_APPEND)) {
-        pglob->gl_pathv=NULL;
-        pglob->gl_pathc=0;
-        pglob->gl_offs=0;
-        pglob->gl_offs=0;
+        pglob->gl_pathv = NULL;
+        pglob->gl_pathc = 0;
+        pglob->gl_offs = 0;
+        pglob->gl_offs = 0;
     }
     pathc = ++pglob->gl_pathc;
-    pglob->gl_pathv = realloc(pglob->gl_pathv, (pathc+1)*sizeof(*pglob->gl_pathv));
-    if (pglob->gl_pathv == NULL) return GLOB_NOSPACE;
-    pglob->gl_pathv[pathc-1]=dest;
-    pglob->gl_pathv[pathc]=NULL;
-    for (s=src; s && *s; s++, dest++) {
+    pglob->gl_pathv = xrealloc(pglob->gl_pathv, (pathc+1) * sizeof(*pglob->gl_pathv));
+    pglob->gl_pathv[pathc-1] = dest;
+    pglob->gl_pathv[pathc] = NULL;
+    for (s = src; s && *s; s++, dest++) {
         if (*s == '\\') s++;
         *dest = *s;
     }
-    *dest='\0';
+    *dest = '\0';
     return 0;
 }
@@ -1762 +2286 @@
     for (; *s; s++) {
         if (*s == '\\') s++;
-        if (strchr("*[?",*s)) return 1;
+        if (strchr("*[?", *s)) return 1;
     }
     return 0;
 }
-
-#if 0
-static void globprint(glob_t *pglob)
-{
-    int i;
-    debug_printf("glob_t at %p:\n", pglob);
-    debug_printf("  gl_pathc=%d  gl_pathv=%p  gl_offs=%d  gl_flags=%d\n",
-        pglob->gl_pathc, pglob->gl_pathv, pglob->gl_offs, pglob->gl_flags);
-    for (i=0; i<pglob->gl_pathc; i++)
-        debug_printf("pglob->gl_pathv[%d] = %p = %s\n", i,
-            pglob->gl_pathv[i], pglob->gl_pathv[i]);
-}
-#endif
 
 static int xglob(o_string *dest, int flags, glob_t *pglob)
@@ -1790 +2301 @@
             /* bash man page calls this an "explicit" null */
             gr = globhack(dest->data, flags, pglob);
-            debug_printf("globhack returned %d\n",gr);
+            debug_printf("globhack returned %d\n", gr);
         } else {
             return 0;
@@ -1796 +2307 @@
     } else if (glob_needed(dest->data)) {
         gr = glob(dest->data, flags, NULL, pglob);
-        debug_printf("glob returned %d\n",gr);
+        debug_printf("glob returned %d\n", gr);
         if (gr == GLOB_NOMATCH) {
             /* quote removal, or more accurately, backslash removal */
             gr = globhack(dest->data, flags, pglob);
-            debug_printf("globhack returned %d\n",gr);
+            debug_printf("globhack returned %d\n", gr);
         }
     } else {
         gr = globhack(dest->data, flags, pglob);
-        debug_printf("globhack returned %d\n",gr);
+        debug_printf("globhack returned %d\n", gr);
     }
     if (gr == GLOB_NOSPACE)
         bb_error_msg_and_die("out of memory during glob");
     if (gr != 0) { /* GLOB_ABORTED ? */
-        bb_error_msg("glob(3) error %d",gr);
+        bb_error_msg("glob(3) error %d", gr);
     }
     /* globprint(glob_target); */
@@ -1815 +2326 @@
 }
 
+/* expand_strvec_to_strvec() takes a list of strings, expands
+ * all variable references within and returns a pointer to
+ * a list of expanded strings, possibly with larger number
+ * of strings. (Think VAR="a b"; echo $VAR).
+ * This new list is allocated as a single malloc block.
+ * NULL-terminated list of char* pointers is at the beginning of it,
+ * followed by strings themself.
+ * Caller can deallocate entire list by single free(list). */
+
+/* Helpers first:
+ * count_XXX estimates size of the block we need. It's okay
+ * to over-estimate sizes a bit, if it makes code simpler */
+static int count_ifs(const char *str)
+{
+    int cnt = 0;
+    debug_printf_expand("count_ifs('%s') ifs='%s'", str, ifs);
+    while (1) {
+        str += strcspn(str, ifs);
+        if (!*str) break;
+        str++; /* str += strspn(str, ifs); */
+        cnt++; /* cnt += strspn(str, ifs); - but this code is larger */
+    }
+    debug_printf_expand(" return %d\n", cnt);
+    return cnt;
+}
+
+static void count_var_expansion_space(int *countp, int *lenp, char *arg)
+{
+    char first_ch;
+    int i;
+    int len = *lenp;
+    int count = *countp;
+    const char *val;
+    char *p;
+
+    while ((p = strchr(arg, SPECIAL_VAR_SYMBOL))) {
+        len += p - arg;
+        arg = ++p;
+        p = strchr(p, SPECIAL_VAR_SYMBOL);
+        first_ch = arg[0];
+
+        switch (first_ch & 0x7f) {
+        /* high bit in 1st_ch indicates that var is double-quoted */
+        case '$': /* pid */
+        case '!': /* bg pid */
+        case '?': /* exitcode */
+        case '#': /* argc */
+            len += sizeof(int)*3 + 1; /* enough for int */
+            break;
+        case '*':
+        case '@':
+            for (i = 1; i < global_argc; i++) {
+                len += strlen(global_argv[i]) + 1;
+                count++;
+                if (!(first_ch & 0x80))
+                    count += count_ifs(global_argv[i]);
+            }
+            break;
+        default:
+            *p = '\0';
+            arg[0] = first_ch & 0x7f;
+            if (isdigit(arg[0])) {
+                i = xatoi_u(arg);
+                val = NULL;
+                if (i < global_argc)
+                    val = global_argv[i];
+            } else
+                val = lookup_param(arg);
+            arg[0] = first_ch;
+            *p = SPECIAL_VAR_SYMBOL;
+
+            if (val) {
+                len += strlen(val) + 1;
+                if (!(first_ch & 0x80))
+                    count += count_ifs(val);
+            }
+        }
+        arg = ++p;
+    }
+
+    len += strlen(arg) + 1;
+    count++;
+    *lenp = len;
+    *countp = count;
+}
+
+/* Store given string, finalizing the word and starting new one whenever
+ * we encounter ifs char(s). This is used for expanding variable values.
+ * End-of-string does NOT finalize word: think about 'echo -$VAR-' */
+static int expand_on_ifs(char **list, int n, char **posp, const char *str)
+{
+    char *pos = *posp;
+    while (1) {
+        int word_len = strcspn(str, ifs);
+        if (word_len) {
+            memcpy(pos, str, word_len); /* store non-ifs chars */
+            pos += word_len;
+            str += word_len;
+        }
+        if (!*str)  /* EOL - do not finalize word */
+            break;
+        *pos++ = '\0';
+        if (n) debug_printf_expand("expand_on_ifs finalized list[%d]=%p '%s' "
+            "strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+            strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+        list[n++] = pos;
+        str += strspn(str, ifs); /* skip ifs chars */
+    }
+    *posp = pos;
+    return n;
+}
+
+/* Expand all variable references in given string, adding words to list[]
+ * at n, n+1,... positions. Return updated n (so that list[n] is next one
+ * to be filled). This routine is extremely tricky: has to deal with
+ * variables/parameters with whitespace, $* and $@, and constructs like
+ * 'echo -$*-'. If you play here, you must run testsuite afterwards! */
+/* NB: another bug is that we cannot detect empty strings yet:
+ * "" or $empty"" expands to zero words, has to expand to empty word */
+static int expand_vars_to_list(char **list, int n, char **posp, char *arg, char or_mask)
+{
+    /* or_mask is either 0 (normal case) or 0x80
+     * (expansion of right-hand side of assignment == 1-element expand) */
+
+    char first_ch, ored_ch;
+    int i;
+    const char *val;
+    char *p;
+    char *pos = *posp;
+
+    ored_ch = 0;
+
+    if (n) debug_printf_expand("expand_vars_to_list finalized list[%d]=%p '%s' "
+        "strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+        strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+    list[n++] = pos;
+
+    while ((p = strchr(arg, SPECIAL_VAR_SYMBOL))) {
+        memcpy(pos, arg, p - arg);
+        pos += (p - arg);
+        arg = ++p;
+        p = strchr(p, SPECIAL_VAR_SYMBOL);
+
+        first_ch = arg[0] | or_mask; /* forced to "quoted" if or_mask = 0x80 */
+        ored_ch |= first_ch;
+        val = NULL;
+        switch (first_ch & 0x7f) {
+        /* Highest bit in first_ch indicates that var is double-quoted */
+        case '$': /* pid */
+            /* FIXME: (echo $$) should still print pid of main shell */
+            val = utoa(getpid());
+            break;
+        case '!': /* bg pid */
+            val = last_bg_pid ? utoa(last_bg_pid) : (char*)"";
+            break;
+        case '?': /* exitcode */
+            val = utoa(last_return_code);
+            break;
+        case '#': /* argc */
+            val = utoa(global_argc ? global_argc-1 : 0);
+            break;
+        case '*':
+        case '@':
+            i = 1;
+            if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
+                while (i < global_argc) {
+                    n = expand_on_ifs(list, n, &pos, global_argv[i]);
+                    debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, global_argc-1);
+                    if (global_argv[i++][0] && i < global_argc) {
+                        /* this argv[] is not empty and not last:
+                         * put terminating NUL, start new word */
+                        *pos++ = '\0';
+                        if (n) debug_printf_expand("expand_vars_to_list 2 finalized list[%d]=%p '%s' "
+                            "strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+                            strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+                        list[n++] = pos;
+                    }
+                }
+            } else
+            /* If or_mask is nonzero, we handle assignment 'a=....$@.....'
+             * and in this case should theat it like '$*' */
+            if (first_ch == ('@'|0x80) && !or_mask) { /* quoted $@ */
+                while (1) {
+                    strcpy(pos, global_argv[i]);
+                    pos += strlen(global_argv[i]);
+                    if (++i >= global_argc)
+                        break;
+                    *pos++ = '\0';
+                    if (n) debug_printf_expand("expand_vars_to_list 3 finalized list[%d]=%p '%s' "
+                        "strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+                            strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+                    list[n++] = pos;
+                }
+            } else { /* quoted $*: add as one word */
+                while (1) {
+                    strcpy(pos, global_argv[i]);
+                    pos += strlen(global_argv[i]);
+                    if (++i >= global_argc)
+                        break;
+                    if (ifs[0])
+                        *pos++ = ifs[0];
+                }
+            }
+            break;
+        default:
+            *p = '\0';
+            arg[0] = first_ch & 0x7f;
+            if (isdigit(arg[0])) {
+                i = xatoi_u(arg);
+                val = NULL;
+                if (i < global_argc)
+                    val = global_argv[i];
+            } else
+                val = lookup_param(arg);
+            arg[0] = first_ch;
+            *p = SPECIAL_VAR_SYMBOL;
+            if (!(first_ch & 0x80)) { /* unquoted $VAR */
+                if (val) {
+                    n = expand_on_ifs(list, n, &pos, val);
+                    val = NULL;
+                }
+            } /* else: quoted $VAR, val will be appended at pos */
+        }
+        if (val) {
+            strcpy(pos, val);
+            pos += strlen(val);
+        }
+        arg = ++p;
+    }
+    debug_printf_expand("expand_vars_to_list adding tail '%s' at %p\n", arg, pos);
+    strcpy(pos, arg);
+    pos += strlen(arg) + 1;
+    if (pos == list[n-1] + 1) { /* expansion is empty */
+        if (!(ored_ch & 0x80)) { /* all vars were not quoted... */
+            debug_printf_expand("expand_vars_to_list list[%d] empty, going back\n", n);
+            pos--;
+            n--;
+        }
+    }
+
+    *posp = pos;
+    return n;
+}
+
+static char **expand_variables(char **argv, char or_mask)
+{
+    int n;
+    int count = 1;
+    int len = 0;
+    char *pos, **v, **list;
+
+    v = argv;
+    if (!*v) debug_printf_expand("count_var_expansion_space: "
+            "argv[0]=NULL count=%d len=%d alloc_space=%d\n",
+            count, len, sizeof(char*) * count + len);
+    while (*v) {
+        count_var_expansion_space(&count, &len, *v);
+        debug_printf_expand("count_var_expansion_space: "
+            "'%s' count=%d len=%d alloc_space=%d\n",
+            *v, count, len, sizeof(char*) * count + len);
+        v++;
+    }
+    len += sizeof(char*) * count; /* total to alloc */
+    list = xmalloc(len);
+    pos = (char*)(list + count);
+    debug_printf_expand("list=%p, list[0] should be %p\n", list, pos);
+    n = 0;
+    v = argv;
+    while (*v)
+        n = expand_vars_to_list(list, n, &pos, *v++, or_mask);
+
+    if (n) debug_printf_expand("finalized list[%d]=%p '%s' "
+        "strlen=%d next=%p pos=%p\n", n-1, list[n-1], list[n-1],
+        strlen(list[n-1]), list[n-1] + strlen(list[n-1]) + 1, pos);
+    list[n] = NULL;
+
+#ifdef DEBUG_EXPAND
+    {
+        int m = 0;
+        while (m <= n) {
+            debug_printf_expand("list[%d]=%p '%s'\n", m, list[m], list[m]);
+            m++;
+        }
+        debug_printf_expand("used_space=%d\n", pos - (char*)list);
+    }
+#endif
+    if (ENABLE_HUSH_DEBUG)
+        if (pos - (char*)list > len)
+            bb_error_msg_and_die("BUG in varexp");
+    return list;
+}
+
+static char **expand_strvec_to_strvec(char **argv)
+{
+    return expand_variables(argv, 0);
+}
+
+static char *expand_string_to_string(const char *str)
+{
+    char *argv[2], **list;
+
+    argv[0] = (char*)str;
+    argv[1] = NULL;
+    list = expand_variables(argv, 0x80); /* 0x80: make one-element expansion */
+    if (ENABLE_HUSH_DEBUG)
+        if (!list[0] || list[1])
+            bb_error_msg_and_die("BUG in varexp2");
+    /* actually, just move string 2*sizeof(char*) bytes back */
+    strcpy((char*)list, list[0]);
+    debug_printf_expand("string_to_string='%s'\n", (char*)list);
+    return (char*)list;
+}
+
+static char* expand_strvec_to_string(char **argv)
+{
+    char **list;
+
+    list = expand_variables(argv, 0x80);
+    /* Convert all NULs to spaces */
+    if (list[0]) {
+        int n = 1;
+        while (list[n]) {
+            if (ENABLE_HUSH_DEBUG)
+                if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
+                    bb_error_msg_and_die("BUG in varexp3");
+            list[n][-1] = ' '; /* TODO: or to ifs[0]? */
+            n++;
+        }
+    }
+    strcpy((char*)list, list[0]);
+    debug_printf_expand("strvec_to_string='%s'\n", (char*)list);
+    return (char*)list;
+}
+
 /* This is used to get/check local shell variables */
-static char *get_local_var(const char *s)
-{
-    struct variables *cur;
-
-    if (!s)
+static struct variable *get_local_var(const char *name)
+{
+    struct variable *cur;
+    int len;
+
+    if (!name)
         return NULL;
-    for (cur = top_vars; cur; cur=cur->next)
-        if(strcmp(cur->name, s)==0)
-            return cur->value;
+    len = strlen(name);
+    for (cur = top_var; cur; cur = cur->next) {
+        if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
+            return cur;
+    }
     return NULL;
 }
 
-/* This is used to set local shell variables
-   flg_export==0 if only local (not exporting) variable
-   flg_export==1 if "new" exporting environ
-   flg_export>1  if current startup environ (not call putenv()) */
-static int set_local_var(const char *s, int flg_export)
-{
-    char *name, *value;
-    int result=0;
-    struct variables *cur;
-
-    name=strdup(s);
-
-    /* Assume when we enter this function that we are already in
-     * NAME=VALUE format.  So the first order of business is to
-     * split 's' on the '=' into 'name' and 'value' */
-    value = strchr(name, '=');
-    if (value==0 && ++value==0) {
-        free(name);
+/* str holds "NAME=VAL" and is expected to be malloced.
+ * We take ownership of it. */
+static int set_local_var(char *str, int flg_export)
+{
+    struct variable *cur;
+    char *value;
+    int name_len;
+
+    value = strchr(str, '=');
+    if (!value) { /* not expected to ever happen? */
+        free(str);
         return -1;
     }
-    *value++ = 0;
-
-    for(cur = top_vars; cur; cur = cur->next) {
-        if(strcmp(cur->name, name)==0)
-            break;
-    }
-
-    if(cur) {
-        if(strcmp(cur->value, value)==0) {
-            if(flg_export>0 && cur->flg_export==0)
-                cur->flg_export=flg_export;
-            else
-                result++;
-        } else {
-            if(cur->flg_read_only) {
-                bb_error_msg("%s: readonly variable", name);
-                result = -1;
-            } else {
-                if(flg_export>0 || cur->flg_export>1)
-                    cur->flg_export=1;
-                free(cur->value);
-
-                cur->value = strdup(value);
-            }
-        }
-    } else {
-        cur = malloc(sizeof(struct variables));
-        if(!cur) {
-            result = -1;
-        } else {
-            cur->name = strdup(name);
-            if(cur->name == 0) {
-                free(cur);
-                result = -1;
-            } else {
-                struct variables *bottom = top_vars;
-                cur->value = strdup(value);
-                cur->next = 0;
-                cur->flg_export = flg_export;
-                cur->flg_read_only = 0;
-                while(bottom->next) bottom=bottom->next;
-                bottom->next = cur;
-            }
-        }
-    }
-
-    if(result==0 && cur->flg_export==1) {
-        *(value-1) = '=';
-        result = putenv(name);
-    } else {
-        free(name);
-        if(result>0)            /* equivalent to previous set */
-            result = 0;
-    }
-    return result;
+
+    name_len = value - str + 1; /* including '=' */
+    cur = top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
+    while (1) {
+        if (strncmp(cur->varstr, str, name_len) != 0) {
+            if (!cur->next) {
+                /* Bail out. Note that now cur points
+                 * to last var in linked list */
+                break;
+            }
+            cur = cur->next;
+            continue;
+        }
+        /* We found an existing var with this name */
+        *value = '\0';
+        if (cur->flg_read_only) {
+            bb_error_msg("%s: readonly variable", str);
+            free(str);
+            return -1;
+        }
+        unsetenv(str); /* just in case */
+        *value = '=';
+        if (strcmp(cur->varstr, str) == 0) {
+ free_and_exp:
+            free(str);
+            goto exp;
+        }
+        if (cur->max_len >= strlen(str)) {
+            /* This one is from startup env, reuse space */
+            strcpy(cur->varstr, str);
+            goto free_and_exp;
+        }
+        /* max_len == 0 signifies "malloced" var, which we can
+         * (and has to) free */
+        if (!cur->max_len)
+            free(cur->varstr);
+        cur->max_len = 0;
+        goto set_str_and_exp;
+    }
+
+    /* Not found - create next variable struct */
+    cur->next = xzalloc(sizeof(*cur));
+    cur = cur->next;
+
+ set_str_and_exp:
+    cur->varstr = str;
+ exp:
+    if (flg_export)
+        cur->flg_export = 1;
+    if (cur->flg_export)
+        return putenv(cur->varstr);
+    return 0;
 }
 
 static void unset_local_var(const char *name)
 {
-    struct variables *cur;
-
-    if (name) {
-        for (cur = top_vars; cur; cur=cur->next) {
-            if(strcmp(cur->name, name)==0)
-                break;
-        }
-        if(cur!=0) {
-            struct variables *next = top_vars;
-            if(cur->flg_read_only) {
+    struct variable *cur;
+    struct variable *prev = prev; /* for gcc */
+    int name_len;
+
+    if (!name)
+        return;
+    name_len = strlen(name);
+    cur = top_var;
+    while (cur) {
+        if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
+            if (cur->flg_read_only) {
                 bb_error_msg("%s: readonly variable", name);
                 return;
-            } else {
-                if(cur->flg_export)
-                    unsetenv(cur->name);
-                free(cur->name);
-                free(cur->value);
-                while (next->next != cur)
-                    next = next->next;
-                next->next = cur->next;
-            }
+            }
+        /* prev is ok to use here because 1st variable, HUSH_VERSION,
+         * is ro, and we cannot reach this code on the 1st pass */
+            prev->next = cur->next;
+            unsetenv(cur->varstr);
+            if (!cur->max_len)
+                free(cur->varstr);
             free(cur);
-        }
+            return;
+        }
+        prev = cur;
+        cur = cur->next;
     }
 }
@@ -1935 +2775 @@
 static int is_assignment(const char *s)
 {
-    if (s==NULL || !isalpha(*s)) return 0;
-    ++s;
-    while(isalnum(*s) || *s=='_') ++s;
-    return *s=='=';
+    if (!s || !isalpha(*s))
+        return 0;
+    s++;
+    while (isalnum(*s) || *s == '_')
+        s++;
+    return *s == '=';
 }
 
@@ -1948 +2790 @@
     struct in_str *input)
 {
-    struct child_prog *child=ctx->child;
+    struct child_prog *child = ctx->child;
     struct redir_struct *redir = child->redirects;
-    struct redir_struct *last_redir=NULL;
+    struct redir_struct *last_redir = NULL;
 
     /* Create a new redir_struct and drop it onto the end of the linked list */
-    while(redir) {
-        last_redir=redir;
-        redir=redir->next;
+    while (redir) {
+        last_redir = redir;
+        redir = redir->next;
     }
     redir = xmalloc(sizeof(struct redir_struct));
-    redir->next=NULL;
-    redir->word.gl_pathv=NULL;
+    redir->next = NULL;
+    redir->word.gl_pathv = NULL;
     if (last_redir) {
-        last_redir->next=redir;
+        last_redir->next = redir;
     } else {
-        child->redirects=redir;
-    }
-
-    redir->type=style;
-    redir->fd= (fd==-1) ? redir_table[style].default_fd : fd ;
+        child->redirects = redir;
+    }
+
+    redir->type = style;
+    redir->fd = (fd == -1) ? redir_table[style].default_fd : fd;
 
     debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
@@ -1983 +2825 @@
          * since we need to return and let src be expanded first.
          * Set ctx->pending_redirect, so we know what to do at the
-         * end of the next parsed word.
-         */
+         * end of the next parsed word. */
         ctx->pending_redirect = redir;
     }
@@ -1990 +2831 @@
 }
 
-static struct pipe *new_pipe(void) {
+static struct pipe *new_pipe(void)
+{
     struct pipe *pi;
-    pi = xmalloc(sizeof(struct pipe));
-    pi->num_progs = 0;
-    pi->progs = NULL;
-    pi->next = NULL;
-    pi->followup = 0;  /* invalid */
-    pi->r_mode = RES_NONE;
+    pi = xzalloc(sizeof(struct pipe));
+    /*pi->num_progs = 0;*/
+    /*pi->progs = NULL;*/
+    /*pi->next = NULL;*/
+    /*pi->followup = 0;  invalid */
+    if (RES_NONE)
+        pi->res_word = RES_NONE;
     return pi;
 }
@@ -2003 +2846 @@
 static void initialize_context(struct p_context *ctx)
 {
-    ctx->pipe=NULL;
-    ctx->pending_redirect=NULL;
-    ctx->child=NULL;
-    ctx->list_head=new_pipe();
-    ctx->pipe=ctx->list_head;
-    ctx->w=RES_NONE;
-    ctx->stack=NULL;
-    ctx->old_flag=0;
+    ctx->child = NULL;
+    ctx->pipe = ctx->list_head = new_pipe();
+    ctx->pending_redirect = NULL;
+    ctx->res_w = RES_NONE;
+    //only ctx->parse_type is not touched... is this intentional?
+    ctx->old_flag = 0;
+    ctx->stack = NULL;
     done_command(ctx);   /* creates the memory for working child */
 }
@@ -2019 +2861 @@
  * case, function, and select are obnoxious, save those for later.
  */
+#if ENABLE_HUSH_IF || ENABLE_HUSH_LOOPS
 static int reserved_word(o_string *dest, struct p_context *ctx)
 {
     struct reserved_combo {
-        char *literal;
-        int code;
-        long flag;
+        char literal[7];
+        unsigned char code;
+        int flag;
     };
     /* Mostly a list of accepted follow-up reserved words.
@@ -2031 +2874 @@
      * FLAG_START means the word must start a new compound list.
      */
-    static struct reserved_combo reserved_list[] = {
+    static const struct reserved_combo reserved_list[] = {
+#if ENABLE_HUSH_IF
         { "if",    RES_IF,    FLAG_THEN | FLAG_START },
         { "then",  RES_THEN,  FLAG_ELIF | FLAG_ELSE | FLAG_FI },
@@ -2037 +2881 @@
         { "else",  RES_ELSE,  FLAG_FI   },
         { "fi",    RES_FI,    FLAG_END  },
+#endif
+#if ENABLE_HUSH_LOOPS
         { "for",   RES_FOR,   FLAG_IN   | FLAG_START },
         { "while", RES_WHILE, FLAG_DO   | FLAG_START },
@@ -2043 +2889 @@
         { "do",    RES_DO,    FLAG_DONE },
         { "done",  RES_DONE,  FLAG_END  }
+#endif
     };
-    struct reserved_combo *r;
-    for (r=reserved_list;
-#define NRES sizeof(reserved_list)/sizeof(struct reserved_combo)
-        r<reserved_list+NRES; r++) {
-        if (strcmp(dest->data, r->literal) == 0) {
-            debug_printf("found reserved word %s, code %d\n",r->literal,r->code);
-            if (r->flag & FLAG_START) {
-                struct p_context *new = xmalloc(sizeof(struct p_context));
-                debug_printf("push stack\n");
-                if (ctx->w == RES_IN || ctx->w == RES_FOR) {
-                    syntax();
-                    free(new);
-                    ctx->w = RES_SNTX;
-                    b_reset(dest);
-                    return 1;
-                }
-                *new = *ctx;   /* physical copy */
-                initialize_context(ctx);
-                ctx->stack=new;
-            } else if ( ctx->w == RES_NONE || ! (ctx->old_flag & (1<<r->code))) {
-                syntax();
-                ctx->w = RES_SNTX;
+
+    const struct reserved_combo *r;
+
+    for (r = reserved_list; r < reserved_list + ARRAY_SIZE(reserved_list); r++) {
+        if (strcmp(dest->data, r->literal) != 0)
+            continue;
+        debug_printf("found reserved word %s, code %d\n", r->literal, r->code);
+        if (r->flag & FLAG_START) {
+            struct p_context *new;
+            debug_printf("push stack\n");
+#if ENABLE_HUSH_LOOPS
+            if (ctx->res_w == RES_IN || ctx->res_w == RES_FOR) {
+                syntax("malformed for"); /* example: 'for if' */
+                ctx->res_w = RES_SNTX;
                 b_reset(dest);
                 return 1;
             }
-            ctx->w=r->code;
-            ctx->old_flag = r->flag;
-            if (ctx->old_flag & FLAG_END) {
-                struct p_context *old;
-                debug_printf("pop stack\n");
-                done_pipe(ctx,PIPE_SEQ);
-                old = ctx->stack;
-                old->child->group = ctx->list_head;
-                old->child->subshell = 0;
-                *ctx = *old;   /* physical copy */
-                free(old);
-            }
-            b_reset (dest);
+#endif
+            new = xmalloc(sizeof(*new));
+            *new = *ctx;   /* physical copy */
+            initialize_context(ctx);
+            ctx->stack = new;
+        } else if (ctx->res_w == RES_NONE || !(ctx->old_flag & (1 << r->code))) {
+            syntax(NULL);
+            ctx->res_w = RES_SNTX;
+            b_reset(dest);
             return 1;
         }
+        ctx->res_w = r->code;
+        ctx->old_flag = r->flag;
+        if (ctx->old_flag & FLAG_END) {
+            struct p_context *old;
+            debug_printf("pop stack\n");
+            done_pipe(ctx, PIPE_SEQ);
+            old = ctx->stack;
+            old->child->group = ctx->list_head;
+            old->child->subshell = 0;
+            *ctx = *old;   /* physical copy */
+            free(old);
+        }
+        b_reset(dest);
+        return 1;
     }
     return 0;
 }
-
-/* normal return is 0.
+#else
+#define reserved_word(dest, ctx) ((int)0)
+#endif
+
+/* Normal return is 0.
  * Syntax or xglob errors return 1. */
 static int done_word(o_string *dest, struct p_context *ctx)
 {
-    struct child_prog *child=ctx->child;
+    struct child_prog *child = ctx->child;
     glob_t *glob_target;
     int gr, flags = 0;
 
-    debug_printf("done_word: %s %p\n", dest->data, child);
+    debug_printf_parse("done_word entered: '%s' %p\n", dest->data, child);
     if (dest->length == 0 && !dest->nonnull) {
-        debug_printf("  true null, ignored\n");
+        debug_printf_parse("done_word return 0: true null, ignored\n");
         return 0;
     }
@@ -2105 +2957 @@
     } else {
         if (child->group) {
-            syntax();
-            return 1;  /* syntax error, groups and arglists don't mix */
-        }
-        if (!child->argv && (ctx->type & FLAG_PARSE_SEMICOLON)) {
-            debug_printf("checking %s for reserved-ness\n",dest->data);
-            if (reserved_word(dest,ctx)) return ctx->w==RES_SNTX;
+            syntax(NULL);
+            debug_printf_parse("done_word return 1: syntax error, groups and arglists don't mix\n");
+            return 1;
+        }
+        if (!child->argv && (ctx->parse_type & PARSEFLAG_SEMICOLON)) {
+            debug_printf_parse(": checking '%s' for reserved-ness\n", dest->data);
+            if (reserved_word(dest, ctx)) {
+                debug_printf_parse("done_word return %d\n", (ctx->res_w == RES_SNTX));
+                return (ctx->res_w == RES_SNTX);
+            }
         }
         glob_target = &child->glob_result;
-        if (child->argv) flags |= GLOB_APPEND;
+        if (child->argv)
+            flags |= GLOB_APPEND;
     }
     gr = xglob(dest, flags, glob_target);
-    if (gr != 0) return 1;
+    if (gr != 0) {
+        debug_printf_parse("done_word return 1: xglob returned %d\n", gr);
+        return 1;
+    }
 
     b_reset(dest);
     if (ctx->pending_redirect) {
-        ctx->pending_redirect=NULL;
+        ctx->pending_redirect = NULL;
         if (glob_target->gl_pathc != 1) {
             bb_error_msg("ambiguous redirect");
+            debug_printf_parse("done_word return 1: ambiguous redirect\n");
             return 1;
         }
@@ -2128 +2989 @@
         child->argv = glob_target->gl_pathv;
     }
-    if (ctx->w == RES_FOR) {
-        done_word(dest,ctx);
-        done_pipe(ctx,PIPE_SEQ);
-    }
+#if ENABLE_HUSH_LOOPS
+    if (ctx->res_w == RES_FOR) {
+        done_word(dest, ctx);
+        done_pipe(ctx, PIPE_SEQ);
+    }
+#endif
+    debug_printf_parse("done_word return 0\n");
     return 0;
 }
@@ -2140 +3004 @@
 {
     /* The child is really already in the pipe structure, so
-     * advance the pipe counter and make a new, null child.
-     * Only real trickiness here is that the uncommitted
-     * child structure, to which ctx->child points, is not
-     * counted in pi->num_progs. */
-    struct pipe *pi=ctx->pipe;
-    struct child_prog *prog=ctx->child;
-
-    if (prog && prog->group == NULL
-             && prog->argv == NULL
-             && prog->redirects == NULL) {
-        debug_printf("done_command: skipping null command\n");
-        return 0;
-    } else if (prog) {
+     * advance the pipe counter and make a new, null child. */
+    struct pipe *pi = ctx->pipe;
+    struct child_prog *child = ctx->child;
+
+    if (child) {
+        if (child->group == NULL
+         && child->argv == NULL
+         && child->redirects == NULL
+        ) {
+            debug_printf_parse("done_command: skipping null cmd, num_progs=%d\n", pi->num_progs);
+            return pi->num_progs;
+        }
         pi->num_progs++;
-        debug_printf("done_command: num_progs incremented to %d\n",pi->num_progs);
+        debug_printf_parse("done_command: ++num_progs=%d\n", pi->num_progs);
     } else {
-        debug_printf("done_command: initializing\n");
-    }
+        debug_printf_parse("done_command: initializing, num_progs=%d\n", pi->num_progs);
+    }
+
+    /* Only real trickiness here is that the uncommitted
+     * child structure is not counted in pi->num_progs. */
     pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1));
-
-    prog = pi->progs + pi->num_progs;
-    prog->redirects = NULL;
-    prog->argv = NULL;
-    prog->is_stopped = 0;
-    prog->group = NULL;
-    prog->glob_result.gl_pathv = NULL;
-    prog->family = pi;
-    prog->sp = 0;
-    ctx->child = prog;
-    prog->type = ctx->type;
-
+    child = &pi->progs[pi->num_progs];
+
+    memset(child, 0, sizeof(*child));
+    /*child->redirects = NULL;*/
+    /*child->argv = NULL;*/
+    /*child->is_stopped = 0;*/
+    /*child->group = NULL;*/
+    /*child->glob_result.gl_pathv = NULL;*/
+    child->family = pi;
+    //sp: /*child->sp = 0;*/
+    //pt: child->parse_type = ctx->parse_type;
+
+    ctx->child = child;
     /* but ctx->pipe and ctx->list_head remain unchanged */
-    return 0;
+
+    return pi->num_progs; /* used only for 0/nonzero check */
 }
 
@@ -2178 +3046 @@
 {
     struct pipe *new_p;
-    done_command(ctx);  /* implicit closure of previous command */
-    debug_printf("done_pipe, type %d\n", type);
+    int not_null;
+
+    debug_printf_parse("done_pipe entered, followup %d\n", type);
+    not_null = done_command(ctx);  /* implicit closure of previous command */
     ctx->pipe->followup = type;
-    ctx->pipe->r_mode = ctx->w;
-    new_p=new_pipe();
-    ctx->pipe->next = new_p;
-    ctx->pipe = new_p;
-    ctx->child = NULL;
-    done_command(ctx);  /* set up new pipe to accept commands */
+    ctx->pipe->res_word = ctx->res_w;
+    /* Without this check, even just <enter> on command line generates
+     * tree of three NOPs (!). Which is harmless but annoying.
+     * IOW: it is safe to do it unconditionally. */
+    if (not_null) {
+        new_p = new_pipe();
+        ctx->pipe->next = new_p;
+        ctx->pipe = new_p;
+        ctx->child = NULL;
+        done_command(ctx);  /* set up new pipe to accept commands */
+    }
+    debug_printf_parse("done_pipe return 0\n");
     return 0;
 }
@@ -2196 +3072 @@
 static int redirect_dup_num(struct in_str *input)
 {
-    int ch, d=0, ok=0;
+    int ch, d = 0, ok = 0;
     ch = b_peek(input);
     if (ch != '&') return -1;
 
     b_getch(input);  /* get the & */
-    ch=b_peek(input);
+    ch = b_peek(input);
     if (ch == '-') {
         b_getch(input);
@@ -2207 +3083 @@
     }
     while (isdigit(ch)) {
-        d = d*10+(ch-'0');
-        ok=1;
+        d = d*10 + (ch-'0');
+        ok = 1;
         b_getch(input);
         ch = b_peek(input);
@@ -2233 +3109 @@
     int num;
 
-    if (o->length==0) return -1;
-    for(num=0; num<o->length; num++) {
-        if (!isdigit(*(o->data+num))) {
+    if (o->length == 0)
+        return -1;
+    for (num = 0; num < o->length; num++) {
+        if (!isdigit(*(o->data + num))) {
             return -1;
         }
     }
     /* reuse num (and save an int) */
-    num=atoi(o->data);
+    num = atoi(o->data);
     b_reset(o);
     return num;
 }
 
+#if ENABLE_HUSH_TICK
 static FILE *generate_stream_from_list(struct pipe *head)
 {
     FILE *pf;
-#if 1
     int pid, channel[2];
-    if (pipe(channel)<0) bb_perror_msg_and_die("pipe");
-#if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
-    pid=fork();
+
+    xpipe(channel);
+#if BB_MMU
+    pid = fork();
 #else
-    pid=vfork();
-#endif
-    if (pid<0) {
+    pid = vfork();
+#endif
+    if (pid < 0) {
         bb_perror_msg_and_die("fork");
-    } else if (pid==0) {
+    } else if (pid == 0) {
         close(channel[0]);
         if (channel[1] != 1) {
-            dup2(channel[1],1);
+            dup2(channel[1], 1);
             close(channel[1]);
         }
-#if 0
-#define SURROGATE "surrogate response"
-        write(1,SURROGATE,sizeof(SURROGATE));
-        _exit(run_list(head));
-#else
+        /* Prevent it from trying to handle ctrl-z etc */
+#if ENABLE_HUSH_JOB
+        run_list_level = 1;
+#endif
+        /* Process substitution is not considered to be usual
+         * 'command execution'.
+         * SUSv3 says ctrl-Z should be ignored, ctrl-C should not. */
+        /* Not needed, we are relying on it being disabled
+         * everywhere outside actual command execution. */
+        /*set_jobctrl_sighandler(SIG_IGN);*/
+        set_misc_sighandler(SIG_DFL);
         _exit(run_list_real(head));   /* leaks memory */
-#endif
-    }
-    debug_printf("forked child %d\n",pid);
+    }
     close(channel[1]);
-    pf = fdopen(channel[0],"r");
-    debug_printf("pipe on FILE *%p\n",pf);
-#else
-    free_pipe_list(head,0);
-    pf=popen("echo surrogate response","r");
-    debug_printf("started fake pipe on FILE *%p\n",pf);
-#endif
+    pf = fdopen(channel[0], "r");
     return pf;
 }
 
-/* this version hacked for testing purposes */
-/* return code is exit status of the process that is run. */
-static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end)
-{
-    int retcode;
-    o_string result=NULL_O_STRING;
+/* Return code is exit status of the process that is run. */
+static int process_command_subs(o_string *dest, struct p_context *ctx,
+    struct in_str *input, const char *subst_end)
+{
+    int retcode, ch, eol_cnt;
+    o_string result = NULL_O_STRING;
     struct p_context inner;
     FILE *p;
     struct in_str pipe_str;
+
     initialize_context(&inner);
 
     /* recursion to generate command */
     retcode = parse_stream(&result, &inner, input, subst_end);
-    if (retcode != 0) return retcode;  /* syntax error or EOF */
+    if (retcode != 0)
+        return retcode;  /* syntax error or EOF */
     done_word(&result, &inner);
     done_pipe(&inner, PIPE_SEQ);
     b_free(&result);
 
-    p=generate_stream_from_list(inner.list_head);
-    if (p==NULL) return 1;
+    p = generate_stream_from_list(inner.list_head);
+    if (p == NULL) return 1;
     mark_open(fileno(p));
     setup_file_in_str(&pipe_str, p);
 
     /* now send results of command back into original context */
-    retcode = parse_stream(dest, ctx, &pipe_str, '\0');
-    /* XXX In case of a syntax error, should we try to kill the child?
-     * That would be tough to do right, so just read until EOF. */
-    if (retcode == 1) {
-        while (b_getch(&pipe_str)!=EOF) { /* discard */ };
+    eol_cnt = 0;
+    while ((ch = b_getch(&pipe_str)) != EOF) {
+        if (ch == '\n') {
+            eol_cnt++;
+            continue;
+        }
+        while (eol_cnt) {
+            b_addqchr(dest, '\n', dest->quote);
+            eol_cnt--;
+        }
+        b_addqchr(dest, ch, dest->quote);
     }
 
@@ -2318 +3202 @@
     /* This is the step that wait()s for the child.  Should be pretty
      * safe, since we just read an EOF from its stdout.  We could try
-     * to better, by using wait(), and keeping track of background jobs
+     * to do better, by using wait(), and keeping track of background jobs
      * at the same time.  That would be a lot of work, and contrary
      * to the KISS philosophy of this program. */
     mark_closed(fileno(p));
-    retcode=pclose(p);
-    free_pipe_list(inner.list_head,0);
-    debug_printf("pclosed, retcode=%d\n",retcode);
-    /* XXX this process fails to trim a single trailing newline */
+    retcode = fclose(p);
+    free_pipe_list(inner.list_head, 0);
+    debug_printf("closed FILE from child, retcode=%d\n", retcode);
     return retcode;
 }
+#endif
 
 static int parse_group(o_string *dest, struct p_context *ctx,
     struct in_str *input, int ch)
 {
-    int rcode, endch=0;
+    int rcode;
+    const char *endch = NULL;
     struct p_context sub;
     struct child_prog *child = ctx->child;
+
+    debug_printf_parse("parse_group entered\n");
     if (child->argv) {
-        syntax();
-        return 1;  /* syntax error, groups and arglists don't mix */
+        syntax(NULL);
+        debug_printf_parse("parse_group return 1: syntax error, groups and arglists don't mix\n");
+        return 1;
     }
     initialize_context(&sub);
-    switch(ch) {
-        case '(': endch=')'; child->subshell=1; break;
-        case '{': endch='}'; break;
-        default: syntax();   /* really logic error */
-    }
-    rcode=parse_stream(dest,&sub,input,endch);
-    done_word(dest,&sub); /* finish off the final word in the subcontext */
+    endch = "}";
+    if (ch == '(') {
+        endch = ")";
+        child->subshell = 1;
+    }
+    rcode = parse_stream(dest, &sub, input, endch);
+//vda: err chk?
+    done_word(dest, &sub); /* finish off the final word in the subcontext */
     done_pipe(&sub, PIPE_SEQ);  /* and the final command there, too */
     child->group = sub.list_head;
+
+    debug_printf_parse("parse_group return %d\n", rcode);
     return rcode;
     /* child remains "open", available for possible redirects */
 }
 
-/* basically useful version until someone wants to get fancier,
+/* Basically useful version until someone wants to get fancier,
  * see the bash man page under "Parameter Expansion" */
-static char *lookup_param(char *src)
-{
-    char *p=NULL;
-    if (src) {
-        p = getenv(src);
-        if (!p)
-            p = get_local_var(src);
-    }
-    return p;
+static const char *lookup_param(const char *src)
+{
+    struct variable *var = get_local_var(src);
+    if (var)
+        return strchr(var->varstr, '=') + 1;
+    return NULL;
 }
 
@@ -2369 +3257 @@
 static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input)
 {
-    int i, advance=0;
-    char sep[]=" ";
-    int ch = input->peek(input);  /* first character after the $ */
-    debug_printf("handle_dollar: ch=%c\n",ch);
+    int ch = b_peek(input);  /* first character after the $ */
+    unsigned char quote_mask = dest->quote ? 0x80 : 0;
+
+    debug_printf_parse("handle_dollar entered: ch='%c'\n", ch);
     if (isalpha(ch)) {
         b_addchr(dest, SPECIAL_VAR_SYMBOL);
-        ctx->child->sp++;
-        while(ch=b_peek(input),isalnum(ch) || ch=='_') {
+        //sp: ctx->child->sp++;
+        while (1) {
+            debug_printf_parse(": '%c'\n", ch);
             b_getch(input);
-            b_addchr(dest,ch);
+            b_addchr(dest, ch | quote_mask);
+            quote_mask = 0;
+            ch = b_peek(input);
+            if (!isalnum(ch) && ch != '_')
+                break;
         }
         b_addchr(dest, SPECIAL_VAR_SYMBOL);
     } else if (isdigit(ch)) {
-        i = ch-'0';  /* XXX is $0 special? */
-        if (i<global_argc) {
-            parse_string(dest, ctx, global_argv[i]); /* recursion */
-        }
-        advance = 1;
+ make_one_char_var:
+        b_addchr(dest, SPECIAL_VAR_SYMBOL);
+        //sp: ctx->child->sp++;
+        debug_printf_parse(": '%c'\n", ch);
+        b_getch(input);
+        b_addchr(dest, ch | quote_mask);
+        b_addchr(dest, SPECIAL_VAR_SYMBOL);
     } else switch (ch) {
-        case '$':
-            b_adduint(dest,getpid());
-            advance = 1;
-            break;
-        case '!':
-            if (last_bg_pid > 0) b_adduint(dest, last_bg_pid);
-            advance = 1;
-            break;
-        case '?':
-            b_adduint(dest,last_return_code);
-            advance = 1;
-            break;
-        case '#':
-            b_adduint(dest,global_argc ? global_argc-1 : 0);
-            advance = 1;
-            break;
+        case '$': /* pid */
+        case '!': /* last bg pid */
+        case '?': /* last exit code */
+        case '#': /* number of args */
+        case '*': /* args */
+        case '@': /* args */
+            goto make_one_char_var;
         case '{':
             b_addchr(dest, SPECIAL_VAR_SYMBOL);
-            ctx->child->sp++;
+            //sp: ctx->child->sp++;
             b_getch(input);
             /* XXX maybe someone will try to escape the '}' */
-            while(ch=b_getch(input),ch!=EOF && ch!='}') {
-                b_addchr(dest,ch);
-            }
-            if (ch != '}') {
-                syntax();
-                return 1;
+            while (1) {
+                ch = b_getch(input);
+                if (ch == '}')
+                    break;
+                if (!isalnum(ch) && ch != '_') {
+                    syntax("unterminated ${name}");
+                    debug_printf_parse("handle_dollar return 1: unterminated ${name}\n");
+                    return 1;
+                }
+                debug_printf_parse(": '%c'\n", ch);
+                b_addchr(dest, ch | quote_mask);
+                quote_mask = 0;
             }
             b_addchr(dest, SPECIAL_VAR_SYMBOL);
             break;
+#if ENABLE_HUSH_TICK
         case '(':
             b_getch(input);
-            process_command_subs(dest, ctx, input, ')');
+            process_command_subs(dest, ctx, input, ")");
             break;
-        case '*':
-            sep[0]=ifs[0];
-            for (i=1; i<global_argc; i++) {
-                parse_string(dest, ctx, global_argv[i]);
-                if (i+1 < global_argc) parse_string(dest, ctx, sep);
-            }
-            break;
-        case '@':
+#endif
         case '-':
         case '_':
             /* still unhandled, but should be eventually */
-            bb_error_msg("unhandled syntax: $%c",ch);
+            bb_error_msg("unhandled syntax: $%c", ch);
             return 1;
             break;
         default:
-            b_addqchr(dest,'$',dest->quote);
-    }
-    /* Eat the character if the flag was set.  If the compiler
-     * is smart enough, we could substitute "b_getch(input);"
-     * for all the "advance = 1;" above, and also end up with
-     * a nice size-optimized program.  Hah!  That'll be the day.
-     */
-    if (advance) b_getch(input);
+            b_addqchr(dest, '$', dest->quote);
+    }
+    debug_printf_parse("handle_dollar return 0\n");
     return 0;
 }
 
-int parse_string(o_string *dest, struct p_context *ctx, const char *src)
-{
-    struct in_str foo;
-    setup_string_in_str(&foo, src);
-    return parse_stream(dest, ctx, &foo, '\0');
-}
-
 /* return code is 0 for normal exit, 1 for syntax error */
-int parse_stream(o_string *dest, struct p_context *ctx,
-    struct in_str *input, int end_trigger)
+static int parse_stream(o_string *dest, struct p_context *ctx,
+    struct in_str *input, const char *end_trigger)
 {
     int ch, m;
@@ -2468 +3342 @@
      * found.  When recursing, quote state is passed in via dest->quote. */
 
-    debug_printf("parse_stream, end_trigger=%d\n",end_trigger);
-    while ((ch=b_getch(input))!=EOF) {
-        m = map[ch];
-        next = (ch == '\n') ? 0 : b_peek(input);
-        debug_printf("parse_stream: ch=%c (%d) m=%d quote=%d\n",
-            ch,ch,m,dest->quote);
-        if (m==0 || ((m==1 || m==2) && dest->quote)) {
+    debug_printf_parse("parse_stream entered, end_trigger='%s'\n", end_trigger);
+
+    while (1) {
+        m = CHAR_IFS;
+        next = '\0';
+        ch = b_getch(input);
+        if (ch != EOF) {
+            m = charmap[ch];
+            if (ch != '\n')
+                next = b_peek(input);
+        }
+        debug_printf_parse(": ch=%c (%d) m=%d quote=%d\n",
+                        ch, ch, m, dest->quote);
+        if (m == CHAR_ORDINARY
+         || (m != CHAR_SPECIAL && dest->quote)
+        ) {
+            if (ch == EOF) {
+                syntax("unterminated \"");
+                debug_printf_parse("parse_stream return 1: unterminated \"\n");
+                return 1;
+            }
             b_addqchr(dest, ch, dest->quote);
-        } else {
-            if (m==2) {  /* unquoted IFS */
-                if (done_word(dest, ctx)) {
-                    return 1;
-                }
-                /* If we aren't performing a substitution, treat a newline as a
-                 * command separator.  */
-                if (end_trigger != '\0' && ch=='\n')
-                    done_pipe(ctx,PIPE_SEQ);
-            }
-            if (ch == end_trigger && !dest->quote && ctx->w==RES_NONE) {
-                debug_printf("leaving parse_stream (triggered)\n");
-                return 0;
-            }
-#if 0
-            if (ch=='\n') {
-                /* Yahoo!  Time to run with it! */
-                done_pipe(ctx,PIPE_SEQ);
-                run_list(ctx->list_head);
-                initialize_context(ctx);
-            }
-#endif
-            if (m!=2) switch (ch) {
+            continue;
+        }
+        if (m == CHAR_IFS) {
+            if (done_word(dest, ctx)) {
+                debug_printf_parse("parse_stream return 1: done_word!=0\n");
+                return 1;
+            }
+            if (ch == EOF)
+                break;
+            /* If we aren't performing a substitution, treat
+             * a newline as a command separator.
+             * [why we don't handle it exactly like ';'? --vda] */
+            if (end_trigger && ch == '\n') {
+                done_pipe(ctx, PIPE_SEQ);
+            }
+        }
+        if ((end_trigger && strchr(end_trigger, ch))
+         && !dest->quote && ctx->res_w == RES_NONE
+        ) {
+            debug_printf_parse("parse_stream return 0: end_trigger char found\n");
+            return 0;
+        }
+        if (m == CHAR_IFS)
+            continue;
+        switch (ch) {
         case '#':
             if (dest->length == 0 && !dest->quote) {
-                while(ch=b_peek(input),ch!=EOF && ch!='\n') { b_getch(input); }
+                while (1) {
+                    ch = b_peek(input);
+                    if (ch == EOF || ch == '\n')
+                        break;
+                    b_getch(input);
+                }
             } else {
                 b_addqchr(dest, ch, dest->quote);
@@ -2508 +3403 @@
         case '\\':
             if (next == EOF) {
-                syntax();
+                syntax("\\<eof>");
+                debug_printf_parse("parse_stream return 1: \\<eof>\n");
                 return 1;
             }
@@ -2515 +3411 @@
             break;
         case '$':
-            if (handle_dollar(dest, ctx, input)!=0) return 1;
+            if (handle_dollar(dest, ctx, input) != 0) {
+                debug_printf_parse("parse_stream return 1: handle_dollar returned non-0\n");
+                return 1;
+            }
             break;
         case '\'':
             dest->nonnull = 1;
-            while(ch=b_getch(input),ch!=EOF && ch!='\'') {
-                b_addchr(dest,ch);
-            }
-            if (ch==EOF) {
-                syntax();
+            while (1) {
+                ch = b_getch(input);
+                if (ch == EOF || ch == '\'')
+                    break;
+                b_addchr(dest, ch);
+            }
+            if (ch == EOF) {
+                syntax("unterminated '");
+                debug_printf_parse("parse_stream return 1: unterminated '\n");
                 return 1;
             }
@@ -2531 +3434 @@
             dest->quote = !dest->quote;
             break;
+#if ENABLE_HUSH_TICK
         case '`':
-            process_command_subs(dest, ctx, input, '`');
+            process_command_subs(dest, ctx, input, "`");
             break;
+#endif
         case '>':
             redir_fd = redirect_opt_num(dest);
             done_word(dest, ctx);
-            redir_style=REDIRECT_OVERWRITE;
+            redir_style = REDIRECT_OVERWRITE;
             if (next == '>') {
-                redir_style=REDIRECT_APPEND;
+                redir_style = REDIRECT_APPEND;
                 b_getch(input);
-            } else if (next == '(') {
-                syntax();   /* until we support >(list) Process Substitution */
+            }
+#if 0
+            else if (next == '(') {
+                syntax(">(process) not supported");
+                debug_printf_parse("parse_stream return 1: >(process) not supported\n");
                 return 1;
             }
+#endif
             setup_redirect(ctx, redir_fd, redir_style, input);
             break;
@@ -2550 +3459 @@
             redir_fd = redirect_opt_num(dest);
             done_word(dest, ctx);
-            redir_style=REDIRECT_INPUT;
+            redir_style = REDIRECT_INPUT;
             if (next == '<') {
-                redir_style=REDIRECT_HEREIS;
+                redir_style = REDIRECT_HEREIS;
                 b_getch(input);
             } else if (next == '>') {
-                redir_style=REDIRECT_IO;
+                redir_style = REDIRECT_IO;
                 b_getch(input);
-            } else if (next == '(') {
-                syntax();   /* until we support <(list) Process Substitution */
+            }
+#if 0
+            else if (next == '(') {
+                syntax("<(process) not supported");
+                debug_printf_parse("parse_stream return 1: <(process) not supported\n");
                 return 1;
             }
+#endif
             setup_redirect(ctx, redir_fd, redir_style, input);
             break;
         case ';':
             done_word(dest, ctx);
-            done_pipe(ctx,PIPE_SEQ);
+            done_pipe(ctx, PIPE_SEQ);
             break;
         case '&':
             done_word(dest, ctx);
-            if (next=='&') {
+            if (next == '&') {
                 b_getch(input);
-                done_pipe(ctx,PIPE_AND);
+                done_pipe(ctx, PIPE_AND);
             } else {
-                done_pipe(ctx,PIPE_BG);
+                done_pipe(ctx, PIPE_BG);
             }
             break;
         case '|':
             done_word(dest, ctx);
-            if (next=='|') {
+            if (next == '|') {
                 b_getch(input);
-                done_pipe(ctx,PIPE_OR);
+                done_pipe(ctx, PIPE_OR);
             } else {
                 /* we could pick up a file descriptor choice here
@@ -2590 +3503 @@
         case '(':
         case '{':
-            if (parse_group(dest, ctx, input, ch)!=0) return 1;
+            if (parse_group(dest, ctx, input, ch) != 0) {
+                debug_printf_parse("parse_stream return 1: parse_group returned non-0\n");
+                return 1;
+            }
             break;
         case ')':
         case '}':
-            syntax();   /* Proper use of this character caught by end_trigger */
+            syntax("unexpected }");   /* Proper use of this character is caught by end_trigger */
+            debug_printf_parse("parse_stream return 1: unexpected '}'\n");
             return 1;
-            break;
         default:
-            syntax();   /* this is really an internal logic error */
-            return 1;
-            }
-        }
-    }
-    /* complain if quote?  No, maybe we just finished a command substitution
+            if (ENABLE_HUSH_DEBUG)
+                bb_error_msg_and_die("BUG: unexpected %c\n", ch);
+        }
+    }
+    /* Complain if quote?  No, maybe we just finished a command substitution
      * that was quoted.  Example:
      * $ echo "`cat foo` plus more"
      * and we just got the EOF generated by the subshell that ran "cat foo"
-     * The only real complaint is if we got an EOF when end_trigger != '\0',
+     * The only real complaint is if we got an EOF when end_trigger != NULL,
      * that is, we were really supposed to get end_trigger, and never got
      * one before the EOF.  Can't use the standard "syntax error" return code,
      * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
-    debug_printf("leaving parse_stream (EOF)\n");
-    if (end_trigger != '\0') return -1;
+    debug_printf_parse("parse_stream return %d\n", -(end_trigger != NULL));
+    if (end_trigger)
+        return -1;
     return 0;
 }
 
-static void mapset(const char *set, int code)
-{
-    const unsigned char *s;
-    for (s = (const unsigned char *)set; *s; s++) map[(int)*s] = code;
-}
-
-static void update_ifs_map(void)
-{
-    /* char *ifs and char map[256] are both globals. */
+static void set_in_charmap(const char *set, int code)
+{
+    while (*set)
+        charmap[(unsigned char)*set++] = code;
+}
+
+static void update_charmap(void)
+{
+    /* char *ifs and char charmap[256] are both globals. */
     ifs = getenv("IFS");
-    if (ifs == NULL) ifs=" \t\n";
+    if (ifs == NULL)
+        ifs = " \t\n";
     /* Precompute a list of 'flow through' behavior so it can be treated
      * quickly up front.  Computation is necessary because of IFS.
      * Special case handling of IFS == " \t\n" is not implemented.
-     * The map[] array only really needs two bits each, and on most machines
-     * that would be faster because of the reduced L1 cache footprint.
+     * The charmap[] array only really needs two bits each,
+     * and on most machines that would be faster (reduced L1 cache use).
      */
-    memset(map,0,sizeof(map)); /* most characters flow through always */
-    mapset("\\$'\"`", 3);      /* never flow through */
-    mapset("<>;&|(){}#", 1);   /* flow through if quoted */
-    mapset(ifs, 2);            /* also flow through if quoted */
+    memset(charmap, CHAR_ORDINARY, sizeof(charmap));
+#if ENABLE_HUSH_TICK
+    set_in_charmap("\\$\"`", CHAR_SPECIAL);
+#else
+    set_in_charmap("\\$\"", CHAR_SPECIAL);
+#endif
+    set_in_charmap("<>;&|(){}#'", CHAR_ORDINARY_IF_QUOTED);
+    set_in_charmap(ifs, CHAR_IFS);  /* are ordinary if quoted */
 }
 
 /* most recursion does not come through here, the exception is
- * from builtin_source() */
-int parse_stream_outer(struct in_str *inp, int flag)
-{
-
+ * from builtin_source() and builtin_eval() */
+static int parse_and_run_stream(struct in_str *inp, int parse_flag)
+{
     struct p_context ctx;
-    o_string temp=NULL_O_STRING;
+    o_string temp = NULL_O_STRING;
     int rcode;
     do {
-        ctx.type = flag;
+        ctx.parse_type = parse_flag;
         initialize_context(&ctx);
-        update_ifs_map();
-        if (!(flag & FLAG_PARSE_SEMICOLON) || (flag & FLAG_REPARSING)) mapset(";$&|", 0);
-        inp->promptmode=1;
-        rcode = parse_stream(&temp, &ctx, inp, '\n');
+        update_charmap();
+        if (!(parse_flag & PARSEFLAG_SEMICOLON) || (parse_flag & PARSEFLAG_REPARSING))
+            set_in_charmap(";$&|", CHAR_ORDINARY);
+#if ENABLE_HUSH_INTERACTIVE
+        inp->promptmode = 0; /* PS1 */
+#endif
+        /* We will stop & execute after each ';' or '\n'.
+         * Example: "sleep 9999; echo TEST" + ctrl-C:
+         * TEST should be printed */
+        rcode = parse_stream(&temp, &ctx, inp, ";\n");
         if (rcode != 1 && ctx.old_flag != 0) {
-            syntax();
+            syntax(NULL);
         }
         if (rcode != 1 && ctx.old_flag == 0) {
             done_word(&temp, &ctx);
-            done_pipe(&ctx,PIPE_SEQ);
+            done_pipe(&ctx, PIPE_SEQ);
+            debug_print_tree(ctx.list_head, 0);
+            debug_printf_exec("parse_stream_outer: run_list\n");
             run_list(ctx.list_head);
         } else {
@@ -2669 +3597 @@
             temp.quote = 0;
             inp->p = NULL;
-            free_pipe_list(ctx.list_head,0);
+            free_pipe_list(ctx.list_head, 0);
         }
         b_free(&temp);
-    } while (rcode != -1 && !(flag & FLAG_EXIT_FROM_LOOP));   /* loop on syntax errors, return on EOF */
+    } while (rcode != -1 && !(parse_flag & PARSEFLAG_EXIT_FROM_LOOP));   /* loop on syntax errors, return on EOF */
     return 0;
 }
 
-static int parse_string_outer(const char *s, int flag)
+static int parse_and_run_string(const char *s, int parse_flag)
 {
     struct in_str input;
     setup_string_in_str(&input, s);
-    return parse_stream_outer(&input, flag);
-}
-
-static int parse_file_outer(FILE *f)
+    return parse_and_run_stream(&input, parse_flag);
+}
+
+static int parse_and_run_file(FILE *f)
 {
     int rcode;
     struct in_str input;
     setup_file_in_str(&input, f);
-    rcode = parse_stream_outer(&input, FLAG_PARSE_SEMICOLON);
+    rcode = parse_and_run_stream(&input, PARSEFLAG_SEMICOLON);
     return rcode;
 }
 
+#if ENABLE_HUSH_JOB
 /* Make sure we have a controlling tty.  If we get started under a job
  * aware app (like bash for example), make sure we are now in charge so
@@ -2697 +3626 @@
 static void setup_job_control(void)
 {
-    static pid_t shell_pgrp;
-    /* Loop until we are in the foreground.  */
-    while (tcgetpgrp (shell_terminal) != (shell_pgrp = getpgrp ()))
-        kill (- shell_pgrp, SIGTTIN);
-
-    /* Ignore interactive and job-control signals.  */
-    signal(SIGINT, SIG_IGN);
-    signal(SIGQUIT, SIG_IGN);
-    signal(SIGTERM, SIG_IGN);
-    signal(SIGTSTP, SIG_IGN);
-    signal(SIGTTIN, SIG_IGN);
-    signal(SIGTTOU, SIG_IGN);
-    signal(SIGCHLD, SIG_IGN);
+    pid_t shell_pgrp;
+
+    saved_task_pgrp = shell_pgrp = getpgrp();
+    debug_printf_jobs("saved_task_pgrp=%d\n", saved_task_pgrp);
+    fcntl(interactive_fd, F_SETFD, FD_CLOEXEC);
+
+    /* If we were ran as 'hush &',
+     * sleep until we are in the foreground.  */
+    while (tcgetpgrp(interactive_fd) != shell_pgrp) {
+        /* Send TTIN to ourself (should stop us) */
+        kill(- shell_pgrp, SIGTTIN);
+        shell_pgrp = getpgrp();
+    }
+
+    /* Ignore job-control and misc signals.  */
+    set_jobctrl_sighandler(SIG_IGN);
+    set_misc_sighandler(SIG_IGN);
+//huh?  signal(SIGCHLD, SIG_IGN);
+
+    /* We _must_ restore tty pgrp on fatal signals */
+    set_fatal_sighandler(sigexit);
 
     /* Put ourselves in our own process group.  */
-    setsid();
-    shell_pgrp = getpid ();
-    setpgid (shell_pgrp, shell_pgrp);
-
+    setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
     /* Grab control of the terminal.  */
-    tcsetpgrp(shell_terminal, shell_pgrp);
-}
-
+    tcsetpgrp(interactive_fd, getpid());
+}
+#endif
+
+int hush_main(int argc, char **argv);
 int hush_main(int argc, char **argv)
 {
+    static const char version_str[] ALIGN1 = "HUSH_VERSION="HUSH_VER_STR;
+    static const struct variable const_shell_ver = {
+        .next = NULL,
+        .varstr = (char*)version_str,
+        .max_len = 1, /* 0 can provoke free(name) */
+        .flg_export = 1,
+        .flg_read_only = 1,
+    };
+
     int opt;
     FILE *input;
-    char **e = environ;
-
+    char **e;
+    struct variable *cur_var;
+
+    PTR_TO_GLOBALS = xzalloc(sizeof(G));
+
+    /* Deal with HUSH_VERSION */
+    shell_ver = const_shell_ver; /* copying struct here */
+    top_var = &shell_ver;
+    unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
+    /* Initialize our shell local variables with the values
+     * currently living in the environment */
+    cur_var = top_var;
+    e = environ;
+    if (e) while (*e) {
+        char *value = strchr(*e, '=');
+        if (value) { /* paranoia */
+            cur_var->next = xzalloc(sizeof(*cur_var));
+            cur_var = cur_var->next;
+            cur_var->varstr = *e;
+            cur_var->max_len = strlen(*e);
+            cur_var->flg_export = 1;
+        }
+        e++;
+    }
+    putenv((char *)version_str); /* reinstate HUSH_VERSION */
+
+#if ENABLE_FEATURE_EDITING
+    line_input_state = new_line_input_t(FOR_SHELL);
+#endif
     /* XXX what should these be while sourcing /etc/profile? */
     global_argc = argc;
     global_argv = argv;
-
-    /* (re?) initialize globals.  Sometimes hush_main() ends up calling
-     * hush_main(), therefore we cannot rely on the BSS to zero out this
-     * stuff.  Reset these to 0 every time. */
-    ifs = NULL;
-    /* map[] is taken care of with call to update_ifs_map() */
-    fake_mode = 0;
-    interactive = 0;
-    close_me_head = NULL;
-    last_bg_pid = 0;
-    job_list = NULL;
-    last_jobid = 0;
-
     /* Initialize some more globals to non-zero values */
     set_cwd();
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
+#if ENABLE_HUSH_INTERACTIVE
+#if ENABLE_FEATURE_EDITING
     cmdedit_set_initial_prompt();
-#else
-    PS1 = NULL;
 #endif
     PS2 = "> ";
-
-    /* initialize our shell local variables with the values
-     * currently living in the environment */
-    if (e) {
-        for (; *e; e++)
-            set_local_var(*e, 2);   /* without call putenv() */
-    }
-
-    last_return_code=EXIT_SUCCESS;
-
+#endif
+
+    if (EXIT_SUCCESS) /* otherwise is already done */
+        last_return_code = EXIT_SUCCESS;
 
     if (argv[0] && argv[0][0] == '-') {
-        debug_printf("\nsourcing /etc/profile\n");
-        if ((input = fopen("/etc/profile", "r")) != NULL) {
+        debug_printf("sourcing /etc/profile\n");
+        input = fopen("/etc/profile", "r");
+        if (input != NULL) {
             mark_open(fileno(input));
-            parse_file_outer(input);
+            parse_and_run_file(input);
             mark_closed(fileno(input));
             fclose(input);
         }
     }
-    input=stdin;
+    input = stdin;
 
     while ((opt = getopt(argc, argv, "c:xif")) > 0) {
         switch (opt) {
-            case 'c':
-                {
-                    global_argv = argv+optind;
-                    global_argc = argc-optind;
-                    opt = parse_string_outer(optarg, FLAG_PARSE_SEMICOLON);
-                    goto final_return;
-                }
-                break;
-            case 'i':
-                interactive++;
-                break;
-            case 'f':
-                fake_mode++;
-                break;
-            default:
+        case 'c':
+            global_argv = argv + optind;
+            global_argc = argc - optind;
+            opt = parse_and_run_string(optarg, PARSEFLAG_SEMICOLON);
+            goto final_return;
+        case 'i':
+            /* Well, we cannot just declare interactiveness,
+             * we have to have some stuff (ctty, etc) */
+            /* interactive_fd++; */
+            break;
+        case 'f':
+            fake_mode = 1;
+            break;
+        default:
 #ifndef BB_VER
-                fprintf(stderr, "Usage: sh [FILE]...\n"
-                        "   or: sh -c command [args]...\n\n");
-                exit(EXIT_FAILURE);
+            fprintf(stderr, "Usage: sh [FILE]...\n"
+                    "   or: sh -c command [args]...\n\n");
+            exit(EXIT_FAILURE);
 #else
-                bb_show_usage();
-#endif
-        }
-    }
-    /* A shell is interactive if the `-i' flag was given, or if all of
+            bb_show_usage();
+#endif
+        }
+    }
+#if ENABLE_HUSH_JOB
+    /* A shell is interactive if the '-i' flag was given, or if all of
      * the following conditions are met:
-     *    no -c command
+     *    no -c command
      *    no arguments remaining or the -s flag given
      *    standard input is a terminal
      *    standard output is a terminal
-     *    Refer to Posix.2, the description of the `sh' utility. */
-    if (argv[optind]==NULL && input==stdin &&
-            isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
-        interactive++;
-    }
-
-    debug_printf("\ninteractive=%d\n", interactive);
-    if (interactive) {
+     *    Refer to Posix.2, the description of the 'sh' utility. */
+    if (argv[optind] == NULL && input == stdin
+     && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
+    ) {
+        saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
+        debug_printf("saved_tty_pgrp=%d\n", saved_tty_pgrp);
+        if (saved_tty_pgrp >= 0) {
+            /* try to dup to high fd#, >= 255 */
+            interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
+            if (interactive_fd < 0) {
+                /* try to dup to any fd */
+                interactive_fd = dup(STDIN_FILENO);
+                if (interactive_fd < 0)
+                    /* give up */
+                    interactive_fd = 0;
+            }
+            // TODO: track & disallow any attempts of user
+            // to (inadvertently) close/redirect it
+        }
+    }
+    debug_printf("interactive_fd=%d\n", interactive_fd);
+    if (interactive_fd) {
         /* Looks like they want an interactive shell */
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
-        printf( "\n\n%s hush - the humble shell v0.01 (testing)\n",
-            BB_BANNER);
-        printf( "Enter 'help' for a list of built-in commands.\n\n");
-#endif
         setup_job_control();
-    }
-
-    if (argv[optind]==NULL) {
-        opt=parse_file_outer(stdin);
+        /* Make xfuncs do cleanup on exit */
+        die_sleep = -1; /* flag */
+// FIXME: should we reset die_sleep = 0 whereever we fork?
+        if (setjmp(die_jmp)) {
+            /* xfunc has failed! die die die */
+            hush_exit(xfunc_error_retval);
+        }
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+        printf("\n\n%s hush - the humble shell v"HUSH_VER_STR"\n", bb_banner);
+        printf("Enter 'help' for a list of built-in commands.\n\n");
+#endif
+    }
+#elif ENABLE_HUSH_INTERACTIVE
+/* no job control compiled, only prompt/line editing */
+    if (argv[optind] == NULL && input == stdin
+     && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
+    ) {
+        interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
+        if (interactive_fd < 0) {
+            /* try to dup to any fd */
+            interactive_fd = dup(STDIN_FILENO);
+            if (interactive_fd < 0)
+                /* give up */
+                interactive_fd = 0;
+        }
+    }
+
+#endif
+
+    if (argv[optind] == NULL) {
+        opt = parse_and_run_file(stdin);
         goto final_return;
     }
 
     debug_printf("\nrunning script '%s'\n", argv[optind]);
-    global_argv = argv+optind;
-    global_argc = argc-optind;
-    input = bb_xfopen(argv[optind], "r");
-    opt = parse_file_outer(input);
-
-#ifdef CONFIG_FEATURE_CLEAN_UP
+    global_argv = argv + optind;
+    global_argc = argc - optind;
+    input = xfopen(argv[optind], "r");
+    opt = parse_and_run_file(input);
+
+ final_return:
+
+#if ENABLE_FEATURE_CLEAN_UP
     fclose(input);
-    if (cwd && cwd != bb_msg_unknown)
+    if (cwd != bb_msg_unknown)
         free((char*)cwd);
-    {
-        struct variables *cur, *tmp;
-        for(cur = top_vars; cur; cur = tmp) {
-            tmp = cur->next;
-            if (!cur->flg_read_only) {
-                free(cur->name);
-                free(cur->value);
-                free(cur);
-            }
-        }
-    }
-#endif
-
-final_return:
-    return(opt?opt:last_return_code);
-}
-
-static char *insert_var_value(char *inp)
-{
-    int res_str_len = 0;
-    int len;
-    int done = 0;
-    char *p, *p1, *res_str = NULL;
-
-    while ((p = strchr(inp, SPECIAL_VAR_SYMBOL))) {
-        if (p != inp) {
-            len = p - inp;
-            res_str = xrealloc(res_str, (res_str_len + len));
-            strncpy((res_str + res_str_len), inp, len);
-            res_str_len += len;
-        }
-        inp = ++p;
-        p = strchr(inp, SPECIAL_VAR_SYMBOL);
-        *p = '\0';
-        if ((p1 = lookup_param(inp))) {
-            len = res_str_len + strlen(p1);
-            res_str = xrealloc(res_str, (1 + len));
-            strcpy((res_str + res_str_len), p1);
-            res_str_len = len;
-        }
-        *p = SPECIAL_VAR_SYMBOL;
-        inp = ++p;
-        done = 1;
-    }
-    if (done) {
-        res_str = xrealloc(res_str, (1 + res_str_len + strlen(inp)));
-        strcpy((res_str + res_str_len), inp);
-        while ((p = strchr(res_str, '\n'))) {
-            *p = ' ';
-        }
-    }
-    return (res_str == NULL) ? inp : res_str;
-}
-
-static char **make_list_in(char **inp, char *name)
-{
-    int len, i;
-    int name_len = strlen(name);
-    int n = 0;
-    char **list;
-    char *p1, *p2, *p3;
-
-    /* create list of variable values */
-    list = xmalloc(sizeof(*list));
-    for (i = 0; inp[i]; i++) {
-        p3 = insert_var_value(inp[i]);
-        p1 = p3;
-        while (*p1) {
-            if ((*p1 == ' ')) {
-                p1++;
-                continue;
-            }
-            if ((p2 = strchr(p1, ' '))) {
-                len = p2 - p1;
-            } else {
-                len = strlen(p1);
-                p2 = p1 + len;
-            }
-            /* we use n + 2 in realloc for list,because we add
-             * new element and then we will add NULL element */
-            list = xrealloc(list, sizeof(*list) * (n + 2));
-            list[n] = xmalloc(2 + name_len + len);
-            strcpy(list[n], name);
-            strcat(list[n], "=");
-            strncat(list[n], p1, len);
-            list[n++][name_len + len + 1] = '\0';
-            p1 = p2;
-        }
-        if (p3 != inp[i]) free(p3);
-    }
-    list[n] = NULL;
-    return list;
-}
-
-/* Make new string for parser */
-static char * make_string(char ** inp)
-{
-    char *p;
-    char *str = NULL;
-    int n;
-    int len = 2;
-
-    for (n = 0; inp[n]; n++) {
-        p = insert_var_value(inp[n]);
-        str = xrealloc(str, (len + strlen(p)));
-        if (n) {
-            strcat(str, " ");
-        } else {
-            *str = '\0';
-        }
-        strcat(str, p);
-        len = strlen(str) + 3;
-        if (p != inp[n]) free(p);
-    }
-    len = strlen(str);
-    *(str + len) = '\n';
-    *(str + len + 1) = '\0';
-    return str;
-}
+    cur_var = top_var->next;
+    while (cur_var) {
+        struct variable *tmp = cur_var;
+        if (!cur_var->max_len)
+            free(cur_var->varstr);
+        cur_var = cur_var->next;
+        free(tmp);
+    }
+#endif
+    hush_exit(opt ? opt : last_return_code);
+}

branches/2.2.5/mindi-busybox/shell/lash.c

@@ -21 +21 @@
 //#define DEBUG_SHELL
 
-
-#include "busybox.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/wait.h>
-#include <unistd.h>
 #include <getopt.h>
-#include <termios.h>
-#include "cmdedit.h"
-
-#ifdef CONFIG_LOCALE_SUPPORT
-#include <locale.h>
-#endif
-
 #include <glob.h>
+
+#include "busybox.h" /* for struct bb_applet */
+
 #define expand_t    glob_t
 
@@ -47 +31 @@
 #define CONFIG_LASH_PIPE_N_REDIRECTS
 #define CONFIG_LASH_JOB_CONTROL
-
-static const int MAX_READ = 128;    /* size of input buffer for `read' builtin */
+#define ENABLE_LASH_PIPE_N_REDIRECTS 1
+#define ENABLE_LASH_JOB_CONTROL      1
+
+
+enum { MAX_READ = 128 }; /* size of input buffer for 'read' builtin */
 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
 
 
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
 enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
     REDIRECT_APPEND
@@ -66 +53 @@
 };
 
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#define LASH_OPT_DONE (1)
+#define LASH_OPT_SAW_QUOTE (2)
+
+#if ENABLE_LASH_PIPE_N_REDIRECTS
 struct redir_struct {
     enum redir_type type;   /* type of redirection */
@@ -80 +70 @@
     int is_stopped;             /* is the program currently running? */
     struct job *family;         /* pointer back to the child's parent job */
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
     struct redir_struct *redirects; /* I/O redirects */
 #endif
@@ -105 +95 @@
 
 struct built_in_command {
-    char *cmd;                  /* name */
-    char *descr;                /* description */
+    const char *cmd;   /* name */
+    const char *descr; /* description */
     int (*function) (struct child_prog *);  /* function ptr */
 };
@@ -127 +117 @@
 static void checkjobs(struct jobset *job_list);
 static void remove_job(struct jobset *j_list, struct job *job);
-static int get_command(FILE * source, char *command);
+static int get_command_bufsiz(FILE * source, char *command);
 static int parse_command(char **command_ptr, struct job *job, int *inbg);
 static int run_command(struct job *newjob, int inbg, int outpipe[2]);
@@ -137 +127 @@
  * can change global variables in the parent shell process but they will not
  * work with pipes and redirects; 'unset foo | whatever' will not work) */
-static struct built_in_command bltins[] = {
-    {"bg", "Resume a job in the background", builtin_fg_bg},
-    {"cd", "Change working directory", builtin_cd},
-    {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
-    {"exit", "Exit from shell()", builtin_exit},
-    {"fg", "Bring job into the foreground", builtin_fg_bg},
-    {"jobs", "Lists the active jobs", builtin_jobs},
+static const struct built_in_command bltins[] = {
+    {"bg"    , "Resume a job in the background", builtin_fg_bg},
+    {"cd"    , "Change working directory", builtin_cd},
+    {"exec"  , "Exec command, replacing this shell with the exec'd process", builtin_exec},
+    {"exit"  , "Exit from shell()", builtin_exit},
+    {"fg"    , "Bring job into the foreground", builtin_fg_bg},
+    {"jobs"  , "Lists the active jobs", builtin_jobs},
     {"export", "Set environment variable", builtin_export},
-    {"unset", "Unset environment variable", builtin_unset},
-    {"read", "Input environment variable", builtin_read},
-    {".", "Source-in and run commands in a file", builtin_source},
+    {"unset" , "Unset environment variable", builtin_unset},
+    {"read"  , "Input environment variable", builtin_read},
+    {"."     , "Source-in and run commands in a file", builtin_source},
+    /* These were "forked applets", but distinction was nuked */
+    /* Original comment retained: */
+    /* Table of forking built-in functions (things that fork cannot change global
+     * variables in the parent process, such as the current working directory) */
+    {"pwd"   , "Print current directory", builtin_pwd},
+    {"help"  , "List shell built-in commands", builtin_help},
     /* to do: add ulimit */
-    {NULL, NULL, NULL}
 };
 
-/* Table of forking built-in functions (things that fork cannot change global
- * variables in the parent process, such as the current working directory) */
-static struct built_in_command bltins_forking[] = {
-    {"pwd", "Print current directory", builtin_pwd},
-    {"help", "List shell built-in commands", builtin_help},
-    {NULL, NULL, NULL}
-};
+
+#define VEC_LAST(v) v[ARRAY_SIZE(v)-1]
 
 
@@ -165 +155 @@
 
 /* Globals that are static to this file */
-static const char *cwd;
-static char *local_pending_command = NULL;
+static char *cwd;
+static char *local_pending_command;
 static struct jobset job_list = { NULL, NULL };
 static int argc;
@@ -175 +165 @@
 static unsigned int last_jobid;
 static int shell_terminal;
-static char *PS1;
-static char *PS2 = "> ";
+static const char *PS1;
+static const char *PS2 = "> ";
 
 
@@ -188 +178 @@
 }
 #else
-static inline void debug_printf(const char *format, ...) { }
+static inline void debug_printf(const char ATTRIBUTE_UNUSED *format, ...) { }
 #endif
 
@@ -219 +209 @@
  */
 
+
+static void update_cwd(void)
+{
+    cwd = xrealloc_getcwd_or_warn(cwd);
+    if (!cwd)
+        cwd = xstrdup(bb_msg_unknown);
+}
+
 /* built-in 'cd <path>' handler */
 static int builtin_cd(struct child_prog *child)
@@ -232 +230 @@
         return EXIT_FAILURE;
     }
-    cwd = xgetcwd((char *)cwd);
-    if (!cwd)
-        cwd = bb_msg_unknown;
+    update_cwd();
     return EXIT_SUCCESS;
 }
@@ -244 +240 @@
         return EXIT_SUCCESS;   /* Really? */
     child->argv++;
-    while(close_me_list) close((long)llist_pop(&close_me_list));
+    while (close_me_list)
+        close((long)llist_pop(&close_me_list));
     pseudo_exec(child);
     /* never returns */
@@ -255 +252 @@
         exit(EXIT_SUCCESS);
 
-    exit (atoi(child->argv[1]));
+    exit(atoi(child->argv[1]));
 }
 
@@ -262 +259 @@
 {
     int i, jobnum;
-    struct job *job=NULL;
+    struct job *job;
 
     /* If they gave us no args, assume they want the last backgrounded task */
@@ -268 +265 @@
         for (job = child->family->job_list->head; job; job = job->next) {
             if (job->jobid == last_jobid) {
-                break;
-            }
-        }
-        if (!job) {
-            bb_error_msg("%s: no current job", child->argv[0]);
-            return EXIT_FAILURE;
-        }
-    } else {
-        if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
-            bb_error_msg(bb_msg_invalid_arg, child->argv[1], child->argv[0]);
-            return EXIT_FAILURE;
-        }
-        for (job = child->family->job_list->head; job; job = job->next) {
-            if (job->jobid == jobnum) {
-                break;
-            }
-        }
-        if (!job) {
-            bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
-            return EXIT_FAILURE;
-        }
-    }
-
+                goto found;
+            }
+        }
+        bb_error_msg("%s: no current job", child->argv[0]);
+        return EXIT_FAILURE;
+    }
+    if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
+        bb_error_msg(bb_msg_invalid_arg, child->argv[1], child->argv[0]);
+        return EXIT_FAILURE;
+    }
+    for (job = child->family->job_list->head; job; job = job->next) {
+        if (job->jobid == jobnum) {
+            goto found;
+        }
+    }
+    bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
+    return EXIT_FAILURE;
+ found:
     if (*child->argv[0] == 'f') {
         /* Put the job into the foreground.  */
@@ -304 +296 @@
     job->stopped_progs = 0;
 
-    if ( (i=kill(- job->pgrp, SIGCONT)) < 0) {
-        if (i == ESRCH) {
+    i = kill(- job->pgrp, SIGCONT);
+    if (i < 0) {
+        if (errno == ESRCH) {
             remove_job(&job_list, job);
         } else {
@@ -316 +309 @@
 
 /* built-in 'help' handler */
-static int builtin_help(struct child_prog *dummy)
-{
-    struct built_in_command *x;
-
-    printf("\nBuilt-in commands:\n");
-    printf("-------------------\n");
-    for (x = bltins; x->cmd; x++) {
-        if (x->descr==NULL)
+static int builtin_help(struct child_prog ATTRIBUTE_UNUSED *dummy)
+{
+    const struct built_in_command *x;
+
+    printf("\nBuilt-in commands:\n"
+           "-------------------\n");
+    for (x = bltins; x <= &VEC_LAST(bltins); x++) {
+        if (x->descr == NULL)
             continue;
         printf("%s\t%s\n", x->cmd, x->descr);
     }
-    for (x = bltins_forking; x->cmd; x++) {
-        if (x->descr==NULL)
-            continue;
-        printf("%s\t%s\n", x->cmd, x->descr);
-    }
-    printf("\n\n");
+    putchar('\n');
     return EXIT_SUCCESS;
 }
@@ -340 +328 @@
 {
     struct job *job;
-    char *status_string;
+    const char *status_string;
 
     for (job = child->family->job_list->head; job; job = job->next) {
@@ -355 +343 @@
 
 /* built-in 'pwd' handler */
-static int builtin_pwd(struct child_prog *dummy)
-{
-    cwd = xgetcwd((char *)cwd);
-    if (!cwd)
-        cwd = bb_msg_unknown;
+static int builtin_pwd(struct child_prog ATTRIBUTE_UNUSED *dummy)
+{
+    update_cwd();
     puts(cwd);
     return EXIT_SUCCESS;
@@ -380 +366 @@
     if (res)
         bb_perror_msg("export");
-#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
-    if (strncmp(v, "PS1=", 4)==0)
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+    if (strncmp(v, "PS1=", 4) == 0)
         PS1 = getenv("PS1");
 #endif
 
-#ifdef CONFIG_LOCALE_SUPPORT
-    if(strncmp(v, "LC_ALL=", 7)==0)
+#if ENABLE_LOCALE_SUPPORT
+    // TODO: why getenv? "" would be just as good...
+    if (strncmp(v, "LC_ALL=", 7) == 0)
         setlocale(LC_ALL, getenv("LC_ALL"));
-    if(strncmp(v, "LC_CTYPE=", 9)==0)
+    if (strncmp(v, "LC_CTYPE=", 9) == 0)
         setlocale(LC_CTYPE, getenv("LC_CTYPE"));
 #endif
 
-    return (res);
+    return res;
 }
 
@@ -398 +385 @@
 static int builtin_read(struct child_prog *child)
 {
-    int res = 0, len, newlen;
+    int res = 0, len;
     char *s;
     char string[MAX_READ];
@@ -409 +396 @@
         string[len]   = '\0';
         fgets(&string[len], sizeof(string) - len, stdin);   /* read string */
-        newlen = strlen(string);
-        if(newlen > len)
-            string[--newlen] = '\0';    /* chomp trailing newline */
+        res = strlen(string);
+        if (res > len)
+            string[--res] = '\0';   /* chomp trailing newline */
         /*
         ** string should now contain "VAR=<value>"
@@ -418 +405 @@
         */
         res = -1;
-        if((s = strdup(string)))
+        s = strdup(string);
+        if (s)
             res = putenv(s);
         if (res)
             bb_perror_msg("read");
-    }
-    else
+    } else
         fgets(string, sizeof(string), stdin);
 
-    return (res);
+    return res;
 }
 
@@ -435 +422 @@
     int status;
 
-    if (child->argv[1] == NULL)
-        return EXIT_FAILURE;
-
-    input = fopen(child->argv[1], "r");
+    input = fopen_or_warn(child->argv[1], "r");
     if (!input) {
-        printf( "Couldn't open file '%s'\n", child->argv[1]);
         return EXIT_FAILURE;
     }
@@ -449 +432 @@
     fclose(input);
     llist_pop(&close_me_list);
-    return (status);
+    return status;
 }
 
@@ -463 +446 @@
 }
 
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
 /* free up all memory from a job */
 static void free_job(struct job *cmd)
@@ -472 +455 @@
     for (i = 0; i < cmd->num_progs; i++) {
         free(cmd->progs[i].argv);
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
         if (cmd->progs[i].redirects)
             free(cmd->progs[i].redirects);
@@ -527 +510 @@
 
         /* This happens on backticked commands */
-        if(job==NULL)
+        if (job == NULL)
             return;
 
@@ -537 +520 @@
             if (!job->running_progs) {
                 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
-                last_jobid=0;
+                last_jobid = 0;
                 remove_job(j_list, job);
             }
@@ -544 +527 @@
             job->stopped_progs++;
             job->progs[prognum].is_stopped = 1;
-
-#if 0
-            /* Printing this stuff is a pain, since it tends to
-             * overwrite the prompt an inconveinient moments.  So
-             * don't do that.  */
-            if (job->stopped_progs == job->num_progs) {
-                printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
-                       job->text);
-            }
-#endif
         }
     }
@@ -572 +545 @@
 #endif
 
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
  * and stderr if they are redirected. */
@@ -595 +568 @@
         }
 
-        openfd = open(redir->filename, mode, 0666);
+        openfd = open3_or_warn(redir->filename, mode, 0666);
         if (openfd < 0) {
             /* this could get lost if stderr has been redirected, but
                bash and ash both lose it as well (though zsh doesn't!) */
-            bb_perror_msg("error opening %s", redir->filename);
             return 1;
         }
@@ -606 +578 @@
             if (squirrel && redir->fd < 3) {
                 squirrel[redir->fd] = dup(redir->fd);
-                fcntl (squirrel[redir->fd], F_SETFD, FD_CLOEXEC);
+                fcntl(squirrel[redir->fd], F_SETFD, FD_CLOEXEC);
             }
             dup2(openfd, redir->fd);
@@ -619 +591 @@
 {
     int i, fd;
-    for (i=0; i<3; i++) {
+    for (i = 0; i < 3; i++) {
         fd = squirrel[i];
         if (fd != -1) {
@@ -641 +613 @@
 static inline void cmdedit_set_initial_prompt(void)
 {
-#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
     PS1 = NULL;
 #else
     PS1 = getenv("PS1");
-    if(PS1==0)
+    if (PS1 == 0)
         PS1 = "\\w \\$ ";
 #endif
 }
 
-static inline void setup_prompt_string(char **prompt_str)
-{
-#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+static inline const char* setup_prompt_string(void)
+{
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
     /* Set up the prompt */
     if (shell_context == 0) {
-        free(PS1);
-        PS1=xmalloc(strlen(cwd)+4);
-        sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ?  "$ ":"# ");
-        *prompt_str = PS1;
+        char *ns;
+        free((char*)PS1);
+        ns = xmalloc(strlen(cwd)+4);
+        sprintf(ns, "%s %c ", cwd, (geteuid() != 0) ? '$': '#');
+        PS1 = ns;
+        return ns;
     } else {
-        *prompt_str = PS2;
+        return PS2;
     }
 #else
-    *prompt_str = (shell_context==0)? PS1 : PS2;
-#endif
-}
-
-static int get_command(FILE * source, char *command)
-{
-    char *prompt_str;
+    return (shell_context == 0)? PS1 : PS2;
+#endif
+}
+
+#if ENABLE_FEATURE_EDITING
+static line_input_t *line_input_state;
+#endif
+
+static int get_command_bufsiz(FILE * source, char *command)
+{
+    const char *prompt_str;
 
     if (source == NULL) {
         if (local_pending_command) {
             /* a command specified (-c option): return it & mark it done */
-            strcpy(command, local_pending_command);
-            free(local_pending_command);
+            strncpy(command, local_pending_command, BUFSIZ);
             local_pending_command = NULL;
             return 0;
@@ -683 +660 @@
 
     if (source == stdin) {
-        setup_prompt_string(&prompt_str);
-
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
+        prompt_str = setup_prompt_string();
+
+#if ENABLE_FEATURE_EDITING
         /*
         ** enable command line editing only while a command line
@@ -692 +669 @@
         ** child processes (rob@sysgo.de)
         */
-        cmdedit_read_input(prompt_str, command);
+        read_line_input(prompt_str, command, BUFSIZ, line_input_state);
         return 0;
 #else
@@ -701 +678 @@
     if (!fgets(command, BUFSIZ - 2, source)) {
         if (source == stdin)
-            printf("\n");
+            puts("");
         return 1;
     }
@@ -708 +685 @@
 }
 
-static char* itoa(register int i)
-{
-    static char a[7]; /* Max 7 ints */
-    register char *b = a + sizeof(a) - 1;
-    int   sign = (i < 0);
-
-    if (sign)
-        i = -i;
-    *b = 0;
-    do
-    {
-        *--b = '0' + (i % 10);
-        i /= 10;
-    }
-    while (i);
-    if (sign)
-        *--b = '-';
-    return b;
-}
-
-static char * strsep_space( char *string, int * ix)
-{
-    char *token;
-
+static char * strsep_space(char *string, int * ix)
+{
     /* Short circuit the trivial case */
-    if ( !string || ! string[*ix])
+    if (!string || ! string[*ix])
         return NULL;
 
     /* Find the end of the token. */
-    while( string[*ix] && !isspace(string[*ix]) ) {
+    while (string[*ix] && !isspace(string[*ix]) ) {
         (*ix)++;
     }
@@ -743 +698 @@
     /* Find the end of any whitespace trailing behind
      * the token and let that be part of the token */
-    while( string[*ix] && isspace(string[*ix]) ) {
+    while (string[*ix] && (isspace)(string[*ix]) ) {
         (*ix)++;
     }
@@ -752 +707 @@
     }
 
-    token = bb_xstrndup(string, *ix);
-
-    return token;
+    return xstrndup(string, *ix);
 }
 
 static int expand_arguments(char *command)
 {
-    int total_length=0, length, i, retval, ix = 0;
+    static const char out_of_space[] ALIGN1 = "out of space during expansion";
+
+    int total_length = 0, length, i, retval, ix = 0;
     expand_t expand_result;
     char *tmpcmd, *cmd, *cmd_copy;
     char *src, *dst, *var;
-    const char *out_of_space = "out of space during expansion";
     int flags = GLOB_NOCHECK
 #ifdef GLOB_BRACE
@@ -777 +731 @@
 
     /* Fix up escape sequences to be the Real Thing(tm) */
-    while( command && command[ix]) {
+    while (command && command[ix]) {
         if (command[ix] == '\\') {
             const char *tmp = command+ix+1;
@@ -793 +747 @@
     /* We need a clean copy, so strsep can mess up the copy while
      * we write stuff into the original (in a minute) */
-    cmd = cmd_copy = bb_xstrdup(command);
+    cmd = cmd_copy = xstrdup(command);
     *command = '\0';
     for (ix = 0, tmpcmd = cmd;
-            (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
+            (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix = 0) {
         if (*tmpcmd == '\0')
             break;
@@ -805 +759 @@
         if (retval == GLOB_NOSPACE) {
             /* Mem may have been allocated... */
-            globfree (&expand_result);
+            globfree(&expand_result);
             bb_error_msg(out_of_space);
             return FALSE;
@@ -817 +771 @@
             /* Convert from char** (one word per string) to a simple char*,
              * but don't overflow command which is BUFSIZ in length */
-            for (i=0; i < expand_result.gl_pathc; i++) {
-                length=strlen(expand_result.gl_pathv[i]);
+            for (i = 0; i < expand_result.gl_pathc; i++) {
+                length = strlen(expand_result.gl_pathv[i]);
                 if (total_length+length+1 >= BUFSIZ) {
                     bb_error_msg(out_of_space);
@@ -824 +778 @@
                 }
                 strcat(command+total_length, " ");
-                total_length+=1;
+                total_length += 1;
                 strcat(command+total_length, expand_result.gl_pathv[i]);
-                total_length+=length;
-            }
-            globfree (&expand_result);
+                total_length += length;
+            }
+            globfree(&expand_result);
         }
     }
@@ -837 +791 @@
      * wordexp can't do for us, namely $? and $! */
     src = command;
-    while((dst = strchr(src,'$')) != NULL){
+    while ((dst = strchr(src,'$')) != NULL) {
         var = NULL;
-        switch(*(dst+1)) {
+        switch (*(dst+1)) {
             case '?':
                 var = itoa(last_return_code);
                 break;
             case '!':
-                if (last_bg_pid==-1)
-                    *(var)='\0';
+                if (last_bg_pid == -1)
+                    *var = '\0';
                 else
                     var = itoa(last_bg_pid);
@@ -863 +817 @@
             case '5':case '6':case '7':case '8':case '9':
                 {
-                    int ixx=*(dst+1)-48+1;
+                    int ixx = *(dst+1)-48+1;
                     if (ixx >= argc) {
-                        var='\0';
+                        var = '\0';
                     } else {
                         var = argv[ixx];
@@ -876 +830 @@
             /* a single character construction was found, and
              * already handled in the case statement */
-            src=dst+2;
+            src = dst + 2;
         } else {
             /* Looks like an environment variable */
             char delim_hold;
-            int num_skip_chars=0;
+            int num_skip_chars = 0;
             int dstlen = strlen(dst);
             /* Is this a ${foo} type variable? */
-            if (dstlen >=2 && *(dst+1) == '{') {
-                src=strchr(dst+1, '}');
-                num_skip_chars=1;
+            if (dstlen >= 2 && *(dst+1) == '{') {
+                src = strchr(dst+1, '}');
+                num_skip_chars = 1;
             } else {
-                src=dst+1;
-                while(isalnum(*src) || *src=='_') src++;
+                src = dst + 1;
+                while ((isalnum)(*src) || *src == '_') src++;
             }
             if (src == NULL) {
                 src = dst+dstlen;
             }
-            delim_hold=*src;
-            *src='\0';  /* temporary */
+            delim_hold = *src;
+            *src = '\0';  /* temporary */
             var = getenv(dst + 1 + num_skip_chars);
-            *src=delim_hold;
+            *src = delim_hold;
             src += num_skip_chars;
         }
         if (var == NULL) {
             /* Seems we got an un-expandable variable.  So delete it. */
-            var = "";
+            var = (char*)"";
         }
         {
@@ -932 +886 @@
     char *return_command = NULL;
     char *src, *buf;
-    int argc_l = 0;
-    int done = 0;
+    int argc_l;
+    int flag;
     int argv_alloced;
-    int saw_quote = 0;
     char quote = '\0';
     struct child_prog *prog;
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
     int i;
     char *chptr;
@@ -944 +897 @@
 
     /* skip leading white space */
-    while (**command_ptr && isspace(**command_ptr))
-        (*command_ptr)++;
+    *command_ptr = skip_whitespace(*command_ptr);
 
     /* this handles empty lines or leading '#' characters */
     if (!**command_ptr || (**command_ptr == '#')) {
-        job->num_progs=0;
+        job->num_progs = 0;
         return 0;
     }
@@ -971 +923 @@
     prog->is_stopped = 0;
     prog->family = job;
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
     prog->redirects = NULL;
 #endif
@@ -979 +931 @@
     prog->argv[0] = job->cmdbuf;
 
+    flag = argc_l = 0;
     buf = command;
     src = *command_ptr;
-    while (*src && !done) {
+    while (*src && !(flag & LASH_OPT_DONE)) {
         if (quote == *src) {
             quote = '\0';
@@ -1002 +955 @@
             *buf++ = *src;
         } else if (isspace(*src)) {
-            if (*prog->argv[argc_l] || saw_quote) {
+            if (*prog->argv[argc_l] || (flag & LASH_OPT_SAW_QUOTE)) {
                 buf++, argc_l++;
                 /* +1 here leaves room for the NULL which ends argv */
@@ -1008 +961 @@
                     argv_alloced += 5;
                     prog->argv = xrealloc(prog->argv,
-                                          sizeof(*prog->argv) *
-                                          argv_alloced);
+                            sizeof(*prog->argv) * argv_alloced);
                 }
                 prog->argv[argc_l] = buf;
-                saw_quote = 0;
+                flag ^= LASH_OPT_SAW_QUOTE;
             }
         } else
@@ -1019 +971 @@
             case '\'':
                 quote = *src;
-                saw_quote = 1;
+                flag |= LASH_OPT_SAW_QUOTE;
                 break;
 
@@ -1026 +978 @@
                     *buf++ = *src;
                 else
-                    done = 1;
+                    flag |= LASH_OPT_DONE;
                 break;
 
-#ifdef CONFIG_LASH_PIPE_N_REDIRECTS
+#if ENABLE_LASH_PIPE_N_REDIRECTS
             case '>':           /* redirects */
             case '<':
                 i = prog->num_redirects++;
                 prog->redirects = xrealloc(prog->redirects,
-                                              sizeof(*prog->redirects) *
-                                              (i + 1));
+                        sizeof(*prog->redirects) * (i + 1));
 
                 prog->redirects[i].fd = -1;
@@ -1069 +1020 @@
                 /* This isn't POSIX sh compliant. Oh well. */
                 chptr = src;
-                while (isspace(*chptr))
-                    chptr++;
+                chptr = skip_whitespace(chptr);
 
                 if (!*chptr) {
                     bb_error_msg("file name expected after %c", *(src-1));
                     free_job(job);
-                    job->num_progs=0;
+                    job->num_progs = 0;
                     return 1;
                 }
@@ -1089 +1039 @@
             case '|':           /* pipe */
                 /* finish this command */
-                if (*prog->argv[argc_l] || saw_quote)
+                if (*prog->argv[argc_l] || flag & LASH_OPT_SAW_QUOTE)
                     argc_l++;
                 if (!argc_l) {
-                    bb_error_msg("empty command in pipe");
-                    free_job(job);
-                    job->num_progs=0;
-                    return 1;
+                    goto empty_command_in_pipe;
                 }
                 prog->argv[argc_l] = NULL;
@@ -1102 +1049 @@
                 job->num_progs++;
                 job->progs = xrealloc(job->progs,
-                                      sizeof(*job->progs) * job->num_progs);
+                        sizeof(*job->progs) * job->num_progs);
                 prog = job->progs + (job->num_progs - 1);
                 prog->num_redirects = 0;
@@ -1115 +1062 @@
 
                 src++;
-                while (*src && isspace(*src))
-                    src++;
+                src = skip_whitespace(src);
 
                 if (!*src) {
+empty_command_in_pipe:
                     bb_error_msg("empty command in pipe");
                     free_job(job);
-                    job->num_progs=0;
+                    job->num_progs = 0;
                     return 1;
                 }
@@ -1129 +1076 @@
 #endif
 
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
             case '&':           /* background */
                 *inbg = 1;
+                /* fallthrough */
 #endif
             case ';':           /* multiple commands */
-                done = 1;
+                flag |= LASH_OPT_DONE;
                 return_command = *command_ptr + (src - *command_ptr) + 1;
                 break;
@@ -1155 +1103 @@
     }
 
-    if (*prog->argv[argc_l] || saw_quote) {
+    if (*prog->argv[argc_l] || flag & LASH_OPT_SAW_QUOTE) {
         argc_l++;
     }
@@ -1165 +1113 @@
 
     if (!return_command) {
-        job->text = bb_xstrdup(*command_ptr);
+        job->text = xstrdup(*command_ptr);
     } else {
         /* This leaves any trailing spaces, which is a bit sloppy */
-        job->text = bb_xstrndup(*command_ptr, return_command - *command_ptr);
+        job->text = xstrndup(*command_ptr, return_command - *command_ptr);
     }
 
@@ -1180 +1128 @@
 static int pseudo_exec(struct child_prog *child)
 {
-    struct built_in_command *x;
+    const struct built_in_command *x;
 
     /* Check if the command matches any of the non-forking builtins.
@@ -1187 +1135 @@
      * if this is one of those cases.
      */
-    for (x = bltins; x->cmd; x++) {
-        if (strcmp(child->argv[0], x->cmd) == 0 ) {
+    /* Check if the command matches any of the forking builtins. */
+    for (x = bltins; x <= &VEC_LAST(bltins); x++) {
+        if (strcmp(child->argv[0], x->cmd) == 0) {
             _exit(x->function(child));
         }
     }
 
-    /* Check if the command matches any of the forking builtins. */
-    for (x = bltins_forking; x->cmd; x++) {
-        if (strcmp(child->argv[0], x->cmd) == 0) {
-            bb_applet_name=x->cmd;
-            _exit (x->function(child));
-        }
-    }
 
     /* Check if the command matches any busybox internal
@@ -1212 +1154 @@
      * /bin/foo is a symlink to busybox.
      */
-
-    if (ENABLE_FEATURE_SH_STANDALONE_SHELL) {
-        char **argv_l = child->argv;
-        int argc_l;
-
-        for(argc_l=0; *argv_l; argv_l++, argc_l++);
-        optind = 1;
-        run_applet_by_name(child->argv[0], argc_l, child->argv);
+    if (ENABLE_FEATURE_SH_STANDALONE) {
+        run_applet_and_exit(child->argv[0], child->argv);
     }
 
@@ -1233 +1169 @@
 {
     struct job *thejob;
-    struct jobset *j_list=newjob->job_list;
+    struct jobset *j_list = newjob->job_list;
 
     /* find the ID for thejob to use */
@@ -1255 +1191 @@
     thejob->stopped_progs = 0;
 
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
     if (inbg) {
         /* we don't wait for background thejobs to return -- append it
@@ -1262 +1198 @@
                newjob->progs[newjob->num_progs - 1].pid);
         last_jobid = newjob->jobid;
-        last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
+        last_bg_pid = newjob->progs[newjob->num_progs - 1].pid;
     } else {
         newjob->job_list->fg = thejob;
@@ -1279 +1215 @@
     int nextin, nextout;
     int pipefds[2];             /* pipefd[0] is for reading */
-    struct built_in_command *x;
+    const struct built_in_command *x;
     struct child_prog *child;
 
-    nextin = 0, nextout = 1;
+    nextin = 0;
     for (i = 0; i < newjob->num_progs; i++) {
-        child = & (newjob->progs[i]);
-
+        child = &(newjob->progs[i]);
+
+        nextout = 1;
         if ((i + 1) < newjob->num_progs) {
-            if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
+            xpipe(pipefds);
             nextout = pipefds[1];
-        } else {
-            if (outpipe[1]!=-1) {
-                nextout = outpipe[1];
-            } else {
-                nextout = 1;
-            }
-        }
-
+        } else if (outpipe[1] != -1) {
+            nextout = outpipe[1];
+        }
 
         /* Check if the command matches any non-forking builtins,
@@ -1305 +1237 @@
          */
         if (newjob->num_progs == 1) {
+            int rcode;
+            int squirrel[] = {-1, -1, -1};
+
             /* Check if the command sets an environment variable. */
             if (strchr(child->argv[0], '=') != NULL) {
@@ -1311 +1246 @@
             }
 
-            for (x = bltins; x->cmd; x++) {
-                if (strcmp(child->argv[0], x->cmd) == 0 ) {
-                    int rcode;
-                    int squirrel[] = {-1, -1, -1};
+            for (x = bltins; x <= &VEC_LAST(bltins); x++) {
+                if (strcmp(child->argv[0], x->cmd) == 0) {
                     setup_redirects(child, squirrel);
                     rcode = x->function(child);
@@ -1321 +1254 @@
                 }
             }
-        }
-
-#if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
-        if (!(child->pid = fork()))
+#if ENABLE_FEATURE_SH_STANDALONE
+            {
+                const struct bb_applet *a = find_applet_by_name(child->argv[i]);
+                if (a && a->nofork) {
+                    setup_redirects(child, squirrel);
+                    rcode = run_nofork_applet(a, child->argv + i);
+                    restore_redirects(squirrel);
+                    return rcode;
+                }
+            }
+#endif
+        }
+
+#if BB_MMU
+        child->pid = fork();
 #else
-        if (!(child->pid = vfork()))
-#endif
-        {
+        child->pid = vfork();
+#endif
+        if (!child->pid) {
             /* Set the handling for job control signals back to the default.  */
             signal(SIGINT, SIG_DFL);
@@ -1337 +1281 @@
             signal(SIGCHLD, SIG_DFL);
 
-            // Close all open filehandles.
-            while(close_me_list) close((long)llist_pop(&close_me_list));
-
-            if (outpipe[1]!=-1) {
+            /* Close all open filehandles. */
+            while (close_me_list)
+                close((long)llist_pop(&close_me_list));
+
+            if (outpipe[1] != -1) {
                 close(outpipe[0]);
             }
@@ -1360 +1305 @@
             pseudo_exec(child);
         }
-        if (outpipe[1]!=-1) {
+        if (outpipe[1] != -1) {
             close(outpipe[1]);
         }
@@ -1392 +1337 @@
     int inbg = 0;
     int status;
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
     pid_t  parent_pgrp;
     /* save current owner of TTY so we can restore it on exit */
@@ -1410 +1355 @@
 
             if (!next_command) {
-                if (get_command(input, command))
+                if (get_command_bufsiz(input, command))
                     break;
                 next_command = command;
             }
 
-            if (! expand_arguments(next_command)) {
+            if (!expand_arguments(next_command)) {
                 free(command);
                 command = xzalloc(BUFSIZ);
@@ -1424 +1369 @@
             if (!parse_command(&next_command, &newjob, &inbg) &&
                 newjob.num_progs) {
-                int pipefds[2] = {-1,-1};
-                debug_printf( "job=%p fed to run_command by busy_loop()'\n",
+                int pipefds[2] = { -1, -1 };
+                debug_printf("job=%p fed to run_command by busy_loop()'\n",
                         &newjob);
                 run_command(&newjob, inbg, pipefds);
@@ -1431 +1376 @@
             else {
                 free(command);
-                command = (char *) xzalloc(BUFSIZ);
+                command = xzalloc(BUFSIZ);
                 next_command = NULL;
             }
@@ -1440 +1385 @@
                    job_list.fg->progs[i].is_stopped == 1) i++;
 
-            if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0) {
+            if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED) < 0) {
                 if (errno != ECHILD) {
-                    bb_perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
+                    bb_perror_msg_and_die("waitpid(%d)", job_list.fg->progs[i].pid);
                 }
             }
@@ -1451 +1396 @@
                 job_list.fg->progs[i].pid = 0;
 
-                last_return_code=WEXITSTATUS(status);
+                last_return_code = WEXITSTATUS(status);
 
                 if (!job_list.fg->running_progs) {
@@ -1459 +1404 @@
                 }
             }
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
             else {
                 /* the child was stopped */
@@ -1483 +1428 @@
     free(command);
 
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
     /* return controlling TTY back to parent process group before exiting */
     if (tcsetpgrp(shell_terminal, parent_pgrp) && errno != ENOTTY)
@@ -1496 +1441 @@
 }
 
-#ifdef CONFIG_FEATURE_CLEAN_UP
+#if ENABLE_FEATURE_CLEAN_UP
 static void free_memory(void)
 {
-    if (cwd && cwd!=bb_msg_unknown) {
-        free((char*)cwd);
-    }
-    if (local_pending_command)
-        free(local_pending_command);
+    free(cwd);
 
     if (job_list.fg && !job_list.fg->running_progs) {
@@ -1513 +1454 @@
 #endif
 
-#ifdef CONFIG_LASH_JOB_CONTROL
+#if ENABLE_LASH_JOB_CONTROL
 /* Make sure we have a controlling tty.  If we get started under a job
  * aware app (like bash for example), make sure we are now in charge so
@@ -1523 +1464 @@
 
     /* Loop until we are in the foreground.  */
-    while ((status = tcgetpgrp (shell_terminal)) >= 0) {
-        if (status == (shell_pgrp = getpgrp ())) {
+    while ((status = tcgetpgrp(shell_terminal)) >= 0) {
+        shell_pgrp = getpgrp();
+        if (status == shell_pgrp) {
             break;
         }
-        kill (- shell_pgrp, SIGTTIN);
+        kill(- shell_pgrp, SIGTTIN);
     }
 
@@ -1540 +1482 @@
     /* Put ourselves in our own process group.  */
     setsid();
-    shell_pgrp = getpid ();
+    shell_pgrp = getpid();
     setpgid(shell_pgrp, shell_pgrp);
 
@@ -1552 +1494 @@
 #endif
 
+int lash_main(int argc_l, char **argv_l);
 int lash_main(int argc_l, char **argv_l)
 {
-    int opt, interactive=FALSE;
+    unsigned opt;
     FILE *input = stdin;
     argc = argc_l;
     argv = argv_l;
 
+#if ENABLE_FEATURE_EDITING
+    line_input_state = new_line_input_t(FOR_SHELL);
+#endif
+
     /* These variables need re-initializing when recursing */
     last_jobid = 0;
-    local_pending_command = NULL;
     close_me_list = NULL;
     job_list.head = NULL;
     job_list.fg = NULL;
-    last_return_code=1;
+    last_return_code = 1;
 
     if (argv[0] && argv[0][0] == '-') {
@@ -1574 +1520 @@
             /* Now run the file */
             busy_loop(prof_input);
-            fclose(prof_input);
+            fclose_if_not_stdin(prof_input);
             llist_pop(&close_me_list);
         }
     }
 
-    while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
-        switch (opt) {
-            case 'c':
-                input = NULL;
-                if (local_pending_command != 0)
-                    bb_error_msg_and_die("multiple -c arguments");
-                local_pending_command = bb_xstrdup(argv[optind]);
-                optind++;
-                argv = argv+optind;
-                break;
-            case 'i':
-                interactive++;
-                break;
-            default:
-                bb_show_usage();
-        }
+    opt = getopt32(argv_l, "+ic:", &local_pending_command);
+#define LASH_OPT_i (1<<0)
+#define LASH_OPT_c (1<<1)
+    if (opt & LASH_OPT_c) {
+        input = NULL;
+        optind++;
+        argv += optind;
     }
     /* A shell is interactive if the `-i' flag was given, or if all of
@@ -1603 +1540 @@
      *    standard output is a terminal
      *    Refer to Posix.2, the description of the `sh' utility. */
-    if (argv[optind]==NULL && input==stdin &&
-            isatty(STDIN_FILENO) && isatty(STDOUT_FILENO))
-    {
-        interactive++;
+    if (argv[optind] == NULL && input == stdin
+     && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
+    ) {
+        opt |= LASH_OPT_i;
     }
     setup_job_control();
-    if (interactive) {
+    if (opt & LASH_OPT_i) {
         /* Looks like they want an interactive shell */
         if (!ENABLE_FEATURE_SH_EXTRA_QUIET) {
-            printf( "\n\n%s Built-in shell (lash)\n", BB_BANNER);
-            printf( "Enter 'help' for a list of built-in commands.\n\n");
+            printf("\n\n%s built-in shell (lash)\n"
+                    "Enter 'help' for a list of built-in commands.\n\n",
+                    bb_banner);
         }
     } else if (!local_pending_command && argv[optind]) {
         //printf( "optind=%d  argv[optind]='%s'\n", optind, argv[optind]);
-        input = bb_xfopen(argv[optind], "r");
+        input = xfopen(argv[optind], "r");
         /* be lazy, never mark this closed */
         llist_add_to(&close_me_list, (void *)(long)fileno(input));
@@ -1623 +1561 @@
 
     /* initialize the cwd -- this is never freed...*/
-    cwd = xgetcwd(0);
-    if (!cwd)
-        cwd = bb_msg_unknown;
+    update_cwd();
 
     if (ENABLE_FEATURE_CLEAN_UP) atexit(free_memory);
 
-    if (ENABLE_FEATURE_COMMAND_EDITING) cmdedit_set_initial_prompt();
+    if (ENABLE_FEATURE_EDITING) cmdedit_set_initial_prompt();
     else PS1 = NULL;
 
-    return (busy_loop(input));
-}
+    return busy_loop(input);
+}

branches/2.2.5/mindi-busybox/shell/msh.c

@@ -11 +11 @@
  *   Erik Andersen <andersen@codepoet.org>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- * Original copyright notice is retained at the end of this file.
- */
-
-#include "busybox.h"
-#include <ctype.h>
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include <sys/times.h>
 #include <setjmp.h>
-#include <signal.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/times.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-
-#include "cmdedit.h"
-
-
-/* Conditional use of "register" keyword */
-#define REGISTER register
-
+
+#ifdef STANDALONE
+# ifndef _GNU_SOURCE
+#  define _GNU_SOURCE
+# endif
+# include <sys/types.h>
+# include <sys/stat.h>
+# include <sys/wait.h>
+# include <signal.h>
+# include <stdio.h>
+# include <stdlib.h>
+# include <unistd.h>
+# include <string.h>
+# include <errno.h>
+# include <dirent.h>
+# include <fcntl.h>
+# include <ctype.h>
+# include <assert.h>
+# define bb_dev_null "/dev/null"
+# define DEFAULT_SHELL "/proc/self/exe"
+# define CONFIG_BUSYBOX_EXEC_PATH "/proc/self/exe"
+# define bb_banner "busybox standalone"
+# define ENABLE_FEATURE_SH_STANDALONE 0
+# define bb_msg_memory_exhausted "memory exhausted"
+# define xmalloc(size) malloc(size)
+# define msh_main(argc,argv) main(argc,argv)
+# define safe_read(fd,buf,count) read(fd,buf,count)
+# define NOT_LONE_DASH(s) ((s)[0] != '-' || (s)[1])
+# define LONE_CHAR(s,c) ((s)[0] == (c) && !(s)[1])
+# define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
+static char *find_applet_by_name(const char *applet)
+{
+    return NULL;
+}
+static char *utoa_to_buf(unsigned n, char *buf, unsigned buflen)
+{
+    unsigned i, out, res;
+    assert(sizeof(unsigned) == 4);
+    if (buflen) {
+        out = 0;
+        for (i = 1000000000; i; i /= 10) {
+            res = n / i;
+            if (res || out || i == 1) {
+                if (!--buflen) break;
+                out++;
+                n -= res*i;
+                *buf++ = '0' + res;
+            }
+        }
+    }
+    return buf;
+}
+static char *itoa_to_buf(int n, char *buf, unsigned buflen)
+{
+    if (buflen && n < 0) {
+        n = -n;
+        *buf++ = '-';
+        buflen--;
+    }
+    return utoa_to_buf((unsigned)n, buf, buflen);
+}
+static char local_buf[12];
+static char *itoa(int n)
+{
+    *(itoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0';
+    return local_buf;
+}
+#else
+# include "busybox.h"
+extern char **environ;
+#endif
 
 /*#define MSHDEBUG 1*/
@@ -59 +93 @@
 int mshdbg = MSHDEBUG;
 
-#define DBGPRINTF(x)    if(mshdbg>0)printf x
-#define DBGPRINTF0(x)   if(mshdbg>0)printf x
-#define DBGPRINTF1(x)   if(mshdbg>1)printf x
-#define DBGPRINTF2(x)   if(mshdbg>2)printf x
-#define DBGPRINTF3(x)   if(mshdbg>3)printf x
-#define DBGPRINTF4(x)   if(mshdbg>4)printf x
-#define DBGPRINTF5(x)   if(mshdbg>5)printf x
-#define DBGPRINTF6(x)   if(mshdbg>6)printf x
-#define DBGPRINTF7(x)   if(mshdbg>7)printf x
-#define DBGPRINTF8(x)   if(mshdbg>8)printf x
-#define DBGPRINTF9(x)   if(mshdbg>9)printf x
+#define DBGPRINTF(x)    if (mshdbg>0) printf x
+#define DBGPRINTF0(x)   if (mshdbg>0) printf x
+#define DBGPRINTF1(x)   if (mshdbg>1) printf x
+#define DBGPRINTF2(x)   if (mshdbg>2) printf x
+#define DBGPRINTF3(x)   if (mshdbg>3) printf x
+#define DBGPRINTF4(x)   if (mshdbg>4) printf x
+#define DBGPRINTF5(x)   if (mshdbg>5) printf x
+#define DBGPRINTF6(x)   if (mshdbg>6) printf x
+#define DBGPRINTF7(x)   if (mshdbg>7) printf x
+#define DBGPRINTF8(x)   if (mshdbg>8) printf x
+#define DBGPRINTF9(x)   if (mshdbg>9) printf x
 
 int mshdbg_rc = 0;
 
-#define RCPRINTF(x)     if(mshdbg_rc)printf x
+#define RCPRINTF(x) if (mshdbg_rc) printf x
 
 #else
 
 #define DBGPRINTF(x)
-#define DBGPRINTF0(x)
-#define DBGPRINTF1(x)
-#define DBGPRINTF2(x)
-#define DBGPRINTF3(x)
-#define DBGPRINTF4(x)
-#define DBGPRINTF5(x)
-#define DBGPRINTF6(x)
-#define DBGPRINTF7(x)
-#define DBGPRINTF8(x)
-#define DBGPRINTF9(x)
-
-#define RCPRINTF(x)
+#define DBGPRINTF0(x) ((void)0)
+#define DBGPRINTF1(x) ((void)0)
+#define DBGPRINTF2(x) ((void)0)
+#define DBGPRINTF3(x) ((void)0)
+#define DBGPRINTF4(x) ((void)0)
+#define DBGPRINTF5(x) ((void)0)
+#define DBGPRINTF6(x) ((void)0)
+#define DBGPRINTF7(x) ((void)0)
+#define DBGPRINTF8(x) ((void)0)
+#define DBGPRINTF9(x) ((void)0)
+
+#define RCPRINTF(x) ((void)0)
 
 #endif                          /* MSHDEBUG */
 
 
-#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
 # define DEFAULT_ROOT_PROMPT "\\u:\\w> "
 # define DEFAULT_USER_PROMPT "\\u:\\w$ "
@@ -119 +153 @@
  * values returned by wait
  */
-#define WAITSIG(s)  ((s)&0177)
-#define WAITVAL(s)  (((s)>>8)&0377)
-#define WAITCORE(s) (((s)&0200)!=0)
+#define WAITSIG(s)  ((s) & 0177)
+#define WAITVAL(s)  (((s) >> 8) & 0377)
+#define WAITCORE(s) (((s) & 0200) != 0)
 
 /*
@@ -131 +165 @@
  * shell components
  */
-
-#define QUOTE   0200
-
 #define NOBLOCK ((struct op *)NULL)
 #define NOWORD  ((char *)NULL)
 #define NOWORDS ((char **)NULL)
 #define NOPIPE  ((int *)NULL)
+
+/*
+ * redirection
+ */
+struct ioword {
+    short io_unit;              /* unit affected */
+    short io_flag;              /* action (below) */
+    char *io_name;              /* file name */
+};
+
+#define IOREAD   1              /* < */
+#define IOHERE   2              /* << (here file) */
+#define IOWRITE  4              /* > */
+#define IOCAT    8              /* >> */
+#define IOXHERE  16             /* ${}, ` in << */
+#define IODUP    32             /* >&digit */
+#define IOCLOSE  64             /* >&- */
+
+#define IODEFAULT (-1)          /* token for default IO unit */
+
 
 /*
@@ -173 +224 @@
 /* Strings for names to make debug easier */
 #ifdef MSHDEBUG
-static char *T_CMD_NAMES[] = {
+static const char *const T_CMD_NAMES[] = {
     "PLACEHOLDER",
     "TCOM",
@@ -198 +249 @@
  * actions determining the environment of a process
  */
-#define BIT(i)  (1<<(i))
-#define FEXEC   BIT(0)          /* execute without forking */
-
-#if 0                           /* Original value */
-#define AREASIZE    (65000)
-#else
-#define AREASIZE    (90000)
-#endif
+#define FEXEC    1      /* execute without forking */
+
+#define AREASIZE (90000)
 
 /*
  * flags to control evaluation of words
  */
-#define DOSUB    1              /* interpret $, `, and quotes */
-#define DOBLANK  2              /* perform blank interpretation */
-#define DOGLOB   4              /* interpret [?* */
-#define DOKEY    8              /* move words with `=' to 2nd arg. list */
-#define DOTRIM   16             /* trim resulting string */
-
-#define DOALL   (DOSUB|DOBLANK|DOGLOB|DOKEY|DOTRIM)
-
-
-/* PROTOTYPES */
-static int newfile(char *s);
-static char *findeq(char *cp);
-static char *cclass(char *p, int sub);
-static void initarea(void);
-extern int msh_main(int argc, char **argv);
+#define DOSUB    1      /* interpret $, `, and quotes */
+#define DOBLANK  2      /* perform blank interpretation */
+#define DOGLOB   4      /* interpret [?* */
+#define DOKEY    8      /* move words with `=' to 2nd arg. list */
+#define DOTRIM   16     /* trim resulting string */
+
+#define DOALL    (DOSUB|DOBLANK|DOGLOB|DOKEY|DOTRIM)
 
 
@@ -232 +270 @@
 };
 
-
-/*
- * redirection
- */
-struct ioword {
-    short io_unit;              /* unit affected */
-    short io_flag;              /* action (below) */
-    char *io_name;              /* file name */
-};
-
-#define IOREAD   1              /* < */
-#define IOHERE   2              /* << (here file) */
-#define IOWRITE  4              /* > */
-#define IOCAT    8              /* >> */
-#define IOXHERE  16             /* ${}, ` in << */
-#define IODUP    32             /* >&digit */
-#define IOCLOSE  64             /* >&- */
-
-#define IODEFAULT (-1)          /* token for default IO unit */
-
-
-
-/*
- * parsing & execution environment
- */
-static struct env {
-    char *linep;
-    struct io *iobase;
-    struct io *iop;
-    xint *errpt;                /* void * */
-    int iofd;
-    struct env *oenv;
-} e;
 
 /*
@@ -276 +281 @@
  * -u: unset variables net diagnostic
  */
-static char *flag;
-
-static char *null;              /* null value for variable */
-static int intr;                /* interrupt pending */
-
-static char *trap[_NSIG + 1];
-static char ourtrap[_NSIG + 1];
+static char flags['z' - 'a' + 1] ALIGN1;
+/* this looks weird, but is OK ... we index FLAG with 'a'...'z' */
+#define FLAG (flags - 'a')
+
+/* moved to G: static char *trap[_NSIG + 1]; */
+/* moved to G: static char ourtrap[_NSIG + 1]; */
 static int trapset;             /* trap pending */
 
-static int heedint;             /* heed interrupt signals */
-
 static int yynerrs;             /* yacc */
 
-static char line[LINELIM];
-static char *elinep;
+/* moved to G: static char line[LINELIM]; */
+
+#if ENABLE_FEATURE_EDITING
+static char *current_prompt;
+static line_input_t *line_input_state;
+#endif
 
 
@@ -296 +302 @@
  * other functions
  */
-static int (*inbuilt(char *s)) (struct op *);
-
-static char *rexecve(char *c, char **v, char **envp);
-static char *space(int n);
-static char *strsave(char *s, int a);
+static const char *rexecve(char *c, char **v, char **envp);
 static char *evalstr(char *cp, int f);
 static char *putn(int n);
-static char *itoa(int n);
 static char *unquote(char *as);
-static struct var *lookup(char *n);
 static int rlookup(char *n);
 static struct wdblock *glob(char *cp, struct wdblock *wb);
@@ -319 +319 @@
 static int newenv(int f);
 static void quitenv(void);
-static void err(char *s);
-static int anys(char *s1, char *s2);
-static int any(int c, char *s);
 static void next(int f);
 static void setdash(void);
 static void onecommand(void);
 static void runtrap(int i);
-static int gmatch(char *s, char *p);
-
-
-/*
- * error handling
- */
-static void leave(void);        /* abort shell (or fail in subshell) */
-static void fail(void);         /* fail but return to process next command */
-static void warn(char *s);
-static void sig(int i);         /* default signal handler */
-
 
 
 /* -------- area stuff -------- */
 
-#define REGSIZE   sizeof(struct region)
-#define GROWBY    (256)
-/* #define  SHRINKBY   (64) */
-#undef  SHRINKBY
-#define FREE      (32767)
-#define BUSY      (0)
-#define ALIGN     (sizeof(int)-1)
+#define REGSIZE   sizeof(struct region)
+#define GROWBY    (256)
+/* #define SHRINKBY (64) */
+#undef  SHRINKBY
+#define FREE      (32767)
+#define BUSY      (0)
+#define ALIGN     (sizeof(int)-1)
 
 
@@ -354 +340 @@
     int area;
 };
-
 
 
@@ -365 +350 @@
 } YYSTYPE;
 
-#define WORD    256
-#define LOGAND  257
-#define LOGOR   258
-#define BREAK   259
-#define IF      260
-#define THEN    261
-#define ELSE    262
-#define ELIF    263
-#define FI      264
-#define CASE    265
-#define ESAC    266
-#define FOR     267
-#define WHILE   268
-#define UNTIL   269
-#define DO      270
-#define DONE    271
-#define IN      272
+#define WORD    256
+#define LOGAND  257
+#define LOGOR   258
+#define BREAK   259
+#define IF      260
+#define THEN    261
+#define ELSE    262
+#define ELIF    263
+#define FI      264
+#define CASE    265
+#define ESAC    266
+#define FOR     267
+#define WHILE   268
+#define UNTIL   269
+#define DO      270
+#define DONE    271
+#define IN      272
 /* Added for "." file expansion */
-#define DOT     273
+#define DOT     273
 
 #define YYERRCODE 300
 
 /* flags to yylex */
-#define CONTIN  01              /* skip new lines to complete command */
-
-#define SYNTAXERR   zzerr()
+#define CONTIN 01     /* skip new lines to complete command */
 
 static struct op *pipeline(int cf);
@@ -415 +398 @@
 static struct ioword **copyio(void);
 static struct ioword *io(int u, int f, char *cp);
-static void zzerr(void);
-static void yyerror(char *s);
 static int yylex(int cf);
 static int collect(int c, int c1);
@@ -438 +419 @@
 
 static int yyparse(void);
-static struct var *lookup(char *n);
-static void setval(struct var *vp, char *val);
-static void nameval(struct var *vp, char *val, char *name);
-static void export(struct var *vp);
-static void ronly(struct var *vp);
-static int isassign(char *s);
-static int checkname(char *cp);
-static int assign(char *s, int cf);
-static void putvlist(int f, int out);
-static int eqname(char *n1, char *n2);
 
 static int execute(struct op *t, int *pin, int *pout, int act);
+
+
+#define AFID_NOBUF  (~0)
+#define AFID_ID     0
 
 
@@ -455 +430 @@
 /* io buffer */
 struct iobuf {
-    unsigned id;                /* buffer id */
-    char buf[512];              /* buffer */
-    char *bufp;                 /* pointer into buffer */
-    char *ebufp;                /* pointer to end of buffer */
+    unsigned id;            /* buffer id */
+    char buf[512];          /* buffer */
+    char *bufp;             /* pointer into buffer */
+    char *ebufp;            /* pointer to end of buffer */
 };
 
 /* possible arguments to an IO function */
 struct ioarg {
-    char *aword;
+    const char *aword;
     char **awordlist;
-    int afile;                  /* file descriptor */
-    unsigned afid;              /* buffer id */
-    long afpos;                 /* file position */
-    struct iobuf *afbuf;        /* buffer for this file */
+    int afile;              /* file descriptor */
+    unsigned afid;          /* buffer id */
+    long afpos;             /* file position */
+    struct iobuf *afbuf;    /* buffer for this file */
 };
-
-//static struct ioarg ioargstack[NPUSH];
-#define AFID_NOBUF  (~0)
-#define AFID_ID     0
 
 /* an input generator's state */
@@ -480 +451 @@
     struct ioarg *argp;
     int peekc;
-    char prev;                  /* previous character read by readc() */
-    char nlcount;               /* for `'s */
-    char xchar;                 /* for `'s */
-    char task;                  /* reason for pushed IO */
+    char prev;              /* previous character read by readc() */
+    char nlcount;           /* for `'s */
+    char xchar;             /* for `'s */
+    char task;              /* reason for pushed IO */
 };
 
-//static    struct  io  iostack[NPUSH];
 #define XOTHER  0               /* none of the below */
 #define XDOLL   1               /* expanding ${} */
 #define XGRAVE  2               /* expanding `'s */
-#define XIO 3                   /* file IO */
+#define XIO 3               /* file IO */
 
 /* in substitution */
 #define INSUB() (e.iop->task == XGRAVE || e.iop->task == XDOLL)
+
+static struct ioarg temparg = { 0, 0, 0, AFID_NOBUF, 0 };   /* temporary for PUSHIO */
+/* moved to G: static struct ioarg ioargstack[NPUSH]; */
+static struct io iostack[NPUSH];
+/* moved to G: static struct iobuf sharedbuf = { AFID_NOBUF }; */
+/* moved to G: static struct iobuf mainbuf = { AFID_NOBUF }; */
+static unsigned bufid = AFID_ID;    /* buffer id counter */
+
+#define RUN(what,arg,gen) ((temparg.what = (arg)), run(&temparg,(gen)))
 
 
@@ -517 +496 @@
 
 
-/*
- * IO functions
- */
 static int eofc(void);
 static int readc(void);
 static void unget(int c);
 static void ioecho(char c);
-static void prs(const char *s);
-static void prn(unsigned u);
-static void closef(int i);
-static void closeall(void);
 
 
@@ -534 +506 @@
  */
 static void pushio(struct ioarg *argp, int (*f) (struct ioarg *));
+#define PUSHIO(what,arg,gen) ((temparg.what = (arg)), pushio(&temparg,(gen)))
 static int remap(int fd);
 static int openpipe(int *pv);
 static void closepipe(int *pv);
 static struct io *setbase(struct io *ip);
-
-#define PUSHIO(what,arg,gen) ((temparg.what = (arg)),pushio(&temparg,(gen)))
-#define RUN(what,arg,gen) ((temparg.what = (arg)), run(&temparg,(gen)))
 
 /* -------- word.h -------- */
@@ -557 +527 @@
 static char **getwords(struct wdblock *wb);
 
-/* -------- area.h -------- */
-
-/*
- * storage allocation
- */
-static char *getcell(unsigned nbytes);
-static void garbage(void);
-static void setarea(char *cp, int a);
-static int getarea(char *cp);
-static void freearea(int a);
-static void freecell(char *cp);
-static int areanum;             /* current allocation area */
-
-#define NEW(type)   (type *)getcell(sizeof(type))
-#define DELETE(obj) freecell((char *)obj)
-
-
 /* -------- misc stuff -------- */
 
 static int forkexec(struct op *t, int *pin, int *pout, int act, char **wp);
 static int iosetup(struct ioword *iop, int pipein, int pipeout);
-static void echo(char **wp);
-static struct op **find1case(struct op *t, char *w);
-static struct op *findcase(struct op *t, char *w);
 static void brkset(struct brkcon *bc);
 static int dolabel(struct op *t);
@@ -608 +558 @@
 static void varput(char *s, int out);
 static int dotimes(struct op *t);
-static int expand(char *cp, struct wdblock **wbp, int f);
+static int expand(const char *cp, struct wdblock **wbp, int f);
 static char *blank(int f);
 static int dollar(int quoted);
@@ -616 +566 @@
 static int anyspcl(struct wdblock *wb);
 static int xstrcmp(char *p1, char *p2);
-static void glob0(char *a0, unsigned int a1, int a2,
+static void glob0(char *a0, unsigned a1, int a2,
                   int (*a3) (char *, char *));
-static void glob1(char *base, char *lim);
-static void glob2(char *i, char *j);
-static void glob3(char *i, char *j, char *k);
 static void readhere(char **name, char *s, int ec);
-static void pushio(struct ioarg *argp, int (*f) (struct ioarg *));
 static int xxchar(struct ioarg *ap);
 
@@ -632 +578 @@
 };
 
-static const char * const signame[] = {
+static const char *const signame[] = {
     "Signal 0",
     "Hangup",
-    (char *) NULL,              /* interrupt */
+    NULL,  /* interrupt */
     "Quit",
     "Illegal instruction",
@@ -646 +592 @@
     "SIGSEGV",
     "SIGUSR2",
-    (char *) NULL,              /* broken pipe */
+    NULL,  /* broken pipe */
     "Alarm clock",
-    "Terminated",
+    "Terminated"
 };
 
-#define NSIGNAL (sizeof(signame)/sizeof(signame[0]))
 
 struct res {
@@ -658 +603 @@
 };
 static const struct res restab[] = {
-    {"for", FOR},
-    {"case", CASE},
-    {"esac", ESAC},
-    {"while", WHILE},
-    {"do", DO},
-    {"done", DONE},
-    {"if", IF},
-    {"in", IN},
-    {"then", THEN},
-    {"else", ELSE},
-    {"elif", ELIF},
-    {"until", UNTIL},
-    {"fi", FI},
-    {";;", BREAK},
-    {"||", LOGOR},
-    {"&&", LOGAND},
-    {"{", '{'},
-    {"}", '}'},
-    {".", DOT},
-    {0, 0},
+    { "for"  , FOR    },
+    { "case" , CASE   },
+    { "esac" , ESAC   },
+    { "while", WHILE  },
+    { "do"   , DO     },
+    { "done" , DONE   },
+    { "if"   , IF     },
+    { "in"   , IN     },
+    { "then" , THEN   },
+    { "else" , ELSE   },
+    { "elif" , ELIF   },
+    { "until", UNTIL  },
+    { "fi"   , FI     },
+    { ";;"   , BREAK  },
+    { "||"   , LOGOR  },
+    { "&&"   , LOGAND },
+    { "{"    , '{'    },
+    { "}"    , '}'    },
+    { "."    , DOT    },
+    { NULL   , 0      },
 };
-
 
 struct builtincmd {
     const char *name;
-    int (*builtinfunc) (struct op * t);
+    int (*builtinfunc)(struct op *t);
 };
 static const struct builtincmd builtincmds[] = {
-    {".", dodot},
-    {":", dolabel},
-    {"break", dobreak},
-    {"cd", dochdir},
-    {"continue", docontinue},
-    {"eval", doeval},
-    {"exec", doexec},
-    {"exit", doexit},
-    {"export", doexport},
-    {"help", dohelp},
-    {"login", dologin},
-    {"newgrp", dologin},
-    {"read", doread},
-    {"readonly", doreadonly},
-    {"set", doset},
-    {"shift", doshift},
-    {"times", dotimes},
-    {"trap", dotrap},
-    {"umask", doumask},
-    {"wait", dowait},
-    {0, 0}
+    { "."       , dodot      },
+    { ":"       , dolabel    },
+    { "break"   , dobreak    },
+    { "cd"      , dochdir    },
+    { "continue", docontinue },
+    { "eval"    , doeval     },
+    { "exec"    , doexec     },
+    { "exit"    , doexit     },
+    { "export"  , doexport   },
+    { "help"    , dohelp     },
+    { "login"   , dologin    },
+    { "newgrp"  , dologin    },
+    { "read"    , doread     },
+    { "readonly", doreadonly },
+    { "set"     , doset      },
+    { "shift"   , doshift    },
+    { "times"   , dotimes    },
+    { "trap"    , dotrap     },
+    { "umask"   , doumask    },
+    { "wait"    , dowait     },
+    { NULL      , NULL       },
 };
 
@@ -712 +656 @@
 static struct op *dowholefile(int, int);
 
+
 /* Globals */
-extern char **environ;          /* environment pointer */
-
 static char **dolv;
 static int dolc;
@@ -729 +672 @@
 static struct wdblock *wdlist;
 static struct wdblock *iolist;
-static char *trap[_NSIG + 1];
-static char ourtrap[_NSIG + 1];
-static int trapset;             /* trap pending */
-static int yynerrs;             /* yacc */
-static char line[LINELIM];
 
 #ifdef MSHDEBUG
@@ -746 +684 @@
 static struct var *ifs;         /* field separators */
 
-static int areanum;             /* current allocation area */
-static int intr;
+static int areanum;                     /* current allocation area */
+static int intr;                        /* interrupt pending */
 static int inparse;
-static char flags['z' - 'a' + 1];
-static char *flag = flags - 'a';
-static char *null = "";
-static int heedint = 1;
-static void (*qflag) (int) = SIG_IGN;
+static char *null = (char*)"";          /* null value for variable */
+static int heedint = 1;                 /* heed interrupt signals */
+static void (*qflag)(int) = SIG_IGN;
 static int startl;
 static int peeksym;
@@ -759 +695 @@
 static int iounit = IODEFAULT;
 static YYSTYPE yylval;
-static char *elinep = line + sizeof(line) - 5;
-
-static struct ioarg temparg = { 0, 0, 0, AFID_NOBUF, 0 };   /* temporary for PUSHIO */
-static struct ioarg ioargstack[NPUSH];
-static struct io iostack[NPUSH];
-static struct iobuf sharedbuf = { AFID_NOBUF };
-static struct iobuf mainbuf = { AFID_NOBUF };
-static unsigned bufid = AFID_ID;    /* buffer id counter */
-
-static struct here *inhere;     /* list of hear docs while parsing */
-static struct here *acthere;    /* list of active here documents */
-static struct region *areabot;  /* bottom of area */
-static struct region *areatop;  /* top of area */
-static struct region *areanxt;  /* starting point of scan */
+static char *elinep; /* done in main(): = line + sizeof(line) - 5 */
+
+static struct here *inhere;     /* list of hear docs while parsing */
+static struct here *acthere;    /* list of active here documents */
+static struct region *areabot;  /* bottom of area */
+static struct region *areatop;  /* top of area */
+static struct region *areanxt;  /* starting point of scan */
 static void *brktop;
 static void *brkaddr;
 
+/*
+ * parsing & execution environment
+ */
+struct env {
+    char *linep;
+    struct io *iobase;
+    struct io *iop;
+    xint *errpt;        /* void * */
+    int iofd;
+    struct env *oenv;
+};
+
 static struct env e = {
-    line,                       /* linep:  char ptr */
-    iostack,                    /* iobase:  struct io ptr */
-    iostack - 1,                /* iop:  struct io ptr */
-    (xint *) NULL,              /* errpt:  void ptr for errors? */
-    FDBASE,                     /* iofd:  file desc  */
-    (struct env *) NULL         /* oenv:  struct env ptr */
+    NULL /* set to line in main() */, /* linep:  char ptr */
+    iostack,                /* iobase:  struct io ptr */
+    iostack - 1,            /* iop:  struct io ptr */
+    (xint *) NULL,          /* errpt:  void ptr for errors? */
+    FDBASE,                 /* iofd:  file desc  */
+    (struct env *) NULL     /* oenv:  struct env ptr */
 };
 
+
+struct globals {
+    char ourtrap[_NSIG + 1];
+    char *trap[_NSIG + 1];
+    struct iobuf sharedbuf; /* in main(): set to { AFID_NOBUF } */
+    struct iobuf mainbuf; /* in main(): set to { AFID_NOBUF } */
+    struct ioarg ioargstack[NPUSH];
+    char filechar_cmdbuf[BUFSIZ];
+    char line[LINELIM];
+    char child_cmd[LINELIM];
+};
+
+#define G (*ptr_to_globals)
+#define ourtrap         (G.ourtrap        )
+#define trap            (G.trap           )
+#define sharedbuf       (G.sharedbuf      )
+#define mainbuf         (G.mainbuf        )
+#define ioargstack      (G.ioargstack     )
+#define filechar_cmdbuf (G.filechar_cmdbuf)
+#define line            (G.line           )
+#define child_cmd       (G.child_cmd      )
+
+
 #ifdef MSHDEBUG
-void print_t(struct op *t);
 void print_t(struct op *t)
 {
@@ -795 +758 @@
         DBGPRINTF(("T: W1: %s", t->words[0]));
     }
-
-    return;
-}
-
-void print_tree(struct op *head);
+}
+
 void print_tree(struct op *head)
 {
@@ -815 +775 @@
     if (head->right)
         print_tree(head->right);
-
-    return;
-}
-#endif                          /* MSHDEBUG */
-
-
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
-static char *current_prompt;
+}
+#endif /* MSHDEBUG */
+
+
+/*
+ * IO functions
+ */
+static void prs(const char *s)
+{
+    if (*s)
+        write(2, s, strlen(s));
+}
+
+static void prn(unsigned u)
+{
+    prs(itoa(u));
+}
+
+static void echo(char **wp)
+{
+    int i;
+
+    prs("+");
+    for (i = 0; wp[i]; i++) {
+        if (i)
+            prs(" ");
+        prs(wp[i]);
+    }
+    prs("\n");
+}
+
+static void closef(int i)
+{
+    if (i > 2)
+        close(i);
+}
+
+static void closeall(void)
+{
+    int u;
+
+    for (u = NUFILE; u < NOFILE;)
+        close(u++);
+}
+
+
+/* fail but return to process next command */
+static void fail(void) ATTRIBUTE_NORETURN;
+static void fail(void)
+{
+    longjmp(failpt, 1);
+    /* NOTREACHED */
+}
+
+/* abort shell (or fail in subshell) */
+static void leave(void) ATTRIBUTE_NORETURN;
+static void leave(void)
+{
+    DBGPRINTF(("LEAVE: leave called!\n"));
+
+    if (execflg)
+        fail();
+    scraphere();
+    freehere(1);
+    runtrap(0);
+    _exit(exstat);
+    /* NOTREACHED */
+}
+
+static void warn(const char *s)
+{
+    if (*s) {
+        prs(s);
+        exstat = -1;
+    }
+    prs("\n");
+    if (FLAG['e'])
+        leave();
+}
+
+static void err(const char *s)
+{
+    warn(s);
+    if (FLAG['n'])
+        return;
+    if (!interactive)
+        leave();
+    if (e.errpt)
+        longjmp(e.errpt, 1);
+    closeall();
+    e.iop = e.iobase = iostack;
+}
+
+
+/* -------- area.c -------- */
+
+/*
+ * All memory between (char *)areabot and (char *)(areatop+1) is
+ * exclusively administered by the area management routines.
+ * It is assumed that sbrk() and brk() manipulate the high end.
+ */
+
+#define sbrk(X) ({ \
+    void * __q = (void *)-1; \
+    if (brkaddr + (int)(X) < brktop) { \
+        __q = brkaddr; \
+        brkaddr += (int)(X); \
+    } \
+    __q; \
+})
+
+static void initarea(void)
+{
+    brkaddr = xmalloc(AREASIZE);
+    brktop = brkaddr + AREASIZE;
+
+    while ((long) sbrk(0) & ALIGN)
+        sbrk(1);
+    areabot = (struct region *) sbrk(REGSIZE);
+
+    areabot->next = areabot;
+    areabot->area = BUSY;
+    areatop = areabot;
+    areanxt = areabot;
+}
+
+static char *getcell(unsigned nbytes)
+{
+    int nregio;
+    struct region *p, *q;
+    int i;
+
+    if (nbytes == 0) {
+        puts("getcell(0)");
+        abort();
+    }
+    /* silly and defeats the algorithm */
+    /*
+     * round upwards and add administration area
+     */
+    nregio = (nbytes + (REGSIZE - 1)) / REGSIZE + 1;
+    p = areanxt;
+    for (;;) {
+        if (p->area > areanum) {
+            /*
+             * merge free cells
+             */
+            while ((q = p->next)->area > areanum && q != areanxt)
+                p->next = q->next;
+            /*
+             * exit loop if cell big enough
+             */
+            if (q >= p + nregio)
+                goto found;
+        }
+        p = p->next;
+        if (p == areanxt)
+            break;
+    }
+    i = nregio >= GROWBY ? nregio : GROWBY;
+    p = (struct region *) sbrk(i * REGSIZE);
+    if (p == (struct region *) -1)
+        return NULL;
+    p--;
+    if (p != areatop) {
+        puts("not contig");
+        abort();                /* allocated areas are contiguous */
+    }
+    q = p + i;
+    p->next = q;
+    p->area = FREE;
+    q->next = areabot;
+    q->area = BUSY;
+    areatop = q;
+ found:
+    /*
+     * we found a FREE area big enough, pointed to by 'p', and up to 'q'
+     */
+    areanxt = p + nregio;
+    if (areanxt < q) {
+        /*
+         * split into requested area and rest
+         */
+        if (areanxt + 1 > q) {
+            puts("OOM");
+            abort();            /* insufficient space left for admin */
+        }
+        areanxt->next = q;
+        areanxt->area = FREE;
+        p->next = areanxt;
+    }
+    p->area = areanum;
+    return (char *) (p + 1);
+}
+
+static void freecell(char *cp)
+{
+    struct region *p;
+
+    p = (struct region *) cp;
+    if (p != NULL) {
+        p--;
+        if (p < areanxt)
+            areanxt = p;
+        p->area = FREE;
+    }
+}
+#define DELETE(obj) freecell((char *)obj)
+
+static void freearea(int a)
+{
+    struct region *p, *top;
+
+    top = areatop;
+    for (p = areabot; p != top; p = p->next)
+        if (p->area >= a)
+            p->area = FREE;
+}
+
+static void setarea(char *cp, int a)
+{
+    struct region *p;
+
+    p = (struct region *) cp;
+    if (p != NULL)
+        (p - 1)->area = a;
+}
+
+static int getarea(char *cp)
+{
+    return ((struct region *) cp - 1)->area;
+}
+
+static void garbage(void)
+{
+    struct region *p, *q, *top;
+
+    top = areatop;
+    for (p = areabot; p != top; p = p->next) {
+        if (p->area > areanum) {
+            while ((q = p->next)->area > areanum)
+                p->next = q->next;
+            areanxt = p;
+        }
+    }
+#ifdef SHRINKBY
+    if (areatop >= q + SHRINKBY && q->area > areanum) {
+        brk((char *) (q + 1));
+        q->next = areabot;
+        q->area = BUSY;
+        areatop = q;
+    }
 #endif
-
-/* -------- sh.c -------- */
-/*
- * shell
- */
-
-
-int msh_main(int argc, char **argv)
-{
-    REGISTER int f;
-    REGISTER char *s;
-    int cflag;
-    char *name, **ap;
-    int (*iof) (struct ioarg *);
-
-    DBGPRINTF(("MSH_MAIN: argc %d, environ %p\n", argc, environ));
-
-    initarea();
-    if ((ap = environ) != NULL) {
-        while (*ap)
-            assign(*ap++, !COPYV);
-        for (ap = environ; *ap;)
-            export(lookup(*ap++));
-    }
-    closeall();
-    areanum = 1;
-
-    shell = lookup("SHELL");
-    if (shell->value == null)
-        setval(shell, (char *)DEFAULT_SHELL);
-    export(shell);
-
-    homedir = lookup("HOME");
-    if (homedir->value == null)
-        setval(homedir, "/");
-    export(homedir);
-
-    setval(lookup("$"), putn(getpid()));
-
-    path = lookup("PATH");
-    if (path->value == null) {
-        if (geteuid() == 0)
-            setval(path, "/sbin:/bin:/usr/sbin:/usr/bin");
-        else
-            setval(path, "/bin:/usr/bin");
-    }
-    export(path);
-
-    ifs = lookup("IFS");
-    if (ifs->value == null)
-        setval(ifs, " \t\n");
-
-#ifdef MSHDEBUG
-    mshdbg_var = lookup("MSHDEBUG");
-    if (mshdbg_var->value == null)
-        setval(mshdbg_var, "0");
-#endif
-
-    prompt = lookup("PS1");
-#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
-    if (prompt->value == null)
-#endif
-        setval(prompt, DEFAULT_USER_PROMPT);
-    if (geteuid() == 0) {
-        setval(prompt, DEFAULT_ROOT_PROMPT);
-        prompt->status &= ~EXPORT;
-    }
-    cprompt = lookup("PS2");
-#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
-    if (cprompt->value == null)
-#endif
-        setval(cprompt, "> ");
-
-    iof = filechar;
-    cflag = 0;
-    name = *argv++;
-    if (--argc >= 1) {
-        if (argv[0][0] == '-' && argv[0][1] != '\0') {
-            for (s = argv[0] + 1; *s; s++)
-                switch (*s) {
-                case 'c':
-                    prompt->status &= ~EXPORT;
-                    cprompt->status &= ~EXPORT;
-                    setval(prompt, "");
-                    setval(cprompt, "");
-                    cflag = 1;
-                    if (--argc > 0)
-                        PUSHIO(aword, *++argv, iof = nlchar);
-                    break;
-
-                case 'q':
-                    qflag = SIG_DFL;
-                    break;
-
-                case 's':
-                    /* standard input */
-                    break;
-
-                case 't':
-                    prompt->status &= ~EXPORT;
-                    setval(prompt, "");
-                    iof = linechar;
-                    break;
-
-                case 'i':
-                    interactive++;
-                default:
-                    if (*s >= 'a' && *s <= 'z')
-                        flag[(int) *s]++;
-                }
-        } else {
-            argv--;
-            argc++;
-        }
-
-        if (iof == filechar && --argc > 0) {
-            setval(prompt, "");
-            setval(cprompt, "");
-            prompt->status &= ~EXPORT;
-            cprompt->status &= ~EXPORT;
-
-/* Shell is non-interactive, activate printf-based debug */
-#ifdef MSHDEBUG
-            mshdbg = (int) (((char) (mshdbg_var->value[0])) - '0');
-            if (mshdbg < 0)
-                mshdbg = 0;
-#endif
-            DBGPRINTF(("MSH_MAIN: calling newfile()\n"));
-
-            if (newfile(name = *++argv))
-                exit(1);        /* Exit on error */
-        }
-    }
-
-    setdash();
-
-    /* This won't be true if PUSHIO has been called, say from newfile() above */
-    if (e.iop < iostack) {
-        PUSHIO(afile, 0, iof);
-        if (isatty(0) && isatty(1) && !cflag) {
-            interactive++;
-#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
-#ifdef MSHDEBUG
-            printf("\n\n%s Built-in shell (msh with debug)\n", BB_BANNER);
-#else
-            printf("\n\n%s Built-in shell (msh)\n", BB_BANNER);
-#endif
-            printf("Enter 'help' for a list of built-in commands.\n\n");
-#endif
-        }
-    }
-
-    signal(SIGQUIT, qflag);
-    if (name && name[0] == '-') {
-        interactive++;
-        if ((f = open(".profile", 0)) >= 0)
-            next(remap(f));
-        if ((f = open("/etc/profile", 0)) >= 0)
-            next(remap(f));
-    }
-    if (interactive)
-        signal(SIGTERM, sig);
-
-    if (signal(SIGINT, SIG_IGN) != SIG_IGN)
-        signal(SIGINT, onintr);
-    dolv = argv;
-    dolc = argc;
-    dolv[0] = name;
-    if (dolc > 1) {
-        for (ap = ++argv; --argc > 0;) {
-            if (assign(*ap = *argv++, !COPYV)) {
-                dolc--;         /* keyword */
-            } else {
-                ap++;
-            }
-        }
-    }
-    setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));
-
-    DBGPRINTF(("MSH_MAIN: begin FOR loop, interactive %d, e.iop %p, iostack %p\n", interactive, e.iop, iostack));
-
-    for (;;) {
-        if (interactive && e.iop <= iostack) {
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
-            current_prompt = prompt->value;
-#else
-            prs(prompt->value);
-#endif
-        }
-        onecommand();
-        /* Ensure that getenv("PATH") stays current */
-        setenv("PATH", path->value, 1);
-    }
-
-    DBGPRINTF(("MSH_MAIN: returning.\n"));
-}
+}
+
+static char *space(int n)
+{
+    char *cp;
+
+    cp = getcell(n);
+    if (cp == NULL)
+        err("out of string space");
+    return cp;
+}
+
+static char *strsave(const char *s, int a)
+{
+    char *cp;
+
+    cp = space(strlen(s) + 1);
+    if (cp == NULL) {
+// FIXME: I highly doubt this is good.
+        return (char*)"";
+    }
+    setarea(cp, a);
+    strcpy(cp, s);
+    return cp;
+}
+
+
+/* -------- var.c -------- */
+
+static int eqname(const char *n1, const char *n2)
+{
+    for (; *n1 != '=' && *n1 != '\0'; n1++)
+        if (*n2++ != *n1)
+            return 0;
+    return *n2 == '\0' || *n2 == '=';
+}
+
+static const char *findeq(const char *cp)
+{
+    while (*cp != '\0' && *cp != '=')
+        cp++;
+    return cp;
+}
+
+/*
+ * Find the given name in the dictionary
+ * and return its value.  If the name was
+ * not previously there, enter it now and
+ * return a null value.
+ */
+static struct var *lookup(const char *n)
+{
+// FIXME: dirty hack
+    static struct var dummy;
+
+    struct var *vp;
+    const char *cp;
+    char *xp;
+    int c;
+
+    if (isdigit(*n)) {
+        dummy.name = (char*)n;
+        for (c = 0; isdigit(*n) && c < 1000; n++)
+            c = c * 10 + *n - '0';
+        dummy.status = RONLY;
+        dummy.value = (c <= dolc ? dolv[c] : null);
+        return &dummy;
+    }
+
+    for (vp = vlist; vp; vp = vp->next)
+        if (eqname(vp->name, n))
+            return vp;
+
+    cp = findeq(n);
+    vp = (struct var *) space(sizeof(*vp));
+    if (vp == 0 || (vp->name = space((int) (cp - n) + 2)) == 0) {
+        dummy.name = dummy.value = (char*)"";
+        return &dummy;
+    }
+
+    xp = vp->name;
+    while ((*xp = *n++) != '\0' && *xp != '=')
+        xp++;
+    *xp++ = '=';
+    *xp = '\0';
+    setarea((char *) vp, 0);
+    setarea((char *) vp->name, 0);
+    vp->value = null;
+    vp->next = vlist;
+    vp->status = GETCELL;
+    vlist = vp;
+    return vp;
+}
+
+/*
+ * if name is not NULL, it must be
+ * a prefix of the space `val',
+ * and end with `='.
+ * this is all so that exporting
+ * values is reasonably painless.
+ */
+static void nameval(struct var *vp, const char *val, const char *name)
+{
+    const char *cp;
+    char *xp;
+    int fl;
+
+    if (vp->status & RONLY) {
+        xp = vp->name;
+        while (*xp && *xp != '=')
+            putc(*xp++, stderr);
+        err(" is read-only");
+        return;
+    }
+    fl = 0;
+    if (name == NULL) {
+        xp = space(strlen(vp->name) + strlen(val) + 2);
+        if (xp == NULL)
+            return;
+        /* make string: name=value */
+        setarea(xp, 0);
+        name = xp;
+        cp = vp->name;
+        while ((*xp = *cp++) != '\0' && *xp != '=')
+            xp++;
+        *xp++ = '=';
+        strcpy(xp, val);
+        val = xp;
+        fl = GETCELL;
+    }
+    if (vp->status & GETCELL)
+        freecell(vp->name);     /* form new string `name=value' */
+    vp->name = (char*)name;
+    vp->value = (char*)val;
+    vp->status |= fl;
+}
+
+/*
+ * give variable at `vp' the value `val'.
+ */
+static void setval(struct var *vp, const char *val)
+{
+    nameval(vp, val, NULL);
+}
+
+static void export(struct var *vp)
+{
+    vp->status |= EXPORT;
+}
+
+static void ronly(struct var *vp)
+{
+    if (isalpha(vp->name[0]) || vp->name[0] == '_') /* not an internal symbol */
+        vp->status |= RONLY;
+}
+
+static int isassign(const char *s)
+{
+    unsigned char c;
+    DBGPRINTF7(("ISASSIGN: enter, s=%s\n", s));
+
+    c = *s;
+    /* no isalpha() - we shouldn't use locale */
+    /* c | 0x20 - lowercase (Latin) letters */
+    if (c != '_' && (unsigned)((c|0x20) - 'a') > 25)
+        /* not letter */
+        return 0;
+
+    while (1) {
+        c = *++s;
+        if (c == '=')
+            return 1;
+        if (c == '\0')
+            return 0;
+        if (c != '_'
+         && (unsigned)(c - '0') > 9  /* not number */
+         && (unsigned)((c|0x20) - 'a') > 25 /* not letter */
+        ) {
+            return 0;
+        }
+    }
+}
+
+static int assign(const char *s, int cf)
+{
+    const char *cp;
+    struct var *vp;
+
+    DBGPRINTF7(("ASSIGN: enter, s=%s, cf=%d\n", s, cf));
+
+    if (!isalpha(*s) && *s != '_')
+        return 0;
+    for (cp = s; *cp != '='; cp++)
+        if (*cp == '\0' || (!isalnum(*cp) && *cp != '_'))
+            return 0;
+    vp = lookup(s);
+    nameval(vp, ++cp, cf == COPYV ? NULL : s);
+    if (cf != COPYV)
+        vp->status &= ~GETCELL;
+    return 1;
+}
+
+static int checkname(char *cp)
+{
+    DBGPRINTF7(("CHECKNAME: enter, cp=%s\n", cp));
+
+    if (!isalpha(*cp++) && *(cp - 1) != '_')
+        return 0;
+    while (*cp)
+        if (!isalnum(*cp++) && *(cp - 1) != '_')
+            return 0;
+    return 1;
+}
+
+static void putvlist(int f, int out)
+{
+    struct var *vp;
+
+    for (vp = vlist; vp; vp = vp->next) {
+        if (vp->status & f && (isalpha(*vp->name) || *vp->name == '_')) {
+            if (vp->status & EXPORT)
+                write(out, "export ", 7);
+            if (vp->status & RONLY)
+                write(out, "readonly ", 9);
+            write(out, vp->name, (int) (findeq(vp->name) - vp->name));
+            write(out, "\n", 1);
+        }
+    }
+}
+
+
+/*
+ * trap handling
+ */
+static void sig(int i)
+{
+    trapset = i;
+    signal(i, sig);
+}
+
+static void runtrap(int i)
+{
+    char *trapstr;
+
+    trapstr = trap[i];
+    if (trapstr == NULL)
+        return;
+
+    if (i == 0)
+        trap[i] = NULL;
+
+    RUN(aword, trapstr, nlchar);
+}
+
 
 static void setdash(void)
 {
-    REGISTER char *cp;
-    REGISTER int c;
+    char *cp;
+    int c;
     char m['z' - 'a' + 1];
 
     cp = m;
     for (c = 'a'; c <= 'z'; c++)
-        if (flag[(int) c])
+        if (FLAG[c])
             *cp++ = c;
-    *cp = 0;
+    *cp = '\0';
     setval(lookup("-"), m);
 }
 
-static int newfile(REGISTER char *s)
-{
-    REGISTER int f;
+static int newfile(char *s)
+{
+    int f;
 
     DBGPRINTF7(("NEWFILE: opening %s\n", s));
 
-    if (strcmp(s, "-") != 0) {
+    f = 0;
+    if (NOT_LONE_DASH(s)) {
         DBGPRINTF(("NEWFILE: s is %s\n", s));
-        f = open(s, 0);
+        f = open(s, O_RDONLY);
         if (f < 0) {
             prs(s);
             err(": cannot open");
-            return (1);
-        }
-    } else
-        f = 0;
+            return 1;
+        }
+    }
 
     next(remap(f));
-    return (0);
+    return 0;
 }
 
@@ -1062 +1324 @@
 
     if (head == NULL)
-        return (NULL);
+        return NULL;
 
     if (head->left != NULL) {
         dotnode = scantree(head->left);
         if (dotnode)
-            return (dotnode);
+            return dotnode;
     }
 
@@ -1073 +1335 @@
         dotnode = scantree(head->right);
         if (dotnode)
-            return (dotnode);
+            return dotnode;
     }
 
     if (head->words == NULL)
-        return (NULL);
+        return NULL;
 
     DBGPRINTF5(("SCANTREE: checking node %p\n", head));
 
-    if ((head->type != TDOT) && (strcmp(".", head->words[0]) == 0)) {
+    if ((head->type != TDOT) && LONE_CHAR(head->words[0], '.')) {
         DBGPRINTF5(("SCANTREE: dot found in node %p\n", head));
-        return (head);
-    }
-
-    return (NULL);
+        return head;
+    }
+
+    return NULL;
 }
 
@@ -1092 +1354 @@
 static void onecommand(void)
 {
-    REGISTER int i;
+    int i;
     jmp_buf m1;
 
@@ -1114 +1376 @@
     execflg = 0;
 
-    setjmp(failpt = m1);        /* Bruce Evans' fix */
-    if (setjmp(failpt = m1) || yyparse() || intr) {
-
+    failpt = m1;
+    setjmp(failpt);     /* Bruce Evans' fix */
+    failpt = m1;
+    if (setjmp(failpt) || yyparse() || intr) {
         DBGPRINTF(("ONECOMMAND: this is not good.\n"));
 
@@ -1134 +1397 @@
     execflg = 0;
 
-    if (!flag['n']) {
+    if (!FLAG['n']) {
         DBGPRINTF(("ONECOMMAND: calling execute, t=outtree=%p\n",
                    outtree));
@@ -1145 +1408 @@
     }
 
-    if ((i = trapset) != 0) {
+    i = trapset;
+    if (i != 0) {
         trapset = 0;
         runtrap(i);
@@ -1151 +1415 @@
 }
 
-static void fail(void)
-{
-    longjmp(failpt, 1);
-    /* NOTREACHED */
-}
-
-static void leave(void)
-{
-    DBGPRINTF(("LEAVE: leave called!\n"));
-
-    if (execflg)
-        fail();
-    scraphere();
-    freehere(1);
-    runtrap(0);
-    _exit(exstat);
-    /* NOTREACHED */
-}
-
-static void warn(REGISTER char *s)
-{
-    if (*s) {
-        prs(s);
-        exstat = -1;
-    }
-    prs("\n");
-    if (flag['e'])
-        leave();
-}
-
-static void err(char *s)
-{
-    warn(s);
-    if (flag['n'])
-        return;
-    if (!interactive)
-        leave();
-    if (e.errpt)
-        longjmp(e.errpt, 1);
-    closeall();
-    e.iop = e.iobase = iostack;
-}
-
 static int newenv(int f)
 {
-    REGISTER struct env *ep;
+    struct env *ep;
 
     DBGPRINTF(("NEWENV: f=%d (indicates quitenv and return)\n", f));
@@ -1202 +1423 @@
     if (f) {
         quitenv();
-        return (1);
+        return 1;
     }
 
@@ -1215 +1436 @@
     e.errpt = errpt;
 
-    return (0);
+    return 0;
 }
 
 static void quitenv(void)
 {
-    REGISTER struct env *ep;
-    REGISTER int fd;
+    struct env *ep;
+    int fd;
 
     DBGPRINTF(("QUITENV: e.oenv=%p\n", e.oenv));
 
-    if ((ep = e.oenv) != NULL) {
+    ep = e.oenv;
+    if (ep != NULL) {
         fd = e.iofd;
         e = *ep;
@@ -1236 +1458 @@
 
 /*
+ * Is character c in s?
+ */
+static int any(int c, const char *s)
+{
+    while (*s)
+        if (*s++ == c)
+            return 1;
+    return 0;
+}
+
+/*
  * Is any character from s1 in s2?
  */
-static int anys(REGISTER char *s1, REGISTER char *s2)
+static int anys(const char *s1, const char *s2)
 {
     while (*s1)
         if (any(*s1++, s2))
-            return (1);
-    return (0);
-}
-
-/*
- * Is character c in s?
- */
-static int any(REGISTER int c, REGISTER char *s)
-{
-    while (*s)
-        if (*s++ == c)
-            return (1);
-    return (0);
-}
-
-static char *putn(REGISTER int n)
-{
-    return (itoa(n));
-}
-
-static char *itoa(REGISTER int n)
-{
-    static char s[20];
-
-    snprintf(s, sizeof(s), "%u", n);
-    return (s);
-}
-
+            return 1;
+    return 0;
+}
+
+static char *putn(int n)
+{
+    return itoa(n);
+}
 
 static void next(int f)
@@ -1291 +1504 @@
 }
 
-static char *space(int n)
-{
-    REGISTER char *cp;
-
-    if ((cp = getcell(n)) == 0)
-        err("out of string space");
-    return (cp);
-}
-
-static char *strsave(REGISTER char *s, int a)
-{
-    REGISTER char *cp, *xp;
-
-    if ((cp = space(strlen(s) + 1)) != NULL) {
-        setarea((char *) cp, a);
-        for (xp = cp; (*xp++ = *s++) != '\0';);
-        return (cp);
-    }
-    return ("");
-}
-
-/*
- * trap handling
- */
-static void sig(REGISTER int i)
-{
-    trapset = i;
-    signal(i, sig);
-}
-
-static void runtrap(int i)
-{
-    char *trapstr;
-
-    if ((trapstr = trap[i]) == NULL)
-        return;
-
-    if (i == 0)
-        trap[i] = 0;
-
-    RUN(aword, trapstr, nlchar);
-}
-
-/* -------- var.c -------- */
-
-/*
- * Find the given name in the dictionary
- * and return its value.  If the name was
- * not previously there, enter it now and
- * return a null value.
- */
-static struct var *lookup(REGISTER char *n)
-{
-    REGISTER struct var *vp;
-    REGISTER char *cp;
-    REGISTER int c;
-    static struct var dummy;
-
-    if (isdigit(*n)) {
-        dummy.name = n;
-        for (c = 0; isdigit(*n) && c < 1000; n++)
-            c = c * 10 + *n - '0';
-        dummy.status = RONLY;
-        dummy.value = c <= dolc ? dolv[c] : null;
-        return (&dummy);
-    }
-    for (vp = vlist; vp; vp = vp->next)
-        if (eqname(vp->name, n))
-            return (vp);
-    cp = findeq(n);
-    vp = (struct var *) space(sizeof(*vp));
-    if (vp == 0 || (vp->name = space((int) (cp - n) + 2)) == 0) {
-        dummy.name = dummy.value = "";
-        return (&dummy);
-    }
-    for (cp = vp->name; (*cp = *n++) && *cp != '='; cp++);
-    if (*cp == 0)
-        *cp = '=';
-    *++cp = 0;
-    setarea((char *) vp, 0);
-    setarea((char *) vp->name, 0);
-    vp->value = null;
-    vp->next = vlist;
-    vp->status = GETCELL;
-    vlist = vp;
-    return (vp);
-}
-
-/*
- * give variable at `vp' the value `val'.
- */
-static void setval(struct var *vp, char *val)
-{
-    nameval(vp, val, (char *) NULL);
-}
-
-/*
- * if name is not NULL, it must be
- * a prefix of the space `val',
- * and end with `='.
- * this is all so that exporting
- * values is reasonably painless.
- */
-static void nameval(REGISTER struct var *vp, char *val, char *name)
-{
-    REGISTER char *cp, *xp;
-    char *nv;
-    int fl;
-
-    if (vp->status & RONLY) {
-        for (xp = vp->name; *xp && *xp != '=';)
-            putc(*xp++, stderr);
-        err(" is read-only");
-        return;
-    }
-    fl = 0;
-    if (name == NULL) {
-        xp = space(strlen(vp->name) + strlen(val) + 2);
-        if (xp == 0)
-            return;
-        /* make string:  name=value */
-        setarea((char *) xp, 0);
-        name = xp;
-        for (cp = vp->name; (*xp = *cp++) && *xp != '='; xp++);
-        if (*xp++ == 0)
-            xp[-1] = '=';
-        nv = xp;
-        for (cp = val; (*xp++ = *cp++) != '\0';);
-        val = nv;
-        fl = GETCELL;
-    }
-    if (vp->status & GETCELL)
-        freecell(vp->name);     /* form new string `name=value' */
-    vp->name = name;
-    vp->value = val;
-    vp->status |= fl;
-}
-
-static void export(struct var *vp)
-{
-    vp->status |= EXPORT;
-}
-
-static void ronly(struct var *vp)
-{
-    if (isalpha(vp->name[0]) || vp->name[0] == '_') /* not an internal symbol */
-        vp->status |= RONLY;
-}
-
-static int isassign(REGISTER char *s)
-{
-    DBGPRINTF7(("ISASSIGN: enter, s=%s\n", s));
-
-    if (!isalpha((int) *s) && *s != '_')
-        return (0);
-    for (; *s != '='; s++)
-        if (*s == 0 || (!isalnum(*s) && *s != '_'))
-            return (0);
-
-    return (1);
-}
-
-static int assign(REGISTER char *s, int cf)
-{
-    REGISTER char *cp;
-    struct var *vp;
-
-    DBGPRINTF7(("ASSIGN: enter, s=%s, cf=%d\n", s, cf));
-
-    if (!isalpha(*s) && *s != '_')
-        return (0);
-    for (cp = s; *cp != '='; cp++)
-        if (*cp == 0 || (!isalnum(*cp) && *cp != '_'))
-            return (0);
-    vp = lookup(s);
-    nameval(vp, ++cp, cf == COPYV ? (char *) NULL : s);
-    if (cf != COPYV)
-        vp->status &= ~GETCELL;
-    return (1);
-}
-
-static int checkname(REGISTER char *cp)
-{
-    DBGPRINTF7(("CHECKNAME: enter, cp=%s\n", cp));
-
-    if (!isalpha(*cp++) && *(cp - 1) != '_')
-        return (0);
-    while (*cp)
-        if (!isalnum(*cp++) && *(cp - 1) != '_')
-            return (0);
-    return (1);
-}
-
-static void putvlist(REGISTER int f, REGISTER int out)
-{
-    REGISTER struct var *vp;
-
-    for (vp = vlist; vp; vp = vp->next)
-        if (vp->status & f && (isalpha(*vp->name) || *vp->name == '_')) {
-            if (vp->status & EXPORT)
-                write(out, "export ", 7);
-            if (vp->status & RONLY)
-                write(out, "readonly ", 9);
-            write(out, vp->name, (int) (findeq(vp->name) - vp->name));
-            write(out, "\n", 1);
-        }
-}
-
-static int eqname(REGISTER char *n1, REGISTER char *n2)
-{
-    for (; *n1 != '=' && *n1 != 0; n1++)
-        if (*n2++ != *n1)
-            return (0);
-    return (*n2 == 0 || *n2 == '=');
-}
-
-static char *findeq(REGISTER char *cp)
-{
-    while (*cp != '\0' && *cp != '=')
-        cp++;
-    return (cp);
-}
 
 /* -------- gmatch.c -------- */
@@ -1524 +1515 @@
 #define CMASK   0377
 #define QUOTE   0200
-#define QMASK   (CMASK&~QUOTE)
+#define QMASK   (CMASK & ~QUOTE)
 #define NOT '!'                 /* might use ^ */
 
-static int gmatch(REGISTER char *s, REGISTER char *p)
-{
-    REGISTER int sc, pc;
-
-    if (s == NULL || p == NULL)
-        return (0);
-    while ((pc = *p++ & CMASK) != '\0') {
-        sc = *s++ & QMASK;
-        switch (pc) {
-        case '[':
-            if ((p = cclass(p, sc)) == NULL)
-                return (0);
-            break;
-
-        case '?':
-            if (sc == 0)
-                return (0);
-            break;
-
-        case '*':
-            s--;
-            do {
-                if (*p == '\0' || gmatch(s, p))
-                    return (1);
-            } while (*s++ != '\0');
-            return (0);
-
-        default:
-            if (sc != (pc & ~QUOTE))
-                return (0);
-        }
-    }
-    return (*s == 0);
-}
-
-static char *cclass(REGISTER char *p, REGISTER int sub)
-{
-    REGISTER int c, d, not, found;
-
-    if ((not = *p == NOT) != 0)
+static const char *cclass(const char *p, int sub)
+{
+    int c, d, not, found;
+
+    not = (*p == NOT);
+    if (not != 0)
         p++;
     found = not;
     do {
         if (*p == '\0')
-            return ((char *) NULL);
+            return NULL;
         c = *p & CMASK;
         if (p[1] == '-' && p[2] != ']') {
@@ -1581 +1538 @@
             found = !not;
     } while (*++p != ']');
-    return (found ? p + 1 : (char *) NULL);
-}
-
-
-/* -------- area.c -------- */
-
-/*
- * All memory between (char *)areabot and (char *)(areatop+1) is
- * exclusively administered by the area management routines.
- * It is assumed that sbrk() and brk() manipulate the high end.
- */
-
-#define sbrk(X) ({ void * __q = (void *)-1; if (brkaddr + (int)(X) < brktop) { __q = brkaddr; brkaddr+=(int)(X); } __q;})
-
-static void initarea(void)
-{
-    brkaddr = xmalloc(AREASIZE);
-    brktop = brkaddr + AREASIZE;
-
-    while ((long) sbrk(0) & ALIGN)
-        sbrk(1);
-    areabot = (struct region *) sbrk(REGSIZE);
-
-    areabot->next = areabot;
-    areabot->area = BUSY;
-    areatop = areabot;
-    areanxt = areabot;
-}
-
-char *getcell(unsigned nbytes)
-{
-    REGISTER int nregio;
-    REGISTER struct region *p, *q;
-    REGISTER int i;
-
-    if (nbytes == 0) {
-        puts("getcell(0)");
-        abort();
-    }
-    /* silly and defeats the algorithm */
-    /*
-     * round upwards and add administration area
-     */
-    nregio = (nbytes + (REGSIZE - 1)) / REGSIZE + 1;
-    for (p = areanxt;;) {
-        if (p->area > areanum) {
-            /*
-             * merge free cells
-             */
-            while ((q = p->next)->area > areanum && q != areanxt)
-                p->next = q->next;
-            /*
-             * exit loop if cell big enough
-             */
-            if (q >= p + nregio)
-                goto found;
-        }
-        p = p->next;
-        if (p == areanxt)
+    return found ? p + 1 : NULL;
+}
+
+static int gmatch(const char *s, const char *p)
+{
+    int sc, pc;
+
+    if (s == NULL || p == NULL)
+        return 0;
+
+    while ((pc = *p++ & CMASK) != '\0') {
+        sc = *s++ & QMASK;
+        switch (pc) {
+        case '[':
+            p = cclass(p, sc);
+            if (p == NULL)
+                return 0;
             break;
-    }
-    i = nregio >= GROWBY ? nregio : GROWBY;
-    p = (struct region *) sbrk(i * REGSIZE);
-    if (p == (struct region *) -1)
-        return ((char *) NULL);
-    p--;
-    if (p != areatop) {
-        puts("not contig");
-        abort();                /* allocated areas are contiguous */
-    }
-    q = p + i;
-    p->next = q;
-    p->area = FREE;
-    q->next = areabot;
-    q->area = BUSY;
-    areatop = q;
-  found:
-    /*
-     * we found a FREE area big enough, pointed to by 'p', and up to 'q'
-     */
-    areanxt = p + nregio;
-    if (areanxt < q) {
-        /*
-         * split into requested area and rest
-         */
-        if (areanxt + 1 > q) {
-            puts("OOM");
-            abort();            /* insufficient space left for admin */
-        }
-        areanxt->next = q;
-        areanxt->area = FREE;
-        p->next = areanxt;
-    }
-    p->area = areanum;
-    return ((char *) (p + 1));
-}
-
-static void freecell(char *cp)
-{
-    REGISTER struct region *p;
-
-    if ((p = (struct region *) cp) != NULL) {
-        p--;
-        if (p < areanxt)
-            areanxt = p;
-        p->area = FREE;
-    }
-}
-
-static void freearea(REGISTER int a)
-{
-    REGISTER struct region *p, *top;
-
-    top = areatop;
-    for (p = areabot; p != top; p = p->next)
-        if (p->area >= a)
-            p->area = FREE;
-}
-
-static void setarea(char *cp, int a)
-{
-    REGISTER struct region *p;
-
-    if ((p = (struct region *) cp) != NULL)
-        (p - 1)->area = a;
-}
-
-int getarea(char *cp)
-{
-    return ((struct region *) cp - 1)->area;
-}
-
-static void garbage(void)
-{
-    REGISTER struct region *p, *q, *top;
-
-    top = areatop;
-    for (p = areabot; p != top; p = p->next) {
-        if (p->area > areanum) {
-            while ((q = p->next)->area > areanum)
-                p->next = q->next;
-            areanxt = p;
-        }
-    }
-#ifdef SHRINKBY
-    if (areatop >= q + SHRINKBY && q->area > areanum) {
-        brk((char *) (q + 1));
-        q->next = areabot;
-        q->area = BUSY;
-        areatop = q;
-    }
-#endif
-}
+
+        case '?':
+            if (sc == 0)
+                return 0;
+            break;
+
+        case '*':
+            s--;
+            do {
+                if (*p == '\0' || gmatch(s, p))
+                    return 1;
+            } while (*s++ != '\0');
+            return 0;
+
+        default:
+            if (sc != (pc & ~QUOTE))
+                return 0;
+        }
+    }
+    return *s == '\0';
+}
+
 
 /* -------- csyn.c -------- */
@@ -1739 +1583 @@
  * shell: syntax (C version)
  */
+
+static void yyerror(const char *s) ATTRIBUTE_NORETURN;
+static void yyerror(const char *s)
+{
+    yynerrs++;
+    if (interactive && e.iop <= iostack) {
+        multiline = 0;
+        while (eofc() == 0 && yylex(0) != '\n');
+    }
+    err(s);
+    fail();
+}
+
+static void zzerr(void) ATTRIBUTE_NORETURN;
+static void zzerr(void)
+{
+    yyerror("syntax error");
+}
 
 int yyparse(void)
@@ -1754 +1616 @@
 static struct op *pipeline(int cf)
 {
-    REGISTER struct op *t, *p;
-    REGISTER int c;
+    struct op *t, *p;
+    int c;
 
     DBGPRINTF7(("PIPELINE: enter, cf=%d\n", cf));
@@ -1765 +1627 @@
     if (t != NULL) {
         while ((c = yylex(0)) == '|') {
-            if ((p = command(CONTIN)) == NULL) {
+            p = command(CONTIN);
+            if (p == NULL) {
                 DBGPRINTF8(("PIPELINE: error!\n"));
-                SYNTAXERR;
+                zzerr();
             }
 
@@ -1781 +1644 @@
 
     DBGPRINTF7(("PIPELINE: returning t=%p\n", t));
-    return (t);
+    return t;
 }
 
 static struct op *andor(void)
 {
-    REGISTER struct op *t, *p;
-    REGISTER int c;
+    struct op *t, *p;
+    int c;
 
     DBGPRINTF7(("ANDOR: enter...\n"));
@@ -1797 +1660 @@
     if (t != NULL) {
         while ((c = yylex(0)) == LOGAND || c == LOGOR) {
-            if ((p = pipeline(CONTIN)) == NULL) {
+            p = pipeline(CONTIN);
+            if (p == NULL) {
                 DBGPRINTF8(("ANDOR: error!\n"));
-                SYNTAXERR;
+                zzerr();
             }
 
@@ -1809 +1673 @@
 
     DBGPRINTF7(("ANDOR: returning t=%p\n", t));
-    return (t);
+    return t;
 }
 
 static struct op *c_list(void)
 {
-    REGISTER struct op *t, *p;
-    REGISTER int c;
+    struct op *t, *p;
+    int c;
 
     DBGPRINTF7(("C_LIST: enter...\n"));
@@ -1822 +1686 @@
 
     if (t != NULL) {
-        if ((peeksym = yylex(0)) == '&')
+        peeksym = yylex(0);
+        if (peeksym == '&')
             t = block(TASYNC, t, NOBLOCK, NOWORDS);
 
@@ -1828 +1693 @@
                || (multiline && c == '\n')) {
 
-            if ((p = andor()) == NULL)
-                return (t);
-
-            if ((peeksym = yylex(0)) == '&')
+            p = andor();
+            if (p== NULL)
+                return t;
+
+            peeksym = yylex(0);
+            if (peeksym == '&')
                 p = block(TASYNC, p, NOBLOCK, NOWORDS);
 
@@ -1841 +1708 @@
     /* IF */
     DBGPRINTF7(("C_LIST: returning t=%p\n", t));
-    return (t);
+    return t;
 }
 
 static int synio(int cf)
 {
-    REGISTER struct ioword *iop;
-    REGISTER int i;
-    REGISTER int c;
+    struct ioword *iop;
+    int i;
+    int c;
 
     DBGPRINTF7(("SYNIO: enter, cf=%d\n", cf));
 
-    if ((c = yylex(cf)) != '<' && c != '>') {
+    c = yylex(cf);
+    if (c != '<' && c != '>') {
         peeksym = c;
-        return (0);
+        return 0;
     }
 
@@ -1866 +1734 @@
 
     DBGPRINTF7(("SYNIO: returning 1\n"));
-    return (1);
+    return 1;
 }
 
 static void musthave(int c, int cf)
 {
-    if ((peeksym = yylex(cf)) != c) {
+    peeksym = yylex(cf);
+    if (peeksym != c) {
         DBGPRINTF7(("MUSTHAVE: error!\n"));
-        SYNTAXERR;
+        zzerr();
     }
 
@@ -1881 +1750 @@
 static struct op *simple(void)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     t = NULL;
@@ -1901 +1770 @@
 
         default:
-            return (t);
+            return t;
         }
     }
@@ -1908 +1777 @@
 static struct op *nested(int type, int mark)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     DBGPRINTF3(("NESTED: enter, type=%d, mark=%d\n", type, mark));
@@ -1916 +1785 @@
     musthave(mark, 0);
     multiline--;
-    return (block(type, t, NOBLOCK, NOWORDS));
+    return block(type, t, NOBLOCK, NOWORDS);
 }
 
 static struct op *command(int cf)
 {
-    REGISTER struct op *t;
+    struct op *t;
     struct wdblock *iosave;
-    REGISTER int c;
+    int c;
 
     DBGPRINTF(("COMMAND: enter, cf=%d\n", cf));
@@ -1941 +1810 @@
     default:
         peeksym = c;
-        if ((t = simple()) == NULL) {
+        t = simple();
+        if (t == NULL) {
             if (iolist == NULL)
-                return ((struct op *) NULL);
+                return NULL;
             t = newtp();
             t->type = TCOM;
@@ -1965 +1835 @@
         multiline++;
         t->words = wordlist();
-        if ((c = yylex(0)) != '\n' && c != ';')
+        c = yylex(0);
+        if (c != '\n' && c != ';')
             peeksym = c;
         t->left = dogroup(0);
@@ -2029 +1900 @@
     DBGPRINTF(("COMMAND: returning %p\n", t));
 
-    return (t);
+    return t;
 }
 
 static struct op *dowholefile(int type, int mark)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     DBGPRINTF(("DOWHOLEFILE: enter, type=%d, mark=%d\n", type, mark));
@@ -2043 +1914 @@
     t = block(type, t, NOBLOCK, NOWORDS);
     DBGPRINTF(("DOWHOLEFILE: return t=%p\n", t));
-    return (t);
+    return t;
 }
 
 static struct op *dogroup(int onlydone)
 {
-    REGISTER int c;
-    REGISTER struct op *mylist;
+    int c;
+    struct op *mylist;
 
     c = yylex(CONTIN);
     if (c == DONE && onlydone)
-        return ((struct op *) NULL);
+        return NULL;
     if (c != DO)
-        SYNTAXERR;
+        zzerr();
     mylist = c_list();
     musthave(DONE, 0);
-    return (mylist);
+    return mylist;
 }
 
 static struct op *thenpart(void)
 {
-    REGISTER int c;
-    REGISTER struct op *t;
-
-    if ((c = yylex(0)) != THEN) {
+    int c;
+    struct op *t;
+
+    c = yylex(0);
+    if (c != THEN) {
         peeksym = c;
-        return ((struct op *) NULL);
+        return NULL;
     }
     t = newtp();
@@ -2074 +1946 @@
     t->left = c_list();
     if (t->left == NULL)
-        SYNTAXERR;
+        zzerr();
     t->right = elsepart();
-    return (t);
+    return t;
 }
 
 static struct op *elsepart(void)
 {
-    REGISTER int c;
-    REGISTER struct op *t;
+    int c;
+    struct op *t;
 
     switch (c = yylex(0)) {
     case ELSE:
-        if ((t = c_list()) == NULL)
-            SYNTAXERR;
-        return (t);
+        t = c_list();
+        if (t == NULL)
+            zzerr();
+        return t;
 
     case ELIF:
@@ -2095 +1968 @@
         t->left = c_list();
         t->right = thenpart();
-        return (t);
+        return t;
 
     default:
         peeksym = c;
-        return ((struct op *) NULL);
+        return NULL;
     }
 }
@@ -2105 +1978 @@
 static struct op *caselist(void)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     t = NULL;
@@ -2114 +1987 @@
 
     DBGPRINTF(("CASELIST, returning t=%p\n", t));
-    return (t);
+    return t;
 }
 
 static struct op *casepart(void)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     DBGPRINTF7(("CASEPART: enter...\n"));
@@ -2128 +2001 @@
     musthave(')', 0);
     t->left = c_list();
-    if ((peeksym = yylex(CONTIN)) != ESAC)
+    peeksym = yylex(CONTIN);
+    if (peeksym != ESAC)
         musthave(BREAK, CONTIN);
 
     DBGPRINTF7(("CASEPART: made newtp(TPAT, t=%p)\n", t));
 
-    return (t);
+    return t;
 }
 
 static char **pattern(void)
 {
-    REGISTER int c, cf;
+    int c, cf;
 
     cf = CONTIN;
@@ -2145 +2019 @@
         word(yylval.cp);
         cf = 0;
-    } while ((c = yylex(0)) == '|');
+        c = yylex(0);
+    } while (c == '|');
     peeksym = c;
     word(NOWORD);
 
-    return (copyw());
+    return copyw();
 }
 
 static char **wordlist(void)
 {
-    REGISTER int c;
-
-    if ((c = yylex(0)) != IN) {
+    int c;
+
+    c = yylex(0);
+    if (c != IN) {
         peeksym = c;
-        return ((char **) NULL);
+        return NULL;
     }
     startl = 0;
@@ -2165 +2041 @@
     word(NOWORD);
     peeksym = c;
-    return (copyw());
+    return copyw();
 }
 
@@ -2171 +2047 @@
  * supporting functions
  */
-static struct op *list(REGISTER struct op *t1, REGISTER struct op *t2)
+static struct op *list(struct op *t1, struct op *t2)
 {
     DBGPRINTF7(("LIST: enter, t1=%p, t2=%p\n", t1, t2));
 
     if (t1 == NULL)
-        return (t2);
+        return t2;
     if (t2 == NULL)
-        return (t1);
-
-    return (block(TLIST, t1, t2, NOWORDS));
+        return t1;
+
+    return block(TLIST, t1, t2, NOWORDS);
 }
 
 static struct op *block(int type, struct op *t1, struct op *t2, char **wp)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     DBGPRINTF7(("BLOCK: enter, type=%d (%s)\n", type, T_CMD_NAMES[type]));
@@ -2198 +2074 @@
                 t2));
 
-    return (t);
+    return t;
 }
 
 /* See if given string is a shell multiline (FOR, IF, etc) */
-static int rlookup(REGISTER char *n)
-{
-    REGISTER const struct res *rp;
+static int rlookup(char *n)
+{
+    const struct res *rp;
 
     DBGPRINTF7(("RLOOKUP: enter, n is %s\n", n));
@@ -2211 +2087 @@
         if (strcmp(rp->r_name, n) == 0) {
             DBGPRINTF7(("RLOOKUP: match, returning %d\n", rp->r_val));
-            return (rp->r_val); /* Return numeric code for shell multiline */
+            return rp->r_val;   /* Return numeric code for shell multiline */
         }
 
     DBGPRINTF7(("RLOOKUP: NO match, returning 0\n"));
-    return (0);                 /* Not a shell multiline */
+    return 0;                   /* Not a shell multiline */
 }
 
 static struct op *newtp(void)
 {
-    REGISTER struct op *t;
+    struct op *t;
 
     t = (struct op *) tree(sizeof(*t));
@@ -2232 +2108 @@
     DBGPRINTF3(("NEWTP: allocated %p\n", t));
 
-    return (t);
-}
-
-static struct op *namelist(REGISTER struct op *t)
-{
-
+    return t;
+}
+
+static struct op *namelist(struct op *t)
+{
     DBGPRINTF7(("NAMELIST: enter, t=%p, type %s, iolist=%p\n", t,
                 T_CMD_NAMES[t->type], iolist));
@@ -2253 +2128 @@
             t->left->ioact = NULL;
         }
-        return (t);
+        return t;
     }
 
@@ -2259 +2134 @@
     t->words = copyw();
 
-
-    return (t);
+    return t;
 }
 
 static char **copyw(void)
 {
-    REGISTER char **wd;
+    char **wd;
 
     wd = getwords(wdlist);
     wdlist = 0;
-    return (wd);
+    return wd;
 }
 
@@ -2279 +2153 @@
 static struct ioword **copyio(void)
 {
-    REGISTER struct ioword **iop;
+    struct ioword **iop;
 
     iop = (struct ioword **) getwords(iolist);
     iolist = 0;
-    return (iop);
+    return iop;
 }
 
 static struct ioword *io(int u, int f, char *cp)
 {
-    REGISTER struct ioword *iop;
+    struct ioword *iop;
 
     iop = (struct ioword *) tree(sizeof(*iop));
@@ -2295 +2169 @@
     iop->io_name = cp;
     iolist = addword((char *) iop, iolist);
-    return (iop);
-}
-
-static void zzerr(void)
-{
-    yyerror("syntax error");
-}
-
-static void yyerror(char *s)
-{
-    yynerrs++;
-    if (interactive && e.iop <= iostack) {
-        multiline = 0;
-        while (eofc() == 0 && yylex(0) != '\n');
-    }
-    err(s);
-    fail();
+    return iop;
 }
 
 static int yylex(int cf)
 {
-    REGISTER int c, c1;
+    int c, c1;
     int atstart;
 
-    if ((c = peeksym) > 0) {
+    c = peeksym;
+    if (c > 0) {
         peeksym = 0;
         if (c == '\n')
             startl = 1;
-        return (c);
-    }
-
+        return c;
+    }
 
     nlseen = 0;
@@ -2336 +2194 @@
     line[LINELIM - 1] = '\0';
 
-  loop:
+ loop:
     while ((c = my_getc(0)) == ' ' || c == '\t')    /* Skip whitespace */
         ;
@@ -2343 +2201 @@
     default:
         if (any(c, "0123456789")) {
-            unget(c1 = my_getc(0));
+            c1 = my_getc(0);
+            unget(c1);
             if (c1 == '<' || c1 == '>') {
                 iounit = c - '0';
@@ -2354 +2213 @@
 
     case '#':                   /* Comment, skip to next newline or End-of-string */
-        while ((c = my_getc(0)) != 0 && c != '\n');
+        while ((c = my_getc(0)) != '\0' && c != '\n');
         unget(c);
         goto loop;
@@ -2360 +2219 @@
     case 0:
         DBGPRINTF5(("YYLEX: return 0, c=%d\n", c));
-        return (c);
+        return c;
 
     case '$':
         DBGPRINTF9(("YYLEX: found $\n"));
         *e.linep++ = c;
-        if ((c = my_getc(0)) == '{') {
-            if ((c = collect(c, '}')) != '\0')
-                return (c);
+        c = my_getc(0);
+        if (c == '{') {
+            c = collect(c, '}');
+            if (c != '\0')
+                return c;
             goto pack;
         }
@@ -2375 +2236 @@
     case '\'':
     case '"':
-        if ((c = collect(c, c)) != '\0')
-            return (c);
+        c = collect(c, c);
+        if (c != '\0')
+            return c;
         goto pack;
 
@@ -2384 +2246 @@
         startl = 1;
         /* If more chars process them, else return NULL char */
-        if ((c1 = dual(c)) != '\0')
-            return (c1);
-        else
-            return (c);
+        c1 = dual(c);
+        if (c1 != '\0')
+            return c1;
+        return c;
 
     case '^':
         startl = 1;
-        return ('|');
+        return '|';
     case '>':
     case '<':
         diag(c);
-        return (c);
+        return c;
 
     case '\n':
@@ -2403 +2265 @@
         if (multiline || cf & CONTIN) {
             if (interactive && e.iop <= iostack) {
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
+#if ENABLE_FEATURE_EDITING
                 current_prompt = cprompt->value;
 #else
@@ -2412 +2274 @@
                 goto loop;
         }
-        return (c);
+        return c;
 
     case '(':
     case ')':
         startl = 1;
-        return (c);
+        return c;
     }
 
     unget(c);
 
-  pack:
-    while ((c = my_getc(0)) != 0 && !any(c, "`$ '\"\t;&<>()|^\n")) {
+ pack:
+    while ((c = my_getc(0)) != '\0' && !any(c, "`$ '\"\t;&<>()|^\n")) {
         if (e.linep >= elinep)
             err("word too long");
@@ -2437 +2299 @@
     *e.linep++ = '\0';
 
-    if (atstart && (c = rlookup(line)) != 0) {
-        startl = 1;
-        return (c);
+    if (atstart) {
+        c = rlookup(line);
+        if (c != 0) {
+            startl = 1;
+            return c;
+        }
     }
 
     yylval.cp = strsave(line, areanum);
-    return (WORD);
-}
-
-
-static int collect(REGISTER int c, REGISTER int c1)
+    return WORD;
+}
+
+
+static int collect(int c, int c1)
 {
     char s[2];
@@ -2461 +2326 @@
             prs("no closing ");
             yyerror(s);
-            return (YYERRCODE);
+            return YYERRCODE;
         }
         if (interactive && c == '\n' && e.iop <= iostack) {
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
+#if ENABLE_FEATURE_EDITING
             current_prompt = cprompt->value;
 #else
@@ -2477 +2342 @@
     DBGPRINTF8(("COLLECT: return 0, line is %s\n", line));
 
-    return (0);
+    return 0;
 }
 
 /* "multiline commands" helper func */
 /* see if next 2 chars form a shell multiline */
-static int dual(REGISTER int c)
+static int dual(int c)
 {
     char s[3];
-    REGISTER char *cp = s;
+    char *cp = s;
 
     DBGPRINTF8(("DUAL: enter, c=%d\n", c));
 
-    *cp++ = c;                  /* c is the given "peek" char */
-    *cp++ = my_getc(0);         /* get next char of input */
-    *cp = 0;                    /* add EOS marker */
-
-    c = rlookup(s);             /* see if 2 chars form a shell multiline */
+    *cp++ = c;              /* c is the given "peek" char */
+    *cp++ = my_getc(0);     /* get next char of input */
+    *cp = '\0';             /* add EOS marker */
+
+    c = rlookup(s);         /* see if 2 chars form a shell multiline */
     if (c == 0)
-        unget(*--cp);           /* String is not a shell multiline, put peek char back */
-
-    return (c);                 /* String is multiline, return numeric multiline (restab) code */
-}
-
-static void diag(REGISTER int ec)
-{
-    REGISTER int c;
+        unget(*--cp);   /* String is not a shell multiline, put peek char back */
+
+    return c;               /* String is multiline, return numeric multiline (restab) code */
+}
+
+static void diag(int ec)
+{
+    int c;
 
     DBGPRINTF8(("DIAG: enter, ec=%d\n", ec));
@@ -2510 +2375 @@
         if (c != ec)
             zzerr();
-        yylval.i = ec == '>' ? IOWRITE | IOCAT : IOHERE;
+        yylval.i = (ec == '>' ? IOWRITE | IOCAT : IOHERE);
         c = my_getc(0);
     } else
-        yylval.i = ec == '>' ? IOWRITE : IOREAD;
+        yylval.i = (ec == '>' ? IOWRITE : IOREAD);
     if (c != '&' || yylval.i == IOHERE)
         unget(c);
@@ -2522 +2387 @@
 static char *tree(unsigned size)
 {
-    REGISTER char *t;
-
-    if ((t = getcell(size)) == NULL) {
+    char *t;
+
+    t = getcell(size);
+    if (t == NULL) {
         DBGPRINTF2(("TREE: getcell(%d) failed!\n", size));
         prs("command line too complicated\n");
@@ -2530 +2396 @@
         /* NOTREACHED */
     }
-    return (t);
-}
+    return t;
+}
+
 
 /* VARARGS1 */
@@ -2538 +2405 @@
 /* -------- exec.c -------- */
 
+static struct op **find1case(struct op *t, const char *w)
+{
+    struct op *t1;
+    struct op **tp;
+    char **wp;
+    char *cp;
+
+    if (t == NULL) {
+        DBGPRINTF3(("FIND1CASE: enter, t==NULL, returning.\n"));
+        return NULL;
+    }
+
+    DBGPRINTF3(("FIND1CASE: enter, t->type=%d (%s)\n", t->type,
+                T_CMD_NAMES[t->type]));
+
+    if (t->type == TLIST) {
+        tp = find1case(t->left, w);
+        if (tp != NULL) {
+            DBGPRINTF3(("FIND1CASE: found one to the left, returning tp=%p\n", tp));
+            return tp;
+        }
+        t1 = t->right;          /* TPAT */
+    } else
+        t1 = t;
+
+    for (wp = t1->words; *wp;) {
+        cp = evalstr(*wp++, DOSUB);
+        if (cp && gmatch(w, cp)) {
+            DBGPRINTF3(("FIND1CASE: returning &t1->left= %p.\n",
+                        &t1->left));
+            return &t1->left;
+        }
+    }
+
+    DBGPRINTF(("FIND1CASE: returning NULL\n"));
+    return NULL;
+}
+
+static struct op *findcase(struct op *t, const char *w)
+{
+    struct op **tp;
+
+    tp = find1case(t, w);
+    return tp != NULL ? *tp : NULL;
+}
+
 /*
  * execute tree
  */
 
-
-static int execute(REGISTER struct op *t, int *pin, int *pout, int act)
-{
-    REGISTER struct op *t1;
+static int execute(struct op *t, int *pin, int *pout, int act)
+{
+    struct op *t1;
     volatile int i, rv, a;
-    char *cp, **wp, **wp2;
+    const char *cp;
+    char **wp, **wp2;
     struct var *vp;
     struct op *outtree_save;
@@ -2559 +2472 @@
     if (t == NULL) {
         DBGPRINTF4(("EXECUTE: enter, t==null, returning.\n"));
-        return (0);
+        return 0;
     }
 
@@ -2572 +2485 @@
         : NULL;
 
-/* Hard to know how many words there are, be careful of garbage pointer values */
-/* They are likely to cause "PCI bus fault" errors */
-#if 0
-    DBGPRINTF(("EXECUTE: t->left=%p, t->right=%p, t->words[1] is %s\n",
-               t->left, t->right,
-               ((t->words[1] == NULL) ? "NULL" : t->words[1])));
-    DBGPRINTF7(("EXECUTE: t->words[2] is %s, t->words[3] is %s\n",
-                ((t->words[2] == NULL) ? "NULL" : t->words[2]),
-                ((t->words[3] == NULL) ? "NULL" : t->words[3])));
-#endif
-
-
     switch (t->type) {
     case TDOT:
@@ -2608 +2509 @@
 
     case TCOM:
-        {
-            rv = forkexec(t, pin, pout, act, wp);
-        }
+        rv = forkexec(t, pin, pout, act, wp);
         break;
 
@@ -2617 +2516 @@
             int pv[2];
 
-            if ((rv = openpipe(pv)) < 0)
+            rv = openpipe(pv);
+            if (rv < 0)
                 break;
             pv[0] = remap(pv[0]);
@@ -2638 +2538 @@
 
             i = vfork();
-            if (i != 0) {
-                interactive = hinteractive;
-                if (i != -1) {
-                    setval(lookup("!"), putn(i));
-                    if (pin != NULL)
-                        closepipe(pin);
-                    if (interactive) {
-                        prs(putn(i));
-                        prs("\n");
-                    }
-                } else
-                    rv = -1;
-                setstatus(rv);
-            } else {
+            if (i == 0) { /* child */
                 signal(SIGINT, SIG_IGN);
                 signal(SIGQUIT, SIG_IGN);
@@ -2659 +2546 @@
                 if (pin == NULL) {
                     close(0);
-                    open(bb_dev_null, 0);
+                    xopen(bb_dev_null, O_RDONLY);
                 }
                 _exit(execute(t->left, pin, pout, FEXEC));
             }
+            interactive = hinteractive;
+            if (i != -1) {
+                setval(lookup("!"), putn(i));
+                if (pin != NULL)
+                    closepipe(pin);
+                if (interactive) {
+                    prs(putn(i));
+                    prs("\n");
+                }
+            } else
+                rv = -1;
+            setstatus(rv);
         }
         break;
@@ -2669 +2568 @@
     case TAND:
         rv = execute(t->left, pin, pout, 0);
-        if ((t1 = t->right) != NULL && (rv == 0) == (t->type == TAND))
+        t1 = t->right;
+        if (t1 != NULL && (rv == 0) == (t->type == TAND))
             rv = execute(t1, pin, pout, 0);
         break;
@@ -2676 +2576 @@
         if (wp == NULL) {
             wp = dolv + 1;
-            if ((i = dolc) < 0)
+            i = dolc;
+            if (i < 0)
                 i = 0;
         } else {
@@ -2716 +2617 @@
 
     case TCASE:
-        if ((cp = evalstr(t->str, DOSUB | DOTRIM)) == 0)
+        cp = evalstr(t->str, DOSUB | DOTRIM);
+        if (cp == NULL)
             cp = "";
 
@@ -2723 +2625 @@
                     ((cp == NULL) ? "NULL" : cp)));
 
-        if ((t1 = findcase(t->left, cp)) != NULL) {
+        t1 = findcase(t->left, cp);
+        if (t1 != NULL) {
             DBGPRINTF7(("EXECUTE: TCASE, calling execute(t=%p, t1=%p)...\n", t, t1));
             rv = execute(t1, pin, pout, 0);
@@ -2732 +2635 @@
     case TBRACE:
 /*
-        if (iopp = t->ioact)
+        iopp = t->ioact;
+        if (i)
             while (*iopp)
                 if (iosetup(*iopp++, pin!=NULL, pout!=NULL)) {
@@ -2739 +2643 @@
                 }
 */
-        if (rv >= 0 && (t1 = t->left))
-            rv = execute(t1, pin, pout, 0);
+        if (rv >= 0) {
+            t1 = t->left;
+            if (t1) {
+                rv = execute(t1, pin, pout, 0);
+            }
+        }
         break;
 
     };
 
-  broken:
+ broken:
     t->words = wp2;
     isbreak = 0;
@@ -2756 +2664 @@
     }
 
-    if ((i = trapset) != 0) {
+    i = trapset;
+    if (i != 0) {
         trapset = 0;
         runtrap(i);
@@ -2762 +2671 @@
 
     DBGPRINTF(("EXECUTE: returning from t=%p, rv=%d\n", t, rv));
-    return (rv);
-}
-
-static int
-forkexec(REGISTER struct op *t, int *pin, int *pout, int act, char **wp)
+    return rv;
+}
+
+typedef int (*builtin_func_ptr)(struct op *);
+
+static builtin_func_ptr inbuilt(const char *s)
+{
+    const struct builtincmd *bp;
+
+    for (bp = builtincmds; bp->name; bp++)
+        if (strcmp(bp->name, s) == 0)
+            return bp->builtinfunc;
+    return NULL;
+}
+
+static int forkexec(struct op *t, int *pin, int *pout, int act, char **wp)
 {
     pid_t newpid;
     int i, rv;
-    int (*shcom) (struct op *) = NULL;
-    REGISTER int f;
-    char *cp = NULL;
+    builtin_func_ptr shcom = NULL;
+    int f;
+    const char *cp = NULL;
     struct ioword **iopp;
     int resetsig;
@@ -2802 +2722 @@
                 ((t->words == NULL) ? "NULL" : t->words[0])));
 
-/* Hard to know how many words there are, be careful of garbage pointer values */
-/* They are likely to cause "PCI bus fault" errors */
-#if 0
-    DBGPRINTF7(("FORKEXEC: t->words is %s, t->words[1] is %s\n",
-                ((t->words == NULL) ? "NULL" : t->words[0]),
-                ((t->words == NULL) ? "NULL" : t->words[1])));
-    DBGPRINTF7(("FORKEXEC: wp is %s, wp[1] is %s\n",
-                ((wp == NULL) ? "NULL" : wp[0]),
-                ((wp[1] == NULL) ? "NULL" : wp[1])));
-    DBGPRINTF7(("FORKEXEC: wp2 is %s, wp[3] is %s\n",
-                ((wp[2] == NULL) ? "NULL" : wp[2]),
-                ((wp[3] == NULL) ? "NULL" : wp[3])));
-#endif
-
-
     owp = wp;
     resetsig = 0;
     rv = -1;                    /* system-detected error */
     if (t->type == TCOM) {
-        while ((cp = *wp++) != NULL);
+        while (*wp++ != NULL)
+            continue;
         cp = *wp;
 
         /* strip all initial assignments */
         /* not correct wrt PATH=yyy command  etc */
-        if (flag['x']) {
+        if (FLAG['x']) {
             DBGPRINTF9(("FORKEXEC: echo'ing, cp=%p, wp=%p, owp=%p\n",
                         cp, wp, owp));
             echo(cp ? wp : owp);
         }
-#if 0
-        DBGPRINTF9(("FORKEXEC: t->words is %s, t->words[1] is %s\n",
-                    ((t->words == NULL) ? "NULL" : t->words[0]),
-                    ((t->words == NULL) ? "NULL" : t->words[1])));
-        DBGPRINTF9(("FORKEXEC: wp is %s, wp[1] is %s\n",
-                    ((wp == NULL) ? "NULL" : wp[0]),
-                    ((wp == NULL) ? "NULL" : wp[1])));
-#endif
 
         if (cp == NULL && t->ioact == NULL) {
-            while ((cp = *owp++) != NULL && assign(cp, COPYV));
+            while ((cp = *owp++) != NULL && assign(cp, COPYV))
+                continue;
             DBGPRINTF(("FORKEXEC: returning setstatus()\n"));
-            return (setstatus(0));
-        } else if (cp != NULL) {
+            return setstatus(0);
+        }
+        if (cp != NULL) {
             shcom = inbuilt(cp);
         }
@@ -2852 +2752 @@
     f = act;
 
-#if 0
-    DBGPRINTF3(("FORKEXEC: t->words is %s, t->words[1] is %s\n",
-                ((t->words == NULL) ? "NULL" : t->words[0]),
-                ((t->words == NULL) ? "NULL" : t->words[1])));
-#endif
     DBGPRINTF(("FORKEXEC: shcom %p, f&FEXEC 0x%x, owp %p\n", shcom,
                f & FEXEC, owp));
@@ -2875 +2770 @@
 
         if (newpid == -1) {
-            DBGPRINTF(("FORKEXEC: ERROR, unable to vfork()!\n"));
-            return (-1);
-        }
-
-
-        if (newpid > 0) {       /* Parent */
-
+            DBGPRINTF(("FORKEXEC: ERROR, cannot vfork()!\n"));
+            return -1;
+        }
+
+        if (newpid > 0) {  /* Parent */
             /* Restore values */
             pin = hpin;
@@ -2890 +2783 @@
             brklist = hbrklist;
             execflg = hexecflg;
-
 /* moved up
             if (i == -1)
-                return(rv);
+                return rv;
 */
-
             if (pin != NULL)
                 closepipe(pin);
@@ -2917 +2808 @@
     }
 
-
     if (owp != NULL)
         while ((cp = *owp++) != NULL && assign(cp, COPYV))
@@ -2928 +2818 @@
         if (forked)
             _exit(-1);
-        return (-1);
+        return -1;
     }
 #endif
 
     if (pin != NULL) {
-        dup2(pin[0], 0);
-        closepipe(pin);
+        xmove_fd(pin[0], 0);
+        if (pin[1] != 0) close(pin[1]);
     }
     if (pout != NULL) {
-        dup2(pout[1], 1);
-        closepipe(pout);
-    }
-
-    if ((iopp = t->ioact) != NULL) {
+        xmove_fd(pout[1], 1);
+        if (pout[1] != 1) close(pout[0]);
+    }
+
+    iopp = t->ioact;
+    if (iopp != NULL) {
         if (shcom != NULL && shcom != doexec) {
             prs(cp);
@@ -2947 +2838 @@
             if (forked)
                 _exit(-1);
-            return (-1);
+            return -1;
         }
         while (*iopp)
@@ -2953 +2844 @@
                 if (forked)
                     _exit(rv);
-                return (rv);
+                return rv;
             }
     }
@@ -2962 +2853 @@
             _exit(i);
         DBGPRINTF(("FORKEXEC: returning i=%d\n", i));
-        return (i);
+        return i;
     }
 
@@ -2996 +2887 @@
  * within pipelines.
  */
-static int iosetup(REGISTER struct ioword *iop, int pipein, int pipeout)
-{
-    REGISTER int u = -1;
-    char *cp = NULL, *msg;
+static int iosetup(struct ioword *iop, int pipein, int pipeout)
+{
+    int u = -1;
+    char *cp = NULL;
+    const char *msg;
 
     DBGPRINTF(("IOSETUP: iop %p, pipein %i, pipeout %i\n", iop,
@@ -3008 +2900 @@
 
     if (pipein && iop->io_unit == 0)
-        return (0);
+        return 0;
 
     if (pipeout && iop->io_unit == 1)
-        return (0);
+        return 0;
 
     msg = iop->io_flag & (IOREAD | IOHERE) ? "open" : "create";
     if ((iop->io_flag & IOHERE) == 0) {
-        cp = iop->io_name;
-        if ((cp = evalstr(cp, DOSUB | DOTRIM)) == NULL)
-            return (1);
+        cp = iop->io_name; /* huh?? */
+        cp = evalstr(cp, DOSUB | DOTRIM);
+        if (cp == NULL)
+            return 1;
     }
 
@@ -3024 +2917 @@
             prs(cp);
             err(": illegal >& argument");
-            return (1);
+            return 1;
         }
         if (*cp == '-')
@@ -3032 +2925 @@
     switch (iop->io_flag) {
     case IOREAD:
-        u = open(cp, 0);
+        u = open(cp, O_RDONLY);
         break;
 
@@ -3038 +2931 @@
     case IOHERE | IOXHERE:
         u = herein(iop->io_name, iop->io_flag & IOXHERE);
-        cp = "here file";
+        cp = (char*)"here file";
         break;
 
     case IOWRITE | IOCAT:
-        if ((u = open(cp, 1)) >= 0) {
-            lseek(u, (long) 0, 2);
+        u = open(cp, O_WRONLY);
+        if (u >= 0) {
+            lseek(u, (long) 0, SEEK_END);
             break;
         }
@@ -3056 +2950 @@
     case IOCLOSE:
         close(iop->io_unit);
-        return (0);
+        return 0;
     }
     if (u < 0) {
@@ -3062 +2956 @@
         prs(": cannot ");
         warn(msg);
-        return (1);
-    } else {
-        if (u != iop->io_unit) {
-            dup2(u, iop->io_unit);
-            close(u);
-        }
-    }
-    return (0);
-}
-
-static void echo(REGISTER char **wp)
-{
-    REGISTER int i;
-
-    prs("+");
-    for (i = 0; wp[i]; i++) {
-        if (i)
-            prs(" ");
-        prs(wp[i]);
-    }
-    prs("\n");
-}
-
-static struct op **find1case(struct op *t, char *w)
-{
-    REGISTER struct op *t1;
-    struct op **tp;
-    REGISTER char **wp, *cp;
-
-
-    if (t == NULL) {
-        DBGPRINTF3(("FIND1CASE: enter, t==NULL, returning.\n"));
-        return ((struct op **) NULL);
-    }
-
-    DBGPRINTF3(("FIND1CASE: enter, t->type=%d (%s)\n", t->type,
-                T_CMD_NAMES[t->type]));
-
-    if (t->type == TLIST) {
-        if ((tp = find1case(t->left, w)) != NULL) {
-            DBGPRINTF3(("FIND1CASE: found one to the left, returning tp=%p\n", tp));
-            return (tp);
-        }
-        t1 = t->right;          /* TPAT */
-    } else
-        t1 = t;
-
-    for (wp = t1->words; *wp;)
-        if ((cp = evalstr(*wp++, DOSUB)) && gmatch(w, cp)) {
-            DBGPRINTF3(("FIND1CASE: returning &t1->left= %p.\n",
-                        &t1->left));
-            return (&t1->left);
-        }
-
-    DBGPRINTF(("FIND1CASE: returning NULL\n"));
-    return ((struct op **) NULL);
-}
-
-static struct op *findcase(struct op *t, char *w)
-{
-    REGISTER struct op **tp;
-
-    return ((tp = find1case(t, w)) != NULL ? *tp : (struct op *) NULL);
+        return 1;
+    }
+    if (u != iop->io_unit) {
+        dup2(u, iop->io_unit);
+        close(u);
+    }
+    return 0;
 }
 
@@ -3143 +2981 @@
  * unless `canintr' is true.
  */
-static int waitfor(REGISTER int lastpid, int canintr)
-{
-    REGISTER int pid, rv;
+static int waitfor(int lastpid, int canintr)
+{
+    int pid, rv;
     int s;
     int oheedint = heedint;
@@ -3157 +2995 @@
                 break;
         } else {
-            if ((rv = WAITSIG(s)) != 0) {
-                if (rv < NSIGNAL) {
+            rv = WAITSIG(s);
+            if (rv != 0) {
+                if (rv < ARRAY_SIZE(signame)) {
                     if (signame[rv] != NULL) {
                         if (pid != lastpid) {
@@ -3177 +3016 @@
                 if (WAITCORE(s))
                     prs(" - core dumped");
-                if (rv >= NSIGNAL || signame[rv])
+                if (rv >= ARRAY_SIZE(signame) || signame[rv])
                     prs("\n");
                 rv = -1;
@@ -3195 +3034 @@
         }
     }
-    return (rv);
-}
-
-static int setstatus(REGISTER int s)
+    return rv;
+}
+
+static int setstatus(int s)
 {
     exstat = s;
     setval(lookup("?"), putn(s));
-    return (s);
+    return s;
 }
 
@@ -3210 +3049 @@
  * execvp might be used.
  */
-static char *rexecve(char *c, char **v, char **envp)
-{
-    REGISTER int i;
-    REGISTER char *sp, *tp;
+static const char *rexecve(char *c, char **v, char **envp)
+{
+    int i;
+    const char *sp;
+    char *tp;
     int eacces = 0, asis = 0;
     char *name = c;
 
-    if (ENABLE_FEATURE_SH_STANDALONE_SHELL) {
-        optind = 1;
+    if (ENABLE_FEATURE_SH_STANDALONE) {
         if (find_applet_by_name(name)) {
             /* We have to exec here since we vforked.  Running
-             * run_applet_by_name() won't work and bad things
+             * run_applet_and_exit() won't work and bad things
              * will happen. */
-            execve(CONFIG_BUSYBOX_EXEC_PATH, v, envp);
+            execve(bb_busybox_exec_path, v, envp);
         }
     }
@@ -3230 +3069 @@
 
     sp = any('/', c) ? "" : path->value;
-    asis = *sp == '\0';
+    asis = (*sp == '\0');
     while (asis || *sp != '\0') {
         asis = 0;
         tp = e.linep;
-        for (; *sp != '\0'; tp++)
-            if ((*tp = *sp++) == ':') {
-                asis = *sp == '\0';
+        for (; *sp != '\0'; tp++) {
+            *tp = *sp++;
+            if (*tp == ':') {
+                asis = (*sp == '\0');
                 break;
             }
+        }
         if (tp != e.linep)
             *tp++ = '/';
@@ -3254 +3095 @@
             execve(DEFAULT_SHELL, v, envp);
             *v = tp;
-            return ("no Shell");
+            return "no Shell";
 
         case ENOMEM:
-            return ((char *) bb_msg_memory_exhausted);
+            return (char *) bb_msg_memory_exhausted;
 
         case E2BIG:
-            return ("argument list too long");
+            return "argument list too long";
 
         case EACCES:
@@ -3267 +3108 @@
         }
     }
-    return (errno == ENOENT ? "not found" : "cannot execute");
+    return errno == ENOENT ? "not found" : "cannot execute";
 }
 
@@ -3298 +3139 @@
     rv = -1;
 
-    if (newenv(setjmp(errpt = ev)) == 0) {
+    errpt = ev;
+    if (newenv(setjmp(errpt)) == 0) {
         wdlist = 0;
         iolist = 0;
@@ -3304 +3146 @@
         e.iobase = e.iop;
         yynerrs = 0;
-        if (setjmp(failpt = rt) == 0 && yyparse() == 0)
+        failpt = rt;
+        if (setjmp(failpt) == 0 && yyparse() == 0)
             rv = execute(outtree, NOPIPE, NOPIPE, 0);
         quitenv();
@@ -3317 +3160 @@
     freearea(areanum--);
 
-    return (rv);
+    return rv;
 }
 
@@ -3331 +3174 @@
     const struct builtincmd *x;
 
-    printf("\nBuilt-in commands:\n");
-    printf("-------------------\n");
-
-    for (col = 0, x = builtincmds; x->builtinfunc != NULL; x++) {
-        if (!x->name)
-            continue;
-        col += printf("%s%s", ((col == 0) ? "\t" : " "), x->name);
+    puts("\nBuilt-in commands:\n"
+         "-------------------");
+
+    col = 0;
+    x = builtincmds;
+    while (x->name) {
+        col += printf("%c%s", ((col == 0) ? '\t' : ' '), x->name);
         if (col > 60) {
-            printf("\n");
+            puts("");
             col = 0;
         }
-    }
-#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+        x++;
+    }
+#if ENABLE_FEATURE_SH_STANDALONE
     {
-        int i;
-        const struct BB_applet *applet;
-        extern const struct BB_applet applets[];
-        extern const size_t NUM_APPLETS;
-
-        for (i = 0, applet = applets; i < NUM_APPLETS; applet++, i++) {
-            if (!applet->name)
-                continue;
-
-            col += printf("%s%s", ((col == 0) ? "\t" : " "), applet->name);
+        const struct bb_applet *applet = applets;
+
+        while (applet->name) {
+            col += printf("%c%s", ((col == 0) ? '\t' : ' '), applet->name);
             if (col > 60) {
-                printf("\n");
+                puts("");
                 col = 0;
             }
+            applet++;
         }
     }
 #endif
-    printf("\n\n");
+    puts("\n");
     return EXIT_SUCCESS;
 }
 
-
-
 static int dolabel(struct op *t)
 {
-    return (0);
-}
-
-static int dochdir(REGISTER struct op *t)
-{
-    REGISTER char *cp, *er;
-
-    if ((cp = t->words[1]) == NULL && (cp = homedir->value) == NULL)
+    return 0;
+}
+
+static int dochdir(struct op *t)
+{
+    const char *cp, *er;
+
+    cp = t->words[1];
+    if (cp == NULL) {
+        cp = homedir->value;
+        if (cp != NULL)
+            goto do_cd;
         er = ": no home directory";
-    else if (chdir(cp) < 0)
+    } else {
+ do_cd:
+        if (chdir(cp) >= 0)
+            return 0;
         er = ": bad directory";
-    else
-        return (0);
+    }
     prs(cp != NULL ? cp : "cd");
     err(er);
-    return (1);
-}
-
-static int doshift(REGISTER struct op *t)
-{
-    REGISTER int n;
+    return 1;
+}
+
+static int doshift(struct op *t)
+{
+    int n;
 
     n = t->words[1] ? getn(t->words[1]) : 1;
     if (dolc < n) {
         err("nothing to shift");
-        return (1);
+        return 1;
     }
     dolv[n] = dolv[0];
@@ -3401 +3244 @@
     dolc -= n;
     setval(lookup("#"), putn(dolc));
-    return (0);
+    return 0;
 }
 
@@ -3409 +3252 @@
 static int dologin(struct op *t)
 {
-    REGISTER char *cp;
+    const char *cp;
 
     if (interactive) {
@@ -3419 +3262 @@
     prs(": ");
     err(cp);
-    return (1);
-}
-
-static int doumask(REGISTER struct op *t)
-{
-    REGISTER int i, n;
-    REGISTER char *cp;
-
-    if ((cp = t->words[1]) == NULL) {
+    return 1;
+}
+
+static int doumask(struct op *t)
+{
+    int i, n;
+    char *cp;
+
+    cp = t->words[1];
+    if (cp == NULL) {
         i = umask(0);
         umask(i);
@@ -3434 +3278 @@
         putc('\n', stderr);
     } else {
+/* huh??? '8','9' are not allowed! */
         for (n = 0; *cp >= '0' && *cp <= '9'; cp++)
             n = n * 8 + (*cp - '0');
         umask(n);
     }
-    return (0);
-}
-
-static int doexec(REGISTER struct op *t)
-{
-    REGISTER int i;
+    return 0;
+}
+
+static int doexec(struct op *t)
+{
+    int i;
     jmp_buf ex;
     xint *ofail;
@@ -3450 +3295 @@
     for (i = 0; (t->words[i] = t->words[i + 1]) != NULL; i++);
     if (i == 0)
-        return (1);
+        return 1;
     execflg = 1;
     ofail = failpt;
-    if (setjmp(failpt = ex) == 0)
+    failpt = ex;
+    if (setjmp(failpt) == 0)
         execute(t, NOPIPE, NOPIPE, FEXEC);
     failpt = ofail;
     execflg = 0;
-    return (1);
+    return 1;
 }
 
 static int dodot(struct op *t)
 {
-    REGISTER int i;
-    REGISTER char *sp, *tp;
+    int i;
+    const char *sp;
+    char *tp;
     char *cp;
     int maltmp;
@@ -3469 +3316 @@
     DBGPRINTF(("DODOT: enter, t=%p, tleft %p, tright %p, e.linep is %s\n", t, t->left, t->right, ((e.linep == NULL) ? "NULL" : e.linep)));
 
-    if ((cp = t->words[1]) == NULL) {
+    cp = t->words[1];
+    if (cp == NULL) {
         DBGPRINTF(("DODOT: bad args, ret 0\n"));
-        return (0);
-    } else {
-        DBGPRINTF(("DODOT: cp is %s\n", cp));
-    }
+        return 0;
+    }
+    DBGPRINTF(("DODOT: cp is %s\n", cp));
 
     sp = any('/', cp) ? ":" : path->value;
@@ -3492 +3339 @@
 
         /* Original code */
-        if ((i = open(e.linep, 0)) >= 0) {
+        i = open(e.linep, O_RDONLY);
+        if (i >= 0) {
             exstat = 0;
             maltmp = remap(i);
@@ -3501 +3349 @@
             DBGPRINTF(("DODOT: returning exstat=%d\n", exstat));
 
-            return (exstat);
-        }
-
-    }                           /* While */
+            return exstat;
+        }
+    } /* while */
 
     prs(cp);
     err(": not found");
 
-    return (-1);
+    return -1;
 }
 
 static int dowait(struct op *t)
 {
-    REGISTER int i;
-    REGISTER char *cp;
-
-    if ((cp = t->words[1]) != NULL) {
+    int i;
+    char *cp;
+
+    cp = t->words[1];
+    if (cp != NULL) {
         i = getn(cp);
         if (i == 0)
-            return (0);
+            return 0;
     } else
         i = -1;
     setstatus(waitfor(i, 1));
-    return (0);
+    return 0;
 }
 
 static int doread(struct op *t)
 {
-    REGISTER char *cp, **wp;
-    REGISTER int nb = 0;
-    REGISTER int nl = 0;
+    char *cp, **wp;
+    int nb = 0;
+    int nl = 0;
 
     if (t->words[1] == NULL) {
         err("Usage: read name ...");
-        return (1);
+        return 1;
     }
     for (wp = t->words + 1; *wp; wp++) {
-        for (cp = e.linep; !nl && cp < elinep - 1; cp++)
-            if ((nb = read(0, cp, sizeof(*cp))) != sizeof(*cp) ||
-                (nl = (*cp == '\n')) || (wp[1] && any(*cp, ifs->value)))
+        for (cp = e.linep; !nl && cp < elinep - 1; cp++) {
+            nb = read(0, cp, sizeof(*cp));
+            if (nb != sizeof(*cp))
                 break;
-        *cp = 0;
+            nl = (*cp == '\n');
+            if (nl || (wp[1] && any(*cp, ifs->value)))
+                break;
+        }
+        *cp = '\0';
         if (nb <= 0)
             break;
         setval(lookup(*wp), e.linep);
     }
-    return (nb <= 0);
-}
-
-static int doeval(REGISTER struct op *t)
-{
-    return (RUN(awordlist, t->words + 1, wdchar));
-}
-
-static int dotrap(REGISTER struct op *t)
-{
-    REGISTER int n, i;
-    REGISTER int resetsig;
+    return nb <= 0;
+}
+
+static int doeval(struct op *t)
+{
+    return RUN(awordlist, t->words + 1, wdchar);
+}
+
+static int dotrap(struct op *t)
+{
+    int n, i;
+    int resetsig;
 
     if (t->words[1] == NULL) {
@@ -3568 +3420 @@
                 prs("\n");
             }
-        return (0);
+        return 0;
     }
     resetsig = isdigit(*t->words[1]);
@@ -3582 +3434 @@
                 setsig(n, SIG_IGN);
         } else {
-            if (interactive)
+            if (interactive) {
                 if (n == SIGINT)
                     setsig(n, onintr);
                 else
                     setsig(n, n == SIGQUIT ? SIG_IGN : SIG_DFL);
-            else
+            } else
                 setsig(n, SIG_DFL);
         }
     }
-    return (0);
+    return 0;
 }
 
 static int getsig(char *s)
 {
-    REGISTER int n;
-
-    if ((n = getn(s)) < 0 || n > _NSIG) {
+    int n;
+
+    n = getn(s);
+    if (n < 0 || n > _NSIG) {
         err("trap: bad signal number");
         n = 0;
     }
-    return (n);
-}
-
-static void setsig(REGISTER int n, sighandler_t f)
+    return n;
+}
+
+static void setsig(int n, sighandler_t f)
 {
     if (n == 0)
@@ -3617 +3470 @@
 static int getn(char *as)
 {
-    REGISTER char *s;
-    REGISTER int n, m;
+    char *s;
+    int n, m;
 
     s = as;
@@ -3632 +3485 @@
         err(": bad number");
     }
-    return (n * m);
+    return n * m;
 }
 
 static int dobreak(struct op *t)
 {
-    return (brkcontin(t->words[1], 1));
+    return brkcontin(t->words[1], 1);
 }
 
 static int docontinue(struct op *t)
 {
-    return (brkcontin(t->words[1], 0));
-}
-
-static int brkcontin(REGISTER char *cp, int val)
-{
-    REGISTER struct brkcon *bc;
-    REGISTER int nl;
+    return brkcontin(t->words[1], 0);
+}
+
+static int brkcontin(char *cp, int val)
+{
+    struct brkcon *bc;
+    int nl;
 
     nl = cp == NULL ? 1 : getn(cp);
@@ -3654 +3507 @@
         nl = 999;
     do {
-        if ((bc = brklist) == NULL)
+        bc = brklist;
+        if (bc == NULL)
             break;
         brklist = bc->nextlev;
@@ -3660 +3514 @@
     if (nl) {
         err("bad break/continue level");
-        return (1);
+        return 1;
     }
     isbreak = val;
@@ -3669 +3523 @@
 static int doexit(struct op *t)
 {
-    REGISTER char *cp;
+    char *cp;
 
     execflg = 0;
-    if ((cp = t->words[1]) != NULL)
+    cp = t->words[1];
+    if (cp != NULL)
         setstatus(getn(cp));
 
@@ -3679 +3534 @@
     leave();
     /* NOTREACHED */
-    return (0);
+    return 0;
 }
 
@@ -3685 +3540 @@
 {
     rdexp(t->words + 1, export, EXPORT);
-    return (0);
+    return 0;
 }
 
@@ -3691 +3546 @@
 {
     rdexp(t->words + 1, ronly, RONLY);
-    return (0);
+    return 0;
 }
 
@@ -3717 +3572 @@
 }
 
-static void badid(REGISTER char *s)
+static void badid(char *s)
 {
     prs(s);
@@ -3723 +3578 @@
 }
 
-static int doset(REGISTER struct op *t)
-{
-    REGISTER struct var *vp;
-    REGISTER char *cp;
-    REGISTER int n;
-
-    if ((cp = t->words[1]) == NULL) {
+static int doset(struct op *t)
+{
+    struct var *vp;
+    char *cp;
+    int n;
+
+    cp = t->words[1];
+    if (cp == NULL) {
         for (vp = vlist; vp; vp = vp->next)
             varput(vp->name, 1);
-        return (0);
+        return 0;
     }
     if (*cp == '-') {
@@ -3738 +3594 @@
         for (n = 0; (t->words[n] = t->words[n + 1]) != NULL; n++);
         if (*++cp == 0)
-            flag['x'] = flag['v'] = 0;
-        else
-            for (; *cp; cp++)
+            FLAG['x'] = FLAG['v'] = 0;
+        else {
+            for (; *cp; cp++) {
                 switch (*cp) {
                 case 'e':
                     if (!interactive)
-                        flag['e']++;
+                        FLAG['e']++;
                     break;
 
                 default:
                     if (*cp >= 'a' && *cp <= 'z')
-                        flag[(int) *cp]++;
+                        FLAG[(int) *cp]++;
                     break;
                 }
+            }
+        }
         setdash();
     }
@@ -3763 +3621 @@
         setarea((char *) (dolv - 1), 0);
     }
-    return (0);
-}
-
-static void varput(REGISTER char *s, int out)
+    return 0;
+}
+
+static void varput(char *s, int out)
 {
     if (isalnum(*s) || *s == '_') {
@@ -3782 +3640 @@
 {
     struct tms buf;
-    long int clk_tck = sysconf(_SC_CLK_TCK);
+    long clk_tck = sysconf(_SC_CLK_TCK);
 
     times(&buf);
@@ -3798 +3656 @@
 
 
-static int (*inbuilt(char *s)) (struct op *) {
-    const struct builtincmd *bp;
-
-    for (bp = builtincmds; bp->name != NULL; bp++)
-        if (strcmp(bp->name, s) == 0)
-            return (bp->builtinfunc);
-
-    return (NULL);
-}
-
 /* -------- eval.c -------- */
 
@@ -3836 +3684 @@
     wb = NULL;
     wf = NULL;
-    if (newenv(setjmp(errpt = ev)) == 0) {
+    errpt = ev;
+    if (newenv(setjmp(errpt)) == 0) {
         while (*ap && isassign(*ap))
             expand(*ap++, &wb, f & ~DOGLOB);
-        if (flag['k']) {
+        if (FLAG['k']) {
             for (wf = ap; *wf; wf++) {
                 if (isassign(*wf))
@@ -3846 +3695 @@
         }
         for (wb = addword((char *) 0, wb); *ap; ap++) {
-            if (!flag['k'] || !isassign(*ap))
+            if (!FLAG['k'] || !isassign(*ap))
                 expand(*ap, &wb, f & ~DOKEY);
         }
@@ -3855 +3704 @@
         gflg = 1;
 
-    return (gflg ? (char **) NULL : wp);
-}
+    return gflg ? (char **) NULL : wp;
+}
+
 
 /*
@@ -3865 +3715 @@
 static char **makenv(int all, struct wdblock *wb)
 {
-    REGISTER struct var *vp;
+    struct var *vp;
 
     DBGPRINTF5(("MAKENV: enter, all=%d\n", all));
@@ -3873 +3723 @@
             wb = addword(vp->name, wb);
     wb = addword((char *) 0, wb);
-    return (getwords(wb));
-}
-
-static char *evalstr(REGISTER char *cp, int f)
-{
-    struct wdblock *wb;
-
-    DBGPRINTF6(("EVALSTR: enter, cp=%p, f=%d\n", cp, f));
-
-    wb = NULL;
-    if (expand(cp, &wb, f)) {
-        if (wb == NULL || wb->w_nword == 0
-            || (cp = wb->w_words[0]) == NULL)
-            cp = "";
-        DELETE(wb);
-    } else
-        cp = NULL;
-    return (cp);
-}
-
-static int expand(char *cp, REGISTER struct wdblock **wbp, int f)
+    return getwords(wb);
+}
+
+static int expand(const char *cp, struct wdblock **wbp, int f)
 {
     jmp_buf ev;
+    char *xp;
 
 #if __GNUC__
@@ -3907 +3741 @@
 
     if (cp == NULL)
-        return (0);
-
-    if (!anys("$`'\"", cp) &&
-        !anys(ifs->value, cp) && ((f & DOGLOB) == 0 || !anys("[*?", cp))) {
-        cp = strsave(cp, areanum);
+        return 0;
+
+    if (!anys("$`'\"", cp) && !anys(ifs->value, cp)
+     && ((f & DOGLOB) == 0 || !anys("[*?", cp))
+    ) {
+        xp = strsave(cp, areanum);
         if (f & DOTRIM)
-            unquote(cp);
-        *wbp = addword(cp, *wbp);
-        return (1);
-    }
-    if (newenv(setjmp(errpt = ev)) == 0) {
+            unquote(xp);
+        *wbp = addword(xp, *wbp);
+        return 1;
+    }
+    errpt = ev;
+    if (newenv(setjmp(errpt)) == 0) {
         PUSHIO(aword, cp, strchar);
         e.iobase = e.iop;
-        while ((cp = blank(f)) && gflg == 0) {
-            e.linep = cp;
-            cp = strsave(cp, areanum);
+        while ((xp = blank(f)) && gflg == 0) {
+            e.linep = xp;
+            xp = strsave(xp, areanum);
             if ((f & DOGLOB) == 0) {
                 if (f & DOTRIM)
-                    unquote(cp);
-                *wbp = addword(cp, *wbp);
+                    unquote(xp);
+                *wbp = addword(xp, *wbp);
             } else
-                *wbp = glob(cp, *wbp);
+                *wbp = glob(xp, *wbp);
         }
         quitenv();
     } else
         gflg = 1;
-    return (gflg == 0);
-}
+    return gflg == 0;
+}
+
+static char *evalstr(char *cp, int f)
+{
+    struct wdblock *wb;
+
+    DBGPRINTF6(("EVALSTR: enter, cp=%p, f=%d\n", cp, f));
+
+    wb = NULL;
+    if (expand(cp, &wb, f)) {
+        if (wb == NULL || wb->w_nword == 0
+         || (cp = wb->w_words[0]) == NULL
+        ) {
+// TODO: I suspect that
+// char *evalstr(char *cp, int f)  is actually
+// const char *evalstr(const char *cp, int f)!
+            cp = (char*)"";
+        }
+        DELETE(wb);
+    } else
+        cp = NULL;
+    return cp;
+}
+
 
 /*
@@ -3941 +3800 @@
 static char *blank(int f)
 {
-    REGISTER int c, c1;
-    REGISTER char *sp;
+    int c, c1;
+    char *sp;
     int scanequals, foundequals;
 
@@ -3951 +3810 @@
     foundequals = 0;
 
-  loop:
-    switch (c = subgetc('"', foundequals)) {
+ loop:
+    c = subgetc('"', foundequals);
+    switch (c) {
     case 0:
         if (sp == e.linep)
-            return (0);
+            return 0;
         *e.linep++ = 0;
-        return (sp);
+        return sp;
 
     default:
@@ -4002 +3862 @@
     }
     *e.linep++ = 0;
-    return (sp);
+    return sp;
 }
 
@@ -4008 +3868 @@
  * Get characters, substituting for ` and $
  */
-static int subgetc(REGISTER char ec, int quoted)
-{
-    REGISTER char c;
+static int subgetc(char ec, int quoted)
+{
+    char c;
 
     DBGPRINTF3(("SUBGETC: enter, quoted=%d\n", quoted));
 
-  again:
+ again:
     c = my_getc(ec);
     if (!INSUB() && ec != '\'') {
         if (c == '`') {
             if (grave(quoted) == 0)
-                return (0);
+                return 0;
             e.iop->task = XGRAVE;
             goto again;
         }
-        if (c == '$' && (c = dollar(quoted)) == 0) {
-            e.iop->task = XDOLL;
-            goto again;
-        }
-    }
-    return (c);
+        if (c == '$') {
+            c = dollar(quoted);
+            if (c == 0) {
+                e.iop->task = XDOLL;
+                goto again;
+            }
+        }
+    }
+    return c;
 }
 
@@ -4039 +3902 @@
     struct io *oiop;
     char *dolp;
-    REGISTER char *s, c, *cp = NULL;
+    char *s, c, *cp = NULL;
     struct var *vp;
 
@@ -4068 +3931 @@
             err("unclosed ${");
             gflg++;
-            return (c);
+            return c;
         }
     }
@@ -4090 +3953 @@
             e.linep = s;
             PUSHIO(awordlist, dolv + 1, dolchar);
-            return (0);
+            return 0;
         } else {                /* trap the nasty ${=} */
             s[0] = '1';
-            s[1] = 0;
+            s[1] = '\0';
         }
     }
     vp = lookup(s);
-    if ((dolp = vp->value) == null) {
+    dolp = vp->value;
+    if (dolp == null) {
         switch (c) {
         case '=':
@@ -4124 +3988 @@
     } else if (c == '+')
         dolp = strsave(cp, areanum);
-    if (flag['u'] && dolp == null) {
+    if (FLAG['u'] && dolp == null) {
         prs("unset variable: ");
         err(s);
@@ -4131 +3995 @@
     e.linep = s;
     PUSHIO(aword, dolp, quoted ? qstrchar : strchar);
-    return (0);
+    return 0;
 }
 
@@ -4140 +4004 @@
 static int grave(int quoted)
 {
-    char *cp;
-    REGISTER int i;
+    /* moved to G: static char child_cmd[LINELIM]; */
+
+    const char *cp;
+    int i;
     int j;
     int pf[2];
-    static char child_cmd[LINELIM];
-    char *src;
+    const char *src;
     char *dest;
     int count;
@@ -4158 +4023 @@
 #endif
 
-    for (cp = e.iop->argp->aword; *cp != '`'; cp++)
+    for (cp = e.iop->argp->aword; *cp != '`'; cp++) {
         if (*cp == 0) {
             err("no closing `");
-            return (0);
-        }
+            return 0;
+        }
+    }
 
     /* string copy with dollar expansion */
@@ -4208 +4074 @@
                 default:
                     err("unclosed ${\n");
-                    return (0);
+                    return 0;
                 }
                 if (operator) {
@@ -4218 +4084 @@
                     if (*src != '}') {
                         err("unclosed ${\n");
-                        return (0);
+                        return 0;
                     }
                 }
@@ -4253 +4119 @@
                 else if (operator == '?') {
                     err(alt_value);
-                    return (0);
+                    return 0;
                 } else if (alt_index && (operator != '+')) {
                     value = alt_value;
@@ -4275 +4141 @@
 
     if (openpipe(pf) < 0)
-        return (0);
+        return 0;
 
     while ((i = vfork()) == -1 && errno == EAGAIN);
@@ -4284 +4150 @@
         closepipe(pf);
         err((char *) bb_msg_memory_exhausted);
-        return (0);
+        return 0;
     }
     if (i != 0) {
@@ -4291 +4157 @@
         close(pf[1]);
         PUSHIO(afile, remap(pf[0]),
-               (int (*)(struct ioarg *)) ((quoted) ? qgravechar :
-                                          gravechar));
-        return (1);
+            (int (*)(struct ioarg *)) ((quoted) ? qgravechar : gravechar));
+        return 1;
     }
     /* allow trapped signals */
@@ -4301 +4166 @@
             signal(j, SIG_DFL);
 
-    dup2(pf[1], 1);
-    closepipe(pf);
+    /* Testcase where below checks are needed:
+     * close stdout & run this script:
+     *  files=`ls`
+     *  echo "$files" >zz
+     */
+    xmove_fd(pf[1], 1);
+    if (pf[0] != 1) close(pf[0]);
 
     argument_list[0] = (char *) DEFAULT_SHELL;
-    argument_list[1] = "-c";
+    argument_list[1] = (char *) "-c";
     argument_list[2] = child_cmd;
-    argument_list[3] = 0;
+    argument_list[3] = NULL;
 
     cp = rexecve(argument_list[0], argument_list, makenv(1, wb));
@@ -4317 +4187 @@
 
 
-static char *unquote(REGISTER char *as)
-{
-    REGISTER char *s;
-
-    if ((s = as) != NULL)
+static char *unquote(char *as)
+{
+    char *s;
+
+    s = as;
+    if (s != NULL)
         while (*s)
             *s++ &= ~QUOTE;
-    return (as);
+    return as;
 }
 
@@ -4338 +4209 @@
 
 static struct wdblock *cl, *nl;
-static char spcl[] = "[?*";
+static const char spcl[] ALIGN1= "[?*";
 
 static struct wdblock *glob(char *cp, struct wdblock *wb)
 {
-    REGISTER int i;
-    REGISTER char *pp;
+    int i;
+    char *pp;
 
     if (cp == 0)
-        return (wb);
+        return wb;
     i = 0;
     for (pp = cp; *pp; pp++)
@@ -4354 +4225 @@
             *pp &= ~QUOTE;
     if (i != 0) {
-        for (cl = addword(scopy(cp), (struct wdblock *) 0); anyspcl(cl);
-             cl = nl) {
+        for (cl = addword(scopy(cp), NULL); anyspcl(cl); cl = nl) {
             nl = newword(cl->w_nword * 2);
             for (i = 0; i < cl->w_nword; i++) { /* for each argument */
@@ -4377 +4247 @@
                 wb = addword(cl->w_words[i], wb);
             DELETE(cl);
-            return (wb);
+            return wb;
         }
     }
     wb = addword(unquote(cp), wb);
-    return (wb);
-}
-
-static void globname(char *we, REGISTER char *pp)
-{
-    REGISTER char *np, *cp;
+    return wb;
+}
+
+static void globname(char *we, char *pp)
+{
+    char *np, *cp;
     char *name, *gp, *dp;
     int k;
@@ -4415 +4285 @@
         /*
            if (ent[j].d_ino == 0)
-           continue;
+              continue;
          */
         strncpy(dname, de->d_name, NAME_MAX);
@@ -4445 +4315 @@
  * the slashes come for free
  */
-static char *generate(char *start1, REGISTER char *end1, char *middle, char *end)
+static char *generate(char *start1, char *end1, char *middle, char *end)
 {
     char *p;
-    REGISTER char *op, *xp;
-
-    p = op =
-        space((int) (end1 - start1) + strlen(middle) + strlen(end) + 2);
+    char *op, *xp;
+
+    p = op = space((int)(end1 - start1) + strlen(middle) + strlen(end) + 2);
     for (xp = start1; xp != end1;)
         *op++ = *xp++;
@@ -4457 +4326 @@
     op--;
     for (xp = end; (*op++ = *xp++) != '\0';);
-    return (p);
-}
-
-static int anyspcl(REGISTER struct wdblock *wb)
-{
-    REGISTER int i;
-    REGISTER char **wd;
+    return p;
+}
+
+static int anyspcl(struct wdblock *wb)
+{
+    int i;
+    char **wd;
 
     wd = wb->w_words;
     for (i = 0; i < wb->w_nword; i++)
         if (anys(spcl, *wd++))
-            return (1);
-    return (0);
+            return 1;
+    return 0;
 }
 
 static int xstrcmp(char *p1, char *p2)
 {
-    return (strcmp(*(char **) p1, *(char **) p2));
-}
+    return strcmp(*(char **) p1, *(char **) p2);
+}
+
 
 /* -------- word.c -------- */
 
-static struct wdblock *newword(REGISTER int nw)
-{
-    REGISTER struct wdblock *wb;
+static struct wdblock *newword(int nw)
+{
+    struct wdblock *wb;
 
     wb = (struct wdblock *) space(sizeof(*wb) + nw * sizeof(char *));
     wb->w_bsize = nw;
     wb->w_nword = 0;
-    return (wb);
-}
-
-static struct wdblock *addword(char *wd, REGISTER struct wdblock *wb)
-{
-    REGISTER struct wdblock *wb2;
-    REGISTER int nw;
+    return wb;
+}
+
+static struct wdblock *addword(char *wd, struct wdblock *wb)
+{
+    struct wdblock *wb2;
+    int nw;
 
     if (wb == NULL)
         wb = newword(NSTART);
-    if ((nw = wb->w_nword) >= wb->w_bsize) {
+    nw = wb->w_nword;
+    if (nw >= wb->w_bsize) {
         wb2 = newword(nw * 2);
         memcpy((char *) wb2->w_words, (char *) wb->w_words,
@@ -4505 +4376 @@
     }
     wb->w_words[wb->w_nword++] = wd;
-    return (wb);
-}
-
-static
-char **getwords(REGISTER struct wdblock *wb)
-{
-    REGISTER char **wd;
-    REGISTER int nb;
+    return wb;
+}
+
+static char **getwords(struct wdblock *wb)
+{
+    char **wd;
+    int nb;
 
     if (wb == NULL)
-        return ((char **) NULL);
+        return NULL;
     if (wb->w_nword == 0) {
         DELETE(wb);
-        return ((char **) NULL);
+        return NULL;
     }
     wd = (char **) space(nb = sizeof(*wd) * wb->w_nword);
     memcpy((char *) wd, (char *) wb->w_words, nb);
     DELETE(wb);                 /* perhaps should done by caller */
-    return (wd);
+    return wd;
 }
 
@@ -4529 +4399 @@
 static int globv;
 
-static void glob0(char *a0, unsigned a1, int a2, int (*a3) (char *, char *))
-{
-    func = a3;
-    globv = a2;
-    glob1(a0, a0 + a1 * a2);
-}
-
-static void glob1(char *base, char *lim)
-{
-    REGISTER char *i, *j;
-    int v2;
-    char *lptr, *hptr;
-    int c;
-    unsigned n;
-
-
-    v2 = globv;
-
-  top:
-    if ((n = (int) (lim - base)) <= v2)
-        return;
-    n = v2 * (n / (2 * v2));
-    hptr = lptr = base + n;
-    i = base;
-    j = lim - v2;
-    for (;;) {
-        if (i < lptr) {
-            if ((c = (*func) (i, lptr)) == 0) {
-                glob2(i, lptr -= v2);
-                continue;
-            }
-            if (c < 0) {
-                i += v2;
-                continue;
-            }
-        }
-
-      begin:
-        if (j > hptr) {
-            if ((c = (*func) (hptr, j)) == 0) {
-                glob2(hptr += v2, j);
-                goto begin;
-            }
-            if (c > 0) {
-                if (i == lptr) {
-                    glob3(i, hptr += v2, j);
-                    i = lptr += v2;
-                    goto begin;
-                }
-                glob2(i, j);
-                j -= v2;
-                i += v2;
-                continue;
-            }
-            j -= v2;
-            goto begin;
-        }
-
-
-        if (i == lptr) {
-            if (lptr - base >= lim - hptr) {
-                glob1(hptr + v2, lim);
-                lim = lptr;
-            } else {
-                glob1(base, lptr);
-                base = hptr + v2;
-            }
-            goto top;
-        }
-
-
-        glob3(j, lptr -= v2, i);
-        j = hptr -= v2;
-    }
-}
-
-static void glob2(char *i, char *j)
-{
-    REGISTER char *index1, *index2, c;
-    int m;
-
-    m = globv;
-    index1 = i;
-    index2 = j;
-    do {
-        c = *index1;
-        *index1++ = *index2;
-        *index2++ = c;
-    } while (--m);
-}
-
 static void glob3(char *i, char *j, char *k)
 {
-    REGISTER char *index1, *index2, *index3;
+    char *index1, *index2, *index3;
     int c;
     int m;
@@ -4638 +4417 @@
 }
 
+static void glob2(char *i, char *j)
+{
+    char *index1, *index2, c;
+    int m;
+
+    m = globv;
+    index1 = i;
+    index2 = j;
+    do {
+        c = *index1;
+        *index1++ = *index2;
+        *index2++ = c;
+    } while (--m);
+}
+
+static void glob1(char *base, char *lim)
+{
+    char *i, *j;
+    int v2;
+    char *lptr, *hptr;
+    int c;
+    unsigned n;
+
+    v2 = globv;
+
+ top:
+    n = (int) (lim - base);
+    if (n <= v2)
+        return;
+    n = v2 * (n / (2 * v2));
+    hptr = lptr = base + n;
+    i = base;
+    j = lim - v2;
+    for (;;) {
+        if (i < lptr) {
+            c = (*func) (i, lptr);
+            if (c == 0) {
+                lptr -= v2;
+                glob2(i, lptr);
+                continue;
+            }
+            if (c < 0) {
+                i += v2;
+                continue;
+            }
+        }
+
+ begin:
+        if (j > hptr) {
+            c = (*func) (hptr, j);
+            if (c == 0) {
+                hptr += v2;
+                glob2(hptr, j);
+                goto begin;
+            }
+            if (c > 0) {
+                if (i == lptr) {
+                    hptr += v2;
+                    glob3(i, hptr, j);
+                    i = (lptr += v2);
+                    goto begin;
+                }
+                glob2(i, j);
+                j -= v2;
+                i += v2;
+                continue;
+            }
+            j -= v2;
+            goto begin;
+        }
+
+
+        if (i == lptr) {
+            if (lptr - base >= lim - hptr) {
+                glob1(hptr + v2, lim);
+                lim = lptr;
+            } else {
+                glob1(base, lptr);
+                base = hptr + v2;
+            }
+            goto top;
+        }
+
+        lptr -= v2;
+        glob3(j, lptr, i);
+        j = (hptr -= v2);
+    }
+}
+
+static void glob0(char *a0, unsigned a1, int a2, int (*a3) (char *, char *))
+{
+    func = a3;
+    globv = a2;
+    glob1(a0, a0 + a1 * a2);
+}
+
+
 /* -------- io.c -------- */
 
@@ -4646 +4522 @@
 static int my_getc(int ec)
 {
-    REGISTER int c;
+    int c;
 
     if (e.linep > elinep) {
@@ -4652 +4528 @@
         err("input line too long");
         gflg++;
-        return (c);
+        return c;
     }
     c = readc();
@@ -4659 +4535 @@
             c = readc();
             if (c == '\n' && ec != '\"')
-                return (my_getc(ec));
+                return my_getc(ec);
             c |= QUOTE;
         }
     }
-    return (c);
+    return c;
 }
 
@@ -4679 +4555 @@
 static int readc(void)
 {
-    REGISTER int c;
+    int c;
 
     RCPRINTF(("READC: e.iop %p, e.iobase %p\n", e.iop, e.iobase));
@@ -4685 +4561 @@
     for (; e.iop >= e.iobase; e.iop--) {
         RCPRINTF(("READC: e.iop %p, peekc 0x%x\n", e.iop, e.iop->peekc));
-        if ((c = e.iop->peekc) != '\0') {
+        c = e.iop->peekc;
+        if (c != '\0') {
             e.iop->peekc = 0;
-            return (c);
-        } else {
-            if (e.iop->prev != 0) {
-                if ((c = (*e.iop->iofn) (e.iop->argp, e.iop)) != '\0') {
-                    if (c == -1) {
-                        e.iop++;
-                        continue;
-                    }
-                    if (e.iop == iostack)
-                        ioecho(c);
-                    return (e.iop->prev = c);
-                } else if (e.iop->task == XIO && e.iop->prev != '\n') {
-                    e.iop->prev = 0;
-                    if (e.iop == iostack)
-                        ioecho('\n');
-                    return '\n';
+            return c;
+        }
+        if (e.iop->prev != 0) {
+            c = (*e.iop->iofn)(e.iop->argp, e.iop);
+            if (c != '\0') {
+                if (c == -1) {
+                    e.iop++;
+                    continue;
                 }
+                if (e.iop == iostack)
+                    ioecho(c);
+                e.iop->prev = c;
+                return e.iop->prev;
             }
-            if (e.iop->task == XIO) {
-                if (multiline) {
-                    return e.iop->prev = 0;
-                }
-                if (interactive && e.iop == iostack + 1) {
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
-                    current_prompt = prompt->value;
+            if (e.iop->task == XIO && e.iop->prev != '\n') {
+                e.iop->prev = 0;
+                if (e.iop == iostack)
+                    ioecho('\n');
+                return '\n';
+            }
+        }
+        if (e.iop->task == XIO) {
+            if (multiline) {
+                e.iop->prev = 0;
+                return e.iop->prev;
+            }
+            if (interactive && e.iop == iostack + 1) {
+#if ENABLE_FEATURE_EDITING
+                current_prompt = prompt->value;
 #else
-                    prs(prompt->value);
+                prs(prompt->value);
 #endif
-                }
             }
         }
-
     }                           /* FOR */
 
     if (e.iop >= iostack) {
         RCPRINTF(("READC: return 0, e.iop %p\n", e.iop));
-        return (0);
+        return 0;
     }
 
@@ -4730 +4609 @@
 
     /* NOTREACHED */
-    return (0);
+    return 0;
 }
 
 static void ioecho(char c)
 {
-    if (flag['v'])
+    if (FLAG['v'])
         write(2, &c, sizeof c);
 }
@@ -4775 +4654 @@
         if ((isatty(e.iop->argp->afile) == 0)
             && (e.iop == &iostack[0]
-                || lseek(e.iop->argp->afile, 0L, 1) != -1)) {
+                || lseek(e.iop->argp->afile, 0L, SEEK_CUR) != -1)) {
             if (++bufid == AFID_NOBUF)  /* counter rollover check, AFID_NOBUF = 11111111  */
                 bufid = AFID_ID;    /* AFID_ID = 0 */
@@ -4797 +4676 @@
         e.iop->task = XIO;
     else if (fn == (int (*)(struct ioarg *)) gravechar
-             || fn == (int (*)(struct ioarg *)) qgravechar)
+     || fn == (int (*)(struct ioarg *)) qgravechar)
         e.iop->task = XGRAVE;
     else
         e.iop->task = XOTHER;
-
-    return;
 }
 
 static struct io *setbase(struct io *ip)
 {
-    REGISTER struct io *xp;
+    struct io *xp;
 
     xp = e.iobase;
     e.iobase = ip;
-    return (xp);
+    return xp;
 }
 
@@ -4821 +4698 @@
  * Produce the characters of a string, then a newline, then EOF.
  */
-static int nlchar(REGISTER struct ioarg *ap)
-{
-    REGISTER int c;
+static int nlchar(struct ioarg *ap)
+{
+    int c;
 
     if (ap->aword == NULL)
-        return (0);
-    if ((c = *ap->aword++) == 0) {
+        return 0;
+    c = *ap->aword++;
+    if (c == 0) {
         ap->aword = NULL;
-        return ('\n');
-    }
-    return (c);
+        return '\n';
+    }
+    return c;
 }
 
@@ -4838 +4716 @@
  * in them, with a space after each word.
  */
-static int wdchar(REGISTER struct ioarg *ap)
-{
-    REGISTER char c;
-    REGISTER char **wl;
-
-    if ((wl = ap->awordlist) == NULL)
-        return (0);
+static int wdchar(struct ioarg *ap)
+{
+    char c;
+    char **wl;
+
+    wl = ap->awordlist;
+    if (wl == NULL)
+        return 0;
     if (*wl != NULL) {
-        if ((c = *(*wl)++) != 0)
-            return (c & 0177);
+        c = *(*wl)++;
+        if (c != 0)
+            return c & 0177;
         ap->awordlist++;
-        return (' ');
+        return ' ';
     }
     ap->awordlist = NULL;
-    return ('\n');
+    return '\n';
 }
 
@@ -4859 +4739 @@
  * producing a space between them.
  */
-static int dolchar(REGISTER struct ioarg *ap)
-{
-    REGISTER char *wp;
-
-    if ((wp = *ap->awordlist++) != NULL) {
+static int dolchar(struct ioarg *ap)
+{
+    char *wp;
+
+    wp = *ap->awordlist++;
+    if (wp != NULL) {
         PUSHIO(aword, wp, *ap->awordlist == NULL ? strchar : xxchar);
-        return (-1);
-    }
-    return (0);
-}
-
-static int xxchar(REGISTER struct ioarg *ap)
-{
-    REGISTER int c;
+        return -1;
+    }
+    return 0;
+}
+
+static int xxchar(struct ioarg *ap)
+{
+    int c;
 
     if (ap->aword == NULL)
-        return (0);
-    if ((c = *ap->aword++) == '\0') {
+        return 0;
+    c = *ap->aword++;
+    if (c == '\0') {
         ap->aword = NULL;
-        return (' ');
-    }
-    return (c);
+        return ' ';
+    }
+    return c;
 }
 
@@ -4886 +4768 @@
  * Produce the characters from a single word (string).
  */
-static int strchar(REGISTER struct ioarg *ap)
-{
-    REGISTER int c;
-
-    if (ap->aword == NULL || (c = *ap->aword++) == 0)
-        return (0);
-    return (c);
+static int strchar(struct ioarg *ap)
+{
+    if (ap->aword == NULL)
+        return 0;
+    return *ap->aword++;
 }
 
@@ -4898 +4778 @@
  * Produce quoted characters from a single word (string).
  */
-static int qstrchar(REGISTER struct ioarg *ap)
-{
-    REGISTER int c;
-
-    if (ap->aword == NULL || (c = *ap->aword++) == 0)
-        return (0);
-    return (c | QUOTE);
+static int qstrchar(struct ioarg *ap)
+{
+    int c;
+
+    if (ap->aword == NULL)
+        return 0;
+    c = *ap->aword++;
+    if (c)
+        c |= QUOTE;
+    return c;
 }
 
@@ -4910 +4793 @@
  * Return the characters from a file.
  */
-static int filechar(REGISTER struct ioarg *ap)
-{
-    REGISTER int i;
+static int filechar(struct ioarg *ap)
+{
+    int i;
     char c;
     struct iobuf *bp = ap->afbuf;
 
     if (ap->afid != AFID_NOBUF) {
-        if ((i = ap->afid != bp->id) || bp->bufp == bp->ebufp) {
-
+        i = (ap->afid != bp->id);
+        if (i || bp->bufp == bp->ebufp) {
             if (i)
-                lseek(ap->afile, ap->afpos, 0);
+                lseek(ap->afile, ap->afpos, SEEK_SET);
 
             i = safe_read(ap->afile, bp->buf, sizeof(bp->buf));
-
             if (i <= 0) {
                 closef(ap->afile);
@@ -4930 +4812 @@
 
             bp->id = ap->afid;
-            bp->ebufp = (bp->bufp = bp->buf) + i;
+            bp->bufp = bp->buf;
+            bp->ebufp = bp->bufp + i;
         }
 
@@ -4936 +4819 @@
         return *bp->bufp++ & 0177;
     }
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
+#if ENABLE_FEATURE_EDITING
     if (interactive && isatty(ap->afile)) {
-        static char mycommand[BUFSIZ];
+        /* moved to G: static char filechar_cmdbuf[BUFSIZ]; */
         static int position = 0, size = 0;
 
         while (size == 0 || position >= size) {
-            cmdedit_read_input(current_prompt, mycommand);
-            size = strlen(mycommand);
+            read_line_input(current_prompt, filechar_cmdbuf, BUFSIZ, line_input_state);
+            size = strlen(filechar_cmdbuf);
             position = 0;
         }
-        c = mycommand[position];
+        c = filechar_cmdbuf[position];
         position++;
-        return (c);
-    } else
+        return c;
+    }
 #endif
-
-    {
-        i = safe_read(ap->afile, &c, sizeof(c));
-        return (i == sizeof(c) ? (c & 0x7f) : (closef(ap->afile), 0));
-    }
+    i = safe_read(ap->afile, &c, sizeof(c));
+    return i == sizeof(c) ? (c & 0x7f) : (closef(ap->afile), 0);
 }
 
@@ -4961 +4841 @@
  * Return the characters from a here temp file.
  */
-static int herechar(REGISTER struct ioarg *ap)
+static int herechar(struct ioarg *ap)
 {
     char c;
-
 
     if (read(ap->afile, &c, sizeof(c)) != sizeof(c)) {
         close(ap->afile);
-        c = 0;
-    }
-    return (c);
-
+        c = '\0';
+    }
+    return c;
 }
 
@@ -4980 +4858 @@
 static int gravechar(struct ioarg *ap, struct io *iop)
 {
-    REGISTER int c;
-
-    if ((c = qgravechar(ap, iop) & ~QUOTE) == '\n')
+    int c;
+
+    c = qgravechar(ap, iop) & ~QUOTE;
+    if (c == '\n')
         c = ' ';
-    return (c);
-}
-
-static int qgravechar(REGISTER struct ioarg *ap, struct io *iop)
-{
-    REGISTER int c;
+    return c;
+}
+
+static int qgravechar(struct ioarg *ap, struct io *iop)
+{
+    int c;
 
     DBGPRINTF3(("QGRAVECHAR: enter, ap=%p, iop=%p\n", ap, iop));
@@ -4996 +4875 @@
         if (iop->nlcount) {
             iop->nlcount--;
-            return ('\n' | QUOTE);
+            return '\n' | QUOTE;
         }
         c = iop->xchar;
@@ -5006 +4885 @@
         iop->xchar = c;
         if (c == 0)
-            return (c);
+            return c;
         iop->nlcount--;
         c = '\n';
     }
-    return (c != 0 ? c | QUOTE : 0);
+    return c != 0 ? c | QUOTE : 0;
 }
 
@@ -5016 +4895 @@
  * Return a single command (usually the first line) from a file.
  */
-static int linechar(REGISTER struct ioarg *ap)
-{
-    REGISTER int c;
-
-    if ((c = filechar(ap)) == '\n') {
+static int linechar(struct ioarg *ap)
+{
+    int c;
+
+    c = filechar(ap);
+    if (c == '\n') {
         if (!multiline) {
             closef(ap->afile);
@@ -5026 +4906 @@
         }
     }
-    return (c);
-}
-
-static void prs(REGISTER const char *s)
-{
-    if (*s)
-        write(2, s, strlen(s));
-}
-
-static void prn(unsigned u)
-{
-    prs(itoa(u));
-}
-
-static void closef(REGISTER int i)
-{
-    if (i > 2)
-        close(i);
-}
-
-static void closeall(void)
-{
-    REGISTER int u;
-
-    for (u = NUFILE; u < NOFILE;)
-        close(u++);
-}
-
+    return c;
+}
 
 /*
  * remap fd into Shell's fd space
  */
-static int remap(REGISTER int fd)
-{
-    REGISTER int i;
+static int remap(int fd)
+{
+    int i;
     int map[NOFILE];
     int newfd;
-
 
     DBGPRINTF(("REMAP: fd=%d, e.iofd=%d\n", fd, e.iofd));
@@ -5085 +4938 @@
     }
 
-    return (fd);
-}
-
-static int openpipe(REGISTER int *pv)
-{
-    REGISTER int i;
-
-    if ((i = pipe(pv)) < 0)
+    return fd;
+}
+
+static int openpipe(int *pv)
+{
+    int i;
+
+    i = pipe(pv);
+    if (i < 0)
         err("can't create pipe - try again");
-    return (i);
-}
-
-static void closepipe(REGISTER int *pv)
+    return i;
+}
+
+static void closepipe(int *pv)
 {
     if (pv != NULL) {
@@ -5105 +4959 @@
 }
 
+
 /* -------- here.c -------- */
 
@@ -5111 +4966 @@
  */
 
-static void markhere(REGISTER char *s, struct ioword *iop)
-{
-    REGISTER struct here *h, *lh;
+static void markhere(char *s, struct ioword *iop)
+{
+    struct here *h, *lh;
 
     DBGPRINTF7(("MARKHERE: enter, s=%p\n", s));
 
     h = (struct here *) space(sizeof(struct here));
-    if (h == 0)
+    if (h == NULL)
         return;
 
@@ -5130 +4985 @@
     if (inhere == 0)
         inhere = h;
-    else
-        for (lh = inhere; lh != NULL; lh = lh->h_next)
+    else {
+        for (lh = inhere; lh != NULL; lh = lh->h_next) {
             if (lh->h_next == 0) {
                 lh->h_next = h;
                 break;
             }
+        }
+    }
     iop->io_flag |= IOHERE | IOXHERE;
-    for (s = h->h_tag; *s; s++)
+    for (s = h->h_tag; *s; s++) {
         if (*s & QUOTE) {
             iop->io_flag &= ~IOXHERE;
             *s &= ~QUOTE;
         }
+    }
     h->h_dosub = iop->io_flag & IOXHERE;
 }
@@ -5147 +5005 @@
 static void gethere(void)
 {
-    REGISTER struct here *h, *hp;
+    struct here *h, *hp;
 
     DBGPRINTF7(("GETHERE: enter...\n"));
@@ -5163 +5021 @@
 }
 
-static void readhere(char **name, REGISTER char *s, int ec)
+static void readhere(char **name, char *s, int ec)
 {
     int tf;
     char tname[30] = ".msh_XXXXXX";
-    REGISTER int c;
+    int c;
     jmp_buf ev;
     char myline[LINELIM + 1];
@@ -5179 +5037 @@
 
     *name = strsave(tname, areanum);
-    if (newenv(setjmp(errpt = ev)) != 0)
+    errpt = ev;
+    if (newenv(setjmp(errpt)) != 0)
         unlink(tname);
     else {
@@ -5186 +5045 @@
         for (;;) {
             if (interactive && e.iop <= iostack) {
-#ifdef CONFIG_FEATURE_COMMAND_EDITING
+#if ENABLE_FEATURE_EDITING
                 current_prompt = cprompt->value;
 #else
@@ -5224 +5083 @@
 static int herein(char *hname, int xdoll)
 {
-    REGISTER int hf;
+    int hf;
     int tf;
 
@@ -5232 +5091 @@
 #endif
     if (hname == NULL)
-        return (-1);
+        return -1;
 
     DBGPRINTF7(("HEREIN: hname is %s, xdoll=%d\n", hname, xdoll));
 
-    hf = open(hname, 0);
+    hf = open(hname, O_RDONLY);
     if (hf < 0)
-        return (-1);
+        return -1;
 
     if (xdoll) {
@@ -5247 +5106 @@
         tf = mkstemp(tname);
         if (tf < 0)
-            return (-1);
-        if (newenv(setjmp(errpt = ev)) == 0) {
+            return -1;
+        errpt = ev;
+        if (newenv(setjmp(errpt)) == 0) {
             PUSHIO(afile, hf, herechar);
             setbase(e.iop);
@@ -5259 +5119 @@
             unlink(tname);
         close(tf);
-        tf = open(tname, 0);
+        tf = open(tname, O_RDONLY);
         unlink(tname);
-        return (tf);
-    } else
-        return (hf);
+        return tf;
+    }
+    return hf;
 }
 
 static void scraphere(void)
 {
-    REGISTER struct here *h;
+    struct here *h;
 
     DBGPRINTF7(("SCRAPHERE: enter...\n"));
@@ -5282 +5142 @@
 static void freehere(int area)
 {
-    REGISTER struct here *h, *hl;
+    struct here *h, *hl;
 
     DBGPRINTF6(("FREEHERE: enter, area=%d\n", area));
@@ -5299 +5159 @@
 }
 
+
+/* -------- sh.c -------- */
+/*
+ * shell
+ */
+
+int msh_main(int argc, char **argv);
+int msh_main(int argc, char **argv)
+{
+    int f;
+    char *s;
+    int cflag;
+    char *name, **ap;
+    int (*iof) (struct ioarg *);
+
+    PTR_TO_GLOBALS = xzalloc(sizeof(G));
+    sharedbuf.id = AFID_NOBUF;
+    mainbuf.id = AFID_NOBUF;
+    e.linep = line;
+    elinep = line + sizeof(line) - 5;
+
+#if ENABLE_FEATURE_EDITING
+    line_input_state = new_line_input_t(FOR_SHELL);
+#endif
+
+    DBGPRINTF(("MSH_MAIN: argc %d, environ %p\n", argc, environ));
+
+    initarea();
+    ap = environ;
+    if (ap != NULL) {
+        while (*ap)
+            assign(*ap++, !COPYV);
+        for (ap = environ; *ap;)
+            export(lookup(*ap++));
+    }
+    closeall();
+    areanum = 1;
+
+    shell = lookup("SHELL");
+    if (shell->value == null)
+        setval(shell, (char *)DEFAULT_SHELL);
+    export(shell);
+
+    homedir = lookup("HOME");
+    if (homedir->value == null)
+        setval(homedir, "/");
+    export(homedir);
+
+    setval(lookup("$"), putn(getpid()));
+
+    path = lookup("PATH");
+    if (path->value == null) {
+        /* Can be merged with same string elsewhere in bbox */
+        if (geteuid() == 0)
+            setval(path, bb_default_root_path);
+        else
+            setval(path, bb_default_path);
+    }
+    export(path);
+
+    ifs = lookup("IFS");
+    if (ifs->value == null)
+        setval(ifs, " \t\n");
+
+#ifdef MSHDEBUG
+    mshdbg_var = lookup("MSHDEBUG");
+    if (mshdbg_var->value == null)
+        setval(mshdbg_var, "0");
+#endif
+
+    prompt = lookup("PS1");
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+    if (prompt->value == null)
+#endif
+        setval(prompt, DEFAULT_USER_PROMPT);
+    if (geteuid() == 0) {
+        setval(prompt, DEFAULT_ROOT_PROMPT);
+        prompt->status &= ~EXPORT;
+    }
+    cprompt = lookup("PS2");
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+    if (cprompt->value == null)
+#endif
+        setval(cprompt, "> ");
+
+    iof = filechar;
+    cflag = 0;
+    name = *argv++;
+    if (--argc >= 1) {
+        if (argv[0][0] == '-' && argv[0][1] != '\0') {
+            for (s = argv[0] + 1; *s; s++)
+                switch (*s) {
+                case 'c':
+                    prompt->status &= ~EXPORT;
+                    cprompt->status &= ~EXPORT;
+                    setval(prompt, "");
+                    setval(cprompt, "");
+                    cflag = 1;
+                    if (--argc > 0)
+                        PUSHIO(aword, *++argv, iof = nlchar);
+                    break;
+
+                case 'q':
+                    qflag = SIG_DFL;
+                    break;
+
+                case 's':
+                    /* standard input */
+                    break;
+
+                case 't':
+                    prompt->status &= ~EXPORT;
+                    setval(prompt, "");
+                    iof = linechar;
+                    break;
+
+                case 'i':
+                    interactive++;
+                default:
+                    if (*s >= 'a' && *s <= 'z')
+                        FLAG[(int) *s]++;
+                }
+        } else {
+            argv--;
+            argc++;
+        }
+
+        if (iof == filechar && --argc > 0) {
+            setval(prompt, "");
+            setval(cprompt, "");
+            prompt->status &= ~EXPORT;
+            cprompt->status &= ~EXPORT;
+
+/* Shell is non-interactive, activate printf-based debug */
+#ifdef MSHDEBUG
+            mshdbg = (int) (((char) (mshdbg_var->value[0])) - '0');
+            if (mshdbg < 0)
+                mshdbg = 0;
+#endif
+            DBGPRINTF(("MSH_MAIN: calling newfile()\n"));
+
+            name = *++argv;
+            if (newfile(name))
+                exit(1);        /* Exit on error */
+        }
+    }
+
+    setdash();
+
+    /* This won't be true if PUSHIO has been called, say from newfile() above */
+    if (e.iop < iostack) {
+        PUSHIO(afile, 0, iof);
+        if (isatty(0) && isatty(1) && !cflag) {
+            interactive++;
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+#ifdef MSHDEBUG
+            printf("\n\n%s built-in shell (msh with debug)\n", bb_banner);
+#else
+            printf("\n\n%s built-in shell (msh)\n", bb_banner);
+#endif
+            printf("Enter 'help' for a list of built-in commands.\n\n");
+#endif
+        }
+    }
+
+    signal(SIGQUIT, qflag);
+    if (name && name[0] == '-') {
+        interactive++;
+        f = open(".profile", O_RDONLY);
+        if (f >= 0)
+            next(remap(f));
+        f = open("/etc/profile", O_RDONLY);
+        if (f >= 0)
+            next(remap(f));
+    }
+    if (interactive)
+        signal(SIGTERM, sig);
+
+    if (signal(SIGINT, SIG_IGN) != SIG_IGN)
+        signal(SIGINT, onintr);
+    dolv = argv;
+    dolc = argc;
+    dolv[0] = name;
+    if (dolc > 1) {
+        for (ap = ++argv; --argc > 0;) {
+            *ap = *argv++;
+            if (assign(*ap, !COPYV)) {
+                dolc--;         /* keyword */
+            } else {
+                ap++;
+            }
+        }
+    }
+    setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));
+
+    DBGPRINTF(("MSH_MAIN: begin FOR loop, interactive %d, e.iop %p, iostack %p\n", interactive, e.iop, iostack));
+
+    for (;;) {
+        if (interactive && e.iop <= iostack) {
+#if ENABLE_FEATURE_EDITING
+            current_prompt = prompt->value;
+#else
+            prs(prompt->value);
+#endif
+        }
+        onecommand();
+        /* Ensure that getenv("PATH") stays current */
+        setenv("PATH", path->value, 1);
+    }
+
+    DBGPRINTF(("MSH_MAIN: returning.\n"));
+}