Patch from Shaun Jackman:

> This patch modfies expr to use portable POSIX regex rather than BSD
> regex.
...
> This updated patch implements an anchored regex by checking that the
> match starts at offset 0.

More to the point, this patch uses the same regex that sed.c is already using
(opportunity to suck in less library code), and even building a dynamically
linked busybox with just expr the result is a slightly smaller binary (by 94
bytes, I dunno what nm --size-sort has to say about it because I didn't build
with debug info, since that changes the binary size a lot by disabling
optimization...)

Your mileage may vary.  Handle with caution.  Do not taunt happy fun ball.

diff --git a/coreutils/expr.c b/coreutils/expr.c
index cbbd4cd0399649e12cb89889bebd6d34ab1b1d26..3f052d92a74f301e56206343629d70b9cce525ee 100644 (file)
--- a/coreutils/expr.c
+++ b/coreutils/expr.c
@@ -245,10 +245,9 @@ static int arithmetic_common (VALUE *l, VALUE *r, int op)
 static VALUE *docolon (VALUE *sv, VALUE *pv)
 {
        VALUE *v;
-       const char *errmsg;
-       struct re_pattern_buffer re_buffer;
-       struct re_registers re_regs;
-       int len;
+       regex_t re_buffer;
+       const int NMATCH = 2;
+       regmatch_t re_regs[NMATCH];
 
        tostring (sv);
        tostring (pv);
@@ -260,27 +259,22 @@ of a basic regular expression is not portable; it is being ignored",
                pv->u.s);
        }
 
-       len = strlen (pv->u.s);
        memset (&re_buffer, 0, sizeof (re_buffer));
-       memset (&re_regs, 0, sizeof (re_regs));
-       re_buffer.allocated = 2 * len;
-       re_buffer.buffer = (unsigned char *) xmalloc (re_buffer.allocated);
-       re_buffer.translate = 0;
-       re_syntax_options = RE_SYNTAX_POSIX_BASIC;
-       errmsg = re_compile_pattern (pv->u.s, len, &re_buffer);
-       if (errmsg) {
-               bb_error_msg_and_die("%s", errmsg);
-       }
-
-       len = re_match (&re_buffer, sv->u.s, strlen (sv->u.s), 0, &re_regs);
-       if (len >= 0) {
+       memset (re_regs, 0, sizeof (*re_regs));
+       if( regcomp (&re_buffer, pv->u.s, 0) != 0 )
+               bb_error_msg_and_die("Invalid regular expression");
+
+       /* expr uses an anchored pattern match, so check that there was a
+        * match and that the match starts at offset 0. */
+       if (regexec (&re_buffer, sv->u.s, NMATCH, re_regs, 0) != REG_NOMATCH &&
+                       re_regs[0].rm_so == 0) {
                /* Were \(...\) used? */
-               if (re_buffer.re_nsub > 0) { /* was (re_regs.start[1] >= 0) */
-                       sv->u.s[re_regs.end[1]] = '\0';
-                       v = str_value (sv->u.s + re_regs.start[1]);
+               if (re_buffer.re_nsub > 0) {
+                       sv->u.s[re_regs[1].rm_eo] = '\0';
+                       v = str_value (sv->u.s + re_regs[1].rm_so);
                }
                else
-                       v = int_value (len);
+                       v = int_value (re_regs[0].rm_eo);
        }
        else {
                /* Match failed -- return the right kind of null.  */
@@ -289,7 +283,6 @@ of a basic regular expression is not portable; it is being ignored",
                else
                        v = int_value (0);
        }
-       free (re_buffer.buffer);
        return v;
 }