/[pcre]/code/branches/pcre16/pcre_compile.c

Diff of /code/branches/pcre16/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 457 by ph10,
Sat Oct  3 16:24:08 2009 UTC
+revision 514 by ph10,
Mon May  3 12:54:22 2010 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2009 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 53 
 supporting internal functions that are n
  #include "pcre_internal.h"
- /* When DEBUG is defined, we need the pcre_printint() function, which is also
+ /* When PCRE_DEBUG is defined, we need the pcre_printint() function, which is
- used by pcretest. DEBUG is not defined when building a production library. */
+ also used by pcretest. PCRE_DEBUG is not defined when building a production
+ library. */
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  #include "pcre_printint.src"
  #endif
-Line 91 
 is 4 there is plenty of room. */
+Line 92 
 is 4 there is plenty of room. */
  #define COMPILE_WORK_SIZE (4096)
+ /* The overrun tests check for a slightly smaller size so that they detect the
+ overrun before it actually does run off the end of the data block. */
+ #define WORK_SIZE_CHECK (COMPILE_WORK_SIZE - 100)
  /* Table for handling escaped characters in the range '0'-'z'. Positive returns
  are simple data values; negative values are for special things like \d and so
-Line 118 
 static const short int escapes[] = {
+Line 124 
 static const short int escapes[] = {
       -ESC_H,                  0,
 ,                       -ESC_K,
 ,                       0,
-,                       0,
+      -ESC_N,                  0,
       -ESC_P,                  -ESC_Q,
       -ESC_R,                  -ESC_S,
 ,                       0,
-Line 165 
 static const short int escapes[] = {
+Line 171 
 static const short int escapes[] = {
  /*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
  /*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
  /*  C8 */-ESC_H,     0,      0,       0,      0,     0,      0,      0,
- /*  D0 */   '}',     0, -ESC_K,       0,      0,     0,      0, -ESC_P,
+ /*  D0 */   '}',     0, -ESC_K,       0,      0,-ESC_N,      0, -ESC_P,
  /*  D8 */-ESC_Q,-ESC_R,      0,       0,      0,     0,      0,      0,
  /*  E0 */  '\\',     0, -ESC_S,       0,      0,-ESC_V, -ESC_W, -ESC_X,
  /*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
-Line 182 
 string is built from string macros so th
+Line 188 
 string is built from string macros so th
  platforms. */
  typedef struct verbitem {
-   int   len;
+   int   len;                 /* Length of verb name */
-   int   op;
+   int   op;                  /* Op when no arg, or -1 if arg mandatory */
+   int   op_arg;              /* Op when arg present, or -1 if not allowed */
  } verbitem;
  static const char verbnames[] =
+   "\0"                       /* Empty name is a shorthand for MARK */
+   STRING_MARK0
    STRING_ACCEPT0
    STRING_COMMIT0
    STRING_F0
-Line 196 
 static const char verbnames[] =
+Line 205 
 static const char verbnames[] =
    STRING_THEN;
  static const verbitem verbs[] = {
-   { 6, OP_ACCEPT },
+   { 0, -1,        OP_MARK },
-   { 6, OP_COMMIT },
+   { 4, -1,        OP_MARK },
-   { 1, OP_FAIL },
+   { 6, OP_ACCEPT, -1 },
-   { 4, OP_FAIL },
+   { 6, OP_COMMIT, -1 },
-   { 5, OP_PRUNE },
+   { 1, OP_FAIL,   -1 },
-   { 4, OP_SKIP  },
+   { 4, OP_FAIL,   -1 },
-   { 4, OP_THEN  }
+   { 5, OP_PRUNE,  OP_PRUNE_ARG },
+   { 4, OP_SKIP,   OP_SKIP_ARG  },
+   { 4, OP_THEN,   OP_THEN_ARG  }
  };
  static const int verbcount = sizeof(verbs)/sizeof(verbitem);
-Line 262 
 the number of relocations needed when a
+Line 273 
 the number of relocations needed when a
  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. */
+ because these strings are used only when there is a compilation error.
+ Each substring ends with \0 to insert a null character. This includes the final
+ substring, so that the whole string ends with \0\0, which can be detected when
+ counting through. */
  static const char error_texts[] =
    "no error\0"
-Line 309 
 static const char error_texts[] =
+Line 324 
 static const char error_texts[] =
    /* 35 */
    "invalid condition (?(0)\0"
    "\\C not allowed in lookbehind assertion\0"
-   "PCRE does not support \\L, \\l, \\N, \\U, or \\u\0"
+   "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"
    "number after (?C is > 255\0"
    "closing ) for (?C expected\0"
    /* 40 */
-Line 335 
 static const char error_texts[] =
+Line 350 
 static const char error_texts[] =
    "inconsistent NEWLINE options\0"
    "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
    "a numbered reference must not be zero\0"
-   "(*VERB) with an argument is not supported\0"
+   "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"
    /* 60 */
    "(*VERB) not recognized\0"
    "number is too big\0"
-Line 343 
 static const char error_texts[] =
+Line 358 
 static const char error_texts[] =
    "digit expected after (?+\0"
    "] is an invalid data character in JavaScript compatibility mode\0"
    /* 65 */
-   "different names for subpatterns of the same number are not allowed";
+   "different names for subpatterns of the same number are not allowed\0"
+   "(*MARK) must have an argument\0"
+   ;
  /* Table to identify digits and hex digits. This is used when compiling
  patterns. Note that the tables in chartables are dependent on the locale, and
-Line 502 
 static const char *
+Line 518 
 static const char *
  find_error_text(int n)
  {
  const char *s = error_texts;
- for (; n > 0; n--) while (*s++ != 0) {};
+ for (; n > 0; n--)
+   {
+   while (*s++ != 0) {};
+   if (*s == 0) return "Error text not found (please report)";
+   }
  return s;
  }
-Line 573 
 else
+Line 593 
 else
      case CHAR_l:
      case CHAR_L:
-     case CHAR_N:
      case CHAR_u:
      case CHAR_U:
      *errorcodeptr = ERR37;
-Line 810 
 else
+Line 829 
 else
      break;
      }
    }
+ /* Perl supports \N{name} for character names, as well as plain \N for "not
+ newline". PCRE does not support \N{name}. */
+ if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET)
+   *errorcodeptr = ERR37;
  *ptrptr = ptr;
  return c;
-Line 1102 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1127 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
        if (name != NULL && lorn == ptr - thisname &&
            strncmp((const char *)name, (const char *)thisname, lorn) == 0)
          return *count;
        term++;
        }
      }
    }
-Line 1148 
 for (; *ptr != 0; ptr++)
+Line 1173 
 for (; *ptr != 0; ptr++)
            break;
          }
        else if (!negate_class && ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
          {
          negate_class = TRUE;
          ptr++;
          }
        else break;
        }
-Line 1317 
 for (;;)
+Line 1342 
 for (;;)
      case OP_CALLOUT:
      case OP_CREF:
+     case OP_NCREF:
      case OP_RREF:
+     case OP_NRREF:
      case OP_DEF:
      code += _pcre_OP_lengths[*code];
      break;
-Line 1338 
 for (;;)
+Line 1365 
 for (;;)
  /* Scan a branch and compute the fixed length of subject that will match it,
  if the length is fixed. This is needed for dealing with backward assertions.
  In UTF8 mode, the result is in characters rather than bytes. The branch is
  temporarily terminated with OP_END when this function is called.
  This function is called when a backward assertion is encountered, so that if it
  fails, the error message can point to the correct place in the pattern.
  However, we cannot do this when the assertion contains subroutine calls,
  because they can be forward references. We solve this by remembering this case
  and doing the check at the end; a flag specifies which mode we are running in.
  Arguments:
    code     points to the start of the pattern (the bracket)
    options  the compiling options
    atend    TRUE if called when the pattern is complete
    cd       the "compile data" structure
  Returns:   the fixed length,
               or -1 if there is no fixed length,
               or -2 if \C was encountered
               or -3 if an OP_RECURSE item was encountered and atend is FALSE
-Line 1403 
 for (;;)
+Line 1430 
 for (;;)
      cc += 1 + LINK_SIZE;
      branchlength = 0;
      break;
      /* A true recursion implies not fixed length, but a subroutine call may
      be OK. If the subroutine is a forward reference, we can't deal with
      it until the end of the pattern, so return -3. */
      case OP_RECURSE:
      if (!atend) return -3;
      cs = ce = (uschar *)cd->start_code + GET(cc, 1);  /* Start subpattern */
      do ce += GET(ce, 1); while (*ce == OP_ALT);       /* End subpattern */
      if (cc > cs && cc < ce) return -1;                /* Recursion */
      d = find_fixedlength(cs + 2, options, atend, cd);
      if (d < 0) return d;
      branchlength += d;
      cc += 1 + LINK_SIZE;
      break;
      /* Skip over assertive subpatterns */
-Line 1432 
 for (;;)
+Line 1459 
 for (;;)
      case OP_REVERSE:
      case OP_CREF:
+     case OP_NCREF:
      case OP_RREF:
+     case OP_NRREF:
      case OP_DEF:
      case OP_OPT:
      case OP_CALLOUT:
      case OP_SOD:
      case OP_SOM:
+     case OP_SET_SOM:
      case OP_EOD:
      case OP_EODN:
      case OP_CIRC:
-Line 1455 
 for (;;)
+Line 1485 
 for (;;)
      branchlength++;
      cc += 2;
  #ifdef SUPPORT_UTF8
      if ((options & PCRE_UTF8) != 0 && cc[-1] >= 0xc0)
        cc += _pcre_utf8_table4[cc[-1] & 0x3f];
  #endif
      break;
-Line 1467 
 for (;;)
+Line 1497 
 for (;;)
      branchlength += GET2(cc,1);
      cc += 4;
  #ifdef SUPPORT_UTF8
      if ((options & PCRE_UTF8) != 0 && cc[-1] >= 0xc0)
        cc += _pcre_utf8_table4[cc[-1] & 0x3f];
  #endif
      break;
-Line 1552 
 for (;;)
+Line 1582 
 for (;;)
  /* This little function scans through a compiled pattern until it finds a
  capturing bracket with the given number, or, if the number is negative, an
  instance of OP_REVERSE for a lookbehind. The function is global in the C sense
  so that it can be called from pcre_study() when finding the minimum matching
  length.
  Arguments:
-Line 1577 
 for (;;)
+Line 1607 
 for (;;)
    the table is zero; the actual length is stored in the compiled code. */
    if (c == OP_XCLASS) code += GET(code, 1);
    /* Handle recursion */
    else if (c == OP_REVERSE)
      {
      if (number < 0) return (uschar *)code;
      code += _pcre_OP_lengths[c];
      }
-Line 1597 
 for (;;)
+Line 1627 
 for (;;)
    /* Otherwise, we can get the item's length from the table, except that for
    repeated character types, we have to test for \p and \P, which have an extra
-   two bytes of parameters. */
+   two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
+   must add in its length. */
    else
      {
-Line 1621 
 for (;;)
+Line 1652 
 for (;;)
        case OP_TYPEPOSUPTO:
        if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
        break;
+       case OP_MARK:
+       case OP_PRUNE_ARG:
+       case OP_SKIP_ARG:
+       case OP_THEN_ARG:
+       code += code[1];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1692 
 for (;;)
+Line 1730 
 for (;;)
    /* Otherwise, we can get the item's length from the table, except that for
    repeated character types, we have to test for \p and \P, which have an extra
-   two bytes of parameters. */
+   two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
+   must add in its length. */
    else
      {
-Line 1716 
 for (;;)
+Line 1755 
 for (;;)
        case OP_TYPEEXACT:
        if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
        break;
+       case OP_MARK:
+       case OP_PRUNE_ARG:
+       case OP_SKIP_ARG:
+       case OP_THEN_ARG:
+       code += code[1];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1772 
 Arguments:
+Line 1818 
 Arguments:
    code        points to start of search
    endcode     points to where to stop
    utf8        TRUE if in UTF8 mode
+   cd          contains pointers to tables etc.
  Returns:      TRUE if what is matched could be empty
  */
  static BOOL
- could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8)
+ could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8,
+   compile_data *cd)
  {
  register int c;
  for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
-Line 1808 
 for (code = first_significant_code(code
+Line 1856 
 for (code = first_significant_code(code
      continue;
      }
+   /* For a recursion/subroutine call, if its end has been reached, which
+   implies a subroutine call, we can scan it. */
+   if (c == OP_RECURSE)
+     {
+     BOOL empty_branch = FALSE;
+     const uschar *scode = cd->start_code + GET(code, 1);
+     if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+     do
+       {
+       if (could_be_empty_branch(scode, endcode, utf8, cd))
+         {
+         empty_branch = TRUE;
+         break;
+         }
+       scode += GET(scode, 1);
+       }
+     while (*scode == OP_ALT);
+     if (!empty_branch) return FALSE;  /* All branches are non-empty */
+     continue;
+     }
    /* For other groups, scan the branches. */
    if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)
-Line 1826 
 for (code = first_significant_code(code
+Line 1896 
 for (code = first_significant_code(code
        empty_branch = FALSE;
        do
          {
-         if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
+         if (!empty_branch && could_be_empty_branch(code, endcode, utf8, cd))
            empty_branch = TRUE;
          code += GET(code, 1);
          }
-Line 1953 
 for (code = first_significant_code(code
+Line 2023 
 for (code = first_significant_code(code
      case OP_POSQUERY:
      if (utf8 && code[1] >= 0xc0) code += _pcre_utf8_table4[code[1] & 0x3f];
      break;
      case OP_UPTO:
      case OP_MINUPTO:
      case OP_POSUPTO:
      if (utf8 && code[3] >= 0xc0) code += _pcre_utf8_table4[code[3] & 0x3f];
      break;
  #endif
+     /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument
+     string. */
+     case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_SKIP_ARG:
+     case OP_THEN_ARG:
+     code += code[1];
+     break;
+     /* None of the remaining opcodes are required to match a character. */
+     default:
+     break;
      }
    }
-Line 1982 
 Arguments:
+Line 2067 
 Arguments:
    endcode     points to where to stop (current RECURSE item)
    bcptr       points to the chain of current (unclosed) branch starts
    utf8        TRUE if in UTF-8 mode
+   cd          pointers to tables etc
  Returns:      TRUE if what is matched could be empty
  */
  static BOOL
  could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
-   BOOL utf8)
+   BOOL utf8, compile_data *cd)
  {
- while (bcptr != NULL && bcptr->current >= code)
+ while (bcptr != NULL && bcptr->current_branch >= code)
    {
-   if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;
+   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf8, cd))
+     return FALSE;
    bcptr = bcptr->outer;
    }
  return TRUE;
-Line 2654 
 BOOL utf8 = FALSE;
+Line 2741 
 BOOL utf8 = FALSE;
  uschar *utf8_char = NULL;
  #endif
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (lengthptr != NULL) DPRINTF((">> start branch\n"));
  #endif
-Line 2713 
 for (;; ptr++)
+Line 2800 
 for (;; ptr++)
    if (lengthptr != NULL)
      {
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
      if (code > cd->hwm) cd->hwm = code;                 /* High water info */
  #endif
-     if (code > cd->start_workspace + COMPILE_WORK_SIZE) /* Check for overrun */
+     if (code > cd->start_workspace + WORK_SIZE_CHECK)   /* Check for overrun */
        {
        *errorcodeptr = ERR52;
        goto FAILED;
-Line 2765 
 for (;; ptr++)
+Line 2852 
 for (;; ptr++)
    /* In the real compile phase, just check the workspace used by the forward
    reference list. */
-   else if (cd->hwm > cd->start_workspace + COMPILE_WORK_SIZE)
+   else if (cd->hwm > cd->start_workspace + WORK_SIZE_CHECK)
      {
      *errorcodeptr = ERR52;
      goto FAILED;
-Line 3122 
 for (;; ptr++)
+Line 3209 
 for (;; ptr++)
        /* Backslash may introduce a single character, or it may introduce one
        of the specials, which just set a flag. The sequence \b is a special
-       case. Inside a class (and only there) it is treated as backspace.
+       case. Inside a class (and only there) it is treated as backspace. We
-       Elsewhere it marks a word boundary. Other escapes have preset maps ready
+       assume that other escapes have more than one character in them, so set
-       to 'or' into the one we are building. We assume they have more than one
+       class_charcount bigger than one. Unrecognized escapes fall through and
-       character in them, so set class_charcount bigger than one. */
+       are either treated as literal characters (by default), or are faulted if
+       PCRE_EXTRA is set. */
        if (c == CHAR_BACKSLASH)
          {
          c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
          if (*errorcodeptr != 0) goto FAILED;
-         if (-c == ESC_b) c = CHAR_BS;       /* \b is backspace in a class */
+         if (-c == ESC_b) c = CHAR_BS;    /* \b is backspace in a class */
-         else if (-c == ESC_X) c = CHAR_X;   /* \X is literal X in a class */
-         else if (-c == ESC_R) c = CHAR_R;   /* \R is literal R in a class */
          else if (-c == ESC_Q)            /* Handle start of quoted string */
            {
            if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
-Line 3419 
 for (;; ptr++)
+Line 3505 
 for (;; ptr++)
            d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
            if (*errorcodeptr != 0) goto FAILED;
-           /* \b is backspace; \X is literal X; \R is literal R; any other
+           /* \b is backspace; any other special means the '-' was literal */
-           special means the '-' was literal */
            if (d < 0)
              {
-             if (d == -ESC_b) d = CHAR_BS;
+             if (d == -ESC_b) d = CHAR_BS; else
-             else if (d == -ESC_X) d = CHAR_X;
-             else if (d == -ESC_R) d = CHAR_R; else
                {
                ptr = oldptr;
                goto LONE_SINGLE_CHARACTER;  /* A few lines below */
-Line 3911 
 we set the flag only if there is a liter
+Line 3994 
 we set the flag only if there is a liter
        if (repeat_max == 0) goto END_REPEAT;
        /*--------------------------------------------------------------------*/
        /* This code is obsolete from release 8.00; the restriction was finally
        removed: */
        /* All real repeats make it impossible to handle partial matching (maybe
        one day we will be able to remove this restriction). */
        /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */
        /*--------------------------------------------------------------------*/
        /* Combine the op_type with the repeat_type */
-Line 4066 
 we set the flag only if there is a liter
+Line 4149 
 we set the flag only if there is a liter
          goto END_REPEAT;
          }
        /*--------------------------------------------------------------------*/
        /* This code is obsolete from release 8.00; the restriction was finally
        removed: */
-Line 4074 
 we set the flag only if there is a liter
+Line 4157 
 we set the flag only if there is a liter
        one day we will be able to remove this restriction). */
        /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */
        /*--------------------------------------------------------------------*/
        if (repeat_min == 0 && repeat_max == -1)
          *code++ = OP_CRSTAR + repeat_type;
-Line 4209 
 we set the flag only if there is a liter
+Line 4292 
 we set the flag only if there is a liter
            {
            /* In the pre-compile phase, we don't actually do the replication. We
            just adjust the length as if we had. Do some paranoid checks for
-           potential integer overflow. */
+           potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
+           integer type when available, otherwise double. */
            if (lengthptr != NULL)
              {
              int delta = (repeat_min - 1)*length_prevgroup;
-             if ((double)(repeat_min - 1)*(double)length_prevgroup >
+             if ((INT64_OR_DOUBLE)(repeat_min - 1)*
-                                                             (double)INT_MAX ||
+                   (INT64_OR_DOUBLE)length_prevgroup >
+                     (INT64_OR_DOUBLE)INT_MAX ||
                  OFLOW_MAX - *lengthptr < delta)
                {
                *errorcodeptr = ERR20;
-Line 4261 
 we set the flag only if there is a liter
+Line 4346 
 we set the flag only if there is a liter
          just adjust the length as if we had. For each repetition we must add 1
          to the length for BRAZERO and for all but the last repetition we must
          add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
-         paranoid checks to avoid integer overflow. */
+         paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is
+         a 64-bit integer type when available, otherwise double. */
          if (lengthptr != NULL && repeat_max > 0)
            {
            int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
 - 2*LINK_SIZE;   /* Last one doesn't nest */
-           if ((double)repeat_max *
+           if ((INT64_OR_DOUBLE)repeat_max *
-                 (double)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
+                 (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
-                   > (double)INT_MAX ||
+                   > (INT64_OR_DOUBLE)INT_MAX ||
                OFLOW_MAX - *lengthptr < delta)
              {
              *errorcodeptr = ERR20;
-Line 4346 
 we set the flag only if there is a liter
+Line 4432 
 we set the flag only if there is a liter
            uschar *scode = bracode;
            do
              {
-             if (could_be_empty_branch(scode, ketcode, utf8))
+             if (could_be_empty_branch(scode, ketcode, utf8, cd))
                {
                *bracode += OP_SBRA - OP_BRA;
                break;
-Line 4389 
 we set the flag only if there is a liter
+Line 4475 
 we set the flag only if there is a liter
      if (possessive_quantifier)
        {
        int len;
        if (*tempcode == OP_TYPEEXACT)
          tempcode += _pcre_OP_lengths[*tempcode] +
            ((tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP)? 2 : 0);
        else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
          {
          tempcode += _pcre_OP_lengths[*tempcode];
-Line 4401 
 we set the flag only if there is a liter
+Line 4487 
 we set the flag only if there is a liter
          if (utf8 && tempcode[-1] >= 0xc0)
            tempcode += _pcre_utf8_table4[tempcode[-1] & 0x3f];
  #endif
          }
        len = code - tempcode;
        if (len > 0) switch (*tempcode)
          {
-Line 4421 
 we set the flag only if there is a liter
+Line 4507 
 we set the flag only if there is a liter
          case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
          case OP_NOTUPTO:  *tempcode = OP_NOTPOSUPTO; break;
+         /* Because we are moving code along, we must ensure that any
+         pending recursive references are updated. */
          default:
+         *code = OP_END;
+         adjust_recurse(tempcode, 1 + LINK_SIZE, utf8, cd, save_hwm);
          memmove(tempcode + 1+LINK_SIZE, tempcode, len);
          code += 1 + LINK_SIZE;
          len += 1 + LINK_SIZE;
-Line 4457 
 we set the flag only if there is a liter
+Line 4548 
 we set the flag only if there is a liter
      /* First deal with various "verbs" that can be introduced by '*'. */
-     if (*(++ptr) == CHAR_ASTERISK && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
+     if (*(++ptr) == CHAR_ASTERISK &&
+          ((cd->ctypes[ptr[1]] & ctype_letter) != 0 || ptr[1] == ':'))
        {
        int i, namelen;
+       int arglen = 0;
        const char *vn = verbnames;
-       const uschar *name = ++ptr;
+       const uschar *name = ptr + 1;
+       const uschar *arg = NULL;
        previous = NULL;
        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
+       namelen = ptr - name;
        if (*ptr == CHAR_COLON)
          {
-         *errorcodeptr = ERR59;   /* Not supported */
+         arg = ++ptr;
-         goto FAILED;
+         while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0
+           || *ptr == '_') ptr++;
+         arglen = ptr - arg;
          }
        if (*ptr != CHAR_RIGHT_PARENTHESIS)
          {
          *errorcodeptr = ERR60;
          goto FAILED;
          }
-       namelen = ptr - name;
+       /* Scan the table of verb names */
        for (i = 0; i < verbcount; i++)
          {
          if (namelen == verbs[i].len &&
              strncmp((char *)name, vn, namelen) == 0)
            {
            /* Check for open captures before ACCEPT */
            if (verbs[i].op == OP_ACCEPT)
              {
              open_capitem *oc;
              cd->had_accept = TRUE;
              for (oc = cd->open_caps; oc != NULL; oc = oc->next)
                {
                *code++ = OP_CLOSE;
                PUT2INC(code, 0, oc->number);
                }
              }
-           *code++ = verbs[i].op;
-           break;
+           /* Handle the cases with/without an argument */
+           if (arglen == 0)
+             {
+             if (verbs[i].op < 0)   /* Argument is mandatory */
+               {
+               *errorcodeptr = ERR66;
+               goto FAILED;
+               }
+             *code++ = verbs[i].op;
+             }
+           else
+             {
+             if (verbs[i].op_arg < 0)   /* Argument is forbidden */
+               {
+               *errorcodeptr = ERR59;
+               goto FAILED;
+               }
+             *code++ = verbs[i].op_arg;
+             *code++ = arglen;
+             memcpy(code, arg, arglen);
+             code += arglen;
+             *code++ = 0;
+             }
+           break;  /* Found verb, exit loop */
            }
          vn += verbs[i].len + 1;
          }
-       if (i < verbcount) continue;
-       *errorcodeptr = ERR60;
+       if (i < verbcount) continue;    /* Successfully handled a verb */
+       *errorcodeptr = ERR60;          /* Verb not recognized */
        goto FAILED;
        }
-Line 4654 
 we set the flag only if there is a liter
+Line 4783 
 we set the flag only if there is a liter
            }
          /* Otherwise (did not start with "+" or "-"), start by looking for the
-         name. */
+         name. If we find a name, add one to the opcode to change OP_CREF or
+         OP_RREF into OP_NCREF or OP_NRREF. These behave exactly the same,
+         except they record that the reference was originally to a name. The
+         information is used to check duplicate names. */
          slot = cd->name_table;
          for (i = 0; i < cd->names_found; i++)
-Line 4669 
 we set the flag only if there is a liter
+Line 4801 
 we set the flag only if there is a liter
            {
            recno = GET2(slot, 0);
            PUT2(code, 2+LINK_SIZE, recno);
+           code[1+LINK_SIZE]++;
            }
          /* Search the pattern for a forward reference */
-Line 4677 
 we set the flag only if there is a liter
+Line 4810 
 we set the flag only if there is a liter
                          (options & PCRE_EXTENDED) != 0)) > 0)
            {
            PUT2(code, 2+LINK_SIZE, i);
+           code[1+LINK_SIZE]++;
            }
          /* If terminator == 0 it means that the name followed directly after
-Line 4878 
 we set the flag only if there is a liter
+Line 5012 
 we set the flag only if there is a liter
            is because the number of names, and hence the table size, is computed
            in the pre-compile, and it affects various numbers and pointers which
            would all have to be modified, and the compiled code moved down, if
            duplicates with the same number were omitted from the table. This
            doesn't seem worth the hassle. However, *different* names for the
            same number are not permitted. */
-Line 4886 
 we set the flag only if there is a liter
+Line 5020 
 we set the flag only if there is a liter
              {
              BOOL dupname = FALSE;
              slot = cd->name_table;
              for (i = 0; i < cd->names_found; i++)
                {
                int crc = memcmp(name, slot+2, namelen);
-Line 4900 
 we set the flag only if there is a liter
+Line 5034 
 we set the flag only if there is a liter
                      *errorcodeptr = ERR43;
                      goto FAILED;
                      }
                    else dupname = TRUE;
                    }
                  else crc = -1;      /* Current name is a substring */
                  }
                /* Make space in the table and break the loop for an earlier
                name. For a duplicate or later name, carry on. We do this for
                duplicates so that in the simple case (when ?(| is not used) they
                are in order of their numbers. */
                if (crc < 0)
                  {
                  memmove(slot + cd->name_entry_size, slot,
                    (cd->names_found - i) * cd->name_entry_size);
                  break;
                  }
                /* Continue the loop for a later or duplicate name */
                slot += cd->name_entry_size;
                }
              /* For non-duplicate names, check for a duplicate number before
              adding the new name. */
              if (!dupname)
                {
                uschar *cslot = cd->name_table;
-Line 4936 
 we set the flag only if there is a liter
+Line 5070 
 we set the flag only if there is a liter
                      {
                      *errorcodeptr = ERR65;
                      goto FAILED;
                      }
                    }
                  else i--;
                  cslot += cd->name_entry_size;
                  }
                }
              PUT2(slot, 0, cd->bracount + 1);
              memcpy(slot + 2, name, namelen);
-Line 5122 
 we set the flag only if there is a liter
+Line 5256 
 we set the flag only if there is a liter
            if (lengthptr == NULL)
              {
              *code = OP_END;
              if (recno != 0)
                called = _pcre_find_bracket(cd->start_code, utf8, recno);
              /* Forward reference */
-Line 5135 
 we set the flag only if there is a liter
+Line 5269 
 we set the flag only if there is a liter
                  *errorcodeptr = ERR15;
                  goto FAILED;
                  }
+               /* Fudge the value of "called" so that when it is inserted as an
+               offset below, what it actually inserted is the reference number
+               of the group. */
                called = cd->start_code + recno;
                PUTINC(cd->hwm, 0, code + 2 + LINK_SIZE - cd->start_code);
                }
-Line 5144 
 we set the flag only if there is a liter
+Line 5283 
 we set the flag only if there is a liter
              recursion that could loop for ever, and diagnose that case. */
              else if (GET(called, 1) == 0 &&
-                      could_be_empty(called, code, bcptr, utf8))
+                      could_be_empty(called, code, bcptr, utf8, cd))
                {
                *errorcodeptr = ERR40;
                goto FAILED;
-Line 5239 
 we set the flag only if there is a liter
+Line 5378 
 we set the flag only if there is a liter
              {
              cd->external_options = newoptions;
              }
-          else
+           else
              {
              if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
                {
-Line 5271 
 we set the flag only if there is a liter
+Line 5410 
 we set the flag only if there is a liter
          }     /* End of switch for character following (? */
        }       /* End of (? handling */
-     /* Opening parenthesis not followed by '?'. If PCRE_NO_AUTO_CAPTURE is set,
+     /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE
-     all unadorned brackets become non-capturing and behave like (?:...)
+     is set, all unadorned brackets become non-capturing and behave like (?:...)
      brackets. */
      else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
-Line 5576 
 we set the flag only if there is a liter
+Line 5715 
 we set the flag only if there is a liter
        if (-c >= ESC_REF)
          {
+         open_capitem *oc;
          recno = -c - ESC_REF;
          HANDLE_REFERENCE:    /* Come here from named backref handling */
-Line 5585 
 we set the flag only if there is a liter
+Line 5725 
 we set the flag only if there is a liter
          PUT2INC(code, 0, recno);
          cd->backref_map |= (recno < 32)? (1 << recno) : 1;
          if (recno > cd->top_backref) cd->top_backref = recno;
+         /* Check to see if this back reference is recursive, that it, it
+         is inside the group that it references. A flag is set so that the
+         group can be made atomic. */
+         for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+           {
+           if (oc->number == recno)
+             {
+             oc->flag = TRUE;
+             break;
+             }
+           }
          }
        /* So are Unicode property matches, if supported. */
-Line 5774 
 int branchfirstbyte, branchreqbyte;
+Line 5927 
 int branchfirstbyte, branchreqbyte;
  int length;
  int orig_bracount;
  int max_bracount;
+ int old_external_options = cd->external_options;
  branch_chain bc;
  bc.outer = bcptr;
- bc.current = code;
+ bc.current_branch = code;
  firstbyte = reqbyte = REQ_UNSET;
-Line 5796 
 them global. It tests the value of lengt
+Line 5950 
 them global. It tests the value of lengt
  pre-compile phase to find out whether anything has yet been compiled or not. */
  /* If this is a capturing subpattern, add to the chain of open capturing items
- so that we can detect them if (*ACCEPT) is encountered. */
+ so that we can detect them if (*ACCEPT) is encountered. This is also used to
+ detect groups that contain recursive back references to themselves. */
  if (*code == OP_CBRA)
    {
    capnumber = GET2(code, 1 + LINK_SIZE);
    capitem.number = capnumber;
    capitem.next = cd->open_caps;
-   cd->open_caps = &capitem;
+   capitem.flag = FALSE;
-   }
+   cd->open_caps = &capitem;
+   }
  /* Offset is set zero to mark that this bracket is still open */
-Line 5850 
 for (;;)
+Line 6006 
 for (;;)
      return FALSE;
      }
+   /* If the external options have changed during this branch, it means that we
+   are at the top level, and a leading option setting has been encountered. We
+   need to re-set the original option values to take account of this so that,
+   during the pre-compile phase, we know to allow for a re-set at the start of
+   subsequent branches. */
+   if (old_external_options != cd->external_options)
+     oldims = cd->external_options & PCRE_IMS;
    /* Keep the highest bracket count in case (?| was used and some branch
    has fewer than the rest. */
-Line 5900 
 for (;;)
+Line 6065 
 for (;;)
      /* If lookbehind, check that this branch matches a fixed-length string, and
      put the length into the OP_REVERSE item. Temporarily mark the end of the
      branch with OP_END. If the branch contains OP_RECURSE, the result is -3
      because there may be forward references that we can't check here. Set a
      flag to cause another lookbehind check at the end. Why not do it all at the
      end? Because common, erroneous checks are picked up here and the offset of
      the problem can be shown. */
      if (lookbehind)
-Line 5914 
 for (;;)
+Line 6079 
 for (;;)
        DPRINTF(("fixed length = %d\n", fixed_length));
        if (fixed_length == -3)
          {
          cd->check_lookbehind = TRUE;
          }
        else if (fixed_length < 0)
          {
          *errorcodeptr = (fixed_length == -2)? ERR36 : ERR25;
-Line 5949 
 for (;;)
+Line 6114 
 for (;;)
          }
        while (branch_length > 0);
        }
-     /* If it was a capturing subpattern, remove it from the chain. */
-     if (capnumber > 0) cd->open_caps = cd->open_caps->next;
      /* Fill in the ket */
-Line 5960 
 for (;;)
+Line 6121 
 for (;;)
      PUT(code, 1, code - start_bracket);
      code += 1 + LINK_SIZE;
-     /* Resetting option if needed */
+     /* If it was a capturing subpattern, check to see if it contained any
+     recursive back references. If so, we must wrap it in atomic brackets.
+     In any event, remove the block from the chain. */
+     if (capnumber > 0)
+       {
+       if (cd->open_caps->flag)
+         {
+         memmove(start_bracket + 1 + LINK_SIZE, start_bracket,
+           code - start_bracket);
+         *start_bracket = OP_ONCE;
+         code += 1 + LINK_SIZE;
+         PUT(start_bracket, 1, code - start_bracket);
+         *code = OP_KET;
+         PUT(code, 1, code - start_bracket);
+         code += 1 + LINK_SIZE;
+         length += 2 + 2*LINK_SIZE;
+         }
+       cd->open_caps = cd->open_caps->next;
+       }
+     /* Reset options if needed. */
      if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
        {
-Line 6009 
 for (;;)
+Line 6191 
 for (;;)
      {
      *code = OP_ALT;
      PUT(code, 1, code - last_branch);
-     bc.current = last_branch = code;
+     bc.current_branch = last_branch = code;
      code += 1 + LINK_SIZE;
      }
-Line 6156 
 do {
+Line 6338 
 do {
       switch (*scode)
         {
         case OP_CREF:
+        case OP_NCREF:
         case OP_RREF:
+        case OP_NRREF:
         case OP_DEF:
         return FALSE;
-Line 6423 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6607 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
-      (*erroroffset = _pcre_valid_utf8((uschar *)pattern, -1)) >= 0)
+      (*erroroffset = _pcre_valid_utf8((USPTR)pattern, -1)) >= 0)
    {
    errorcode = ERR44;
    goto PCRE_EARLY_ERROR_RETURN2;
-Line 6620 
 if debugging, leave the test till after
+Line 6804 
 if debugging, leave the test till after
  *code++ = OP_END;
- #ifndef DEBUG
+ #ifndef PCRE_DEBUG
  if (code - codestart > length) errorcode = ERR23;
  #endif
-Line 6643 
 subpattern. */
+Line 6827 
 subpattern. */
  if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;
  /* If there were any lookbehind assertions that contained OP_RECURSE
  (recursions or subroutine calls), a flag is set for them to be checked here,
  because they may contain forward references. Actual recursions can't be fixed
  length, but subroutine calls can. It is done like this so that those without
-Line 6654 
 length, and set their lengths. */
+Line 6838 
 length, and set their lengths. */
  if (cd->check_lookbehind)
    {
    uschar *cc = (uschar *)codestart;
    /* Loop, searching for OP_REVERSE items, and process those that do not have
    their length set. (Actually, it will also re-process any that have a length
    of zero, but that is a pathological case, and it does no harm.) When we find
    one, we temporarily terminate the branch it is in while we scan it. */
    for (cc = (uschar *)_pcre_find_bracket(codestart, utf8, -1);
         cc != NULL;
         cc = (uschar *)_pcre_find_bracket(cc, utf8, -1))
      {
      if (GET(cc, 1) == 0)
        {
        int fixed_length;
        uschar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
        int end_op = *be;
        *be = OP_END;
        fixed_length = find_fixedlength(cc, re->options, TRUE, cd);
        *be = end_op;
-Line 6676 
 if (cd->check_lookbehind)
+Line 6860 
 if (cd->check_lookbehind)
        if (fixed_length < 0)
          {
          errorcode = (fixed_length == -2)? ERR36 : ERR25;
          break;
          }
        PUT(cc, 1, fixed_length);
        }
      cc += 1 + LINK_SIZE;
      }
    }
  /* Failed to compile, or error while post-processing */
-Line 6744 
 if (reqbyte >= 0 &&
+Line 6928 
 if (reqbyte >= 0 &&
  /* Print out the compiled data if debugging is enabled. This is never the
  case when building a production library. */
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  printf("Length = %d top_bracket = %d top_backref = %d\n",
    length, re->top_bracket, re->top_backref);
-Line 6782 
 if (code - codestart > length)
+Line 6965 
 if (code - codestart > length)
    if (errorcodeptr != NULL) *errorcodeptr = ERR23;
    return NULL;
    }
- #endif   /* DEBUG */
+ #endif   /* PCRE_DEBUG */
  return (pcre *)re;
  }

 Legend:



Removed from v.457
 


changed lines


 
Added in v.514
 Legend:



Removed from v.457
 


changed lines


 
Added in v.514
-Removed from v.457
+Added in v.514

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12