/[pcre]/code/trunk/pcre_compile.c

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 240 by ph10,
Tue Sep 11 15:47:20 2007 UTC
+revision 340 by ph10,
Fri Apr 18 20:00:21 2008 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2007 University of Cambridge
+            Copyright (c) 1997-2008 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 140 
 static const short int escapes[] = {
  #endif
  /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
  searched linearly. Put all the names into a single string, in order to reduce
  the number of relocations when a shared library is dynamically linked. */
  typedef struct verbitem {
 Line 150 
 typedef struct verbitem {
  } verbitem;
  static const char verbnames[] =
    "ACCEPT\0"
    "COMMIT\0"
    "F\0"
    "FAIL\0"
    "PRUNE\0"
    "SKIP\0"
    "THEN";
- static verbitem verbs[] = {
+ static const verbitem verbs[] = {
    { 6, OP_ACCEPT },
    { 6, OP_COMMIT },
    { 1, OP_FAIL },
 Line 168 
 static verbitem verbs[] = {
    { 4, OP_THEN  }
  };
- static int verbcount = sizeof(verbs)/sizeof(verbitem);
+ static const int verbcount = sizeof(verbs)/sizeof(verbitem);
  /* Tables of names of POSIX character classes and their lengths. The names are
  now all in a single string, to reduce the number of relocations when a shared
  library is dynamically loaded. The list of lengths is terminated by a zero
  length entry. The first three must be alpha, lower, upper, as this is assumed
  for handling case independence. */
  static const char posix_names[] =
    "alpha\0"  "lower\0"  "upper\0"  "alnum\0"  "ascii\0"  "blank\0"
    "cntrl\0"  "digit\0"  "graph\0"  "print\0"  "punct\0"  "space\0"
    "word\0"   "xdigit";
  static const uschar posix_name_lengths[] = {
 Line 219 
 static const int posix_class_maps[] = {
  /* The texts of compile-time error messages. These are "char *" because they
  are passed to the outside world. Do not ever re-use any error number, because
  they are documented. Always add a new error instead. Messages marked DEAD below
  are no longer used. This used to be a table of strings, but in order to reduce
  the number of relocations needed when a shared library is loaded dynamically,
  it is now one long string. We cannot use a table of offsets, because the
  lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
  simply count through to the one we want - this isn't a performance issue
  because these strings are used only when there is a compilation error. */
  static const char error_texts[] =
 Line 241 
 static const char error_texts[] =
    /* 10 */
    "operand of unlimited repeat could match the empty string\0"  /** DEAD **/
    "internal error: unexpected repeat\0"
-   "unrecognized character after (?\0"
+   "unrecognized character after (? or (?-\0"
    "POSIX named classes are supported only within a class\0"
    "missing )\0"
    /* 15 */
 Line 295 
 static const char error_texts[] =
    /* 55 */
    "repeating a DEFINE group is not allowed\0"
    "inconsistent NEWLINE options\0"
-   "\\g is not followed by a braced name or an optionally braced non-zero number\0"
+   "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
-   "(?+ or (?- or (?(+ or (?(- must be followed by a non-zero number\0"
+   "a numbered reference must not be zero\0"
    "(*VERB) with an argument is not supported\0"
    /* 60 */
    "(*VERB) not recognized\0"
-   "number is too big";
+   "number is too big\0"
+   "subpattern name expected\0"
+   "digit expected after (?+\0"
+   "] is an invalid data character in JavaScript compatibility mode";
  /* Table to identify digits and hex digits. This is used when compiling
-Line 439 
 static BOOL
+Line 442 
 static BOOL
  *            Find an error text                  *
  *************************************************/
  /* The error texts are now all in one long string, to save on relocations. As
  some of the text is of unknown length, we can't use a table of offsets.
  Instead, just count through the strings. This is not a performance issue
  because it happens only when there has been a compilation error.
  Argument:   the error number
-Line 452 
 static const char *
+Line 455 
 static const char *
  find_error_text(int n)
  {
  const char *s = error_texts;
  for (; n > 0; n--) while (*s++ != 0);
  return s;
  }
-Line 496 
 ptr--;                            /* Set
+Line 499 
 ptr--;                            /* Set
  if (c == 0) *errorcodeptr = ERR1;
- /* Non-alphamerics are literals. For digits or letters, do an initial lookup in
+ /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
- a table. A non-zero result is something that can be returned immediately.
+ in a table. A non-zero result is something that can be returned immediately.
  Otherwise further processing may be required. */
  #ifndef EBCDIC  /* ASCII coding */
- else if (c < '0' || c > 'z') {}                           /* Not alphameric */
+ else if (c < '0' || c > 'z') {}                           /* Not alphanumeric */
  else if ((i = escapes[c - '0']) != 0) c = i;
  #else           /* EBCDIC coding */
- else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphameric */
+ else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphanumeric */
  else if ((i = escapes[c - 0x48]) != 0)  c = i;
  #endif
-Line 529 
 else
+Line 532 
 else
      *errorcodeptr = ERR37;
      break;
-     /* \g must be followed by a number, either plain or braced. If positive, it
+     /* \g must be followed by one of a number of specific things:
-     is an absolute backreference. If negative, it is a relative backreference.
-     This is a Perl 5.10 feature. Perl 5.10 also supports \g{name} as a
+     (1) A number, either plain or braced. If positive, it is an absolute
-     reference to a named group. This is part of Perl's movement towards a
+     backreference. If negative, it is a relative backreference. This is a Perl
-     unified syntax for back references. As this is synonymous with \k{name}, we
+.10 feature.
-     fudge it up by pretending it really was \k. */
+     (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
+     is part of Perl's movement towards a unified syntax for back references. As
+     this is synonymous with \k{name}, we fudge it up by pretending it really
+     was \k.
+     (3) For Oniguruma compatibility we also support \g followed by a name or a
+     number either in angle brackets or in single quotes. However, these are
+     (possibly recursive) subroutine calls, _not_ backreferences. Just return
+     the -ESC_g code (cf \k). */
      case 'g':
+     if (ptr[1] == '<' || ptr[1] == '\'')
+       {
+       c = -ESC_g;
+       break;
+       }
+     /* Handle the Perl-compatible cases */
      if (ptr[1] == '{')
        {
        const uschar *p;
-Line 563 
 else
+Line 583 
 else
      while ((digitab[ptr[1]] & ctype_digit) != 0)
        c = c * 10 + *(++ptr) - '0';
-     if (c < 0)
+     if (c < 0)   /* Integer overflow */
        {
        *errorcodeptr = ERR61;
        break;
        }
-     if (c == 0 || (braced && *(++ptr) != '}'))
+     if (braced && *(++ptr) != '}')
        {
        *errorcodeptr = ERR57;
        break;
        }
+     if (c == 0)
+       {
+       *errorcodeptr = ERR58;
+       break;
+       }
      if (negated)
        {
-Line 609 
 else
+Line 635 
 else
        c -= '0';
        while ((digitab[ptr[1]] & ctype_digit) != 0)
          c = c * 10 + *(++ptr) - '0';
-       if (c < 0)
+       if (c < 0)    /* Integer overflow */
          {
          *errorcodeptr = ERR61;
          break;
-Line 722 
 else
+Line 748 
 else
      break;
      /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
-     other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
+     other alphanumeric following \ is an error if PCRE_EXTRA was set;
-     for Perl compatibility, it is a literal. This code looks a bit odd, but
+     otherwise, for Perl compatibility, it is a literal. This code looks a bit
-     there used to be some cases other than the default, and there may be again
+     odd, but there used to be some cases other than the default, and there may
-     in future, so I haven't "optimized" it. */
+     be again in future, so I haven't "optimized" it. */
      default:
      if ((options & PCRE_EXTRA) != 0) switch(c)
-Line 982 
 for (; *ptr != 0; ptr++)
+Line 1008 
 for (; *ptr != 0; ptr++)
      continue;
      }
-   /* Skip over character classes */
+   /* Skip over character classes; this logic must be similar to the way they
+   are handled for real. If the first character is '^', skip it. Also, if the
+   first few characters (either before or after ^) are \Q\E or \E we skip them
+   too. This makes for compatibility with Perl. */
    if (*ptr == '[')
      {
+     BOOL negate_class = FALSE;
+     for (;;)
+       {
+       int c = *(++ptr);
+       if (c == '\\')
+         {
+         if (ptr[1] == 'E') ptr++;
+           else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;
+             else break;
+         }
+       else if (!negate_class && c == '^')
+         negate_class = TRUE;
+       else break;
+       }
+     /* If the next character is ']', it is a data character that must be
+     skipped. */
+     if (ptr[1] == ']') ptr++;
      while (*(++ptr) != ']')
        {
        if (*ptr == 0) return -1;
-Line 1506 
 for (;;)
+Line 1555 
 for (;;)
  can match the empty string or not. It is called from could_be_empty()
  below and from compile_branch() when checking for an unlimited repeat of a
  group that can match nothing. Note that first_significant_code() skips over
- assertions. If we hit an unclosed bracket, we return "empty" - this means we've
+ backward and negative forward assertions when its final argument is TRUE. If we
- struck an inner bracket whose current branch will already have been scanned.
+ hit an unclosed bracket, we return "empty" - this means we've struck an inner
+ bracket whose current branch will already have been scanned.
  Arguments:
    code        points to start of search
-Line 1529 
 for (code = first_significant_code(code
+Line 1579 
 for (code = first_significant_code(code
    c = *code;
+   /* Skip over forward assertions; the other assertions are skipped by
+   first_significant_code() with a TRUE final argument. */
+   if (c == OP_ASSERT)
+     {
+     do code += GET(code, 1); while (*code == OP_ALT);
+     c = *code;
+     continue;
+     }
    /* Groups with zero repeats can of course be empty; skip them. */
-   if (c == OP_BRAZERO || c == OP_BRAMINZERO)
+   if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO)
      {
      code += _pcre_OP_lengths[c];
      do code += GET(code, 1); while (*code == OP_ALT);
-Line 1724 
 return TRUE;
+Line 1784 
 return TRUE;
  *************************************************/
  /* This function is called when the sequence "[:" or "[." or "[=" is
- encountered in a character class. It checks whether this is followed by an
+ encountered in a character class. It checks whether this is followed by a
- optional ^ and then a sequence of letters, terminated by a matching ":]" or
+ sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
- ".]" or "=]".
+ reach an unescaped ']' without the special preceding character, return FALSE.
+ Originally, this function only recognized a sequence of letters between the
+ terminators, but it seems that Perl recognizes any sequence of characters,
+ though of course unknown POSIX names are subsequently rejected. Perl gives an
+ "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
+ didn't consider this to be a POSIX class. Likewise for [:1234:].
+ The problem in trying to be exactly like Perl is in the handling of escapes. We
+ have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
+ class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
+ below handles the special case of \], but does not try to do any other escape
+ processing. This makes it different from Perl for cases such as [:l\ower:]
+ where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize
+ "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,
+ I think.
- Argument:
+ Arguments:
    ptr      pointer to the initial [
    endptr   where to return the end pointer
-   cd       pointer to compile data
  Returns:   TRUE or FALSE
  */
  static BOOL
- check_posix_syntax(const uschar *ptr, const uschar **endptr, compile_data *cd)
+ check_posix_syntax(const uschar *ptr, const uschar **endptr)
  {
  int terminator;          /* Don't combine these lines; the Solaris cc */
  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
- if (*(++ptr) == '^') ptr++;
+ for (++ptr; *ptr != 0; ptr++)
- while ((cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
- if (*ptr == terminator && ptr[1] == ']')
    {
-   *endptr = ptr;
+   if (*ptr == '\\' && ptr[1] == ']') ptr++; else
-   return TRUE;
+     {
+     if (*ptr == ']') return FALSE;
+     if (*ptr == terminator && ptr[1] == ']')
+       {
+       *endptr = ptr;
+       return TRUE;
+       }
+     }
    }
  return FALSE;
  }
-Line 1777 
 while (posix_name_lengths[yield] != 0)
+Line 1856 
 while (posix_name_lengths[yield] != 0)
    {
    if (len == posix_name_lengths[yield] &&
      strncmp((const char *)ptr, pn, len) == 0) return yield;
    pn += posix_name_lengths[yield] + 1;
    yield++;
    }
  return -1;
-Line 1792 
 return -1;
+Line 1871 
 return -1;
  that is referenced. This means that groups can be replicated for fixed
  repetition simply by copying (because the recursion is allowed to refer to
  earlier groups that are outside the current group). However, when a group is
- optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
+ optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
- it, after it has been compiled. This means that any OP_RECURSE items within it
+ inserted before it, after it has been compiled. This means that any OP_RECURSE
- that refer to the group itself or any contained groups have to have their
+ items within it that refer to the group itself or any contained groups have to
- offsets adjusted. That one of the jobs of this function. Before it is called,
+ have their offsets adjusted. That one of the jobs of this function. Before it
- the partially compiled regex must be temporarily terminated with OP_END.
+ is called, the partially compiled regex must be temporarily terminated with
+ OP_END.
  This function has been extended with the possibility of forward references for
  recursions and subroutine calls. It must also check the list of such references
-Line 1827 
 while ((ptr = (uschar *)find_recurse(ptr
+Line 1907 
 while ((ptr = (uschar *)find_recurse(ptr
    /* See if this recursion is on the forward reference list. If so, adjust the
    reference. */
    for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
      {
      offset = GET(hc, 0);
-Line 2081 
 if (next >= 0) switch(op_code)
+Line 2161 
 if (next >= 0) switch(op_code)
    /* For OP_NOT, "item" must be a single-byte character. */
    case OP_NOT:
-   if (next < 0) return FALSE;  /* Not a character */
    if (item == next) return TRUE;
    if ((options & PCRE_CASELESS) == 0) return FALSE;
  #ifdef SUPPORT_UTF8
-Line 2344 
 uschar classbits[32];
+Line 2423 
 uschar classbits[32];
  BOOL class_utf8;
  BOOL utf8 = (options & PCRE_UTF8) != 0;
  uschar *class_utf8data;
+ uschar *class_utf8data_base;
  uschar utf8_char[6];
  #else
  BOOL utf8 = FALSE;
-Line 2383 
 req_caseopt = ((options & PCRE_CASELESS)
+Line 2463 
 req_caseopt = ((options & PCRE_CASELESS)
  for (;; ptr++)
    {
    BOOL negate_class;
+   BOOL should_flip_negation;
    BOOL possessive_quantifier;
    BOOL is_quantifier;
    BOOL is_recurse;
-Line 2402 
 for (;; ptr++)
+Line 2483 
 for (;; ptr++)
    /* Get next byte in the pattern */
    c = *ptr;
    /* If we are in the pre-compile phase, accumulate the length used for the
    previous cycle of this loop. */
-Line 2597 
 for (;; ptr++)
+Line 2678 
 for (;; ptr++)
      opcode is compiled. It may optionally have a bit map for characters < 256,
      but those above are are explicitly listed afterwards. A flag byte tells
      whether the bitmap is present, and whether this is a negated class or not.
-     */
+     In JavaScript compatibility mode, an isolated ']' causes an error. In
+     default (Perl) mode, it is treated as a data character. */
+     case ']':
+     if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+       {
+       *errorcodeptr = ERR64;
+       goto FAILED;
+       }
+     goto NORMAL_CHAR;
      case '[':
      previous = code;
-Line 2606 
 for (;; ptr++)
+Line 2697 
 for (;; ptr++)
      they are encountered at the top level, so we'll do that too. */
      if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
-         check_posix_syntax(ptr, &tempptr, cd))
+         check_posix_syntax(ptr, &tempptr))
        {
        *errorcodeptr = (ptr[1] == ':')? ERR13 : ERR31;
        goto FAILED;
-Line 2631 
 for (;; ptr++)
+Line 2722 
 for (;; ptr++)
        else break;
        }
+     /* If a class contains a negative special such as \S, we need to flip the
+     negation flag at the end, so that support for characters > 255 works
+     correctly (they are all included in the class). */
+     should_flip_negation = FALSE;
      /* Keep a count of chars with values < 256 so that we can optimize the case
      of just a single character (as long as it's < 256). However, For higher
      valued UTF-8 characters, we don't yet do any optimization. */
-Line 2648 
 for (;; ptr++)
+Line 2745 
 for (;; ptr++)
  #ifdef SUPPORT_UTF8
      class_utf8 = FALSE;                       /* No chars >= 256 */
      class_utf8data = code + LINK_SIZE + 2;    /* For UTF-8 items */
+     class_utf8data_base = class_utf8data;     /* For resetting in pass 1 */
  #endif
      /* Process characters until ] is reached. By writing this as a "do" it
-Line 2663 
 for (;; ptr++)
+Line 2761 
 for (;; ptr++)
          {                           /* Braces are required because the */
          GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
          }
+       /* In the pre-compile phase, accumulate the length of any UTF-8 extra
+       data and reset the pointer. This is so that very large classes that
+       contain a zillion UTF-8 characters no longer overwrite the work space
+       (which is on the stack). */
+       if (lengthptr != NULL)
+         {
+         *lengthptr += class_utf8data - class_utf8data_base;
+         class_utf8data = class_utf8data_base;
+         }
  #endif
        /* Inside \Q...\E everything is literal except \E */
-Line 2686 
 for (;; ptr++)
+Line 2796 
 for (;; ptr++)
        if (c == '[' &&
            (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
-           check_posix_syntax(ptr, &tempptr, cd))
+           check_posix_syntax(ptr, &tempptr))
          {
          BOOL local_negate = FALSE;
          int posix_class, taboffset, tabopt;
-Line 2703 
 for (;; ptr++)
+Line 2813 
 for (;; ptr++)
          if (*ptr == '^')
            {
            local_negate = TRUE;
+           should_flip_negation = TRUE;  /* Note negative special */
            ptr++;
            }
-Line 2777 
 for (;; ptr++)
+Line 2888 
 for (;; ptr++)
          c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
          if (*errorcodeptr != 0) goto FAILED;
-         if (-c == ESC_b) c = '\b';       /* \b is backslash in a class */
+         if (-c == ESC_b) c = '\b';       /* \b is backspace in a class */
          else if (-c == ESC_X) c = 'X';   /* \X is literal X in a class */
          else if (-c == ESC_R) c = 'R';   /* \R is literal R in a class */
          else if (-c == ESC_Q)            /* Handle start of quoted string */
-Line 2805 
 for (;; ptr++)
+Line 2916 
 for (;; ptr++)
              continue;
              case ESC_D:
+             should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
              continue;
-Line 2813 
 for (;; ptr++)
+Line 2925 
 for (;; ptr++)
              continue;
              case ESC_W:
+             should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
              continue;
-Line 2822 
 for (;; ptr++)
+Line 2935 
 for (;; ptr++)
              continue;
              case ESC_S:
+             should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
              classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */
              continue;
-             case ESC_E: /* Perl ignores an orphan \E */
-             continue;
              default:    /* Not recognized; fall through */
              break;      /* Need "default" setting to stop compiler warning. */
              }
-Line 3063 
 for (;; ptr++)
+Line 3174 
 for (;; ptr++)
            d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
            if (*errorcodeptr != 0) goto FAILED;
-           /* \b is backslash; \X is literal X; \R is literal R; any other
+           /* \b is backspace; \X is literal X; \R is literal R; any other
            special means the '-' was literal */
            if (d < 0)
-Line 3327 
 we set the flag only if there is a liter
+Line 3438 
 we set the flag only if there is a liter
      zeroreqbyte = reqbyte;
      /* If there are characters with values > 255, we have to compile an
-     extended class, with its own opcode. If there are no characters < 256,
+     extended class, with its own opcode, unless there was a negated special
-     we can omit the bitmap in the actual compiled code. */
+     such as \S in the class, because in that case all characters > 255 are in
+     the class, so any that were explicitly given as well can be ignored. If
+     (when there are explicit characters > 255 that must be listed) there are no
+     characters < 256, we can omit the bitmap in the actual compiled code. */
  #ifdef SUPPORT_UTF8
-     if (class_utf8)
+     if (class_utf8 && !should_flip_negation)
        {
        *class_utf8data++ = XCL_END;    /* Marks the end of extra data */
        *code++ = OP_XCLASS;
-Line 3357 
 we set the flag only if there is a liter
+Line 3471 
 we set the flag only if there is a liter
        }
  #endif
-     /* If there are no characters > 255, negate the 32-byte map if necessary,
+     /* If there are no characters > 255, set the opcode to OP_CLASS or
-     and copy it into the code vector. If this is the first thing in the branch,
+     OP_NCLASS, depending on whether the whole class was negated and whether
-     there can be no first char setting, whatever the repeat count. Any reqbyte
+     there were negative specials such as \S in the class. Then copy the 32-byte
-     setting must remain unchanged after any kind of repeat. */
+     map into the code vector, negating it if necessary. */
+     *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
      if (negate_class)
        {
-       *code++ = OP_NCLASS;
        if (lengthptr == NULL)    /* Save time in the pre-compile phase */
          for (c = 0; c < 32; c++) code[c] = ~classbits[c];
        }
      else
        {
-       *code++ = OP_CLASS;
        memcpy(code, classbits, 32);
        }
      code += 32;
-Line 3764 
 we set the flag only if there is a liter
+Line 3877 
 we set the flag only if there is a liter
        if (repeat_min == 0)
          {
-         /* If the maximum is also zero, we just omit the group from the output
+         /* If the maximum is also zero, we used to just omit the group from the
-         altogether. */
+         output altogether, like this:
-         if (repeat_max == 0)
+         ** if (repeat_max == 0)
-           {
+         **   {
-           code = previous;
+         **   code = previous;
-           goto END_REPEAT;
+         **   goto END_REPEAT;
-           }
+         **   }
-         /* If the maximum is 1 or unlimited, we just have to stick in the
+         However, that fails when a group is referenced as a subroutine from
-         BRAZERO and do no more at this point. However, we do need to adjust
+         elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
-         any OP_RECURSE calls inside the group that refer to the group itself or
+         so that it is skipped on execution. As we don't have a list of which
-         any internal or forward referenced group, because the offset is from
+         groups are referenced, we cannot do this selectively.
-         the start of the whole regex. Temporarily terminate the pattern while
-         doing this. */
+         If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
+         and do no more at this point. However, we do need to adjust any
+         OP_RECURSE calls inside the group that refer to the group itself or any
+         internal or forward referenced group, because the offset is from the
+         start of the whole regex. Temporarily terminate the pattern while doing
+         this. */
-         if (repeat_max <= 1)
+         if (repeat_max <= 1)    /* Covers 0, 1, and unlimited */
            {
            *code = OP_END;
            adjust_recurse(previous, 1, utf8, cd, save_hwm);
            memmove(previous+1, previous, len);
            code++;
+           if (repeat_max == 0)
+             {
+             *previous++ = OP_SKIPZERO;
+             goto END_REPEAT;
+             }
            *previous++ = OP_BRAZERO + repeat_type;
            }
-Line 4006 
 we set the flag only if there is a liter
+Line 4129 
 we set the flag only if there is a liter
        int len;
        if (*tempcode == OP_EXACT || *tempcode == OP_TYPEEXACT ||
            *tempcode == OP_NOTEXACT)
-         tempcode += _pcre_OP_lengths[*tempcode];
+         tempcode += _pcre_OP_lengths[*tempcode] +
+           ((*tempcode == OP_TYPEEXACT &&
+              (tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP))? 2:0);
        len = code - tempcode;
        if (len > 0) switch (*tempcode)
          {
-Line 4058 
 we set the flag only if there is a liter
+Line 4183 
 we set the flag only if there is a liter
      bravalue = OP_CBRA;
      save_hwm = cd->hwm;
      reset_bracount = FALSE;
      /* First deal with various "verbs" that can be introduced by '*'. */
      if (*(++ptr) == '*' && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
        {
        int i, namelen;
        const char *vn = verbnames;
        const uschar *name = ++ptr;
        previous = NULL;
        while ((cd->ctypes[*++ptr] & ctype_letter) != 0);
-Line 4088 
 we set the flag only if there is a liter
+Line 4213 
 we set the flag only if there is a liter
            if (*code++ == OP_ACCEPT) cd->had_accept = TRUE;
            break;
            }
          vn += verbs[i].len + 1;
          }
        if (i < verbcount) continue;
        *errorcodeptr = ERR60;
-Line 4233 
 we set the flag only if there is a liter
+Line 4358 
 we set the flag only if there is a liter
              *errorcodeptr = ERR58;
              goto FAILED;
              }
-           if (refsign == '-')
+           recno = (refsign == '-')?
+             cd->bracount - recno + 1 : recno +cd->bracount;
+           if (recno <= 0 || recno > cd->final_bracount)
              {
-             recno = cd->bracount - recno + 1;
+             *errorcodeptr = ERR15;
-             if (recno <= 0)
+             goto FAILED;
-               {
-               *errorcodeptr = ERR15;
-               goto FAILED;
-               }
              }
-           else recno += cd->bracount;
            PUT2(code, 2+LINK_SIZE, recno);
            break;
            }
-Line 4314 
 we set the flag only if there is a liter
+Line 4436 
 we set the flag only if there is a liter
            skipbytes = 1;
            }
-         /* Check for the "name" actually being a subpattern number. */
+         /* Check for the "name" actually being a subpattern number. We are
+         in the second pass here, so final_bracount is set. */
-         else if (recno > 0)
+         else if (recno > 0 && recno <= cd->final_bracount)
            {
            PUT2(code, 2+LINK_SIZE, recno);
            }
-Line 4510 
 we set the flag only if there is a liter
+Line 4633 
 we set the flag only if there is a liter
          /* We come here from the Python syntax above that handles both
          references (?P=name) and recursion (?P>name), as well as falling
-         through from the Perl recursion syntax (?&name). */
+         through from the Perl recursion syntax (?&name). We also come here from
+         the Perl \k<name> or \k'name' back reference syntax and the \k{name}
+         .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */
          NAMED_REF_OR_RECURSE:
          name = ++ptr;
-Line 4522 
 we set the flag only if there is a liter
+Line 4647 
 we set the flag only if there is a liter
          if (lengthptr != NULL)
            {
+           if (namelen == 0)
+             {
+             *errorcodeptr = ERR62;
+             goto FAILED;
+             }
            if (*ptr != terminator)
              {
              *errorcodeptr = ERR42;
-Line 4535 
 we set the flag only if there is a liter
+Line 4665 
 we set the flag only if there is a liter
            recno = 0;
            }
-         /* In the real compile, seek the name in the table */
+         /* In the real compile, seek the name in the table. We check the name
+         first, and then check that we have reached the end of the name in the
+         table. That way, if the name that is longer than any in the table,
+         the comparison will fail without reading beyond the table entry. */
          else
            {
            slot = cd->name_table;
            for (i = 0; i < cd->names_found; i++)
              {
-             if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;
+             if (strncmp((char *)name, (char *)slot+2, namelen) == 0 &&
+                 slot[2+namelen] == 0)
+               break;
              slot += cd->name_entry_size;
              }
-Line 4578 
 we set the flag only if there is a liter
+Line 4713 
 we set the flag only if there is a liter
          case '5': case '6': case '7': case '8': case '9':   /* subroutine */
            {
            const uschar *called;
+           terminator = ')';
+           /* Come here from the \g<...> and \g'...' code (Oniguruma
+           compatibility). However, the syntax has been checked to ensure that
+           the ... are a (signed) number, so that neither ERR63 nor ERR29 will
+           be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
+           ever be taken. */
+           HANDLE_NUMERICAL_RECURSION:
-           if ((refsign = *ptr) == '+') ptr++;
+           if ((refsign = *ptr) == '+')
+             {
+             ptr++;
+             if ((digitab[*ptr] & ctype_digit) == 0)
+               {
+               *errorcodeptr = ERR63;
+               goto FAILED;
+               }
+             }
            else if (refsign == '-')
              {
              if ((digitab[ptr[1]] & ctype_digit) == 0)
-Line 4591 
 we set the flag only if there is a liter
+Line 4743 
 we set the flag only if there is a liter
            while((digitab[*ptr] & ctype_digit) != 0)
              recno = recno * 10 + *ptr++ - '0';
-           if (*ptr != ')')
+           if (*ptr != terminator)
              {
              *errorcodeptr = ERR29;
              goto FAILED;
-Line 4987 
 we set the flag only if there is a liter
+Line 5139 
 we set the flag only if there is a liter
      back references and those types that consume a character may be repeated.
      We can test for values between ESC_b and ESC_Z for the latter; this may
      have to change if any new ones are ever created. */
      case '\\':
      tempptr = ptr;
      c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);
-Line 5014 
 we set the flag only if there is a liter
+Line 5166 
 we set the flag only if there is a liter
        zerofirstbyte = firstbyte;
        zeroreqbyte = reqbyte;
+       /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
+       is a subroutine call by number (Oniguruma syntax). In fact, the value
+       -ESC_g is returned only for these cases. So we don't need to check for <
+       or ' if the value is -ESC_g. For the Perl syntax \g{n} the value is
+       -ESC_REF+n, and for the Perl syntax \g{name} the result is -ESC_k (as
+       that is a synonym for a named back reference). */
+       if (-c == ESC_g)
+         {
+         const uschar *p;
+         save_hwm = cd->hwm;   /* Normally this is set when '(' is read */
+         terminator = (*(++ptr) == '<')? '>' : '\'';
+         /* These two statements stop the compiler for warning about possibly
+         unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In
+         fact, because we actually check for a number below, the paths that
+         would actually be in error are never taken. */
+         skipbytes = 0;
+         reset_bracount = FALSE;
+         /* Test for a name */
+         if (ptr[1] != '+' && ptr[1] != '-')
+           {
+           BOOL isnumber = TRUE;
+           for (p = ptr + 1; *p != 0 && *p != terminator; p++)
+             {
+             if ((cd->ctypes[*p] & ctype_digit) == 0) isnumber = FALSE;
+             if ((cd->ctypes[*p] & ctype_word) == 0) break;
+             }
+           if (*p != terminator)
+             {
+             *errorcodeptr = ERR57;
+             break;
+             }
+           if (isnumber)
+             {
+             ptr++;
+             goto HANDLE_NUMERICAL_RECURSION;
+             }
+           is_recurse = TRUE;
+           goto NAMED_REF_OR_RECURSE;
+           }
+         /* Test a signed number in angle brackets or quotes. */
+         p = ptr + 2;
+         while ((digitab[*p] & ctype_digit) != 0) p++;
+         if (*p != terminator)
+           {
+           *errorcodeptr = ERR57;
+           break;
+           }
+         ptr++;
+         goto HANDLE_NUMERICAL_RECURSION;
+         }
        /* \k<name> or \k'name' is a back reference by name (Perl syntax).
        We also support \k{name} (.NET syntax) */
-Line 5745 
 to fill in forward references to subpatt
+Line 5955 
 to fill in forward references to subpatt
  uschar cworkspace[COMPILE_WORK_SIZE];
  /* Set this early so that early errors get offset 0. */
  ptr = (const uschar *)pattern;
-Line 5906 
 to compile parts of the pattern into; th
+Line 6115 
 to compile parts of the pattern into; th
  no longer needed, so hopefully this workspace will never overflow, though there
  is a test for its doing so. */
- cd->bracount = 0;
+ cd->bracount = cd->final_bracount = 0;
  cd->names_found = 0;
  cd->name_entry_size = 0;
  cd->name_table = NULL;
-Line 5983 
 field. Reset the bracket count and the n
+Line 6192 
 field. Reset the bracket count and the n
  field; this time it's used for remembering forward references to subpatterns.
  */
+ cd->final_bracount = cd->bracount;  /* Save for checking forward references */
  cd->bracount = 0;
  cd->names_found = 0;
  cd->name_table = (uschar *)re + re->name_table_offset;
-Line 6033 
 while (errorcode == 0 && cd->hwm > cwork
+Line 6243 
 while (errorcode == 0 && cd->hwm > cwork
    if (groupptr == NULL) errorcode = ERR53;
      else PUT(((uschar *)codestart), offset, groupptr - codestart);
    }
  /* Give an error if there's back reference to a non-existent capturing
  subpattern. */

 Legend:



Removed from v.240
 


changed lines


 
Added in v.340
 Legend:



Removed from v.240
 


changed lines


 
Added in v.340
-Removed from v.240
+Added in v.340

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12