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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 31 by nigel,
Sat Feb 24 21:38:57 2007 UTC
+revision 49 by nigel,
Sat Feb 24 21:39:33 2007 UTC
 Line 9 
 the file Tech.Notes for some information
  Written by: Philip Hazel <ph10@cam.ac.uk>
-            Copyright (c) 1997-1999 University of Cambridge
+            Copyright (c) 1997-2000 University of Cambridge
  -----------------------------------------------------------------------------
  Permission is granted to anyone to use this software for any purpose on any
 Line 66 
 not be set greater than 200. */
  #define BRASTACK_SIZE 200
+ /* The number of bytes in a literal character string above which we can't add
+ any more is different when UTF-8 characters may be encountered. */
+ #ifdef SUPPORT_UTF8
+ #define MAXLIT 250
+ #else
+ #define MAXLIT 255
+ #endif
  /* Min and max values for the common repeats; for the maxima, 0 => infinity */
  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
-Line 82 
 static const char *OP_names[] = {
+Line 92 
 static const char *OP_names[] = {
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{",
-   "class", "Ref",
+   "class", "Ref", "Recurse",
    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",
    "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cref",
    "Brazero", "Braminzero", "Bra"
-Line 107 
 static const short int escapes[] = {
+Line 117 
 static const short int escapes[] = {
 ,      0, -ESC_z                                            /* x - z */
  };
+ /* Tables of names of POSIX character classes and their lengths. The list is
+ terminated by a zero length entry. The first three must be alpha, upper, lower,
+ as this is assumed for handling case independence. */
+ static const char *posix_names[] = {
+   "alpha", "lower", "upper",
+   "alnum", "ascii", "cntrl", "digit", "graph",
+   "print", "punct", "space", "word",  "xdigit" };
+ static const uschar posix_name_lengths[] = {
+, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
+ /* Table of class bit maps for each POSIX class; up to three may be combined
+ to form the class. */
+ static const int posix_class_maps[] = {
+   cbit_lower, cbit_upper, -1,             /* alpha */
+   cbit_lower, -1,         -1,             /* lower */
+   cbit_upper, -1,         -1,             /* upper */
+   cbit_digit, cbit_lower, cbit_upper,     /* alnum */
+   cbit_print, cbit_cntrl, -1,             /* ascii */
+   cbit_cntrl, -1,         -1,             /* cntrl */
+   cbit_digit, -1,         -1,             /* digit */
+   cbit_graph, -1,         -1,             /* graph */
+   cbit_print, -1,         -1,             /* print */
+   cbit_punct, -1,         -1,             /* punct */
+   cbit_space, -1,         -1,             /* space */
+   cbit_word,  -1,         -1,             /* word */
+   cbit_xdigit,-1,         -1              /* xdigit */
+ };
  /* Definition to allow mutual recursion */
  static BOOL
    compile_regex(int, int, int *, uschar **, const uschar **, const char **,
-     BOOL, int, compile_data *);
+     BOOL, int, int *, int *, compile_data *);
+ /* Structure for building a chain of data that actually lives on the
+ stack, for holding the values of the subject pointer at the start of each
+ subpattern, so as to detect when an empty string has been matched by a
+ subpattern - to break infinite loops. */
+ typedef struct eptrblock {
+   struct eptrblock *prev;
+   const uschar *saved_eptr;
+ } eptrblock;
+ /* Flag bits for the match() function */
+ #define match_condassert   0x01    /* Called to check a condition assertion */
+ #define match_isgroup      0x02    /* Set if start of bracketed group */
-Line 129 
 void  (*pcre_free)(void *) = free;
+Line 186 
 void  (*pcre_free)(void *) = free;
+ /*************************************************
+ *    Macros and tables for character handling    *
+ *************************************************/
+ /* When UTF-8 encoding is being used, a character is no longer just a single
+ byte. The macros for character handling generate simple sequences when used in
+ byte-mode, and more complicated ones for UTF-8 characters. */
+ #ifndef SUPPORT_UTF8
+ #define GETCHARINC(c, eptr) c = *eptr++;
+ #define GETCHARLEN(c, eptr, len) c = *eptr;
+ #define BACKCHAR(eptr)
+ #else   /* SUPPORT_UTF8 */
+ /* Get the next UTF-8 character, advancing the pointer */
+ #define GETCHARINC(c, eptr) \
+   c = *eptr++; \
+   if (md->utf8 && (c & 0xc0) == 0xc0) \
+     { \
+     int a = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+     int s = 6 - a;                  /* Amount to shift next byte */  \
+     c &= utf8_table3[a];            /* Low order bits from first byte */ \
+     while (a-- > 0) \
+       { \
+       c |= (*eptr++ & 0x3f) << s; \
+       s += 6; \
+       } \
+     }
+ /* Get the next UTF-8 character, not advancing the pointer, setting length */
+ #define GETCHARLEN(c, eptr, len) \
+   c = *eptr; \
+   len = 1; \
+   if (md->utf8 && (c & 0xc0) == 0xc0) \
+     { \
+     int i; \
+     int a = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+     int s = 6 - a;                  /* Amount to shift next byte */  \
+     c &= utf8_table3[a];            /* Low order bits from first byte */ \
+     for (i = 1; i <= a; i++) \
+       { \
+       c |= (eptr[i] & 0x3f) << s; \
+       s += 6; \
+       } \
+     len += a; \
+     }
+ /* If the pointer is not at the start of a character, move it back until
+ it is. */
+ #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--;
+ #endif
  /*************************************************
  *             Default character tables           *
-Line 144 
 tables. */
+Line 259 
 tables. */
+ #ifdef SUPPORT_UTF8
+ /*************************************************
+ *           Tables for UTF-8 support             *
+ *************************************************/
+ /* These are the breakpoints for different numbers of bytes in a UTF-8
+ character. */
+ static int utf8_table1[] = { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff};
+ /* These are the indicator bits and the mask for the data bits to set in the
+ first byte of a character, indexed by the number of additional bytes. */
+ static int utf8_table2[] = { 0,    0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
+ static int utf8_table3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
+ /* Table of the number of extra characters, indexed by the first character
+ masked with 0x3f. The highest number for a valid UTF-8 character is in fact
+x3d. */
+ static uschar utf8_table4[] = {
+,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
+ /*************************************************
+ *       Convert character value to UTF-8         *
+ *************************************************/
+ /* This function takes an integer value in the range 0 - 0x7fffffff
+ and encodes it as a UTF-8 character in 0 to 6 bytes.
+ Arguments:
+   cvalue     the character value
+   buffer     pointer to buffer for result - at least 6 bytes long
+ Returns:     number of characters placed in the buffer
+ */
+ static int
+ ord2utf8(int cvalue, uschar *buffer)
+ {
+ register int i, j;
+ for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
+   if (cvalue <= utf8_table1[i]) break;
+ *buffer++ = utf8_table2[i] | (cvalue & utf8_table3[i]);
+ cvalue >>= 6 - i;
+ for (j = 0; j < i; j++)
+   {
+   *buffer++ = 0x80 | (cvalue & 0x3f);
+   cvalue >>= 6;
+   }
+ return i + 1;
+ }
+ #endif
  /*************************************************
  *          Return version string                 *
  *************************************************/
+ #define STRING(a)  # a
+ #define XSTRING(s) STRING(s)
  const char *
  pcre_version(void)
  {
- return PCRE_VERSION;
+ return XSTRING(PCRE_MAJOR) "." XSTRING(PCRE_MINOR) " " XSTRING(PCRE_DATE);
  }
  /*************************************************
- *       Return info about a compiled pattern     *
+ * (Obsolete) Return info about compiled pattern  *
  *************************************************/
- /* This function picks potentially useful data out of the private
+ /* This is the original "info" function. It picks potentially useful data out
- structure.
+ of the private structure, but its interface was too rigid. It remains for
+ backwards compatibility. The public options are passed back in an int - though
+ the re->options field has been expanded to a long int, all the public options
+ at the low end of it, and so even on 16-bit systems this will still be OK.
+ Therefore, I haven't changed the API for pcre_info().
  Arguments:
    external_re   points to compiled code
-Line 171 
 Arguments:
+Line 353 
 Arguments:
                  or -1 if multiline and all branches start ^,
                  or -2 otherwise
- Returns:        number of identifying extraction brackets
+ Returns:        number of capturing subpatterns
                  or negative values on error
  */
-Line 181 
 pcre_info(const pcre *external_re, int *
+Line 363 
 pcre_info(const pcre *external_re, int *
  const real_pcre *re = (const real_pcre *)external_re;
  if (re == NULL) return PCRE_ERROR_NULL;
  if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
- if (optptr != NULL) *optptr = (re->options & PUBLIC_OPTIONS);
+ if (optptr != NULL) *optptr = (int)(re->options & PUBLIC_OPTIONS);
  if (first_char != NULL)
    *first_char = ((re->options & PCRE_FIRSTSET) != 0)? re->first_char :
       ((re->options & PCRE_STARTLINE) != 0)? -1 : -2;
-Line 190 
 return re->top_bracket;
+Line 372 
 return re->top_bracket;
+ /*************************************************
+ *        Return info about compiled pattern      *
+ *************************************************/
+ /* This is a newer "info" function which has an extensible interface so
+ that additional items can be added compatibly.
+ Arguments:
+   external_re      points to compiled code
+   external_study   points to study data, or NULL
+   what             what information is required
+   where            where to put the information
+ Returns:           0 if data returned, negative on error
+ */
+ int
+ pcre_fullinfo(const pcre *external_re, const pcre_extra *study_data, int what,
+   void *where)
+ {
+ const real_pcre *re = (const real_pcre *)external_re;
+ const real_pcre_extra *study = (const real_pcre_extra *)study_data;
+ if (re == NULL || where == NULL) return PCRE_ERROR_NULL;
+ if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
+ switch (what)
+   {
+   case PCRE_INFO_OPTIONS:
+   *((unsigned long int *)where) = re->options & PUBLIC_OPTIONS;
+   break;
+   case PCRE_INFO_SIZE:
+   *((size_t *)where) = re->size;
+   break;
+   case PCRE_INFO_CAPTURECOUNT:
+   *((int *)where) = re->top_bracket;
+   break;
+   case PCRE_INFO_BACKREFMAX:
+   *((int *)where) = re->top_backref;
+   break;
+   case PCRE_INFO_FIRSTCHAR:
+   *((int *)where) =
+     ((re->options & PCRE_FIRSTSET) != 0)? re->first_char :
+     ((re->options & PCRE_STARTLINE) != 0)? -1 : -2;
+   break;
+   case PCRE_INFO_FIRSTTABLE:
+   *((const uschar **)where) =
+     (study != NULL && (study->options & PCRE_STUDY_MAPPED) != 0)?
+       study->start_bits : NULL;
+   break;
+   case PCRE_INFO_LASTLITERAL:
+   *((int *)where) =
+     ((re->options & PCRE_REQCHSET) != 0)? re->req_char : -1;
+   break;
+   default: return PCRE_ERROR_BADOPTION;
+   }
+ return 0;
+ }
  #ifdef DEBUG
  /*************************************************
-Line 227 
 while (length-- > 0)
+Line 477 
 while (length-- > 0)
  /* This function is called when a \ has been encountered. It either returns a
  positive value for a simple escape such as \n, or a negative value which
- encodes one of the more complicated things such as \d. On entry, ptr is
+ encodes one of the more complicated things such as \d. When UTF-8 is enabled,
- pointing at the \. On exit, it is on the final character of the escape
+ a positive value greater than 255 may be returned. On entry, ptr is pointing at
- sequence.
+ the \. On exit, it is on the final character of the escape sequence.
  Arguments:
    ptrptr     points to the pattern position pointer
-Line 249 
 check_escape(const uschar **ptrptr, cons
+Line 499 
 check_escape(const uschar **ptrptr, cons
    int options, BOOL isclass, compile_data *cd)
  {
  const uschar *ptr = *ptrptr;
- int c = *(++ptr) & 255;   /* Ensure > 0 on signed-char systems */
+ int c, i;
- int i;
+ /* If backslash is at the end of the pattern, it's an error. */
+ c = *(++ptr);
  if (c == 0) *errorptr = ERR1;
  /* Digits or letters may have special meaning; all others are literals. */
-Line 311 
 else
+Line 563 
 else
        }
      /* \0 always starts an octal number, but we may drop through to here with a
-     larger first octal digit */
+     larger first octal digit. */
      case '0':
      c -= '0';
      while(i++ < 2 && (cd->ctypes[ptr[1]] & ctype_digit) != 0 &&
        ptr[1] != '8' && ptr[1] != '9')
          c = c * 8 + *(++ptr) - '0';
+     c &= 255;     /* Take least significant 8 bits */
      break;
-     /* Special escapes not starting with a digit are straightforward */
+     /* \x is complicated when UTF-8 is enabled. \x{ddd} is a character number
+     which can be greater than 0xff, but only if the ddd are hex digits. */
      case 'x':
+ #ifdef SUPPORT_UTF8
+     if (ptr[1] == '{' && (options & PCRE_UTF8) != 0)
+       {
+       const uschar *pt = ptr + 2;
+       register int count = 0;
+       c = 0;
+       while ((cd->ctypes[*pt] & ctype_xdigit) != 0)
+         {
+         count++;
+         c = c * 16 + cd->lcc[*pt] -
+           (((cd->ctypes[*pt] & ctype_digit) != 0)? '0' : 'W');
+         pt++;
+         }
+       if (*pt == '}')
+         {
+         if (c < 0 || count > 8) *errorptr = ERR34;
+         ptr = pt;
+         break;
+         }
+       /* If the sequence of hex digits does not end with '}', then we don't
+       recognize this construct; fall through to the normal \x handling. */
+       }
+ #endif
+     /* Read just a single hex char */
      c = 0;
      while (i++ < 2 && (cd->ctypes[ptr[1]] & ctype_xdigit) != 0)
        {
-Line 332 
 else
+Line 612 
 else
        }
      break;
+     /* Other special escapes not starting with a digit are straightforward */
      case 'c':
      c = *(++ptr);
      if (c == 0)
-Line 469 
 if the length is fixed. This is needed f
+Line 751 
 if the length is fixed. This is needed f
  Arguments:
    code     points to the start of the pattern (the bracket)
+   options  the compiling options
  Returns:   the fixed length, or -1 if there is no fixed length
  */
  static int
- find_fixedlength(uschar *code)
+ find_fixedlength(uschar *code, int options)
  {
  int length = -1;
-Line 495 
 for (;;)
+Line 778 
 for (;;)
      case OP_BRA:
      case OP_ONCE:
      case OP_COND:
-     d = find_fixedlength(cc);
+     d = find_fixedlength(cc, options);
      if (d < 0) return -1;
      branchlength += d;
      do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT);
-Line 532 
 for (;;)
+Line 815 
 for (;;)
      case OP_REVERSE:
      cc++;
+     /* Fall through */
      case OP_CREF:
      case OP_OPT:
-Line 548 
 for (;;)
+Line 832 
 for (;;)
      cc++;
      break;
-     /* Handle char strings */
+     /* Handle char strings. In UTF-8 mode we must count characters, not bytes.
+     This requires a scan of the string, unfortunately. We assume valid UTF-8
+     strings, so all we do is reduce the length by one for byte whose bits are
+xxxxxx. */
      case OP_CHARS:
      branchlength += *(++cc);
+ #ifdef SUPPORT_UTF8
+     for (d = 1; d <= *cc; d++)
+       if ((cc[d] & 0xc0) == 0x80) branchlength--;
+ #endif
      cc += *cc + 1;
      break;
-Line 615 
 for (;;)
+Line 906 
 for (;;)
  /*************************************************
+ *           Check for POSIX class syntax         *
+ *************************************************/
+ /* This function is called when the sequence "[:" or "[." or "[=" is
+ encountered in a character class. It checks whether this is followed by an
+ optional ^ and then a sequence of letters, terminated by a matching ":]" or
+ ".]" or "=]".
+ Argument:
+   ptr      pointer to the initial [
+   endptr   where to return the end pointer
+   cd       pointer to compile data
+ Returns:   TRUE or FALSE
+ */
+ static BOOL
+ check_posix_syntax(const uschar *ptr, const uschar **endptr, compile_data *cd)
+ {
+ int terminator;          /* Don't combine these lines; the Solaris cc */
+ terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
+ if (*(++ptr) == '^') ptr++;
+ while ((cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
+ if (*ptr == terminator && ptr[1] == ']')
+   {
+   *endptr = ptr;
+   return TRUE;
+   }
+ return FALSE;
+ }
+ /*************************************************
+ *          Check POSIX class name                *
+ *************************************************/
+ /* This function is called to check the name given in a POSIX-style class entry
+ such as [:alnum:].
+ Arguments:
+   ptr        points to the first letter
+   len        the length of the name
+ Returns:     a value representing the name, or -1 if unknown
+ */
+ static int
+ check_posix_name(const uschar *ptr, int len)
+ {
+ register int yield = 0;
+ while (posix_name_lengths[yield] != 0)
+   {
+   if (len == posix_name_lengths[yield] &&
+     strncmp((const char *)ptr, posix_names[yield], len) == 0) return yield;
+   yield++;
+   }
+ return -1;
+ }
+ /*************************************************
  *           Compile one branch                   *
  *************************************************/
-Line 627 
 Arguments:
+Line 983 
 Arguments:
    ptrptr       points to the current pattern pointer
    errorptr     points to pointer to error message
    optchanged   set to the value of the last OP_OPT item compiled
+   reqchar      set to the last literal character required, else -1
+   countlits    set to count of mandatory literal characters
    cd           contains pointers to tables
  Returns:       TRUE on success
-Line 636 
 Returns:       TRUE on success
+Line 994 
 Returns:       TRUE on success
  static BOOL
  compile_branch(int options, int *brackets, uschar **codeptr,
    const uschar **ptrptr, const char **errorptr, int *optchanged,
-   compile_data *cd)
+   int *reqchar, int *countlits, compile_data *cd)
  {
  int repeat_type, op_type;
  int repeat_min, repeat_max;
  int bravalue, length;
  int greedy_default, greedy_non_default;
+ int prevreqchar;
+ int condcount = 0;
+ int subcountlits = 0;
  register int c;
  register uschar *code = *codeptr;
  uschar *tempcode;
-Line 655 
 uschar class[32];
+Line 1016 
 uschar class[32];
  greedy_default = ((options & PCRE_UNGREEDY) != 0);
  greedy_non_default = greedy_default ^ 1;
+ /* Initialize no required char, and count of literals */
+ *reqchar = prevreqchar = -1;
+ *countlits = 0;
  /* Switch on next character until the end of the branch */
  for (;; ptr++)
-Line 664 
 for (;; ptr++)
+Line 1030 
 for (;; ptr++)
    int class_lastchar;
    int newoptions;
    int condref;
+   int subreqchar;
    c = *ptr;
    if ((options & PCRE_EXTENDED) != 0)
-Line 671 
 for (;; ptr++)
+Line 1038 
 for (;; ptr++)
      if ((cd->ctypes[c] & ctype_space) != 0) continue;
      if (c == '#')
        {
-       while ((c = *(++ptr)) != 0 && c != '\n');
+       /* The space before the ; is to avoid a warning on a silly compiler
+       on the Macintosh. */
+       while ((c = *(++ptr)) != 0 && c != '\n') ;
        continue;
        }
      }
-Line 746 
 for (;; ptr++)
+Line 1115 
 for (;; ptr++)
          goto FAILED;
          }
+       /* Handle POSIX class names. Perl allows a negation extension of the
+       form [:^name]. A square bracket that doesn't match the syntax is
+       treated as a literal. We also recognize the POSIX constructions
+       [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
+.6 does. */
+       if (c == '[' &&
+           (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
+           check_posix_syntax(ptr, &tempptr, cd))
+         {
+         BOOL local_negate = FALSE;
+         int posix_class, i;
+         register const uschar *cbits = cd->cbits;
+         if (ptr[1] != ':')
+           {
+           *errorptr = ERR31;
+           goto FAILED;
+           }
+         ptr += 2;
+         if (*ptr == '^')
+           {
+           local_negate = TRUE;
+           ptr++;
+           }
+         posix_class = check_posix_name(ptr, tempptr - ptr);
+         if (posix_class < 0)
+           {
+           *errorptr = ERR30;
+           goto FAILED;
+           }
+         /* If matching is caseless, upper and lower are converted to
+         alpha. This relies on the fact that the class table starts with
+         alpha, lower, upper as the first 3 entries. */
+         if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
+           posix_class = 0;
+         /* Or into the map we are building up to 3 of the static class
+         tables, or their negations. */
+         posix_class *= 3;
+         for (i = 0; i < 3; i++)
+           {
+           int taboffset = posix_class_maps[posix_class + i];
+           if (taboffset < 0) break;
+           if (local_negate)
+             for (c = 0; c < 32; c++) class[c] |= ~cbits[c+taboffset];
+           else
+             for (c = 0; c < 32; c++) class[c] |= cbits[c+taboffset];
+           }
+         ptr = tempptr + 1;
+         class_charcount = 10;  /* Set > 1; assumes more than 1 per class */
+         continue;
+         }
        /* Backslash may introduce a single character, or it may introduce one
        of the specials, which just set a flag. Escaped items are checked for
        validity in the pre-compiling pass. The sequence \b is a special case.
-Line 773 
 for (;; ptr++)
+Line 1202 
 for (;; ptr++)
              continue;
              case ESC_w:
-             for (c = 0; c < 32; c++)
+             for (c = 0; c < 32; c++) class[c] |= cbits[c+cbit_word];
-               class[c] |= (cbits[c+cbit_digit] | cbits[c+cbit_word]);
              continue;
              case ESC_W:
-             for (c = 0; c < 32; c++)
+             for (c = 0; c < 32; c++) class[c] |= ~cbits[c+cbit_word];
-               class[c] |= ~(cbits[c+cbit_digit] | cbits[c+cbit_word]);
              continue;
              case ESC_s:
-Line 795 
 for (;; ptr++)
+Line 1222 
 for (;; ptr++)
              goto FAILED;
              }
            }
-         /* Fall through if single character */
+         /* Fall through if single character, but don't at present allow
+         chars > 255 in UTF-8 mode. */
+ #ifdef SUPPORT_UTF8
+         if (c > 255)
+           {
+           *errorptr = ERR33;
+           goto FAILED;
+           }
+ #endif
          }
        /* A single character may be followed by '-' to form a range. However,
-Line 815 
 for (;; ptr++)
+Line 1252 
 for (;; ptr++)
            }
          /* The second part of a range can be a single-character escape, but
-         not any of the other escapes. */
+         not any of the other escapes. Perl 5.6 treats a hyphen as a literal
+         in such circumstances. */
          if (d == '\\')
            {
+           const uschar *oldptr = ptr;
            d = check_escape(&ptr, errorptr, *brackets, options, TRUE, cd);
+ #ifdef SUPPORT_UTF8
+           if (d > 255)
+             {
+             *errorptr = ERR33;
+             goto FAILED;
+             }
+ #endif
+           /* \b is backslash; any other special means the '-' was literal */
            if (d < 0)
              {
              if (d == -ESC_b) d = '\b'; else
                {
-               *errorptr = ERR7;
+               ptr = oldptr - 2;
-               goto FAILED;
+               goto SINGLE_CHARACTER;  /* A few lines below */
                }
              }
            }
-Line 853 
 for (;; ptr++)
+Line 1302 
 for (;; ptr++)
        /* Handle a lone single character - we can get here for a normal
        non-escape char, or after \ that introduces a single character. */
+       SINGLE_CHARACTER:
        class [c/8] |= (1 << (c&7));
        if ((options & PCRE_CASELESS) != 0)
          {
-Line 937 
 for (;; ptr++)
+Line 1388 
 for (;; ptr++)
        { repeat_type = greedy_non_default; ptr++; }
      else repeat_type = greedy_default;
-     /* If the maximum is zero then the minimum must also be zero; Perl allows
-     this case, so we do too - by simply omitting the item altogether. */
-     if (repeat_max == 0) code = previous;
      /* If previous was a string of characters, chop off the last one and use it
      as the subject of the repeat. If there was only one character, we can
-     abolish the previous item altogether. */
+     abolish the previous item altogether. A repeat with a zero minimum wipes
+     out any reqchar setting, backing up to the previous value. We must also
+     adjust the countlits value. */
-     else if (*previous == OP_CHARS)
+     if (*previous == OP_CHARS)
        {
        int len = previous[1];
+       if (repeat_min == 0) *reqchar = prevreqchar;
+       *countlits += repeat_min - 1;
        if (len == 1)
          {
          c = previous[2];
-Line 987 
 for (;; ptr++)
+Line 1439 
 for (;; ptr++)
        code = previous;
        OUTPUT_SINGLE_REPEAT:
-       repeat_type += op_type;      /* Combine both values for many cases */
+       /* If the maximum is zero then the minimum must also be zero; Perl allows
+       this case, so we do too - by simply omitting the item altogether. */
+       if (repeat_max == 0) goto END_REPEAT;
+       /* Combine the op_type with the repeat_type */
+       repeat_type += op_type;
        /* A minimum of zero is handled either as the special case * or ?, or as
        an UPTO, with the maximum given. */
-Line 1064 
 for (;; ptr++)
+Line 1524 
 for (;; ptr++)
        }
      /* If previous was a character class or a back reference, we put the repeat
-     stuff after it. */
+     stuff after it, but just skip the item if the repeat was {0,0}. */
      else if (*previous == OP_CLASS || *previous == OP_REF)
        {
+       if (repeat_max == 0)
+         {
+         code = previous;
+         goto END_REPEAT;
+         }
        if (repeat_min == 0 && repeat_max == -1)
          *code++ = OP_CRSTAR + repeat_type;
        else if (repeat_min == 1 && repeat_max == -1)
-Line 1118 
 for (;; ptr++)
+Line 1583 
 for (;; ptr++)
        if (repeat_min == 0)
          {
+         /* If we set up a required char from the bracket, we must back off
+         to the previous value and reset the countlits value too. */
+         if (subcountlits > 0)
+           {
+           *reqchar = prevreqchar;
+           *countlits -= subcountlits;
+           }
          /* If the maximum is also zero, we just omit the group from the output
          altogether. */
          if (repeat_max == 0)
            {
            code = previous;
-           previous = NULL;
+           goto END_REPEAT;
-           break;
            }
          /* If the maximum is 1 or unlimited, we just have to stick in the
-Line 1230 
 for (;; ptr++)
+Line 1703 
 for (;; ptr++)
        correct offset was computed above. */
        else code[-ketoffset] = OP_KETRMAX + repeat_type;
- #ifdef NEVER
-       /* If the minimum is greater than zero, and the maximum is unlimited or
-       equal to the minimum, the first copy remains where it is, and is
-       replicated up to the minimum number of times. This case includes the +
-       repeat, but of course no replication is needed in that case. */
-       if (repeat_min > 0 && (repeat_max == -1 || repeat_max == repeat_min))
-         {
-         for (i = 1; i < repeat_min; i++)
-           {
-           memcpy(code, previous, len);
-           code += len;
-           }
-         }
-       /* If the minimum is zero, stick BRAZERO in front of the first copy.
-       Then, if there is a fixed upper limit, replicated up to that many times,
-       sticking BRAZERO in front of all the optional ones. */
-       else
-         {
-         if (repeat_min == 0)
-           {
-           memmove(previous+1, previous, len);
-           code++;
-           *previous++ = OP_BRAZERO + repeat_type;
-           }
-         for (i = 1; i < repeat_min; i++)
-           {
-           memcpy(code, previous, len);
-           code += len;
-           }
-         for (i = (repeat_min > 0)? repeat_min : 1; i < repeat_max; i++)
-           {
-           *code++ = OP_BRAZERO + repeat_type;
-           memcpy(code, previous, len);
-           code += len;
-           }
-         }
-       /* If the maximum is unlimited, set a repeater in the final copy. We
-       can't just offset backwards from the current code point, because we
-       don't know if there's been an options resetting after the ket. The
-       correct offset was computed above. */
-       if (repeat_max == -1) code[-ketoffset] = OP_KETRMAX + repeat_type;
- #endif
        }
      /* Else there's some kind of shambles */
-Line 1295 
 for (;; ptr++)
+Line 1715 
 for (;; ptr++)
      /* In all case we no longer have a previous item. */
+     END_REPEAT:
      previous = NULL;
      break;
-Line 1372 
 for (;; ptr++)
+Line 1793 
 for (;; ptr++)
          ptr++;
          break;
+         case 'R':                 /* Pattern recursion */
+         *code++ = OP_RECURSE;
+         ptr++;
+         continue;
          default:                  /* Option setting */
          set = unset = 0;
          optset = &set;
-Line 1463 
 for (;; ptr++)
+Line 1889 
 for (;; ptr++)
           (bravalue == OP_ASSERTBACK ||
            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
           condref,                      /* Condition reference number */
+          &subreqchar,                  /* For possible last char */
+          &subcountlits,                /* For literal count */
           cd))                          /* Tables block */
        goto FAILED;
-Line 1476 
 for (;; ptr++)
+Line 1904 
 for (;; ptr++)
      if (bravalue == OP_COND)
        {
-       int branchcount = 0;
        uschar *tc = code;
+       condcount = 0;
        do {
-          branchcount++;
+          condcount++;
           tc += (tc[1] << 8) | tc[2];
           }
        while (*tc != OP_KET);
-       if (branchcount > 2)
+       if (condcount > 2)
          {
          *errorptr = ERR27;
          goto FAILED;
          }
        }
+     /* Handle updating of the required character. If the subpattern didn't
+     set one, leave it as it was. Otherwise, update it for normal brackets of
+     all kinds, forward assertions, and conditions with two branches. Don't
+     update the literal count for forward assertions, however. If the bracket
+     is followed by a quantifier with zero repeat, we have to back off. Hence
+     the definition of prevreqchar and subcountlits outside the main loop so
+     that they can be accessed for the back off. */
+     if (subreqchar > 0 &&
+          (bravalue >= OP_BRA || bravalue == OP_ONCE || bravalue == OP_ASSERT ||
+          (bravalue == OP_COND && condcount == 2)))
+       {
+       prevreqchar = *reqchar;
+       *reqchar = subreqchar;
+       if (bravalue != OP_ASSERT) *countlits += subcountlits;
+       }
      /* Now update the main code pointer to the end of the group. */
      code = tempcode;
-Line 1559 
 for (;; ptr++)
+Line 2004 
 for (;; ptr++)
          if ((cd->ctypes[c] & ctype_space) != 0) continue;
          if (c == '#')
            {
-           while ((c = *(++ptr)) != 0 && c != '\n');
+           /* The space before the ; is to avoid a warning on a silly compiler
+           on the Macintosh. */
+           while ((c = *(++ptr)) != 0 && c != '\n') ;
            if (c == 0) break;
            continue;
            }
-Line 1574 
 for (;; ptr++)
+Line 2021 
 for (;; ptr++)
          tempptr = ptr;
          c = check_escape(&ptr, errorptr, *brackets, options, FALSE, cd);
          if (c < 0) { ptr = tempptr; break; }
+         /* If a character is > 127 in UTF-8 mode, we have to turn it into
+         two or more characters in the UTF-8 encoding. */
+ #ifdef SUPPORT_UTF8
+         if (c > 127 && (options & PCRE_UTF8) != 0)
+           {
+           uschar buffer[8];
+           int len = ord2utf8(c, buffer);
+           for (c = 0; c < len; c++) *code++ = buffer[c];
+           length += len;
+           continue;
+           }
+ #endif
          }
        /* Ordinary character or single-char escape */
-Line 1584 
 for (;; ptr++)
+Line 2045 
 for (;; ptr++)
      /* This "while" is the end of the "do" above. */
-     while (length < 255 && (cd->ctypes[c = *(++ptr)] & ctype_meta) == 0);
+     while (length < MAXLIT && (cd->ctypes[c = *(++ptr)] & ctype_meta) == 0);
+     /* Update the last character and the count of literals */
+     prevreqchar = (length > 1)? code[-2] : *reqchar;
+     *reqchar = code[-1];
+     *countlits += length;
      /* Compute the length and set it in the data vector, and advance to
      the next state. */
      previous[1] = length;
-     if (length < 255) ptr--;
+     if (length < MAXLIT) ptr--;
      break;
      }
    }                   /* end of big loop */
-Line 1629 
 Argument:
+Line 2096 
 Argument:
    errorptr    -> pointer to error message
    lookbehind  TRUE if this is a lookbehind assertion
    condref     > 0 for OPT_CREF setting at start of conditional group
+   reqchar     -> place to put the last required character, or a negative number
+   countlits   -> place to put the shortest literal count of any branch
    cd          points to the data block with tables pointers
  Returns:      TRUE on success
-Line 1637 
 Returns:      TRUE on success
+Line 2106 
 Returns:      TRUE on success
  static BOOL
  compile_regex(int options, int optchanged, int *brackets, uschar **codeptr,
    const uschar **ptrptr, const char **errorptr, BOOL lookbehind, int condref,
-   compile_data *cd)
+   int *reqchar, int *countlits, compile_data *cd)
  {
  const uschar *ptr = *ptrptr;
  uschar *code = *codeptr;
-Line 1645 
 uschar *last_branch = code;
+Line 2114 
 uschar *last_branch = code;
  uschar *start_bracket = code;
  uschar *reverse_count = NULL;
  int oldoptions = options & PCRE_IMS;
+ int branchreqchar, branchcountlits;
+ *reqchar = -1;
+ *countlits = INT_MAX;
  code += 3;
  /* At the start of a reference-based conditional group, insert the reference
-Line 1684 
 for (;;)
+Line 2156 
 for (;;)
    /* Now compile the branch */
-   if (!compile_branch(options,brackets,&code,&ptr,errorptr,&optchanged,cd))
+   if (!compile_branch(options, brackets, &code, &ptr, errorptr, &optchanged,
+       &branchreqchar, &branchcountlits, cd))
      {
      *ptrptr = ptr;
      return FALSE;
-Line 1696 
 for (;;)
+Line 2169 
 for (;;)
    last_branch[1] = length >> 8;
    last_branch[2] = length & 255;
+   /* Save the last required character if all branches have the same; a current
+   value of -1 means unset, while -2 means "previous branch had no last required
+   char".  */
+   if (*reqchar != -2)
+     {
+     if (branchreqchar >= 0)
+       {
+       if (*reqchar == -1) *reqchar = branchreqchar;
+       else if (*reqchar != branchreqchar) *reqchar = -2;
+       }
+     else *reqchar = -2;
+     }
+   /* Keep the shortest literal count */
+   if (branchcountlits < *countlits) *countlits = branchcountlits;
+   DPRINTF(("literal count = %d min=%d\n", branchcountlits, *countlits));
    /* 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. */
-Line 1703 
 for (;;)
+Line 2195 
 for (;;)
    if (lookbehind)
      {
      *code = OP_END;
-     length = find_fixedlength(last_branch);
+     length = find_fixedlength(last_branch, options);
      DPRINTF(("fixed length = %d\n", length));
      if (length < 0)
        {
-Line 1790 
 for (;;)
+Line 2282 
 for (;;)
      code += 2;
      break;
+     case OP_WORD_BOUNDARY:
+     case OP_NOT_WORD_BOUNDARY:
+     code++;
+     break;
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
-Line 1817 
 all of whose alternatives start with OP_
+Line 2314 
 all of whose alternatives start with OP_
  it's anchored. However, if this is a multiline pattern, then only OP_SOD
  counts, since OP_CIRC can match in the middle.
- A branch is also implicitly anchored if it starts with .* because that will try
+ A branch is also implicitly anchored if it starts with .* and DOTALL is set,
- the rest of the pattern at all possible matching points, so there is no point
+ because that will try the rest of the pattern at all possible matching points,
- trying them again.
+ so there is no point trying them again.
  Arguments:
    code       points to start of expression (the bracket)
-Line 1837 
 do {
+Line 2334 
 do {
     register int op = *scode;
     if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
       { if (!is_anchored(scode, options)) return FALSE; }
-    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
+    else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR) &&
+             (*options & PCRE_DOTALL) != 0)
       { if (scode[1] != OP_ANY) return FALSE; }
     else if (op != OP_SOD &&
             ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
-Line 1851 
 return TRUE;
+Line 2349 
 return TRUE;
  /*************************************************
- *     Check for start with \n line expression    *
+ *         Check for starting with ^ or .*        *
  *************************************************/
- /* This is called for multiline expressions to try to find out if every branch
+ /* This is called to find out if every branch starts with ^ or .* so that
- starts with ^ so that "first char" processing can be done to speed things up.
+ "first char" processing can be done to speed things up in multiline
+ matching and for non-DOTALL patterns that start with .* (which must start at
+ the beginning or after \n).
  Argument:  points to start of expression (the bracket)
  Returns:   TRUE or FALSE
-Line 1869 
 do {
+Line 2369 
 do {
     register int op = *scode;
     if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
       { if (!is_startline(scode)) return FALSE; }
+    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
+      { if (scode[1] != OP_ANY) return FALSE; }
     else if (op != OP_CIRC) return FALSE;
     code += (code[1] << 8) + code[2];
     }
-Line 1967 
 pcre_compile(const char *pattern, int op
+Line 2469 
 pcre_compile(const char *pattern, int op
  real_pcre *re;
  int length = 3;      /* For initial BRA plus length */
  int runlength;
- int c, size;
+ int c, reqchar, countlits;
  int bracount = 0;
  int top_backref = 0;
  int branch_extra = 0;
  int branch_newextra;
  unsigned int brastackptr = 0;
+ size_t size;
  uschar *code;
  const uschar *ptr;
  compile_data compile_block;
-Line 1983 
 uschar bralenstack[BRASTACK_SIZE];
+Line 2486 
 uschar bralenstack[BRASTACK_SIZE];
  uschar *code_base, *code_end;
  #endif
+ /* Can't support UTF8 unless PCRE has been compiled to include the code. */
+ #ifndef SUPPORT_UTF8
+ if ((options & PCRE_UTF8) != 0)
+   {
+   *errorptr = ERR32;
+   return NULL;
+   }
+ #endif
  /* We can't pass back an error message if errorptr is NULL; I guess the best we
  can do is just return NULL. */
-Line 2035 
 while ((c = *(++ptr)) != 0)
+Line 2548 
 while ((c = *(++ptr)) != 0)
      if ((compile_block.ctypes[c] & ctype_space) != 0) continue;
      if (c == '#')
        {
-       while ((c = *(++ptr)) != 0 && c != '\n');
+       /* The space before the ; is to avoid a warning on a silly compiler
+       on the Macintosh. */
+       while ((c = *(++ptr)) != 0 && c != '\n') ;
        continue;
        }
      }
-Line 2200 
 while ((c = *(++ptr)) != 0)
+Line 2715 
 while ((c = *(++ptr)) != 0)
          ptr += 2;
          break;
+         /* A recursive call to the regex is an extension, to provide the
+         facility which can be obtained by $(?p{perl-code}) in Perl 5.6. */
+         case 'R':
+         if (ptr[3] != ')')
+           {
+           *errorptr = ERR29;
+           goto PCRE_ERROR_RETURN;
+           }
+         ptr += 3;
+         length += 1;
+         break;
          /* Lookbehinds are in Perl from version 5.005 */
          case '<':
-Line 2232 
 while ((c = *(++ptr)) != 0)
+Line 2760 
 while ((c = *(++ptr)) != 0)
          else   /* An assertion must follow */
            {
            ptr++;   /* Can treat like ':' as far as spacing is concerned */
+           if (ptr[2] != '?' ||
-           if (ptr[2] != '?' || strchr("=!<", ptr[3]) == NULL)
+              (ptr[3] != '=' && ptr[3] != '!' && ptr[3] != '<') )
              {
              ptr += 2;    /* To get right offset in message */
              *errorptr = ERR28;
-Line 2307 
 while ((c = *(++ptr)) != 0)
+Line 2835 
 while ((c = *(++ptr)) != 0)
              will lead to an over-estimate on the length, but this shouldn't
              matter very much. We also have to allow for resetting options at
              the start of any alternations, which we do by setting
-             branch_newextra to 2. */
+             branch_newextra to 2. Finally, we record whether the case-dependent
+             flag ever changes within the regex. This is used by the "required
+             character" code. */
              case ':':
              if (((set|unset) & PCRE_IMS) != 0)
                {
                length += 4;
                branch_newextra = 2;
+               if (((set|unset) & PCRE_CASELESS) != 0) options |= PCRE_ICHANGED;
                }
              goto END_OPTIONS;
-Line 2443 
 while ((c = *(++ptr)) != 0)
+Line 2974 
 while ((c = *(++ptr)) != 0)
          if ((compile_block.ctypes[c] & ctype_space) != 0) continue;
          if (c == '#')
            {
-           while ((c = *(++ptr)) != 0 && c != '\n');
+           /* The space before the ; is to avoid a warning on a silly compiler
+           on the Macintosh. */
+           while ((c = *(++ptr)) != 0 && c != '\n') ;
            continue;
            }
          }
-Line 2458 
 while ((c = *(++ptr)) != 0)
+Line 2991 
 while ((c = *(++ptr)) != 0)
            &compile_block);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          if (c < 0) { ptr = saveptr; break; }
+ #ifdef SUPPORT_UTF8
+         if (c > 127 && (options & PCRE_UTF8) != 0)
+           {
+           int i;
+           for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
+             if (c <= utf8_table1[i]) break;
+           runlength += i;
+           }
+ #endif
          }
        /* Ordinary character or single-char escape */
-Line 2467 
 while ((c = *(++ptr)) != 0)
+Line 3010 
 while ((c = *(++ptr)) != 0)
      /* This "while" is the end of the "do" above. */
-     while (runlength < 255 &&
+     while (runlength < MAXLIT &&
        (compile_block.ctypes[c = *(++ptr)] & ctype_meta) == 0);
      ptr--;
-Line 2499 
 if (re == NULL)
+Line 3042 
 if (re == NULL)
    return NULL;
    }
- /* Put in the magic number and the options. */
+ /* Put in the magic number, and save the size, options, and table pointer */
  re->magic_number = MAGIC_NUMBER;
+ re->size = size;
  re->options = options;
  re->tables = tables;
-Line 2514 
 code = re->code;
+Line 3058 
 code = re->code;
  *code = OP_BRA;
  bracount = 0;
  (void)compile_regex(options, -1, &bracount, &code, &ptr, errorptr, FALSE, -1,
-   &compile_block);
+   &reqchar, &countlits, &compile_block);
  re->top_bracket = bracount;
  re->top_backref = top_backref;
-Line 2546 
 if (*errorptr != NULL)
+Line 3090 
 if (*errorptr != NULL)
    return NULL;
    }
- /* If the anchored option was not passed, set flag if we can determine that it
+ /* If the anchored option was not passed, set flag if we can determine that the
- is anchored by virtue of ^ characters or \A or anything else. Otherwise, see if
+ pattern is anchored by virtue of ^ characters or \A or anything else (such as
- we can determine what the first character has to be, because that speeds up
+ starting with .* when DOTALL is set).
- unanchored matches no end. In the case of multiline matches, an alternative is
- to set the PCRE_STARTLINE flag if all branches start with ^. */
+ Otherwise, see if we can determine what the first character has to be, because
+ that speeds up unanchored matches no end. If not, see if we can set the
+ PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
+ start with ^. and also when all branches start with .* for non-DOTALL matches.
+ */
  if ((options & PCRE_ANCHORED) == 0)
    {
-Line 2570 
 if ((options & PCRE_ANCHORED) == 0)
+Line 3118 
 if ((options & PCRE_ANCHORED) == 0)
      }
    }
+ /* Save the last required character if there are at least two literal
+ characters on all paths, or if there is no first character setting. */
+ if (reqchar >= 0 && (countlits > 1 || (re->options & PCRE_FIRSTSET) == 0))
+   {
+   re->req_char = reqchar;
+   re->options |= PCRE_REQCHSET;
+   }
  /* Print out the compiled data for debugging */
  #ifdef DEBUG
-Line 2579 
 printf("Length = %d top_bracket = %d top
+Line 3136 
 printf("Length = %d top_bracket = %d top
  if (re->options != 0)
    {
-   printf("%s%s%s%s%s%s%s%s\n",
+   printf("%s%s%s%s%s%s%s%s%s\n",
      ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
      ((re->options & PCRE_CASELESS) != 0)? "caseless " : "",
+     ((re->options & PCRE_ICHANGED) != 0)? "case state changed " : "",
      ((re->options & PCRE_EXTENDED) != 0)? "extended " : "",
      ((re->options & PCRE_MULTILINE) != 0)? "multiline " : "",
      ((re->options & PCRE_DOTALL) != 0)? "dotall " : "",
-Line 2596 
 if ((re->options & PCRE_FIRSTSET) != 0)
+Line 3154 
 if ((re->options & PCRE_FIRSTSET) != 0)
      else printf("First char = \\x%02x\n", re->first_char);
    }
+ if ((re->options & PCRE_REQCHSET) != 0)
+   {
+   if (isprint(re->req_char)) printf("Req char = %c\n", re->req_char);
+     else printf("Req char = \\x%02x\n", re->req_char);
+   }
  code_end = code;
  code_base = code = re->code;
-Line 2829 
 Returns:      TRUE if matched
+Line 3393 
 Returns:      TRUE if matched
  static BOOL
  match_ref(int offset, register const uschar *eptr, int length, match_data *md,
-   int ims)
+   unsigned long int ims)
  {
  const uschar *p = md->start_subject + md->offset_vector[offset];
-Line 2880 
 Arguments:
+Line 3444 
 Arguments:
     offset_top  current top pointer
     md          pointer to "static" info for the match
     ims         current /i, /m, and /s options
-    condassert  TRUE if called to check a condition assertion
+    eptrb       pointer to chain of blocks containing eptr at start of
-    eptrb       eptr at start of last bracket
+                  brackets - for testing for empty matches
+    flags       can contain
+                  match_condassert - this is an assertion condition
+                  match_isgroup - this is the start of a bracketed group
  Returns:       TRUE if matched
  */
  static BOOL
  match(register const uschar *eptr, register const uschar *ecode,
-   int offset_top, match_data *md, int ims, BOOL condassert, const uschar *eptrb)
+   int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
+   int flags)
  {
- int original_ims = ims;   /* Save for resetting on ')' */
+ unsigned long int original_ims = ims;   /* Save for resetting on ')' */
+ eptrblock newptrb;
+ /* At the start of a bracketed group, add the current subject pointer to the
+ stack of such pointers, to be re-instated at the end of the group when we hit
+ the closing ket. When match() is called in other circumstances, we don't add to
+ the stack. */
+ if ((flags & match_isgroup) != 0)
+   {
+   newptrb.prev = eptrb;
+   newptrb.saved_eptr = eptr;
+   eptrb = &newptrb;
+   }
+ /* Now start processing the operations. */
  for (;;)
    {
-Line 2936 
 for (;;)
+Line 3519 
 for (;;)
        do
          {
-         if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
+         if (match(eptr, ecode+3, offset_top, md, ims, eptrb, match_isgroup))
+           return TRUE;
          ecode += (ecode[1] << 8) + ecode[2];
          }
        while (*ecode == OP_ALT);
-Line 2962 
 for (;;)
+Line 3546 
 for (;;)
      DPRINTF(("start bracket 0\n"));
      do
        {
-       if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
+       if (match(eptr, ecode+3, offset_top, md, ims, eptrb, match_isgroup))
+         return TRUE;
        ecode += (ecode[1] << 8) + ecode[2];
        }
      while (*ecode == OP_ALT);
-Line 2981 
 for (;;)
+Line 3566 
 for (;;)
        return match(eptr,
          ecode + ((offset < offset_top && md->offset_vector[offset] >= 0)?
 : 3 + (ecode[1] << 8) + ecode[2]),
-         offset_top, md, ims, FALSE, eptr);
+         offset_top, md, ims, eptrb, match_isgroup);
        }
      /* The condition is an assertion. Call match() to evaluate it - setting
-Line 2989 
 for (;;)
+Line 3574 
 for (;;)
      else
        {
-       if (match(eptr, ecode+3, offset_top, md, ims, TRUE, NULL))
+       if (match(eptr, ecode+3, offset_top, md, ims, NULL,
+           match_condassert | match_isgroup))
          {
          ecode += 3 + (ecode[4] << 8) + ecode[5];
          while (*ecode == OP_ALT) ecode += (ecode[1] << 8) + ecode[2];
          }
        else ecode += (ecode[1] << 8) + ecode[2];
-       return match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr);
+       return match(eptr, ecode+3, offset_top, md, ims, eptrb, match_isgroup);
        }
      /* Control never reaches here */
-Line 3005 
 for (;;)
+Line 3591 
 for (;;)
      ecode += 2;
      break;
-     /* End of the pattern */
+     /* End of the pattern. If PCRE_NOTEMPTY is set, fail if we have matched
+     an empty string - recursion will then try other alternatives, if any. */
      case OP_END:
+     if (md->notempty && eptr == md->start_match) return FALSE;
      md->end_match_ptr = eptr;          /* Record where we ended */
      md->end_offset_top = offset_top;   /* and how many extracts were taken */
      return TRUE;
-Line 3017 
 for (;;)
+Line 3605 
 for (;;)
      case OP_OPT:
      ims = ecode[1];
      ecode += 2;
-     DPRINTF(("ims set to %02x\n", ims));
+     DPRINTF(("ims set to %02lx\n", ims));
      break;
      /* Assertion brackets. Check the alternative branches in turn - the
-Line 3030 
 for (;;)
+Line 3618 
 for (;;)
      case OP_ASSERTBACK:
      do
        {
-       if (match(eptr, ecode+3, offset_top, md, ims, FALSE, NULL)) break;
+       if (match(eptr, ecode+3, offset_top, md, ims, NULL, match_isgroup)) break;
        ecode += (ecode[1] << 8) + ecode[2];
        }
      while (*ecode == OP_ALT);
-Line 3038 
 for (;;)
+Line 3626 
 for (;;)
      /* If checking an assertion for a condition, return TRUE. */
-     if (condassert) return TRUE;
+     if ((flags & match_condassert) != 0) return TRUE;
      /* Continue from after the assertion, updating the offsets high water
      mark, since extracts may have been taken during the assertion. */
-Line 3054 
 for (;;)
+Line 3642 
 for (;;)
      case OP_ASSERTBACK_NOT:
      do
        {
-       if (match(eptr, ecode+3, offset_top, md, ims, FALSE, NULL)) return FALSE;
+       if (match(eptr, ecode+3, offset_top, md, ims, NULL, match_isgroup))
+         return FALSE;
        ecode += (ecode[1] << 8) + ecode[2];
        }
      while (*ecode == OP_ALT);
-     if (condassert) return TRUE;
+     if ((flags & match_condassert) != 0) return TRUE;
      ecode += 3;
      continue;
      /* Move the subject pointer back. This occurs only at the start of
      each branch of a lookbehind assertion. If we are too close to the start to
-     move back, this match function fails. */
+     move back, this match function fails. When working with UTF-8 we move
+     back a number of characters, not bytes. */
      case OP_REVERSE:
+ #ifdef SUPPORT_UTF8
+     c = (ecode[1] << 8) + ecode[2];
+     for (i = 0; i < c; i++)
+       {
+       eptr--;
+       BACKCHAR(eptr)
+       }
+ #else
      eptr -= (ecode[1] << 8) + ecode[2];
+ #endif
      if (eptr < md->start_subject) return FALSE;
      ecode += 3;
      break;
+     /* Recursion matches the current regex, nested. If there are any capturing
+     brackets started but not finished, we have to save their starting points
+     and reinstate them after the recursion. However, we don't know how many
+     such there are (offset_top records the completed total) so we just have
+     to save all the potential data. There may be up to 99 such values, which
+     is a bit large to put on the stack, but using malloc for small numbers
+     seems expensive. As a compromise, the stack is used when there are fewer
+     than 16 values to store; otherwise malloc is used. A problem is what to do
+     if the malloc fails ... there is no way of returning to the top level with
+     an error. Save the top 15 values on the stack, and accept that the rest
+     may be wrong. */
+     case OP_RECURSE:
+       {
+       BOOL rc;
+       int *save;
+       int stacksave[15];
+       c = md->offset_max;
+       if (c < 16) save = stacksave; else
+         {
+         save = (int *)(pcre_malloc)((c+1) * sizeof(int));
+         if (save == NULL)
+           {
+           save = stacksave;
+           c = 15;
+           }
+         }
+       for (i = 1; i <= c; i++)
+         save[i] = md->offset_vector[md->offset_end - i];
+       rc = match(eptr, md->start_pattern, offset_top, md, ims, eptrb,
+         match_isgroup);
+       for (i = 1; i <= c; i++)
+         md->offset_vector[md->offset_end - i] = save[i];
+       if (save != stacksave) (pcre_free)(save);
+       if (!rc) return FALSE;
+       /* In case the recursion has set more capturing values, save the final
+       number, then move along the subject till after the recursive match,
+       and advance one byte in the pattern code. */
+       offset_top = md->end_offset_top;
+       eptr = md->end_match_ptr;
+       ecode++;
+       }
+     break;
      /* "Once" brackets are like assertion brackets except that after a match,
      the point in the subject string is not moved back. Thus there can never be
-Line 3084 
 for (;;)
+Line 3733 
 for (;;)
      case OP_ONCE:
        {
        const uschar *prev = ecode;
+       const uschar *saved_eptr = eptr;
        do
          {
-         if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) break;
+         if (match(eptr, ecode+3, offset_top, md, ims, eptrb, match_isgroup))
+           break;
          ecode += (ecode[1] << 8) + ecode[2];
          }
        while (*ecode == OP_ALT);
-Line 3110 
 for (;;)
+Line 3761 
 for (;;)
 .005. If there is an options reset, it will get obeyed in the normal
        course of events. */
-       if (*ecode == OP_KET || eptr == eptrb)
+       if (*ecode == OP_KET || eptr == saved_eptr)
          {
          ecode += 3;
          break;
-Line 3124 
 for (;;)
+Line 3775 
 for (;;)
        if (ecode[3] == OP_OPT)
          {
          ims = (ims & ~PCRE_IMS) | ecode[4];
-         DPRINTF(("ims set to %02x at group repeat\n", ims));
+         DPRINTF(("ims set to %02lx at group repeat\n", ims));
          }
        if (*ecode == OP_KETRMIN)
          {
-         if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr) ||
+         if (match(eptr, ecode+3, offset_top, md, ims, eptrb, 0) ||
-             match(eptr, prev, offset_top, md, ims, FALSE, eptr)) return TRUE;
+             match(eptr, prev, offset_top, md, ims, eptrb, match_isgroup))
+               return TRUE;
          }
        else  /* OP_KETRMAX */
          {
-         if (match(eptr, prev, offset_top, md, ims, FALSE, eptr) ||
+         if (match(eptr, prev, offset_top, md, ims, eptrb, match_isgroup) ||
-             match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
+             match(eptr, ecode+3, offset_top, md, ims, eptrb, 0)) return TRUE;
          }
        }
      return FALSE;
-Line 3156 
 for (;;)
+Line 3808 
 for (;;)
      case OP_BRAZERO:
        {
        const uschar *next = ecode+1;
-       if (match(eptr, next, offset_top, md, ims, FALSE, eptr)) return TRUE;
+       if (match(eptr, next, offset_top, md, ims, eptrb, match_isgroup))
+         return TRUE;
        do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
        ecode = next + 3;
        }
-Line 3166 
 for (;;)
+Line 3819 
 for (;;)
        {
        const uschar *next = ecode+1;
        do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
-       if (match(eptr, next+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
+       if (match(eptr, next+3, offset_top, md, ims, eptrb, match_isgroup))
+         return TRUE;
        ecode++;
        }
      break;
-Line 3181 
 for (;;)
+Line 3835 
 for (;;)
      case OP_KETRMAX:
        {
        const uschar *prev = ecode - (ecode[1] << 8) - ecode[2];
+       const uschar *saved_eptr = eptrb->saved_eptr;
+       eptrb = eptrb->prev;    /* Back up the stack of bracket start pointers */
        if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
            *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
-Line 3200 
 for (;;)
+Line 3857 
 for (;;)
          int number = *prev - OP_BRA;
          int offset = number << 1;
-         DPRINTF(("end bracket %d\n", number));
+ #ifdef DEBUG
+         printf("end bracket %d", number);
+         printf("\n");
+ #endif
          if (number > 0)
            {
-Line 3218 
 for (;;)
+Line 3878 
 for (;;)
        the group. */
        ims = original_ims;
-       DPRINTF(("ims reset to %02x\n", ims));
+       DPRINTF(("ims reset to %02lx\n", ims));
        /* For a non-repeating ket, just continue at this level. This also
        happens for a repeating ket if no characters were matched in the group.
-Line 3226 
 for (;;)
+Line 3886 
 for (;;)
 .005. If there is an options reset, it will get obeyed in the normal
        course of events. */
-       if (*ecode == OP_KET || eptr == eptrb)
+       if (*ecode == OP_KET || eptr == saved_eptr)
          {
          ecode += 3;
          break;
-Line 3237 
 for (;;)
+Line 3897 
 for (;;)
        if (*ecode == OP_KETRMIN)
          {
-         if (match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr) ||
+         if (match(eptr, ecode+3, offset_top, md, ims, eptrb, 0) ||
-             match(eptr, prev, offset_top, md, ims, FALSE, eptr)) return TRUE;
+             match(eptr, prev, offset_top, md, ims, eptrb, match_isgroup))
+               return TRUE;
          }
        else  /* OP_KETRMAX */
          {
-         if (match(eptr, prev, offset_top, md, ims, FALSE, eptr) ||
+         if (match(eptr, prev, offset_top, md, ims, eptrb, match_isgroup) ||
-             match(eptr, ecode+3, offset_top, md, ims, FALSE, eptr)) return TRUE;
+             match(eptr, ecode+3, offset_top, md, ims, eptrb, 0)) return TRUE;
          }
        }
      return FALSE;
-Line 3328 
 for (;;)
+Line 3989 
 for (;;)
      if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == '\n')
        return FALSE;
      if (eptr++ >= md->end_subject) return FALSE;
+ #ifdef SUPPORT_UTF8
+     if (md->utf8)
+       while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+ #endif
      ecode++;
      break;
-Line 3454 
 for (;;)
+Line 4119 
 for (;;)
          {
          for (i = min;; i++)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            if (i >= max || !match_ref(offset, eptr, length, md, ims))
              return FALSE;
-Line 3475 
 for (;;)
+Line 4140 
 for (;;)
            }
          while (eptr >= pp)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            eptr -= length;
            }
-Line 3529 
 for (;;)
+Line 4194 
 for (;;)
        for (i = 1; i <= min; i++)
          {
          if (eptr >= md->end_subject) return FALSE;
-         c = *eptr++;
+         GETCHARINC(c, eptr)         /* Get character; increment eptr */
+ #ifdef SUPPORT_UTF8
+         /* We do not yet support class members > 255 */
+         if (c > 255) return FALSE;
+ #endif
          if ((data[c/8] & (1 << (c&7))) != 0) continue;
          return FALSE;
          }
-Line 3546 
 for (;;)
+Line 4217 
 for (;;)
          {
          for (i = min;; i++)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            if (i >= max || eptr >= md->end_subject) return FALSE;
-           c = *eptr++;
+           GETCHARINC(c, eptr)       /* Get character; increment eptr */
+ #ifdef SUPPORT_UTF8
+           /* We do not yet support class members > 255 */
+           if (c > 255) return FALSE;
+ #endif
            if ((data[c/8] & (1 << (c&7))) != 0) continue;
            return FALSE;
            }
-Line 3561 
 for (;;)
+Line 4237 
 for (;;)
        else
          {
          const uschar *pp = eptr;
-         for (i = min; i < max; eptr++, i++)
+         int len = 1;
+         for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject) break;
-           c = *eptr;
+           GETCHARLEN(c, eptr, len)  /* Get character, set length if UTF-8 */
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;
-           break;
+ #ifdef SUPPORT_UTF8
+           /* We do not yet support class members > 255 */
+           if (c > 255) break;
+ #endif
+           if ((data[c/8] & (1 << (c&7))) == 0) break;
+           eptr += len;
            }
          while (eptr >= pp)
-           if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
+           {
+           if (match(eptr--, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
+ #ifdef SUPPORT_UTF8
+           BACKCHAR(eptr)
+ #endif
+           }
          return FALSE;
          }
        }
-Line 3667 
 for (;;)
+Line 4355 
 for (;;)
          {
          for (i = min;; i++)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            if (i >= max || eptr >= md->end_subject ||
                c != md->lcc[*eptr++])
-Line 3684 
 for (;;)
+Line 4372 
 for (;;)
            eptr++;
            }
          while (eptr >= pp)
-           if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr--, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
          return FALSE;
          }
-Line 3701 
 for (;;)
+Line 4389 
 for (;;)
          {
          for (i = min;; i++)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            if (i >= max || eptr >= md->end_subject || c != *eptr++) return FALSE;
            }
-Line 3716 
 for (;;)
+Line 4404 
 for (;;)
            eptr++;
            }
          while (eptr >= pp)
-          if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
+          if (match(eptr--, ecode, offset_top, md, ims, eptrb, 0))
             return TRUE;
          return FALSE;
          }
-Line 3798 
 for (;;)
+Line 4486 
 for (;;)
          {
          for (i = min;; i++)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            if (i >= max || eptr >= md->end_subject ||
                c == md->lcc[*eptr++])
-Line 3815 
 for (;;)
+Line 4503 
 for (;;)
            eptr++;
            }
          while (eptr >= pp)
-           if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr--, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
          return FALSE;
          }
-Line 3832 
 for (;;)
+Line 4520 
 for (;;)
          {
          for (i = min;; i++)
            {
-           if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb))
+           if (match(eptr, ecode, offset_top, md, ims, eptrb, 0))
              return TRUE;
            if (i >= max || eptr >= md->end_subject || c == *eptr++) return FALSE;
            }
-Line 3847 
 for (;;)
+Line 4535 
 for (;;)
            eptr++;
            }
          while (eptr >= pp)
-          if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
+          if (match(eptr--, ecode, offset_top, md, ims, eptrb, 0))
             return TRUE;
          return FALSE;
          }
-Line 3891 
 for (;;)
+Line 4579 
 for (;;)
      /* First, ensure the minimum number of matches are present. Use inline
      code for maximizing the speed, and do the type test once at the start
-     (i.e. keep it out of the loop). Also test that there are at least the
+     (i.e. keep it out of the loop). Also we can test that there are at least
-     minimum number of characters before we start. */
+     the minimum number of bytes before we start, except when doing '.' in
+     UTF8 mode. Leave the test in in all cases; in the special case we have
+     to test after each character. */
      if (min > md->end_subject - eptr) return FALSE;
      if (min > 0) switch(ctype)
        {
        case OP_ANY:
+ #ifdef SUPPORT_UTF8
+       if (md->utf8)
+         {
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject ||
+              (*eptr++ == '\n' && (ims & PCRE_DOTALL) == 0))
+             return FALSE;
+           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+           }
+         break;
+         }
+ #endif
+       /* Non-UTF8 can be faster */
        if ((ims & PCRE_DOTALL) == 0)
          { for (i = 1; i <= min; i++) if (*eptr++ == '\n') return FALSE; }
        else eptr += min;
-Line 3947 
 for (;;)
+Line 4651 
 for (;;)
        {
        for (i = min;; i++)
          {
-         if (match(eptr, ecode, offset_top, md, ims, FALSE, eptrb)) return TRUE;
+         if (match(eptr, ecode, offset_top, md, ims, eptrb, 0)) return TRUE;
          if (i >= max || eptr >= md->end_subject) return FALSE;
          c = *eptr++;
-Line 3955 
 for (;;)
+Line 4659 
 for (;;)
            {
            case OP_ANY:
            if ((ims & PCRE_DOTALL) == 0 && c == '\n') return FALSE;
+ #ifdef SUPPORT_UTF8
+           if (md->utf8)
+             while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+ #endif
            break;
            case OP_NOT_DIGIT:
-Line 3994 
 for (;;)
+Line 4702 
 for (;;)
        switch(ctype)
          {
          case OP_ANY:
+         /* Special code is required for UTF8, but when the maximum is unlimited
+         we don't need it. */
+ #ifdef SUPPORT_UTF8
+         if (md->utf8 && max < INT_MAX)
+           {
+           if ((ims & PCRE_DOTALL) == 0)
+             {
+             for (i = min; i < max; i++)
+               {
+               if (eptr >= md->end_subject || *eptr++ == '\n') break;
+               while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+               }
+             }
+           else
+             {
+             for (i = min; i < max; i++)
+               {
+               eptr++;
+               while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+               }
+             }
+           break;
+           }
+ #endif
+         /* Non-UTF8 can be faster */
          if ((ims & PCRE_DOTALL) == 0)
            {
            for (i = min; i < max; i++)
-Line 4066 
 for (;;)
+Line 4801 
 for (;;)
          }
        while (eptr >= pp)
-         if (match(eptr--, ecode, offset_top, md, ims, FALSE, eptrb))
+         {
+         if (match(eptr--, ecode, offset_top, md, ims, eptrb, 0))
            return TRUE;
+ #ifdef SUPPORT_UTF8
+         if (md->utf8)
+           while (eptr > pp && (*eptr & 0xc0) == 0x80) eptr--;
+ #endif
+         }
        return FALSE;
        }
      /* Control never gets here */
-Line 4104 
 Arguments:
+Line 4845 
 Arguments:
    external_extra  points to "hints" from pcre_study() or is NULL
    subject         points to the subject string
    length          length of subject string (may contain binary zeros)
+   start_offset    where to start in the subject string
    options         option bits
    offsets         points to a vector of ints to be filled in with offsets
    offsetcount     the number of elements in the vector
-Line 4116 
 Returns:          > 0 => success; value
+Line 4858 
 Returns:          > 0 => success; value
  int
  pcre_exec(const pcre *external_re, const pcre_extra *external_extra,
-   const char *subject, int length, int options, int *offsets, int offsetcount)
+   const char *subject, int length, int start_offset, int options, int *offsets,
+   int offsetcount)
  {
  int resetcount, ocount;
  int first_char = -1;
- int ims = 0;
+ int req_char = -1;
+ int req_char2 = -1;
+ unsigned long int ims = 0;
  match_data match_block;
  const uschar *start_bits = NULL;
- const uschar *start_match = (const uschar *)subject;
+ const uschar *start_match = (const uschar *)subject + start_offset;
  const uschar *end_subject;
+ const uschar *req_char_ptr = start_match - 1;
  const real_pcre *re = (const real_pcre *)external_re;
  const real_pcre_extra *extra = (const real_pcre_extra *)external_extra;
  BOOL using_temporary_offsets = FALSE;
-Line 4137 
 if (re == NULL || subject == NULL ||
+Line 4883 
 if (re == NULL || subject == NULL ||
     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
  if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
+ match_block.start_pattern = re->code;
  match_block.start_subject = (const uschar *)subject;
  match_block.end_subject = match_block.start_subject + length;
  end_subject = match_block.end_subject;
  match_block.endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
+ match_block.utf8 = (re->options & PCRE_UTF8) != 0;
  match_block.notbol = (options & PCRE_NOTBOL) != 0;
  match_block.noteol = (options & PCRE_NOTEOL) != 0;
+ match_block.notempty = (options & PCRE_NOTEMPTY) != 0;
  match_block.errorcode = PCRE_ERROR_NOMATCH;     /* Default error */
-Line 4215 
 if (!anchored)
+Line 4964 
 if (!anchored)
          start_bits = extra->start_bits;
    }
- /* Loop for unanchored matches; for anchored regexps the loop runs just once. */
+ /* For anchored or unanchored matches, there may be a "last known required
+ character" set. If the PCRE_CASELESS is set, implying that the match starts
+ caselessly, or if there are any changes of this flag within the regex, set up
+ both cases of the character. Otherwise set the two values the same, which will
+ avoid duplicate testing (which takes significant time). This covers the vast
+ majority of cases. It will be suboptimal when the case flag changes in a regex
+ and the required character in fact is caseful. */
+ if ((re->options & PCRE_REQCHSET) != 0)
+   {
+   req_char = re->req_char;
+   req_char2 = ((re->options & (PCRE_CASELESS | PCRE_ICHANGED)) != 0)?
+     (re->tables + fcc_offset)[req_char] : req_char;
+   }
+ /* Loop for handling unanchored repeated matching attempts; for anchored regexs
+ the loop runs just once. */
  do
    {
-Line 4244 
 do
+Line 5009 
 do
    else if (startline)
      {
-     if (start_match > match_block.start_subject)
+     if (start_match > match_block.start_subject + start_offset)
        {
        while (start_match < end_subject && start_match[-1] != '\n')
          start_match++;
        }
      }
-   /* Or to a non-unique first char */
+   /* Or to a non-unique first char after study */
    else if (start_bits != NULL)
      {
-Line 4268 
 do
+Line 5033 
 do
    printf("\n");
  #endif
+   /* If req_char is set, we know that that character must appear in the subject
+   for the match to succeed. If the first character is set, req_char must be
+   later in the subject; otherwise the test starts at the match point. This
+   optimization can save a huge amount of backtracking in patterns with nested
+   unlimited repeats that aren't going to match. We don't know what the state of
+   case matching may be when this character is hit, so test for it in both its
+   cases if necessary. However, the different cased versions will not be set up
+   unless PCRE_CASELESS was given or the casing state changes within the regex.
+   Writing separate code makes it go faster, as does using an autoincrement and
+   backing off on a match. */
+   if (req_char >= 0)
+     {
+     register const uschar *p = start_match + ((first_char >= 0)? 1 : 0);
+     /* We don't need to repeat the search if we haven't yet reached the
+     place we found it at last time. */
+     if (p > req_char_ptr)
+       {
+       /* Do a single test if no case difference is set up */
+       if (req_char == req_char2)
+         {
+         while (p < end_subject)
+           {
+           if (*p++ == req_char) { p--; break; }
+           }
+         }
+       /* Otherwise test for either case */
+       else
+         {
+         while (p < end_subject)
+           {
+           register int pp = *p++;
+           if (pp == req_char || pp == req_char2) { p--; break; }
+           }
+         }
+       /* If we can't find the required character, break the matching loop */
+       if (p >= end_subject) break;
+       /* If we have found the required character, save the point where we
+       found it, so that we don't search again next time round the loop if
+       the start hasn't passed this character yet. */
+       req_char_ptr = p;
+       }
+     }
    /* When a match occurs, substrings will be set for all internal extractions;
    we just need to set up the whole thing as substring 0 before returning. If
    there were too many extractions, set the return code to zero. In the case
-Line 4275 
 do
+Line 5093 
 do
    those back references that we can. In this case there need not be overflow
    if certain parts of the pattern were not used. */
-   if (!match(start_match, re->code, 2, &match_block, ims, FALSE, start_match))
+   match_block.start_match = start_match;
+   if (!match(start_match, re->code, 2, &match_block, ims, NULL, match_isgroup))
      continue;
    /* Copy the offset information from temporary store if necessary */

 Legend:



Removed from v.31
 


changed lines


 
Added in v.49
 Legend:



Removed from v.31
 


changed lines


 
Added in v.49
-Removed from v.31
+Added in v.49

	ViewVC Help
Powered by ViewVC 1.1.5