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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 72 by nigel,
Sat Feb 24 21:40:24 2007 UTC
+revision 73 by nigel,
Sat Feb 24 21:40:30 2007 UTC
 Line 32 
 restrictions:
  -----------------------------------------------------------------------------
  */
- /* Define DEBUG to get debugging output on stdout. */
+ /* Define DEBUG to get debugging output on stdout. */
  /* #define DEBUG */
  /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
 Line 46 
 pre-processor statements. I suppose it's
  #define DPRINTF(p) /*nothing*/
  #endif
- /* Include the internals header, which itself includes Standard C headers plus
+ /* Include the internals header, which itself includes "config.h", the Standard
- the external pcre header. */
+ C headers, and the external pcre header. */
  #include "internal.h"
 Line 92 
 req_byte match. */
  /* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
  the definition is next to the definition of the opcodes in internal.h. */
- static uschar OP_lengths[] = { OP_LENGTHS };
+ static const uschar OP_lengths[] = { OP_LENGTHS };
  /* Min and max values for the common repeats; for the maxima, 0 => infinity */
 Line 104 
 are simple data values; negative values
  on. Zero means further processing is needed (for things like \x), or the escape
  is invalid. */
+ #if !EBCDIC   /* This is the "normal" table for ASCII systems */
  static const short int escapes[] = {
 ,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
 ,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
-Line 117 
 static const short int escapes[] = {
+Line 118 
 static const short int escapes[] = {
 ,      0, -ESC_z                                            /* x - z */
  };
+ #else         /* This is the "abnormal" table for EBCDIC systems */
+ static const short int escapes[] = {
+ /*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',
+ /*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,
+ /*  58 */     0,     0,    '!',     '$',    '*',   ')',    ';',    '~',
+ /*  60 */   '-',   '/',      0,       0,      0,     0,      0,      0,
+ /*  68 */     0,     0,    '|',     ',',    '%',   '_',    '>',    '?',
+ /*  70 */     0,     0,      0,       0,      0,     0,      0,      0,
+ /*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',
+ /*  80 */     0,     7, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,
+ /*  88 */     0,     0,      0,     '{',      0,     0,      0,      0,
+ /*  90 */     0,     0,      0,     'l',      0, ESC_n,      0,      0,
+ /*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,
+ /*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,     0, -ESC_w,      0,
+ /*  A8 */     0,-ESC_z,      0,       0,      0,   '[',      0,      0,
+ /*  B0 */     0,     0,      0,       0,      0,     0,      0,      0,
+ /*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
+ /*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
+ /*  C8 */     0,     0,      0,       0,      0,     0,      0,      0,
+ /*  D0 */   '}',     0,      0,       0,      0,     0,      0,      0,
+ /*  D8 */-ESC_Q,     0,      0,       0,      0,     0,      0,      0,
+ /*  E0 */  '\\',     0, -ESC_S,       0,      0,     0, -ESC_W,      0,
+ /*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
+ /*  F0 */     0,     0,      0,       0,      0,     0,      0,      0,
+ /*  F8 */     0,     0,      0,       0,      0,     0,      0,      0
+ };
+ #endif
  /* 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[] = {
+ static const char *const posix_names[] = {
    "alpha", "lower", "upper",
    "alnum", "ascii", "blank", "cntrl", "digit", "graph",
    "print", "punct", "space", "word",  "xdigit" };
-Line 150 
 static const int posix_class_maps[] = {
+Line 180 
 static const int posix_class_maps[] = {
    cbit_xdigit,-1,         -1              /* xdigit */
  };
- /* Table to identify ASCII digits and hex digits. This is used when compiling
+ /* Table to identify digits and hex digits. This is used when compiling
  patterns. Note that the tables in chartables are dependent on the locale, and
  may mark arbitrary characters as digits - but the PCRE compiling code expects
  to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
-Line 166 
 For convenience, we use the same bit def
+Line 196 
 For convenience, we use the same bit def
  Then we can use ctype_digit and ctype_xdigit in the code. */
+ #if !EBCDIC    /* This is the "normal" case, for ASCII systems */
  static const unsigned char digitab[] =
    {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
-Line 201 
 static const unsigned char digitab[] =
+Line 232 
 static const unsigned char digitab[] =
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
+ #else          /* This is the "abnormal" case, for EBCDIC systems */
+ static const unsigned char digitab[] =
+   {
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 10 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  32- 39 20 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 30 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 40 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  72- |     */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 50 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  88- �     */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 60 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ?     */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "     */
+x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g  80 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p  90 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x  A0 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 B0 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191    */
+x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  { - G  C0 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  } - P  D0 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223    */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  \ - X  E0 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239    */
+x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  F0 */
+x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255    */
+ static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
+x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*   0-  7 */
+x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
+x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  16- 23 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  32- 39 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63 */
+x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 */
+x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /*  72- |  */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 */
+x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /*  88- �  */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 */
+x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ?  */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
+x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "  */
+x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g  */
+x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143 */
+x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p  */
+x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159 */
+x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x  */
+x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175 */
+x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 */
+x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  { - G  */
+x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207 */
+x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  } - P  */
+x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223 */
+x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /*  \ - X  */
+x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239 */
+x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
+x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255 */
+ #endif
  /* Definition to allow mutual recursion */
  static BOOL
-Line 210 
 static BOOL
+Line 313 
 static BOOL
  /* 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. */
+ subpattern - to break infinite loops. When NO_RECURSE is set, these blocks
+ are on the heap, not on the stack. */
  typedef struct eptrblock {
-   struct eptrblock *prev;
+   struct eptrblock *epb_prev;
-   const uschar *saved_eptr;
+   const uschar *epb_saved_eptr;
  } eptrblock;
  /* Flag bits for the match() function */
-Line 235 
 defined PCRE_ERROR_xxx codes, which are
+Line 339 
 defined PCRE_ERROR_xxx codes, which are
  *************************************************/
  /* PCRE is thread-clean and doesn't use any global variables in the normal
- sense. However, it calls memory allocation and free functions via the two
+ sense. However, it calls memory allocation and free functions via the four
  indirections below, and it can optionally do callouts. These values can be
  changed by the caller, but are shared between all threads. However, when
  compiling for Virtual Pascal, things are done differently (see pcre.in). */
-Line 244 
 compiling for Virtual Pascal, things are
+Line 348 
 compiling for Virtual Pascal, things are
  #ifdef __cplusplus
  extern "C" void *(*pcre_malloc)(size_t) = malloc;
  extern "C" void  (*pcre_free)(void *) = free;
+ extern "C" void *(*pcre_stack_malloc)(size_t) = malloc;
+ extern "C" void  (*pcre_stack_free)(void *) = free;
  extern "C" int   (*pcre_callout)(pcre_callout_block *) = NULL;
  #else
  void *(*pcre_malloc)(size_t) = malloc;
  void  (*pcre_free)(void *) = free;
+ void *(*pcre_stack_malloc)(size_t) = malloc;
+ void  (*pcre_stack_free)(void *) = free;
  int   (*pcre_callout)(pcre_callout_block *) = NULL;
  #endif
  #endif
-Line 444 
 pcretest.c. It defines a function called
+Line 552 
 pcretest.c. It defines a function called
  #define STRING(a)  # a
  #define XSTRING(s) STRING(s)
- const char *
+ EXPORT const char *
  pcre_version(void)
  {
  return XSTRING(PCRE_MAJOR) "." XSTRING(PCRE_MINOR) " " XSTRING(PCRE_DATE);
-Line 475 
 Returns:        number of capturing subp
+Line 583 
 Returns:        number of capturing subp
                  or negative values on error
  */
- int
+ EXPORT int
  pcre_info(const pcre *external_re, int *optptr, int *first_byte)
  {
  const real_pcre *re = (const real_pcre *)external_re;
-Line 506 
 Arguments:
+Line 614 
 Arguments:
  Returns:           0 if data returned, negative on error
  */
- int
+ EXPORT int
  pcre_fullinfo(const pcre *external_re, const pcre_extra *extra_data, int what,
    void *where)
  {
-Line 592 
 Arguments:
+Line 700 
 Arguments:
  Returns:           0 if data returned, negative on error
  */
- int
+ EXPORT int
  pcre_config(int what, void *where)
  {
  switch (what)
-Line 621 
 switch (what)
+Line 729 
 switch (what)
    *((unsigned int *)where) = MATCH_LIMIT;
    break;
+   case PCRE_CONFIG_STACKRECURSE:
+ #ifdef NO_RECURSE
+   *((int *)where) = 0;
+ #else
+   *((int *)where) = 1;
+ #endif
+   break;
    default: return PCRE_ERROR_BADOPTION;
    }
-Line 693 
 int c, i;
+Line 809 
 int c, i;
  c = *(++ptr);
  if (c == 0) *errorptr = ERR1;
- /* Digits or letters may have special meaning; all others are literals. */
+ /* Non-alphamerics are literals. For digits or letters, do an initial lookup in
+ a table. A non-zero result is something that can be returned immediately.
- else if (c < '0' || c > 'z') {}
+ Otherwise further processing may be required. */
- /* Do an initial lookup in a table. A non-zero result is something that can be
- returned immediately. Otherwise further processing may be required. */
+ #if !EBCDIC    /* ASCII coding */
+ else if (c < '0' || c > 'z') {}                           /* Not alphameric */
  else if ((i = escapes[c - '0']) != 0) c = i;
+ #else          /* EBCDIC coding */
+ else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphameric */
+ else if ((i = escapes[c - 0x48]) != 0)  c = i;
+ #endif
  /* Escapes that need further processing, or are illegal. */
  else
-Line 786 
 else
+Line 906 
 else
        while ((digitab[*pt] & ctype_xdigit) != 0)
          {
          int cc = *pt++;
-         if (cc >= 'a') cc -= 32;            /* Convert to upper case */
          count++;
+ #if !EBCDIC    /* ASCII coding */
+         if (cc >= 'a') cc -= 32;               /* Convert to upper case */
          c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
+ #else          /* EBCDIC coding */
+         if (cc >= 'a' && cc <= 'z') cc += 64;  /* Convert to upper case */
+         c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
+ #endif
          }
        if (*pt == '}')
          {
-Line 808 
 else
+Line 933 
 else
        {
        int cc;                               /* Some compilers don't like ++ */
        cc = *(++ptr);                        /* in initializers */
+ #if !EBCDIC    /* ASCII coding */
        if (cc >= 'a') cc -= 32;              /* Convert to upper case */
        c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
+ #else          /* EBCDIC coding */
+       if (cc <= 'z') cc += 64;              /* Convert to upper case */
+       c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
+ #endif
        }
      break;
-Line 824 
 else
+Line 954 
 else
        }
      /* A letter is upper-cased; then the 0x40 bit is flipped. This coding
-     is ASCII-specific, but then the whole concept of \cx is ASCII-specific. */
+     is ASCII-specific, but then the whole concept of \cx is ASCII-specific.
+     (However, an EBCDIC equivalent has now been added.) */
+ #if !EBCDIC    /* ASCII coding */
      if (c >= 'a' && c <= 'z') c -= 32;
      c ^= 0x40;
+ #else          /* EBCDIC coding */
+     if (c >= 'a' && c <= 'z') c += 64;
+     c ^= 0xC0;
+ #endif
      break;
      /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
-Line 871 
 Returns:    TRUE or FALSE
+Line 1007 
 Returns:    TRUE or FALSE
  static BOOL
  is_counted_repeat(const uschar *p)
  {
- if ((digitab[*p++] && ctype_digit) == 0) return FALSE;
+ if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
  while ((digitab[*p] & ctype_digit) != 0) p++;
  if (*p == '}') return TRUE;
  if (*p++ != ',') return FALSE;
  if (*p == '}') return TRUE;
- if ((digitab[*p++] && ctype_digit) == 0) return FALSE;
+ if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
  while ((digitab[*p] & ctype_digit) != 0) p++;
  return (*p == '}');
-Line 1218 
 for (;;)
+Line 1354 
 for (;;)
      {
      code += OP_lengths[c];
+ #ifdef SUPPORT_UTF8
      /* In UTF-8 mode, opcodes that are followed by a character may be followed
      by a multi-byte character. The length in the table is a minimum, so we have
      to scan along to skip the extra characters. All opcodes are less than 128,
      so we can use relatively efficient code. */
+     if (utf8) switch(c)
+       {
+       case OP_EXACT:
+       case OP_UPTO:
+       case OP_MINUPTO:
+       case OP_STAR:
+       case OP_MINSTAR:
+       case OP_PLUS:
+       case OP_MINPLUS:
+       case OP_QUERY:
+       case OP_MINQUERY:
+       while ((*code & 0xc0) == 0x80) code++;
+       break;
+       /* XCLASS is used for classes that cannot be represented just by a bit
+       map. This includes negated single high-valued characters. The length in
+       the table is zero; the actual length is stored in the compled code. */
+       case OP_XCLASS:
+       code += GET(code, 1) + 1;
+       break;
+       }
+ #endif
+     }
+   }
+ }
+ /*************************************************
+ *   Scan compiled regex for recursion reference  *
+ *************************************************/
+ /* This little function scans through a compiled pattern until it finds an
+ instance of OP_RECURSE.
+ Arguments:
+   code        points to start of expression
+   utf8        TRUE in UTF-8 mode
+ Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
+ */
+ static const uschar *
+ find_recurse(const uschar *code, BOOL utf8)
+ {
+ #ifndef SUPPORT_UTF8
+ utf8 = utf8;               /* Stop pedantic compilers complaining */
+ #endif
+ for (;;)
+   {
+   register int c = *code;
+   if (c == OP_END) return NULL;
+   else if (c == OP_RECURSE) return code;
+   else if (c == OP_CHARS) code += code[1] + OP_lengths[c];
+   else if (c > OP_BRA)
+     {
+     code += OP_lengths[OP_BRA];
+     }
+   else
+     {
+     code += OP_lengths[c];
  #ifdef SUPPORT_UTF8
+     /* In UTF-8 mode, opcodes that are followed by a character may be followed
+     by a multi-byte character. The length in the table is a minimum, so we have
+     to scan along to skip the extra characters. All opcodes are less than 128,
+     so we can use relatively efficient code. */
      if (utf8) switch(c)
        {
        case OP_EXACT:
-Line 1237 
 for (;;)
+Line 1445 
 for (;;)
        case OP_MINQUERY:
        while ((*code & 0xc0) == 0x80) code++;
        break;
+       /* XCLASS is used for classes that cannot be represented just by a bit
+       map. This includes negated single high-valued characters. The length in
+       the table is zero; the actual length is stored in the compled code. */
+       case OP_XCLASS:
+       code += GET(code, 1) + 1;
+       break;
        }
  #endif
      }
-Line 1480 
 return -1;
+Line 1696 
 return -1;
  }
+ /*************************************************
+ *    Adjust OP_RECURSE items in repeated group   *
+ *************************************************/
+ /* OP_RECURSE items contain an offset from the start of the regex to the group
+ that is referenced. This means that groups can be replicated for fixed
+ repetition simply by copying (because the recursion is allowed to refer to
+ earlier groups that are outside the current group). However, when a group is
+ optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
+ it, after it has been compiled. This means that any OP_RECURSE items within it
+ that refer to the group itself or any contained groups have to have their
+ offsets adjusted. That is the job of this function. Before it is called, the
+ partially compiled regex must be temporarily terminated with OP_END.
+ Arguments:
+   group      points to the start of the group
+   adjust     the amount by which the group is to be moved
+   utf8       TRUE in UTF-8 mode
+   cd         contains pointers to tables etc.
+ Returns:     nothing
+ */
+ static void
+ adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd)
+ {
+ uschar *ptr = group;
+ while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
+   {
+   int offset = GET(ptr, 1);
+   if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
+   ptr += 1 + LINK_SIZE;
+   }
+ }
  /*************************************************
-Line 1766 
 for (;; ptr++)
+Line 2017 
 for (;; ptr++)
          posix_class *= 3;
          for (i = 0; i < 3; i++)
            {
-           BOOL isblank = strncmp((char *)ptr, "blank", 5) == 0;
+           BOOL blankclass = strncmp((char *)ptr, "blank", 5) == 0;
            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];
-             if (isblank) class[1] |= 0x3c;
+             if (blankclass) class[1] |= 0x3c;
              }
            else
              {
              for (c = 0; c < 32; c++) class[c] |= cbits[c+taboffset];
-             if (isblank) class[1] &= ~0x3c;
+             if (blankclass) class[1] &= ~0x3c;
              }
            }
-Line 2442 
 for (;; ptr++)
+Line 2693 
 for (;; ptr++)
            }
          /* If the maximum is 1 or unlimited, we just have to stick in the
-         BRAZERO and do no more at this point. */
+         BRAZERO and do no more at this point. However, we do need to adjust
+         any OP_RECURSE calls inside the group that refer to the group itself or
+         any internal group, because the offset is from the start of the whole
+         regex. Temporarily terminate the pattern while doing this. */
          if (repeat_max <= 1)
            {
+           *code = OP_END;
+           adjust_recurse(previous, 1, utf8, cd);
            memmove(previous+1, previous, len);
            code++;
            *previous++ = OP_BRAZERO + repeat_type;
-Line 2455 
 for (;; ptr++)
+Line 2711 
 for (;; ptr++)
          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
+         that is common with the non-zero minimum case below. We have to
-         adjust the value or repeat_max, since one less copy is required. */
+         adjust the value or repeat_max, since one less copy is required. Once
+         again, we may have to adjust any OP_RECURSE calls inside the group. */
          else
            {
            int offset;
+           *code = OP_END;
+           adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd);
            memmove(previous + 2 + LINK_SIZE, previous, len);
            code += 2 + LINK_SIZE;
            *previous++ = OP_BRAZERO + repeat_type;
-Line 3149 
 for (;; ptr++)
+Line 3408 
 for (;; ptr++)
          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. */
+         two or more bytes in the UTF-8 encoding. */
  #ifdef SUPPORT_UTF8
          if (utf8 && c > 127)
-Line 3762 
 if (length < 0)
+Line 4021 
 if (length < 0)
  for (p = string; length-- > 0; p++)
    {
-   int ab;
+   register int ab;
-   if (*p < 128) continue;
+   register int c = *p;
-   if ((*p & 0xc0) != 0xc0) return p - string;
+   if (c < 128) continue;
-   ab = utf8_table4[*p & 0x3f];  /* Number of additional bytes */
+   if ((c & 0xc0) != 0xc0) return p - string;
+   ab = utf8_table4[c & 0x3f];  /* Number of additional bytes */
    if (length < ab) return p - string;
-   while (ab-- > 0)
+   length -= ab;
+   /* Check top bits in the second byte */
+   if ((*(++p) & 0xc0) != 0x80) return p - string;
+   /* Check for overlong sequences for each different length */
+   switch (ab)
+     {
+     /* Check for xx00 000x */
+     case 1:
+     if ((c & 0x3e) == 0) return p - string;
+     continue;   /* We know there aren't any more bytes to check */
+     /* Check for 1110 0000, xx0x xxxx */
+     case 2:
+     if (c == 0xe0 && (*p & 0x20) == 0) return p - string;
+     break;
+     /* Check for 1111 0000, xx00 xxxx */
+     case 3:
+     if (c == 0xf0 && (*p & 0x30) == 0) return p - string;
+     break;
+     /* Check for 1111 1000, xx00 0xxx */
+     case 4:
+     if (c == 0xf8 && (*p & 0x38) == 0) return p - string;
+     break;
+     /* Check for leading 0xfe or 0xff, and then for 1111 1100, xx00 00xx */
+     case 5:
+     if (c == 0xfe || c == 0xff ||
+        (c == 0xfc && (*p & 0x3c) == 0)) return p - string;
+     break;
+     }
+   /* Check for valid bytes after the 2nd, if any; all must start 10 */
+   while (--ab > 0)
      {
      if ((*(++p) & 0xc0) != 0x80) return p - string;
-     length--;
      }
    }
-Line 3798 
 Returns:       pointer to compiled data
+Line 4093 
 Returns:       pointer to compiled data
                 with errorptr and erroroffset set
  */
- pcre *
+ EXPORT pcre *
  pcre_compile(const char *pattern, int options, const char **errorptr,
    int *erroroffset, const unsigned char *tables)
  {
-Line 4207 
 while ((c = *(++ptr)) != 0)
+Line 4502 
 while ((c = *(++ptr)) != 0)
        {
        length += 33;
-       /* A repeat needs either 1 or 5 bytes. */
+       /* A repeat needs either 1 or 5 bytes. If it is a possessive quantifier,
+       we also need extra for wrapping the whole thing in a sub-pattern. */
        if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2))
          {
-Line 4217 
 while ((c = *(++ptr)) != 0)
+Line 4513 
 while ((c = *(++ptr)) != 0)
            (min == 1 && max == -1))
              length++;
          else length += 5;
-         if (ptr[1] == '?') ptr++;
+         if (ptr[1] == '+')
+           {
+           ptr++;
+           length += 2 + 2*LINK_SIZE;
+           }
+         else if (ptr[1] == '?') ptr++;
          }
        }
      continue;
-Line 4858 
 if (re->options != 0)
+Line 5159 
 if (re->options != 0)
  if ((re->options & PCRE_FIRSTSET) != 0)
    {
    int ch = re->first_byte & 255;
-   char *caseless = ((re->first_byte & REQ_CASELESS) == 0)? "" : " (caseless)";
+   const char *caseless = ((re->first_byte & REQ_CASELESS) == 0)? "" : " (caseless)";
    if (isprint(ch)) printf("First char = %c%s\n", ch, caseless);
      else printf("First char = \\x%02x%s\n", ch, caseless);
    }
-Line 4866 
 if ((re->options & PCRE_FIRSTSET) != 0)
+Line 5167 
 if ((re->options & PCRE_FIRSTSET) != 0)
  if ((re->options & PCRE_REQCHSET) != 0)
    {
    int ch = re->req_byte & 255;
-   char *caseless = ((re->req_byte & REQ_CASELESS) == 0)? "" : " (caseless)";
+   const char *caseless = ((re->req_byte & REQ_CASELESS) == 0)? "" : " (caseless)";
    if (isprint(ch)) printf("Req char = %c%s\n", ch, caseless);
      else printf("Req char = \\x%02x%s\n", ch, caseless);
    }
-Line 5000 
 return negated;   /* char was not found
+Line 5301 
 return negated;   /* char was not found
  #endif
+ /***************************************************************************
+ ****************************************************************************
+                    RECURSION IN THE match() FUNCTION
+ The match() function is highly recursive. Some regular expressions can cause
+ it to recurse thousands of times. I was writing for Unix, so I just let it
+ call itself recursively. This uses the stack for saving everything that has
+ to be saved for a recursive call. On Unix, the stack can be large, and this
+ works fine.
+ It turns out that on non-Unix systems there are problems with programs that
+ use a lot of stack. (This despite the fact that every last chip has oodles
+ of memory these days, and techniques for extending the stack have been known
+ for decades.) So....
+ There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
+ calls by keeping local variables that need to be preserved in blocks of memory
+ obtained from malloc instead instead of on the stack. Macros are used to
+ achieve this so that the actual code doesn't look very different to what it
+ always used to.
+ ****************************************************************************
+ ***************************************************************************/
+ /* These versions of the macros use the stack, as normal */
+ #ifndef NO_RECURSE
+ #define REGISTER register
+ #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) rx = match(ra,rb,rc,rd,re,rf,rg)
+ #define RRETURN(ra) return ra
+ #else
+ /* These versions of the macros manage a private stack on the heap. Note
+ that the rd argument of RMATCH isn't actually used. It's the md argument of
+ match(), which never actually changes. */
+ #define REGISTER
+ #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\
+   {\
+   heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
+   if (setjmp(frame->Xwhere) == 0)\
+     {\
+     newframe->Xeptr = ra;\
+     newframe->Xecode = rb;\
+     newframe->Xoffset_top = rc;\
+     newframe->Xims = re;\
+     newframe->Xeptrb = rf;\
+     newframe->Xflags = rg;\
+     newframe->Xprevframe = frame;\
+     frame = newframe;\
+     DPRINTF(("restarting from line %d\n", __LINE__));\
+     goto HEAP_RECURSE;\
+     }\
+   else\
+     {\
+     DPRINTF(("longjumped back to line %d\n", __LINE__));\
+     frame = md->thisframe;\
+     rx = frame->Xresult;\
+     }\
+   }
+ #define RRETURN(ra)\
+   {\
+   heapframe *newframe = frame;\
+   frame = newframe->Xprevframe;\
+   (pcre_stack_free)(newframe);\
+   if (frame != NULL)\
+     {\
+     frame->Xresult = ra;\
+     md->thisframe = frame;\
+     longjmp(frame->Xwhere, 1);\
+     }\
+   return ra;\
+   }
+ /* Structure for remembering the local variables in a private frame */
+ typedef struct heapframe {
+   struct heapframe *Xprevframe;
+   /* Function arguments that may change */
+   const uschar *Xeptr;
+   const uschar *Xecode;
+   int Xoffset_top;
+   long int Xims;
+   eptrblock *Xeptrb;
+   int Xflags;
+   /* Function local variables */
+   const uschar *Xcallpat;
+   const uschar *Xcharptr;
+   const uschar *Xdata;
+   const uschar *Xlastptr;
+   const uschar *Xnext;
+   const uschar *Xpp;
+   const uschar *Xprev;
+   const uschar *Xsaved_eptr;
+   recursion_info Xnew_recursive;
+   BOOL Xcur_is_word;
+   BOOL Xcondition;
+   BOOL Xminimize;
+   BOOL Xprev_is_word;
+   unsigned long int Xoriginal_ims;
+   int Xctype;
+   int Xfc;
+   int Xfi;
+   int Xlength;
+   int Xmax;
+   int Xmin;
+   int Xnumber;
+   int Xoffset;
+   int Xop;
+   int Xsave_capture_last;
+   int Xsave_offset1, Xsave_offset2, Xsave_offset3;
+   int Xstacksave[REC_STACK_SAVE_MAX];
+   eptrblock Xnewptrb;
+   /* Place to pass back result, and where to jump back to */
+   int  Xresult;
+   jmp_buf Xwhere;
+ } heapframe;
+ #endif
+ /***************************************************************************
+ ***************************************************************************/
  /*************************************************
-Line 5037 
 Returns:       MATCH_MATCH if matched
+Line 5478 
 Returns:       MATCH_MATCH if matched
  */
  static int
- match(register const uschar *eptr, register const uschar *ecode,
+ match(REGISTER const uschar *eptr, REGISTER const uschar *ecode,
    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
    int flags)
  {
- unsigned long int original_ims = ims;   /* Save for resetting on ')' */
+ /* These variables do not need to be preserved over recursion in this function,
- register int rrc;
+ so they can be ordinary variables in all cases. Mark them with "register"
+ because they are used a lot in loops. */
+ register int rrc;    /* Returns from recursive calls */
+ register int i;      /* Used for loops not involving calls to RMATCH() */
+ register int c;      /* Character values not kept over RMATCH() calls */
+ /* When recursion is not being used, all "local" variables that have to be
+ preserved over calls to RMATCH() are part of a "frame" which is obtained from
+ heap storage. Set up the top-level frame here; others are obtained from the
+ heap whenever RMATCH() does a "recursion". See the macro definitions above. */
+ #ifdef NO_RECURSE
+ heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
+ frame->Xprevframe = NULL;            /* Marks the top level */
+ /* Copy in the original argument variables */
+ frame->Xeptr = eptr;
+ frame->Xecode = ecode;
+ frame->Xoffset_top = offset_top;
+ frame->Xims = ims;
+ frame->Xeptrb = eptrb;
+ frame->Xflags = flags;
+ /* This is where control jumps back to to effect "recursion" */
+ HEAP_RECURSE:
+ /* Macros make the argument variables come from the current frame */
+ #define eptr               frame->Xeptr
+ #define ecode              frame->Xecode
+ #define offset_top         frame->Xoffset_top
+ #define ims                frame->Xims
+ #define eptrb              frame->Xeptrb
+ #define flags              frame->Xflags
+ /* Ditto for the local variables */
+ #define callpat            frame->Xcallpat
+ #define charptr            frame->Xcharptr
+ #define data               frame->Xdata
+ #define lastptr            frame->Xlastptr
+ #define next               frame->Xnext
+ #define pp                 frame->Xpp
+ #define prev               frame->Xprev
+ #define saved_eptr         frame->Xsaved_eptr
+ #define new_recursive      frame->Xnew_recursive
+ #define cur_is_word        frame->Xcur_is_word
+ #define condition          frame->Xcondition
+ #define minimize           frame->Xminimize
+ #define prev_is_word       frame->Xprev_is_word
+ #define original_ims       frame->Xoriginal_ims
+ #define ctype              frame->Xctype
+ #define fc                 frame->Xfc
+ #define fi                 frame->Xfi
+ #define length             frame->Xlength
+ #define max                frame->Xmax
+ #define min                frame->Xmin
+ #define number             frame->Xnumber
+ #define offset             frame->Xoffset
+ #define op                 frame->Xop
+ #define save_capture_last  frame->Xsave_capture_last
+ #define save_offset1       frame->Xsave_offset1
+ #define save_offset2       frame->Xsave_offset2
+ #define save_offset3       frame->Xsave_offset3
+ #define stacksave          frame->Xstacksave
+ #define newptrb            frame->Xnewptrb
+ /* When recursion is being used, local variables are allocated on the stack and
+ get preserved during recursion in the normal way. In this environment, fi and
+ i, and fc and c, can be the same variables. */
+ #else
+ #define fi i
+ #define fc c
+ const uschar *callpat;             /* Many of these variables are used ony */
+ const uschar *charptr;             /* small blocks of the code. My normal  */
+ const uschar *data;                /* style of coding would have declared  */
+ const uschar *lastptr;             /* them within each of those blocks.    */
+ const uschar *next;                /* However, in order to accommodate the */
+ const uschar *pp;                  /* version of this code that uses an    */
+ const uschar *prev;                /* external "stack" implemented on the  */
+ const uschar *saved_eptr;          /* heap, it is easier to declare them   */
+                                    /* all here, so the declarations can    */
+ recursion_info new_recursive;      /* be cut out in a block. The only      */
+                                    /* declarations within blocks below are */
+ BOOL cur_is_word;                  /* for variables that do not have to    */
+ BOOL condition;                    /* be preserved over a recursive call   */
+ BOOL minimize;                     /* to RMATCH().                         */
+ BOOL prev_is_word;
+ unsigned long int original_ims;
+ int ctype;
+ int length;
+ int max;
+ int min;
+ int number;
+ int offset;
+ int op;
+ int save_capture_last;
+ int save_offset1, save_offset2, save_offset3;
+ int stacksave[REC_STACK_SAVE_MAX];
  eptrblock newptrb;
+ #endif
+ /* OK, now we can get on with the real code of the function. Recursion is
+ specified by the macros RMATCH and RRETURN. When NO_RECURSE is *not* defined,
+ these just turn into a recursive call to match() and a "return", respectively.
+ However, RMATCH isn't like a function call because it's quite a complicated
+ macro. It has to be used in one particular way. This shouldn't, however, impact
+ performance when true recursion is being used. */
+ if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
- if (md->match_call_count++ >= md->match_limit) return PCRE_ERROR_MATCHLIMIT;
+ original_ims = ims;    /* Save for resetting on ')' */
  /* 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. */
+ this stack. */
  if ((flags & match_isgroup) != 0)
    {
-   newptrb.prev = eptrb;
+   newptrb.epb_prev = eptrb;
-   newptrb.saved_eptr = eptr;
+   newptrb.epb_saved_eptr = eptr;
    eptrb = &newptrb;
    }
-Line 5063 
 if ((flags & match_isgroup) != 0)
+Line 5626 
 if ((flags & match_isgroup) != 0)
  for (;;)
    {
-   int op = (int)*ecode;
+   op = *ecode;
-   int min, max, ctype;
+   minimize = FALSE;
-   register int i;
-   register int c;
-   BOOL minimize = FALSE;
    /* Opening capturing bracket. If there is space in the offset vector, save
    the current subject position in the working slot at the top of the vector. We
-Line 5085 
 for (;;)
+Line 5645 
 for (;;)
    if (op > OP_BRA)
      {
-     int offset;
+     number = op - OP_BRA;
-     int number = op - OP_BRA;
      /* For extended extraction brackets (large number), we have to fish out the
      number from a dummy opcode at the start. */
-Line 5103 
 for (;;)
+Line 5662 
 for (;;)
      if (offset < md->offset_max)
        {
-       int save_offset1 = md->offset_vector[offset];
+       save_offset1 = md->offset_vector[offset];
-       int save_offset2 = md->offset_vector[offset+1];
+       save_offset2 = md->offset_vector[offset+1];
-       int save_offset3 = md->offset_vector[md->offset_end - number];
+       save_offset3 = md->offset_vector[md->offset_end - number];
-       int save_capture_last = md->capture_last;
+       save_capture_last = md->capture_last;
        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
        do
          {
-         if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
+         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
-               eptrb, match_isgroup)) != MATCH_NOMATCH) return rrc;
+           match_isgroup);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          }
-Line 5126 
 for (;;)
+Line 5686 
 for (;;)
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
        }
      /* Insufficient room for saving captured contents */
-Line 5142 
 for (;;)
+Line 5702 
 for (;;)
      DPRINTF(("start bracket 0\n"));
      do
        {
-       if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
-         match_isgroup)) != MATCH_NOMATCH) return rrc;
+         match_isgroup);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      while (*ecode == OP_ALT);
      DPRINTF(("bracket 0 failed\n"));
-     return MATCH_NOMATCH;
+     RRETURN(MATCH_NOMATCH);
      /* Conditional group: compilation checked that there are no more than
      two branches. If the condition is false, skipping the first branch takes us
-Line 5158 
 for (;;)
+Line 5719 
 for (;;)
      case OP_COND:
      if (ecode[LINK_SIZE+1] == OP_CREF) /* Condition extract or recurse test */
        {
-       int offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
+       offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
-       BOOL condition = (offset == CREF_RECURSE * 2)?
+       condition = (offset == CREF_RECURSE * 2)?
          (md->recursive != NULL) :
          (offset < offset_top && md->offset_vector[offset] >= 0);
-       return match(eptr, ecode + (condition?
+       RMATCH(rrc, eptr, ecode + (condition?
          (LINK_SIZE + 4) : (LINK_SIZE + 1 + GET(ecode, 1))),
          offset_top, md, ims, eptrb, match_isgroup);
+       RRETURN(rrc);
        }
      /* The condition is an assertion. Call match() to evaluate it - setting
-Line 5172 
 for (;;)
+Line 5734 
 for (;;)
      else
        {
-       if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
-           match_condassert | match_isgroup)) == MATCH_MATCH)
+           match_condassert | match_isgroup);
+       if (rrc == MATCH_MATCH)
          {
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE+2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH) return rrc;
+       else if (rrc != MATCH_NOMATCH)
+         {
+         RRETURN(rrc);         /* Need braces because of following else */
+         }
        else ecode += GET(ecode, 1);
-       return match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
          match_isgroup);
+       RRETURN(rrc);
        }
      /* Control never reaches here */
-Line 5201 
 for (;;)
+Line 5768 
 for (;;)
        {
        recursion_info *rec = md->recursive;
        DPRINTF(("Hit the end in a (?0) recursion\n"));
-       md->recursive = rec->prev;
+       md->recursive = rec->prevrec;
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
        md->start_match = rec->save_start;
-Line 5213 
 for (;;)
+Line 5780 
 for (;;)
      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
      string - backtracking will then try other alternatives, if any. */
-     if (md->notempty && eptr == md->start_match) return MATCH_NOMATCH;
+     if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);
      md->end_match_ptr = eptr;          /* Record where we ended */
      md->end_offset_top = offset_top;   /* and how many extracts were taken */
-     return MATCH_MATCH;
+     RRETURN(MATCH_MATCH);
      /* Change option settings */
-Line 5236 
 for (;;)
+Line 5803 
 for (;;)
      case OP_ASSERTBACK:
      do
        {
-       if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
-         match_isgroup)) == MATCH_MATCH) break;
+         match_isgroup);
-       if (rrc != MATCH_NOMATCH) return rrc;
+       if (rrc == MATCH_MATCH) break;
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      while (*ecode == OP_ALT);
-     if (*ecode == OP_KET) return MATCH_NOMATCH;
+     if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
      /* If checking an assertion for a condition, return MATCH_MATCH. */
-     if ((flags & match_condassert) != 0) return MATCH_MATCH;
+     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
      /* Continue from after the assertion, updating the offsets high water
      mark, since extracts may have been taken during the assertion. */
-Line 5262 
 for (;;)
+Line 5830 
 for (;;)
      case OP_ASSERTBACK_NOT:
      do
        {
-       if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
-         match_isgroup)) == MATCH_MATCH) return MATCH_NOMATCH;
+         match_isgroup);
-       if (rrc != MATCH_NOMATCH) return rrc;
+       if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-     if ((flags & match_condassert) != 0) return MATCH_MATCH;
+     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
      ecode += 1 + LINK_SIZE;
      continue;
-Line 5287 
 for (;;)
+Line 5856 
 for (;;)
        for (i = 0; i < c; i++)
          {
          eptr--;
-         if (eptr < md->start_subject) return MATCH_NOMATCH;
+         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr)
          }
        }
-Line 5298 
 for (;;)
+Line 5867 
 for (;;)
        {
        eptr -= GET(ecode,1);
-       if (eptr < md->start_subject) return MATCH_NOMATCH;
+       if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
        }
      /* Skip to next op code */
-Line 5324 
 for (;;)
+Line 5893 
 for (;;)
        cb.capture_top      = offset_top/2;
        cb.capture_last     = md->capture_last;
        cb.callout_data     = md->callout_data;
-       if ((rrc = (*pcre_callout)(&cb)) > 0) return MATCH_NOMATCH;
+       if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
-       if (rrc < 0) return rrc;
+       if (rrc < 0) RRETURN(rrc);
        }
      ecode += 2;
      break;
      /* Recursion either matches the current regex, or some subexpression. The
      offset data is the offset to the starting bracket from the start of the
-     whole pattern. However, it is possible that a BRAZERO was inserted before
+     whole pattern. (This is so that it works from duplicated subpatterns.)
-     this bracket after we took the offset - we just skip it if encountered.
      If there are any capturing brackets started but not finished, we have to
      save their starting points and reinstate them after the recursion. However,
-Line 5352 
 for (;;)
+Line 5920 
 for (;;)
      case OP_RECURSE:
        {
-       int stacksave[REC_STACK_SAVE_MAX];
+       callpat = md->start_code + GET(ecode, 1);
-       recursion_info new_recursive;
-       const uschar *callpat = md->start_code + GET(ecode, 1);
-       if (*callpat == OP_BRAZERO) callpat++;
        new_recursive.group_num = *callpat - OP_BRA;
        /* For extended extraction brackets (large number), we have to fish out
-Line 5368 
 for (;;)
+Line 5931 
 for (;;)
        /* Add to "recursing stack" */
-       new_recursive.prev = md->recursive;
+       new_recursive.prevrec = md->recursive;
        md->recursive = &new_recursive;
        /* Find where to continue from afterwards */
-Line 5385 
 for (;;)
+Line 5948 
 for (;;)
          {
          new_recursive.offset_save =
            (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
-         if (new_recursive.offset_save == NULL) return PCRE_ERROR_NOMEMORY;
+         if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
          }
        memcpy(new_recursive.offset_save, md->offset_vector,
-Line 5399 
 for (;;)
+Line 5962 
 for (;;)
        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
        do
          {
-         if ((rrc = match(eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,
+         RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,
-             eptrb, match_isgroup)) == MATCH_MATCH)
+             eptrb, match_isgroup);
+         if (rrc == MATCH_MATCH)
            {
-           md->recursive = new_recursive.prev;
+           md->recursive = new_recursive.prevrec;
            if (new_recursive.offset_save != stacksave)
              (pcre_free)(new_recursive.offset_save);
-           return MATCH_MATCH;
+           RRETURN(MATCH_MATCH);
            }
-         else if (rrc != MATCH_NOMATCH) return rrc;
+         else if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->recursive = &new_recursive;
          memcpy(md->offset_vector, new_recursive.offset_save,
-Line 5417 
 for (;;)
+Line 5981 
 for (;;)
        while (*callpat == OP_ALT);
        DPRINTF(("Recursion didn't match\n"));
-       md->recursive = new_recursive.prev;
+       md->recursive = new_recursive.prevrec;
        if (new_recursive.offset_save != stacksave)
          (pcre_free)(new_recursive.offset_save);
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
        }
      /* Control never reaches here */
-Line 5433 
 for (;;)
+Line 5997 
 for (;;)
      case OP_ONCE:
        {
-       const uschar *prev = ecode;
+       prev = ecode;
-       const uschar *saved_eptr = eptr;
+       saved_eptr = eptr;
        do
          {
-         if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
+         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
-           eptrb, match_isgroup)) == MATCH_MATCH) break;
+           eptrb, match_isgroup);
-         if (rrc != MATCH_NOMATCH) return rrc;
+         if (rrc == MATCH_MATCH) break;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          ecode += GET(ecode,1);
          }
        while (*ecode == OP_ALT);
        /* If hit the end of the group (which could be repeated), fail */
-       if (*ecode != OP_ONCE && *ecode != OP_ALT) return MATCH_NOMATCH;
+       if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
        /* Continue as from after the assertion, updating the offsets high water
        mark, since extracts may have been taken. */
-Line 5482 
 for (;;)
+Line 6047 
 for (;;)
        if (*ecode == OP_KETRMIN)
          {
-         if ((rrc = match(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
+         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0);
-              eptrb, 0)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-         if ((rrc = match(eptr, prev, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
-              match_isgroup)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          }
        else  /* OP_KETRMAX */
          {
-         if ((rrc = match(eptr, prev, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
-              match_isgroup)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-         if ((rrc = match(eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
-)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          }
        }
-     return MATCH_NOMATCH;
+     RRETURN(MATCH_NOMATCH);
      /* An alternation is the end of a branch; scan along to find the end of the
      bracketed group and go to there. */
-Line 5512 
 for (;;)
+Line 6077 
 for (;;)
      case OP_BRAZERO:
        {
-       const uschar *next = ecode+1;
+       next = ecode+1;
-       if ((rrc = match(eptr, next, offset_top, md, ims, eptrb, match_isgroup))
+       RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);
-            != MATCH_NOMATCH) return rrc;
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        do next += GET(next,1); while (*next == OP_ALT);
        ecode = next + 1+LINK_SIZE;
        }
-Line 5522 
 for (;;)
+Line 6087 
 for (;;)
      case OP_BRAMINZERO:
        {
-       const uschar *next = ecode+1;
+       next = ecode+1;
        do next += GET(next,1); while (*next == OP_ALT);
-       if ((rrc = match(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb,
+       RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb,
-         match_isgroup)) != MATCH_NOMATCH) return rrc;
+         match_isgroup);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode++;
        }
      break;
-Line 5539 
 for (;;)
+Line 6105 
 for (;;)
      case OP_KETRMIN:
      case OP_KETRMAX:
        {
-       const uschar *prev = ecode - GET(ecode, 1);
+       prev = ecode - GET(ecode, 1);
-       const uschar *saved_eptr = eptrb->saved_eptr;
+       saved_eptr = eptrb->epb_saved_eptr;
+       /* Back up the stack of bracket start pointers. */
-       eptrb = eptrb->prev;    /* Back up the stack of bracket start pointers */
+       eptrb = eptrb->epb_prev;
        if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
            *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
-Line 5550 
 for (;;)
+Line 6118 
 for (;;)
          {
          md->end_match_ptr = eptr;      /* For ONCE */
          md->end_offset_top = offset_top;
-         return MATCH_MATCH;
+         RRETURN(MATCH_MATCH);
          }
        /* In all other cases except a conditional group we have to check the
-Line 5559 
 for (;;)
+Line 6127 
 for (;;)
        if (*prev != OP_COND)
          {
-         int offset;
+         number = *prev - OP_BRA;
-         int number = *prev - OP_BRA;
          /* For extended extraction brackets (large number), we have to fish out
          the number from a dummy opcode at the start. */
-Line 5596 
 for (;;)
+Line 6163 
 for (;;)
              {
              recursion_info *rec = md->recursive;
              DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
-             md->recursive = rec->prev;
+             md->recursive = rec->prevrec;
              md->start_match = rec->save_start;
              memcpy(md->offset_vector, rec->offset_save,
                rec->saved_max * sizeof(int));
-Line 5630 
 for (;;)
+Line 6197 
 for (;;)
        if (*ecode == OP_KETRMIN)
          {
-         if ((rrc = match(eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
-)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-         if ((rrc = match(eptr, prev, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
-              match_isgroup)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          }
        else  /* OP_KETRMAX */
          {
-         if ((rrc = match(eptr, prev, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
-              match_isgroup)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-         if ((rrc = match(eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
-)) != MATCH_NOMATCH) return rrc;
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          }
        }
-     return MATCH_NOMATCH;
+     RRETURN(MATCH_NOMATCH);
      /* Start of subject unless notbol, or after internal newline if multiline */
      case OP_CIRC:
-     if (md->notbol && eptr == md->start_subject) return MATCH_NOMATCH;
+     if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr != md->start_subject && eptr[-1] != NEWLINE)
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
        ecode++;
        break;
        }
-Line 5661 
 for (;;)
+Line 6229 
 for (;;)
      /* Start of subject assertion */
      case OP_SOD:
-     if (eptr != md->start_subject) return MATCH_NOMATCH;
+     if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      /* Start of match assertion */
      case OP_SOM:
-     if (eptr != md->start_subject + md->start_offset) return MATCH_NOMATCH;
+     if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 5679 
 for (;;)
+Line 6247 
 for (;;)
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr < md->end_subject)
-         { if (*eptr != NEWLINE) return MATCH_NOMATCH; }
+         { if (*eptr != NEWLINE) RRETURN(MATCH_NOMATCH); }
        else
-         { if (md->noteol) return MATCH_NOMATCH; }
+         { if (md->noteol) RRETURN(MATCH_NOMATCH); }
        ecode++;
        break;
        }
      else
        {
-       if (md->noteol) return MATCH_NOMATCH;
+       if (md->noteol) RRETURN(MATCH_NOMATCH);
        if (!md->endonly)
          {
          if (eptr < md->end_subject - 1 ||
             (eptr == md->end_subject - 1 && *eptr != NEWLINE))
-           return MATCH_NOMATCH;
+           RRETURN(MATCH_NOMATCH);
          ecode++;
          break;
          }
-Line 5702 
 for (;;)
+Line 6270 
 for (;;)
      /* End of subject assertion (\z) */
      case OP_EOD:
-     if (eptr < md->end_subject) return MATCH_NOMATCH;
+     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 5710 
 for (;;)
+Line 6278 
 for (;;)
      case OP_EODN:
      if (eptr < md->end_subject - 1 ||
-        (eptr == md->end_subject - 1 && *eptr != NEWLINE)) return MATCH_NOMATCH;
+        (eptr == md->end_subject - 1 && *eptr != NEWLINE)) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 5719 
 for (;;)
+Line 6287 
 for (;;)
      case OP_NOT_WORD_BOUNDARY:
      case OP_WORD_BOUNDARY:
        {
-       BOOL prev_is_word, cur_is_word;
        /* Find out if the previous and current characters are "word" characters.
        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
-Line 5730 
 for (;;)
+Line 6297 
 for (;;)
          {
          if (eptr == md->start_subject) prev_is_word = FALSE; else
            {
-           const uschar *lastptr = eptr - 1;
+           lastptr = eptr - 1;
            while((*lastptr & 0xc0) == 0x80) lastptr--;
            GETCHAR(c, lastptr);
            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
-Line 5757 
 for (;;)
+Line 6324 
 for (;;)
        if ((*ecode++ == OP_WORD_BOUNDARY)?
             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
        }
      break;
-Line 5765 
 for (;;)
+Line 6332 
 for (;;)
      case OP_ANY:
      if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == NEWLINE)
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
-     if (eptr++ >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
  #ifdef SUPPORT_UTF8
      if (md->utf8)
        while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
-Line 5778 
 for (;;)
+Line 6345 
 for (;;)
      any byte, even newline, independent of the setting of PCRE_DOTALL. */
      case OP_ANYBYTE:
-     if (eptr++ >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_NOT_DIGIT:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 5791 
 for (;;)
+Line 6358 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) != 0
         )
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_DIGIT:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 5804 
 for (;;)
+Line 6371 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) == 0
         )
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_NOT_WHITESPACE:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 5817 
 for (;;)
+Line 6384 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) != 0
         )
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_WHITESPACE:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 5830 
 for (;;)
+Line 6397 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) == 0
         )
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_NOT_WORDCHAR:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 5843 
 for (;;)
+Line 6410 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) != 0
         )
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_WORDCHAR:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 5856 
 for (;;)
+Line 6423 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) == 0
         )
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 5870 
 for (;;)
+Line 6437 
 for (;;)
      case OP_REF:
        {
-       int length;
+       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
-       int offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
        ecode += 3;                                     /* Advance past item */
        /* If the reference is unset, set the length to be longer than the amount
-Line 5910 
 for (;;)
+Line 6476 
 for (;;)
          break;
          default:               /* No repeat follows */
-         if (!match_ref(offset, eptr, length, md, ims)) return MATCH_NOMATCH;
+         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
          eptr += length;
          continue;              /* With the main loop */
          }
-Line 5926 
 for (;;)
+Line 6492 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (!match_ref(offset, eptr, length, md, ims)) return MATCH_NOMATCH;
+         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
          eptr += length;
          }
-Line 5939 
 for (;;)
+Line 6505 
 for (;;)
        if (minimize)
          {
-         for (i = min;; i++)
+         for (fi = min;; fi++)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (i >= max || !match_ref(offset, eptr, length, md, ims))
+           if (fi >= max || !match_ref(offset, eptr, length, md, ims))
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            eptr += length;
            }
          /* Control never gets here */
-Line 5954 
 for (;;)
+Line 6520 
 for (;;)
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
          for (i = min; i < max; i++)
            {
            if (!match_ref(offset, eptr, length, md, ims)) break;
-Line 5962 
 for (;;)
+Line 6528 
 for (;;)
            }
          while (eptr >= pp)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            eptr -= length;
            }
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 5985 
 for (;;)
+Line 6551 
 for (;;)
      case OP_NCLASS:
      case OP_CLASS:
        {
-       const uschar *data = ecode + 1;  /* Save for matching */
+       data = ecode + 1;                /* Save for matching */
        ecode += 33;                     /* Advance past the item */
        switch (*ecode)
-Line 6025 
 for (;;)
+Line 6591 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) return MATCH_NOMATCH;
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            if (c > 255)
              {
-             if (op == OP_CLASS) return MATCH_NOMATCH;
+             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
              }
            else
              {
-             if ((data[c/8] & (1 << (c&7))) == 0) return MATCH_NOMATCH;
+             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
              }
            }
          }
-Line 6043 
 for (;;)
+Line 6609 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) return MATCH_NOMATCH;
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            c = *eptr++;
-           if ((data[c/8] & (1 << (c&7))) == 0) return MATCH_NOMATCH;
+           if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
            }
          }
-Line 6063 
 for (;;)
+Line 6629 
 for (;;)
          /* UTF-8 mode */
          if (md->utf8)
            {
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (i >= max || eptr >= md->end_subject) return MATCH_NOMATCH;
+             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
              if (c > 255)
                {
-               if (op == OP_CLASS) return MATCH_NOMATCH;
+               if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
                }
              else
                {
-               if ((data[c/8] & (1 << (c&7))) == 0) return MATCH_NOMATCH;
+               if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
                }
              }
            }
-Line 6083 
 for (;;)
+Line 6649 
 for (;;)
  #endif
          /* Not UTF-8 mode */
            {
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (i >= max || eptr >= md->end_subject) return MATCH_NOMATCH;
+             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              c = *eptr++;
-             if ((data[c/8] & (1 << (c&7))) == 0) return MATCH_NOMATCH;
+             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 6099 
 for (;;)
+Line 6665 
 for (;;)
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
  #ifdef SUPPORT_UTF8
          /* UTF-8 mode */
-Line 6122 
 for (;;)
+Line 6688 
 for (;;)
              }
            for (;;)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
              }
-Line 6141 
 for (;;)
+Line 6707 
 for (;;)
              }
            while (eptr >= pp)
              {
-             if ((rrc = match(eptr--, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             eptr--;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              }
            }
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 6158 
 for (;;)
+Line 6725 
 for (;;)
  #ifdef SUPPORT_UTF8
      case OP_XCLASS:
        {
-       const uschar *data = ecode + 1 + LINK_SIZE;  /* Save for matching */
+       data = ecode + 1 + LINK_SIZE;                /* Save for matching */
        ecode += GET(ecode, 1);                      /* Advance past the item */
        switch (*ecode)
-Line 6194 
 for (;;)
+Line 6761 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (eptr >= md->end_subject) return MATCH_NOMATCH;
+         if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
          GETCHARINC(c, eptr);
-         if (!match_xclass(c, data)) return MATCH_NOMATCH;
+         if (!match_xclass(c, data)) RRETURN(MATCH_NOMATCH);
          }
        /* If max == min we can continue with the main loop without the
-Line 6209 
 for (;;)
+Line 6776 
 for (;;)
        if (minimize)
          {
-         for (i = min;; i++)
+         for (fi = min;; fi++)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (i >= max || eptr >= md->end_subject) return MATCH_NOMATCH;
+           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
-           if (!match_xclass(c, data)) return MATCH_NOMATCH;
+           if (!match_xclass(c, data)) RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 6224 
 for (;;)
+Line 6791 
 for (;;)
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
          for (i = min; i < max; i++)
            {
            int len = 1;
-Line 6235 
 for (;;)
+Line 6802 
 for (;;)
            }
          for(;;)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            BACKCHAR(eptr)
            }
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
-Line 6251 
 for (;;)
+Line 6818 
 for (;;)
      case OP_CHARS:
        {
-       register int length = ecode[1];
+       register int slen = ecode[1];
        ecode += 2;
  #ifdef DEBUG    /* Sigh. Some compilers never learn. */
-Line 6260 
 for (;;)
+Line 6827 
 for (;;)
        else
          {
          printf("matching subject ");
-         pchars(eptr, length, TRUE, md);
+         pchars(eptr, slen, TRUE, md);
          printf(" against pattern ");
          }
-       pchars(ecode, length, FALSE, md);
+       pchars(ecode, slen, FALSE, md);
        printf("\n");
  #endif
-       if (length > md->end_subject - eptr) return MATCH_NOMATCH;
+       if (slen > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
        if ((ims & PCRE_CASELESS) != 0)
          {
-         while (length-- > 0)
+         while (slen-- > 0)
            if (md->lcc[*ecode++] != md->lcc[*eptr++])
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
          }
        else
          {
-         while (length-- > 0) if (*ecode++ != *eptr++) return MATCH_NOMATCH;
+         while (slen-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
          }
        }
      break;
-Line 6316 
 for (;;)
+Line 6883 
 for (;;)
  #ifdef SUPPORT_UTF8
      if (md->utf8)
        {
-       int len = 1;
+       length = 1;
-       const uschar *charptr = ecode;
+       charptr = ecode;
-       GETCHARLEN(c, ecode, len);
+       GETCHARLEN(fc, ecode, length);
-       if (min * len > md->end_subject - eptr) return MATCH_NOMATCH;
+       if (min * length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
-       ecode += len;
+       ecode += length;
        /* Handle multibyte character matching specially here. There is no
        support for any kind of casing for multibyte characters. */
-       if (len > 1)
+       if (length > 1)
          {
          for (i = 1; i <= min; i++)
            {
-           if (memcmp(eptr, charptr, len) != 0) return MATCH_NOMATCH;
+           if (memcmp(eptr, charptr, length) != 0) RRETURN(MATCH_NOMATCH);
-           eptr += len;
+           eptr += length;
            }
          if (min == max) continue;
          if (minimize)
            {
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (i >= max ||
+             if (fi >= max ||
                  eptr >= md->end_subject ||
-                 memcmp(eptr, charptr, len) != 0)
+                 memcmp(eptr, charptr, length) != 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
-             eptr += len;
+             eptr += length;
              }
            /* Control never gets here */
            }
          else
            {
-           const uschar *pp = eptr;
+           pp = eptr;
            for (i = min; i < max; i++)
              {
-             if (eptr > md->end_subject - len ||
+             if (eptr > md->end_subject - length ||
-                 memcmp(eptr, charptr, len) != 0)
+                 memcmp(eptr, charptr, length) != 0)
                break;
-             eptr += len;
+             eptr += length;
              }
            while (eptr >= pp)
             {
-            if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                 MATCH_NOMATCH) return rrc;
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-            eptr -= len;
+            eptr -= length;
             }
-           return MATCH_NOMATCH;
+           RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
        /* If the length of a UTF-8 character is 1, we fall through here, and
        obey the code as for non-UTF-8 characters below, though in this case the
-       value of c will always be < 128. */
+       value of fc will always be < 128. */
        }
      else
  #endif
      /* When not in UTF-8 mode, load a single-byte character. */
        {
-       if (min > md->end_subject - eptr) return MATCH_NOMATCH;
+       if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
-       c = *ecode++;
+       fc = *ecode++;
        }
-     /* The value of c at this point is always less than 256, though we may or
+     /* The value of fc at this point is always less than 256, though we may or
      may not be in UTF-8 mode. The code is duplicated for the caseless and
      caseful cases, for speed, since matching characters is likely to be quite
      common. First, ensure the minimum number of matches are present. If min =
-Line 6392 
 for (;;)
+Line 6959 
 for (;;)
      matching character if failing, up to the maximum. Alternatively, if
      maximizing, find the maximum number of characters and work backwards. */
-     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", c, min, max,
+     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
        max, eptr));
      if ((ims & PCRE_CASELESS) != 0)
        {
-       c = md->lcc[c];
+       fc = md->lcc[fc];
        for (i = 1; i <= min; i++)
-         if (c != md->lcc[*eptr++]) return MATCH_NOMATCH;
+         if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
        if (min == max) continue;
        if (minimize)
          {
-         for (i = min;; i++)
+         for (fi = min;; fi++)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (i >= max || eptr >= md->end_subject ||
+           if (fi >= max || eptr >= md->end_subject ||
-               c != md->lcc[*eptr++])
+               fc != md->lcc[*eptr++])
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || c != md->lcc[*eptr]) break;
+           if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
            eptr++;
            }
          while (eptr >= pp)
-           if ((rrc = match(eptr--, ecode, offset_top, md, ims, eptrb, 0)) !=
+           {
-                MATCH_NOMATCH) return rrc;
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-         return MATCH_NOMATCH;
+           eptr--;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           }
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 6433 
 for (;;)
+Line 7003 
 for (;;)
      else
        {
-       for (i = 1; i <= min; i++) if (c != *eptr++) return MATCH_NOMATCH;
+       for (i = 1; i <= min; i++) if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
        if (min == max) continue;
        if (minimize)
          {
-         for (i = min;; i++)
+         for (fi = min;; fi++)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (i >= max || eptr >= md->end_subject || c != *eptr++)
+           if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || c != *eptr) break;
+           if (eptr >= md->end_subject || fc != *eptr) break;
            eptr++;
            }
          while (eptr >= pp)
-          if ((rrc = match(eptr--, ecode, offset_top, md, ims, eptrb, 0)) !=
+           {
-               MATCH_NOMATCH) return rrc;
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-         return MATCH_NOMATCH;
+           eptr--;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           }
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 6466 
 for (;;)
+Line 7039 
 for (;;)
      checking can be multibyte. */
      case OP_NOT:
-     if (eptr >= md->end_subject) return MATCH_NOMATCH;
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
      ecode++;
      GETCHARINCTEST(c, eptr);
      if ((ims & PCRE_CASELESS) != 0)
-Line 6475 
 for (;;)
+Line 7048 
 for (;;)
        if (c < 256)
  #endif
        c = md->lcc[c];
-       if (md->lcc[*ecode++] == c) return MATCH_NOMATCH;
+       if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);
        }
      else
        {
-       if (*ecode++ == c) return MATCH_NOMATCH;
+       if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
        }
      break;
-Line 6520 
 for (;;)
+Line 7093 
 for (;;)
      characters left in the subject. */
      REPEATNOTCHAR:
-     if (min > md->end_subject - eptr) return MATCH_NOMATCH;
+     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
-     c = *ecode++;
+     fc = *ecode++;
      /* The code is duplicated for the caseless and caseful cases, for speed,
      since matching characters is likely to be quite common. First, ensure the
-Line 6531 
 for (;;)
+Line 7104 
 for (;;)
      maximum. Alternatively, if maximizing, find the maximum number of
      characters and work backwards. */
-     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
+     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
        max, eptr));
      if ((ims & PCRE_CASELESS) != 0)
        {
-       c = md->lcc[c];
+       fc = md->lcc[fc];
  #ifdef SUPPORT_UTF8
        /* UTF-8 mode */
-Line 6547 
 for (;;)
+Line 7120 
 for (;;)
            {
            GETCHARINC(d, eptr);
            if (d < 256) d = md->lcc[d];
-           if (c == d) return MATCH_NOMATCH;
+           if (fc == d) RRETURN(MATCH_NOMATCH);
            }
          }
        else
-Line 6556 
 for (;;)
+Line 7129 
 for (;;)
        /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
-           if (c == md->lcc[*eptr++]) return MATCH_NOMATCH;
+           if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
          }
        if (min == max) continue;
-Line 6568 
 for (;;)
+Line 7141 
 for (;;)
          if (md->utf8)
            {
            register int d;
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              GETCHARINC(d, eptr);
              if (d < 256) d = md->lcc[d];
-             if (i >= max || eptr >= md->end_subject || c == d)
+             if (fi >= max || eptr >= md->end_subject || fc == d)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              }
            }
          else
  #endif
          /* Not UTF-8 mode */
            {
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (i >= max || eptr >= md->end_subject || c == md->lcc[*eptr++])
+             if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 6597 
 for (;;)
+Line 7170 
 for (;;)
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
  #ifdef SUPPORT_UTF8
          /* UTF-8 mode */
-Line 6610 
 for (;;)
+Line 7183 
 for (;;)
              if (eptr >= md->end_subject) break;
              GETCHARLEN(d, eptr, len);
              if (d < 256) d = md->lcc[d];
-             if (c == d) break;
+             if (fc == d) break;
              eptr += len;
              }
            for(;;)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
              }
-Line 6627 
 for (;;)
+Line 7200 
 for (;;)
            {
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || c == md->lcc[*eptr]) break;
+             if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
              eptr++;
              }
            while (eptr >= pp)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 6655 
 for (;;)
+Line 7228 
 for (;;)
          for (i = 1; i <= min; i++)
            {
            GETCHARINC(d, eptr);
-           if (c == d) return MATCH_NOMATCH;
+           if (fc == d) RRETURN(MATCH_NOMATCH);
            }
          }
        else
-Line 6663 
 for (;;)
+Line 7236 
 for (;;)
        /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
-           if (c == *eptr++) return MATCH_NOMATCH;
+           if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
          }
        if (min == max) continue;
-Line 6675 
 for (;;)
+Line 7248 
 for (;;)
          if (md->utf8)
            {
            register int d;
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              GETCHARINC(d, eptr);
-             if (i >= max || eptr >= md->end_subject || c == d)
+             if (fi >= max || eptr >= md->end_subject || fc == d)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              }
            }
          else
  #endif
          /* Not UTF-8 mode */
            {
-           for (i = min;; i++)
+           for (fi = min;; fi++)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                  MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (i >= max || eptr >= md->end_subject || c == *eptr++)
+             if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 6703 
 for (;;)
+Line 7276 
 for (;;)
        else
          {
-         const uschar *pp = eptr;
+         pp = eptr;
  #ifdef SUPPORT_UTF8
          /* UTF-8 mode */
-Line 6715 
 for (;;)
+Line 7288 
 for (;;)
              int len = 1;
              if (eptr >= md->end_subject) break;
              GETCHARLEN(d, eptr, len);
-             if (c == d) break;
+             if (fc == d) break;
              eptr += len;
              }
            for(;;)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                 MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
              }
-Line 6732 
 for (;;)
+Line 7305 
 for (;;)
            {
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || c == *eptr) break;
+             if (eptr >= md->end_subject || fc == *eptr) break;
              eptr++;
              }
            while (eptr >= pp)
              {
-             if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                 MATCH_NOMATCH) return rrc;
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         return MATCH_NOMATCH;
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 6792 
 for (;;)
+Line 7365 
 for (;;)
      UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
      is tidier. */
-     if (min > md->end_subject - eptr) return MATCH_NOMATCH;
+     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
      if (min > 0)
        {
  #ifdef SUPPORT_UTF8
-Line 6803 
 for (;;)
+Line 7376 
 for (;;)
            {
            if (eptr >= md->end_subject ||
               (*eptr++ == NEWLINE && (ims & PCRE_DOTALL) == 0))
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
          break;
-Line 6815 
 for (;;)
+Line 7388 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) return MATCH_NOMATCH;
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            }
          break;
-Line 6827 
 for (;;)
+Line 7400 
 for (;;)
            {
            if (eptr >= md->end_subject ||
               *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 6837 
 for (;;)
+Line 7410 
 for (;;)
            {
            if (eptr >= md->end_subject ||
               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
          break;
-Line 6847 
 for (;;)
+Line 7420 
 for (;;)
            {
            if (eptr >= md->end_subject ||
               *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 6857 
 for (;;)
+Line 7430 
 for (;;)
            {
            if (eptr >= md->end_subject ||
               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
          break;
-Line 6867 
 for (;;)
+Line 7440 
 for (;;)
            {
            if (eptr >= md->end_subject ||
               *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 6883 
 for (;;)
+Line 7456 
 for (;;)
          if ((ims & PCRE_DOTALL) == 0)
            {
            for (i = 1; i <= min; i++)
-             if (*eptr++ == NEWLINE) return MATCH_NOMATCH;
+             if (*eptr++ == NEWLINE) RRETURN(MATCH_NOMATCH);
            }
          else eptr += min;
          break;
-Line 6894 
 for (;;)
+Line 7467 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_digit) != 0) return MATCH_NOMATCH;
+           if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
          break;
          case OP_DIGIT:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_digit) == 0) return MATCH_NOMATCH;
+           if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
          break;
          case OP_NOT_WHITESPACE:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_space) != 0) return MATCH_NOMATCH;
+           if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
          break;
          case OP_WHITESPACE:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_space) == 0) return MATCH_NOMATCH;
+           if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
          break;
          case OP_NOT_WORDCHAR:
          for (i = 1; i <= min; i++)
            if ((md->ctypes[*eptr++] & ctype_word) != 0)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
          break;
          case OP_WORDCHAR:
          for (i = 1; i <= min; i++)
            if ((md->ctypes[*eptr++] & ctype_word) == 0)
-             return MATCH_NOMATCH;
+             RRETURN(MATCH_NOMATCH);
          break;
          }
        }
-Line 6939 
 for (;;)
+Line 7512 
 for (;;)
        /* UTF-8 mode */
        if (md->utf8)
          {
-         for (i = min;; i++)
+         for (fi = min;; fi++)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (i >= max || eptr >= md->end_subject) return MATCH_NOMATCH;
+           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            switch(ctype)
              {
              case OP_ANY:
-             if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) return MATCH_NOMATCH;
+             if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);
              break;
              case OP_ANYBYTE:
-Line 6957 
 for (;;)
+Line 7530 
 for (;;)
              case OP_NOT_DIGIT:
              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              break;
              case OP_DIGIT:
              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WHITESPACE:
              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              break;
              case OP_WHITESPACE:
              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WORDCHAR:
              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              break;
              case OP_WORDCHAR:
              if (c >= 256 && (md->ctypes[c] & ctype_word) == 0)
-               return MATCH_NOMATCH;
+               RRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 6991 
 for (;;)
+Line 7564 
 for (;;)
  #endif
        /* Not UTF-8 mode */
          {
-         for (i = min;; i++)
+         for (fi = min;; fi++)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (i >= max || eptr >= md->end_subject) return MATCH_NOMATCH;
+           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            c = *eptr++;
            switch(ctype)
              {
              case OP_ANY:
-             if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) return MATCH_NOMATCH;
+             if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);
              break;
              case OP_ANYBYTE:
              break;
              case OP_NOT_DIGIT:
-             if ((md->ctypes[c] & ctype_digit) != 0) return MATCH_NOMATCH;
+             if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
              break;
              case OP_DIGIT:
-             if ((md->ctypes[c] & ctype_digit) == 0) return MATCH_NOMATCH;
+             if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WHITESPACE:
-             if ((md->ctypes[c] & ctype_space) != 0) return MATCH_NOMATCH;
+             if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
              break;
              case OP_WHITESPACE:
-             if  ((md->ctypes[c] & ctype_space) == 0) return MATCH_NOMATCH;
+             if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WORDCHAR:
-             if ((md->ctypes[c] & ctype_word) != 0) return MATCH_NOMATCH;
+             if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
              break;
              case OP_WORDCHAR:
-             if ((md->ctypes[c] & ctype_word) == 0) return MATCH_NOMATCH;
+             if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 7041 
 for (;;)
+Line 7614 
 for (;;)
      else
        {
-       const uschar *pp = eptr;
+       pp = eptr;
  #ifdef SUPPORT_UTF8
        /* UTF-8 mode */
-Line 7178 
 for (;;)
+Line 7751 
 for (;;)
          for(;;)
            {
-           if ((rrc = match(eptr, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            BACKCHAR(eptr);
            }
-Line 7268 
 for (;;)
+Line 7841 
 for (;;)
          while (eptr >= pp)
            {
-           if ((rrc = match(eptr--, ecode, offset_top, md, ims, eptrb, 0)) !=
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-                MATCH_NOMATCH) return rrc;
+           eptr--;
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
          }
        /* Get here if we can't make it match with any permitted repetitions */
-       return MATCH_NOMATCH;
+       RRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 7286 
 for (;;)
+Line 7860 
 for (;;)
      default:
      DPRINTF(("Unknown opcode %d\n", *ecode));
-     return PCRE_ERROR_UNKNOWN_NODE;
+     RRETURN(PCRE_ERROR_UNKNOWN_NODE);
      }
    /* Do not stick any code in here without much thought; it is assumed
-Line 7298 
 for (;;)
+Line 7872 
 for (;;)
  }
+ /***************************************************************************
+ ****************************************************************************
+                    RECURSION IN THE match() FUNCTION
+ Undefine all the macros that were defined above to handle this. */
+ #ifdef NO_RECURSE
+ #undef eptr
+ #undef ecode
+ #undef offset_top
+ #undef ims
+ #undef eptrb
+ #undef flags
+ #undef callpat
+ #undef charptr
+ #undef data
+ #undef lastptr
+ #undef next
+ #undef pp
+ #undef prev
+ #undef saved_eptr
+ #undef new_recursive
+ #undef cur_is_word
+ #undef condition
+ #undef minimize
+ #undef prev_is_word
+ #undef original_ims
+ #undef ctype
+ #undef length
+ #undef max
+ #undef min
+ #undef number
+ #undef offset
+ #undef op
+ #undef save_capture_last
+ #undef save_offset1
+ #undef save_offset2
+ #undef save_offset3
+ #undef stacksave
+ #undef newptrb
+ #endif
+ /* These two are defined as macros in both cases */
+ #undef fc
+ #undef fi
+ /***************************************************************************
+ ***************************************************************************/
  /*************************************************
-Line 7324 
 Returns:          > 0 => success; value
+Line 7955 
 Returns:          > 0 => success; value
                   < -1 => some kind of unexpected problem
  */
- int
+ EXPORT int
  pcre_exec(const pcre *external_re, const pcre_extra *extra_data,
    const char *subject, int length, int start_offset, int options, int *offsets,
    int offsetcount)
-Line 7401 
 match_block.ctypes = re->tables + ctypes
+Line 8032 
 match_block.ctypes = re->tables + ctypes
  back the character offset. */
  #ifdef SUPPORT_UTF8
- if (match_block.utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
+ if (match_block.utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
-     valid_utf8((uschar *)subject, length) >= 0)
+   {
-   return PCRE_ERROR_BADUTF8;
+   if (valid_utf8((uschar *)subject, length) >= 0)
+     return PCRE_ERROR_BADUTF8;
+   if (start_offset > 0 && start_offset < length)
+     {
+     int tb = ((uschar *)subject)[start_offset];
+     if (tb > 127)
+       {
+       tb &= 0xc0;
+       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;
+       }
+     }
+   }
  #endif
  /* The ims options can vary during the matching as a result of the presence

 Legend:



Removed from v.72
 


changed lines


 
Added in v.73
 Legend:



Removed from v.72
 


changed lines


 
Added in v.73
-Removed from v.72
+Added in v.73

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12