Changeset 3621 for branches/3.3/mindi-busybox/shell – MondoRescue

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

-              r3232
+              r3621
 #define JOBS ENABLE_ASH_JOB_CONTROL
-#include <paths.h>
 #include <setjmp.h>
 #include <fnmatch.h>
 #include <sys/times.h>
+#include <sys/utsname.h> /* for setting $HOSTNAME */
 #include "busybox.h" /* for applet_names */
 …
 //config:     Enable support for test builtin in ash.
 //config:
+//config:config ASH_HELP
+//config:   bool "help builtin"
+//config:   default y
+//config:   depends on ASH
+//config:   help
+//config:     Enable help builtin in ash.
+//config:
 //config:config ASH_CMDCMD
 //config:   bool "'command' command to override shell builtins"
 …
 #define xbarrier() do { __asm__ __volatile__ ("": : :"memory"); } while (0)
+#define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
+#define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
 static int isdigit_str9(const char *str)
+{
 …
+}
+/* Was called outcslow(c,FILE*), but c was always '\n' */
 static void
 outcslow(int c, FILE *dest)
+newline_and_flush(FILE *dest)
+{
     INT_OFF;
     putc(c, dest);
+    putc('\n', dest);
     fflush(dest);
     INT_ON;
 …
 #define CTLENDVAR    ((unsigned char)'\203')
 #define CTLBACKQ     ((unsigned char)'\204')
-#define CTLQUOTE 01             /* ored with CTLBACKQ code if in quotes */
-/*      CTLBACKQ | CTLQUOTE == '\205' */
 #define CTLARI       ((unsigned char)'\206')    /* arithmetic expression */
 #define CTLENDARI    ((unsigned char)'\207')
 …
 #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 */
 …
 static const char dolatstr[] ALIGN1 = {
     CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'
+    CTLQUOTEMARK, CTLVAR, VSNORMAL, '@', '=', CTLQUOTEMARK, '\0'
 };
+#define DOLATSTRLEN 6
 #define NCMD      0
 …
         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);
 …
             break;
         case CTLBACKQ:
-        case CTLBACKQ|CTLQUOTE:
             putc('$', fp);
             putc('(', fp);
 …
+    }
     vfprintf(stderr, msg, ap);
     outcslow('\n', stderr);
+    newline_and_flush(stderr);
+}
 …
 #endif
-/* math.h has these, otherwise define our private copies */
-#if !ENABLE_SH_MATH_SUPPORT
-#define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
-#define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
-/*
- * Return the pointer to the first char which is not part of a legal variable name
- * (a letter or underscore followed by letters, underscores, and digits).
- */
-static const char*
-endofname(const char *name)
+{
-    if (!is_name(*name))
-        return name;
-    while (*++name) {
-        if (!is_in_name(*name))
-            break;
+    }
-    return name;
+}
-#endif
 /*
  * Compares two strings up to the first = or '\0'.  The first
 …
     while ((c = *p) == (d = *q)) {
         if (!c || c == '=')
+        if (c == '\0' || c == '=')
             goto out;
         p++;
 …
+}
+static void reinit_unicode_for_ash(void)
+{
+    /* Unicode support should be activated even if LANG is set
+     * _during_ shell execution, not only if it was set when
+     * shell was started. Therefore, re-check LANG every time:
+     */
+    if (ENABLE_FEATURE_CHECK_UNICODE_IN_ENV
+     || ENABLE_UNICODE_USING_LOCALE
+    ) {
+        const char *s = lookupvar("LC_ALL");
+        if (!s) s = lookupvar("LC_CTYPE");
+        if (!s) s = lookupvar("LANG");
+        reinit_unicode(s);
+    }
+}
 /*
  * Search the environment of a builtin command.
 …
 static void FAST_FUNC
 setvar2(const char *name, const char *val)
+setvar0(const char *name, const char *val)
+{
     setvar(name, val, 0);
 …
             INT_ON;
         } else {
             setvar(s, 0, 0);
+            setvar0(s, NULL);
             vp->flags &= ~VEXPORT;
+        }
 …
             USTPUTC('/', new);
+        }
         p = strtok(0, "/");
+        p = strtok(NULL, "/");
+    }
     if (new > lim)
 …
 # define SIT_ITEM(a,b,c,d) (a | (b << 4) | (c << 8))
 #endif
 static const uint16_t S_I_T[] = {
+static const uint16_t S_I_T[] ALIGN2 = {
 #if ENABLE_ASH_ALIAS
     SIT_ITEM(CSPCL   , CIGN     , CIGN , CIGN   ),    /* 0, PEOA */
 …
 #else   /* !USE_SIT_FUNCTION */
 static const uint8_t syntax_index_table[] = {
+static const uint8_t syntax_index_table[] ALIGN1 = {
     /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
     /*   0      */ CWORD_CWORD_CWORD_CWORD,
 …
 #define SHOW_PIDS       0x02    /* show individual pids, not just one line per job */
 #define SHOW_CHANGED    0x04    /* only jobs whose state has changed */
+#define SHOW_STDERR     0x08    /* print to stderr (else stdout) */
 /*
 …
     if (is_number(p)) {
         num = atoi(p);
         if (num < njobs) {
+        if (num <= njobs) {
             jp = jobtab + num - 1;
             if (jp->used)
 …
     for (ps = jp->ps + 1; ps < psend; ps++)
         printf(" | %s", ps->ps_cmd);
     outcslow('\n', stdout);
+    newline_and_flush(stdout);
     flush_stdout_stderr();
+}
 …
 static int
 sprint_status(char *s, int status, int sigonly)
+sprint_status48(char *s, int status, int sigonly)
+{
     int col;
 …
     col = 0;
     if (!WIFEXITED(status)) {
+#if JOBS
+        if (WIFSTOPPED(status))
+        if (JOBS && WIFSTOPPED(status))
             st = WSTOPSIG(status);
         else
-#endif
             st = WTERMSIG(status);
         if (sigonly) {
             if (st == SIGINT || st == SIGPIPE)
                 goto out;
+#if JOBS
+            if (WIFSTOPPED(status))
+            if (JOBS && WIFSTOPPED(status))
                 goto out;
-#endif
+        }
         st &= 0x7f;
 …
         col = fmtstr(s, 32, strsignal(st));
         if (WCOREDUMP(status)) {
+            col += fmtstr(s + col, 16, " (core dumped)");
+            strcpy(s + col, " (core dumped)");
+            col += sizeof(" (core dumped)")-1;
+        }
     } else if (!sigonly) {
         st = WEXITSTATUS(status);
+        if (st)
+            col = fmtstr(s, 16, "Done(%d)", st);
+        else
+            col = fmtstr(s, 16, "Done");
+        col = fmtstr(s, 16, (st ? "Done(%d)" : "Done"), st);
+    }
  out:
 …
     struct job *jp;
     struct job *thisjob;
-    int state;
     TRACE(("dowait(0x%x) called\n", wait_flags));
 …
     thisjob = NULL;
     for (jp = curjob; jp; jp = jp->prev_job) {
+        int jobstate;
         struct procstat *ps;
         struct procstat *psend;
         if (jp->state == JOBDONE)
             continue;
         state = JOBDONE;
+        jobstate = JOBDONE;
         ps = jp->ps;
         psend = ps + jp->nprocs;
 …
+            }
             if (ps->ps_status == -1)
                 state = JOBRUNNING;
+                jobstate = JOBRUNNING;
 #if JOBS
             if (state == JOBRUNNING)
+            if (jobstate == JOBRUNNING)
                 continue;
             if (WIFSTOPPED(ps->ps_status)) {
                 jp->stopstatus = ps->ps_status;
                 state = JOBSTOPPED;
+                jobstate = JOBSTOPPED;
+            }
 #endif
         } while (++ps < psend);
+        if (thisjob)
+            goto gotjob;
+    }
+        if (!thisjob)
+            continue;
+        /* Found the job where one of its processes changed its state.
+         * Is there at least one live and running process in this job? */
+        if (jobstate != JOBRUNNING) {
+            /* No. All live processes in the job are stopped
+             * (JOBSTOPPED) or there are no live processes (JOBDONE)
+             */
+            thisjob->changed = 1;
+            if (thisjob->state != jobstate) {
+                TRACE(("Job %d: changing state from %d to %d\n",
+                    jobno(thisjob), thisjob->state, jobstate));
+                thisjob->state = jobstate;
 #if JOBS
+    if (!WIFSTOPPED(status))
+#endif
+                if (jobstate == JOBSTOPPED)
+                    set_curjob(thisjob, CUR_STOPPED);
+#endif
+            }
+        }
+        goto out;
+    }
+    /* The process wasn't found in job list */
+    if (JOBS && !WIFSTOPPED(status))
         jobless--;
-    goto out;
- 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));
-            thisjob->state = state;
-#if JOBS
-            if (state == JOBSTOPPED) {
-                set_curjob(thisjob, CUR_STOPPED);
+            }
-#endif
+        }
+    }
  out:
     INT_ON;
 …
         int len;
         len = sprint_status(s, status, 1);
+        len = sprint_status48(s, status, 1);
         if (len) {
             s[len] = '\n';
 …
 #if JOBS
 static void
 showjob(FILE *out, struct job *jp, int mode)
+showjob(struct job *jp, int mode)
+{
     struct procstat *ps;
 …
     int col;
     int indent_col;
+    char s[80];
+    char s[16 + 16 + 48];
+    FILE *out = (mode & SHOW_STDERR ? stderr : stdout);
     ps = jp->ps;
 …
         if (jp->state == JOBSTOPPED)
             status = jp->stopstatus;
         col += sprint_status(s + col, status, 0);
+        col += sprint_status48(s + col, status, 0);
+    }
     /* By now, "[JOBID]*  [maybe PID] STATUS" is printed */
 …
         );
     } while (++ps != psend);
     outcslow('\n', out);
+    newline_and_flush(out);
     jp->changed = 0;
 …
  */
 static void
 showjobs(FILE *out, int mode)
+showjobs(int mode)
+{
     struct job *jp;
 …
     for (jp = curjob; jp; jp = jp->prev_job) {
         if (!(mode & SHOW_CHANGED) || jp->changed) {
             showjob(out, jp, mode);
+            showjob(jp, mode);
+        }
+    }
 …
     if (*argv) {
         do
             showjob(stdout, getjob(*argv, 0), mode);
+            showjob(getjob(*argv, 0), mode);
         while (*++argv);
     } else {
         showjobs(stdout, mode);
+        showjobs(mode);
+    }
 …
             else
                 str = "${";
+            if (!(subtype & VSQUOTE) == !(quoted & 1))
+                goto dostr;
+            quoted ^= 1;
+            c = '"';
+            break;
+            goto dostr;
         case CTLENDVAR:
             str = "\"}" + !(quoted & 1);
 …
         case CTLBACKQ:
             str = "$(...)";
-            goto dostr;
-        case CTLBACKQ+CTLQUOTE:
-            str = "\"$(...)\"";
             goto dostr;
 #if ENABLE_SH_MATH_SUPPORT
 …
          */
         /* Save trap handler strings for trap builtin to print */
         trap_ptr = memcpy(xmalloc(sizeof(trap)), trap, sizeof(trap));
+        trap_ptr = xmemdup(trap, sizeof(trap));
         /* Fall through into clearing traps */
+    }
 …
     int i;
     if (--g_nullredirs >= 0)
+    if (--g_nullredirs >= 0 || redirlist == NULL)
         return;
     INT_OFF;
 …
     math_state.lookupvar = lookupvar;
     math_state.setvar    = setvar2;
+    math_state.setvar    = setvar0;
     //math_state.endofname = endofname;
 …
 #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_QPAT        0x20    /* pattern in quoted parameter expansion */
 #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 */
+#define EXP_QUOTED      0x100   /* expand word in double quotes */
 /*
  * 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 */
+#define RMESCAPE_SLASH  0x20    /* Stop globbing after slash */
+/* Add CTLESC when necessary. */
+#define QUOTES_ESC     (EXP_FULL | EXP_CASE | EXP_QPAT | EXP_REDIR)
+/* Do not skip NUL characters. */
+#define QUOTES_KEEPNUL EXP_TILDE
 /*
 …
     int len;
     expdest = makestrspace(32, expdest);
     len = fmtstr(expdest, 32, ARITH_FMT, num);
+    expdest = makestrspace(sizeof(arith_t)*3 + 2, expdest);
+    len = fmtstr(expdest, sizeof(arith_t)*3 + 2, ARITH_FMT, num);
     STADJUST(len, expdest);
     return len;
 …
 rmescapes(char *str, int flag)
+{
+    static const char qchars[] ALIGN1 = { CTLESC, CTLQUOTEMARK, '\0' };
+    static const char qchars[] ALIGN1 = {
+        IF_ASH_BASH_COMPAT('/',) CTLESC, CTLQUOTEMARK, '\0' };
     char *p, *q, *r;
 …
     unsigned protect_against_glob;
     unsigned globbing;
+    p = strpbrk(str, qchars);
+    IF_ASH_BASH_COMPAT(unsigned slash = flag & RMESCAPE_SLASH;)
+    p = strpbrk(str, qchars IF_ASH_BASH_COMPAT(+ !slash));
     if (!p)
         return str;
 …
+    }
     inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED;
+    inquotes = 0;
     globbing = flag & RMESCAPE_GLOB;
     protect_against_glob = globbing;
     while (*p) {
         if ((unsigned char)*p == CTLQUOTEMARK) {
-// TODO: if no RMESCAPE_QUOTED in flags, inquotes never becomes 0
-// (alternates between RMESCAPE_QUOTED and ~RMESCAPE_QUOTED). Is it ok?
 // Note: both inquotes and protect_against_glob only affect whether
 // CTLESC,<ch> gets converted to <ch> or to \<ch>
 …
             continue;
+        }
+        if (*p == '\\') {
+        if ((unsigned char)*p == CTLESC) {
+            p++;
+            if (protect_against_glob) {
+                *q++ = '\\';
+            }
+        } else if (*p == '\\' && !inquotes) {
             /* naked back slash */
             protect_against_glob = 0;
             goto copy;
+        }
+        if ((unsigned char)*p == CTLESC) {
+            p++;
+            if (protect_against_glob && inquotes && *p != '/') {
+                *q++ = '\\';
+            }
+        }
+#if ENABLE_ASH_BASH_COMPAT
+        else if (*p == '/' && slash) {
+            /* stop handling globbing and mark location of slash */
+            globbing = slash = 0;
+            *p = CTLESC;
+        }
+#endif
         protect_against_glob = globbing;
  copy:
 …
  */
 static char *
+preglob(const char *pattern, int quoted, int flag)
+{
+    flag |= RMESCAPE_GLOB;
+    if (quoted) {
+        flag |= RMESCAPE_QUOTED;
+    }
+    return rmescapes((char *)pattern, flag);
+preglob(const char *pattern, int flag)
+{
+    return rmescapes((char *)pattern, flag | RMESCAPE_GLOB);
+}
 …
 memtodest(const char *p, size_t len, int syntax, int quotes)
+{
+    char *q = expdest;
+    q = makestrspace(quotes ? len * 2 : len, q);
+    while (len--) {
+    char *q;
+    if (!len)
+        return;
+    q = makestrspace((quotes & QUOTES_ESC) ? len * 2 : len, expdest);
+    do {
         unsigned char c = *p++;
+        if (c == '\0')
+        if (c) {
+            int n = SIT(c, syntax);
+            if ((quotes & QUOTES_ESC) &&
+                    ((n == CCTL) ||
+                    (((quotes & EXP_FULL) || syntax != BASESYNTAX) &&
+                    n == CBACK)))
+                USTPUTC(CTLESC, q);
+        } else if (!(quotes & QUOTES_KEEPNUL))
             continue;
-        if (quotes) {
-            int n = SIT(c, syntax);
-            if (n == CCTL || n == CBACK)
-                USTPUTC(CTLESC, q);
+        }
         USTPUTC(c, q);
+    }
+    } while (--len);
     expdest = q;
+}
 static void
+static size_t
 strtodest(const char *p, int syntax, int quotes)
+{
+    memtodest(p, strlen(p), syntax, quotes);
+    size_t len = strlen(p);
+    memtodest(p, len, syntax, quotes);
+    return len;
+}
 …
     struct passwd *pw;
     const char *home;
+    int quotes = flags & (EXP_FULL | EXP_CASE | EXP_REDIR);
+    int startloc;
+    int quotes = flags & QUOTES_ESC;
     name = p + 1;
 …
         goto lose;
     *p = c;
-    startloc = expdest - (char *)stackblock();
     strtodest(home, SQSYNTAX, quotes);
-    recordregion(startloc, expdest - (char *)stackblock(), 0);
     return p;
  lose:
 …
  */
 static void
 expbackq(union node *cmd, int quoted, int quotes)
+expbackq(union node *cmd, int flag)
+{
     struct backcmd in;
 …
     char *dest;
     int startloc;
     int syntax = quoted ? DQSYNTAX : BASESYNTAX;
+    int syntax = flag & EXP_QUOTED ? DQSYNTAX : BASESYNTAX;
     struct stackmark smark;
 …
         goto read;
     for (;;) {
         memtodest(p, i, syntax, quotes);
+        memtodest(p, i, syntax, flag & QUOTES_ESC);
  read:
         if (in.fd < 0)
             break;
         i = nonblock_immune_read(in.fd, buf, sizeof(buf), /*loop_on_EINTR:*/ 1);
+        i = nonblock_immune_read(in.fd, buf, sizeof(buf));
         TRACE(("expbackq: read returns %d\n", i));
         if (i <= 0)
 …
     expdest = dest;
     if (quoted == 0)
+    if (!(flag & EXP_QUOTED))
         recordregion(startloc, dest - (char *)stackblock(), 0);
     TRACE(("evalbackq: size:%d:'%.*s'\n",
 …
  */
 static void
 expari(int quotes)
+expari(int flag)
+{
     char *p, *start;
     int begoff;
-    int flag;
     int len;
 …
     removerecordregions(begoff);
-    flag = p[1];
     expdest = p;
     if (quotes)
         rmescapes(p + 2, 0);
     len = cvtnum(ash_arith(p + 2));
     if (flag != '"')
+    if (flag & QUOTES_ESC)
+        rmescapes(p + 1, 0);
+    len = cvtnum(ash_arith(p + 1));
+    if (!(flag & EXP_QUOTED))
         recordregion(begoff, begoff + len, 0);
+}
 …
         CTLVAR,
         CTLBACKQ,
-        CTLBACKQ | CTLQUOTE,
 #if ENABLE_SH_MATH_SUPPORT
         CTLENDARI,
 …
     };
     const char *reject = spclchars;
+    int quotes = flags & (EXP_FULL | EXP_CASE | EXP_REDIR); /* do CTLESC */
+    int breakall = flags & EXP_WORD;
+    int breakall = (flags & (EXP_WORD | EXP_QUOTED)) == EXP_WORD;
     int inquotes;
     size_t length;
 …
  tilde:
         q = p;
-        if ((unsigned char)*q == CTLESC && (flags & EXP_QWORD))
-            q++;
         if (*q == '~')
             p = exptilde(p, q, flags);
 …
             goto breakloop;
         case CTLQUOTEMARK:
+            inquotes ^= EXP_QUOTED;
             /* "$@" syntax adherence hack */
+            if (!inquotes
+             && memcmp(p, dolatstr, 4) == 0
+             && (  p[4] == (char)CTLQUOTEMARK
+                || (p[4] == (char)CTLENDVAR && p[5] == (char)CTLQUOTEMARK)
+                )
+            ) {
+                p = evalvar(p + 1, flags, /* var_str_list: */ NULL) + 1;
+            if (inquotes && !memcmp(p, dolatstr + 1, DOLATSTRLEN - 1)) {
+                p = evalvar(p + 1, flags | inquotes, /* var_str_list: */ NULL) + 1;
                 goto start;
+            }
-            inquotes = !inquotes;
  addquote:
             if (quotes) {
+            if (flags & QUOTES_ESC) {
                 p--;
                 length++;
 …
             startloc++;
             length++;
+            /*
+             * Quoted parameter expansion pattern: remove quote
+             * unless inside inner quotes or we have a literal
+             * backslash.
+             */
+            if (((flags | inquotes) & (EXP_QPAT | EXP_QUOTED)) ==
+                EXP_QPAT && *p != '\\')
+                break;
             goto addquote;
         case CTLVAR:
             TRACE(("argstr: evalvar('%s')\n", p));
             p = evalvar(p, flags, var_str_list);
+            p = evalvar(p, flags | inquotes, var_str_list);
             TRACE(("argstr: evalvar:'%s'\n", (char *)stackblock()));
             goto start;
         case CTLBACKQ:
+            c = '\0';
+        case CTLBACKQ|CTLQUOTE:
+            expbackq(argbackq->n, c, quotes);
+            expbackq(argbackq->n, flags | inquotes);
             argbackq = argbackq->next;
             goto start;
 …
         case CTLENDARI:
             p--;
             expari(quotes);
+            expari(flags | inquotes);
             goto start;
 #endif
 …
+}
-#if ENABLE_ASH_BASH_COMPAT
-static char *
-parse_sub_pattern(char *arg, int varflags)
+{
-    char *idx, *repl = NULL;
-    unsigned char c;
-    //char *org_arg = arg;
-    //bb_error_msg("arg:'%s' varflags:%x", arg, varflags);
-    idx = arg;
-    while (1) {
-        c = *arg;
-        if (!c)
-            break;
-        if (c == '/') {
-            /* Only the first '/' seen is our separator */
-            if (!repl) {
-                repl = idx + 1;
-                c = '\0';
+            }
+        }
-        *idx++ = c;
-        arg++;
-        /*
-         * Example: v='ab\c'; echo ${v/\\b/_\\_\z_}
-         * The result is a_\_z_c (not a\_\_z_c)!
+         *
-         * Enable debug prints in this function and you'll see:
-         * ash: arg:'\\b/_\\_z_' varflags:d
-         * ash: pattern:'\\b' repl:'_\_z_'
-         * That is, \\b is interpreted as \\b, but \\_ as \_!
-         * IOW: search pattern and replace string treat backslashes
-         * differently! That is the reason why we check repl below:
-         */
-        if (c == '\\' && *arg == '\\' && repl && !(varflags & VSQUOTE))
-            arg++; /* skip both '\', not just first one */
+    }
-    *idx = c; /* NUL */
-    //bb_error_msg("pattern:'%s' repl:'%s'", org_arg, repl);
-    return repl;
+}
-#endif /* ENABLE_ASH_BASH_COMPAT */
 static const char *
 subevalvar(char *p, char *varname, int strloc, int subtype,
         int startloc, int varflags, int quotes, struct strlist *var_str_list)
+        int startloc, int varflags, int flag, struct strlist *var_str_list)
+{
     struct nodelist *saveargbackq = argbackq;
+    int quotes = flag & QUOTES_ESC;
     char *startp;
     char *loc;
     char *rmesc, *rmescend;
     char *str;
     IF_ASH_BASH_COMPAT(const char *repl = NULL;)
+    IF_ASH_BASH_COMPAT(char *repl = NULL;)
     IF_ASH_BASH_COMPAT(int pos, len, orig_len;)
     int saveherefd = herefd;
 …
     herefd = -1;
+    argstr(p, (subtype != VSASSIGN && subtype != VSQUESTION) ? EXP_CASE : 0,
+    argstr(p, EXP_TILDE | (subtype != VSASSIGN && subtype != VSQUESTION ?
+            (flag & (EXP_QUOTED | EXP_QPAT) ? EXP_QPAT : EXP_CASE) : 0),
             var_str_list);
     STPUTC('\0', expdest);
 …
     switch (subtype) {
     case VSASSIGN:
         setvar(varname, startp, 0);
+        setvar0(varname, startp);
         amount = startp - expdest;
         STADJUST(amount, expdest);
 …
+            }
+        }
+        if (pos >= orig_len) {
+        if (pos < 0) {
+            /* ${VAR:$((-n)):l} starts n chars from the end */
+            pos = orig_len + pos;
+        }
+        if ((unsigned)pos >= orig_len) {
+            /* apart from obvious ${VAR:999999:l},
+             * covers ${VAR:$((-9999999)):l} - result is ""
+             * (bash-compat)
+             */
             pos = 0;
             len = 0;
 …
     rmescend--;
     str = (char *)stackblock() + strloc;
+    preglob(str, varflags & VSQUOTE, 0);
+    /*
+     * Example: v='a\bc'; echo ${v/\\b/_\\_\z_}
+     * The result is a_\_z_c (not a\_\_z_c)!
+     *
+     * The search pattern and replace string treat backslashes differently!
+     * RMESCAPE_SLASH causes preglob to work differently on the pattern
+     * and string.  It's only used on the first call.
+     */
+    preglob(str, IF_ASH_BASH_COMPAT(
+        (subtype == VSREPLACE || subtype == VSREPLACEALL) && !repl ?
+            RMESCAPE_SLASH :) 0);
 #if ENABLE_ASH_BASH_COMPAT
 …
         if (!repl) {
             repl = parse_sub_pattern(str, varflags);
             //bb_error_msg("repl:'%s'", repl);
             if (!repl)
+            if ((repl=strchr(str, CTLESC)))
+                *repl++ = '\0';
+            else
                 repl = nullstr;
+        }
+        //bb_error_msg("str:'%s' repl:'%s'", str, repl);
         /* If there's no pattern to match, return the expansion unmolested */
 …
     int num;
     int i;
-    int sepq = 0;
     ssize_t len = 0;
+    int sep;
+    int quoted = flags & EXP_QUOTED;
     int subtype = varflags & VSTYPE;
     int quotes = flags & (EXP_FULL | EXP_CASE | EXP_REDIR);
     int quoted = varflags & VSQUOTE;
+    int discard = subtype == VSPLUS || subtype == VSLENGTH;
+    int quotes = (discard ? 0 : (flags & QUOTES_ESC)) | QUOTES_KEEPNUL;
     int syntax = quoted ? DQSYNTAX : BASESYNTAX;
+    sep = quoted ? ((flags & EXP_FULL) << CHAR_BIT) : 0;
     switch (*name) {
 …
     case '@': {
         char **ap;
         int sep;
+        char sepc;
         if (quoted && (flags & EXP_FULL)) {
 …
     case '*':
         sep = ifsset() ? (unsigned char)(ifsval()[0]) : ' ';
-        i = SIT(sep, syntax);
-        if (quotes && (i == CCTL || i == CBACK))
-            sepq = 1;
  param:
         ap = shellparam.p;
+        sepc = sep;
         if (!ap)
             return -1;
         while ((p = *ap++) != NULL) {
+            size_t partlen;
+            partlen = strlen(p);
+            len += partlen;
+            if (!(subtype == VSPLUS || subtype == VSLENGTH))
+                memtodest(p, partlen, syntax, quotes);
+            len += strtodest(p, syntax, quotes);
             if (*ap && sep) {
-                char *q;
                 len++;
+                if (subtype == VSPLUS || subtype == VSLENGTH) {
+                    continue;
+                }
+                q = expdest;
+                if (sepq)
+                    STPUTC(CTLESC, q);
+                /* note: may put NUL despite sep != 0
+                 * (see sep = 1 << CHAR_BIT above) */
+                STPUTC(sep, q);
+                expdest = q;
+                memtodest(&sepc, 1, syntax, quotes);
+            }
+        }
         return len;
+        break;
     } /* case '@' and '*' */
     case '0':
 …
             return -1;
+        len = strlen(p);
+        if (!(subtype == VSPLUS || subtype == VSLENGTH))
+            memtodest(p, len, syntax, quotes);
+        return len;
+    }
+    if (subtype == VSPLUS || subtype == VSLENGTH)
+        len = strtodest(p, syntax, quotes);
+#if ENABLE_UNICODE_SUPPORT
+        if (subtype == VSLENGTH && len > 0) {
+            reinit_unicode_for_ash();
+            if (unicode_status == UNICODE_ON) {
+                STADJUST(-len, expdest);
+                discard = 0;
+                len = unicode_strlen(p);
+            }
+        }
+#endif
+        break;
+    }
+    if (discard)
         STADJUST(-len, expdest);
     return len;
 …
     char varflags;
     char subtype;
     char quoted;
+    int quoted;
     char easy;
     char *var;
 …
     varflags = (unsigned char) *p++;
     subtype = varflags & VSTYPE;
     quoted = varflags & VSQUOTE;
+    quoted = flags & EXP_QUOTED;
     var = p;
     easy = (!quoted || (*var == '@' && shellparam.nparam));
 …
             argstr(
                 p,
                 flags | (quoted ? EXP_TILDE|EXP_QWORD : EXP_TILDE|EXP_WORD),
+                flags | EXP_TILDE | EXP_WORD,
                 var_str_list
             );
 …
             if (subevalvar(p, var, /* strloc: */ 0,
                     subtype, startloc, varflags,
                     /* quotes: */ 0,
+                    /* quotes: */ flags & ~QUOTES_ESC,
                     var_str_list)
             ) {
 …
         patloc = expdest - (char *)stackblock();
         if (NULL == subevalvar(p, /* varname: */ NULL, patloc, subtype,
+                startloc, varflags,
+                /* quotes: */ flags & (EXP_FULL | EXP_CASE | EXP_REDIR),
+                var_str_list)
+        ) {
+                startloc, varflags, flags, var_str_list)) {
             int amount = expdest - (
                 (char *)stackblock() + patloc - 1
 …
             if (c == CTLESC)
                 p++;
             else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
+            else if (c == CTLBACKQ) {
                 if (varlen >= 0)
                     argbackq = argbackq->next;
 …
     int atend;
     int matchdot;
+    int esc;
     metaflag = 0;
     start = name;
     for (p = name; *p; p++) {
+    for (p = name; esc = 0, *p; p += esc + 1) {
         if (*p == '*' || *p == '?')
             metaflag = 1;
 …
+                }
+            }
+        } else if (*p == '\\')
+            p++;
+        else if (*p == '/') {
+            if (metaflag)
+                goto out;
+            start = p + 1;
+        }
+    }
+ out:
+        } else {
+            if (*p == '\\')
+                esc++;
+            if (p[esc] == '/') {
+                if (metaflag)
+                    break;
+                start = p + esc + 1;
+            }
+        }
+    }
     if (metaflag == 0) {    /* we've reached the end of the file name */
         if (enddir != expdir)
 …
     } else {
         atend = 0;
+        *endname++ = '\0';
+        *endname = '\0';
+        endname += esc + 1;
+    }
     matchdot = 0;
 …
     closedir(dirp);
     if (!atend)
         endname[-1] = '/';
+        endname[-esc - 1] = esc ? '\\' : '/';
+}
 …
         INT_OFF;
         p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+        p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+        {
             int i = strlen(str->text);
 …
+{
     herefd = fd;
     expandarg(arg, (struct arglist *)NULL, 0);
+    expandarg(arg, (struct arglist *)NULL, EXP_QUOTED);
     full_write(fd, stackblock(), expdest - (char *)stackblock());
+}
 …
 patmatch(char *pattern, const char *string)
+{
     return pmatch(preglob(pattern, 0, 0), string);
+    return pmatch(preglob(pattern, 0), string);
+}
 …
     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
+enum {
+    TEOF,
+    TNL,
+    TREDIR,
+    TWORD,
+    TSEMI,
+    TBACKGND,
+    TAND,
+    TOR,
+    TPIPE,
+    TLP,
+    TRP,
+    TENDCASE,
+    TENDBQUOTE,
+    TNOT,
+    TCASE,
+    TDO,
+    TDONE,
+    TELIF,
+    TELSE,
+    TESAC,
+    TFI,
+    TFOR,
+#if ENABLE_ASH_BASH_COMPAT
+    TFUNCTION,
+#endif
+    TIF,
+    TIN,
+    TTHEN,
+    TUNTIL,
+    TWHILE,
+    TBEGIN,
+    TEND
+};
 typedef smallint token_id_t;
 …
     "\1fi",
     "\0for",
+#if ENABLE_ASH_BASH_COMPAT
+    "\0function",
+#endif
     "\0if",
     "\0in",
 …
  */
 static int
 describe_command(char *command, int describe_command_verbose)
+describe_command(char *command, const char *path, int describe_command_verbose)
+{
     struct cmdentry entry;
 …
     const struct alias *ap;
 #endif
+    const char *path = pathval();
+    path = path ? path : pathval();
     if (describe_command_verbose) {
 …
+    }
     while (argv[i]) {
         err |= describe_command(argv[i++], verbose);
+        err |= describe_command(argv[i++], NULL, verbose);
+    }
     return err;
 …
         VERIFY_VERBOSE = 2,
     } verify = 0;
+    const char *path = NULL;
     while ((c = nextopt("pvV")) != '\0')
 …
             abort();
 #endif
+        else
+            path = bb_default_path;
     /* Mimic bash: just "command -v" doesn't complain, it's a nop */
     if (verify && (*argptr != NULL)) {
         return describe_command(*argptr, verify - VERIFY_BRIEF);
+        return describe_command(*argptr, path, verify - VERIFY_BRIEF);
+    }
 …
 #define EV_BACKCMD 04           /* command executing within back quotes */
 static const uint8_t nodesize[N_NUMBER] = {
+static const uint8_t nodesize[N_NUMBER] ALIGN1 = {
     [NCMD     ] = SHELL_ALIGN(sizeof(struct ncmd)),
     [NPIPE    ] = SHELL_ALIGN(sizeof(struct npipe)),
 …
             (flags | ((is_or >> 1) - 1)) & EV_TESTED
         );
         if (!exitstatus == is_or)
+        if ((!exitstatus) == is_or)
             break;
         if (!evalskip) {
 …
     arglist.lastp = &arglist.list;
     for (argp = n->nfor.args; argp; argp = argp->narg.next) {
         expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
+        expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
         /* XXX */
         if (evalskip)
 …
     flags &= EV_TESTED;
     for (sp = arglist.list; sp; sp = sp->next) {
         setvar(n->nfor.var, sp->text, 0);
+        setvar0(n->nfor.var, sp->text);
         evaltree(n->nfor.body, flags);
         if (evalskip) {
 …
             /* note: ash and hush share this string */
             out1fmt("\n\n%s %s\n"
                 "Enter 'help' for a list of built-in commands."
                 "\n\n",
+                IF_ASH_HELP("Enter 'help' for a list of built-in commands.\n")
+                "\n",
                 bb_banner,
                 "built-in shell (ash)"
 …
         cp = *++argv;
         if (!cp)
             return 0;
+            return NULL;
         if (*cp++ != '-')
             break;
 …
             break;
         if (c == '-' && !*cp) {
+            argv++;
+            if (!*++argv)
+                return NULL;
             break;
+        }
 …
             default:
                 /* run 'typecmd' for other options */
                 return 0;
+                return NULL;
+            }
             c = *cp++;
 …
  * 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.
+ * "-" as a special case: it makes changes to "set +-options" local
+ * (options will be restored on return from the function).
  */
 static void
 …
     struct var **vpp;
     struct var *vp;
+    char *eq = strchr(name, '=');
     INT_OFF;
+    lvp = ckzalloc(sizeof(struct localvar));
+    /* Cater for duplicate "local". Examples:
+     * x=0; f() { local x=1; echo $x; local x; echo $x; }; f; echo $x
+     * x=0; f() { local x=1; echo $x; local x=2; echo $x; }; f; echo $x
+     */
+    lvp = localvars;
+    while (lvp) {
+        if (lvp->vp && varcmp(lvp->vp->var_text, name) == 0) {
+            if (eq)
+                setvareq(name, 0);
+            /* else:
+             * it's a duplicate "local VAR" declaration, do nothing
+             */
+            return;
+        }
+        lvp = lvp->next;
+    }
+    lvp = ckzalloc(sizeof(*lvp));
     if (LONE_DASH(name)) {
         char *p;
 …
         vp = NULL;
     } else {
-        char *eq;
         vpp = hashvar(name);
         vp = *findvar(vpp, name);
-        eq = strchr(name, '=');
         if (vp == NULL) {
+            /* variable did not exist yet */
             if (eq)
                 setvareq(name, VSTRFIXED);
 …
             lvp->text = vp->var_text;
             lvp->flags = vp->flags;
+            /* make sure neither "struct var" nor string gets freed
+             * during (un)setting:
+             */
             vp->flags |= VSTRFIXED|VTEXTFIXED;
             if (eq)
                 setvareq(name, 0);
+            else
+                /* "local VAR" unsets VAR: */
+                setvar0(name, NULL);
+        }
+    }
 …
+{
     char *name;
+    if (!funcnest)
+        ash_msg_and_raise_error("not in a function");
     argv = argptr;
 …
 static int getoptscmd(int, char **) FAST_FUNC;
 #endif
 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
+#if ENABLE_ASH_HELP
 static int helpcmd(int, char **) FAST_FUNC;
+#endif
+#if MAX_HISTORY
+static int historycmd(int, char **) FAST_FUNC;
 #endif
 #if ENABLE_SH_MATH_SUPPORT
 …
 #endif
     { BUILTIN_NOSPEC        "hash"    , hashcmd    },
 #if !ENABLE_FEATURE_SH_EXTRA_QUIET
+#if ENABLE_ASH_HELP
     { BUILTIN_NOSPEC        "help"    , helpcmd    },
+#endif
+#if MAX_HISTORY
+    { BUILTIN_NOSPEC        "history" , historycmd },
 #endif
 #if JOBS
 …
             int exit_status;
             int i = exception_type;
             if (i == EXEXIT)
+            if (i == EXEXIT || i == EXEXEC)
                 goto raise;
             exit_status = 2;
 …
             goto raise;
         break;
     } /* switch */
 …
          * However I implemented that within libedit itself.
          */
         setvar("_", lastarg, 0);
+        setvar0("_", lastarg);
+    }
     popstackmark(&smark);
 …
  retry:
     if (!iflag || g_parsefile->pf_fd != STDIN_FILENO)
         nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1, /*loop_on_EINTR:*/ 1);
+        nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
     else {
         int timeout = -1;
 …
         line_input_state->path_lookup = pathval();
 # endif
+        /* Unicode support should be activated even if LANG is set
+         * _during_ shell execution, not only if it was set when
+         * shell was started. Therefore, re-check LANG every time:
+         */
+        reinit_unicode(lookupvar("LANG"));
+        reinit_unicode_for_ash();
         nr = read_line_input(line_input_state, cmdedit_prompt, buf, IBUFSIZ, timeout);
         if (nr == 0) {
 …
 # if ENABLE_ASH_IDLE_TIMEOUT
             else if (errno == EAGAIN && timeout > 0) {
                 printf("\007timed out waiting for input: auto-logout\n");
+                puts("\007timed out waiting for input: auto-logout");
                 exitshell();
+            }
 …
+    }
 #else
     nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1, /*loop_on_EINTR:*/ 1);
+    nr = nonblock_immune_read(g_parsefile->pf_fd, buf, IBUFSIZ - 1);
 #endif
 …
 #if ENABLE_ASH_MAIL
+#define MAXMBOXES 10
+/* times of mailboxes */
+static time_t mailtime[MAXMBOXES];
+/* Hash of mtimes of mailboxes */
+static unsigned mailtime_hash;
 /* Set if MAIL or MAILPATH is changed. */
 static smallint mail_var_path_changed;
 …
     char *p;
     char *q;
     time_t *mtp;
+    unsigned new_hash;
     struct stackmark smark;
     struct stat statb;
 …
     setstackmark(&smark);
     mpath = mpathset() ? mpathval() : mailval();
+    for (mtp = mailtime; mtp < mailtime + MAXMBOXES; mtp++) {
+    new_hash = 0;
+    for (;;) {
         p = path_advance(&mpath, nullstr);
         if (p == NULL)
 …
         q[-1] = '\0';                   /* delete trailing '/' */
         if (stat(p, &statb) < 0) {
-            *mtp = 0;
             continue;
+        }
         if (!mail_var_path_changed && statb.st_mtime != *mtp) {
             fprintf(
                 stderr, "%s\n",
                 pathopt ? pathopt : "you have mail"
             );
+        }
         *mtp = statb.st_mtime;
+        /* Very simplistic "hash": just a sum of all mtimes */
+        new_hash += (unsigned)statb.st_mtime;
+    }
+    if (!mail_var_path_changed && mailtime_hash != new_hash) {
+        if (mailtime_hash != 0)
+            out2str("you have mail\n");
+        mailtime_hash = new_hash;
+    }
     mail_var_path_changed = 0;
 …
     int done = 0;
     int err = 0;
     char s[12];
+    char sbuf[2];
     char **optnext;
+    sbuf[1] = '\0';
     if (*param_optind < 1)
 …
         if (*q == '\0') {
             if (optstr[0] == ':') {
                 s[0] = c;
                 s[1] = '\0';
                 err |= setvarsafe("OPTARG", s, 0);
+                sbuf[0] = c;
+                /*sbuf[1] = '\0'; - already is */
+                err |= setvarsafe("OPTARG", sbuf, 0);
             } else {
                 fprintf(stderr, "Illegal option -%c\n", c);
 …
         if (*p == '\0' && (p = *optnext) == NULL) {
             if (optstr[0] == ':') {
                 s[0] = c;
                 s[1] = '\0';
                 err |= setvarsafe("OPTARG", s, 0);
+                sbuf[0] = c;
+                /*sbuf[1] = '\0'; - already is */
+                err |= setvarsafe("OPTARG", sbuf, 0);
                 c = ':';
             } else {
 …
     *optoff = p ? p - *(optnext - 1) : -1;
     *param_optind = optnext - optfirst + 1;
+    fmtstr(s, sizeof(s), "%d", *param_optind);
+    err |= setvarsafe("OPTIND", s, VNOFUNC);
+    s[0] = c;
+    s[1] = '\0';
+    err |= setvarsafe(optvar, s, 0);
+    err |= setvarsafe("OPTIND", itoa(*param_optind), VNOFUNC);
+    sbuf[0] = c;
+    /*sbuf[1] = '\0'; - already is */
+    err |= setvarsafe(optvar, sbuf, 0);
     if (err) {
         *param_optind = 1;
 …
 static smallint tokpushback;           /* last token pushed back */
-static smallint parsebackquote;        /* nonzero if we are inside backquotes */
 static smallint quoteflag;             /* set if (part of) last token was quoted */
 static token_id_t lasttoken;           /* last token read (integer id Txxx) */
 …
 static union node *parse_command(void);
 static void parseheredoc(void);
 static char peektoken(void);
+static int peektoken(void);
 static int readtoken(void);
 …
     int tok;
-    checkkwd = CHKNL | CHKKWD | CHKALIAS;
-    if (nlflag == 2 && peektoken())
-        return NULL;
     n1 = NULL;
     for (;;) {
+        switch (peektoken()) {
+        case TNL:
+            if (!(nlflag & 1))
+                break;
+            parseheredoc();
+            return n1;
+        case TEOF:
+            if (!n1 && (nlflag & 1))
+                n1 = NODE_EOF;
+            parseheredoc();
+            return n1;
+        }
+        checkkwd = CHKNL | CHKKWD | CHKALIAS;
+        if (nlflag == 2 && tokname_array[peektoken()][0])
+            return n1;
+        nlflag |= 2;
         n2 = andor();
         tok = readtoken();
 …
+        }
         switch (tok) {
+        case TNL:
+        case TEOF:
+            tokpushback = 1;
+            /* fall through */
         case TBACKGND:
         case TSEMI:
-            tok = readtoken();
-            /* fall through */
-        case TNL:
-            if (tok == TNL) {
-                parseheredoc();
-                if (nlflag == 1)
-                    return n1;
-            } else {
-                tokpushback = 1;
+            }
-            checkkwd = CHKNL | CHKKWD | CHKALIAS;
-            if (peektoken())
-                return n1;
             break;
-        case TEOF:
-            if (heredoclist)
-                parseheredoc();
-            else
-                pungetc();              /* push back EOF on input */
-            return n1;
         default:
             if (nlflag == 1)
+            if ((nlflag & 1))
                 raise_error_unexpected_syntax(-1);
             tokpushback = 1;
 …
 #if ENABLE_ASH_BASH_COMPAT
     smallint double_brackets_flag = 0;
+    smallint function_flag = 0;
 #endif
 …
         switch (t) {
 #if ENABLE_ASH_BASH_COMPAT
+        case TFUNCTION:
+            if (peektoken() != TWORD)
+                raise_error_unexpected_syntax(TWORD);
+            function_flag = 1;
+            break;
         case TAND: /* "&&" */
         case TOR: /* "||" */
 …
                 savecheckkwd = 0;
+            }
+#if ENABLE_ASH_BASH_COMPAT
+            if (function_flag) {
+                checkkwd = CHKNL | CHKKWD;
+                switch (peektoken()) {
+                case TBEGIN:
+                case TIF:
+                case TCASE:
+                case TUNTIL:
+                case TWHILE:
+                case TFOR:
+                    goto do_func;
+                case TLP:
+                    function_flag = 0;
+                    break;
+                case TWORD:
+                    if (strcmp("[[", wordtext) == 0)
+                        goto do_func;
+                    /* fall through */
+                default:
+                    raise_error_unexpected_syntax(-1);
+                }
+            }
+#endif
             break;
         case TREDIR:
 …
             break;
         case TLP:
+ IF_ASH_BASH_COMPAT(do_func:)
             if (args && app == &args->narg.next
              && !vars && !redir
 …
                 /* We have a function */
                 if (readtoken() != TRP)
+                if (IF_ASH_BASH_COMPAT(!function_flag &&) readtoken() != TRP)
                     raise_error_unexpected_syntax(TRP);
                 name = n->narg.text;
 …
                 return n;
+            }
+            IF_ASH_BASH_COMPAT(function_flag = 0;)
             /* fall through */
         default:
 …
         n1->type = NFOR;
         n1->nfor.var = wordtext;
         checkkwd = CHKKWD | CHKALIAS;
+        checkkwd = CHKNL | CHKKWD | CHKALIAS;
         if (readtoken() == TIN) {
             app = &ap;
 …
              * that the original Bourne shell only allowed NL).
              */
             if (lasttoken != TNL && lasttoken != TSEMI)
+            if (lasttoken != TSEMI)
                 tokpushback = 1;
+        }
 …
         n2->narg.text = wordtext;
         n2->narg.backquote = backquotelist;
+        do {
+            checkkwd = CHKKWD | CHKALIAS;
+        } while (readtoken() == TNL);
+        if (lasttoken != TIN)
+        checkkwd = CHKNL | CHKKWD | CHKALIAS;
+        if (readtoken() != TIN)
             raise_error_unexpected_syntax(TIN);
         cpp = &n1->ncase.cases;
 …
         t = TEND;
         break;
+    IF_ASH_BASH_COMPAT(case TFUNCTION:)
     case TWORD:
     case TREDIR:
 …
     IF_ASH_BASH_COMPAT(smallint bash_dollar_squote = 0;)
-#if __GNUC__
-    /* Avoid longjmp clobbering */
-    (void) &out;
-    (void) &quotef;
-    (void) &dblquote;
-    (void) &varnest;
-    (void) &arinest;
-    (void) &parenlevel;
-    (void) &dqvarnest;
-    (void) &oldstyle;
-    (void) &prevsyntax;
-    (void) &syntax;
-#endif
     startlinno = g_parsefile->linno;
     bqlist = NULL;
 …
                  && (c != '"' || eofmark != NULL)
                 ) {
-                    USTPUTC(CTLESC, out);
                     USTPUTC('\\', out);
+                }
+                if (SIT(c, SQSYNTAX) == CCTL)
+                    USTPUTC(CTLESC, out);
+                USTPUTC(CTLESC, out);
                 USTPUTC(c, out);
                 quotef = 1;
 …
         case CENDQUOTE:
             IF_ASH_BASH_COMPAT(bash_dollar_squote = 0;)
+            if (eofmark != NULL && arinest == 0
+             && varnest == 0
+            ) {
+            if (eofmark != NULL && varnest == 0) {
                 USTPUTC(c, out);
             } else {
 …
             } else {
                 if (pgetc() == ')') {
+                    c = CTLENDARI;
                     if (--arinest == 0) {
                         syntax = prevsyntax;
-                        dblquote = (syntax == DQSYNTAX);
-                        c = CTLENDARI;
+                    }
                 } else {
 …
         raise_error_syntax("missing '))'");
 #endif
     if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
+    if (syntax != BASESYNTAX && eofmark == NULL)
         raise_error_syntax("unterminated quoted string");
     if (varnest != 0) {
 …
     ) {
 #if ENABLE_ASH_BASH_COMPAT
         if (c == '\'')
+        if (syntax != DQSYNTAX && c == '\'')
             bash_dollar_squote = 1;
         else
 …
             pungetc();
+        }
-        if (dblquote || arinest)
-            flags |= VSQUOTE;
         ((unsigned char *)stackblock())[typeloc] = subtype | flags;
         if (subtype != VSNORMAL) {
             varnest++;
             if (dblquote || arinest) {
+            if (dblquote) {
                 dqvarnest++;
+            }
 …
 parsebackq: {
     struct nodelist **nlpp;
-    smallint savepbq;
     union node *n;
+    char *volatile str;
+    struct jmploc jmploc;
+    struct jmploc *volatile savehandler;
+    char *str;
     size_t savelen;
     smallint saveprompt = 0;
-#ifdef __GNUC__
-    (void) &saveprompt;
-#endif
-    savepbq = parsebackquote;
-    if (setjmp(jmploc.loc)) {
-        free(str);
-        parsebackquote = 0;
-        exception_handler = savehandler;
-        longjmp(exception_handler->loc, 1);
+    }
-    INT_OFF;
     str = NULL;
     savelen = out - (char *)stackblock();
     if (savelen > 0) {
         str = ckmalloc(savelen);
+        str = alloca(savelen);
         memcpy(str, stackblock(), savelen);
+    }
-    savehandler = exception_handler;
-    exception_handler = &jmploc;
-    INT_ON;
     if (oldstyle) {
         /* We must read until the closing backquote, giving special
 …
     *nlpp = stzalloc(sizeof(**nlpp));
     /* (*nlpp)->next = NULL; - stzalloc did it */
-    parsebackquote = oldstyle;
     if (oldstyle) {
 …
         memcpy(out, str, savelen);
         STADJUST(savelen, out);
+        INT_OFF;
+        free(str);
+        str = NULL;
+        INT_ON;
+    }
+    parsebackquote = savepbq;
+    exception_handler = savehandler;
+    if (arinest || dblquote)
+        USTPUTC(CTLBACKQ | CTLQUOTE, out);
+    else
+        USTPUTC(CTLBACKQ, out);
+    }
+    USTPUTC(CTLBACKQ, out);
     if (oldstyle)
         goto parsebackq_oldreturn;
 …
         prevsyntax = syntax;
         syntax = ARISYNTAX;
+        USTPUTC(CTLARI, out);
+        if (dblquote)
+            USTPUTC('"', out);
+        else
+            USTPUTC(' ', out);
+    } else {
+        /*
+         * we collapse embedded arithmetic expansion to
+         * parenthesis, which should be equivalent
+         */
+        USTPUTC('(', out);
+    }
+    }
+    USTPUTC(CTLARI, out);
     goto parsearith_return;
+}
 #endif
 } /* end of readtoken */
 …
+{
     int t;
+    int kwd = checkkwd;
 #if DEBUG
     smallint alreadyseen = tokpushback;
 …
      * eat newlines
      */
     if (checkkwd & CHKNL) {
+    if (kwd & CHKNL) {
         while (t == TNL) {
             parseheredoc();
 …
      * check for keywords
      */
     if (checkkwd & CHKKWD) {
+    if (kwd & CHKKWD) {
         const char *const *pp;
 …
+}
 static char
+static int
 peektoken(void)
+{
 …
     t = readtoken();
     tokpushback = 1;
     return tokname_array[t][0];
+    return t;
+}
 …
 parsecmd(int interact)
+{
-    int t;
     tokpushback = 0;
+    checkkwd = 0;
+    heredoclist = 0;
     doprompt = interact;
     setprompt_if(doprompt, doprompt);
     needprompt = 0;
-    t = readtoken();
-    if (t == TEOF)
-        return NODE_EOF;
-    if (t == TNL)
-        return NULL;
-    tokpushback = 1;
     return list(1);
+}
 …
     n.narg.backquote = backquotelist;
     expandarg(&n, NULL, 0);
+    expandarg(&n, NULL, EXP_QUOTED);
     return stackblock();
+}
 …
 #if JOBS
         if (doing_jobctl)
             showjobs(stderr, SHOW_CHANGED);
+            showjobs(SHOW_CHANGED|SHOW_STDERR);
 #endif
         inter = 0;
 …
     exitstatus = 0;
+    /* This aborts if file isn't found, which is POSIXly correct.
+     * bash returns exitcode 1 instead.
+     */
     fullname = find_dot_file(argv[1]);
     argv += 2;
     argc -= 2;
 …
     };
+    /* This aborts if file can't be opened, which is POSIXly correct.
+     * bash returns exitcode 1 instead.
+     */
     setinputfile(fullname, INPUT_PUSH_FILE);
     commandname = fullname;
 …
 /* ============ Builtins */
+#if !ENABLE_FEATURE_SH_EXTRA_QUIET
+/*
+ * Lists available builtins
+ */
+#if ENABLE_ASH_HELP
 static int FAST_FUNC
 helpcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
 …
+        }
+    }
 #if ENABLE_FEATURE_SH_STANDALONE
+# if ENABLE_FEATURE_SH_STANDALONE
+    {
         const char *a = applet_names;
 …
                 col = 0;
+            }
+            a += strlen(a) + 1;
+        }
+    }
+#endif
+            while (*a++ != '\0')
+                continue;
+        }
+    }
+# endif
     out1fmt("\n\n");
     return EXIT_SUCCESS;
+}
+#endif /* FEATURE_SH_EXTRA_QUIET */
+#endif
+#if MAX_HISTORY
+static int FAST_FUNC
+historycmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
+{
+    show_history(line_input_state);
+    return EXIT_SUCCESS;
+}
+#endif
 /*
 …
     struct tms buf;
     clk_tck = sysconf(_SC_CLK_TCK);
+    clk_tck = bb_clk_tck();
     times(&buf);
 …
      */
     INT_OFF;
     r = shell_builtin_read(setvar2,
+    r = shell_builtin_read(setvar0,
         argptr,
         bltinlookup("IFS"), /* can be NULL */
 …
 static int FAST_FUNC
+umaskcmd(int argc UNUSED_PARAM, 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,
+        S_IROTH, S_IWOTH, S_IXOTH
+    };
+    /* TODO: use bb_parse_mode() instead */
+    char *ap;
+umaskcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
+{
+    static const char permuser[3] ALIGN1 = "ogu";
     mode_t mask;
-    int i;
     int symbolic_mode = 0;
 …
     INT_ON;
+    ap = *argptr;
+    if (ap == NULL) {
+    if (*argptr == NULL) {
         if (symbolic_mode) {
             char buf[18];
+            char buf[sizeof(",u=rwx,g=rwx,o=rwx")];
             char *p = buf;
+            for (i = 0; i < 3; i++) {
+                int j;
+            int i;
+            i = 2;
+            for (;;) {
+                *p++ = ',';
                 *p++ = permuser[i];
                 *p++ = '=';
+                for (j = 0; j < 3; j++) {
+                    if ((mask & permmask[3 * i + j]) == 0) {
+                        *p++ = permmode[j];
+                    }
+                }
+                *p++ = ',';
+                /* mask is 0..0uuugggooo. i=2 selects uuu bits */
+                if (!(mask & 0400)) *p++ = 'r';
+                if (!(mask & 0200)) *p++ = 'w';
+                if (!(mask & 0100)) *p++ = 'x';
+                mask <<= 3;
+                if (--i < 0)
+                    break;
+            }
             *--p = 0;
             puts(buf);
+            *p = '\0';
+            puts(buf + 1);
         } else {
             out1fmt("%.4o\n", mask);
+            out1fmt("%04o\n", mask);
+        }
     } else {
+        if (isdigit((unsigned char) *ap)) {
+            mask = 0;
+            do {
+                if (*ap >= '8' || *ap < '0')
+                    ash_msg_and_raise_error(msg_illnum, argv[1]);
+                mask = (mask << 3) + (*ap - '0');
+            } while (*++ap != '\0');
+            umask(mask);
+        } else {
+            mask = ~mask & 0777;
+            if (!bb_parse_mode(ap, &mask)) {
+                ash_msg_and_raise_error("illegal mode: %s", ap);
+            }
+            umask(~mask & 0777);
+        }
+        char *modestr = *argptr;
+                /* numeric umasks are taken as-is */
+                /* symbolic umasks are inverted: "umask a=rx" calls umask(222) */
+        if (!isdigit(modestr[0]))
+            mask ^= 0777;
+        mask = bb_parse_mode(modestr, mask);
+        if ((unsigned)mask > 0777) {
+            ash_msg_and_raise_error("illegal mode: %s", modestr);
+        }
+        if (!isdigit(modestr[0]))
+            mask ^= 0777;
+        umask(mask);
+    }
     return 0;
 …
+        }
+        setvar("PPID", utoa(getppid()), 0);
+        setvar0("PPID", utoa(getppid()));
+#if ENABLE_ASH_BASH_COMPAT
+        p = lookupvar("SHLVL");
+        setvar("SHLVL", utoa((p ? atoi(p) : 0) + 1), VEXPORT);
+        if (!lookupvar("HOSTNAME")) {
+            struct utsname uts;
+            uname(&uts);
+            setvar0("HOSTNAME", uts.nodename);
+        }
+#endif
         p = lookupvar("PWD");
         if (p) {
 …
+        }
         if (e == EXINT) {
             outcslow('\n', stderr);
+            newline_and_flush(stderr);
+        }
 …
     procargs(argv);
-#if ENABLE_FEATURE_EDITING_SAVEHISTORY
-    if (iflag) {
-        const char *hp = lookupvar("HISTFILE");
-        if (!hp) {
-            hp = lookupvar("HOME");
-            if (hp) {
-                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) {
+        const char *hp;
         state = 1;
         read_profile("/etc/profile");
  state1:
         state = 2;
+        read_profile(".profile");
+        hp = lookupvar("HOME");
+        if (hp) {
+            hp = concat_path_file(hp, ".profile");
+            read_profile(hp);
+            free((char*)hp);
+        }
+    }
  state2:
 …
         if (iflag) {
             const char *hp = lookupvar("HISTFILE");
+            if (!hp) {
+                hp = lookupvar("HOME");
+                if (hp) {
+                    hp = concat_path_file(hp, ".ash_history");
+                    setvar0("HISTFILE", hp);
+                    free((char*)hp);
+                    hp = lookupvar("HISTFILE");
+                }
+            }
             if (hp)
                 line_input_state->hist_file = hp;

branches/3.3/mindi-busybox/shell/ash_test/ash-quoting/dollar_squote_bash1.right

r2725	r3621
1	1	a b
	2	$'a\tb'
2	3	a
3	4	b c

branches/3.3/mindi-busybox/shell/ash_test/ash-quoting/dollar_squote_bash1.tests

r2725	r3621
1	1	echo $'a\tb'
	2	echo "$'a\tb'"
2	3	echo $'a\nb' $'c\nd''ef'
3	4	echo $'a\'b' $'c\"d' $'e\\f'

branches/3.3/mindi-busybox/shell/ash_test/printenv.c

r2725	r3621
25	25	Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
26	26
	27	#include <stdio.h>
27	28	#include <stdlib.h>
28	29	#include <string.h>

branches/3.3/mindi-busybox/shell/ash_test/run-all

-              r2725
+              r3621
         #*) echo $x ; sh $x ;;
         *)
+        echo -n "$1/$x: "
         sh "$x" >"$TOPDIR/$noslash-$x.fail" 2>&1 && \
         { echo "$1/$x: ok"; rm "$TOPDIR/$noslash-$x.fail"; } || echo "$1/$x: fail";
+        { echo "ok"; rm "$TOPDIR/$noslash-$x.fail"; } || echo "fail";
         ;;
     esac
 …
     name="${x%%.tests}"
     test -f "$name.right" || continue
+    echo -n "$1/$x: "
+    {
         "$THIS_SH" "./$x" >"$name.xx" 2>&1
         diff -u "$name.xx" "$name.right" >"$TOPDIR/$noslash-$x.fail" \
         && rm -f "$name.xx" "$TOPDIR/$noslash-$x.fail"
     } && echo "$1/$x: ok" || echo "$1/$x: fail"
+    } && echo "ok" || echo "fail"
     done
+    )

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

-              r3232
+              r3621
 # include <fnmatch.h>
 #endif
+#include <sys/utsname.h> /* for setting $HOSTNAME */
 #include "busybox.h"  /* for APPLET_IS_NOFORK/NOEXEC */
 …
     DEFINITELY_ASSIGNMENT = 1,
     NOT_ASSIGNMENT        = 2,
     /* Not an assigment, but next word may be: "if v=xyz cmd;" */
+    /* Not an assignment, but next word may be: "if v=xyz cmd;" */
     WORD_IS_KEYWORD       = 3,
 };
 …
 static int builtin_help(char **argv) FAST_FUNC;
 #endif
+#if MAX_HISTORY && ENABLE_FEATURE_EDITING
+static int builtin_history(char **argv) FAST_FUNC;
+#endif
 #if ENABLE_HUSH_LOCAL
 static int builtin_local(char **argv) FAST_FUNC;
 …
     BLTIN("help"     , builtin_help    , NULL),
 #endif
+#if MAX_HISTORY && ENABLE_FEATURE_EDITING
+    BLTIN("history"  , builtin_history , "Show command history"),
+#endif
 #if ENABLE_HUSH_JOB
     BLTIN("jobs"     , builtin_jobs    , "List jobs"),
 …
 #endif
     BLTIN("trap"     , builtin_trap    , "Trap signals"),
+    BLTIN("true"     , builtin_true    , NULL),
     BLTIN("type"     , builtin_type    , "Show command type"),
     BLTIN("ulimit"   , shell_builtin_ulimit  , "Control resource limits"),
 …
  * pipe.
+ *
  * Wait builtin in interruptible by signals for which user trap is set
+ * Wait builtin is interruptible by signals for which user trap is set
  * or by SIGINT in interactive shell.
+ *
 …
+ *
  * Problem: the above approach makes it unwieldy to catch signals while
  * we are in read builtin, of while we read commands from stdin:
+ * we are in read builtin, or while we read commands from stdin:
  * masked signals are not visible!
+ *
 …
  * We are interested in: signals which need to have special handling
  * as described above, and all signals which have traps set.
  * Signals are rocorded in pending_set.
+ * Signals are recorded in pending_set.
  * After each pipe execution, we extract any pending signals
  * and act on them.
 …
+}
+static void hush_exit(int exitcode) NORETURN;
+static void fflush_and__exit(void) NORETURN;
+static void restore_ttypgrp_and__exit(void) NORETURN;
+static void restore_ttypgrp_and__exit(void)
+{
+    /* xfunc has failed! die die die */
+    /* no EXIT traps, this is an escape hatch! */
+    G.exiting = 1;
+    hush_exit(xfunc_error_retval);
+}
+/* Needed only on some libc:
+ * It was observed that on exit(), fgetc'ed buffered data
+ * gets "unwound" via lseek(fd, -NUM, SEEK_CUR).
+ * With the net effect that even after fork(), not vfork(),
+ * exit() in NOEXECed applet in "sh SCRIPT":
+ *  noexec_applet_here
+ *  echo END_OF_SCRIPT
+ * lseeks fd in input FILE object from EOF to "e" in "echo END_OF_SCRIPT".
+ * This makes "echo END_OF_SCRIPT" executed twice.
+ * Similar problems can be seen with die_if_script() -> xfunc_die()
+ * and in `cmd` handling.
+ * If set as die_func(), this makes xfunc_die() exit via _exit(), not exit():
+ */
+static void fflush_and__exit(void)
+{
+    fflush_all();
+    _exit(xfunc_error_retval);
+}
 #if ENABLE_HUSH_JOB
 /* After [v]fork, in child: do not restore tty pgrp on xfunc death */
 # define disable_restore_tty_pgrp_on_exit() (die_sleep = 0)
+# define disable_restore_tty_pgrp_on_exit() (die_func = fflush_and__exit)
 /* After [v]fork, in parent: restore tty pgrp on xfunc death */
 # define enable_restore_tty_pgrp_on_exit()  (die_sleep = -1)
+# define enable_restore_tty_pgrp_on_exit()  (die_func = restore_ttypgrp_and__exit)
 /* Restores tty foreground process group, and exits.
 …
  * (will resend signal to itself, producing correct exit state)
  * or called directly with -EXITCODE.
+ * We also call it if xfunc is exiting. */
+ * We also call it if xfunc is exiting.
+ */
 static void sigexit(int sig) NORETURN;
 static void sigexit(int sig)
 …
 /* Restores tty foreground process group, and exits. */
-static void hush_exit(int exitcode) NORETURN;
 static void hush_exit(int exitcode)
+{
 …
 #endif
+    fflush_all();
 #if ENABLE_HUSH_JOB
-    fflush_all();
     sigexit(- (exitcode & 0xff));
 #else
     exit(exitcode);
+    _exit(exitcode);
 #endif
+}
 …
     struct variable **var_pp;
     struct variable *cur;
+    char *free_me = NULL;
     char *eq_sign;
     int name_len;
 …
             continue;
+        }
         /* We found an existing var with this name */
         if (cur->flg_read_only) {
 …
                 goto free_and_exp;
+            }
+        } else {
+            /* max_len == 0 signifies "malloced" var, which we can
+             * (and has to) free */
+            free(cur->varstr);
+        }
+        cur->max_len = 0;
+            /* Can't reuse */
+            cur->max_len = 0;
+            goto set_str_and_exp;
+        }
+        /* max_len == 0 signifies "malloced" var, which we can
+         * (and have to) free. But we can't free(cur->varstr) here:
+         * if cur->flg_export is 1, it is in the environment.
+         * We should either unsetenv+free, or wait until putenv,
+         * then putenv(new)+free(old).
+         */
+        free_me = cur->varstr;
         goto set_str_and_exp;
+    }
 …
             /* unsetenv was already done */
         } else {
+            int i;
             debug_printf_env("%s: putenv '%s'\n", __func__, cur->varstr);
+            return putenv(cur->varstr);
+        }
+    }
+            i = putenv(cur->varstr);
+            /* only now we can free old exported malloced string */
+            free(free_me);
+            return i;
+        }
+    }
+    free(free_me);
     return 0;
+}
 …
+    }
     return old;
+}
+/*
+ * Unicode helper
+ */
+static void reinit_unicode_for_hush(void)
+{
+    /* Unicode support should be activated even if LANG is set
+     * _during_ shell execution, not only if it was set when
+     * shell was started. Therefore, re-check LANG every time:
+     */
+    if (ENABLE_FEATURE_CHECK_UNICODE_IN_ENV
+     || ENABLE_UNICODE_USING_LOCALE
+        ) {
+        const char *s = get_local_var_value("LC_ALL");
+        if (!s) s = get_local_var_value("LC_CTYPE");
+        if (!s) s = get_local_var_value("LANG");
+        reinit_unicode(s);
+    }
+}
 …
      * is actually being read */
     do {
+        /* Unicode support should be activated even if LANG is set
+         * _during_ shell execution, not only if it was set when
+         * shell was started. Therefore, re-check LANG every time:
+         */
+        reinit_unicode(get_local_var_value("LANG"));
+        reinit_unicode_for_hush();
         G.flag_SIGINT = 0;
         /* buglet: SIGINT will not make new prompt to appear _at once_,
 …
         old->command->cmd_type = CMD_NORMAL;
 # if !BB_MMU
+        o_addstr(&old->as_string, ctx->as_string.data);
+        o_free_unsafe(&ctx->as_string);
+        old->command->group_as_string = xstrdup(old->as_string.data);
+        debug_printf_parse("pop, remembering as:'%s'\n",
+                old->command->group_as_string);
+        /* At this point, the compound command's string is in
+         * ctx->as_string... except for the leading keyword!
+         * Consider this example: "echo a | if true; then echo a; fi"
+         * ctx->as_string will contain "true; then echo a; fi",
+         * with "if " remaining in old->as_string!
+         */
+        {
+            char *str;
+            int len = old->as_string.length;
+            /* Concatenate halves */
+            o_addstr(&old->as_string, ctx->as_string.data);
+            o_free_unsafe(&ctx->as_string);
+            /* Find where leading keyword starts in first half */
+            str = old->as_string.data + len;
+            if (str > old->as_string.data)
+                str--; /* skip whitespace after keyword */
+            while (str > old->as_string.data && isalpha(str[-1]))
+                str--;
+            /* Ugh, we're done with this horrid hack */
+            old->command->group_as_string = xstrdup(str);
+            debug_printf_parse("pop, remembering as:'%s'\n",
+                    old->command->group_as_string);
+        }
 # endif
         *ctx = *old;   /* physical copy */
 …
+            }
 #if !BB_MMU
             debug_printf_parse("as_string '%s'\n", ctx.as_string.data);
+            debug_printf_parse("as_string1 '%s'\n", ctx.as_string.data);
             if (pstring)
                 *pstring = ctx.as_string.data;
 …
                 o_free(&dest);
 #if !BB_MMU
                 debug_printf_parse("as_string '%s'\n", ctx.as_string.data);
+                debug_printf_parse("as_string2 '%s'\n", ctx.as_string.data);
                 if (pstring)
                     *pstring = ctx.as_string.data;
 …
                  * "echo foo 2| cat" yields "foo 2". */
                 done_command(&ctx);
-#if !BB_MMU
-                o_reset_to_empty_unquoted(&ctx.as_string);
-#endif
+            }
             goto new_cmd;
 …
     /* Handle any expansions */
     if (exp_op == 'L') {
+        reinit_unicode_for_hush();
         debug_printf_expand("expand: length(%s)=", val);
         val = utoa(val ? strlen(val) : 0);
+        val = utoa(val ? unicode_strlen(val) : 0);
         debug_printf_expand("%s\n", val);
     } else if (exp_op) {
 …
+            }
             break;
         } /* switch (char after <SPECIAL_VAR_SYMBOL>) */
 …
          */
         s = skip_whitespace(s);
         if (strncmp(s, "trap", 4) == 0
+        if (is_prefixed_with(s, "trap")
          && skip_whitespace(s + 4)[0] == '\0'
         ) {
             static const char *const argv[] = { NULL, NULL };
             builtin_trap((char**)argv);
+            exit(0); /* not _exit() - we need to fflush */
+            fflush_all(); /* important */
+            _exit(0);
+        }
 # if BB_MMU
 …
  * Don't 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? -- because of vfork! (vda) */
+ * in particular stdin handling. Not sure why? -- because of vfork! (vda)
+ */
 static void pseudo_exec_argv(nommu_save_t *nommu_save,
         char **argv, int assignment_cnt,
 …
                         if (i == fg_pipe->num_cmds-1)
                             /* TODO: use strsignal() instead for bash compat? but that's bloat... */
                             printf("%s\n", sig == SIGINT || sig == SIGPIPE ? "" : get_signame(sig));
+                            puts(sig == SIGINT || sig == SIGPIPE ? "" : get_signame(sig));
                         /* TODO: if (WCOREDUMP(status)) + " (core dumped)"; */
                         /* TODO: MIPS has 128 sigs (1..128), what if sig==128 here?
 …
                 debug_printf_exec("skipped cmd because of || or &&\n");
                 last_followup = pi->followup;
                 continue;
+                goto dont_check_jobs_but_continue;
+            }
+        }
 …
                         /* else: e.g. "continue 2" should *break* once, *then* continue */
                     } /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
+                    if (G.depth_break_continue != 0 || fbc == BC_BREAK)
+                        goto check_jobs_and_break;
+                    if (G.depth_break_continue != 0 || fbc == BC_BREAK) {
+                        checkjobs(NULL);
+                        break;
+                    }
                     /* "continue": simulate end of loop */
                     rword = RES_DONE;
 …
 #if ENABLE_HUSH_FUNCTIONS
                 if (G.flag_return_in_progress == 1) {
-                    /* same as "goto check_jobs_and_break" */
                     checkjobs(NULL);
                     break;
 …
             cond_code = rcode;
 #endif
+ check_jobs_and_continue:
+        checkjobs(NULL);
+ dont_check_jobs_but_continue: ;
 #if ENABLE_HUSH_LOOPS
         /* Beware of "while false; true; do ..."! */
 …
                     G.last_exitcode = rcode = EXIT_SUCCESS;
                     debug_printf_exec(": while expr is false: breaking (exitcode:EXIT_SUCCESS)\n");
                     goto check_jobs_and_break;
+                    break;
+                }
+            }
 …
                 if (!rcode) {
                     debug_printf_exec(": until expr is true: breaking\n");
- check_jobs_and_break:
-                    checkjobs(NULL);
                     break;
+                }
 …
+        }
 #endif
- check_jobs_and_continue:
-        checkjobs(NULL);
     } /* for (pi) */
 …
     if (EXIT_SUCCESS != 0) /* if EXIT_SUCCESS == 0, it is already done */
         G.last_exitcode = EXIT_SUCCESS;
 #if ENABLE_HUSH_FAST
     G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
 …
     /* Export PWD */
     set_pwd_var(/*exp:*/ 1);
+#if ENABLE_HUSH_BASH_COMPAT
+    /* Set (but not export) HOSTNAME unless already set */
+    if (!get_local_var_value("HOSTNAME")) {
+        struct utsname uts;
+        uname(&uts);
+        set_local_var_from_halves("HOSTNAME", uts.nodename);
+    }
     /* bash also exports SHLVL and _,
      * and sets (but doesn't export) the following variables:
 …
      * MACHTYPE=i386-pc-linux-gnu
      * OSTYPE=linux-gnu
-     * HOSTNAME=<xxxxxxxxxx>
      * PPID=<NNNNN> - we also do it elsewhere
      * EUID=<NNNNN>
 …
      * PS4='+ '
      */
+#endif
 #if ENABLE_FEATURE_EDITING
 …
     cmdedit_update_prompt();
+    if (setjmp(die_jmp)) {
+        /* xfunc has failed! die die die */
+        /* no EXIT traps, this is an escape hatch! */
+        G.exiting = 1;
+        hush_exit(xfunc_error_retval);
+    }
+    die_func = restore_ttypgrp_and__exit;
     /* Shell is non-interactive at first. We need to call
 …
             tcsetpgrp(G_interactive_fd, getpid());
+        }
+        /* -1 is special - makes xfuncs longjmp, not exit
+         * (we reset die_sleep = 0 whereever we [v]fork) */
+        enable_restore_tty_pgrp_on_exit(); /* sets die_sleep = -1 */
+        enable_restore_tty_pgrp_on_exit();
 # if ENABLE_HUSH_SAVEHISTORY && MAX_HISTORY > 0
 …
+    }
     bb_putchar('\n');
+    return EXIT_SUCCESS;
+}
+#endif
+#if MAX_HISTORY && ENABLE_FEATURE_EDITING
+static int FAST_FUNC builtin_history(char **argv UNUSED_PARAM)
+{
+    show_history(G.line_input_state);
     return EXIT_SUCCESS;
+}
 …
     if (!input) {
         /* bb_perror_msg("%s", *argv); - done by fopen_or_warn */
+        /* POSIX: non-interactive shell should abort here,
+         * not merely fail. So far no one complained :)
+         */
         return EXIT_FAILURE;
+    }
 …
     G.flag_return_in_progress = -1;
 #endif
+    save_and_replace_G_args(&sv, argv);
+    if (argv[1])
+        save_and_replace_G_args(&sv, argv);
     parse_and_run_file(input);
     fclose(input);
+    restore_G_args(&sv, argv);
+    if (argv[1])
+        restore_G_args(&sv, argv);
 #if ENABLE_HUSH_FUNCTIONS
     G.flag_return_in_progress = sv_flg;
 …
     mode_t mask;
+    rc = 1;
     mask = umask(0);
     argv = skip_dash_dash(argv);
 …
         mode_t old_mask = mask;
+        mask ^= 0777;
+        rc = bb_parse_mode(argv[0], &mask);
+        mask ^= 0777;
+        if (rc == 0) {
+        /* numeric umasks are taken as-is */
+        /* symbolic umasks are inverted: "umask a=rx" calls umask(222) */
+        if (!isdigit(argv[0][0]))
+            mask ^= 0777;
+        mask = bb_parse_mode(argv[0], mask);
+        if (!isdigit(argv[0][0]))
+            mask ^= 0777;
+        if ((unsigned)mask > 0777) {
             mask = old_mask;
             /* bash messages:
 …
              */
             bb_error_msg("%s: invalid mode '%s'", "umask", argv[0]);
+            rc = 0;
+        }
     } else {
-        rc = 1;
         /* Mimic bash */
         printf("%04o\n", (unsigned) mask);
 …
+        }
         if (waitpid(pid, &status, 0) == pid) {
+            ret = WEXITSTATUS(status);
             if (WIFSIGNALED(status))
                 ret = 128 + WTERMSIG(status);
-            else if (WIFEXITED(status))
-                ret = WEXITSTATUS(status);
-            else /* wtf? */
-                ret = EXIT_FAILURE;
         } else {
             bb_perror_msg("wait %s", *argv);

branches/3.3/mindi-busybox/shell/hush_test/hush-misc/func_args1.tests

r2725	r3621
1		~~# UNFIXED BUG~~
2
3	1	f() { echo "'f $1 $2 $3' called"; }
4	2

branches/3.3/mindi-busybox/shell/math.c

-              r3232
+              r3621
         else if (right_side_val == 0)
             return "divide by zero";
+        else if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
+            rez /= right_side_val;
+        else if (op == TOK_REM || op == TOK_REM_ASSIGN)
+            rez %= right_side_val;
+        else if (op == TOK_DIV || op == TOK_DIV_ASSIGN
+              || op == TOK_REM || op == TOK_REM_ASSIGN) {
+            /*
+             * bash 4.2.45 x86 64bit: SEGV on 'echo $((2**63 / -1))'
+             *
+             * MAX_NEGATIVE_INT / -1 = MAX_POSITIVE_INT+1
+             * and thus is not representable.
+             * Some CPUs segfault trying such op.
+             * Others overflow MAX_POSITIVE_INT+1 to
+             * MAX_NEGATIVE_INT (0x7fff+1 = 0x8000).
+             * Make sure to at least not SEGV here:
+             */
+            if (right_side_val == -1
+             && rez << 1 == 0 /* MAX_NEGATIVE_INT or 0 */
+            ) {
+                right_side_val = 1;
+            }
+            if (op == TOK_DIV || op == TOK_DIV_ASSIGN)
+                rez /= right_side_val;
+            else {
+                rez %= right_side_val;
+            }
+        }
+    }
 …
 #define ptr_to_rparen (&op_tokens[sizeof(op_tokens)-7])
-const char* FAST_FUNC
-endofname(const char *name)
+{
-    if (!is_name(*name))
-        return name;
-    while (*++name) {
-        if (!is_in_name(*name))
-            break;
+    }
-    return name;
+}
 static arith_t FAST_FUNC
 evaluate_string(arith_state_t *math_state, const char *expr)

branches/3.3/mindi-busybox/shell/math.h

-              r2725
+              r3621
 #endif
-/* ash's and hush's endofname is the same, so... */
-# define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
-# define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
-const char* FAST_FUNC endofname(const char *name);
 typedef const char* FAST_FUNC (*arith_var_lookup_t)(const char *name);
 typedef void        FAST_FUNC (*arith_var_set_t)(const char *name, const char *val);

branches/3.3/mindi-busybox/shell/random.c

-              r2725
+              r3621
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
+#include "libbb.h"
+#include "random.h"
+/* For testing against dieharder, you need only random.{c,h}
+ * Howto:
+ * gcc -O2 -Wall -DRANDTEST random.c -o random
+ * ./random | dieharder -g 200 -a
+ */
+#if !defined RANDTEST
+# include "libbb.h"
+# include "random.h"
+# define RAND_BASH_MASK 0x7fff
+#else
+# include <stdint.h>
+# include <unistd.h>
+# include <stdio.h>
+# include <time.h>
+# define FAST_FUNC /* nothing */
+# define PUSH_AND_SET_FUNCTION_VISIBILITY_TO_HIDDEN /* nothing */
+# define POP_SAVED_FUNCTION_VISIBILITY /* nothing */
+# define monotonic_us() time(NULL)
+# include "random.h"
+# define RAND_BASH_MASK 0xffffffff /* off */
+#endif
 uint32_t FAST_FUNC
 next_random(random_t *rnd)
+{
+    /* Galois LFSR parameter */
+    /* Taps at 32 31 29 1: */
+    /* Galois LFSR parameter:
+     * Taps at 32 31 29 1:
+     */
     enum { MASK = 0x8000000b };
     /* Another example - taps at 32 31 30 10: */
+    /* MASK = 0x00400007 */
+    /* enum { MASK = 0x00400007 }; */
+    /* Xorshift parameters:
+     * Choices for a,b,c: 10,13,10; 8,9,22; 2,7,3; 23,3,24
+     * (given by algorithm author)
+     */
+        enum {
+                a = 2,
+                b = 7,
+                c = 3,
+        };
     uint32_t t;
 …
+    }
+    /* LCG has period of 2^32 and alternating lowest bit */
+    /* LCG: period of 2^32, but quite weak:
+     * bit 0 alternates beetween 0 and 1 (pattern of length 2)
+     * bit 1 has a repeating pattern of length 4
+     * bit 2 has a repeating pattern of length 8
+     * etc...
+     */
     rnd->LCG = 1664525 * rnd->LCG + 1013904223;
+    /* Galois LFSR has period of 2^32-1 = 3 * 5 * 17 * 257 * 65537 */
+    /* Galois LFSR:
+     * period of 2^32-1 = 3 * 5 * 17 * 257 * 65537.
+     * Successive values are right-shifted one bit
+     * and possibly xored with a sparse constant.
+     */
     t = (rnd->galois_LFSR << 1);
     if (rnd->galois_LFSR < 0) /* if we just shifted 1 out of msb... */
         t ^= MASK;
     rnd->galois_LFSR = t;
-    /* Both are weak, combining them gives better randomness
-     * and ~2^64 period. & 0x7fff is probably bash compat
-     * for $RANDOM range. Combining with subtraction is
-     * just for fun. + and ^ would work equally well. */
-    t = (t - rnd->LCG) & 0x7fff;
+    return t;
+    /* http://en.wikipedia.org/wiki/Xorshift
+     * Moderately good statistical properties:
+     * fails the following "dieharder -g 200 -a" tests:
+     *       diehard_operm5|   0
+     *         diehard_oqso|   0
+     * diehard_count_1s_byt|   0
+     *     diehard_3dsphere|   3
+     *      diehard_squeeze|   0
+     *         diehard_runs|   0
+     *         diehard_runs|   0
+     *        diehard_craps|   0
+     *        diehard_craps|   0
+     * rgb_minimum_distance|   3
+     * rgb_minimum_distance|   4
+     * rgb_minimum_distance|   5
+     *     rgb_permutations|   3
+     *     rgb_permutations|   4
+     *     rgb_permutations|   5
+     *         dab_filltree|  32
+     *         dab_filltree|  32
+     *         dab_monobit2|  12
+     */
+ again:
+    t = rnd->xs64_x ^ (rnd->xs64_x << a);
+    rnd->xs64_x = rnd->xs64_y;
+    rnd->xs64_y = rnd->xs64_y ^ (rnd->xs64_y >> c) ^ t ^ (t >> b);
+    /*
+     * Period 2^64-1 = 2^32+1 * 2^32-1 has a common divisor with Galois LFSR.
+     * By skipping two possible states (0x1 and 0x2) we reduce period to
+     * 2^64-3 = 13 * 3889 * 364870227143809 which has no common divisors:
+     */
+    if (rnd->xs64_y == 0 && rnd->xs64_x <= 2)
+        goto again;
+    /* Combined LCG + Galois LFSR rng has 2^32 * 2^32-1 period.
+     * Strength:
+     * individually, both are extremely weak cryptographycally;
+     * when combined, they fail the following "dieharder -g 200 -a" tests:
+     *     diehard_rank_6x8|   0
+     *         diehard_oqso|   0
+     *          diehard_dna|   0
+     * diehard_count_1s_byt|   0
+     *          rgb_bitdist|   2
+     *         dab_monobit2|  12
+     *
+     * Combining them with xorshift-64 increases period to
+     * 2^32 * 2^32-1 * 2^64-3
+     * which is about 2^128, or in base 10 ~3.40*10^38.
+     * Strength of the combination:
+     * passes all "dieharder -g 200 -a" tests.
+     *
+     * Combining with subtraction and addition is just for fun.
+     * It does not add meaningful strength, could use xor operation instead.
+     */
+    t = rnd->galois_LFSR - rnd->LCG + rnd->xs64_y;
+    /* bash compat $RANDOM range: */
+    return t & RAND_BASH_MASK;
+}
+#ifdef RANDTEST
+static random_t rnd;
+int main(int argc, char **argv)
+{
+    int i;
+    uint32_t buf[4096];
+    for (;;) {
+        for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++) {
+            buf[i] = next_random(&rnd);
+        }
+        write(1, buf, sizeof(buf));
+    }
+        return 0;
+}
+#endif

branches/3.3/mindi-busybox/shell/random.h

-              r2725
+              r3621
 typedef struct random_t {
+    /* Random number generators */
+    int32_t galois_LFSR; /* Galois LFSR (fast but weak). signed! */
+    uint32_t LCG;        /* LCG (fast but weak) */
+    /* State of random number generators: */
+    /* Galois LFSR (fast but weak) */
+    int32_t galois_LFSR; /* must be signed! */
+    /* LCG (fast but weak) */
+    uint32_t LCG;
+    /* 64-bit xorshift (fast, moderate strength) */
+    uint32_t xs64_x;
+    uint32_t xs64_y;
 } random_t;
 …
 #define INIT_RANDOM_T(rnd, nonzero, v) \
     ((rnd)->galois_LFSR = (nonzero), (rnd)->LCG = (v))
+    ((rnd)->galois_LFSR = (rnd)->xs64_x = (nonzero), (rnd)->LCG = (rnd)->xs64_y = (v))
 #define CLEAR_RANDOM_T(rnd) \

branches/3.3/mindi-busybox/shell/shell_common.c

-              r3232
+              r3621
 /* read builtin */
 /* Needs to be interruptible: shell mush handle traps and shell-special signals
+/* Needs to be interruptible: shell must handle traps and shell-special signals
  * while inside read. To implement this, be sure to not loop on EINTR
  * and return errno == EINTR reliably.
 …
 /* "-": treat args as parameters of option with ASCII code 1 */
 static const char ulimit_opt_string[] = "-HSa"
+static const char ulimit_opt_string[] ALIGN1 = "-HSa"
 #ifdef RLIMIT_FSIZE
             "f::"
 …
     if (val == RLIM_INFINITY)
         printf("unlimited\n");
+        puts("unlimited");
     else {
         val >>= l->factor_shift;
 …
             break;
+        }
     } /* while (there are options) */

Context Navigation

Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/shell

Legend:

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

branches/3.3/mindi-busybox/shell/ash_test/ash-quoting/dollar_squote_bash1.right

branches/3.3/mindi-busybox/shell/ash_test/ash-quoting/dollar_squote_bash1.tests

branches/3.3/mindi-busybox/shell/ash_test/printenv.c

branches/3.3/mindi-busybox/shell/ash_test/run-all

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

branches/3.3/mindi-busybox/shell/hush_test/hush-misc/func_args1.tests

branches/3.3/mindi-busybox/shell/math.c

branches/3.3/mindi-busybox/shell/math.h

branches/3.3/mindi-busybox/shell/random.c

branches/3.3/mindi-busybox/shell/random.h

branches/3.3/mindi-busybox/shell/shell_common.c

Download in other formats: