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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 23 by nigel,
Sat Feb 24 21:38:41 2007 UTC
+revision 53 by nigel,
Sat Feb 24 21:39:42 2007 UTC
 Line 9 
 the file Tech.Notes for some information
  Written by: Philip Hazel <ph10@cam.ac.uk>
-            Copyright (c) 1998 University of Cambridge
+            Copyright (c) 1997-2001 University of Cambridge
  -----------------------------------------------------------------------------
  Permission is granted to anyone to use this software for any purpose on any
 Line 25 
 restrictions:
 . Altered versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
+. If PCRE is embedded in any software that is released under the GNU
+    General Purpose Licence (GPL), then the terms of that licence shall
+    supersede any condition above with which it is incompatible.
  -----------------------------------------------------------------------------
  */
-Line 56 
 the external pcre header. */
+Line 60 
 the external pcre header. */
  #endif
- /* Number of items on the nested bracket stacks at compile time. This should
+ /* Maximum number of items on the nested bracket stacks at compile time. This
- not be set greater than 200. */
+ applies to the nesting of all kinds of parentheses. It does not limit
+ un-nested, non-capturing parentheses. This number can be made bigger if
+ necessary - it is used to dimension one int and one unsigned char vector at
+ compile time. */
  #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 78 
 static const char *OP_names[] = {
+Line 95 
 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"
+   "Brazero", "Braminzero", "Branumber", "Bra"
  };
  #endif
-Line 97 
 static const short int escapes[] = {
+Line 114 
 static const short int escapes[] = {
 ,      0,      0,      0,      0,      0,      0,      0,   /* H - O */
 ,      0,      0, -ESC_S,      0,      0,      0, -ESC_W,   /* P - W */
 ,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */
-   '`',      7, -ESC_b,      0, -ESC_d,     27,   '\f',      0,   /* ` - g */
+   '`',      7, -ESC_b,      0, -ESC_d,  ESC_E,  ESC_F,      0,   /* ` - g */
-,      0,      0,      0,      0,      0,   '\n',      0,   /* h - o */
+,      0,      0,      0,      0,      0,  ESC_N,      0,   /* h - o */
-,      0,   '\r', -ESC_s,   '\t',      0,      0, -ESC_w,   /* p - w */
+,      0,  ESC_R, -ESC_s,  ESC_T,      0,      0, -ESC_w,   /* p - w */
 ,      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);
+     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;
- /* Structure for passing "static" information around between the functions
+ /* Flag bits for the match() function */
- doing the matching, so that they are thread-safe. */
- typedef struct match_data {
+ #define match_condassert   0x01    /* Called to check a condition assertion */
-   int    errorcode;             /* As it says */
+ #define match_isgroup      0x02    /* Set if start of bracketed group */
-   int   *offset_vector;         /* Offset vector */
-   int    offset_end;            /* One past the end */
-   int    offset_max;            /* The maximum usable for return data */
-   BOOL   offset_overflow;       /* Set if too many extractions */
-   BOOL   notbol;                /* NOTBOL flag */
-   BOOL   noteol;                /* NOTEOL flag */
-   BOOL   endonly;               /* Dollar not before final \n */
-   const uschar *start_subject;  /* Start of the subject string */
-   const uschar *end_subject;    /* End of the subject string */
-   const uschar *end_match_ptr;  /* Subject position at end match */
-   int     end_offset_top;       /* Highwater mark at end of match */
- } match_data;
-Line 143 
 void  (*pcre_free)(void *) = free;
+Line 189 
 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           *
+ *************************************************/
+ /* A default set of character tables is included in the PCRE binary. Its source
+ is built by the maketables auxiliary program, which uses the default C ctypes
+ functions, and put in the file chartables.c. These tables are used by PCRE
+ whenever the caller of pcre_compile() does not provide an alternate set of
+ tables. */
+ #include "chartables.c"
+ #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 356 
 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 366 
 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 375 
 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 480 
 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 237 
 Arguments:
+Line 490 
 Arguments:
    bracount   number of previous extracting brackets
    options    the options bits
    isclass    TRUE if inside a character class
+   cd         pointer to char tables block
  Returns:     zero or positive => a data character
               negative => a special escape sequence
-Line 245 
 Returns:     zero or positive => a data
+Line 499 
 Returns:     zero or positive => a data
  static int
  check_escape(const uschar **ptrptr, const char **errorptr, int bracount,
-   int options, BOOL isclass)
+   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 288 
 else
+Line 544 
 else
        {
        oldptr = ptr;
        c -= '0';
-       while ((pcre_ctypes[ptr[1]] & ctype_digit) != 0)
+       while ((cd->ctypes[ptr[1]] & ctype_digit) != 0)
          c = c * 10 + *(++ptr) - '0';
        if (c < 10 || c <= bracount)
          {
-Line 310 
 else
+Line 566 
 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 && (pcre_ctypes[ptr[1]] & ctype_digit) != 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 && (pcre_ctypes[ptr[1]] & ctype_xdigit) != 0)
+     while (i++ < 2 && (cd->ctypes[ptr[1]] & ctype_xdigit) != 0)
        {
        ptr++;
-       c = c * 16 + pcre_lcc[*ptr] -
+       c = c * 16 + cd->lcc[*ptr] -
-         (((pcre_ctypes[*ptr] & ctype_digit) != 0)? '0' : 'W');
+         (((cd->ctypes[*ptr] & ctype_digit) != 0)? '0' : 'W');
        }
      break;
+     /* Other special escapes not starting with a digit are straightforward */
      case 'c':
      c = *(++ptr);
      if (c == 0)
-Line 341 
 else
+Line 627 
 else
      /* A letter is upper-cased; then the 0x40 bit is flipped */
-     if (c >= 'a' && c <= 'z') c = pcre_fcc[c];
+     if (c >= 'a' && c <= 'z') c = cd->fcc[c];
      c ^= 0x40;
      break;
      /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
      other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
-     for Perl compatibility, it is a literal. */
+     for Perl compatibility, it is a literal. This code looks a bit odd, but
+     there used to be some cases other than the default, and there may be again
+     in future, so I haven't "optimized" it. */
      default:
      if ((options & PCRE_EXTRA) != 0) switch(c)
-Line 377 
 where the ddds are digits.
+Line 665 
 where the ddds are digits.
  Arguments:
    p         pointer to the first char after '{'
+   cd        pointer to char tables block
  Returns:    TRUE or FALSE
  */
  static BOOL
- is_counted_repeat(const uschar *p)
+ is_counted_repeat(const uschar *p, compile_data *cd)
  {
- if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE;
+ if ((cd->ctypes[*p++] & ctype_digit) == 0) return FALSE;
- while ((pcre_ctypes[*p] & ctype_digit) != 0) p++;
+ while ((cd->ctypes[*p] & ctype_digit) != 0) p++;
  if (*p == '}') return TRUE;
  if (*p++ != ',') return FALSE;
  if (*p == '}') return TRUE;
- if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE;
+ if ((cd->ctypes[*p++] & ctype_digit) == 0) return FALSE;
- while ((pcre_ctypes[*p] & ctype_digit) != 0) p++;
+ while ((cd->ctypes[*p] & ctype_digit) != 0) p++;
  return (*p == '}');
  }
-Line 412 
 Arguments:
+Line 701 
 Arguments:
    maxp       pointer to int for max
               returned as -1 if no max
    errorptr   points to pointer to error message
+   cd         pointer to character tables clock
  Returns:     pointer to '}' on success;
               current ptr on error, with errorptr set
  */
  static const uschar *
- read_repeat_counts(const uschar *p, int *minp, int *maxp, const char **errorptr)
+ read_repeat_counts(const uschar *p, int *minp, int *maxp,
+   const char **errorptr, compile_data *cd)
  {
  int min = 0;
  int max = -1;
- while ((pcre_ctypes[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
+ while ((cd->ctypes[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
  if (*p == '}') max = min; else
    {
    if (*(++p) != '}')
      {
      max = 0;
-     while((pcre_ctypes[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
+     while((cd->ctypes[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
      if (max < min)
        {
        *errorptr = ERR4;
-Line 463 
 if the length is fixed. This is needed f
+Line 754 
 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 489 
 for (;;)
+Line 781 
 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 525 
 for (;;)
+Line 817 
 for (;;)
      /* Skip over things that don't match chars */
      case OP_REVERSE:
+     case OP_BRANUMBER:
+     case OP_CREF:
      cc++;
+     /* Fall through */
-     case OP_CREF:
      case OP_OPT:
      cc++;
      /* Fall through */
-Line 542 
 for (;;)
+Line 836 
 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 574 
 for (;;)
+Line 875 
 for (;;)
      /* Check a class for variable quantification */
      case OP_CLASS:
-     cc += (*cc == OP_REF)? 2 : 33;
+     cc += 33;
      switch (*cc)
        {
-Line 609 
 for (;;)
+Line 910 
 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                   *
  *************************************************/
  /* Scan the pattern, compiling it into the code vector.
  Arguments:
-   options     the option bits
+   options      the option bits
-   brackets    points to number of brackets used
+   brackets     points to number of extracting brackets used
-   code        points to the pointer to the current code point
+   code         points to the pointer to the current code point
-   ptrptr      points to the current pattern pointer
+   ptrptr       points to the current pattern pointer
-   errorptr    points to pointer to error message
+   errorptr     points to pointer to error message
-   optchanged  set to the value of the last OP_OPT item compiled
+   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
+ Returns:       TRUE on success
-               FALSE, with *errorptr set on error
+                FALSE, with *errorptr set on error
  */
  static BOOL
  compile_branch(int options, int *brackets, uschar **codeptr,
-   const uschar **ptrptr, const char **errorptr, int *optchanged)
+   const uschar **ptrptr, const char **errorptr, int *optchanged,
+   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 647 
 uschar class[32];
+Line 1020 
 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 655 
 for (;; ptr++)
+Line 1033 
 for (;; ptr++)
    int class_charcount;
    int class_lastchar;
    int newoptions;
-   int condref;
+   int skipbytes;
+   int subreqchar;
    c = *ptr;
    if ((options & PCRE_EXTENDED) != 0)
      {
-     if ((pcre_ctypes[c] & ctype_space) != 0) continue;
+     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 != NEWLINE) ;
        continue;
        }
      }
-Line 738 
 for (;; ptr++)
+Line 1119 
 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 748 
 for (;; ptr++)
+Line 1189 
 for (;; ptr++)
        if (c == '\\')
          {
-         c = check_escape(&ptr, errorptr, *brackets, options, TRUE);
+         c = check_escape(&ptr, errorptr, *brackets, options, TRUE, cd);
          if (-c == ESC_b) c = '\b';
          else if (c < 0)
            {
+           register const uschar *cbits = cd->cbits;
            class_charcount = 10;
            switch (-c)
              {
              case ESC_d:
-             for (c = 0; c < 32; c++) class[c] |= pcre_cbits[c+cbit_digit];
+             for (c = 0; c < 32; c++) class[c] |= cbits[c+cbit_digit];
              continue;
              case ESC_D:
-             for (c = 0; c < 32; c++) class[c] |= ~pcre_cbits[c+cbit_digit];
+             for (c = 0; c < 32; c++) class[c] |= ~cbits[c+cbit_digit];
              continue;
              case ESC_w:
-             for (c = 0; c < 32; c++)
+             for (c = 0; c < 32; c++) class[c] |= cbits[c+cbit_word];
-               class[c] |= (pcre_cbits[c] | pcre_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] |= ~(pcre_cbits[c] | pcre_cbits[c+cbit_word]);
              continue;
              case ESC_s:
-             for (c = 0; c < 32; c++) class[c] |= pcre_cbits[c+cbit_space];
+             for (c = 0; c < 32; c++) class[c] |= cbits[c+cbit_space];
              continue;
              case ESC_S:
-             for (c = 0; c < 32; c++) class[c] |= ~pcre_cbits[c+cbit_space];
+             for (c = 0; c < 32; c++) class[c] |= ~cbits[c+cbit_space];
              continue;
              default:
-Line 786 
 for (;; ptr++)
+Line 1226 
 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 806 
 for (;; ptr++)
+Line 1256 
 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 == '\\')
            {
-           d = check_escape(&ptr, errorptr, *brackets, options, TRUE);
+           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 832 
 for (;; ptr++)
+Line 1294 
 for (;; ptr++)
            class[c/8] |= (1 << (c&7));
            if ((options & PCRE_CASELESS) != 0)
              {
-             int uc = pcre_fcc[c];           /* flip case */
+             int uc = cd->fcc[c];           /* flip case */
              class[uc/8] |= (1 << (uc&7));
              }
            class_charcount++;                /* in case a one-char range */
-Line 844 
 for (;; ptr++)
+Line 1306 
 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)
          {
-         c = pcre_fcc[c];   /* flip case */
+         c = cd->fcc[c];   /* flip case */
          class[c/8] |= (1 << (c&7));
          }
        class_charcount++;
-Line 894 
 for (;; ptr++)
+Line 1358 
 for (;; ptr++)
      /* Various kinds of repeat */
      case '{':
-     if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR;
+     if (!is_counted_repeat(ptr+1, cd)) goto NORMAL_CHAR;
-     ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorptr);
+     ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorptr, cd);
      if (*errorptr != NULL) goto FAILED;
      goto REPEAT;
-Line 928 
 for (;; ptr++)
+Line 1392 
 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 978 
 for (;; ptr++)
+Line 1443 
 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 1055 
 for (;; ptr++)
+Line 1528 
 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 1082 
 for (;; ptr++)
+Line 1560 
 for (;; ptr++)
      else if ((int)*previous >= OP_BRA || (int)*previous == OP_ONCE ||
               (int)*previous == OP_COND)
        {
-       int i, ketoffset = 0;
+       register int i;
+       int ketoffset = 0;
        int len = code - previous;
+       uschar *bralink = NULL;
        /* If the maximum repeat count is unlimited, find the end of the bracket
        by scanning through from the start, and compute the offset back to it
-Line 1098 
 for (;; ptr++)
+Line 1578 
 for (;; ptr++)
          ketoffset = code - ket;
          }
-       /* If the minimum is greater than zero, and the maximum is unlimited or
+       /* The case of a zero minimum is special because of the need to stick
-       equal to the minimum, the first copy remains where it is, and is
+       OP_BRAZERO in front of it, and because the group appears once in the
-       replicated up to the minimum number of times. This case includes the +
+       data, whereas in other cases it appears the minimum number of times. For
-       repeat, but of course no replication is needed in that case. */
+       this reason, it is simplest to treat this case separately, as otherwise
+       the code gets far too messy. There are several special subcases when the
+       minimum is zero. */
-       if (repeat_min > 0 && (repeat_max == -1 || repeat_max == repeat_min))
+       if (repeat_min == 0)
          {
-         for (i = 1; i < repeat_min; i++)
+         /* 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)
            {
-           memcpy(code, previous, len);
+           *reqchar = prevreqchar;
-           code += len;
+           *countlits -= subcountlits;
            }
-         }
-       /* If the minimum is zero, stick BRAZERO in front of the first copy.
+         /* If the maximum is also zero, we just omit the group from the output
-       Then, if there is a fixed upper limit, replicated up to that many times,
+         altogether. */
-       sticking BRAZERO in front of all the optional ones. */
-       else
+         if (repeat_max == 0)
-         {
+           {
-         if (repeat_min == 0)
+           code = previous;
+           goto END_REPEAT;
+           }
+         /* If the maximum is 1 or unlimited, we just have to stick in the
+         BRAZERO and do no more at this point. */
+         if (repeat_max <= 1)
            {
            memmove(previous+1, previous, len);
            code++;
            *previous++ = OP_BRAZERO + repeat_type;
            }
+         /* If the maximum is greater than 1 and limited, we have to replicate
+         in a nested fashion, sticking OP_BRAZERO before each set of brackets.
+         The first one has to be handled carefully because it's the original
+         copy, which has to be moved up. The remainder can be handled by code
+         that is common with the non-zero minimum case below. We just have to
+         adjust the value or repeat_max, since one less copy is required. */
+         else
+           {
+           int offset;
+           memmove(previous+4, previous, len);
+           code += 4;
+           *previous++ = OP_BRAZERO + repeat_type;
+           *previous++ = OP_BRA;
+           /* We chain together the bracket offset fields that have to be
+           filled in later when the ends of the brackets are reached. */
+           offset = (bralink == NULL)? 0 : previous - bralink;
+           bralink = previous;
+           *previous++ = offset >> 8;
+           *previous++ = offset & 255;
+           }
+         repeat_max--;
+         }
+       /* If the minimum is greater than zero, replicate the group as many
+       times as necessary, and adjust the maximum to the number of subsequent
+       copies that we need. */
+       else
+         {
          for (i = 1; i < repeat_min; i++)
            {
            memcpy(code, previous, len);
            code += len;
            }
+         if (repeat_max > 0) repeat_max -= repeat_min;
+         }
-         for (i = (repeat_min > 0)? repeat_min : 1; i < repeat_max; i++)
+       /* This code is common to both the zero and non-zero minimum cases. If
+       the maximum is limited, it replicates the group in a nested fashion,
+       remembering the bracket starts on a stack. In the case of a zero minimum,
+       the first one was set up above. In all cases the repeat_max now specifies
+       the number of additional copies needed. */
+       if (repeat_max >= 0)
+         {
+         for (i = repeat_max - 1; i >= 0; i--)
            {
            *code++ = OP_BRAZERO + repeat_type;
+           /* All but the final copy start a new nesting, maintaining the
+           chain of brackets outstanding. */
+           if (i != 0)
+             {
+             int offset;
+             *code++ = OP_BRA;
+             offset = (bralink == NULL)? 0 : code - bralink;
+             bralink = code;
+             *code++ = offset >> 8;
+             *code++ = offset & 255;
+             }
            memcpy(code, previous, len);
            code += len;
            }
+         /* Now chain through the pending brackets, and fill in their length
+         fields (which are holding the chain links pro tem). */
+         while (bralink != NULL)
+           {
+           int oldlinkoffset;
+           int offset = code - bralink + 1;
+           uschar *bra = code - offset;
+           oldlinkoffset = (bra[1] << 8) + bra[2];
+           bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
+           *code++ = OP_KET;
+           *code++ = bra[1] = offset >> 8;
+           *code++ = bra[2] = (offset & 255);
+           }
          }
        /* If the maximum is unlimited, set a repeater in the final copy. We
-Line 1144 
 for (;; ptr++)
+Line 1706 
 for (;; ptr++)
        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;
+       else code[-ketoffset] = OP_KETRMAX + repeat_type;
        }
      /* Else there's some kind of shambles */
-Line 1157 
 for (;; ptr++)
+Line 1719 
 for (;; ptr++)
      /* In all case we no longer have a previous item. */
+     END_REPEAT:
      previous = NULL;
      break;
-Line 1170 
 for (;; ptr++)
+Line 1733 
 for (;; ptr++)
      case '(':
      newoptions = options;
-     condref = -1;
+     skipbytes = 0;
      if (*(++ptr) == '?')
        {
-Line 1191 
 for (;; ptr++)
+Line 1754 
 for (;; ptr++)
          case '(':
          bravalue = OP_COND;       /* Conditional group */
-         if ((pcre_ctypes[*(++ptr)] & ctype_digit) != 0)
+         if ((cd->ctypes[*(++ptr)] & ctype_digit) != 0)
            {
-           condref = *ptr - '0';
+           int condref = *ptr - '0';
            while (*(++ptr) != ')') condref = condref*10 + *ptr - '0';
+           if (condref == 0)
+             {
+             *errorptr = ERR35;
+             goto FAILED;
+             }
            ptr++;
+           code[3] = OP_CREF;
+           code[4] = condref >> 8;
+           code[5] = condref & 255;
+           skipbytes = 3;
            }
          else ptr--;
          break;
-Line 1234 
 for (;; ptr++)
+Line 1806 
 for (;; ptr++)
          ptr++;
          break;
+         case 'R':                 /* Pattern recursion */
+         *code++ = OP_RECURSE;
+         ptr++;
+         continue;
          default:                  /* Option setting */
          set = unset = 0;
          optset = &set;
-Line 1293 
 for (;; ptr++)
+Line 1870 
 for (;; ptr++)
          }
        }
-     /* Else we have a referencing group; adjust the opcode. */
+     /* Else we have a referencing group; adjust the opcode. If the bracket
+     number is greater than EXTRACT_BASIC_MAX, we set the opcode one higher, and
+     arrange for the true number to follow later, in an OP_BRANUMBER item. */
      else
        {
-       if (++(*brackets) > EXTRACT_MAX)
+       if (++(*brackets) > EXTRACT_BASIC_MAX)
          {
-         *errorptr = ERR13;
+         bravalue = OP_BRA + EXTRACT_BASIC_MAX + 1;
-         goto FAILED;
+         code[3] = OP_BRANUMBER;
+         code[4] = *brackets >> 8;
+         code[5] = *brackets & 255;
+         skipbytes = 3;
          }
-       bravalue = OP_BRA + *brackets;
+       else bravalue = OP_BRA + *brackets;
        }
      /* Process nested bracketed re. Assertions may not be repeated, but other
-Line 1318 
 for (;; ptr++)
+Line 1900 
 for (;; ptr++)
           options | PCRE_INGROUP,       /* Set for all nested groups */
           ((options & PCRE_IMS) != (newoptions & PCRE_IMS))?
             newoptions & PCRE_IMS : -1, /* Pass ims options if changed */
-          brackets,                     /* Bracket level */
+          brackets,                     /* Extracting bracket count */
           &tempcode,                    /* Where to put code (updated) */
           &ptr,                         /* Input pointer (updated) */
           errorptr,                     /* Where to put an error message */
           (bravalue == OP_ASSERTBACK ||
            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
-          condref))                     /* Condition reference number */
+          skipbytes,                    /* Skip over OP_COND/OP_BRANUMBER */
+          &subreqchar,                  /* For possible last char */
+          &subcountlits,                /* For literal count */
+          cd))                          /* Tables block */
        goto FAILED;
      /* At the end of compiling, code is still pointing to the start of the
-Line 1335 
 for (;; ptr++)
+Line 1920 
 for (;; ptr++)
      /* If this is a conditional bracket, check that there are no more than
      two branches in the group. */
-     if (bravalue == OP_COND)
+     else 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 1372 
 for (;; ptr++)
+Line 1974 
 for (;; ptr++)
      case '\\':
      tempptr = ptr;
-     c = check_escape(&ptr, errorptr, *brackets, options, FALSE);
+     c = check_escape(&ptr, errorptr, *brackets, options, FALSE, cd);
      /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
      are arranged to be the negation of the corresponding OP_values. For the
-Line 1385 
 for (;; ptr++)
+Line 1987 
 for (;; ptr++)
        {
        if (-c >= ESC_REF)
          {
+         int number = -c - ESC_REF;
          previous = code;
          *code++ = OP_REF;
-         *code++ = -c - ESC_REF;
+         *code++ = number >> 8;
+         *code++ = number & 255;
          }
        else
          {
-Line 1417 
 for (;; ptr++)
+Line 2021 
 for (;; ptr++)
        {
        if ((options & PCRE_EXTENDED) != 0)
          {
-         if ((pcre_ctypes[c] & ctype_space) != 0) continue;
+         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 != NEWLINE) ;
            if (c == 0) break;
            continue;
            }
-Line 1433 
 for (;; ptr++)
+Line 2039 
 for (;; ptr++)
        if (c == '\\')
          {
          tempptr = ptr;
-         c = check_escape(&ptr, errorptr, *brackets, options, FALSE);
+         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 1445 
 for (;; ptr++)
+Line 2065 
 for (;; ptr++)
      /* This "while" is the end of the "do" above. */
-     while (length < 255 && (pcre_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 1489 
 Argument:
+Line 2115 
 Argument:
    ptrptr      -> the address of the current pattern pointer
    errorptr    -> pointer to error message
    lookbehind  TRUE if this is a lookbehind assertion
-   condref     > 0 for OPT_CREF setting at start of conditional group
+   skipbytes   skip this many bytes at start (for OP_COND, OP_BRANUMBER)
+   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
  */
  static BOOL
  compile_regex(int options, int optchanged, int *brackets, uschar **codeptr,
-   const uschar **ptrptr, const char **errorptr, BOOL lookbehind, int condref)
+   const uschar **ptrptr, const char **errorptr, BOOL lookbehind, int skipbytes,
+   int *reqchar, int *countlits, compile_data *cd)
  {
  const uschar *ptr = *ptrptr;
  uschar *code = *codeptr;
-Line 1504 
 uschar *last_branch = code;
+Line 2134 
 uschar *last_branch = code;
  uschar *start_bracket = code;
  uschar *reverse_count = NULL;
  int oldoptions = options & PCRE_IMS;
+ int branchreqchar, branchcountlits;
- code += 3;
+ *reqchar = -1;
+ *countlits = INT_MAX;
- /* At the start of a reference-based conditional group, insert the reference
+ code += 3 + skipbytes;
- number as an OP_CREF item. */
- if (condref > 0)
-   {
-   *code++ = OP_CREF;
-   *code++ = condref;
-   }
  /* Loop for each alternative branch */
-Line 1543 
 for (;;)
+Line 2167 
 for (;;)
    /* Now compile the branch */
-   if (!compile_branch(options, brackets, &code, &ptr, errorptr, &optchanged))
+   if (!compile_branch(options, brackets, &code, &ptr, errorptr, &optchanged,
+       &branchreqchar, &branchcountlits, cd))
      {
      *ptrptr = ptr;
      return FALSE;
-Line 1555 
 for (;;)
+Line 2180 
 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 1562 
 for (;;)
+Line 2206 
 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 1646 
 for (;;)
+Line 2290 
 for (;;)
      break;
      case OP_CREF:
-     code += 2;
+     case OP_BRANUMBER:
+     code += 3;
+     break;
+     case OP_WORD_BOUNDARY:
+     case OP_NOT_WORD_BOUNDARY:
+     code++;
      break;
      case OP_ASSERT_NOT:
-Line 1676 
 all of whose alternatives start with OP_
+Line 2326 
 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 1696 
 do {
+Line 2346 
 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 1710 
 return TRUE;
+Line 2361 
 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 1728 
 do {
+Line 2381 
 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 1813 
 Arguments:
+Line 2468 
 Arguments:
    options      various option bits
    errorptr     pointer to pointer to error text
    erroroffset  ptr offset in pattern where error was detected
+   tables       pointer to character tables or NULL
  Returns:       pointer to compiled data block, or NULL on error,
                 with errorptr and erroroffset set
-Line 1820 
 Returns:       pointer to compiled data
+Line 2476 
 Returns:       pointer to compiled data
  pcre *
  pcre_compile(const char *pattern, int options, const char **errorptr,
-   int *erroroffset)
+   int *erroroffset, const unsigned char *tables)
  {
  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;
  int brastack[BRASTACK_SIZE];
  uschar bralenstack[BRASTACK_SIZE];
-Line 1840 
 uschar bralenstack[BRASTACK_SIZE];
+Line 2498 
 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 1861 
 if ((options & ~PUBLIC_OPTIONS) != 0)
+Line 2529 
 if ((options & ~PUBLIC_OPTIONS) != 0)
    return NULL;
    }
+ /* Set up pointers to the individual character tables */
+ if (tables == NULL) tables = pcre_default_tables;
+ compile_block.lcc = tables + lcc_offset;
+ compile_block.fcc = tables + fcc_offset;
+ compile_block.cbits = tables + cbits_offset;
+ compile_block.ctypes = tables + ctypes_offset;
+ /* Reflect pattern for debugging output */
  DPRINTF(("------------------------------------------------------------------\n"));
  DPRINTF(("%s\n", pattern));
-Line 1876 
 while ((c = *(++ptr)) != 0)
+Line 2554 
 while ((c = *(++ptr)) != 0)
    {
    int min, max;
    int class_charcount;
+   int bracket_length;
    if ((options & PCRE_EXTENDED) != 0)
      {
-     if ((pcre_ctypes[c] & ctype_space) != 0) continue;
+     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 != NEWLINE) ;
        continue;
        }
      }
-Line 1897 
 while ((c = *(++ptr)) != 0)
+Line 2578 
 while ((c = *(++ptr)) != 0)
      case '\\':
        {
        const uschar *save_ptr = ptr;
-       c = check_escape(&ptr, errorptr, bracount, options, FALSE);
+       c = check_escape(&ptr, errorptr, bracount, options, FALSE, &compile_block);
        if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
        if (c >= 0)
          {
-Line 1908 
 while ((c = *(++ptr)) != 0)
+Line 2589 
 while ((c = *(++ptr)) != 0)
        }
      length++;
-     /* A back reference needs an additional char, plus either one or 5
+     /* A back reference needs an additional 2 bytes, plus either one or 5
      bytes for a repeat. We also need to keep the value of the highest
      back reference. */
-Line 1916 
 while ((c = *(++ptr)) != 0)
+Line 2597 
 while ((c = *(++ptr)) != 0)
        {
        int refnum = -c - ESC_REF;
        if (refnum > top_backref) top_backref = refnum;
-       length++;   /* For single back reference */
+       length += 2;   /* For single back reference */
-       if (ptr[1] == '{' && is_counted_repeat(ptr+2))
+       if (ptr[1] == '{' && is_counted_repeat(ptr+2, &compile_block))
          {
-         ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+         ptr = read_repeat_counts(ptr+2, &min, &max, errorptr, &compile_block);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          if ((min == 0 && (max == 1 || max == -1)) ||
            (min == 1 && max == -1))
-Line 1943 
 while ((c = *(++ptr)) != 0)
+Line 2624 
 while ((c = *(++ptr)) != 0)
      or back reference. */
      case '{':
-     if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR;
+     if (!is_counted_repeat(ptr+1, &compile_block)) goto NORMAL_CHAR;
-     ptr = read_repeat_counts(ptr+1, &min, &max, errorptr);
+     ptr = read_repeat_counts(ptr+1, &min, &max, errorptr, &compile_block);
      if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
      if ((min == 0 && (max == 1 || max == -1)) ||
        (min == 1 && max == -1))
-Line 1979 
 while ((c = *(++ptr)) != 0)
+Line 2660 
 while ((c = *(++ptr)) != 0)
        {
        if (*ptr == '\\')
          {
-         int ch = check_escape(&ptr, errorptr, bracount, options, TRUE);
+         int ch = check_escape(&ptr, errorptr, bracount, options, TRUE,
+           &compile_block);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          if (-ch == ESC_b) class_charcount++; else class_charcount = 10;
          }
-Line 1996 
 while ((c = *(++ptr)) != 0)
+Line 2678 
 while ((c = *(++ptr)) != 0)
        /* A repeat needs either 1 or 5 bytes. */
-       if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2))
+       if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2, &compile_block))
          {
-         ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+         ptr = read_repeat_counts(ptr+2, &min, &max, errorptr, &compile_block);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          if ((min == 0 && (max == 1 || max == -1)) ||
            (min == 1 && max == -1))
-Line 2013 
 while ((c = *(++ptr)) != 0)
+Line 2695 
 while ((c = *(++ptr)) != 0)
      case '(':
      branch_newextra = 0;
+     bracket_length = 3;
      /* Handle special forms of bracket, which all start (? */
-Line 2046 
 while ((c = *(++ptr)) != 0)
+Line 2729 
 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 2064 
 while ((c = *(++ptr)) != 0)
+Line 2760 
 while ((c = *(++ptr)) != 0)
          group. */
          case '(':
-         if ((pcre_ctypes[ptr[3]] & ctype_digit) != 0)
+         if ((compile_block.ctypes[ptr[3]] & ctype_digit) != 0)
            {
            ptr += 4;
-           length += 2;
+           length += 3;
-           while ((pcre_ctypes[*ptr] & ctype_digit) != 0) ptr++;
+           while ((compile_block.ctypes[*ptr] & ctype_digit) != 0) ptr++;
            if (*ptr != ')')
              {
              *errorptr = ERR26;
-Line 2078 
 while ((c = *(++ptr)) != 0)
+Line 2774 
 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 2153 
 while ((c = *(++ptr)) != 0)
+Line 2849 
 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 2191 
 while ((c = *(++ptr)) != 0)
+Line 2890 
 while ((c = *(++ptr)) != 0)
        }
      /* Extracting brackets must be counted so we can process escapes in a
-     Perlish way. */
+     Perlish way. If the number exceeds EXTRACT_BASIC_MAX we are going to
+     need an additional 3 bytes of store per extracting bracket. */
-     else bracount++;
+     else
+       {
+       bracount++;
+       if (bracount > EXTRACT_BASIC_MAX) bracket_length += 3;
+       }
-     /* Non-special forms of bracket. Save length for computing whole length
+     /* Save length for computing whole length at end if there's a repeat that
-     at end if there's a repeat that requires duplication of the group. Also
+     requires duplication of the group. Also save the current value of
-     save the current value of branch_extra, and start the new group with
+     branch_extra, and start the new group with the new value. If non-zero, this
-     the new value. If non-zero, this will either be 2 for a (?imsx: group, or 3
+     will either be 2 for a (?imsx: group, or 3 for a lookbehind assertion. */
-     for a lookbehind assertion. */
      if (brastackptr >= sizeof(brastack)/sizeof(int))
        {
-Line 2211 
 while ((c = *(++ptr)) != 0)
+Line 2914 
 while ((c = *(++ptr)) != 0)
      branch_extra = branch_newextra;
      brastack[brastackptr++] = length;
-     length += 3;
+     length += bracket_length;
      continue;
      /* Handle ket. Look for subsequent max/min; for certain sets of values we
-Line 2237 
 while ((c = *(++ptr)) != 0)
+Line 2940 
 while ((c = *(++ptr)) != 0)
        /* Leave ptr at the final char; for read_repeat_counts this happens
        automatically; for the others we need an increment. */
-       if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2))
+       if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2, &compile_block))
          {
-         ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr);
+         ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr,
+           &compile_block);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          }
        else if (c == '*') { minval = 0; maxval = -1; ptr++; }
        else if (c == '+') { maxval = -1; ptr++; }
        else if (c == '?') { minval = 0; ptr++; }
-       /* If there is a minimum > 1 we have to replicate up to minval-1 times;
+       /* If the minimum is zero, we have to allow for an OP_BRAZERO before the
-       if there is a limited maximum we have to replicate up to maxval-1 times
+       group, and if the maximum is greater than zero, we have to replicate
-       and allow for a BRAZERO item before each optional copy, as we also have
+       maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
-       to do before the first copy if the minimum is zero. */
+       bracket set - hence the 7. */
-       if (minval == 0) length++;
+       if (minval == 0)
-         else if (minval > 1) length += (minval - 1) * duplength;
+         {
-       if (maxval > minval) length += (maxval - minval) * (duplength + 1);
+         length++;
+         if (maxval > 0) length += (maxval - 1) * (duplength + 7);
+         }
+       /* When the minimum is greater than zero, 1 we have to replicate up to
+       minval-1 times, with no additions required in the copies. Then, if
+       there is a limited maximum we have to replicate up to maxval-1 times
+       allowing for a BRAZERO item before each optional copy and nesting
+       brackets for all but one of the optional copies. */
+       else
+         {
+         length += (minval - 1) * duplength;
+         if (maxval > minval)   /* Need this test as maxval=-1 means no limit */
+           length += (maxval - minval) * (duplength + 7) - 6;
+         }
        }
      continue;
-Line 2270 
 while ((c = *(++ptr)) != 0)
+Line 2989 
 while ((c = *(++ptr)) != 0)
        {
        if ((options & PCRE_EXTENDED) != 0)
          {
-         if ((pcre_ctypes[c] & ctype_space) != 0) continue;
+         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 != NEWLINE) ;
            continue;
            }
          }
-Line 2284 
 while ((c = *(++ptr)) != 0)
+Line 3005 
 while ((c = *(++ptr)) != 0)
        if (c == '\\')
          {
          const uschar *saveptr = ptr;
-         c = check_escape(&ptr, errorptr, bracount, options, FALSE);
+         c = check_escape(&ptr, errorptr, bracount, options, FALSE,
+           &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 2296 
 while ((c = *(++ptr)) != 0)
+Line 3028 
 while ((c = *(++ptr)) != 0)
      /* This "while" is the end of the "do" above. */
-     while (runlength < 255 && (pcre_ctypes[c = *(++ptr)] & ctype_meta) == 0);
+     while (runlength < MAXLIT &&
+       (compile_block.ctypes[c = *(++ptr)] & ctype_meta) == 0);
      ptr--;
      length += runlength;
-Line 2327 
 if (re == NULL)
+Line 3060 
 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;
  /* Set up a starting, non-extracting bracket, then compile the expression. On
  error, *errorptr will be set non-NULL, so we don't need to look at the result
-Line 2340 
 ptr = (const uschar *)pattern;
+Line 3075 
 ptr = (const uschar *)pattern;
  code = re->code;
  *code = OP_BRA;
  bracount = 0;
- (void)compile_regex(options, -1, &bracount, &code, &ptr, errorptr, FALSE, -1);
+ (void)compile_regex(options, -1, &bracount, &code, &ptr, errorptr, FALSE, 0,
+   &reqchar, &countlits, &compile_block);
  re->top_bracket = bracount;
  re->top_backref = top_backref;
-Line 2372 
 if (*errorptr != NULL)
+Line 3108 
 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 2396 
 if ((options & PCRE_ANCHORED) == 0)
+Line 3136 
 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 2405 
 printf("Length = %d top_bracket = %d top
+Line 3154 
 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 2422 
 if ((re->options & PCRE_FIRSTSET) != 0)
+Line 3172 
 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 2433 
 while (code < code_end)
+Line 3189 
 while (code < code_end)
    if (*code >= OP_BRA)
      {
-     printf("%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA);
+     if (*code - OP_BRA > EXTRACT_BASIC_MAX)
+       printf("%3d Bra extra", (code[1] << 8) + code[2]);
+     else
+       printf("%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA);
      code += 2;
      }
-Line 2444 
 while (code < code_end)
+Line 3203 
 while (code < code_end)
      code++;
      break;
-     case OP_COND:
-     printf("%3d Cond", (code[1] << 8) + code[2]);
-     code += 2;
-     break;
-     case OP_CREF:
-     printf(" %.2d %s", code[1], OP_names[*code]);
-     code++;
-     break;
      case OP_CHARS:
      charlength = *(++code);
      printf("%3d ", charlength);
-Line 2470 
 while (code < code_end)
+Line 3219 
 while (code < code_end)
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
      case OP_ONCE:
-     printf("%3d %s", (code[1] << 8) + code[2], OP_names[*code]);
-     code += 2;
-     break;
      case OP_REVERSE:
+     case OP_BRANUMBER:
+     case OP_COND:
+     case OP_CREF:
      printf("%3d %s", (code[1] << 8) + code[2], OP_names[*code]);
      code += 2;
      break;
-Line 2547 
 while (code < code_end)
+Line 3295 
 while (code < code_end)
      break;
      case OP_REF:
-     printf("    \\%d", *(++code));
+     printf("    \\%d", (code[1] << 8) | code[2]);
-     code ++;
+     code += 3;
      goto CLASS_REF_REPEAT;
      case OP_CLASS:
-Line 2637 
 return (pcre *)re;
+Line 3385 
 return (pcre *)re;
  /*************************************************
- *        Match a character type                  *
- *************************************************/
- /* Not used in all the places it might be as it's sometimes faster
- to put the code inline.
- Arguments:
-   type        the character type
-   c           the character
-   dotall      the dotall flag
- Returns:      TRUE if character is of the type
- */
- static BOOL
- match_type(int type, int c, BOOL dotall)
- {
- #ifdef DEBUG
- if (isprint(c)) printf("matching subject %c against ", c);
-   else printf("matching subject \\x%02x against ", c);
- printf("%s\n", OP_names[type]);
- #endif
- switch(type)
-   {
-   case OP_ANY:            return dotall || c != '\n';
-   case OP_NOT_DIGIT:      return (pcre_ctypes[c] & ctype_digit) == 0;
-   case OP_DIGIT:          return (pcre_ctypes[c] & ctype_digit) != 0;
-   case OP_NOT_WHITESPACE: return (pcre_ctypes[c] & ctype_space) == 0;
-   case OP_WHITESPACE:     return (pcre_ctypes[c] & ctype_space) != 0;
-   case OP_NOT_WORDCHAR:   return (pcre_ctypes[c] & ctype_word) == 0;
-   case OP_WORDCHAR:       return (pcre_ctypes[c] & ctype_word) != 0;
-   }
- return FALSE;
- }
- /*************************************************
  *          Match a back-reference                *
  *************************************************/
-Line 2695 
 Returns:      TRUE if matched
+Line 3403 
 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 2719 
 if (length > md->end_subject - eptr) ret
+Line 3427 
 if (length > md->end_subject - eptr) ret
  /* Separate the caselesss case for speed */
  if ((ims & PCRE_CASELESS) != 0)
-   { while (length-- > 0) if (pcre_lcc[*p++] != pcre_lcc[*eptr++]) return FALSE; }
+   {
+   while (length-- > 0)
+     if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;
+   }
  else
    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
-Line 2743 
 Arguments:
+Line 3454 
 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 2779 
 for (;;)
+Line 3509 
 for (;;)
    if (op > OP_BRA)
      {
+     int offset;
      int number = op - OP_BRA;
-     int offset = number << 1;
-     DPRINTF(("start bracket %d\n", number));
+     /* For extended extraction brackets (large number), we have to fish out the
+     number from a dummy opcode at the start. */
+     if (number > EXTRACT_BASIC_MAX) number = (ecode[4] << 8) | ecode[5];
+     offset = number << 1;
+ #ifdef DEBUG
+     printf("start bracket %d subject=", number);
+     pchars(eptr, 16, TRUE, md);
+     printf("\n");
+ #endif
      if (offset < md->offset_max)
        {
-Line 2795 
 for (;;)
+Line 3535 
 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 2805 
 for (;;)
+Line 3546 
 for (;;)
        md->offset_vector[offset] = save_offset1;
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
        return FALSE;
        }
-Line 2821 
 for (;;)
+Line 3563 
 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 2836 
 for (;;)
+Line 3579 
 for (;;)
      case OP_COND:
      if (ecode[3] == OP_CREF)         /* Condition is extraction test */
        {
-       int offset = ecode[4] << 1;    /* Doubled reference number */
+       int offset = (ecode[4] << 9) | (ecode[5] << 1); /* Doubled ref number */
        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 2848 
 for (;;)
+Line 3591 
 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 */
-     /* Skip over conditional reference data if encountered (should not be) */
+     /* Skip over conditional reference or large extraction number data if
+     encountered. */
      case OP_CREF:
-     ecode += 2;
+     case OP_BRANUMBER:
+     ecode += 3;
      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 2876 
 for (;;)
+Line 3624 
 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 2889 
 for (;;)
+Line 3637 
 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 2897 
 for (;;)
+Line 3645 
 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 2913 
 for (;;)
+Line 3661 
 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 2943 
 for (;;)
+Line 3752 
 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 2969 
 for (;;)
+Line 3780 
 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 2983 
 for (;;)
+Line 3794 
 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 3015 
 for (;;)
+Line 3827 
 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 3025 
 for (;;)
+Line 3838 
 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 3040 
 for (;;)
+Line 3854 
 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 3056 
 for (;;)
+Line 3873 
 for (;;)
        if (*prev != OP_COND)
          {
+         int offset;
          int number = *prev - OP_BRA;
-         int offset = number << 1;
-         DPRINTF(("end bracket %d\n", number));
+         /* For extended extraction brackets (large number), we have to fish out
+         the number from a dummy opcode at the start. */
+         if (number > EXTRACT_BASIC_MAX) number = (prev[4] << 8) | prev[5];
+         offset = number << 1;
+ #ifdef DEBUG
+         printf("end bracket %d", number);
+         printf("\n");
+ #endif
          if (number > 0)
            {
-Line 3077 
 for (;;)
+Line 3903 
 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 3085 
 for (;;)
+Line 3911 
 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 3096 
 for (;;)
+Line 3922 
 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 3113 
 for (;;)
+Line 3940 
 for (;;)
      if (md->notbol && eptr == md->start_subject) return FALSE;
      if ((ims & PCRE_MULTILINE) != 0)
        {
-       if (eptr != md->start_subject && eptr[-1] != '\n') return FALSE;
+       if (eptr != md->start_subject && eptr[-1] != NEWLINE) return FALSE;
        ecode++;
        break;
        }
-Line 3132 
 for (;;)
+Line 3959 
 for (;;)
      case OP_DOLL:
      if ((ims & PCRE_MULTILINE) != 0)
        {
-       if (eptr < md->end_subject) { if (*eptr != '\n') return FALSE; }
+       if (eptr < md->end_subject) { if (*eptr != NEWLINE) return FALSE; }
          else { if (md->noteol) return FALSE; }
        ecode++;
        break;
-Line 3143 
 for (;;)
+Line 3970 
 for (;;)
        if (!md->endonly)
          {
          if (eptr < md->end_subject - 1 ||
-            (eptr == md->end_subject - 1 && *eptr != '\n')) return FALSE;
+            (eptr == md->end_subject - 1 && *eptr != NEWLINE)) return FALSE;
          ecode++;
          break;
-Line 3162 
 for (;;)
+Line 3989 
 for (;;)
      case OP_EODN:
      if (eptr < md->end_subject - 1 ||
-        (eptr == md->end_subject - 1 && *eptr != '\n')) return FALSE;
+        (eptr == md->end_subject - 1 && *eptr != NEWLINE)) return FALSE;
      ecode++;
      break;
-Line 3172 
 for (;;)
+Line 3999 
 for (;;)
      case OP_WORD_BOUNDARY:
        {
        BOOL prev_is_word = (eptr != md->start_subject) &&
-         ((pcre_ctypes[eptr[-1]] & ctype_word) != 0);
+         ((md->ctypes[eptr[-1]] & ctype_word) != 0);
        BOOL cur_is_word = (eptr < md->end_subject) &&
-         ((pcre_ctypes[*eptr] & ctype_word) != 0);
+         ((md->ctypes[*eptr] & ctype_word) != 0);
        if ((*ecode++ == OP_WORD_BOUNDARY)?
             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
          return FALSE;
-Line 3184 
 for (;;)
+Line 4011 
 for (;;)
      /* Match a single character type; inline for speed */
      case OP_ANY:
-     if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == '\n')
+     if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == NEWLINE)
        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;
      case OP_NOT_DIGIT:
-     if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_digit) != 0)
+     if (eptr >= md->end_subject ||
+        (md->ctypes[*eptr++] & ctype_digit) != 0)
        return FALSE;
      ecode++;
      break;
      case OP_DIGIT:
-     if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_digit) == 0)
+     if (eptr >= md->end_subject ||
+        (md->ctypes[*eptr++] & ctype_digit) == 0)
        return FALSE;
      ecode++;
      break;
      case OP_NOT_WHITESPACE:
-     if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_space) != 0)
+     if (eptr >= md->end_subject ||
+        (md->ctypes[*eptr++] & ctype_space) != 0)
        return FALSE;
      ecode++;
      break;
      case OP_WHITESPACE:
-     if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_space) == 0)
+     if (eptr >= md->end_subject ||
+        (md->ctypes[*eptr++] & ctype_space) == 0)
        return FALSE;
      ecode++;
      break;
      case OP_NOT_WORDCHAR:
-     if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_word) != 0)
+     if (eptr >= md->end_subject ||
+        (md->ctypes[*eptr++] & ctype_word) != 0)
        return FALSE;
      ecode++;
      break;
      case OP_WORDCHAR:
-     if (eptr >= md->end_subject || (pcre_ctypes[*eptr++] & ctype_word) == 0)
+     if (eptr >= md->end_subject ||
+        (md->ctypes[*eptr++] & ctype_word) == 0)
        return FALSE;
      ecode++;
      break;
-Line 3237 
 for (;;)
+Line 4074 
 for (;;)
      case OP_REF:
        {
        int length;
-       int offset = ecode[1] << 1;                /* Doubled reference number */
+       int offset = (ecode[1] << 9) | (ecode[2] << 1); /* Doubled ref number */
-       ecode += 2;                                /* Advance past the item */
+       ecode += 3;                                     /* Advance past item */
        /* If the reference is unset, set the length to be longer than the amount
        of subject left; this ensures that every attempt at a match fails. We
-Line 3307 
 for (;;)
+Line 4144 
 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 3328 
 for (;;)
+Line 4165 
 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 3382 
 for (;;)
+Line 4219 
 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 3399 
 for (;;)
+Line 4242 
 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 3414 
 for (;;)
+Line 4262 
 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 3453 
 for (;;)
+Line 4313 
 for (;;)
        if (length > md->end_subject - eptr) return FALSE;
        if ((ims & PCRE_CASELESS) != 0)
          {
-         while (length-- > 0) if (pcre_lcc[*ecode++] != pcre_lcc[*eptr++]) return FALSE;
+         while (length-- > 0)
+           if (md->lcc[*ecode++] != md->lcc[*eptr++])
+             return FALSE;
          }
        else
          {
-Line 3510 
 for (;;)
+Line 4372 
 for (;;)
      if ((ims & PCRE_CASELESS) != 0)
        {
-       c = pcre_lcc[c];
+       c = md->lcc[c];
-       for (i = 1; i <= min; i++) if (c != pcre_lcc[*eptr++]) return FALSE;
+       for (i = 1; i <= min; i++)
+         if (c != md->lcc[*eptr++]) return FALSE;
        if (min == max) continue;
        if (minimize)
          {
          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 != pcre_lcc[*eptr++])
+           if (i >= max || eptr >= md->end_subject ||
+               c != md->lcc[*eptr++])
              return FALSE;
            }
          /* Control never gets here */
-Line 3529 
 for (;;)
+Line 4393 
 for (;;)
          const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || c != pcre_lcc[*eptr]) break;
+           if (eptr >= md->end_subject || c != md->lcc[*eptr]) break;
            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 3550 
 for (;;)
+Line 4414 
 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 3565 
 for (;;)
+Line 4429 
 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 3579 
 for (;;)
+Line 4443 
 for (;;)
      ecode++;
      if ((ims & PCRE_CASELESS) != 0)
        {
-       if (pcre_lcc[*ecode++] == pcre_lcc[*eptr++]) return FALSE;
+       if (md->lcc[*ecode++] == md->lcc[*eptr++]) return FALSE;
        }
      else
        {
-Line 3639 
 for (;;)
+Line 4503 
 for (;;)
      if ((ims & PCRE_CASELESS) != 0)
        {
-       c = pcre_lcc[c];
+       c = md->lcc[c];
-       for (i = 1; i <= min; i++) if (c == pcre_lcc[*eptr++]) return FALSE;
+       for (i = 1; i <= min; i++)
+         if (c == md->lcc[*eptr++]) return FALSE;
        if (min == max) continue;
        if (minimize)
          {
          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 == pcre_lcc[*eptr++])
+           if (i >= max || eptr >= md->end_subject ||
+               c == md->lcc[*eptr++])
              return FALSE;
            }
          /* Control never gets here */
-Line 3658 
 for (;;)
+Line 4524 
 for (;;)
          const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || c == pcre_lcc[*eptr]) break;
+           if (eptr >= md->end_subject || c == md->lcc[*eptr]) break;
            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 3679 
 for (;;)
+Line 4545 
 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 3694 
 for (;;)
+Line 4560 
 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 3738 
 for (;;)
+Line 4604 
 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++ == NEWLINE && (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; }
+         { for (i = 1; i <= min; i++) if (*eptr++ == NEWLINE) return FALSE; }
        else eptr += min;
        break;
        case OP_NOT_DIGIT:
        for (i = 1; i <= min; i++)
-         if ((pcre_ctypes[*eptr++] & ctype_digit) != 0) return FALSE;
+         if ((md->ctypes[*eptr++] & ctype_digit) != 0) return FALSE;
        break;
        case OP_DIGIT:
        for (i = 1; i <= min; i++)
-         if ((pcre_ctypes[*eptr++] & ctype_digit) == 0) return FALSE;
+         if ((md->ctypes[*eptr++] & ctype_digit) == 0) return FALSE;
        break;
        case OP_NOT_WHITESPACE:
        for (i = 1; i <= min; i++)
-         if ((pcre_ctypes[*eptr++] & ctype_space) != 0) return FALSE;
+         if ((md->ctypes[*eptr++] & ctype_space) != 0) return FALSE;
        break;
        case OP_WHITESPACE:
        for (i = 1; i <= min; i++)
-         if ((pcre_ctypes[*eptr++] & ctype_space) == 0) return FALSE;
+         if ((md->ctypes[*eptr++] & ctype_space) == 0) return FALSE;
        break;
        case OP_NOT_WORDCHAR:
-       for (i = 1; i <= min; i++) if ((pcre_ctypes[*eptr++] & ctype_word) != 0)
+       for (i = 1; i <= min; i++)
-         return FALSE;
+         if ((md->ctypes[*eptr++] & ctype_word) != 0)
+           return FALSE;
        break;
        case OP_WORDCHAR:
-       for (i = 1; i <= min; i++) if ((pcre_ctypes[*eptr++] & ctype_word) == 0)
+       for (i = 1; i <= min; i++)
-         return FALSE;
+         if ((md->ctypes[*eptr++] & ctype_word) == 0)
+           return FALSE;
        break;
        }
-Line 3786 
 for (;;)
+Line 4670 
 for (;;)
      if (min == max) continue;
      /* If minimizing, we have to test the rest of the pattern before each
-     subsequent match, so inlining isn't much help; just use the function. */
+     subsequent match. */
      if (minimize)
        {
        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 ||
+         if (i >= max || eptr >= md->end_subject) return FALSE;
-           !match_type(ctype, *eptr++, (ims & PCRE_DOTALL) != 0))
-             return FALSE;
+         c = *eptr++;
+         switch(ctype)
+           {
+           case OP_ANY:
+           if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) return FALSE;
+ #ifdef SUPPORT_UTF8
+           if (md->utf8)
+             while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+ #endif
+           break;
+           case OP_NOT_DIGIT:
+           if ((md->ctypes[c] & ctype_digit) != 0) return FALSE;
+           break;
+           case OP_DIGIT:
+           if ((md->ctypes[c] & ctype_digit) == 0) return FALSE;
+           break;
+           case OP_NOT_WHITESPACE:
+           if ((md->ctypes[c] & ctype_space) != 0) return FALSE;
+           break;
+           case OP_WHITESPACE:
+           if  ((md->ctypes[c] & ctype_space) == 0) return FALSE;
+           break;
+           case OP_NOT_WORDCHAR:
+           if ((md->ctypes[c] & ctype_word) != 0) return FALSE;
+           break;
+           case OP_WORDCHAR:
+           if ((md->ctypes[c] & ctype_word) == 0) return FALSE;
+           break;
+           }
          }
        /* Control never gets here */
        }
-Line 3809 
 for (;;)
+Line 4727 
 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++ == NEWLINE) 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++)
              {
-             if (eptr >= md->end_subject || *eptr == '\n') break;
+             if (eptr >= md->end_subject || *eptr == NEWLINE) break;
              eptr++;
              }
            }
-Line 3828 
 for (;;)
+Line 4773 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_digit) != 0)
+           if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)
              break;
            eptr++;
            }
-Line 3837 
 for (;;)
+Line 4782 
 for (;;)
          case OP_DIGIT:
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_digit) == 0)
+           if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)
              break;
            eptr++;
            }
-Line 3846 
 for (;;)
+Line 4791 
 for (;;)
          case OP_NOT_WHITESPACE:
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_space) != 0)
+           if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)
              break;
            eptr++;
            }
-Line 3855 
 for (;;)
+Line 4800 
 for (;;)
          case OP_WHITESPACE:
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_space) == 0)
+           if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)
              break;
            eptr++;
            }
-Line 3864 
 for (;;)
+Line 4809 
 for (;;)
          case OP_NOT_WORDCHAR:
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_word) != 0)
+           if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)
              break;
            eptr++;
            }
-Line 3873 
 for (;;)
+Line 4818 
 for (;;)
          case OP_WORDCHAR:
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || (pcre_ctypes[*eptr] & ctype_word) == 0)
+           if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)
              break;
            eptr++;
            }
-Line 3881 
 for (;;)
+Line 4826 
 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 3919 
 Arguments:
+Line 4870 
 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 3931 
 Returns:          > 0 => success; value
+Line 4883 
 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;
- BOOL anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
+ BOOL anchored;
- BOOL startline = (re->options & PCRE_STARTLINE) != 0;
+ BOOL startline;
  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
-Line 3952 
 if (re == NULL || subject == NULL ||
+Line 4908 
 if (re == NULL || subject == NULL ||
     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
  if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
+ anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
+ startline = (re->options & PCRE_STARTLINE) != 0;
+ 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 */
+ match_block.lcc = re->tables + lcc_offset;
+ match_block.ctypes = re->tables + ctypes_offset;
  /* The ims options can vary during the matching as a result of the presence
  of (?ims) items in the pattern. They are kept in a local variable so that
  restoring at the exit of a group is easy. */
-Line 3997 
 in the pattern. */
+Line 4962 
 in the pattern. */
  resetcount = 2 + re->top_bracket * 2;
  if (resetcount > offsetcount) resetcount = ocount;
+ /* Reset the working variable associated with each extraction. These should
+ never be used unless previously set, but they get saved and restored, and so we
+ initialize them to avoid reading uninitialized locations. */
+ if (match_block.offset_vector != NULL)
+   {
+   register int *iptr = match_block.offset_vector + ocount;
+   register int *iend = iptr - resetcount/2 + 1;
+   while (--iptr >= iend) *iptr = -1;
+   }
  /* Set up the first character to match, if available. The first_char value is
  never set for an anchored regular expression, but the anchoring may be forced
  at run time, so we have to test for anchoring. The first char may be unset for
-Line 4008 
 if (!anchored)
+Line 4984 
 if (!anchored)
    if ((re->options & PCRE_FIRSTSET) != 0)
      {
      first_char = re->first_char;
-     if ((ims & PCRE_CASELESS) != 0) first_char = pcre_lcc[first_char];
+     if ((ims & PCRE_CASELESS) != 0) first_char = match_block.lcc[first_char];
      }
    else
      if (!startline && extra != NULL &&
-Line 4016 
 if (!anchored)
+Line 4992 
 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 4033 
 do
+Line 5025 
 do
    if (first_char >= 0)
      {
      if ((ims & PCRE_CASELESS) != 0)
-       while (start_match < end_subject && pcre_lcc[*start_match] != first_char)
+       while (start_match < end_subject &&
+              match_block.lcc[*start_match] != first_char)
          start_match++;
      else
        while (start_match < end_subject && *start_match != first_char)
-Line 4044 
 do
+Line 5037 
 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')
+       while (start_match < end_subject && start_match[-1] != NEWLINE)
          start_match++;
        }
      }
-   /* Or to a non-unique first char */
+   /* Or to a non-unique first char after study */
    else if (start_bits != NULL)
      {
-Line 4068 
 do
+Line 5061 
 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 4075 
 do
+Line 5121 
 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 */
-Line 4106 
 do
+Line 5153 
 do
    DPRINTF((">>>> returning %d\n", rc));
    return rc;
    }
+ /* This "while" is the end of the "do" above */
  while (!anchored &&
         match_block.errorcode == PCRE_ERROR_NOMATCH &&
         start_match++ < end_subject);

 Legend:



Removed from v.23
 


changed lines


 
Added in v.53
 Legend:



Removed from v.23
 


changed lines


 
Added in v.53
-Removed from v.23
+Added in v.53

	ViewVC Help
Powered by ViewVC 1.1.5