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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 604 by ph10,
Thu Jun  2 19:04:54 2011 UTC
+revision 635 by ph10,
Sat Jul 23 16:19:50 2011 UTC
 Line 409 
 static const char error_texts[] =
    "(*MARK) must have an argument\0"
    "this version of PCRE is not compiled with PCRE_UCP support\0"
    "\\c must be followed by an ASCII character\0"
+   "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
-Line 1694 
 _pcre_find_bracket(const uschar *code, B
+Line 1695 
 _pcre_find_bracket(const uschar *code, B
  for (;;)
    {
    register int c = *code;
    if (c == OP_END) return NULL;
    /* XCLASS is used for classes that cannot be represented just by a bit
-Line 1974 
 for (code = first_significant_code(code
+Line 1976 
 for (code = first_significant_code(code
      }
    /* For a recursion/subroutine call, if its end has been reached, which
-   implies a subroutine call, we can scan it. */
+   implies a backward reference subroutine call, we can scan it. If it's a
+   forward reference subroutine call, we can't. To detect forward reference
+   we have to scan up the list that is kept in the workspace. This function is
+   called only when doing the real compile, not during the pre-compile that
+   measures the size of the compiled pattern. */
    if (c == OP_RECURSE)
      {
-     BOOL empty_branch = FALSE;
+     const uschar *scode;
-     const uschar *scode = cd->start_code + GET(code, 1);
+     BOOL empty_branch;
+     /* Test for forward reference */
+     for (scode = cd->start_workspace; scode < cd->hwm; scode += LINK_SIZE)
+       if (GET(scode, 0) == code + 1 - cd->start_code) return TRUE;
+     /* Not a forward reference, test for completed backward reference */
+     empty_branch = FALSE;
+     scode = cd->start_code + GET(code, 1);
      if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+     /* Completed backwards reference */
      do
        {
        if (could_be_empty_branch(scode, endcode, utf8, cd))
-Line 1991 
 for (code = first_significant_code(code
+Line 2010 
 for (code = first_significant_code(code
        scode += GET(scode, 1);
        }
      while (*scode == OP_ALT);
      if (!empty_branch) return FALSE;  /* All branches are non-empty */
      continue;
      }
-Line 2216 
 return TRUE;
+Line 2236 
 return TRUE;
  the current branch of the current pattern to see if it could match the empty
  string. If it could, we must look outwards for branches at other levels,
  stopping when we pass beyond the bracket which is the subject of the recursion.
+ This function is called only during the real compile, not during the
+ pre-compile.
  Arguments:
    code        points to start of the recursion
-Line 3017 
 int greedy_default, greedy_non_default;
+Line 3039 
 int greedy_default, greedy_non_default;
  int firstbyte, reqbyte;
  int zeroreqbyte, zerofirstbyte;
  int req_caseopt, reqvary, tempreqvary;
- int options = *optionsptr;
+ int options = *optionsptr;               /* May change dynamically */
  int after_manual_callout = 0;
  int length_prevgroup = 0;
  register int c;
-Line 3035 
 uschar *previous_callout = NULL;
+Line 3057 
 uschar *previous_callout = NULL;
  uschar *save_hwm = NULL;
  uschar classbits[32];
+ /* We can fish out the UTF-8 setting once and for all into a BOOL, but we
+ must not do this for other options (e.g. PCRE_EXTENDED) because they may change
+ dynamically as we process the pattern. */
  #ifdef SUPPORT_UTF8
  BOOL class_utf8;
  BOOL utf8 = (options & PCRE_UTF8) != 0;
-Line 3215 
 for (;; ptr++)
+Line 3241 
 for (;; ptr++)
      previous_callout = NULL;
      }
-   /* In extended mode, skip white space and comments */
+   /* In extended mode, skip white space and comments. */
    if ((options & PCRE_EXTENDED) != 0)
      {
-Line 4207 
 for (;; ptr++)
+Line 4233 
 for (;; ptr++)
        ptr++;
        }
      else repeat_type = greedy_default;
+     /* If previous was a recursion call, wrap it in atomic brackets so that
+     previous becomes the atomic group. All recursions were so wrapped in the
+     past, but it no longer happens for non-repeated recursions. In fact, the
+     repeated ones could be re-implemented independently so as not to need this,
+     but for the moment we rely on the code for repeating groups. */
+     if (*previous == OP_RECURSE)
+       {
+       memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
+       *previous = OP_ONCE;
+       PUT(previous, 1, 2 + 2*LINK_SIZE);
+       previous[2 + 2*LINK_SIZE] = OP_KET;
+       PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
+       code += 2 + 2 * LINK_SIZE;
+       length_prevgroup = 3 + 3*LINK_SIZE;
+       /* When actually compiling, we need to check whether this was a forward
+       reference, and if so, adjust the offset. */
+       if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)
+         {
+         int offset = GET(cd->hwm, -LINK_SIZE);
+         if (offset == previous + 1 - cd->start_code)
+           PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);
+         }
+       }
+     /* Now handle repetition for the different types of item. */
      /* If previous was a character match, abolish the item and generate a
      repeat item instead. If a char item has a minumum of more than one, ensure
-Line 4510 
 for (;; ptr++)
+Line 4565 
 for (;; ptr++)
        int len = (int)(code - previous);
        uschar *bralink = NULL;
        uschar *brazeroptr = NULL;
        /* Repeating a DEFINE group is pointless */
        if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
-Line 4726 
 for (;; ptr++)
+Line 4781 
 for (;; ptr++)
          }
        /* If the maximum is unlimited, set a repeater in the final copy. For
-       ONCE brackets, that's all we need to do.
+       ONCE brackets, that's all we need to do. However, possessively repeated
+       ONCE brackets can be converted into non-capturing brackets, as the
+       behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
+       deal with possessive ONCEs specially.
        Otherwise, if the quantifier was possessive, we convert the BRA code to
        the POS form, and the KET code to KETRPOS. (It turns out to be convenient
        at runtime to detect this kind of subpattern at both the start and at the
-       end.) If the group is preceded by OP_BRAZERO, convert this to
+       end.) The use of special opcodes makes it possible to reduce greatly the
-       OP_BRAPOSZERO. Then cancel the possessive flag so that the default action
+       stack usage in pcre_exec(). If the group is preceded by OP_BRAZERO,
-       below, of wrapping everything inside atomic brackets, does not happen.
+       convert this to OP_BRAPOSZERO. Then cancel the possessive flag so that
+       the default action below, of wrapping everything inside atomic brackets,
+       does not happen.
        Then, when we are doing the actual compile phase, check to see whether
        this group is one that could match an empty string. If so, convert the
-Line 4745 
 for (;; ptr++)
+Line 4805 
 for (;; ptr++)
          {
          uschar *ketcode = code - 1 - LINK_SIZE;
          uschar *bracode = ketcode - GET(ketcode, 1);
-         if (*bracode == OP_ONCE)
+         if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA;
+         if (*bracode == OP_ONCE)
            *ketcode = OP_KETRMAX + repeat_type;
          else
            {
-Line 4793 
 for (;; ptr++)
+Line 4854 
 for (;; ptr++)
        }
      /* If the character following a repeat is '+', or if certain optimization
-     tests above succeeded, possessive_quantifier is TRUE. For some of the
+     tests above succeeded, possessive_quantifier is TRUE. For some opcodes,
-     simpler opcodes, there is an special alternative opcode for this. For
+     there are special alternative opcodes for this case. For anything else, we
-     anything else, we wrap the entire repeated item inside OP_ONCE brackets.
+     wrap the entire repeated item inside OP_ONCE brackets. Logically, the '+'
-     The '+' notation is just syntactic sugar, taken from Sun's Java package,
+     notation is just syntactic sugar, taken from Sun's Java package, but the
-     but the special opcodes can optimize it a bit. The repeated item starts at
+     special opcodes can optimize it.
-     tempcode, not at previous, which might be the first part of a string whose
-     (former) last char we repeated.
+     Possessively repeated subpatterns have already been handled in the code
+     just above, so possessive_quantifier is always FALSE for them at this
+     stage.
+     Note that the repeated item starts at tempcode, not at previous, which
+     might be the first part of a string whose (former) last char we repeated.
      Possessifying an 'exact' quantifier has no effect, so we can ignore it. But
      an 'upto' may follow. We skip over an 'exact' item, and then test the
-Line 4924 
 for (;; ptr++)
+Line 4990 
 for (;; ptr++)
          if (namelen == verbs[i].len &&
              strncmp((char *)name, vn, namelen) == 0)
            {
-           /* Check for open captures before ACCEPT */
+           /* Check for open captures before ACCEPT and convert it to
+           ASSERT_ACCEPT if in an assertion. */
            if (verbs[i].op == OP_ACCEPT)
              {
              open_capitem *oc;
+             if (arglen != 0)
+               {
+               *errorcodeptr = ERR59;
+               goto FAILED;
+               }
              cd->had_accept = TRUE;
              for (oc = cd->open_caps; oc != NULL; oc = oc->next)
                {
                *code++ = OP_CLOSE;
                PUT2INC(code, 0, oc->number);
                }
+             *code++ = (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
              }
-           /* Handle the cases with/without an argument */
+           /* Handle other cases with/without an argument */
-           if (arglen == 0)
+           else if (arglen == 0)
              {
              if (verbs[i].op < 0)   /* Argument is mandatory */
                {
-Line 5228 
 for (;; ptr++)
+Line 5301 
 for (;; ptr++)
          /* ------------------------------------------------------------ */
          case CHAR_EQUALS_SIGN:                 /* Positive lookahead */
          bravalue = OP_ASSERT;
+         cd->assert_depth += 1;
          ptr++;
          break;
-Line 5242 
 for (;; ptr++)
+Line 5316 
 for (;; ptr++)
            continue;
            }
          bravalue = OP_ASSERT_NOT;
+         cd->assert_depth += 1;
          break;
-Line 5251 
 for (;; ptr++)
+Line 5326 
 for (;; ptr++)
            {
            case CHAR_EQUALS_SIGN:               /* Positive lookbehind */
            bravalue = OP_ASSERTBACK;
+           cd->assert_depth += 1;
            ptr += 2;
            break;
            case CHAR_EXCLAMATION_MARK:          /* Negative lookbehind */
            bravalue = OP_ASSERTBACK_NOT;
+           cd->assert_depth += 1;
            ptr += 2;
            break;
-Line 5499 
 for (;; ptr++)
+Line 5576 
 for (;; ptr++)
            temp = cd->end_pattern;
            cd->end_pattern = ptr;
            recno = find_parens(cd, name, namelen,
              (options & PCRE_EXTENDED) != 0, utf8);
            cd->end_pattern = temp;
            if (recno < 0) recno = 0;    /* Forward ref; set dummy number */
-Line 5646 
 for (;; ptr++)
+Line 5723 
 for (;; ptr++)
                /* 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. */
+               of the group. Then remember the forward reference. */
                called = cd->start_code + recno;
-               PUTINC(cd->hwm, 0, (int)(code + 2 + LINK_SIZE - cd->start_code));
+               PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));
                }
              /* If not a forward reference, and the subpattern is still open,
-Line 5664 
 for (;; ptr++)
+Line 5741 
 for (;; ptr++)
                }
              }
-           /* Insert the recursion/subroutine item, automatically wrapped inside
+           /* Insert the recursion/subroutine item. */
-           "once" brackets. Set up a "previous group" length so that a
-           subsequent quantifier will work. */
-           *code = OP_ONCE;
-           PUT(code, 1, 2 + 2*LINK_SIZE);
-           code += 1 + LINK_SIZE;
            *code = OP_RECURSE;
            PUT(code, 1, (int)(called - cd->start_code));
            code += 1 + LINK_SIZE;
-           *code = OP_KET;
-           PUT(code, 1, 2 + 2*LINK_SIZE);
-           code += 1 + LINK_SIZE;
-           length_prevgroup = 3 + 3*LINK_SIZE;
            }
          /* Can't determine a first byte now */
-Line 5823 
 for (;; ptr++)
+Line 5888 
 for (;; ptr++)
             &length_prevgroup           /* Pre-compile phase */
           ))
        goto FAILED;
+     if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
+       cd->assert_depth -= 1;
      /* At the end of compiling, code is still pointing to the start of the
      group, while tempcode has been updated to point past the end of the group
-Line 5894 
 for (;; ptr++)
+Line 5962 
 for (;; ptr++)
          goto FAILED;
          }
        *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
-       *code++ = OP_BRA;
+       code++;   /* This already contains bravalue */
        PUTINC(code, 0, 1 + LINK_SIZE);
        *code++ = OP_KET;
        PUTINC(code, 0, 1 + LINK_SIZE);
-Line 6062 
 for (;; ptr++)
+Line 6130 
 for (;; ptr++)
          }
        /* \k<name> or \k'name' is a back reference by name (Perl syntax).
-       We also support \k{name} (.NET syntax) */
+       We also support \k{name} (.NET syntax).  */
-       if (-c == ESC_k && (ptr[1] == CHAR_LESS_THAN_SIGN ||
+       if (-c == ESC_k)
-           ptr[1] == CHAR_APOSTROPHE || ptr[1] == CHAR_LEFT_CURLY_BRACKET))
          {
+         if ((ptr[1] != CHAR_LESS_THAN_SIGN &&
+           ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))
+           {
+           *errorcodeptr = ERR69;
+           break;
+           }
          is_recurse = FALSE;
          terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
            CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
            CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
          goto NAMED_REF_OR_RECURSE;
          }
        /* Back references are handled specially; must disable firstbyte if
        not set to cope with cases like (?=(\w+))\1: which would otherwise set
-Line 6969 
 utf8 = (options & PCRE_UTF8) != 0;
+Line 7042 
 utf8 = (options & PCRE_UTF8) != 0;
  /* Can't support UTF8 unless PCRE has been compiled to include the code. The
  return of an error code from _pcre_valid_utf8() is a new feature, introduced in
- release 8.13. The only use we make of it here is to adjust the offset value to
+ release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is
- the end of the string for a short string error, for compatibility with previous
+ not used here. */
- versions. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
-      (*erroroffset = _pcre_valid_utf8((USPTR)pattern, -1, &errorcode)) >= 0)
+      (errorcode = _pcre_valid_utf8((USPTR)pattern, -1, erroroffset)) != 0)
    {
    errorcode = ERR44;
    goto PCRE_EARLY_ERROR_RETURN2;
-Line 7146 
 field; this time it's used for rememberi
+Line 7218 
 field; this time it's used for rememberi
  */
  cd->final_bracount = cd->bracount;  /* Save for checking forward references */
+ cd->assert_depth = 0;
  cd->bracount = 0;
  cd->names_found = 0;
  cd->name_table = (uschar *)re + re->name_table_offset;

 Legend:



Removed from v.604
 


changed lines


 
Added in v.635
 Legend:



Removed from v.604
 


changed lines


 
Added in v.635
-Removed from v.604
+Added in v.635

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12