ash: cleanup part 1

git-svn-id: svn://busybox.net/trunk/busybox@17953 69ca8d6d-28ef-0310-b511-8ec308f3f277

1 files changed, 539 insertions, 586 deletions

diff --git a/shell/ash.c b/shell/ash.c
index e262c0e13..379e8ab7f 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -503,6 +503,289 @@ errmsg(int e, const char *em)
 }
 
 
+/* ============ 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;
+}
+
+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;
+
+        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);
+}
+
+
 /* ============ Unsorted yet */
 
 
@@ -773,9 +1056,7 @@ static union node *redirnode;
 static struct heredoc *heredoc;
 static int quoteflag;                  /* set if (part of) last token was quoted */
 
-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   */
@@ -867,7 +1148,8 @@ static const char *const tokname_array[] = {
         "\1}",
 };
 
-static const char *tokname(int tok)
+static const char *
+tokname(int tok)
 {
         static char buf[16];
 
@@ -878,24 +1160,20 @@ static const char *tokname(int tok)
         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.
- */
+/* 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);
+}
 
+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);
+}
 
 /* Syntax classes */
 #define CWORD 0                 /* character is nothing special */
@@ -1006,7 +1284,8 @@ static const char S_I_T[][3] = {
 
 #define U_C(c) ((unsigned char)(c))
 
-static int SIT(int c, int syntax)
+static int
+SIT(int c, int syntax)
 {
         static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
 #if ENABLE_ASH_ALIAS
@@ -1392,13 +1671,8 @@ 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 char *nodeckstrdup(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 */
@@ -1637,16 +1911,16 @@ static void change_random(const char *);
 # endif
 #endif
 
-/*      init.h        */
-
-static void reset(void);
-
 /*      var.h     */
 
 /*
  * Shell variables.
  */
 
+#if ENABLE_ASH_GETOPTS
+static void getoptsreset(const char *);
+#endif
+
 /* flags */
 #define VEXPORT         0x01    /* variable is exported */
 #define VREADONLY       0x02    /* variable cannot be modified */
@@ -1684,11 +1958,6 @@ static struct localvar *localvars;
 /*
  * Shell variables.
  */
-
-#if ENABLE_ASH_GETOPTS
-static void getoptsreset(const char *);
-#endif
-
 #if ENABLE_LOCALE_SUPPORT
 static void change_lc_all(const char *value);
 static void change_lc_ctype(const char *value);
@@ -1950,46 +2219,6 @@ static void showjobs(FILE *, int);
 
 static void readcmdfile(char *);
  
-/*      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 void *ckmalloc(size_t);
-static void *ckrealloc(void *, size_t);
-static char *savestr(const char *);
-static void *stalloc(size_t);
-static void stunalloc(void *);
-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 char *_STPUTC(int c, char *p)
 {
@@ -1999,8 +2228,6 @@ static char *_STPUTC(int c, char *p)
         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) \
@@ -2070,7 +2297,6 @@ static int nextopt(const char *);
 #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);
@@ -2137,29 +2363,6 @@ static int is_safe_applet(char *name)
 }
 
 
-/*
- * 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 ENABLE_ASH_ALIAS
 static struct alias *atab[ATABSIZE];
 
@@ -2179,13 +2382,13 @@ setalias(const char *name, const char *val)
                 if (!(ap->flag & ALIASINUSE)) {
                         free(ap->val);
                 }
-                ap->val = savestr(val);
+                ap->val = ckstrdup(val);
                 ap->flag &= ~ALIASDEAD;
         } else {
                 /* not found */
                 ap = ckmalloc(sizeof(struct alias));
-                ap->name = savestr(name);
-                ap->val = savestr(val);
+                ap->name = ckstrdup(name);
+                ap->val = ckstrdup(val);
                 ap->flag = 0;
                 ap->next = 0;
                 *app = ap;
@@ -2461,7 +2664,7 @@ static const char * updatepwd(const char *dir)
         if (*dir != '/') {
                 if (curdir == nullstr)
                         return 0;
-                new = stputs(curdir, new);
+                new = stack_putstr(curdir, new);
         }
         new = makestrspace(strlen(dir) + 2, new);
         lim = stackblock() + 1;
@@ -2494,7 +2697,7 @@ static const char * updatepwd(const char *dir)
                                 break;
                         /* fall through */
                 default:
-                        new = stputs(p, new);
+                        new = stack_putstr(p, new);
                         USTPUTC('/', new);
                 }
                 p = strtok(0, "/");
@@ -2582,7 +2785,7 @@ setpwd(const char *val, int setold)
                 if (!val)
                         dir = s;
         } else
-                dir = savestr(val);
+                dir = ckstrdup(val);
         if (oldcur != dir && oldcur != nullstr) {
                 free(oldcur);
         }
@@ -2621,70 +2824,6 @@ static const struct builtincmd bltin = {
 };
 
 
-/*
- * 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);
-                                p = *ap++;
-                                if (p == 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
@@ -3993,15 +4132,6 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
 
 
 /*
- * 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 *
@@ -4606,7 +4736,7 @@ argstr(char *p, int flag)
                 }
                 if (length > 0) {
                         int newloc;
-                        expdest = stnputs(p, length, expdest);
+                        expdest = stack_nputstr(p, length, expdest);
                         newloc = expdest - (char *)stackblock();
                         if (breakall && !inquotes && newloc > startloc) {
                                 recordregion(startloc, newloc, 0);
@@ -7370,7 +7500,7 @@ commandtext(union node *n)
         name = stackblock();
         TRACE(("commandtext: name %p, end %p\n\t\"%s\"\n",
                 name, cmdnextc, cmdnextc));
-        return savestr(name);
+        return ckstrdup(name);
 }
 
 static void
@@ -7753,79 +7883,11 @@ changemail(const char *val)
 #endif /* ASH_MAIL */
 
 /*
- * 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 = (job_warning == 2) ? 1 : 0;
-                        numeof = 0;
-                        evaltree(n, 0);
-                }
-                popstackmark(&smark);
-                skip = evalskip;
-
-                if (skip) {
-                        evalskip = 0;
-                        return skip & SKIPEVAL;
-                }
-        }
-
-        return 0;
-}
-
-
-/*
- * 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 char * find_dot_file(char *name)
+static char *
+find_dot_file(char *name)
 {
         char *fullname;
         const char *path = pathval();
@@ -7851,322 +7913,6 @@ static char * find_dot_file(char *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(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]);
-        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 bb_test(argc, argv);
-}
-#endif
-
-/*      memalloc.c        */
-
-/*
- * Same for malloc, realloc, but returns an error when out of space.
- */
-static void *
-ckrealloc(void * p, size_t nbytes)
-{
-        p = realloc(p, nbytes);
-        if (p == NULL)
-                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 *
-savestr(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;
-}
-
-
-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;
-
-        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 *
-stnputs(const char *s, size_t n, char *p)
-{
-        p = makestrspace(n, p);
-        p = memcpy(p, s, n) + n;
-        return p;
-}
-
-static char *
-stputs(const char *s, char *p)
-{
-        return stnputs(s, strlen(s), p);
-}
-
 /*      mystring.c   */
 
 /*
@@ -8404,7 +8150,7 @@ copynode(union node *n)
                 new->nif.test = copynode(n->nif.test);
                 break;
         case NFOR:
-                new->nfor.var = nodesavestr(n->nfor.var);
+                new->nfor.var = nodeckstrdup(n->nfor.var);
                 new->nfor.body = copynode(n->nfor.body);
                 new->nfor.args = copynode(n->nfor.args);
                 break;
@@ -8420,7 +8166,7 @@ copynode(union node *n)
         case NDEFUN:
         case NARG:
                 new->narg.backquote = copynodelist(n->narg.backquote);
-                new->narg.text = nodesavestr(n->narg.text);
+                new->narg.text = nodeckstrdup(n->narg.text);
                 new->narg.next = copynode(n->narg.next);
                 break;
         case NTO:
@@ -8474,7 +8220,7 @@ copynodelist(struct nodelist *lp)
 
 
 static char *
-nodesavestr(char *s)
+nodeckstrdup(char *s)
 {
         char *rtn = funcstring;
 
@@ -8612,7 +8358,7 @@ setparam(char **argv)
         for (nparam = 0; argv[nparam]; nparam++);
         ap = newparam = ckmalloc((nparam + 1) * sizeof(*ap));
         while (*argv) {
-                *ap++ = savestr(*argv++);
+                *ap++ = ckstrdup(*argv++);
         }
         *ap = NULL;
         freeparam(&shellparam);
@@ -9411,7 +9157,8 @@ makename(void)
         return n;
 }
 
-static void fixredir(union node *n, const char *text, int err)
+static void
+fixredir(union node *n, const char *text, int err)
 {
         TRACE(("Fix redir %s %d\n", text, err));
         if (!err)
@@ -9491,7 +9238,8 @@ parseheredoc(void)
         }
 }
 
-static char peektoken(void)
+static char
+peektoken(void)
 {
         int t;
 
@@ -10453,13 +10201,195 @@ static void setprompt(int whichprompt)
 }
 
 
-static const char *const *findkwd(const char *s)
+/*
+ * Execute a command or commands contained in a string.
+ */
+static int
+evalstring(char *s, int mask)
 {
-        return bsearch(s, tokname_array + KWDOFFSET,
-                        (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
-                        sizeof(const char *), pstrcmp);
+        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;
 }
 
+/*
+ * 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 = (job_warning == 2) ? 1 : 0;
+                        numeof = 0;
+                        evaltree(n, 0);
+                }
+                popstackmark(&smark);
+                skip = evalskip;
+
+                if (skip) {
+                        evalskip = 0;
+                        return skip & SKIPEVAL;
+                }
+        }
+        return 0;
+}
+
+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(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]);
+        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 bb_test(argc, argv);
+}
+#endif
+
+/*
+ * Read a file containing shell functions.
+ */
+static void
+readcmdfile(char *name)
+{
+        setinputfile(name, INPUT_PUSH_FILE);
+        cmdloop(0);
+        popfile();
+}
+
+
 /*      redir.c      */
 
 /*
@@ -10477,7 +10407,8 @@ static const char *const *findkwd(const char *s)
  * Open a file in noclobber mode.
  * The code was copied from bash.
  */
-static int noclobberopen(const char *fname)
+static int
+noclobberopen(const char *fname)
 {
         int r, fd;
         struct stat finfo, finfo2;
@@ -10536,7 +10467,8 @@ static int noclobberopen(const char *fname)
  * data to a pipe.  If the document is short, we can stuff the data in
  * the pipe without forking.
  */
-static int openhere(union node *redir)
+static int
+openhere(union node *redir)
 {
         int pip[2];
         size_t len = 0;
@@ -10633,7 +10565,8 @@ openredirect(union node *redir)
         ash_msg_and_raise_error("cannot open %s: %s", fname, errmsg(errno, "No such file"));
 }
 
-static void dupredirect(union node *redir, int f)
+static void
+dupredirect(union node *redir, int f)
 {
         int fd = redir->nfile.fd;
 
@@ -11208,7 +11141,7 @@ trapcmd(int argc, char **argv)
                         if (LONE_DASH(action))
                                 action = NULL;
                         else
-                                action = savestr(action);
+                                action = ckstrdup(action);
                 }
                 if (trap[signo])
                         free(trap[signo]);
@@ -11614,7 +11547,7 @@ setvareq(char *s, int flags)
                 *vpp = vp;
         }
         if (!(flags & (VTEXTFIXED|VSTACK|VNOSAVE)))
-                s = savestr(s);
+                s = ckstrdup(s);
         vp->text = s;
         vp->flags = flags;
 }
@@ -13311,6 +13244,26 @@ read_profile(const char *name)
                 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();
@@ -13404,9 +13357,9 @@ int ash_main(int argc, char **argv)
         state = 3;
         if (
 #ifndef linux
-                getuid() == geteuid() && getgid() == getegid() &&
+         getuid() == geteuid() && getgid() == getegid() &&
 #endif
-                iflag
+         iflag
         ) {
                 shinit = lookupvar("ENV");
                 if (shinit != NULL && *shinit != '\0') {