/[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 389 by ph10,
Sun Mar 15 18:24:05 2009 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2008 University of Cambridge
+            Copyright (c) 1997-2009 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 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 454 
 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);
+ for (; n > 0; n--) while (*s++ != 0) {};
  return s;
  }
-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 1000 
 for (; *ptr != 0; ptr++)
+Line 1002 
 for (; *ptr != 0; ptr++)
      if (*(++ptr) == 0) return -1;
      if (*ptr == 'Q') for (;;)
        {
-       while (*(++ptr) != 0 && *ptr != '\\');
+       while (*(++ptr) != 0 && *ptr != '\\') {};
        if (*ptr == 0) return -1;
        if (*(++ptr) == 'E') break;
        }
      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 1019 
 for (; *ptr != 0; ptr++)
+Line 1045 
 for (; *ptr != 0; ptr++)
          if (*(++ptr) == 0) return -1;
          if (*ptr == 'Q') for (;;)
            {
-           while (*(++ptr) != 0 && *ptr != '\\');
+           while (*(++ptr) != 0 && *ptr != '\\') {};
            if (*ptr == 0) return -1;
            if (*(++ptr) == 'E') break;
            }
-Line 1033 
 for (; *ptr != 0; ptr++)
+Line 1059 
 for (; *ptr != 0; ptr++)
    if (xmode && *ptr == '#')
      {
-     while (*(++ptr) != 0 && *ptr != '\n');
+     while (*(++ptr) != 0 && *ptr != '\n') {};
      if (*ptr == 0) return -1;
      continue;
      }
-Line 1275 
 for (;;)
+Line 1301 
 for (;;)
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
      case OP_ANY:
+     case OP_ALLANY:
      branchlength++;
      cc++;
      break;
-Line 1423 
 for (;;)
+Line 1450 
 for (;;)
        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
        break;
        }
+ #else
+     (void)(utf8);  /* Keep compiler happy by referencing function argument */
  #endif
      }
    }
-Line 1516 
 for (;;)
+Line 1545 
 for (;;)
        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
        break;
        }
+ #else
+     (void)(utf8);  /* Keep compiler happy by referencing function argument */
  #endif
      }
    }
-Line 1567 
 for (code = first_significant_code(code
+Line 1598 
 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 1684 
 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 1879 
 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 1986 
 get_othercase_range(unsigned int *cptr,
+Line 2019 
 get_othercase_range(unsigned int *cptr,
  unsigned int c, othercase, next;
  for (c = *cptr; c <= d; c++)
-   { if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR) break; }
+   { if ((othercase = UCD_OTHERCASE(c)) != c) break; }
  if (c > d) return FALSE;
-Line 1995 
 next = othercase + 1;
+Line 2028 
 next = othercase + 1;
  for (++c; c <= d; c++)
    {
-   if (_pcre_ucp_othercase(c) != next) break;
+   if (UCD_OTHERCASE(c) != next) break;
    next++;
    }
-Line 2105 
 if (next >= 0) switch(op_code)
+Line 2138 
 if (next >= 0) switch(op_code)
    case OP_CHAR:
  #ifdef SUPPORT_UTF8
    if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
+ #else
+   (void)(utf8_char);  /* Keep compiler happy by referencing function argument */
  #endif
    return item != next;
-Line 2123 
 if (next >= 0) switch(op_code)
+Line 2158 
 if (next >= 0) switch(op_code)
      unsigned int othercase;
      if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = _pcre_ucp_othercase((unsigned int)next);
+     othercase = UCD_OTHERCASE((unsigned int)next);
  #else
      othercase = NOTACHAR;
  #endif
-Line 2144 
 if (next >= 0) switch(op_code)
+Line 2179 
 if (next >= 0) switch(op_code)
      unsigned int othercase;
      if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = _pcre_ucp_othercase(next);
+     othercase = UCD_OTHERCASE(next);
  #else
      othercase = NOTACHAR;
  #endif
-Line 2638 
 for (;; ptr++)
+Line 2673 
 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 2688 
 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 2732 
 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 3287 
 for (;; ptr++)
+Line 3345 
 for (;; ptr++)
          if ((options & PCRE_CASELESS) != 0)
            {
            unsigned int othercase;
-           if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR)
+           if ((othercase = UCD_OTHERCASE(c)) != c)
              {
              *class_utf8data++ = XCL_SINGLE;
              class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
-Line 3842 
 we set the flag only if there is a liter
+Line 3900 
 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 4126 
 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 4147 
 we set the flag only if there is a liter
+Line 4222 
 we set the flag only if there is a liter
        const char *vn = verbnames;
        const uschar *name = ++ptr;
        previous = NULL;
-       while ((cd->ctypes[*++ptr] & ctype_letter) != 0);
+       while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
        if (*ptr == ':')
          {
          *errorcodeptr = ERR59;   /* Not supported */
-Line 4344 
 we set the flag only if there is a liter
+Line 4419 
 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 4716 
 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 4744 
 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 4826 
 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 4851 
 we set the flag only if there is a liter
+Line 4926 
 we set the flag only if there is a liter
          both phases.
          If we are not at the pattern start, compile code to change the ims
-         options if this setting actually changes any of them. We also pass the
+         options if this setting actually changes any of them, and reset the
-         new setting back so that it can be put at the start of any following
+         greedy defaults and the case value for firstbyte and reqbyte. */
-         branches, and when this group ends (if we are in a group), a resetting
-         item can be compiled. */
          if (*ptr == ')')
            {
-Line 4862 
 we set the flag only if there is a liter
+Line 4935 
 we set the flag only if there is a liter
                 (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))
              {
              cd->external_options = newoptions;
-             options = newoptions;
              }
           else
              {
-Line 4871 
 we set the flag only if there is a liter
+Line 4943 
 we set the flag only if there is a liter
                *code++ = OP_OPT;
                *code++ = newoptions & PCRE_IMS;
                }
-             /* Change options at this level, and pass them back for use
-             in subsequent branches. Reset the greedy defaults and the case
-             value for firstbyte and reqbyte. */
-             *optionsptr = options = newoptions;
              greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
              greedy_non_default = greedy_default ^ 1;
-             req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
+             req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
              }
+           /* Change options at this level, and pass them back for use
+           in subsequent branches. When not at the start of the pattern, this
+           information is also necessary so that a resetting item can be
+           compiled at the end of a group (if we are in a group). */
+           *optionsptr = options = newoptions;
            previous = NULL;       /* This item can't be repeated */
            continue;              /* It is complete */
            }
-Line 5094 
 we set the flag only if there is a liter
+Line 5166 
 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 5193 
 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 5248 
 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 5758 
 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 */
-Line 5737 
 do {
+Line 5810 
 do {
     const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
       NULL, 0, FALSE);
     register int op = *scode;
+    /* If we are at the start of a conditional assertion group, *both* the
+    conditional assertion *and* what follows the condition must satisfy the test
+    for start of line. Other kinds of condition fail. Note that there may be an
+    auto-callout at the start of a condition. */
+    if (op == OP_COND)
+      {
+      scode += 1 + LINK_SIZE;
+      if (*scode == OP_CALLOUT) scode += _pcre_OP_lengths[OP_CALLOUT];
+      switch (*scode)
+        {
+        case OP_CREF:
+        case OP_RREF:
+        case OP_DEF:
+        return FALSE;
+        default:     /* Assertion */
+        if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+        do scode += GET(scode, 1); while (*scode == OP_ALT);
+        scode += 1 + LINK_SIZE;
+        break;
+        }
+      scode = first_significant_code(scode, NULL, 0, FALSE);
+      op = *scode;
+      }
     /* Non-capturing brackets */
-Line 5756 
 do {
+Line 5855 
 do {
     /* Other brackets */
-    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
+    else if (op == OP_ASSERT || op == OP_ONCE)
-      { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }
+      {
+      if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+      }
     /* .* means "start at start or after \n" if it isn't in brackets that
     may be referenced. */
-Line 5874 
 Returns:        pointer to compiled data
+Line 5975 
 Returns:        pointer to compiled data
                  with errorptr and erroroffset set
  */
- PCRE_EXP_DEFN pcre *
+ PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile(const char *pattern, int options, const char **errorptr,
    int *erroroffset, const unsigned char *tables)
  {
-Line 5882 
 return pcre_compile2(pattern, options, N
+Line 5983 
 return pcre_compile2(pattern, options, N
  }
- PCRE_EXP_DEFN pcre *
+ PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile2(const char *pattern, int options, int *errorcodeptr,
    const char **errorptr, int *erroroffset, const unsigned char *tables)
  {
-Line 5954 
 if ((options & PCRE_UTF8) != 0)
+Line 6055 
 if ((options & PCRE_UTF8) != 0)
    }
  #endif
- if ((options & ~PUBLIC_OPTIONS) != 0)
+ if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)
    {
    errorcode = ERR17;
    goto PCRE_EARLY_ERROR_RETURN;

 Legend:



Removed from v.333
 


changed lines


 
Added in v.389
 Legend:



Removed from v.333
 


changed lines


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

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12