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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 716 by ph10,
Tue Oct  4 16:38:05 2011 UTC
+revision 976 by ph10,
Sat Jun 16 17:53:17 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 37 
 POSSIBILITY OF SUCH DAMAGE.
  -----------------------------------------------------------------------------
  */
  /* This module contains pcre_exec(), the externally visible function that does
  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
  possible. There are also some static supporting functions. */
-Line 82 
 negative to avoid the external error cod
+Line 81 
 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 112 
 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 148 
 Arguments:
+Line 139 
 Arguments:
    md          points to match data block
    caseless    TRUE if caseless
- Returns:      < 0 if not matched, otherwise the number of subject bytes matched
+ Returns:      >= 0 the number of subject bytes matched
+               -1 no match
+               -2 partial match; always given if at end subject
  */
  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 171 
 pchars(p, length, FALSE, md);
+Line 164 
 pchars(p, length, FALSE, md);
  printf("\n");
  #endif
- /* Always fail if reference not set (and not JavaScript compatible). */
+ /* Always fail if reference not set (and not JavaScript compatible - in that
+ case the length is passed as zero). */
  if (length < 0) return -1;
-Line 181 
 ASCII characters. */
+Line 175 
 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 187 
 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;
-       if (eptr >= md->end_subject) return -1;
+       if (eptr >= md->end_subject) return -2;   /* Partial match */
        GETCHARINC(c, eptr);
        GETCHARINC(d, p);
        if (c != d && c != UCD_OTHERCASE(d)) return -1;
-Line 210 
 if (caseless)
+Line 204 
 if (caseless)
    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
    is no UCP support. */
      {
-     if (eptr + length > md->end_subject) return -1;
      while (length-- > 0)
-       { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
+       {
+       if (eptr >= md->end_subject) return -2;   /* Partial match */
+       if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;
+       p++;
+       eptr++;
+       }
      }
    }
-Line 221 
 are in UTF-8 mode. */
+Line 219 
 are in UTF-8 mode. */
  else
    {
-   if (eptr + length > md->end_subject) return -1;
+   while (length-- > 0)
-   while (length-- > 0) if (*p++ != *eptr++) return -1;
+     {
+     if (eptr >= md->end_subject) return -2;   /* Partial match */
+     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 278 
 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 291 
 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 301 
 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 316 
 argument of match(), which never changes
  #define RMATCH(ra,rb,rc,rd,re,rw)\
    {\
-   heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
+   heapframe *newframe = frame->Xnextframe;\
-   if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
+   if (newframe == NULL)\
-   frame->Xwhere = rw; \
+     {\
+     newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
+     if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
+     newframe->Xnextframe = NULL;\
+     frame->Xnextframe = newframe;\
+     }\
+   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 343 
 argument of match(), which never changes
    {\
    heapframe *oldframe = frame;\
    frame = oldframe->Xprevframe;\
-   (pcre_stack_free)(oldframe);\
    if (frame != NULL)\
      {\
      rrc = ra;\
-Line 351 
 argument of match(), which never changes
+Line 356 
 argument of match(), which never changes
  typedef struct heapframe {
    struct heapframe *Xprevframe;
+   struct heapframe *Xnextframe;
    /* 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 390 
 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 432 
 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 443 
 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 464 
 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 478 
 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 489 
 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;
  int condcode;
  /* When recursion is not being used, all "local" variables that have to be
- preserved over calls to RMATCH() are part of a "frame" which is obtained from
+ preserved over calls to RMATCH() are part of a "frame". We set up the top-level
- heap storage. Set up the top-level frame here; others are obtained from the
+ frame on the stack here; subsequent instantiations are obtained from the heap
- heap whenever RMATCH() does a "recursion". See the macro definitions above. */
+ whenever RMATCH() does a "recursion". See the macro definitions above. Putting
+ the top-level on the stack rather than malloc-ing them all gives a performance
+ boost in many cases where there is not much "recursion". */
  #ifdef NO_RECURSE
- heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
+ heapframe *frame = (heapframe *)md->match_frames_base;
- if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
- frame->Xprevframe = NULL;            /* Marks the top level */
  /* Copy in the original argument variables */
  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 523 
 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 587 
 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 608 
 int prop_type;
  int prop_value;
  int prop_fail_result;
  int oclength;
- uschar occhars[8];
+ pcre_uchar occhars[6];
  #endif
  int codelink;
-Line 622 
 int save_offset1, save_offset2, save_off
+Line 624 
 int save_offset1, save_offset2, save_off
  int stacksave[REC_STACK_SAVE_MAX];
  eptrblock newptrb;
+ /* There is a special fudge for calling match() in a way that causes it to
+ measure the size of its basic stack frame when the stack is being used for
+ recursion. The second argument (ecode) being NULL triggers this behaviour. It
+ cannot normally ever be NULL. The return is the negated value of the frame
+ size. */
+ if (ecode == NULL)
+   {
+   if (rdepth == 0)
+     return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
+   else
+     {
+     int len = (char *)&rdepth - (char *)eptr;
+     return (len > 0)? -len : len;
+     }
+   }
  #endif     /* NO_RECURSE */
  /* To save space on the stack and in the heap frame, I have doubled up on some
-Line 634 
 the alternative names that are used. */
+Line 653 
 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 680 
 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 722 
 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 736 
 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);
-Line 780 
 for (;;)
+Line 814 
 for (;;)
      match pointer to do this. */
      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;
-     MRRETURN(MATCH_THEN);
+     RRETURN(MATCH_THEN);
      case OP_THEN_ARG:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
+     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, 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;
-     md->mark = ecode + 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 */
+       {
+       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 826 
 for (;;)
+Line 945 
 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 834 
 for (;;)
+Line 954 
 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 we backed up to a THEN, check whether it is within the current
          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 872 
 for (;;)
+Line 993 
 for (;;)
        /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
-       if (md->mark == NULL) md->mark = markptr;
        RRETURN(rrc);
        }
-Line 888 
 for (;;)
+Line 1008 
 for (;;)
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* Non-capturing or atomic group, except for possessive with unlimited
-     repeat. Loop for all the alternatives.
+     repeat and ONCE group with no captures. Loop for all the alternatives.
      When we get to the final alternative within the brackets, we used to return
      the result of a recursive call to match() whatever happened so it was
-Line 914 
 for (;;)
+Line 1034 
 for (;;)
      for (;;)
        {
-       if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;
+       if (op >= OP_SBRA || op == OP_ONCE)
+         md->match_function_type = MATCH_CBEGROUP;
        /* 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
-Line 922 
 for (;;)
+Line 1043 
 for (;;)
        else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
          {
-         ecode += _pcre_OP_lengths[*ecode];
+         ecode += PRIV(OP_lengths)[*ecode];
          goto TAIL_RECURSE;
          }
        /* In all other cases, we have to make another call to match(). */
-       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
+       save_mark = md->mark;
+       RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
          RM2);
        /* 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 957 
 for (;;)
+Line 1079 
 for (;;)
          RRETURN(rrc);
          }
        ecode += GET(ecode, 1);
+       md->mark = save_mark;
        if (*ecode != OP_ALT) break;
        }
-     if (md->mark == NULL) md->mark = markptr;
      RRETURN(MATCH_NOMATCH);
      /* Handle possessive capturing brackets with an unlimited repeat. We come
-Line 989 
 for (;;)
+Line 1111 
 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 1012 
 for (;;)
+Line 1134 
 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 1023 
 for (;;)
+Line 1145 
 for (;;)
            matched_once = TRUE;
            continue;
            }
          /* 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) RRETURN(rrc);
          md->capture_last = save_capture_last;
-Line 1048 
 for (;;)
+Line 1170 
 for (;;)
          md->offset_vector[md->offset_end - number] = save_offset3;
          }
-       if (md->mark == NULL) md->mark = markptr;
        if (allow_zero || matched_once)
          {
          ecode += 1 + LINK_SIZE;
-Line 1080 
 for (;;)
+Line 1201 
 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 1095 
 for (;;)
+Line 1216 
 for (;;)
          matched_once = TRUE;
          continue;
          }
        /* 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) RRETURN(rrc);
        ecode += GET(ecode, 1);
-Line 1135 
 for (;;)
+Line 1256 
 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          = 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 1150 
 for (;;)
+Line 1275 
 for (;;)
          cb.capture_top      = offset_top/2;
          cb.capture_last     = md->capture_last;
          cb.callout_data     = md->callout_data;
-         cb.mark             = markptr;
+         cb.mark             = md->nomatch_mark;
-         if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
+         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 1171 
 for (;;)
+Line 1296 
 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 1193 
 for (;;)
+Line 1318 
 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 1213 
 for (;;)
+Line 1338 
 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 1226 
 for (;;)
+Line 1351 
 for (;;)
          /* Chose branch according to the condition */
-         ecode += condition? 3 : GET(ecode, 1);
+         ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);
          }
        }
-Line 1243 
 for (;;)
+Line 1368 
 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 1257 
 for (;;)
+Line 1382 
 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 1279 
 for (;;)
+Line 1404 
 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 1294 
 for (;;)
+Line 1419 
 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 1319 
 for (;;)
+Line 1444 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
        /* 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 1351 
 for (;;)
+Line 1476 
 for (;;)
          ecode += 1 + LINK_SIZE;
          goto TAIL_RECURSE;
          }
        md->match_function_type = MATCH_CBEGROUP;
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
        RRETURN(rrc);
-Line 1386 
 for (;;)
+Line 1511 
 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 1406 
 for (;;)
+Line 1531 
 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 1415 
 for (;;)
+Line 1540 
 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 1433 
 for (;;)
+Line 1558 
 for (;;)
      case OP_ASSERT:
      case OP_ASSERTBACK:
+     save_mark = md->mark;
      if (md->match_function_type == MATCH_CONDASSERT)
        {
        condassert = TRUE;
-Line 1446 
 for (;;)
+Line 1572 
 for (;;)
        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
          {
          mstart = md->start_match_ptr;   /* In case \K reset it */
-         markptr = md->mark;
          break;
          }
+       md->mark = save_mark;
-       /* PCRE does not allow THEN to escape beyond an assertion; it is treated
-       as NOMATCH. */
+       /* A COMMIT failure must fail the entire assertion, without trying any
+       subsequent branches. */
+       if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
+       /* PCRE does not allow THEN to escape beyond an assertion; it
+       is treated as NOMATCH. */
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      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 1478 
 for (;;)
+Line 1609 
 for (;;)
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK_NOT:
+     save_mark = md->mark;
      if (md->match_function_type == MATCH_CONDASSERT)
        {
        condassert = TRUE;
-Line 1488 
 for (;;)
+Line 1620 
 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;
          }
        /* PCRE does not allow THEN to escape beyond an assertion; it is treated
        as NOMATCH. */
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
-Line 1514 
 for (;;)
+Line 1647 
 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 1532 
 for (;;)
+Line 1665 
 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 1546 
 for (;;)
+Line 1679 
 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          = 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 1561 
 for (;;)
+Line 1698 
 for (;;)
        cb.capture_top      = offset_top/2;
        cb.capture_last     = md->capture_last;
        cb.callout_data     = md->callout_data;
-       cb.mark             = markptr;
+       cb.mark             = md->nomatch_mark;
-       if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
+       if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
        if (rrc < 0) RRETURN(rrc);
        }
      ecode += 2 + 2*LINK_SIZE;
-Line 1621 
 for (;;)
+Line 1758 
 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 1636 
 for (;;)
+Line 1773 
 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));
-Line 1645 
 for (;;)
+Line 1782 
 for (;;)
            {
            DPRINTF(("Recursion matched\n"));
            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 1656 
 for (;;)
+Line 1793 
 for (;;)
            goto RECURSION_MATCHED;        /* Exit loop; end processing */
            }
-         /* PCRE does not allow THEN to escape beyond a recursion; it is treated
+         /* PCRE does not allow THEN or COMMIT to escape beyond a recursion; it
-         as NOMATCH. */
+         is treated as NOMATCH. */
-         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
+                  rrc != MATCH_COMMIT)
            {
            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 1675 
 for (;;)
+Line 1813 
 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 1745 
 for (;;)
+Line 1883 
 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 1821 
 for (;;)
+Line 1959 
 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 1870 
 for (;;)
+Line 2008 
 for (;;)
          }
        if (*prev >= OP_SBRA)    /* Could match an empty string */
          {
-         md->match_function_type = MATCH_CBEGROUP;
          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
          RRETURN(rrc);
          }
-Line 1879 
 for (;;)
+Line 2016 
 for (;;)
        }
      else  /* OP_KETRMAX */
        {
-       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-Line 1898 
 for (;;)
+Line 2034 
 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 1936 
 for (;;)
+Line 2072 
 for (;;)
      case OP_DOLLM:
      if (eptr < md->end_subject)
-       { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
+       {
+       if (!IS_NEWLINE(eptr))
+         {
+         if (md->partial != 0 &&
+             eptr + 1 >= md->end_subject &&
+             NLBLOCK->nltype == NLTYPE_FIXED &&
+             NLBLOCK->nllen == 2 &&
+             *eptr == NLBLOCK->nl[0])
+           {
+           md->hitend = TRUE;
+           if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+           }
+         RRETURN(MATCH_NOMATCH);
+         }
+       }
      else
        {
-       if (md->noteol) MRRETURN(MATCH_NOMATCH);
+       if (md->noteol) RRETURN(MATCH_NOMATCH);
        SCHECK_PARTIAL();
        }
      ecode++;
-Line 1949 
 for (;;)
+Line 2099 
 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 1957 
 for (;;)
+Line 2107 
 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 1968 
 for (;;)
+Line 2118 
 for (;;)
      ASSERT_NL_OR_EOS:
      if (eptr < md->end_subject &&
          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-       MRRETURN(MATCH_NOMATCH);
+       {
+       if (md->partial != 0 &&
+           eptr + 1 >= md->end_subject &&
+           NLBLOCK->nltype == NLTYPE_FIXED &&
+           NLBLOCK->nllen == 2 &&
+           *eptr == NLBLOCK->nl[0])
+         {
+         md->hitend = TRUE;
+         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+         }
+       RRETURN(MATCH_NOMATCH);
+       }
      /* Either at end of string or \n before end. */
-Line 1987 
 for (;;)
+Line 2148 
 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 2060 
 for (;;)
+Line 2221 
 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 2083 
 for (;;)
+Line 2245 
 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 */
+     /* Match any single character type except newline; have to take care with
+     CRLF newlines and partial matching. */
      case OP_ANY:
-     if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
+     if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+     if (md->partial != 0 &&
+         eptr + 1 >= md->end_subject &&
+         NLBLOCK->nltype == NLTYPE_FIXED &&
+         NLBLOCK->nllen == 2 &&
+         *eptr == NLBLOCK->nl[0])
+       {
+       md->hitend = TRUE;
+       if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+       }
      /* Fall through */
+     /* Match any single character whatsoever. */
      case OP_ALLANY:
      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++;
-     if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+ #ifdef SUPPORT_UTF
+     if (utf) ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+ #endif
      ecode++;
      break;
-Line 2118 
 for (;;)
+Line 2296 
 for (;;)
      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++;
-Line 2128 
 for (;;)
+Line 2306 
 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 2145 
 for (;;)
+Line 2323 
 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 2162 
 for (;;)
+Line 2340 
 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 2179 
 for (;;)
+Line 2357 
 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 2196 
 for (;;)
+Line 2374 
 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 2213 
 for (;;)
+Line 2391 
 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 2230 
 for (;;)
+Line 2408 
 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++;
+       if (eptr >= md->end_subject)
+         {
+         SCHECK_PARTIAL();
+         }
+       else if (*eptr == 0x0a) eptr++;
        break;
        case 0x000a:
-Line 2249 
 for (;;)
+Line 2431 
 for (;;)
        case 0x0085:
        case 0x2028:
        case 0x2029:
-       if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
+       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
        break;
        }
      ecode++;
-Line 2259 
 for (;;)
+Line 2441 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 2284 
 for (;;)
+Line 2466 
 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 2293 
 for (;;)
+Line 2475 
 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 2327 
 for (;;)
+Line 2509 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 2340 
 for (;;)
+Line 2522 
 for (;;)
        case 0x85:      /* NEL */
        case 0x2028:    /* LINE SEPARATOR */
        case 0x2029:    /* PARAGRAPH SEPARATOR */
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 2349 
 for (;;)
+Line 2531 
 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 2376 
 for (;;)
+Line 2558 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
        {
-Line 2385 
 for (;;)
+Line 2567 
 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 2457 
 for (;;)
+Line 2639 
 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;
        }
+     CHECK_PARTIAL();
      ecode++;
      break;
  #endif
-Line 2485 
 for (;;)
+Line 2668 
 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 2525 
 for (;;)
+Line 2708 
 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)
          {
+         if (length == -2) eptr = md->end_subject;   /* Partial match */
          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 2554 
 for (;;)
+Line 2742 
 for (;;)
        int slength;
        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
          {
+         if (slength == -2) eptr = md->end_subject;   /* Partial match */
          CHECK_PARTIAL();
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        eptr += slength;
        }
-Line 2574 
 for (;;)
+Line 2763 
 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)
            {
+           if (slength == -2) eptr = md->end_subject;   /* Partial match */
            CHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          eptr += slength;
          }
-Line 2595 
 for (;;)
+Line 2785 
 for (;;)
          int slength;
          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
            {
-           CHECK_PARTIAL();
+           /* Can't use CHECK_PARTIAL because we don't want to update eptr in
+           the soft partial matching case. */
+           if (slength == -2 && md->partial != 0 &&
+               md->end_subject > md->start_used_ptr)
+             {
+             md->hitend = TRUE;
+             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+             }
            break;
            }
          eptr += slength;
          }
        while (eptr >= pp)
          {
          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          eptr -= length;
          }
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 2624 
 for (;;)
+Line 2823 
 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 2646 
 for (;;)
+Line 2848 
 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 2658 
 for (;;)
+Line 2860 
 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 2706 
 for (;;)
+Line 2912 
 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 2758 
 for (;;)
+Line 2968 
 for (;;)
          {
          pp = eptr;
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-         /* UTF-8 mode */
+         if (utf)
-         if (utf8)
            {
            for (i = min; i < max; i++)
              {
-Line 2776 
 for (;;)
+Line 2985 
 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 2791 
 for (;;)
+Line 2998 
 for (;;)
            }
          else
  #endif
-           /* Not UTF-8 mode */
+           /* Not UTF mode */
            {
            for (i = min; i < max; i++)
              {
-Line 2801 
 for (;;)
+Line 3008 
 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 2812 
 for (;;)
+Line 3026 
 for (;;)
              }
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
+ #undef BYTE_MAP
        }
      /* Control never gets here */
-Line 2822 
 for (;;)
+Line 3037 
 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 2847 
 for (;;)
+Line 3062 
 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 2864 
 for (;;)
+Line 3079 
 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 2884 
 for (;;)
+Line 3099 
 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 2909 
 for (;;)
+Line 3124 
 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 2918 
 for (;;)
+Line 3137 
 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 2930 
 for (;;)
+Line 3151 
 for (;;)
      /* Match a single character, casefully */
      case OP_CHAR:
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-     if (utf8)
+     if (utf)
        {
        length = 1;
        ecode++;
-Line 2939 
 for (;;)
+Line 3160 
 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 2998 
 for (;;)
+Line 3226 
 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 3022 
 for (;;)
+Line 3247 
 for (;;)
      case OP_EXACT:
      case OP_EXACTI:
      min = max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATCHAR;
      case OP_POSUPTO:
-Line 3037 
 for (;;)
+Line 3262 
 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 3085 
 for (;;)
+Line 3310 
 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 3102 
 for (;;)
+Line 3327 
 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 3130 
 for (;;)
+Line 3355 
 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 3153 
 for (;;)
+Line 3378 
 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 3172 
 for (;;)
+Line 3397 
 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 3189 
 for (;;)
+Line 3414 
 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 3205 
 for (;;)
+Line 3428 
 for (;;)
      maximizing, find the maximum number of characters and work backwards. */
      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
-       max, eptr));
+       max, (char *)eptr));
      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 3226 
 for (;;)
+Line 3466 
 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 3246 
 for (;;)
+Line 3487 
 for (;;)
              SCHECK_PARTIAL();
              break;
              }
-           if (fc != md->lcc[*eptr]) break;
+           if (fc != *eptr && foc != *eptr) break;
            eptr++;
            }
-Line 3258 
 for (;;)
+Line 3499 
 for (;;)
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3272 
 for (;;)
+Line 3513 
 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 3285 
 for (;;)
+Line 3526 
 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 3316 
 for (;;)
+Line 3557 
 for (;;)
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3329 
 for (;;)
+Line 3570 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       MRRETURN(MATCH_NOMATCH);
+       RRETURN(MATCH_NOMATCH);
        }
-     ecode++;
+ #ifdef SUPPORT_UTF
-     GETCHARINCTEST(c, eptr);
+     if (utf)
-     if (op == OP_NOTI)         /* The caseless case */
        {
- #ifdef SUPPORT_UTF8
+       register unsigned int ch, och;
-       if (c < 256)
- #endif
+       ecode++;
-       c = md->lcc[c];
+       GETCHARINC(ch, ecode);
-       if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
+       GETCHARINC(c, eptr);
+       if (op == OP_NOT)
+         {
+         if (ch == c) RRETURN(MATCH_NOMATCH);
+         }
+       else
+         {
+ #ifdef SUPPORT_UCP
+         if (ch > 127)
+           och = UCD_OTHERCASE(ch);
+ #else
+         if (ch > 127)
+           och = ch;
+ #endif /* SUPPORT_UCP */
+         else
+           och = TABLE_GET(ch, md->fcc, ch);
+         if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
+         }
        }
-     else    /* Caseful */
+     else
+ #endif
        {
-       if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
+       register unsigned int ch = ecode[1];
+       c = *eptr++;
+       if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
+         RRETURN(MATCH_NOMATCH);
+       ecode += 2;
        }
      break;
-Line 3357 
 for (;;)
+Line 3620 
 for (;;)
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
      min = max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATNOTCHAR;
      case OP_NOTUPTO:
-Line 3367 
 for (;;)
+Line 3630 
 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 3399 
 for (;;)
+Line 3662 
 for (;;)
      possessive = TRUE;
      min = 0;
      max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATNOTCHAR;
      case OP_NOTSTAR:
-Line 3423 
 for (;;)
+Line 3686 
 for (;;)
      /* Common code for all repeated single-byte matches. */
      REPEATNOTCHAR:
-     fc = *ecode++;
+     GETCHARINCTEST(fc, ecode);
      /* The code is duplicated for the caseless and caseful cases, for speed,
      since matching characters is likely to be quite common. First, ensure the
-Line 3434 
 for (;;)
+Line 3697 
 for (;;)
      characters and work backwards. */
      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
-       max, eptr));
+       max, (char *)eptr));
      if (op >= OP_NOTSTARI)     /* Caseless */
        {
-       fc = md->lcc[fc];
+ #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);
- #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UTF
-       /* UTF-8 mode */
+       if (utf)
-       if (utf8)
          {
          register unsigned int d;
          for (i = 1; i <= min; i++)
-Line 3450 
 for (;;)
+Line 3722 
 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 || (unsigned int)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 3477 
 for (;;)
+Line 3748 
 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 || (unsigned int)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 3523 
 for (;;)
+Line 3793 
 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 3537 
 for (;;)
+Line 3806 
 for (;;)
                break;
                }
              GETCHARLEN(d, eptr, len);
-             if (d < 256) d = md->lcc[d];
+             if (fc == d || (unsigned int)foc == d) break;
-             if (fc == d) break;
              eptr += len;
              }
-         if (possessive) continue;
+           if (possessive) continue;
-         for(;;)
+           for(;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-Line 3552 
 for (;;)
+Line 3820 
 for (;;)
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (i = min; i < max; i++)
              {
-Line 3561 
 for (;;)
+Line 3829 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             if (fc == md->lcc[*eptr]) break;
+             if (fc == *eptr || foc == *eptr) break;
              eptr++;
              }
            if (possessive) continue;
-Line 3573 
 for (;;)
+Line 3841 
 for (;;)
              }
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3582 
 for (;;)
+Line 3850 
 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 3592 
 for (;;)
+Line 3859 
 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 3617 
 for (;;)
+Line 3884 
 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 3662 
 for (;;)
+Line 3928 
 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 3690 
 for (;;)
+Line 3955 
 for (;;)
            }
          else
  #endif
-         /* Not UTF-8 mode */
+         /* Not UTF mode */
            {
            for (i = min; i < max; i++)
              {
-Line 3711 
 for (;;)
+Line 3976 
 for (;;)
              }
            }
-         MRRETURN(MATCH_NOMATCH);
+         RRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3723 
 for (;;)
+Line 3988 
 for (;;)
      case OP_TYPEEXACT:
      min = max = GET2(ecode, 1);
      minimize = TRUE;
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATTYPE;
      case OP_TYPEUPTO:
-Line 3731 
 for (;;)
+Line 3996 
 for (;;)
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_TYPEMINUPTO;
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATTYPE;
      case OP_TYPEPOSSTAR:
-Line 3759 
 for (;;)
+Line 4024 
 for (;;)
      possessive = TRUE;
      min = 0;
      max = GET2(ecode, 1);
-     ecode += 3;
+     ecode += 1 + IMM2_SIZE;
      goto REPEATTYPE;
      case OP_TYPESTAR:
-Line 3805 
 for (;;)
+Line 4070 
 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 3824 
 for (;;)
+Line 4089 
 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 3841 
 for (;;)
+Line 4106 
 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 3855 
 for (;;)
+Line 4120 
 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 3869 
 for (;;)
+Line 4134 
 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 3884 
 for (;;)
+Line 4149 
 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 3899 
 for (;;)
+Line 4164 
 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 3915 
 for (;;)
+Line 4180 
 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 3932 
 for (;;)
+Line 4197 
 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 3959 
 for (;;)
+Line 4224 
 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;
              }
+           CHECK_PARTIAL();
            }
          }
-Line 3978 
 for (;;)
+Line 4244 
 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 3987 
 for (;;)
+Line 4253 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+           if (md->partial != 0 &&
+               eptr + 1 >= md->end_subject &&
+               NLBLOCK->nltype == NLTYPE_FIXED &&
+               NLBLOCK->nllen == 2 &&
+               *eptr == NLBLOCK->nl[0])
+             {
+             md->hitend = TRUE;
+             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
              }
-           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
            eptr++;
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+           ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
            }
          break;
-Line 4001 
 for (;;)
+Line 4276 
 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 4019 
 for (;;)
+Line 4294 
 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 4038 
 for (;;)
+Line 4313 
 for (;;)
              case 0x0085:
              case 0x2028:
              case 0x2029:
-             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 4050 
 for (;;)
+Line 4325 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 4075 
 for (;;)
+Line 4350 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 4086 
 for (;;)
+Line 4361 
 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 4122 
 for (;;)
+Line 4397 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 4135 
 for (;;)
+Line 4410 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 4146 
 for (;;)
+Line 4421 
 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 4170 
 for (;;)
+Line 4445 
 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 4184 
 for (;;)
+Line 4459 
 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 4198 
 for (;;)
+Line 4474 
 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 4212 
 for (;;)
+Line 4489 
 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 4226 
 for (;;)
+Line 4504 
 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 4240 
 for (;;)
+Line 4519 
 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 4253 
 for (;;)
+Line 4533 
 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 4266 
 for (;;)
+Line 4546 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+           if (md->partial != 0 &&
+               eptr + 1 >= md->end_subject &&
+               NLBLOCK->nltype == NLTYPE_FIXED &&
+               NLBLOCK->nllen == 2 &&
+               *eptr == NLBLOCK->nl[0])
+             {
+             md->hitend = TRUE;
+             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
              }
-           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
            eptr++;
            }
          break;
-Line 4277 
 for (;;)
+Line 4566 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 4286 
 for (;;)
+Line 4575 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           MRRETURN(MATCH_NOMATCH);
+           RRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 4297 
 for (;;)
+Line 4586 
 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 4313 
 for (;;)
+Line 4602 
 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 4325 
 for (;;)
+Line 4618 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 4333 
 for (;;)
+Line 4626 
 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 4344 
 for (;;)
+Line 4655 
 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 4363 
 for (;;)
+Line 4692 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             MRRETURN(MATCH_NOMATCH);
+             RRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 4373 
 for (;;)
+Line 4702 
 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 4384 
 for (;;)
+Line 4717 
 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 4405 
 for (;;)
+Line 4742 
 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 4417 
 for (;;)
+Line 4756 
 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 4429 
 for (;;)
+Line 4770 
 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 4441 
 for (;;)
+Line 4784 
 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 4453 
 for (;;)
+Line 4798 
 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 4466 
 for (;;)
+Line 4812 
 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 4498 
 for (;;)
+Line 4845 
 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 4515 
 for (;;)
+Line 4862 
 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 4535 
 for (;;)
+Line 4882 
 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 4552 
 for (;;)
+Line 4899 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);
              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_CHARTYPE(c) == prop_value) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4569 
 for (;;)
+Line 4916 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);
              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_SCRIPT(c) == prop_value) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4587 
 for (;;)
+Line 4934 
 for (;;)
              int category;
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
              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);
              category = UCD_CATEGORY(c);
              if ((category == ucp_L || category == ucp_N) == prop_fail_result)
-               MRRETURN(MATCH_NOMATCH);
+               RRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4605 
 for (;;)
+Line 4952 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);