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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 642 by ph10,
Thu Jul 28 18:59:40 2011 UTC
+revision 888 by ph10,
Tue Jan 17 14:43:23 2012 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2011 University of Cambridge
+            Copyright (c) 1997-2012 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 82 
 negative to avoid the external error cod
  #define MATCH_SKIP_ARG     (-993)
  #define MATCH_THEN         (-992)
- /* This is a convenience macro for code that occurs many times. */
- #define MRRETURN(ra) \
-   { \
-   md->mark = markptr; \
-   RRETURN(ra); \
-   }
  /* Maximum number of ints of offset to save on the stack for recursive calls.
  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
  because the offset vector is always a multiple of 3 long. */
-Line 121 
 Returns:     nothing
+Line 113 
 Returns:     nothing
  */
  static void
- pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
+ pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
  {
  unsigned int c;
  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
-Line 152 
 Returns:      < 0 if not matched, otherw
+Line 144 
 Returns:      < 0 if not matched, otherw
  */
  static int
- match_ref(int offset, register USPTR eptr, int length, match_data *md,
+ match_ref(int offset, register PCRE_PUCHAR eptr, int length, match_data *md,
    BOOL caseless)
  {
- USPTR eptr_start = eptr;
+ PCRE_PUCHAR eptr_start = eptr;
- register USPTR p = md->start_subject + md->offset_vector[offset];
+ register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
  #ifdef PCRE_DEBUG
  if (eptr >= md->end_subject)
-Line 181 
 ASCII characters. */
+Line 173 
 ASCII characters. */
  if (caseless)
    {
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
  #ifdef SUPPORT_UCP
-   if (md->utf8)
+   if (md->utf)
      {
      /* Match characters up to the end of the reference. NOTE: the number of
      bytes matched may differ, because there are some characters whose upper and
-Line 193 
 if (caseless)
+Line 185 
 if (caseless)
      the latter. It is important, therefore, to check the length along the
      reference, not along the subject (earlier code did this wrong). */
-     USPTR endptr = p + length;
+     PCRE_PUCHAR endptr = p + length;
      while (p < endptr)
        {
        int c, d;
-Line 212 
 if (caseless)
+Line 204 
 if (caseless)
      {
      if (eptr + length > md->end_subject) return -1;
      while (length-- > 0)
-       { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
+       {
+       if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;
+       p++;
+       eptr++;
+       }
      }
    }
-Line 225 
 else
+Line 221 
 else
    while (length-- > 0) if (*p++ != *eptr++) return -1;
    }
- return eptr - eptr_start;
+ return (int)(eptr - eptr_start);
  }
-Line 277 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 273 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
-        RM61,  RM62, RM63 };
+        RM61,  RM62, RM63, RM64, RM65, RM66 };
  /* These versions of the macros use the stack, as normal. There are debugging
  versions and production versions. Note that the "rw" argument of RMATCH isn't
-Line 290 
 actually used in this definition. */
+Line 286 
 actually used in this definition. */
  #define RMATCH(ra,rb,rc,rd,re,rw) \
    { \
    printf("match() called in line %d\n", __LINE__); \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1); \
+   rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 300 
 actually used in this definition. */
+Line 296 
 actually used in this definition. */
    }
  #else
  #define RMATCH(ra,rb,rc,rd,re,rw) \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1)
+   rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
-Line 315 
 argument of match(), which never changes
+Line 311 
 argument of match(), which never changes
  #define RMATCH(ra,rb,rc,rd,re,rw)\
    {\
-   heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
+   heapframe *newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
    frame->Xwhere = rw; \
    newframe->Xeptr = ra;\
    newframe->Xecode = rb;\
    newframe->Xmstart = mstart;\
-   newframe->Xmarkptr = markptr;\
    newframe->Xoffset_top = rc;\
    newframe->Xeptrb = re;\
    newframe->Xrdepth = frame->Xrdepth + 1;\
-Line 337 
 argument of match(), which never changes
+Line 332 
 argument of match(), which never changes
    {\
    heapframe *oldframe = frame;\
    frame = oldframe->Xprevframe;\
-   (pcre_stack_free)(oldframe);\
+   (PUBL(stack_free))(oldframe);\
    if (frame != NULL)\
      {\
      rrc = ra;\
-Line 354 
 typedef struct heapframe {
+Line 349 
 typedef struct heapframe {
    /* Function arguments that may change */
-   USPTR Xeptr;
+   PCRE_PUCHAR Xeptr;
-   const uschar *Xecode;
+   const pcre_uchar *Xecode;
-   USPTR Xmstart;
+   PCRE_PUCHAR Xmstart;
-   USPTR Xmarkptr;
    int Xoffset_top;
    eptrblock *Xeptrb;
    unsigned int Xrdepth;
    /* Function local variables */
-   USPTR Xcallpat;
+   PCRE_PUCHAR Xcallpat;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-   USPTR Xcharptr;
+   PCRE_PUCHAR Xcharptr;
  #endif
-   USPTR Xdata;
+   PCRE_PUCHAR Xdata;
-   USPTR Xnext;
+   PCRE_PUCHAR Xnext;
-   USPTR Xpp;
+   PCRE_PUCHAR Xpp;
-   USPTR Xprev;
+   PCRE_PUCHAR Xprev;
-   USPTR Xsaved_eptr;
+   PCRE_PUCHAR Xsaved_eptr;
    recursion_info Xnew_recursive;
-Line 385 
 typedef struct heapframe {
+Line 379 
 typedef struct heapframe {
    int Xprop_value;
    int Xprop_fail_result;
    int Xoclength;
-   uschar Xocchars[8];
+   pcre_uchar Xocchars[6];
  #endif
    int Xcodelink;
-Line 427 
 returns a negative (error) response, the
+Line 421 
 returns a negative (error) response, the
  same response. */
  /* These macros pack up tests that are used for partial matching, and which
- appears several times in the code. We set the "hit end" flag if the pointer is
+ appear several times in the code. We set the "hit end" flag if the pointer is
  at the end of the subject and also past the start of the subject (i.e.
  something has been matched). For hard partial matching, we then return
  immediately. The second one is used when we already know we are past the end of
-Line 438 
 the subject. */
+Line 432 
 the subject. */
        eptr > md->start_used_ptr) \
      { \
      md->hitend = TRUE; \
-     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
+     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
      }
  #define SCHECK_PARTIAL()\
    if (md->partial != 0 && eptr > md->start_used_ptr) \
      { \
      md->hitend = TRUE; \
-     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
+     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
      }
  /* Performance note: It might be tempting to extract commonly used fields from
- the md structure (e.g. utf8, end_subject) into individual variables to improve
+ the md structure (e.g. utf, end_subject) into individual variables to improve
  performance. Tests using gcc on a SPARC disproved this; in the first case, it
  made performance worse.
-Line 459 
 Arguments:
+Line 453 
 Arguments:
     ecode       pointer to current position in compiled code
     mstart      pointer to the current match start position (can be modified
                   by encountering \K)
-    markptr     pointer to the most recent MARK name, or NULL
     offset_top  current top pointer
     md          pointer to "static" info for the match
     eptrb       pointer to chain of blocks containing eptr at start of
-Line 474 
 Returns:       MATCH_MATCH if matched
+Line 467 
 Returns:       MATCH_MATCH if matched
  */
  static int
- match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
+ match(REGISTER PCRE_PUCHAR eptr, REGISTER const pcre_uchar *ecode,
-   const uschar *markptr, int offset_top, match_data *md, eptrblock *eptrb,
+   PCRE_PUCHAR mstart, int offset_top, match_data *md, eptrblock *eptrb,
    unsigned int rdepth)
  {
  /* These variables do not need to be preserved over recursion in this function,
-Line 485 
 so they can be ordinary variables in all
+Line 478 
 so they can be ordinary variables in all
  register int  rrc;         /* Returns from recursive calls */
  register int  i;           /* Used for loops not involving calls to RMATCH() */
  register unsigned int c;   /* Character values not kept over RMATCH() calls */
- register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
+ register BOOL utf;         /* Local copy of UTF flag for speed */
  BOOL minimize, possessive; /* Quantifier options */
  BOOL caseless;
-Line 497 
 heap storage. Set up the top-level frame
+Line 490 
 heap storage. Set up the top-level frame
  heap whenever RMATCH() does a "recursion". See the macro definitions above. */
  #ifdef NO_RECURSE
- heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
+ heapframe *frame = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));
  if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
  frame->Xprevframe = NULL;            /* Marks the top level */
-Line 506 
 frame->Xprevframe = NULL;            /*
+Line 499 
 frame->Xprevframe = NULL;            /*
  frame->Xeptr = eptr;
  frame->Xecode = ecode;
  frame->Xmstart = mstart;
- frame->Xmarkptr = markptr;
  frame->Xoffset_top = offset_top;
  frame->Xeptrb = eptrb;
  frame->Xrdepth = rdepth;
-Line 520 
 HEAP_RECURSE:
+Line 512 
 HEAP_RECURSE:
  #define eptr               frame->Xeptr
  #define ecode              frame->Xecode
  #define mstart             frame->Xmstart
- #define markptr            frame->Xmarkptr
  #define offset_top         frame->Xoffset_top
  #define eptrb              frame->Xeptrb
  #define rdepth             frame->Xrdepth
  /* Ditto for the local variables */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
  #define charptr            frame->Xcharptr
  #endif
  #define callpat            frame->Xcallpat
-Line 585 
 declarations can be cut out in a block.
+Line 576 
 declarations can be cut out in a block.
  below are for variables that do not have to be preserved over a recursive call
  to RMATCH(). */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- const uschar *charptr;
+ const pcre_uchar *charptr;
  #endif
- const uschar *callpat;
+ const pcre_uchar *callpat;
- const uschar *data;
+ const pcre_uchar *data;
- const uschar *next;
+ const pcre_uchar *next;
- USPTR         pp;
+ PCRE_PUCHAR       pp;
- const uschar *prev;
+ const pcre_uchar *prev;
- USPTR         saved_eptr;
+ PCRE_PUCHAR       saved_eptr;
  recursion_info new_recursive;
-Line 606 
 int prop_type;
+Line 597 
 int prop_type;
  int prop_value;
  int prop_fail_result;
  int oclength;
- uschar occhars[8];
+ pcre_uchar occhars[6];
  #endif
  int codelink;
-Line 634 
 the alternative names that are used. */
+Line 625 
 the alternative names that are used. */
  #define code_offset   codelink
  #define condassert    condition
  #define matched_once  prev_is_word
+ #define foc           number
+ #define save_mark     data
  /* These statements are here to stop the compiler complaining about unitialized
  variables. */
-Line 659 
 defined). However, RMATCH isn't like a f
+Line 652 
 defined). However, RMATCH isn't like a f
  complicated macro. It has to be used in one particular way. This shouldn't,
  however, impact performance when true recursion is being used. */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
- utf8 = md->utf8;       /* Local copy of the flag */
+ utf = md->utf;       /* Local copy of the flag */
  #else
- utf8 = FALSE;
+ utf = FALSE;
  #endif
  /* First check that we haven't called match() too many times, or that we
-Line 701 
 for (;;)
+Line 694 
 for (;;)
    switch(op)
      {
      case OP_MARK:
-     markptr = ecode + 2;
+     md->nomatch_mark = ecode + 2;
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+     md->mark = NULL;    /* In case previously set by assertion */
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
        eptrb, RM55);
+     if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
+          md->mark == NULL) md->mark = ecode + 2;
      /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
      argument, and we must check whether that argument matches this MARK's
-Line 712 
 for (;;)
+Line 708 
 for (;;)
      position and return MATCH_SKIP. Otherwise, pass back the return code
      unaltered. */
-     if (rrc == MATCH_SKIP_ARG &&
+     else if (rrc == MATCH_SKIP_ARG &&
-         strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
+         STRCMP_UC_UC(ecode + 2, md->start_match_ptr) == 0)
        {
        md->start_match_ptr = eptr;
        RRETURN(MATCH_SKIP);
        }
-     if (md->mark == NULL) md->mark = markptr;
      RRETURN(rrc);
      case OP_FAIL:
-     MRRETURN(MATCH_NOMATCH);
+     RRETURN(MATCH_NOMATCH);
      /* COMMIT overrides PRUNE, SKIP, and THEN */
      case OP_COMMIT:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
        eptrb, RM52);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
          rrc != MATCH_THEN)
        RRETURN(rrc);
-     MRRETURN(MATCH_COMMIT);
+     RRETURN(MATCH_COMMIT);
      /* PRUNE overrides THEN */
      case OP_PRUNE:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
        eptrb, RM51);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
-     MRRETURN(MATCH_PRUNE);
+     RRETURN(MATCH_PRUNE);
      case OP_PRUNE_ARG:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+     md->nomatch_mark = ecode + 2;
+     md->mark = NULL;    /* In case previously set by assertion */
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
        eptrb, RM56);
+     if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
+          md->mark == NULL) md->mark = ecode + 2;
      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
-     md->mark = ecode + 2;
      RRETURN(MATCH_PRUNE);
      /* SKIP overrides PRUNE and THEN */
      case OP_SKIP:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
        eptrb, RM53);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
        RRETURN(rrc);
      md->start_match_ptr = eptr;   /* Pass back current position */
-     MRRETURN(MATCH_SKIP);
+     RRETURN(MATCH_SKIP);
+     /* Note that, for Perl compatibility, SKIP with an argument does NOT set
+     nomatch_mark. There is a flag that disables this opcode when re-matching a
+     pattern that ended with a SKIP for which there was not a matching MARK. */
      case OP_SKIP_ARG:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+     if (md->ignore_skip_arg)
+       {
+       ecode += PRIV(OP_lengths)[*ecode] + ecode[1];
+       break;
+       }
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
        eptrb, RM57);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
        RRETURN(rrc);
      /* Pass back the current skip name by overloading md->start_match_ptr and
      returning the special MATCH_SKIP_ARG return code. This will either be
-     caught by a matching MARK, or get to the top, where it is treated the same
+     caught by a matching MARK, or get to the top, where it causes a rematch
-     as PRUNE. */
+     with the md->ignore_skip_arg flag set. */
      md->start_match_ptr = ecode + 2;
      RRETURN(MATCH_SKIP_ARG);
-     /* For THEN (and THEN_ARG) we pass back the address of the bracket or
+     /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
-     the alt that is at the start of the current branch. This makes it possible
+     the branch in which it occurs can be determined. Overload the start of
-     to skip back past alternatives that precede the THEN within the current
+     match pointer to do this. */
-     branch. */
      case OP_THEN:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
        eptrb, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->start_match_ptr = ecode;
-     MRRETURN(MATCH_THEN);
+     RRETURN(MATCH_THEN);
      case OP_THEN_ARG:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
+     md->nomatch_mark = ecode + 2;
-       offset_top, md, eptrb, RM58);
+     md->mark = NULL;    /* In case previously set by assertion */
+     RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top,
+       md, eptrb, RM58);
+     if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
+          md->mark == NULL) md->mark = ecode + 2;
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->start_match_ptr = ecode;
-     md->mark = ecode + LINK_SIZE + 2;
      RRETURN(MATCH_THEN);
+     /* Handle an atomic group that does not contain any capturing parentheses.
+     This can be handled like an assertion. Prior to 8.13, all atomic groups
+     were handled this way. In 8.13, the code was changed as below for ONCE, so
+     that backups pass through the group and thereby reset captured values.
+     However, this uses a lot more stack, so in 8.20, atomic groups that do not
+     contain any captures generate OP_ONCE_NC, which can be handled in the old,
+     less stack intensive way.
+     Check the alternative branches in turn - the matching won't pass the KET
+     for this kind of subpattern. If any one branch matches, we carry on as at
+     the end of a normal bracket, leaving the subject pointer, but resetting
+     the start-of-match value in case it was changed by \K. */
+     case OP_ONCE_NC:
+     prev = ecode;
+     saved_eptr = eptr;
+     save_mark = md->mark;
+     do
+       {
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
+       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
+         {
+         mstart = md->start_match_ptr;
+         break;
+         }
+       if (rrc == MATCH_THEN)
+         {
+         next = ecode + GET(ecode,1);
+         if (md->start_match_ptr < next &&
+             (*ecode == OP_ALT || *next == OP_ALT))
+           rrc = MATCH_NOMATCH;
+         }
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       ecode += GET(ecode,1);
+       md->mark = save_mark;
+       }
+     while (*ecode == OP_ALT);
+     /* If hit the end of the group (which could be repeated), fail */
+     if (*ecode != OP_ONCE_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
+     /* Continue as from after the group, updating the offsets high water
+     mark, since extracts may have been taken. */
+     do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
+     offset_top = md->end_offset_top;
+     eptr = md->end_match_ptr;
+     /* For a non-repeating ket, just continue at this level. This also
+     happens for a repeating ket if no characters were matched in the group.
+     This is the forcible breaking of infinite loops as implemented in Perl
+.005. */
+     if (*ecode == OP_KET || eptr == saved_eptr)
+       {
+       ecode += 1+LINK_SIZE;
+       break;
+       }
+     /* The repeating kets try the rest of the pattern or restart from the
+     preceding bracket, in the appropriate order. The second "call" of match()
+     uses tail recursion, to avoid using another stack frame. */
+     if (*ecode == OP_KETRMIN)
+       {
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       ecode = prev;
+       goto TAIL_RECURSE;
+       }
+     else  /* OP_KETRMAX */
+       {
+       md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       ecode += 1 + LINK_SIZE;
+       goto TAIL_RECURSE;
+       }
+     /* Control never gets here */
      /* Handle a capturing bracket, other than those that are possessive with an
      unlimited repeat. If there is space in the offset vector, save the current
      subject position in the working slot at the top of the vector. We mustn't
-Line 827 
 for (;;)
+Line 918 
 for (;;)
        save_offset2 = md->offset_vector[offset+1];
        save_offset3 = md->offset_vector[md->offset_end - number];
        save_capture_last = md->capture_last;
+       save_mark = md->mark;
        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
        md->offset_vector[md->offset_end - number] =
-Line 835 
 for (;;)
+Line 927 
 for (;;)
        for (;;)
          {
          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
            eptrb, RM1);
          if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */
-         if (rrc != MATCH_NOMATCH &&
-             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         /* If we backed up to a THEN, check whether it is within the current
-           RRETURN(rrc);
+         branch by comparing the address of the THEN that is passed back with
+         the end of the branch. If it is within the current branch, and the
+         branch is one of two or more alternatives (it either starts or ends
+         with OP_ALT), we have reached the limit of THEN's action, so convert
+         the return code to NOMATCH, which will cause normal backtracking to
+         happen from now on. Otherwise, THEN is passed back to an outer
+         alternative. This implements Perl's treatment of parenthesized groups,
+         where a group not containing | does not affect the current alternative,
+         that is, (X) is NOT the same as (X|(*F)). */
+         if (rrc == MATCH_THEN)
+           {
+           next = ecode + GET(ecode,1);
+           if (md->start_match_ptr < next &&
+               (*ecode == OP_ALT || *next == OP_ALT))
+             rrc = MATCH_NOMATCH;
+           }
+         /* Anything other than NOMATCH is passed back. */
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
+         md->mark = save_mark;
          if (*ecode != OP_ALT) break;
          }
-Line 851 
 for (;;)
+Line 964 
 for (;;)
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
-       /* At this point, rrc will be one of MATCH_ONCE, MATCH_NOMATCH, or
+       /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
-       MATCH_THEN. */
-       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
+       RRETURN(rrc);
-       RRETURN(((rrc == MATCH_ONCE)? MATCH_ONCE:MATCH_NOMATCH));
        }
      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
-Line 870 
 for (;;)
+Line 981 
 for (;;)
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* Non-capturing or atomic group, except for possessive with unlimited
-     repeat. Loop for all the alternatives. When we get to the final alternative
+     repeat and ONCE group with no captures. Loop for all the alternatives.
-     within the brackets, we used to return the result of a recursive call to
-     match() whatever happened so it was possible to reduce stack usage by
+     When we get to the final alternative within the brackets, we used to return
-     turning this into a tail recursion, except in the case of a possibly empty
+     the result of a recursive call to match() whatever happened so it was
-     group. However, now that there is the possiblity of (*THEN) occurring in
+     possible to reduce stack usage by turning this into a tail recursion,
-     the final alternative, this optimization is no longer possible.
+     except in the case of a possibly empty group. However, now that there is
+     the possiblity of (*THEN) occurring in the final alternative, this
+     optimization is no longer always possible.
+     We can optimize if we know there are no (*THEN)s in the pattern; at present
+     this is the best that can be done.
      MATCH_ONCE is returned when the end of an atomic group is successfully
      reached, but subsequent matching fails. It passes back up the tree (causing
-Line 892 
 for (;;)
+Line 1008 
 for (;;)
      for (;;)
        {
        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;
-       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
+       /* If this is not a possibly empty group, and there are no (*THEN)s in
+       the pattern, and this is the final alternative, optimize as described
+       above. */
+       else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
+         {
+         ecode += PRIV(OP_lengths)[*ecode];
+         goto TAIL_RECURSE;
+         }
+       /* In all other cases, we have to make another call to match(). */
+       save_mark = md->mark;
+       RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
          RM2);
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* See comment in the code for capturing groups above about handling
+       THEN. */
+       if (rrc == MATCH_THEN)
+         {
+         next = ecode + GET(ecode,1);
+         if (md->start_match_ptr < next &&
+             (*ecode == OP_ALT || *next == OP_ALT))
+           rrc = MATCH_NOMATCH;
+         }
+       if (rrc != MATCH_NOMATCH)
          {
          if (rrc == MATCH_ONCE)
            {
-           const uschar *scode = ecode;
+           const pcre_uchar *scode = ecode;
            if (*scode != OP_ONCE)           /* If not at start, find it */
              {
              while (*scode == OP_ALT) scode += GET(scode, 1);
-Line 910 
 for (;;)
+Line 1051 
 for (;;)
          RRETURN(rrc);
          }
        ecode += GET(ecode, 1);
+       md->mark = save_mark;
        if (*ecode != OP_ALT) break;
        }
-     if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
      RRETURN(MATCH_NOMATCH);
      /* Handle possessive capturing brackets with an unlimited repeat. We come
-Line 941 
 for (;;)
+Line 1083 
 for (;;)
      if (offset < md->offset_max)
        {
        matched_once = FALSE;
-       code_offset = ecode - md->start_code;
+       code_offset = (int)(ecode - md->start_code);
        save_offset1 = md->offset_vector[offset];
        save_offset2 = md->offset_vector[offset+1];
-Line 964 
 for (;;)
+Line 1106 
 for (;;)
          md->offset_vector[md->offset_end - number] =
            (int)(eptr - md->start_subject);
          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
            eptrb, RM63);
          if (rrc == MATCH_KETRPOS)
            {
-Line 975 
 for (;;)
+Line 1117 
 for (;;)
            matched_once = TRUE;
            continue;
            }
-         if (rrc != MATCH_NOMATCH &&
-             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         /* See comment in the code for capturing groups above about handling
-           RRETURN(rrc);
+         THEN. */
+         if (rrc == MATCH_THEN)
+           {
+           next = ecode + GET(ecode,1);
+           if (md->start_match_ptr < next &&
+               (*ecode == OP_ALT || *next == OP_ALT))
+             rrc = MATCH_NOMATCH;
+           }
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          if (*ecode != OP_ALT) break;
-Line 990 
 for (;;)
+Line 1142 
 for (;;)
          md->offset_vector[md->offset_end - number] = save_offset3;
          }
-       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
        if (allow_zero || matched_once)
          {
          ecode += 1 + LINK_SIZE;
-Line 1022 
 for (;;)
+Line 1173 
 for (;;)
      POSSESSIVE_NON_CAPTURE:
      matched_once = FALSE;
-     code_offset = ecode - md->start_code;
+     code_offset = (int)(ecode - md->start_code);
      for (;;)
        {
        if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
-       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
          eptrb, RM48);
        if (rrc == MATCH_KETRPOS)
          {
-Line 1037 
 for (;;)
+Line 1188 
 for (;;)
          matched_once = TRUE;
          continue;
          }
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* See comment in the code for capturing groups above about handling
-         RRETURN(rrc);
+       THEN. */
+       if (rrc == MATCH_THEN)
+         {
+         next = ecode + GET(ecode,1);
+         if (md->start_match_ptr < next &&
+             (*ecode == OP_ALT || *next == OP_ALT))
+           rrc = MATCH_NOMATCH;
+         }
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode, 1);
        if (*ecode != OP_ALT) break;
        }
-Line 1067 
 for (;;)
+Line 1228 
 for (;;)
      if (ecode[LINK_SIZE+1] == OP_CALLOUT)
        {
-       if (pcre_callout != NULL)
+       if (PUBL(callout) != NULL)
          {
-         pcre_callout_block cb;
+         PUBL(callout_block) cb;
-         cb.version          = 1;   /* Version 1 of the callout block */
+         cb.version          = 2;   /* Version 1 of the callout block */
          cb.callout_number   = ecode[LINK_SIZE+2];
          cb.offset_vector    = md->offset_vector;
+ #ifdef COMPILE_PCRE8
          cb.subject          = (PCRE_SPTR)md->start_subject;
+ #else
+         cb.subject          = (PCRE_SPTR16)md->start_subject;
+ #endif
          cb.subject_length   = (int)(md->end_subject - md->start_subject);
          cb.start_match      = (int)(mstart - md->start_subject);
          cb.current_position = (int)(eptr - md->start_subject);
-Line 1082 
 for (;;)
+Line 1247 
 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) MRRETURN(MATCH_NOMATCH);
+         cb.mark             = md->nomatch_mark;
+         if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
          if (rrc < 0) RRETURN(rrc);
          }
-       ecode += _pcre_OP_lengths[OP_CALLOUT];
+       ecode += PRIV(OP_lengths)[OP_CALLOUT];
        }
      condcode = ecode[LINK_SIZE+1];
-Line 1102 
 for (;;)
+Line 1268 
 for (;;)
        else
          {
          int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
-         condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
+         condition = (recno == RREF_ANY || recno == md->recursive->group_num);
          /* If the test is for recursion into a specific subpattern, and it is
          false, but the test was set up by name, scan the table to see if the
          name refers to any other numbers, and test them. The condition is true
          if any one is set. */
-         if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
+         if (!condition && condcode == OP_NRREF)
            {
-           uschar *slotA = md->name_table;
+           pcre_uchar *slotA = md->name_table;
            for (i = 0; i < md->name_count; i++)
              {
              if (GET2(slotA, 0) == recno) break;
-Line 1124 
 for (;;)
+Line 1290 
 for (;;)
            if (i < md->name_count)
              {
-             uschar *slotB = slotA;
+             pcre_uchar *slotB = slotA;
              while (slotB > md->name_table)
                {
                slotB -= md->name_entry_size;
-               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+               if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
                  {
                  condition = GET2(slotB, 0) == md->recursive->group_num;
                  if (condition) break;
-Line 1144 
 for (;;)
+Line 1310 
 for (;;)
                for (i++; i < md->name_count; i++)
                  {
                  slotB += md->name_entry_size;
-                 if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                 if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
                    {
                    condition = GET2(slotB, 0) == md->recursive->group_num;
                    if (condition) break;
-Line 1157 
 for (;;)
+Line 1323 
 for (;;)
          /* Chose branch according to the condition */
-         ecode += condition? 3 : GET(ecode, 1);
+         ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);
          }
        }
-Line 1174 
 for (;;)
+Line 1340 
 for (;;)
        if (!condition && condcode == OP_NCREF)
          {
          int refno = offset >> 1;
-         uschar *slotA = md->name_table;
+         pcre_uchar *slotA = md->name_table;
          for (i = 0; i < md->name_count; i++)
            {
-Line 1188 
 for (;;)
+Line 1354 
 for (;;)
          if (i < md->name_count)
            {
-           uschar *slotB = slotA;
+           pcre_uchar *slotB = slotA;
            while (slotB > md->name_table)
              {
              slotB -= md->name_entry_size;
-             if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+             if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
                {
                offset = GET2(slotB, 0) << 1;
                condition = offset < offset_top &&
-Line 1210 
 for (;;)
+Line 1376 
 for (;;)
              for (i++; i < md->name_count; i++)
                {
                slotB += md->name_entry_size;
-               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+               if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
                  {
                  offset = GET2(slotB, 0) << 1;
                  condition = offset < offset_top &&
-Line 1225 
 for (;;)
+Line 1391 
 for (;;)
        /* Chose branch according to the condition */
-       ecode += condition? 3 : GET(ecode, 1);
+       ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);
        }
      else if (condcode == OP_DEF)     /* DEFINE - always false */
-Line 1250 
 for (;;)
+Line 1416 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH &&
-               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
+       assertion; it is therefore treated as NOMATCH. */
+       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
-Line 1262 
 for (;;)
+Line 1431 
 for (;;)
          }
        }
-     /* We are now at the branch that is to be obeyed. As there is only one,
+     /* We are now at the branch that is to be obeyed. As there is only one, can
-     we used to use tail recursion to avoid using another stack frame, except
+     use tail recursion to avoid using another stack frame, except when there is
-     when there was unlimited repeat of a possibly empty group. However, that
+     unlimited repeat of a possibly empty group. In the latter case, a recursive
-     strategy no longer works because of the possibilty of (*THEN) being
+     call to match() is always required, unless the second alternative doesn't
-     encountered in the branch. A recursive call to match() is always required,
+     exist, in which case we can just plough on. Note that, for compatibility
-     unless the second alternative doesn't exist, in which case we can just
+     with Perl, the | in a conditional group is NOT treated as creating two
-     plough on. */
+     alternatives. If a THEN is encountered in the branch, it propagates out to
+     the enclosing alternative (unless nested in a deeper set of alternatives,
+     of course). */
      if (condition || *ecode == OP_ALT)
        {
-       if (op == OP_SCOND) md->match_function_type = MATCH_CBEGROUP;
+       if (op != OP_SCOND)
+         {
+         ecode += 1 + LINK_SIZE;
+         goto TAIL_RECURSE;
+         }
+       md->match_function_type = MATCH_CBEGROUP;
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
-       if (rrc == MATCH_THEN && md->start_match_ptr == ecode)
-         rrc = MATCH_NOMATCH;
        RRETURN(rrc);
        }
-     else                         /* Condition false & no alternative */
+      /* Condition false & no alternative; continue after the group. */
+     else
        {
        ecode += 1 + LINK_SIZE;
        }
-Line 1305 
 for (;;)
+Line 1483 
 for (;;)
        md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
        if (offset_top <= offset) offset_top = offset + 2;
        }
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      break;
-Line 1325 
 for (;;)
+Line 1503 
 for (;;)
           (md->notempty ||
             (md->notempty_atstart &&
               mstart == md->start_subject + md->start_offset)))
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      /* Otherwise, we have a match. */
-Line 1334 
 for (;;)
+Line 1512 
 for (;;)
      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
      /* For some reason, the macros don't work properly if an expression is
-     given as the argument to MRRETURN when the heap is in use. */
+     given as the argument to RRETURN when the heap is in use. */
      rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
-     MRRETURN(rrc);
+     RRETURN(rrc);
      /* Assertion brackets. Check the alternative branches in turn - the
      matching won't pass the KET for an assertion. If any one branch matches,
-Line 1352 
 for (;;)
+Line 1530 
 for (;;)
      case OP_ASSERT:
      case OP_ASSERTBACK:
+     save_mark = md->mark;
      if (md->match_function_type == MATCH_CONDASSERT)
        {
        condassert = TRUE;
-Line 1365 
 for (;;)
+Line 1544 
 for (;;)
        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
          {
          mstart = md->start_match_ptr;   /* In case \K reset it */
-         markptr = md->mark;
          break;
          }
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* PCRE does not allow THEN to escape beyond an assertion; it is treated
-         RRETURN(rrc);
+       as NOMATCH. */
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode, 1);
+       md->mark = save_mark;
        }
      while (*ecode == OP_ALT);
-     if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
+     if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
      /* If checking an assertion for a condition, return MATCH_MATCH. */
-Line 1395 
 for (;;)
+Line 1576 
 for (;;)
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK_NOT:
+     save_mark = md->mark;
      if (md->match_function_type == MATCH_CONDASSERT)
        {
        condassert = TRUE;
-Line 1405 
 for (;;)
+Line 1587 
 for (;;)
      do
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
-       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
+       md->mark = save_mark;
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
          {
          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
          break;
          }
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* PCRE does not allow THEN to escape beyond an assertion; it is treated
-         RRETURN(rrc);
+       as NOMATCH. */
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 1429 
 for (;;)
+Line 1614 
 for (;;)
      back a number of characters, not bytes. */
      case OP_REVERSE:
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (utf8)
+     if (utf)
        {
        i = GET(ecode, 1);
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr);
          }
        }
-Line 1447 
 for (;;)
+Line 1632 
 for (;;)
        {
        eptr -= GET(ecode, 1);
-       if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
+       if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
        }
      /* Save the earliest consulted character, then skip to next op code */
-Line 1461 
 for (;;)
+Line 1646 
 for (;;)
      function is able to force a failure. */
      case OP_CALLOUT:
-     if (pcre_callout != NULL)
+     if (PUBL(callout) != NULL)
        {
-       pcre_callout_block cb;
+       PUBL(callout_block) cb;
-       cb.version          = 1;   /* Version 1 of the callout block */
+       cb.version          = 2;   /* Version 1 of the callout block */
        cb.callout_number   = ecode[1];
        cb.offset_vector    = md->offset_vector;
+ #ifdef COMPILE_PCRE8
        cb.subject          = (PCRE_SPTR)md->start_subject;
+ #else
+       cb.subject          = (PCRE_SPTR16)md->start_subject;
+ #endif
        cb.subject_length   = (int)(md->end_subject - md->start_subject);
        cb.start_match      = (int)(mstart - md->start_subject);
        cb.current_position = (int)(eptr - md->start_subject);
-Line 1476 
 for (;;)
+Line 1665 
 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) MRRETURN(MATCH_NOMATCH);
+       cb.mark             = md->nomatch_mark;
+       if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
        if (rrc < 0) RRETURN(rrc);
        }
      ecode += 2 + 2*LINK_SIZE;
-Line 1503 
 for (;;)
+Line 1693 
 for (;;)
        {
        recursion_info *ri;
        int recno;
        callpat = md->start_code + GET(ecode, 1);
        recno = (callpat == md->start_code)? 0 :
          GET2(callpat, 1 + LINK_SIZE);
        /* Check for repeating a recursion without advancing the subject pointer.
        This should catch convoluted mutual recursions. (Some simple cases are
        caught at compile time.) */
        for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
          if (recno == ri->group_num && eptr == ri->subject_position)
            RRETURN(PCRE_ERROR_RECURSELOOP);
        /* Add to "recursing stack" */
-Line 1535 
 for (;;)
+Line 1725 
 for (;;)
        else
          {
          new_recursive.offset_save =
-           (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
+           (int *)(PUBL(malloc))(new_recursive.saved_max * sizeof(int));
          if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
          }
        memcpy(new_recursive.offset_save, md->offset_vector,
-Line 1550 
 for (;;)
+Line 1740 
 for (;;)
        do
          {
          if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
-         RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
+         RMATCH(eptr, callpat + PRIV(OP_lengths)[*callpat], offset_top,
            md, eptrb, RM6);
          memcpy(md->offset_vector, new_recursive.offset_save,
              new_recursive.saved_max * sizeof(int));
+         md->recursive = new_recursive.prevrec;
          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
            {
            DPRINTF(("Recursion matched\n"));
-           md->recursive = new_recursive.prevrec;
            if (new_recursive.offset_save != stacksave)
-             (pcre_free)(new_recursive.offset_save);
+             (PUBL(free))(new_recursive.offset_save);
            /* Set where we got to in the subject, and reset the start in case
            it was changed by \K. This *is* propagated back out of a recursion,
-Line 1569 
 for (;;)
+Line 1759 
 for (;;)
            mstart = md->start_match_ptr;
            goto RECURSION_MATCHED;        /* Exit loop; end processing */
            }
-         else if (rrc != MATCH_NOMATCH &&
-                 (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         /* PCRE does not allow THEN to escape beyond a recursion; it is treated
+         as NOMATCH. */
+         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
            if (new_recursive.offset_save != stacksave)
-             (pcre_free)(new_recursive.offset_save);
+             (PUBL(free))(new_recursive.offset_save);
            RRETURN(rrc);
            }
-Line 1586 
 for (;;)
+Line 1779 
 for (;;)
        DPRINTF(("Recursion didn't match\n"));
        md->recursive = new_recursive.prevrec;
        if (new_recursive.offset_save != stacksave)
-         (pcre_free)(new_recursive.offset_save);
+         (PUBL(free))(new_recursive.offset_save);
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      RECURSION_MATCHED:
-Line 1656 
 for (;;)
+Line 1849 
 for (;;)
        }
      else saved_eptr = NULL;
-     /* If we are at the end of an assertion group, stop matching and return
+     /* If we are at the end of an assertion group or a non-capturing atomic
-     MATCH_MATCH, but record the current high water mark for use by positive
+     group, stop matching and return MATCH_MATCH, but record the current high
-     assertions. We also need to record the match start in case it was changed
+     water mark for use by positive assertions. We also need to record the match
-     by \K. */
+     start in case it was changed by \K. */
-     if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
+     if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
-         *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT)
+          *prev == OP_ONCE_NC)
        {
-       md->end_match_ptr = eptr;      /* For ONCE */
+       md->end_match_ptr = eptr;      /* For ONCE_NC */
        md->end_offset_top = offset_top;
        md->start_match_ptr = mstart;
-       MRRETURN(MATCH_MATCH);         /* Sets md->mark */
+       RRETURN(MATCH_MATCH);         /* Sets md->mark */
        }
      /* For capturing groups we have to check the group number back at the start
-Line 1732 
 for (;;)
+Line 1925 
 for (;;)
      /* For an ordinary non-repeating ket, just continue at this level. This
      also happens for a repeating ket if no characters were matched in the
      group. This is the forcible breaking of infinite loops as implemented in
-     Perl 5.005. For a non-repeating atomic group, establish a backup point by
+     Perl 5.005. For a non-repeating atomic group that includes captures,
-     processing the rest of the pattern at a lower level. If this results in a
+     establish a backup point by processing the rest of the pattern at a lower
-     NOMATCH return, pass MATCH_ONCE back to the original OP_ONCE level, thereby
+     level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
-     bypassing intermediate backup points, but resetting any captures that
+     original OP_ONCE level, thereby bypassing intermediate backup points, but
-     happened along the way. */
+     resetting any captures that happened along the way. */
      if (*ecode == OP_KET || eptr == saved_eptr)
        {
-Line 1809 
 for (;;)
+Line 2002 
 for (;;)
      /* Not multiline mode: start of subject assertion, unless notbol. */
      case OP_CIRC:
-     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
+     if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
      /* Start of subject assertion */
      case OP_SOD:
-     if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
+     if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      /* Multiline mode: start of subject unless notbol, or after any newline. */
      case OP_CIRCM:
-     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
+     if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
      if (eptr != md->start_subject &&
          (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      /* Start of match assertion */
      case OP_SOM:
-     if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
+     if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1847 
 for (;;)
+Line 2040 
 for (;;)
      case OP_DOLLM:
      if (eptr < md->end_subject)
-       { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
+       { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
      else
        {
-       if (md->noteol) MRRETURN(MATCH_NOMATCH);
+       if (md->noteol) RRETURN(MATCH_NOMATCH);
        SCHECK_PARTIAL();
        }
      ecode++;
-Line 1860 
 for (;;)
+Line 2053 
 for (;;)
      subject unless noteol is set. */
      case OP_DOLL:
-     if (md->noteol) MRRETURN(MATCH_NOMATCH);
+     if (md->noteol) RRETURN(MATCH_NOMATCH);
      if (!md->endonly) goto ASSERT_NL_OR_EOS;
      /* ... else fall through for endonly */
-Line 1868 
 for (;;)
+Line 2061 
 for (;;)
      /* End of subject assertion (\z) */
      case OP_EOD:
-     if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
+     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
      SCHECK_PARTIAL();
      ecode++;
      break;
-Line 1879 
 for (;;)
+Line 2072 
 for (;;)
      ASSERT_NL_OR_EOS:
      if (eptr < md->end_subject &&
          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      /* Either at end of string or \n before end. */
-Line 1898 
 for (;;)
+Line 2091 
 for (;;)
        be "non-word" characters. Remember the earliest consulted character for
        partial matching. */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-       if (utf8)
+       if (utf)
          {
          /* Get status of previous character */
          if (eptr == md->start_subject) prev_is_word = FALSE; else
            {
-           USPTR lastptr = eptr - 1;
+           PCRE_PUCHAR lastptr = eptr - 1;
-           while((*lastptr & 0xc0) == 0x80) lastptr--;
+           BACKCHAR(lastptr);
            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
            GETCHAR(c, lastptr);
  #ifdef SUPPORT_UCP
-Line 1971 
 for (;;)
+Line 2164 
 for (;;)
              }
            else
  #endif
-           prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+           prev_is_word = MAX_255(eptr[-1])
+             && ((md->ctypes[eptr[-1]] & ctype_word) != 0);
            }
          /* Get status of next character */
-Line 1994 
 for (;;)
+Line 2188 
 for (;;)
            }
          else
  #endif
-         cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
+         cur_is_word = MAX_255(*eptr)
+           && ((md->ctypes[*eptr] & ctype_word) != 0);
          }
        /* Now see if the situation is what we want */
        if ((*ecode++ == OP_WORD_BOUNDARY)?
             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
        }
      break;
      /* Match a single character type; inline for speed */
      case OP_ANY:
-     if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
+     if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
      /* Fall through */
      case OP_ALLANY:
-     if (eptr++ >= md->end_subject)
+     if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
-       {
+       {                            /* not be updated before SCHECK_PARTIAL. */
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
-     if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+     eptr++;
+ #ifdef SUPPORT_UTF
+     if (utf) ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+ #endif
      ecode++;
      break;
-Line 2025 
 for (;;)
+Line 2223 
 for (;;)
      any byte, even newline, independent of the setting of PCRE_DOTALL. */
      case OP_ANYBYTE:
-     if (eptr++ >= md->end_subject)
+     if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
-       {
+       {                            /* not be updated before SCHECK_PARTIAL. */
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
+     eptr++;
      ecode++;
      break;
-Line 2037 
 for (;;)
+Line 2236 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
         c < 256 &&
  #endif
         (md->ctypes[c] & ctype_digit) != 0
         )
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 2054 
 for (;;)
+Line 2253 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
-        c >= 256 ||
+        c > 255 ||
  #endif
         (md->ctypes[c] & ctype_digit) == 0
         )
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 2071 
 for (;;)
+Line 2270 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
         c < 256 &&
  #endif
         (md->ctypes[c] & ctype_space) != 0
         )
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 2088 
 for (;;)
+Line 2287 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
-        c >= 256 ||
+        c > 255 ||
  #endif
         (md->ctypes[c] & ctype_space) == 0
         )
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 2105 
 for (;;)
+Line 2304 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
         c < 256 &&
  #endif
         (md->ctypes[c] & ctype_word) != 0
         )
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 2122 
 for (;;)
+Line 2321 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
-        c >= 256 ||
+        c > 255 ||
  #endif
         (md->ctypes[c] & ctype_word) == 0
         )
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 2139 
 for (;;)
+Line 2338 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: MRRETURN(MATCH_NOMATCH);
+       default: RRETURN(MATCH_NOMATCH);
        case 0x000d:
        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
-Line 2158 
 for (;;)
+Line 2357 
 for (;;)
        case 0x0085:
        case 0x2028:
        case 0x2029:
-       if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
+       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
        break;
        }
      ecode++;
-Line 2168 
 for (;;)
+Line 2367 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 2193 
 for (;;)
+Line 2392 
 for (;;)
        case 0x202f:    /* NARROW NO-BREAK SPACE */
        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
        case 0x3000:    /* IDEOGRAPHIC SPACE */
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 2202 
 for (;;)
+Line 2401 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: MRRETURN(MATCH_NOMATCH);
+       default: RRETURN(MATCH_NOMATCH);
        case 0x09:      /* HT */
        case 0x20:      /* SPACE */
        case 0xa0:      /* NBSP */
-Line 2236 
 for (;;)
+Line 2435 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 2249 
 for (;;)
+Line 2448 
 for (;;)
        case 0x85:      /* NEL */
        case 0x2028:    /* LINE SEPARATOR */
        case 0x2029:    /* PARAGRAPH SEPARATOR */
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 2258 
 for (;;)
+Line 2457 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: MRRETURN(MATCH_NOMATCH);
+       default: RRETURN(MATCH_NOMATCH);
        case 0x0a:      /* LF */
        case 0x0b:      /* VT */
        case 0x0c:      /* FF */
-Line 2285 
 for (;;)
+Line 2484 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
        {
-Line 2294 
 for (;;)
+Line 2493 
 for (;;)
        switch(ecode[1])
          {
          case PT_ANY:
-         if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
+         if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
          break;
          case PT_LAMP:
          if ((prop->chartype == ucp_Lu ||
               prop->chartype == ucp_Ll ||
               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          case PT_GC:
-         if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
+         if ((ecode[2] != PRIV(ucp_gentype)[prop->chartype]) == (op == OP_PROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          case PT_PC:
          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          case PT_SC:
          if ((ecode[2] != prop->script) == (op == OP_PROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          /* These are specials */
          case PT_ALNUM:
-         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+         if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-              _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
+              PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          case PT_SPACE:    /* Perl space */
-         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+         if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
                 == (op == OP_NOTPROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          case PT_PXSPACE:  /* POSIX space */
-         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+         if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
               c == CHAR_FF || c == CHAR_CR)
                 == (op == OP_NOTPROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          case PT_WORD:
-         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+         if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-              _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+              PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
          break;
          /* This should never occur */
-Line 2366 
 for (;;)
+Line 2565 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
-     if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
+     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
      while (eptr < md->end_subject)
        {
        int len = 1;
-       if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
+       if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
        if (UCD_CATEGORY(c) != ucp_M) break;
        eptr += len;
        }
-Line 2394 
 for (;;)
+Line 2593 
 for (;;)
      case OP_REFI:
      caseless = op == OP_REFI;
      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      /* If the reference is unset, there are two possibilities:
-Line 2434 
 for (;;)
+Line 2633 
 for (;;)
        case OP_CRMINRANGE:
        minimize = (*ecode == OP_CRMINRANGE);
        min = GET2(ecode, 1);
-       max = GET2(ecode, 3);
+       max = GET2(ecode, 1 + IMM2_SIZE);
        if (max == 0) max = INT_MAX;
-       ecode += 5;
+       ecode += 1 + 2 * IMM2_SIZE;
        break;
        default:               /* No repeat follows */
        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
          {
          CHECK_PARTIAL();
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        eptr += length;
        continue;              /* With the main loop */
        }
      /* Handle repeated back references. If the length of the reference is
-     zero, just continue with the main loop. */
+     zero, just continue with the main loop. If the length is negative, it
+     means the reference is unset in non-Java-compatible mode. If the minimum is
+     zero, we can continue at the same level without recursion. For any other
+     minimum, carrying on will result in NOMATCH. */
      if (length == 0) continue;
+     if (length < 0 && min == 0) continue;
      /* First, ensure the minimum number of matches are present. We get back
      the length of the reference string explicitly rather than passing the
-Line 2464 
 for (;;)
+Line 2667 
 for (;;)
        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
          {
          CHECK_PARTIAL();
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        eptr += slength;
        }
-Line 2483 
 for (;;)
+Line 2686 
 for (;;)
          int slength;
          RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-         if (fi >= max) MRRETURN(MATCH_NOMATCH);
+         if (fi >= max) RRETURN(MATCH_NOMATCH);
          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
            {
            CHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          eptr += slength;
          }
-Line 2515 
 for (;;)
+Line 2718 
 for (;;)
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          eptr -= length;
          }
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 2533 
 for (;;)
+Line 2736 
 for (;;)
      case OP_NCLASS:
      case OP_CLASS:
        {
+       /* The data variable is saved across frames, so the byte map needs to
+       be stored there. */
+ #define BYTE_MAP ((pcre_uint8 *)data)
        data = ecode + 1;                /* Save for matching */
-       ecode += 33;                     /* Advance past the item */
+       ecode += 1 + (32 / sizeof(pcre_uchar)); /* Advance past the item */
        switch (*ecode)
          {
-Line 2555 
 for (;;)
+Line 2761 
 for (;;)
          case OP_CRMINRANGE:
          minimize = (*ecode == OP_CRMINRANGE);
          min = GET2(ecode, 1);
-         max = GET2(ecode, 3);
+         max = GET2(ecode, 1 + IMM2_SIZE);
          if (max == 0) max = INT_MAX;
-         ecode += 5;
+         ecode += 1 + 2 * IMM2_SIZE;
          break;
          default:               /* No repeat follows */
-Line 2567 
 for (;;)
+Line 2773 
 for (;;)
        /* First, ensure the minimum number of matches are present. */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-       /* UTF-8 mode */
+       if (utf)
-       if (utf8)
          {
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            if (c > 255)
              {
-             if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
+             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
              }
            else
-             {
+             if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
-             if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
-             }
            }
          }
        else
  #endif
-       /* Not UTF-8 mode */
+       /* Not UTF mode */
          {
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            c = *eptr++;
-           if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
+ #ifndef COMPILE_PCRE8
+           if (c > 255)
+             {
+             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+             }
+           else
+ #endif
+             if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
            }
          }
-Line 2615 
 for (;;)
+Line 2825 
 for (;;)
        if (minimize)
          {
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            for (fi = min;; fi++)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINC(c, eptr);
              if (c > 255)
                {
-               if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
+               if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
                }
              else
-               {
+               if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
-               if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
-               }
              }
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (fi = min;; fi++)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              c = *eptr++;
-             if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
+ #ifndef COMPILE_PCRE8
+             if (c > 255)
+               {
+               if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+               }
+             else
+ #endif
+               if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 2667 
 for (;;)
+Line 2881 
 for (;;)
          {
          pp = eptr;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            for (i = min; i < max; i++)
              {
-Line 2685 
 for (;;)
+Line 2898 
 for (;;)
                if (op == OP_CLASS) break;
                }
              else
-               {
+               if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
-               if ((data[c/8] & (1 << (c&7))) == 0) break;
-               }
              eptr += len;
              }
            for (;;)
-Line 2700 
 for (;;)
+Line 2911 
 for (;;)
            }
          else
  #endif
-           /* Not UTF-8 mode */
+           /* Not UTF mode */
            {
            for (i = min; i < max; i++)
              {
-Line 2710 
 for (;;)
+Line 2921 
 for (;;)
                break;
                }
              c = *eptr;
-             if ((data[c/8] & (1 << (c&7))) == 0) break;
+ #ifndef COMPILE_PCRE8
+             if (c > 255)
+               {
+               if (op == OP_CLASS) break;
+               }
+             else
+ #endif
+               if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
              eptr++;
              }
            while (eptr >= pp)
-Line 2721 
 for (;;)
+Line 2939 
 for (;;)
              }
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
+ #undef BYTE_MAP
        }
      /* Control never gets here */
-Line 2731 
 for (;;)
+Line 2950 
 for (;;)
      when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
      mode, because Unicode properties are supported in non-UTF-8 mode. */
- #ifdef SUPPORT_UTF8
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
      case OP_XCLASS:
        {
        data = ecode + 1 + LINK_SIZE;                /* Save for matching */
-Line 2756 
 for (;;)
+Line 2975 
 for (;;)
          case OP_CRMINRANGE:
          minimize = (*ecode == OP_CRMINRANGE);
          min = GET2(ecode, 1);
-         max = GET2(ecode, 3);
+         max = GET2(ecode, 1 + IMM2_SIZE);
          if (max == 0) max = INT_MAX;
-         ecode += 5;
+         ecode += 1 + 2 * IMM2_SIZE;
          break;
          default:               /* No repeat follows */
-Line 2773 
 for (;;)
+Line 2992 
 for (;;)
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          GETCHARINCTEST(c, eptr);
-         if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
+         if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
          }
        /* If max == min we can continue with the main loop without the
-Line 2793 
 for (;;)
+Line 3012 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) MRRETURN(MATCH_NOMATCH);
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
-           if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
+           if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2818 
 for (;;)
+Line 3037 
 for (;;)
              SCHECK_PARTIAL();
              break;
              }
+ #ifdef SUPPORT_UTF
            GETCHARLENTEST(c, eptr, len);
-           if (!_pcre_xclass(c, data)) break;
+ #else
+           c = *eptr;
+ #endif
+           if (!PRIV(xclass)(c, data, utf)) break;
            eptr += len;
            }
          for(;;)
-Line 2827 
 for (;;)
+Line 3050 
 for (;;)
            RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
-           if (utf8) BACKCHAR(eptr);
+ #ifdef SUPPORT_UTF
+           if (utf) BACKCHAR(eptr);
+ #endif
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
-Line 2839 
 for (;;)
+Line 3064 
 for (;;)
      /* Match a single character, casefully */
      case OP_CHAR:
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (utf8)
+     if (utf)
        {
        length = 1;
        ecode++;
-Line 2848 
 for (;;)
+Line 3073 
 for (;;)
        if (length > md->end_subject - eptr)
          {
          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
-       while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
+       while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
        }
      else
  #endif
+     /* Not UTF mode */
-     /* Non-UTF-8 mode */
        {
        if (md->end_subject - eptr < 1)
          {
          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
-       if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
+       if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
      break;
-     /* Match a single character, caselessly */
+     /* Match a single character, caselessly. If we are at the end of the
+     subject, give up immediately. */
      case OP_CHARI:
- #ifdef SUPPORT_UTF8
+     if (eptr >= md->end_subject)
-     if (utf8)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
+ #ifdef SUPPORT_UTF
+     if (utf)
        {
        length = 1;
        ecode++;
        GETCHARLEN(fc, ecode, length);
-       if (length > md->end_subject - eptr)
-         {
-         CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
-         MRRETURN(MATCH_NOMATCH);
-         }
        /* If the pattern character's value is < 128, we have only one byte, and
-       can use the fast lookup table. */
+       we know that its other case must also be one byte long, so we can use the
+       fast lookup table. We know that there is at least one byte left in the
+       subject. */
        if (fc < 128)
          {
-         if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+         if (md->lcc[fc]
+             != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);
+         ecode++;
+         eptr++;
          }
-       /* Otherwise we must pick up the subject character */
+       /* Otherwise we must pick up the subject character. Note that we cannot
+       use the value of "length" to check for sufficient bytes left, because the
+       other case of the character may have more or fewer bytes.  */
        else
          {
-Line 2907 
 for (;;)
+Line 3139 
 for (;;)
  #ifdef SUPPORT_UCP
            if (dc != UCD_OTHERCASE(fc))
  #endif
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
            }
          }
        }
      else
- #endif   /* SUPPORT_UTF8 */
+ #endif   /* SUPPORT_UTF */
-     /* Non-UTF-8 mode */
+     /* Not UTF mode */
        {
-       if (md->end_subject - eptr < 1)
+       if (TABLE_GET(ecode[1], md->lcc, ecode[1])
-         {
+           != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);
-         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
+       eptr++;
-         MRRETURN(MATCH_NOMATCH);
-         }
-       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
      break;
-Line 2931 
 for (;;)
+Line 3160 
 for (;;)
      case OP_EXACT:
      case OP_EXACTI:
      min = max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATCHAR;
      case OP_POSUPTO:
-Line 2946 
 for (;;)
+Line 3175 
 for (;;)
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATCHAR;
      case OP_POSSTAR:
-Line 2994 
 for (;;)
+Line 3223 
 for (;;)
      /* Common code for all repeated single-character matches. */
      REPEATCHAR:
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (utf8)
+     if (utf)
        {
        length = 1;
        charptr = ecode;
-Line 3011 
 for (;;)
+Line 3240 
 for (;;)
          unsigned int othercase;
          if (op >= OP_STARI &&     /* Caseless */
              (othercase = UCD_OTHERCASE(fc)) != fc)
-           oclength = _pcre_ord2utf8(othercase, occhars);
+           oclength = PRIV(ord2utf)(othercase, occhars);
          else oclength = 0;
  #endif  /* SUPPORT_UCP */
          for (i = 1; i <= min; i++)
            {
            if (eptr <= md->end_subject - length &&
-             memcmp(eptr, charptr, length) == 0) eptr += length;
+             memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
  #ifdef SUPPORT_UCP
            else if (oclength > 0 &&
                     eptr <= md->end_subject - oclength &&
-                    memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+                    memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
  #endif  /* SUPPORT_UCP */
            else
              {
              CHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            }
-Line 3039 
 for (;;)
+Line 3268 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr <= md->end_subject - length &&
-               memcmp(eptr, charptr, length) == 0) eptr += length;
+               memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
  #ifdef SUPPORT_UCP
              else if (oclength > 0 &&
                       eptr <= md->end_subject - oclength &&
-                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+                      memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
  #endif  /* SUPPORT_UCP */
              else
                {
                CHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              }
            /* Control never gets here */
-Line 3062 
 for (;;)
+Line 3291 
 for (;;)
            for (i = min; i < max; i++)
              {
              if (eptr <= md->end_subject - length &&
-                 memcmp(eptr, charptr, length) == 0) eptr += length;
+                 memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
  #ifdef SUPPORT_UCP
              else if (oclength > 0 &&
                       eptr <= md->end_subject - oclength &&
-                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+                      memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
  #endif  /* SUPPORT_UCP */
              else
                {
-Line 3081 
 for (;;)
+Line 3310 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
+             if (eptr == pp) { RRETURN(MATCH_NOMATCH); }
  #ifdef SUPPORT_UCP
              eptr--;
              BACKCHAR(eptr);
-Line 3098 
 for (;;)
+Line 3327 
 for (;;)
        value of fc will always be < 128. */
        }
      else
- #endif  /* SUPPORT_UTF8 */
+ #endif  /* SUPPORT_UTF */
+       /* When not in UTF-8 mode, load a single-byte character. */
+       fc = *ecode++;
-     /* When not in UTF-8 mode, load a single-byte character. */
+     /* The value of fc at this point is always one character, though we may
+     or may not be in UTF mode. The code is duplicated for the caseless and
-     fc = *ecode++;
-     /* 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 =
      max, continue at the same level without recursing. Otherwise, if
-Line 3118 
 for (;;)
+Line 3345 
 for (;;)
      if (op >= OP_STARI)  /* Caseless */
        {
-       fc = md->lcc[fc];
+ #ifdef COMPILE_PCRE8
+       /* fc must be < 128 if UTF is enabled. */
+       foc = md->fcc[fc];
+ #else
+ #ifdef SUPPORT_UTF
+ #ifdef SUPPORT_UCP
+       if (utf && fc > 127)
+         foc = UCD_OTHERCASE(fc);
+ #else
+       if (utf && fc > 127)
+         foc = fc;
+ #endif /* SUPPORT_UCP */
+       else
+ #endif /* SUPPORT_UTF */
+         foc = TABLE_GET(fc, md->fcc, fc);
+ #endif /* COMPILE_PCRE8 */
        for (i = 1; i <= min; i++)
          {
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
-         if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+         if (fc != *eptr && foc != *eptr) RRETURN(MATCH_NOMATCH);
+         eptr++;
          }
        if (min == max) continue;
        if (minimize)
-Line 3135 
 for (;;)
+Line 3379 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) MRRETURN(MATCH_NOMATCH);
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+           if (fc != *eptr && foc != *eptr) RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          /* Control never gets here */
          }
-Line 3155 
 for (;;)
+Line 3400 
 for (;;)
              SCHECK_PARTIAL();
              break;
              }
-           if (fc != md->lcc[*eptr]) break;
+           if (fc != *eptr && foc != *eptr) break;
            eptr++;
            }
-Line 3167 
 for (;;)
+Line 3412 
 for (;;)
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3181 
 for (;;)
+Line 3426 
 for (;;)
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
-         if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
+         if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
          }
        if (min == max) continue;
-Line 3194 
 for (;;)
+Line 3439 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) MRRETURN(MATCH_NOMATCH);
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
+           if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 3225 
 for (;;)
+Line 3470 
 for (;;)
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3238 
 for (;;)
+Line 3483 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      ecode++;
      GETCHARINCTEST(c, eptr);
      if (op == OP_NOTI)         /* The caseless case */
        {
- #ifdef SUPPORT_UTF8
+       register int ch, och;
-       if (c < 256)
+       ch = *ecode++;
- #endif
+ #ifdef COMPILE_PCRE8
-       c = md->lcc[c];
+       /* ch must be < 128 if UTF is enabled. */
-       if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
+       och = md->fcc[ch];
+ #else
+ #ifdef SUPPORT_UTF
+ #ifdef SUPPORT_UCP
+       if (utf && ch > 127)
+         och = UCD_OTHERCASE(ch);
+ #else
+       if (utf && ch > 127)
+         och = ch;
+ #endif /* SUPPORT_UCP */
+       else
+ #endif /* SUPPORT_UTF */
+         och = TABLE_GET(ch, md->fcc, ch);
+ #endif /* COMPILE_PCRE8 */
+       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
        }
      else    /* Caseful */
        {
-       if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
+       if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
        }
      break;
-Line 3266 
 for (;;)
+Line 3525 
 for (;;)
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
      min = max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATNOTCHAR;
      case OP_NOTUPTO:
-Line 3276 
 for (;;)
+Line 3535 
 for (;;)
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATNOTCHAR;
      case OP_NOTPOSSTAR:
-Line 3308 
 for (;;)
+Line 3567 
 for (;;)
      possessive = TRUE;
      min = 0;
      max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATNOTCHAR;
      case OP_NOTSTAR:
-Line 3347 
 for (;;)
+Line 3606 
 for (;;)
      if (op >= OP_NOTSTARI)     /* Caseless */
        {
-       fc = md->lcc[fc];
+ #ifdef COMPILE_PCRE8
+       /* fc must be < 128 if UTF is enabled. */
+       foc = md->fcc[fc];
+ #else
+ #ifdef SUPPORT_UTF
+ #ifdef SUPPORT_UCP
+       if (utf && fc > 127)
+         foc = UCD_OTHERCASE(fc);
+ #else
+       if (utf && fc > 127)
+         foc = fc;
+ #endif /* SUPPORT_UCP */
+       else
+ #endif /* SUPPORT_UTF */
+         foc = TABLE_GET(fc, md->fcc, fc);
+ #endif /* COMPILE_PCRE8 */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-       /* UTF-8 mode */
+       if (utf)
-       if (utf8)
          {
          register unsigned int d;
          for (i = 1; i <= min; i++)
-Line 3359 
 for (;;)
+Line 3632 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(d, eptr);
-           if (d < 256) d = md->lcc[d];
+           if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);
-           if (fc == d) MRRETURN(MATCH_NOMATCH);
            }
          }
        else
  #endif
+       /* Not UTF mode */
-       /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+           if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          }
-Line 3386 
 for (;;)
+Line 3658 
 for (;;)
        if (minimize)
          {
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            register unsigned int d;
            for (fi = min;; fi++)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINC(d, eptr);
-             if (d < 256) d = md->lcc[d];
+             if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);
-             if (fc == d) MRRETURN(MATCH_NOMATCH);
              }
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (fi = min;; fi++)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
-             if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+             if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
+             eptr++;
              }
            }
          /* Control never gets here */
-Line 3432 
 for (;;)
+Line 3703 
 for (;;)
          {
          pp = eptr;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            register unsigned int d;
            for (i = min; i < max; i++)
-Line 3446 
 for (;;)
+Line 3716 
 for (;;)
                break;
                }
              GETCHARLEN(d, eptr, len);
-             if (d < 256) d = md->lcc[d];
+             if (fc == d || foc == d) break;
-             if (fc == d) break;
              eptr += len;
              }
          if (possessive) continue;
-Line 3461 
 for (;;)
+Line 3730 
 for (;;)
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (i = min; i < max; i++)
              {
-Line 3470 
 for (;;)
+Line 3739 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             if (fc == md->lcc[*eptr]) break;
+             if (fc == *eptr || foc == *eptr) break;
              eptr++;
              }
            if (possessive) continue;
-Line 3482 
 for (;;)
+Line 3751 
 for (;;)
              }
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3491 
 for (;;)
+Line 3760 
 for (;;)
      else
        {
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-       /* UTF-8 mode */
+       if (utf)
-       if (utf8)
          {
          register unsigned int d;
          for (i = 1; i <= min; i++)
-Line 3501 
 for (;;)
+Line 3769 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(d, eptr);
-           if (fc == d) MRRETURN(MATCH_NOMATCH);
+           if (fc == d) RRETURN(MATCH_NOMATCH);
            }
          }
        else
  #endif
-       /* Not UTF-8 mode */
+       /* Not UTF mode */
          {
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
+           if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
            }
          }
-Line 3526 
 for (;;)
+Line 3794 
 for (;;)
        if (minimize)
          {
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            register unsigned int d;
            for (fi = min;; fi++)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINC(d, eptr);
-             if (fc == d) MRRETURN(MATCH_NOMATCH);
+             if (fc == d) RRETURN(MATCH_NOMATCH);
              }
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (fi = min;; fi++)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
-             if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
+             if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 3571 
 for (;;)
+Line 3838 
 for (;;)
          {
          pp = eptr;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            register unsigned int d;
            for (i = min; i < max; i++)
-Line 3599 
 for (;;)
+Line 3865 
 for (;;)
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (i = min; i < max; i++)
              {
-Line 3620 
 for (;;)
+Line 3886 
 for (;;)
              }
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3632 
 for (;;)
+Line 3898 
 for (;;)
      case OP_TYPEEXACT:
      min = max = GET2(ecode, 1);
      minimize = TRUE;
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATTYPE;
      case OP_TYPEUPTO:
-Line 3640 
 for (;;)
+Line 3906 
 for (;;)
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_TYPEMINUPTO;
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATTYPE;
      case OP_TYPEPOSSTAR:
-Line 3668 
 for (;;)
+Line 3934 
 for (;;)
      possessive = TRUE;
      min = 0;
      max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATTYPE;
      case OP_TYPESTAR:
-Line 3714 
 for (;;)
+Line 3980 
 for (;;)
          switch(prop_type)
            {
            case PT_ANY:
-           if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
+           if (prop_fail_result) RRETURN(MATCH_NOMATCH);
            for (i = 1; i <= min; i++)
              {
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              }
-Line 3733 
 for (;;)
+Line 3999 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              chartype = UCD_CHARTYPE(c);
              if ((chartype == ucp_Lu ||
                   chartype == ucp_Ll ||
                   chartype == ucp_Lt) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3750 
 for (;;)
+Line 4016 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3764 
 for (;;)
+Line 4030 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3778 
 for (;;)
+Line 4044 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3793 
 for (;;)
+Line 4059 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              category = UCD_CATEGORY(c);
              if ((category == ucp_L || category == ucp_N) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3808 
 for (;;)
+Line 4074 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_FF || c == CHAR_CR)
                     == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3824 
 for (;;)
+Line 4090 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
                     == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3841 
 for (;;)
+Line 4107 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              category = UCD_CATEGORY(c);
              if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)
                     == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3868 
 for (;;)
+Line 4134 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
-           if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
+           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
+             if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
              if (UCD_CATEGORY(c) != ucp_M) break;
              eptr += len;
              }
-Line 3887 
 for (;;)
+Line 4153 
 for (;;)
  /* Handle all other cases when the coding is UTF-8 */
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-       if (utf8) switch(ctype)
+       if (utf) switch(ctype)
          {
          case OP_ANY:
          for (i = 1; i <= min; i++)
-Line 3896 
 for (;;)
+Line 4162 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
+           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
            eptr++;
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+           ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
            }
          break;
-Line 3910 
 for (;;)
+Line 4176 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            eptr++;
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+           ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
            }
          break;
          case OP_ANYBYTE:
-         if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
+         if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
          eptr += min;
          break;
-Line 3928 
 for (;;)
+Line 4194 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: MRRETURN(MATCH_NOMATCH);
+             default: RRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
-Line 3947 
 for (;;)
+Line 4213 
 for (;;)
              case 0x0085:
              case 0x2028:
              case 0x2029:
-             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3959 
 for (;;)
+Line 4225 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3984 
 for (;;)
+Line 4250 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3995 
 for (;;)
+Line 4261 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: MRRETURN(MATCH_NOMATCH);
+             default: RRETURN(MATCH_NOMATCH);
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-Line 4031 
 for (;;)
+Line 4297 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 4044 
 for (;;)
+Line 4310 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 4055 
 for (;;)
+Line 4321 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: MRRETURN(MATCH_NOMATCH);
+             default: RRETURN(MATCH_NOMATCH);
              case 0x0a:      /* LF */
              case 0x0b:      /* VT */
              case 0x0c:      /* FF */
-Line 4079 
 for (;;)
+Line 4345 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
            }
          break;
-Line 4093 
 for (;;)
+Line 4359 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
+           if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_digit) == 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 4107 
 for (;;)
+Line 4374 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
-           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
+           eptr++;
+           ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
            }
          break;
-Line 4121 
 for (;;)
+Line 4389 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+           if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_space) == 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 4135 
 for (;;)
+Line 4404 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
-           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
+           eptr++;
+           ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
            }
          break;
-Line 4149 
 for (;;)
+Line 4419 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+           if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_word) == 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 4162 
 for (;;)
+Line 4433 
 for (;;)
          }  /* End switch(ctype) */
        else
- #endif     /* SUPPORT_UTF8 */
+ #endif     /* SUPPORT_UTF */
        /* Code for the non-UTF-8 case for minimum matching of operators other
        than OP_PROP and OP_NOTPROP. */
-Line 4175 
 for (;;)
+Line 4446 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
+           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
            eptr++;
            }
          break;
-Line 4186 
 for (;;)
+Line 4457 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 4195 
 for (;;)
+Line 4466 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 4206 
 for (;;)
+Line 4477 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-             default: MRRETURN(MATCH_NOMATCH);
+             default: RRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
-Line 4222 
 for (;;)
+Line 4493 
 for (;;)
              case 0x000b:
              case 0x000c:
              case 0x0085:
-             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
+ #ifdef COMPILE_PCRE16
+             case 0x2028:
+             case 0x2029:
+ #endif
+             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 4234 
 for (;;)
+Line 4509 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 4242 
 for (;;)
+Line 4517 
 for (;;)
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-             MRRETURN(MATCH_NOMATCH);
+ #ifdef COMPILE_PCRE16
+             case 0x1680:    /* OGHAM SPACE MARK */
+             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+             case 0x2000:    /* EN QUAD */
+             case 0x2001:    /* EM QUAD */
+             case 0x2002:    /* EN SPACE */
+             case 0x2003:    /* EM SPACE */
+             case 0x2004:    /* THREE-PER-EM SPACE */
+             case 0x2005:    /* FOUR-PER-EM SPACE */
+             case 0x2006:    /* SIX-PER-EM SPACE */
+             case 0x2007:    /* FIGURE SPACE */
+             case 0x2008:    /* PUNCTUATION SPACE */
+             case 0x2009:    /* THIN SPACE */
+             case 0x200A:    /* HAIR SPACE */
+             case 0x202f:    /* NARROW NO-BREAK SPACE */
+             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+             case 0x3000:    /* IDEOGRAPHIC SPACE */
+ #endif
+             RRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 4253 
 for (;;)
+Line 4546 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-             default: MRRETURN(MATCH_NOMATCH);
+             default: RRETURN(MATCH_NOMATCH);
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
+ #ifdef COMPILE_PCRE16
+             case 0x1680:    /* OGHAM SPACE MARK */
+             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+             case 0x2000:    /* EN QUAD */
+             case 0x2001:    /* EM QUAD */
+             case 0x2002:    /* EN SPACE */
+             case 0x2003:    /* EM SPACE */
+             case 0x2004:    /* THREE-PER-EM SPACE */
+             case 0x2005:    /* FOUR-PER-EM SPACE */
+             case 0x2006:    /* SIX-PER-EM SPACE */
+             case 0x2007:    /* FIGURE SPACE */
+             case 0x2008:    /* PUNCTUATION SPACE */
+             case 0x2009:    /* THIN SPACE */
+             case 0x200A:    /* HAIR SPACE */
+             case 0x202f:    /* NARROW NO-BREAK SPACE */
+             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+             case 0x3000:    /* IDEOGRAPHIC SPACE */
+ #endif
              break;
              }
            }
-Line 4272 
 for (;;)
+Line 4583 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 4282 
 for (;;)
+Line 4593 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             MRRETURN(MATCH_NOMATCH);
+ #ifdef COMPILE_PCRE16
+             case 0x2028:    /* LINE SEPARATOR */
+             case 0x2029:    /* PARAGRAPH SEPARATOR */
+ #endif
+             RRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 4293 
 for (;;)
+Line 4608 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-             default: MRRETURN(MATCH_NOMATCH);
+             default: RRETURN(MATCH_NOMATCH);
              case 0x0a:      /* LF */
              case 0x0b:      /* VT */
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
+ #ifdef COMPILE_PCRE16
+             case 0x2028:    /* LINE SEPARATOR */
+             case 0x2029:    /* PARAGRAPH SEPARATOR */
+ #endif
              break;
              }
            }
-Line 4314 
 for (;;)
+Line 4633 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
+           if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0)
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          break;
-Line 4326 
 for (;;)
+Line 4647 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
+           if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0)
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          break;
-Line 4338 
 for (;;)
+Line 4661 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
+           if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0)
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          break;
-Line 4350 
 for (;;)
+Line 4675 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
+           if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0)
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          break;
-Line 4362 
 for (;;)
+Line 4689 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_word) != 0)
+           if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          break;
-Line 4375 
 for (;;)
+Line 4703 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_word) == 0)
+           if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0)
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+           eptr++;
            }
          break;
-Line 4407 
 for (;;)
+Line 4736 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
+             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4424 
 for (;;)
+Line 4753 
 for (;;)
              int chartype;
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              chartype = UCD_CHARTYPE(c);
              if ((chartype == ucp_Lu ||
                   chartype == ucp_Ll ||
                   chartype == ucp_Lt) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4444 
 for (;;)
+Line 4773 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
 Line 4461