Merge branch 'origin/master' (early part)

4 files changed, 109 insertions, 77 deletions

diff --git a/shell/ash.c b/shell/ash.c
index 308cc0273..f7fad88cd 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -5977,7 +5977,7 @@ removerecordregions(int endoff)
                 return;
 
         if (ifsfirst.endoff > endoff) {
-                while (ifsfirst.next != NULL) {
+                while (ifsfirst.next) {
                         struct ifsregion *ifsp;
                         INT_OFF;
                         ifsp = ifsfirst.next->next;
@@ -5985,9 +5985,9 @@ removerecordregions(int endoff)
                         ifsfirst.next = ifsp;
                         INT_ON;
                 }
-                if (ifsfirst.begoff > endoff)
+                if (ifsfirst.begoff > endoff) {
                         ifslastp = NULL;
-                else {
+                } else {
                         ifslastp = &ifsfirst;
                         ifsfirst.endoff = endoff;
                 }
@@ -5996,8 +5996,8 @@ removerecordregions(int endoff)
 
         ifslastp = &ifsfirst;
         while (ifslastp->next && ifslastp->next->begoff < endoff)
-                ifslastp=ifslastp->next;
-        while (ifslastp->next != NULL) {
+                ifslastp = ifslastp->next;
+        while (ifslastp->next) {
                 struct ifsregion *ifsp;
                 INT_OFF;
                 ifsp = ifslastp->next->next;
@@ -6205,9 +6205,9 @@ expbackq(union node *cmd, int quoted, int quotes)
 
         if (quoted == 0)
                 recordregion(startloc, dest - (char *)stackblock(), 0);
-        TRACE(("evalbackq: size=%d: \"%.*s\"\n",
-                (dest - (char *)stackblock()) - startloc,
-                (dest - (char *)stackblock()) - startloc,
+        TRACE(("evalbackq: size:%d:'%.*s'\n",
+                (int)((dest - (char *)stackblock()) - startloc),
+                (int)((dest - (char *)stackblock()) - startloc),
                 stackblock() + startloc));
 }
 
@@ -6426,42 +6426,16 @@ argstr(char *p, int flags, struct strlist *var_str_list)
 }
 
 static char *
-scanleft(char *startp, char *rmesc, char *rmescend UNUSED_PARAM, char *str, int quotes,
-        int zero)
-{
-// This commented out code was added by James Simmons <jsimmons@infradead.org>
-// as part of a larger change when he added support for ${var/a/b}.
-// However, it broke # and % operators:
-//
-//var=ababcdcd
-//                 ok       bad
-//echo ${var#ab}   abcdcd   abcdcd
-//echo ${var##ab}  abcdcd   abcdcd
-//echo ${var#a*b}  abcdcd   ababcdcd  (!)
-//echo ${var##a*b} cdcd     cdcd
-//echo ${var#?}    babcdcd  ababcdcd  (!)
-//echo ${var##?}   babcdcd  babcdcd
-//echo ${var#*}    ababcdcd babcdcd   (!)
-//echo ${var##*}
-//echo ${var%cd}   ababcd   ababcd
-//echo ${var%%cd}  ababcd   abab      (!)
-//echo ${var%c*d}  ababcd   ababcd
-//echo ${var%%c*d} abab     ababcdcd  (!)
-//echo ${var%?}    ababcdc  ababcdc
-//echo ${var%%?}   ababcdc  ababcdcd  (!)
-//echo ${var%*}    ababcdcd ababcdcd
-//echo ${var%%*}
-//
-// Commenting it back out helped. Remove it completely if it really
-// is not needed.
-
-        char *loc, *loc2; //, *full;
+scanleft(char *startp, char *rmesc, char *rmescend UNUSED_PARAM,
+                char *pattern, int quotes, int zero)
+{
+        char *loc, *loc2;
         char c;
 
         loc = startp;
         loc2 = rmesc;
         do {
-                int match; // = strlen(str);
+                int match;
                 const char *s = loc2;
 
                 c = *loc2;
@@ -6469,35 +6443,22 @@ scanleft(char *startp, char *rmesc, char *rmescend UNUSED_PARAM, char *str, int
                         *loc2 = '\0';
                         s = rmesc;
                 }
-                match = pmatch(str, s); // this line was deleted
-
-//              // chop off end if its '*'
-//              full = strrchr(str, '*');
-//              if (full && full != str)
-//                      match--;
-//
-//              // If str starts with '*' replace with s.
-//              if ((*str == '*') && strlen(s) >= match) {
-//                      full = xstrdup(s);
-//                      strncpy(full+strlen(s)-match+1, str+1, match-1);
-//              } else
-//                      full = xstrndup(str, match);
-//              match = strncmp(s, full, strlen(full));
-//              free(full);
-//
+                match = pmatch(pattern, s);
+
                 *loc2 = c;
-                if (match) // if (!match)
+                if (match)
                         return loc;
                 if (quotes && (unsigned char)*loc == CTLESC)
                         loc++;
                 loc++;
                 loc2++;
         } while (c);
-        return 0;
+        return NULL;
 }
 
 static char *
-scanright(char *startp, char *rmesc, char *rmescend, char *pattern, int quotes, int match_at_start)
+scanright(char *startp, char *rmesc, char *rmescend,
+                char *pattern, int quotes, int match_at_start)
 {
 #if !ENABLE_ASH_OPTIMIZE_FOR_SIZE
         int try2optimize = match_at_start;
@@ -6563,7 +6524,7 @@ scanright(char *startp, char *rmesc, char *rmescend, char *pattern, int quotes,
                         }
                 }
         }
-        return 0;
+        return NULL;
 }
 
 static void varunset(const char *, const char *, const char *, int) NORETURN;
@@ -6583,16 +6544,18 @@ varunset(const char *end, const char *var, const char *umsg, int varflags)
                         msg = umsg;
                 }
         }
-        ash_msg_and_raise_error("%.*s: %s%s", end - var - 1, var, msg, tail);
+        ash_msg_and_raise_error("%.*s: %s%s", (int)(end - var - 1), var, msg, tail);
 }
 
 #if ENABLE_ASH_BASH_COMPAT
 static char *
-parse_sub_pattern(char *arg, int inquotes)
+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;
@@ -6606,11 +6569,23 @@ parse_sub_pattern(char *arg, int inquotes)
                         }
                 }
                 *idx++ = c;
-                if (!inquotes && c == '\\' && arg[1] == '\\')
-                        arg++; /* skip both \\, not just first one */
                 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;
 }
@@ -6748,7 +6723,7 @@ subevalvar(char *p, char *varname, int strloc, int subtype,
                 char *idx, *end;
 
                 if (!repl) {
-                        repl = parse_sub_pattern(str, varflags & VSQUOTE);
+                        repl = parse_sub_pattern(str, varflags);
                         //bb_error_msg("repl:'%s'", repl);
                         if (!repl)
                                 repl = nullstr;
@@ -6817,12 +6792,9 @@ subevalvar(char *p, char *varname, int strloc, int subtype,
                         }
 
                         if (subtype == VSREPLACE) {
+                                //bb_error_msg("tail:'%s', quotes:%x", idx, quotes);
                                 while (*idx) {
                                         char *restart_detect = stackblock();
-                                        if (quotes && *idx == '\\') {
-                                                STPUTC(CTLESC, expdest);
-                                                len++;
-                                        }
                                         STPUTC(*idx, expdest);
                                         if (stackblock() != restart_detect)
                                                 goto restart;
diff --git a/shell/ash_test/ash-vars/var_bash4.right b/shell/ash_test/ash-vars/var_bash4.right
index fc3a9e41c..600e8532f 100644
--- a/shell/ash_test/ash-vars/var_bash4.right
+++ b/shell/ash_test/ash-vars/var_bash4.right
@@ -1,4 +1,23 @@
-In assignment: a*b-backslashstar-
-Unquoted: a*b-backslashstar-
-Quoted: a*b-backslashstar-
+Source:        a*b\*c
+Replace str:   _\\_\z_
+Pattern:       single backslash and star: "replace literal star"
+In assignment: a_\_z_b\*c
+Unquoted:      a_\_z_b\*c
+Quoted:        a_\_\z_b\*c
+Pattern:       double backslash and star: "replace backslash and everything after it"
+In assignment: a*b_\_z_
+Unquoted:      a*b_\_z_
+Quoted:        a*b_\_\z_
+
+Source:        a\bc
+Replace str:   _\\_\z_
+Pattern:       single backslash and b: "replace b"
+In assignment: a\_\_z_c
+Unquoted:      a\_\_z_c
+Quoted:        a\_\_\z_c
+Pattern:       double backslash and b: "replace backslash and b"
+In assignment: a_\_z_c
+Unquoted:      a_\_z_c
+Quoted:        a_\_\z_c
+
 Done: 0
diff --git a/shell/ash_test/ash-vars/var_bash4.tests b/shell/ash_test/ash-vars/var_bash4.tests
index 3b323c576..d5470614b 100755
--- a/shell/ash_test/ash-vars/var_bash4.tests
+++ b/shell/ash_test/ash-vars/var_bash4.tests
@@ -1,6 +1,47 @@
-FOO='a*b\*c'
-BAR=${FOO//\\*/-backslashstar-}
-echo In assignment: "$BAR"
-echo Unquoted: ${FOO//\\*/-backslashstar-}
-echo Quoted: "${FOO//\\*/-backslashstar-}"
+# This testcase demonstrates that backslashes are treated differently
+# in 1st and 2nd parts of ${var/search/repl}:
+# if quoted ("${var/search/repl}"), and repl contains \a (a non-special char),
+# the backslash in repl stays; if unquoted, backslash is removed.
+# But search part does not act like that: \a is always converted to just a,
+# even in quotes.
+#
+# bash4 (and probably bash3 too): "Quoted:" results are different from
+# unquoted and assignment expansions - they have a backslash before z.
+
+v='a*b\*c'
+echo 'Source:       ' "$v"
+echo 'Replace str:  ' '_\\_\z_'
+
+echo 'Pattern:      ' 'single backslash and star: "replace literal star"'
+r=${v/\*/_\\_\z_}
+echo 'In assignment:' "$r"
+echo 'Unquoted:     ' ${v/\*/_\\_\z_}
+echo 'Quoted:       ' "${v/\*/_\\_\z_}"
+
+echo 'Pattern:      ' 'double backslash and star: "replace backslash and everything after it"'
+r=${v/\\*/_\\_\z_}
+echo 'In assignment:' "$r"
+echo 'Unquoted:     '  ${v/\\*/_\\_\z_}
+echo 'Quoted:       ' "${v/\\*/_\\_\z_}"
+
+echo
+
+v='a\bc'
+echo 'Source:       ' "$v"
+echo 'Replace str:  ' '_\\_\z_'
+
+echo 'Pattern:      ' 'single backslash and b: "replace b"'
+r=${v/\b/_\\_\z_}
+echo 'In assignment:' "$r"
+echo 'Unquoted:     '  ${v/\b/_\\_\z_}
+echo 'Quoted:       ' "${v/\b/_\\_\z_}"
+
+echo 'Pattern:      ' 'double backslash and b: "replace backslash and b"'
+r=${v/\\b/_\\_\z_}
+echo 'In assignment:' "$r"
+echo 'Unquoted:     '  ${v/\\b/_\\_\z_}
+echo 'Quoted:       ' "${v/\\b/_\\_\z_}"
+
+echo
+
 echo Done: $?
diff --git a/shell/hush.c b/shell/hush.c
index 0a420f685..df4058998 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -2788,7 +2788,7 @@ static NOINLINE int expand_vars_to_list(o_string *output, int n, char *arg, char
                         /* lookup the variable in question */
                         if (isdigit(var[0])) {
                                 /* parse_dollar() should have vetted var for us */
-                                i = xatoi_u(var);
+                                i = xatoi_positive(var);
                                 if (i < G.global_argc)
                                         val = G.global_argv[i];
                                 /* else val remains NULL: $N with too big N */