[fusl] Update fusl

fusl/src/regex/regcomp.c

 /*
   regcomp.c - TRE POSIX compatible regex compilation functions.
 
   Copyright (c) 2001-2009 Ville Laurikari <vl@iki.fi>
   All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
 
@@ skipping 690 matching lines @@
         *n = 0;
         for (;;) {
                 *n = 10 * *n + (*s - '0');
                 s++;
                 if (!isdigit(*s) || *n > RE_DUP_MAX)
                         break;
         }
         return s;
 }
 
-static reg_errcode_t parse_dup(tre_parse_ctx_t *ctx, const char *s)
+static const char *parse_dup(const char *s, int ere, int *pmin, int *pmax)
 {
         int min, max;
 
         s = parse_dup_count(s, &min);
         if (*s == ',')
                 s = parse_dup_count(s+1, &max);
         else
                 max = min;
 
         if (
                 (max < min && max >= 0) ||
                 max > RE_DUP_MAX ||
                 min > RE_DUP_MAX ||
                 min < 0 ||
-                (!(ctx->cflags & REG_EXTENDED) && *s++ != '\\') ||
+                (!ere && *s++ != '\\') ||
                 *s++ != '}'
         )
-                return REG_BADBR;
-
-        if (min == 0 && max == 0)
-                ctx->n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
-        else
-                ctx->n = tre_ast_new_iter(ctx->mem, ctx->n, min, max, 0);
-        if (!ctx->n)
-                return REG_ESPACE;
-        ctx->s = s;
-        return REG_OK;
+                return 0;
+        *pmin = min;
+        *pmax = max;
+        return s;
 }
 
 static int hexval(unsigned c)
 {
         if (c-'0'<10) return c-'0';
         c |= 32;
         if (c-'a'<6) return c-'a'+10;
         return -1;
 }
 
@@ skipping 78 matching lines @@
                                 c = hexval(s[i]);
                                 if (c < 0) break;
                                 v = 16*v + c;
                         }
                         s += i;
                         if (len == 8) {
                                 if (*s != '}')
                                         return REG_EBRACE;
                                 s++;
                         }
-                        node = tre_ast_new_literal(ctx->mem, v, v, ctx->position);
-                        ctx->position++;
+                        node = tre_ast_new_literal(ctx->mem, v, v, ctx->position++);
                         s--;
                         break;
+                case '{':
+                case '+':
+                case '?':
+                        /* extension: treat \+, \? as repetitions in BRE */
+                        /* reject repetitions after empty expression in BRE */
+                        if (!ere)
+                                return REG_BADRPT;
+                case '|':
+                        /* extension: treat \| as alternation in BRE */
+                        if (!ere) {
+                                node = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+                                s--;
+                                goto end;
+                        }
+                        /* fallthrough */
                 default:
                         if (!ere && (unsigned)*s-'1' < 9) {
                                 /* back reference */
                                 int val = *s - '0';
-                                node = tre_ast_new_literal(ctx->mem, BACKREF, val, ctx->position);
+                                node = tre_ast_new_literal(ctx->mem, BACKREF, val, ctx->position++);
                                 ctx->max_backref = MAX(val, ctx->max_backref);
                         } else {
                                 /* extension: accept unknown escaped char
                                    as a literal */
                                 goto parse_literal;
                         }
-                        ctx->position++;
                 }
                 s++;
                 break;
         case '.':
                 if (ctx->cflags & REG_NEWLINE) {
                         tre_ast_node_t *tmp1, *tmp2;
                         tmp1 = tre_ast_new_literal(ctx->mem, 0, '\n'-1, ctx->position++);
                         tmp2 = tre_ast_new_literal(ctx->mem, '\n'+1, TRE_CHAR_MAX, ctx->position++);
                         if (tmp1 && tmp2)
                                 node = tre_ast_new_union(ctx->mem, tmp1, tmp2);
@@ skipping 12 matching lines @@
                 s++;
                 break;
         case '$':
                 /* '$' is special everywhere in EREs, and in the end of the string in BREs. */
                 if (!ere && s[1])
                         goto parse_literal;
                 node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_EOL, -1);
                 s++;
                 break;
         case '*':
-        case '|':
+                return REG_BADPAT;
         case '{':
         case '+':
         case '?':
+                /* reject repetitions after empty expression in ERE */
+                if (ere)
+                        return REG_BADRPT;
+        case '|':
                 if (!ere)
                         goto parse_literal;
         case 0:
                 node = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
                 break;
         default:
 parse_literal:
                 len = mbtowc(&wc, s, -1);
                 if (len < 0)
                         return REG_BADPAT;
                 if (ctx->cflags & REG_ICASE && (tre_isupper(wc) || tre_islower(wc))) {
                         tre_ast_node_t *tmp1, *tmp2;
                         /* multiple opposite case characters are not supported */
                         tmp1 = tre_ast_new_literal(ctx->mem, tre_toupper(wc), tre_toupper(wc), ctx->position);
                         tmp2 = tre_ast_new_literal(ctx->mem, tre_tolower(wc), tre_tolower(wc), ctx->position);
                         if (tmp1 && tmp2)
                                 node = tre_ast_new_union(ctx->mem, tmp1, tmp2);
                         else
                                 node = 0;
                 } else {
                         node = tre_ast_new_literal(ctx->mem, wc, wc, ctx->position);
                 }
                 ctx->position++;
                 s += len;
                 break;
         }
+end:
         if (!node)
                 return REG_ESPACE;
         ctx->n = node;
         ctx->s = s;
         return REG_OK;
 }
 
 #define PUSHPTR(err, s, v) do { \
         if ((err = tre_stack_push_voidptr(s, v)) != REG_OK) \
                 return err; \
@@ skipping 34 matching lines @@
                         if (!ctx->n)
                                 return REG_ESPACE;
                 } else {
                         err = parse_atom(ctx, s);
                         if (err != REG_OK)
                                 return err;
                         s = ctx->s;
                 }
 
         parse_iter:
-                /* extension: repetitions are accepted after an empty node
-                   eg. (+), ^*, a$?, a|{2} */
-                switch (*s) {
-                case '+':
-                case '?':
-                        if (!ere)
+                /* extension: repetitions are rejected after an empty node
+                   eg. (+), |*, {2}, but assertions are not treated as empty
+                   so ^* or $? are accepted currently. */
+                for (;;) {
+                        int min, max;
+
+                        if (*s!='\\' && *s!='*') {
+                                if (!ere)
+                                        break;
+                                if (*s!='+' && *s!='?' && *s!='{')
+                                        break;
+                        }
+                        if (*s=='\\' && ere)
                                 break;
-                        /* fallthrough */
-                case '*':;
-                        int min=0, max=-1;
-                        if (*s == '+')
-                                min = 1;
-                        if (*s == '?')
-                                max = 1;
-                        s++;
-                        ctx->n = tre_ast_new_iter(ctx->mem, ctx->n, min, max, 0);
-                        if (!ctx->n)
-                                return REG_ESPACE;
+                        /* extension: treat \+, \? as repetitions in BRE */
+                        if (*s=='\\' && s[1]!='+' && s[1]!='?' && s[1]!='{')
+                                break;
+                        if (*s=='\\')
+                                s++;
+
                         /* extension: multiple consecutive *+?{,} is unspecified,
                            but (a+)+ has to be supported so accepting a++ makes
                            sense, note however that the RE_DUP_MAX limit can be
                            circumvented: (a{255}){255} uses a lot of memory.. */
-                        goto parse_iter;
-                case '\\':
-                        if (ere || s[1] != '{')
-                                break;
-                        s++;
-                        goto parse_brace;
-                case '{':
-                        if (!ere)
-                                break;
-                parse_brace:
-                        err = parse_dup(ctx, s+1);
-                        if (err != REG_OK)
-                                return err;
-                        s = ctx->s;
-                        goto parse_iter;
+                        if (*s=='{') {
+                                s = parse_dup(s+1, ere, &min, &max);
+                                if (!s)
+                                        return REG_BADBR;
+                        } else {
+                                min=0;
+                                max=-1;
+                                if (*s == '+')
+                                        min = 1;
+                                if (*s == '?')
+                                        max = 1;
+                                s++;
+                        }
+                        if (max == 0)
+                                ctx->n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+                        else
+                                ctx->n = tre_ast_new_iter(ctx->mem, ctx->n, min, max, 0);
+                        if (!ctx->n)
+                                return REG_ESPACE;
                 }
 
                 nbranch = tre_ast_new_catenation(ctx->mem, nbranch, ctx->n);
                 if ((ere && *s == '|') ||
                     (ere && *s == ')' && depth) ||
                     (!ere && *s == '\\' && s[1] == ')') ||
+                    /* extension: treat \| as alternation in BRE */
+                    (!ere && *s == '\\' && s[1] == '|') ||
                     !*s) {
                         /* extension: empty branch is unspecified (), (|a), (a|)
                            here they are not rejected but match on empty string */
                         int c = *s;
                         nunion = tre_ast_new_union(ctx->mem, nunion, nbranch);
                         nbranch = 0;
-                        if (c != '|') {
+
+                        if (c == '\\' && s[1] == '|') {
+                                s+=2;
+                        } else if (c == '|') {
+                                s++;
+                        } else {
                                 if (c == '\\') {
                                         if (!depth) return REG_EPAREN;
                                         s+=2;
                                 } else if (c == ')')
                                         s++;
                                 depth--;
                                 err = marksub(ctx, nunion, tre_stack_pop_int(stack));
                                 if (err != REG_OK)
                                         return err;
                                 if (!c && depth<0) {
                                         ctx->submatch_id = subid;
                                         return REG_OK;
                                 }
                                 if (!c || depth<0)
                                         return REG_EPAREN;
                                 nbranch = tre_stack_pop_voidptr(stack);
                                 nunion = tre_stack_pop_voidptr(stack);
                                 goto parse_iter;
                         }
-                        s++;
                 }
         }
 }
 
 
 /***********************************************************************
  from tre-compile.c
 ***********************************************************************/
 
 
@@ skipping 1608 matching lines @@
   tre_submatch_data_t *submatch_data;
   tre_tag_direction_t *tag_directions = NULL;
   reg_errcode_t errcode;
   tre_mem_t mem;
 
   /* Parse context. */
   tre_parse_ctx_t parse_ctx;
 
   /* Allocate a stack used throughout the compilation process for various
      purposes. */
-  stack = tre_stack_new(512, 10240, 128);
+  stack = tre_stack_new(512, 1024000, 128);
   if (!stack)
     return REG_ESPACE;
   /* Allocate a fast memory allocator. */
   mem = tre_mem_new();
   if (!mem)
     {
       tre_stack_destroy(stack);
       return REG_ESPACE;
     }
 
@@ skipping 223 matching lines @@
     }
 
   if (tnfa->tag_directions)
     xfree(tnfa->tag_directions);
   if (tnfa->firstpos_chars)
     xfree(tnfa->firstpos_chars);
   if (tnfa->minimal_tags)
     xfree(tnfa->minimal_tags);
   xfree(tnfa);
 }