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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 333 by ph10,
Thu Apr 10 19:55:57 2008 UTC
+revision 345 by ph10,
Mon Apr 28 15:10:02 2008 UTC
 Line 302 
 static const char error_texts[] =
    "(*VERB) not recognized\0"
    "number is too big\0"
    "subpattern name expected\0"
-   "digit expected after (?+";
+   "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 532 
 else
+Line 533 
 else
      break;
      /* \g must be followed by one of a number of specific things:
      (1) A number, either plain or braced. If positive, it is an absolute
      backreference. If negative, it is a relative backreference. This is a Perl
 .10 feature.
      (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 587 
 else
+Line 588 
 else
        *errorcodeptr = ERR61;
        break;
        }
      if (braced && *(++ptr) != '}')
        {
        *errorcodeptr = ERR57;
        break;
        }
      if (c == 0)
        {
        *errorcodeptr = ERR58;
        break;
        }
      if (negated)
        {
-Line 975 
 be terminated by '>' because that is che
+Line 976 
 be terminated by '>' because that is che
  Arguments:
    ptr          current position in the pattern
-   count        current count of capturing parens so far encountered
+   cd           compile background data
    name         name to seek, or NULL if seeking a numbered subpattern
    lorn         name length, or subpattern number if name is NULL
    xmode        TRUE if we are in /x mode
-Line 984 
 Returns:       the number of the named s
+Line 985 
 Returns:       the number of the named s
  */
  static int
- find_parens(const uschar *ptr, int count, const uschar *name, int lorn,
+ find_parens(const uschar *ptr, compile_data *cd, const uschar *name, int lorn,
    BOOL xmode)
  {
  const uschar *thisname;
+ int count = cd->bracount;
  for (; *ptr != 0; ptr++)
    {
-Line 1007 
 for (; *ptr != 0; ptr++)
+Line 1009 
 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, except in JavaScript compatibility mode. */
+     if (ptr[1] == ']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
+       ptr++;
      while (*(++ptr) != ']')
        {
        if (*ptr == 0) return -1;
-Line 1275 
 for (;;)
+Line 1301 
 for (;;)
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
      case OP_ANY:
+     case OP_ALLANY:
      branchlength++;
      cc++;
      break;
-Line 1567 
 for (code = first_significant_code(code
+Line 1594 
 for (code = first_significant_code(code
    /* 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 1653 
 for (code = first_significant_code(code
+Line 1680 
 for (code = first_significant_code(code
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
      case OP_ANY:
+     case OP_ALLANY:
      case OP_ANYBYTE:
      case OP_CHAR:
      case OP_CHARNC:
-Line 1847 
 return -1;
+Line 1875 
 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 2638 
 for (;; ptr++)
+Line 2667 
 for (;; ptr++)
      zerofirstbyte = firstbyte;
      zeroreqbyte = reqbyte;
      previous = code;
-     *code++ = OP_ANY;
+     *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
      break;
-Line 2653 
 for (;; ptr++)
+Line 2682 
 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 2687 
 for (;; ptr++)
+Line 2726 
 for (;; ptr++)
        else break;
        }
+     /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,
+     an initial ']' is taken as a data character -- the code below handles
+     that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
+     [^] must match any character, so generate OP_ALLANY. */
+     if (c ==']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+       {
+       *code++ = negate_class? OP_ALLANY : OP_FAIL;
+       if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+       zerofirstbyte = firstbyte;
+       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). */
-Line 3842 
 we set the flag only if there is a liter
+Line 3894 
 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)
-           {
-           code = previous;
-           goto END_REPEAT;
-           }
-         /* If the maximum is 1 or unlimited, we just have to stick in the
+         ** if (repeat_max == 0)
-         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
+         **   code = previous;
-         any internal or forward referenced group, because the offset is from
+         **   goto END_REPEAT;
-         the start of the whole regex. Temporarily terminate the pattern while
+         **   }
-         doing this. */
+         However, that fails when a group is referenced as a subroutine from
+         elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
+         so that it is skipped on execution. As we don't have a list of which
+         groups are referenced, we cannot do this selectively.
+         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 4058 
 we set the flag only if there is a liter
+Line 4120 
 we set the flag only if there is a liter
          }
        }
+     /* If previous is OP_FAIL, it was generated by an empty class [] in
+     JavaScript mode. The other ways in which OP_FAIL can be generated, that is
+     by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"
+     error above. We can just ignore the repeat in JS case. */
+     else if (*previous == OP_FAIL) goto END_REPEAT;
      /* Else there's some kind of shambles */
      else
-Line 4344 
 we set the flag only if there is a liter
+Line 4413 
 we set the flag only if there is a liter
          /* Search the pattern for a forward reference */
-         else if ((i = find_parens(ptr, cd->bracount, name, namelen,
+         else if ((i = find_parens(ptr, cd, name, namelen,
                          (options & PCRE_EXTENDED) != 0)) > 0)
            {
            PUT2(code, 2+LINK_SIZE, i);
-Line 4641 
 we set the flag only if there is a liter
+Line 4710 
 we set the flag only if there is a liter
              recno = GET2(slot, 0);
              }
            else if ((recno =                /* Forward back reference */
-                     find_parens(ptr, cd->bracount, name, namelen,
+                     find_parens(ptr, cd, name, namelen,
                        (options & PCRE_EXTENDED) != 0)) <= 0)
              {
              *errorcodeptr = ERR15;
-Line 4669 
 we set the flag only if there is a liter
+Line 4738 
 we set the flag only if there is a liter
            {
            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) == '+')
              {
-Line 4751 
 we set the flag only if there is a liter
+Line 4820 
 we set the flag only if there is a liter
              if (called == NULL)
                {
-               if (find_parens(ptr, cd->bracount, NULL, recno,
+               if (find_parens(ptr, cd, NULL, recno,
-                    (options & PCRE_EXTENDED) != 0) < 0)
+                     (options & PCRE_EXTENDED) != 0) < 0)
                  {
                  *errorcodeptr = ERR15;
                  goto FAILED;
-Line 5094 
 we set the flag only if there is a liter
+Line 5163 
 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 5121 
 we set the flag only if there is a liter
+Line 5190 
 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). */
+       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)
-Line 5175 
 we set the flag only if there is a liter
+Line 5245 
 we set the flag only if there is a liter
            *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 5685 
 do {
+Line 5755 
 do {
       if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
       }
-    /* .* is not anchored unless DOTALL is set and it isn't in brackets that
+    /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
-    are or may be referenced. */
+    it isn't in brackets that are or may be referenced. */
     else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
-              op == OP_TYPEPOSSTAR) &&
+              op == OP_TYPEPOSSTAR))
-             (*options & PCRE_DOTALL) != 0)
       {
-      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
+      if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)
+        return FALSE;
       }
     /* Check for explicit anchoring */

 Legend:



Removed from v.333
 


changed lines


 
Added in v.345
 Legend:



Removed from v.333
 


changed lines


 
Added in v.345
-Removed from v.333
+Added in v.345

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12