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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 371 by ph10,
Mon Aug 25 18:28:05 2008 UTC
+revision 512 by ph10,
Tue Mar 30 11:11:52 2010 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2008 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 71 
 defined PCRE_ERROR_xxx codes, which are
  /* Special internal returns from the match() function. Make them sufficiently
  negative to avoid the external error codes. */
- #define MATCH_COMMIT       (-999)
+ #define MATCH_ACCEPT       (-999)
- #define MATCH_PRUNE        (-998)
+ #define MATCH_COMMIT       (-998)
- #define MATCH_SKIP         (-997)
+ #define MATCH_PRUNE        (-997)
- #define MATCH_THEN         (-996)
+ #define MATCH_SKIP         (-996)
+ #define MATCH_SKIP_ARG     (-995)
+ #define MATCH_THEN         (-994)
+ /* 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,
-Line 89 
 static const char rep_max[] = { 0, 0, 0,
+Line 99 
 static const char rep_max[] = { 0, 0, 0,
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  /*************************************************
  *        Debugging function to print chars       *
  *************************************************/
-Line 141 
 match_ref(int offset, register USPTR ept
+Line 151 
 match_ref(int offset, register USPTR ept
  {
  USPTR p = md->start_subject + md->offset_vector[offset];
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (eptr >= md->end_subject)
    printf("matching subject <null>");
  else
-Line 245 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 255 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
-        RM51,  RM52, RM53, RM54 };
+        RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58 };
  /* 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
- actuall used in this definition. */
+ actually used in this definition. */
  #ifndef NO_RECURSE
  #define REGISTER register
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
    { \
    printf("match() called in line %d\n", __LINE__); \
-   rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 268 
 actuall used in this definition. */
+Line 278 
 actuall used in this definition. */
    }
  #else
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
-   rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
-Line 288 
 argument of match(), which never changes
+Line 298 
 argument of match(), which never changes
    newframe->Xeptr = ra;\
    newframe->Xecode = rb;\
    newframe->Xmstart = mstart;\
+   newframe->Xmarkptr = markptr;\
    newframe->Xoffset_top = rc;\
    newframe->Xims = re;\
    newframe->Xeptrb = rf;\
-Line 322 
 typedef struct heapframe {
+Line 333 
 typedef struct heapframe {
    /* Function arguments that may change */
-   const uschar *Xeptr;
+   USPTR Xeptr;
    const uschar *Xecode;
-   const uschar *Xmstart;
+   USPTR Xmstart;
+   USPTR Xmarkptr;
    int Xoffset_top;
    long int Xims;
    eptrblock *Xeptrb;
-Line 333 
 typedef struct heapframe {
+Line 345 
 typedef struct heapframe {
    /* Function local variables */
-   const uschar *Xcallpat;
+   USPTR Xcallpat;
-   const uschar *Xcharptr;
+ #ifdef SUPPORT_UTF8
-   const uschar *Xdata;
+   USPTR Xcharptr;
-   const uschar *Xnext;
+ #endif
-   const uschar *Xpp;
+   USPTR Xdata;
-   const uschar *Xprev;
+   USPTR Xnext;
-   const uschar *Xsaved_eptr;
+   USPTR Xpp;
+   USPTR Xprev;
+   USPTR Xsaved_eptr;
    recursion_info Xnew_recursive;
-Line 360 
 typedef struct heapframe {
+Line 374 
 typedef struct heapframe {
    uschar Xocchars[8];
  #endif
+   int Xcodelink;
    int Xctype;
    unsigned int Xfc;
    int Xfi;
-Line 395 
 typedef struct heapframe {
+Line 410 
 typedef struct heapframe {
  /* This function is called recursively in many circumstances. Whenever it
  returns a negative (error) response, the outer incarnation must also return the
- same response.
+ 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
+ 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
+ the subject. */
+ #define CHECK_PARTIAL()\
+   if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
+     {\
+     md->hitend = TRUE;\
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
+     }
+ #define SCHECK_PARTIAL()\
+   if (md->partial != 0 && eptr > mstart)\
+     {\
+     md->hitend = TRUE;\
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
+     }
- Performance note: It might be tempting to extract commonly used fields from the
+ /* Performance note: It might be tempting to extract commonly used fields from
- md structure (e.g. utf8, end_subject) into individual variables to improve
+ the md structure (e.g. utf8, 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 407 
 Arguments:
+Line 444 
 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
     ims         current /i, /m, and /s options
-Line 420 
 Arguments:
+Line 458 
 Arguments:
  Returns:       MATCH_MATCH if matched            )  these values are >= 0
                 MATCH_NOMATCH if failed to match  )
+                a negative MATCH_xxx value for PRUNE, SKIP, etc
                 a negative PCRE_ERROR_xxx value if aborted by an error condition
                   (e.g. stopped by repeated call or recursion limit)
  */
  static int
- match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
+ match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
-   int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
+   const uschar *markptr, int offset_top, match_data *md, unsigned long int ims,
-   int flags, unsigned int rdepth)
+   eptrblock *eptrb, int flags, unsigned int rdepth)
  {
  /* These variables do not need to be preserved over recursion in this function,
  so they can be ordinary variables in all cases. Mark some of them with
-Line 439 
 register unsigned int c;   /* Character
+Line 478 
 register unsigned int c;   /* Character
  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
  BOOL minimize, possessive; /* Quantifier options */
+ 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
-Line 454 
 frame->Xprevframe = NULL;            /*
+Line 494 
 frame->Xprevframe = NULL;            /*
  frame->Xeptr = eptr;
  frame->Xecode = ecode;
  frame->Xmstart = mstart;
+ frame->Xmarkptr = markptr;
  frame->Xoffset_top = offset_top;
  frame->Xims = ims;
  frame->Xeptrb = eptrb;
-Line 469 
 HEAP_RECURSE:
+Line 510 
 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 ims                frame->Xims
  #define eptrb              frame->Xeptrb
-Line 481 
 HEAP_RECURSE:
+Line 523 
 HEAP_RECURSE:
  #define charptr            frame->Xcharptr
  #endif
  #define callpat            frame->Xcallpat
+ #define codelink           frame->Xcodelink
  #define data               frame->Xdata
  #define next               frame->Xnext
  #define pp                 frame->Xpp
-Line 561 
 int oclength;
+Line 604 
 int oclength;
  uschar occhars[8];
  #endif
+ int codelink;
  int ctype;
  int length;
  int max;
-Line 594 
 TAIL_RECURSE:
+Line 638 
 TAIL_RECURSE:
  /* OK, now we can get on with the real code of the function. Recursive calls
  are specified by the macro RMATCH and RRETURN is used to return. When
  NO_RECURSE is *not* defined, these just turn into a recursive call to match()
- and a "return", respectively (possibly with some debugging if DEBUG is
+ and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
  defined). However, RMATCH isn't like a function call because it's quite a
  complicated macro. It has to be used in one particular way. This shouldn't,
  however, impact performance when true recursion is being used. */
-Line 636 
 for (;;)
+Line 680 
 for (;;)
    minimize = possessive = FALSE;
    op = *ecode;
-   /* For partial matching, remember if we ever hit the end of the subject after
-   matching at least one subject character. */
-   if (md->partial &&
-       eptr >= md->end_subject &&
-       eptr > mstart)
-     md->hitend = TRUE;
    switch(op)
      {
+     case OP_MARK:
+     markptr = ecode + 2;
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM55);
+     /* 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
+     argument. It is passed back in md->start_match_ptr (an overloading of that
+     variable). If it does match, we reset that variable to the current subject
+     position and return MATCH_SKIP. Otherwise, pass back the return code
+     unaltered. */
+     if (rrc == MATCH_SKIP_ARG &&
+         strcmp((char *)markptr, (char *)(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:
-     RRETURN(MATCH_NOMATCH);
+     MRRETURN(MATCH_NOMATCH);
+     case OP_COMMIT:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM52);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     MRRETURN(MATCH_COMMIT);
      case OP_PRUNE:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM51);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     RRETURN(MATCH_PRUNE);
+     MRRETURN(MATCH_PRUNE);
-     case OP_COMMIT:
+     case OP_PRUNE_ARG:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
-       ims, eptrb, flags, RM52);
+       ims, eptrb, flags, RM56);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     RRETURN(MATCH_COMMIT);
+     md->mark = ecode + 2;
+     RRETURN(MATCH_PRUNE);
      case OP_SKIP:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM53);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      md->start_match_ptr = eptr;   /* Pass back current position */
-     RRETURN(MATCH_SKIP);
+     MRRETURN(MATCH_SKIP);
+     case OP_SKIP_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM57);
+     if (rrc != MATCH_NOMATCH) 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
+     as PRUNE. */
+     md->start_match_ptr = ecode + 2;
+     RRETURN(MATCH_SKIP_ARG);
      case OP_THEN:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     MRRETURN(MATCH_THEN);
+     case OP_THEN_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM58);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->mark = ecode + 2;
      RRETURN(MATCH_THEN);
      /* Handle a capturing bracket. If there is space in the offset vector, save
-Line 693 
 for (;;)
+Line 778 
 for (;;)
      number = GET2(ecode, 1+LINK_SIZE);
      offset = number << 1;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
      printf("start bracket %d\n", number);
      printf("subject=");
      pchars(eptr, 16, TRUE, md);
-Line 727 
 for (;;)
+Line 812 
 for (;;)
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
+       if (rrc != MATCH_THEN) md->mark = markptr;
        RRETURN(MATCH_NOMATCH);
        }
-Line 766 
 for (;;)
+Line 852 
 for (;;)
          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
            eptrb, flags, RM48);
+         if (rrc == MATCH_NOMATCH) md->mark = markptr;
          RRETURN(rrc);
          }
-Line 787 
 for (;;)
+Line 874 
 for (;;)
      case OP_COND:
      case OP_SCOND:
-     if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */
+     codelink= GET(ecode, 1);
+     /* Because of the way auto-callout works during compile, a callout item is
+     inserted between OP_COND and an assertion condition. */
+     if (ecode[LINK_SIZE+1] == OP_CALLOUT)
        {
-       offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
+       if (pcre_callout != NULL)
-       condition = md->recursive != NULL &&
+         {
-         (offset == RREF_ANY || offset == md->recursive->group_num);
+         pcre_callout_block cb;
-       ecode += condition? 3 : GET(ecode, 1);
+         cb.version          = 1;   /* Version 1 of the callout block */
+         cb.callout_number   = ecode[LINK_SIZE+2];
+         cb.offset_vector    = md->offset_vector;
+         cb.subject          = (PCRE_SPTR)md->start_subject;
+         cb.subject_length   = md->end_subject - md->start_subject;
+         cb.start_match      = mstart - md->start_subject;
+         cb.current_position = eptr - md->start_subject;
+         cb.pattern_position = GET(ecode, LINK_SIZE + 3);
+         cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
+         cb.capture_top      = offset_top/2;
+         cb.capture_last     = md->capture_last;
+         cb.callout_data     = md->callout_data;
+         if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
+         if (rrc < 0) RRETURN(rrc);
+         }
+       ecode += _pcre_OP_lengths[OP_CALLOUT];
+       }
+     condcode = ecode[LINK_SIZE+1];
+     /* Now see what the actual condition is */
+     if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
+       {
+       if (md->recursive == NULL)                /* Not recursing => FALSE */
+         {
+         condition = FALSE;
+         ecode += GET(ecode, 1);
+         }
+       else
+         {
+         int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
+         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)
+           {
+           uschar *slotA = md->name_table;
+           for (i = 0; i < md->name_count; i++)
+             {
+             if (GET2(slotA, 0) == recno) break;
+             slotA += md->name_entry_size;
+             }
+           /* Found a name for the number - there can be only one; duplicate
+           names for different numbers are allowed, but not vice versa. First
+           scan down for duplicates. */
+           if (i < md->name_count)
+             {
+             uschar *slotB = slotA;
+             while (slotB > md->name_table)
+               {
+               slotB -= md->name_entry_size;
+               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                 {
+                 condition = GET2(slotB, 0) == md->recursive->group_num;
+                 if (condition) break;
+                 }
+               else break;
+               }
+             /* Scan up for duplicates */
+             if (!condition)
+               {
+               slotB = slotA;
+               for (i++; i < md->name_count; i++)
+                 {
+                 slotB += md->name_entry_size;
+                 if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                   {
+                   condition = GET2(slotB, 0) == md->recursive->group_num;
+                   if (condition) break;
+                   }
+                 else break;
+                 }
+               }
+             }
+           }
+         /* Chose branch according to the condition */
+         ecode += condition? 3 : GET(ecode, 1);
+         }
        }
-     else if (ecode[LINK_SIZE+1] == OP_CREF)    /* Group used test */
+     else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
        {
        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
        condition = offset < offset_top && md->offset_vector[offset] >= 0;
+       /* If the numbered capture is unset, but the reference was 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. This is tediously similar
+       to the code above, but not close enough to try to amalgamate. */
+       if (!condition && condcode == OP_NCREF)
+         {
+         int refno = offset >> 1;
+         uschar *slotA = md->name_table;
+         for (i = 0; i < md->name_count; i++)
+           {
+           if (GET2(slotA, 0) == refno) break;
+           slotA += md->name_entry_size;
+           }
+         /* Found a name for the number - there can be only one; duplicate names
+         for different numbers are allowed, but not vice versa. First scan down
+         for duplicates. */
+         if (i < md->name_count)
+           {
+           uschar *slotB = slotA;
+           while (slotB > md->name_table)
+             {
+             slotB -= md->name_entry_size;
+             if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+               {
+               offset = GET2(slotB, 0) << 1;
+               condition = offset < offset_top &&
+                 md->offset_vector[offset] >= 0;
+               if (condition) break;
+               }
+             else break;
+             }
+           /* Scan up for duplicates */
+           if (!condition)
+             {
+             slotB = slotA;
+             for (i++; i < md->name_count; i++)
+               {
+               slotB += md->name_entry_size;
+               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                 {
+                 offset = GET2(slotB, 0) << 1;
+                 condition = offset < offset_top &&
+                   md->offset_vector[offset] >= 0;
+                 if (condition) break;
+                 }
+               else break;
+               }
+             }
+           }
+         }
+       /* Chose branch according to the condition */
        ecode += condition? 3 : GET(ecode, 1);
        }
-     else if (ecode[LINK_SIZE+1] == OP_DEF)     /* DEFINE - always false */
+     else if (condcode == OP_DEF)     /* DEFINE - always false */
        {
        condition = FALSE;
        ecode += GET(ecode, 1);
-Line 829 
 for (;;)
+Line 1069 
 for (;;)
        else
          {
          condition = FALSE;
-         ecode += GET(ecode, 1);
+         ecode += codelink;
          }
        }
-Line 852 
 for (;;)
+Line 1092 
 for (;;)
          goto TAIL_RECURSE;
          }
        }
-     else                         /* Condition false & no 2nd alternative */
+     else                         /* Condition false & no alternative */
        {
        ecode += 1 + LINK_SIZE;
        }
      break;
+     /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
+     to close any currently open capturing brackets. */
+     case OP_CLOSE:
+     number = GET2(ecode, 1);
+     offset = number << 1;
+ #ifdef PCRE_DEBUG
+       printf("end bracket %d at *ACCEPT", number);
+       printf("\n");
+ #endif
+     md->capture_last = number;
+     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
+       {
+       md->offset_vector[offset] =
+         md->offset_vector[md->offset_end - number];
+       md->offset_vector[offset+1] = eptr - md->start_subject;
+       if (offset_top <= offset) offset_top = offset + 2;
+       }
+     ecode += 3;
+     break;
      /* End of the pattern, either real or forced. If we are in a top-level
      recursion, we should restore the offsets appropriately and continue from
      after the call. */
-Line 872 
 for (;;)
+Line 1136 
 for (;;)
        md->recursive = rec->prevrec;
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
-       mstart = rec->save_start;
+       offset_top = rec->save_offset_top;
        ims = original_ims;
        ecode = rec->after_call;
        break;
        }
-     /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
+     /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
-     string - backtracking will then try other alternatives, if any. */
+     set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
+     the subject. In both cases, backtracking will then try other alternatives,
+     if any. */
+     if (eptr == mstart &&
+         (md->notempty ||
+           (md->notempty_atstart &&
+             mstart == md->start_subject + md->start_offset)))
+       MRRETURN(MATCH_NOMATCH);
+     /* Otherwise, we have a match. */
-     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
      md->end_match_ptr = eptr;           /* Record where we ended */
      md->end_offset_top = offset_top;    /* and how many extracts were taken */
      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
-     RRETURN(MATCH_MATCH);
+     /* 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. */
+     rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
+     MRRETURN(rrc);
      /* Change option settings */
-Line 907 
 for (;;)
+Line 1185 
 for (;;)
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
          RM4);
-       if (rrc == MATCH_MATCH) break;
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
+         {
+         mstart = md->start_match_ptr;   /* In case \K reset it */
+         break;
+         }
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      while (*ecode == OP_ALT);
-     if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
+     if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
      /* If checking an assertion for a condition, return MATCH_MATCH. */
-Line 926 
 for (;;)
+Line 1208 
 for (;;)
      offset_top = md->end_offset_top;
      continue;
-     /* Negative assertion: all branches must fail to match */
+     /* Negative assertion: all branches must fail to match. Encountering SKIP,
+     PRUNE, or COMMIT means we must assume failure without checking subsequent
+     branches. */
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK_NOT:
-Line 934 
 for (;;)
+Line 1218 
 for (;;)
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
          RM5);
-       if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
+       if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
+         {
+         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+         break;
+         }
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
-Line 958 
 for (;;)
+Line 1247 
 for (;;)
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr);
          }
        }
-Line 969 
 for (;;)
+Line 1258 
 for (;;)
        {
        eptr -= GET(ecode, 1);
-       if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+       if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
        }
-     /* Skip to next op code */
+     /* Save the earliest consulted character, then skip to next op code */
+     if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
      ecode += 1 + LINK_SIZE;
      break;
-Line 997 
 for (;;)
+Line 1287 
 for (;;)
        cb.capture_top      = offset_top/2;
        cb.capture_last     = md->capture_last;
        cb.callout_data     = md->callout_data;
-       if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
+       if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
        if (rrc < 0) RRETURN(rrc);
        }
      ecode += 2 + 2*LINK_SIZE;
-Line 1052 
 for (;;)
+Line 1342 
 for (;;)
        memcpy(new_recursive.offset_save, md->offset_vector,
              new_recursive.saved_max * sizeof(int));
-       new_recursive.save_start = mstart;
+       new_recursive.save_offset_top = offset_top;
-       mstart = eptr;
        /* OK, now we can do the recursion. For each top-level alternative we
        restore the offset and recursion data. */
-Line 1064 
 for (;;)
+Line 1353 
 for (;;)
          {
          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
            md, ims, eptrb, flags, RM6);
-         if (rrc == MATCH_MATCH)
+         if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
            {
            DPRINTF(("Recursion matched\n"));
            md->recursive = new_recursive.prevrec;
            if (new_recursive.offset_save != stacksave)
              (pcre_free)(new_recursive.offset_save);
-           RRETURN(MATCH_MATCH);
+           MRRETURN(MATCH_MATCH);
            }
          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
+           if (new_recursive.offset_save != stacksave)
+             (pcre_free)(new_recursive.offset_save);
            RRETURN(rrc);
            }
-Line 1089 
 for (;;)
+Line 1380 
 for (;;)
        md->recursive = new_recursive.prevrec;
        if (new_recursive.offset_save != stacksave)
          (pcre_free)(new_recursive.offset_save);
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      /* Control never reaches here */
-Line 1098 
 for (;;)
+Line 1389 
 for (;;)
      a move back into the brackets. Friedl calls these "atomic" subpatterns.
      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. */
+     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:
      prev = ecode;
-Line 1107 
 for (;;)
+Line 1399 
 for (;;)
      do
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
-       if (rrc == MATCH_MATCH) break;
+       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
+         {
+         mstart = md->start_match_ptr;
+         break;
+         }
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
-Line 1226 
 for (;;)
+Line 1522 
 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 an atomic group, stop
-     MATCH_MATCH, but record the current high water mark for use by positive
+     matching and return MATCH_MATCH, but record the current high water mark for
-     assertions. Do this also for the "once" (atomic) groups. */
+     use by positive assertions. We also need to record the match start in case
+     it was changed by \K. */
      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
-Line 1236 
 for (;;)
+Line 1533 
 for (;;)
        {
        md->end_match_ptr = eptr;      /* For ONCE */
        md->end_offset_top = offset_top;
-       RRETURN(MATCH_MATCH);
+       md->start_match_ptr = mstart;
+       MRRETURN(MATCH_MATCH);
        }
      /* For capturing groups we have to check the group number back at the start
-Line 1250 
 for (;;)
+Line 1548 
 for (;;)
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
        printf("end bracket %d", number);
        printf("\n");
  #endif
-Line 1272 
 for (;;)
+Line 1570 
 for (;;)
          recursion_info *rec = md->recursive;
          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
          md->recursive = rec->prevrec;
-         mstart = rec->save_start;
          memcpy(md->offset_vector, rec->offset_save,
            rec->saved_max * sizeof(int));
+         offset_top = rec->save_offset_top;
          ecode = rec->after_call;
          ims = original_ims;
          break;
-Line 1331 
 for (;;)
+Line 1629 
 for (;;)
      /* Start of subject unless notbol, or after internal newline if multiline */
      case OP_CIRC:
-     if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
+     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr != md->start_subject &&
            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
        ecode++;
        break;
        }
-Line 1345 
 for (;;)
+Line 1643 
 for (;;)
      /* Start of subject assertion */
      case OP_SOD:
-     if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      /* Start of match assertion */
      case OP_SOM:
-     if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
+     if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1370 
 for (;;)
+Line 1668 
 for (;;)
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr < md->end_subject)
-         { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
+         { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
        else
-         { if (md->noteol) RRETURN(MATCH_NOMATCH); }
+         { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
        ecode++;
        break;
        }
      else
        {
-       if (md->noteol) RRETURN(MATCH_NOMATCH);
+       if (md->noteol) MRRETURN(MATCH_NOMATCH);
        if (!md->endonly)
          {
          if (eptr != md->end_subject &&
              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          ecode++;
          break;
          }
-Line 1393 
 for (;;)
+Line 1691 
 for (;;)
      /* End of subject assertion (\z) */
      case OP_EOD:
-     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1402 
 for (;;)
+Line 1700 
 for (;;)
      case OP_EODN:
      if (eptr != md->end_subject &&
          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1414 
 for (;;)
+Line 1712 
 for (;;)
        /* Find out if the previous and current characters are "word" characters.
        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
-       be "non-word" characters. */
+       be "non-word" characters. Remember the earliest consulted character for
+       partial matching. */
  #ifdef SUPPORT_UTF8
        if (utf8)
          {
          if (eptr == md->start_subject) prev_is_word = FALSE; else
            {
-           const uschar *lastptr = eptr - 1;
+           USPTR lastptr = eptr - 1;
            while((*lastptr & 0xc0) == 0x80) lastptr--;
+           if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
            GETCHAR(c, lastptr);
            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
            }
-         if (eptr >= md->end_subject) cur_is_word = FALSE; else
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           cur_is_word = FALSE;
+           }
+         else
            {
            GETCHAR(c, eptr);
            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
-Line 1435 
 for (;;)
+Line 1740 
 for (;;)
        else
  #endif
-       /* More streamlined when not in UTF-8 mode */
+       /* Not in UTF-8 mode */
          {
-         prev_is_word = (eptr != md->start_subject) &&
+         if (eptr == md->start_subject) prev_is_word = FALSE; else
-           ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+           {
-         cur_is_word = (eptr < md->end_subject) &&
+           if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
-           ((md->ctypes[*eptr] & ctype_word) != 0);
+           prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+           }
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           cur_is_word = FALSE;
+           }
+         else cur_is_word = ((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)
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
        }
      break;
      /* Match a single character type; inline for speed */
      case OP_ANY:
-     if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+     if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
      /* Fall through */
      case OP_ALLANY:
-     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr++ >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
      ecode++;
      break;
-Line 1468 
 for (;;)
+Line 1784 
 for (;;)
      any byte, even newline, independent of the setting of PCRE_DOTALL. */
      case OP_ANYBYTE:
-     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr++ >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      ecode++;
      break;
      case OP_NOT_DIGIT:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1481 
 for (;;)
+Line 1805 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_DIGIT:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1494 
 for (;;)
+Line 1822 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_NOT_WHITESPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1507 
 for (;;)
+Line 1839 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_WHITESPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1520 
 for (;;)
+Line 1856 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_NOT_WORDCHAR:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1533 
 for (;;)
+Line 1873 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_WORDCHAR:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1546 
 for (;;)
+Line 1890 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      case OP_ANYNL:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: RRETURN(MATCH_NOMATCH);
+       default: MRRETURN(MATCH_NOMATCH);
        case 0x000d:
        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
        break;
-Line 1568 
 for (;;)
+Line 1916 
 for (;;)
        case 0x0085:
        case 0x2028:
        case 0x2029:
-       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+       if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
        break;
        }
      ecode++;
      break;
      case OP_NOT_HSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1599 
 for (;;)
+Line 1951 
 for (;;)
        case 0x202f:    /* NARROW NO-BREAK SPACE */
        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
        case 0x3000:    /* IDEOGRAPHIC SPACE */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
      case OP_HSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: RRETURN(MATCH_NOMATCH);
+       default: MRRETURN(MATCH_NOMATCH);
        case 0x09:      /* HT */
        case 0x20:      /* SPACE */
        case 0xa0:      /* NBSP */
-Line 1635 
 for (;;)
+Line 1991 
 for (;;)
      break;
      case OP_NOT_VSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1647 
 for (;;)
+Line 2007 
 for (;;)
        case 0x85:      /* NEL */
        case 0x2028:    /* LINE SEPARATOR */
        case 0x2029:    /* PARAGRAPH SEPARATOR */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
      case OP_VSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: RRETURN(MATCH_NOMATCH);
+       default: MRRETURN(MATCH_NOMATCH);
        case 0x0a:      /* LF */
        case 0x0b:      /* VT */
        case 0x0c:      /* FF */
-Line 1676 
 for (;;)
+Line 2040 
 for (;;)
      case OP_PROP:
      case OP_NOTPROP:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
        {
-       const ucd_record * prop = GET_UCD(c);
+       const ucd_record *prop = GET_UCD(c);
        switch(ecode[1])
          {
          case PT_ANY:
-         if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
+         if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
          break;
          case PT_LAMP:
          if ((prop->chartype == ucp_Lu ||
               prop->chartype == ucp_Ll ||
               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
           break;
          case PT_GC:
          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          case PT_PC:
          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          case PT_SC:
          if ((ecode[2] != prop->script) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          default:
-Line 1721 
 for (;;)
+Line 2089 
 for (;;)
      is in the binary; otherwise a compile-time error occurs. */
      case OP_EXTUNI:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
        {
        int category = UCD_CATEGORY(c);
-       if (category == ucp_M) RRETURN(MATCH_NOMATCH);
+       if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
        while (eptr < md->end_subject)
          {
          int len = 1;
-Line 1801 
 for (;;)
+Line 2173 
 for (;;)
          break;
          default:               /* No repeat follows */
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         if (!match_ref(offset, eptr, length, md, ims))
+           {
+           CHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
          eptr += length;
          continue;              /* With the main loop */
          }
-Line 1817 
 for (;;)
+Line 2193 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         if (!match_ref(offset, eptr, length, md, ims))
+           {
+           CHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
          eptr += length;
          }
-Line 1834 
 for (;;)
+Line 2214 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || !match_ref(offset, eptr, length, md, ims))
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             RRETURN(MATCH_NOMATCH);
+           if (!match_ref(offset, eptr, length, md, ims))
+             {
+             CHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            eptr += length;
            }
          /* Control never gets here */
-Line 1848 
 for (;;)
+Line 2232 
 for (;;)
          pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (!match_ref(offset, eptr, length, md, ims)) break;
+           if (!match_ref(offset, eptr, length, md, ims))
+             {
+             CHECK_PARTIAL();
+             break;
+             }
            eptr += length;
            }
          while (eptr >= pp)
-Line 1857 
 for (;;)
+Line 2245 
 for (;;)
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            eptr -= length;
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
      /* Match a bit-mapped character class, possibly repeatedly. This op code is
      used when all the characters in the class have values in the range 0-255,
      and either the matching is caseful, or the characters are in the range
-Line 1918 
 for (;;)
+Line 2304 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            if (c > 255)
              {
-             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+             if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
              }
            else
              {
-             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+             if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
              }
            }
          }
-Line 1936 
 for (;;)
+Line 2326 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            c = *eptr++;
-           if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+           if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
            }
          }
-Line 1960 
 for (;;)
+Line 2354 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              if (c > 255)
                {
-               if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+               if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
                }
              else
                {
-               if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+               if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
                }
              }
            }
-Line 1980 
 for (;;)
+Line 2379 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              c = *eptr++;
-             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+             if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 2001 
 for (;;)
+Line 2405 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c > 255)
                {
-Line 2027 
 for (;;)
+Line 2435 
 for (;;)
            {
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              c = *eptr;
              if ((data[c/8] & (1 << (c&7))) == 0) break;
              eptr++;
-Line 2040 
 for (;;)
+Line 2452 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
      /* Match an extended character class. This opcode is encountered only
-     in UTF-8 mode, because that's the only time it is compiled. */
+     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
      case OP_XCLASS:
-Line 2088 
 for (;;)
+Line 2501 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr >= md->end_subject)
-         GETCHARINC(c, eptr);
+           {
-         if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+           SCHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
+         GETCHARINCTEST(c, eptr);
+         if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
          }
        /* If max == min we can continue with the main loop without the
-Line 2107 
 for (;;)
+Line 2524 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-           GETCHARINC(c, eptr);
+           if (eptr >= md->end_subject)
-           if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           GETCHARINCTEST(c, eptr);
+           if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2122 
 for (;;)
+Line 2544 
 for (;;)
          for (i = min; i < max; i++)
            {
            int len = 1;
-           if (eptr >= md->end_subject) break;
+           if (eptr >= md->end_subject)
-           GETCHARLEN(c, eptr, len);
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
+           GETCHARLENTEST(c, eptr, len);
            if (!_pcre_xclass(c, data)) break;
            eptr += len;
            }
-Line 2134 
 for (;;)
+Line 2560 
 for (;;)
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            if (utf8) BACKCHAR(eptr);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
-Line 2150 
 for (;;)
+Line 2576 
 for (;;)
        length = 1;
        ecode++;
        GETCHARLEN(fc, ecode, length);
-       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+       if (length > md->end_subject - eptr)
-       while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
+         {
+         CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
+         MRRETURN(MATCH_NOMATCH);
+         }
+       while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
        }
      else
  #endif
      /* Non-UTF-8 mode */
        {
-       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
+       if (md->end_subject - eptr < 1)
-       if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
+         {
+         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
+         MRRETURN(MATCH_NOMATCH);
+         }
+       if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
      break;
-Line 2174 
 for (;;)
+Line 2608 
 for (;;)
        ecode++;
        GETCHARLEN(fc, ecode, length);
-       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+       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. */
        if (fc < 128)
          {
-         if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+         if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
          }
        /* Otherwise we must pick up the subject character */
-Line 2200 
 for (;;)
+Line 2638 
 for (;;)
  #ifdef SUPPORT_UCP
            if (dc != UCD_OTHERCASE(fc))
  #endif
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          }
        }
-Line 2209 
 for (;;)
+Line 2647 
 for (;;)
      /* Non-UTF-8 mode */
        {
-       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
+       if (md->end_subject - eptr < 1)
-       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+         {
+         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
+         MRRETURN(MATCH_NOMATCH);
+         }
+       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
      break;
-Line 2263 
 for (;;)
+Line 2705 
 for (;;)
      case OP_MINQUERY:
      c = *ecode++ - OP_STAR;
      minimize = (c & 1) != 0;
      min = rep_min[c];                 /* Pick up values from tables; */
      max = rep_max[c];                 /* zero for max => infinity */
      if (max == 0) max = INT_MAX;
-     /* Common code for all repeated single-character matches. We can give
+     /* Common code for all repeated single-character matches. */
-     up quickly if there are fewer than the minimum number of characters left in
-     the subject. */
      REPEATCHAR:
  #ifdef SUPPORT_UTF8
-Line 2278 
 for (;;)
+Line 2719 
 for (;;)
        length = 1;
        charptr = ecode;
        GETCHARLEN(fc, ecode, length);
-       if (min * length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
        ecode += length;
        /* Handle multibyte character matching specially here. There is
-Line 2296 
 for (;;)
+Line 2736 
 for (;;)
          for (i = 1; i <= min; i++)
            {
-           if (memcmp(eptr, charptr, length) == 0) eptr += length;
+           if (eptr <= md->end_subject - length &&
+             memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-           /* Need braces because of following else */
+           else if (oclength > 0 &&
-           else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
+                    eptr <= md->end_subject - oclength &&
+                    memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+ #endif  /* SUPPORT_UCP */
            else
              {
-             if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
+             CHECK_PARTIAL();
-             eptr += oclength;
+             MRRETURN(MATCH_NOMATCH);
              }
- #else   /* without SUPPORT_UCP */
-           else { RRETURN(MATCH_NOMATCH); }
- #endif  /* SUPPORT_UCP */
            }
          if (min == max) continue;
-Line 2318 
 for (;;)
+Line 2758 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             if (memcmp(eptr, charptr, length) == 0) eptr += length;
+             if (eptr <= md->end_subject - length &&
+               memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-             /* Need braces because of following else */
+             else if (oclength > 0 &&
-             else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
+                      eptr <= md->end_subject - oclength &&
+                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+ #endif  /* SUPPORT_UCP */
              else
                {
-               if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
+               CHECK_PARTIAL();
-               eptr += oclength;
+               MRRETURN(MATCH_NOMATCH);
                }
- #else   /* without SUPPORT_UCP */
-             else { RRETURN (MATCH_NOMATCH); }
- #endif  /* SUPPORT_UCP */
              }
            /* Control never gets here */
            }
-Line 2340 
 for (;;)
+Line 2780 
 for (;;)
            pp = eptr;
            for (i = min; i < max; i++)
              {
-             if (eptr > md->end_subject - length) break;
+             if (eptr <= md->end_subject - length &&
-             if (memcmp(eptr, charptr, length) == 0) eptr += length;
+                 memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-             else if (oclength == 0) break;
+             else if (oclength > 0 &&
+                      eptr <= md->end_subject - oclength &&
+                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+ #endif  /* SUPPORT_UCP */
              else
                {
-               if (memcmp(eptr, occhars, oclength) != 0) break;
+               CHECK_PARTIAL();
-               eptr += oclength;
+               break;
                }
- #else   /* without SUPPORT_UCP */
-             else break;
- #endif  /* SUPPORT_UCP */
              }
            if (possessive) continue;
            for(;;)
-            {
+             {
-            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-            if (eptr == pp) RRETURN(MATCH_NOMATCH);
+             if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
  #ifdef SUPPORT_UCP
-            eptr--;
+             eptr--;
-            BACKCHAR(eptr);
+             BACKCHAR(eptr);
  #else   /* without SUPPORT_UCP */
-            eptr -= length;
+             eptr -= length;
  #endif  /* SUPPORT_UCP */
-            }
+             }
            }
          /* Control never gets here */
          }
-Line 2379 
 for (;;)
+Line 2820 
 for (;;)
  #endif  /* SUPPORT_UTF8 */
      /* When not in UTF-8 mode, load a single-byte character. */
-       {
-       if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+     fc = *ecode++;
-       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
-Line 2400 
 for (;;)
+Line 2839 
 for (;;)
        {
        fc = md->lcc[fc];
        for (i = 1; i <= min; i++)
-         if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+         {
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
+         if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+         }
        if (min == max) continue;
        if (minimize)
          {
-Line 2408 
 for (;;)
+Line 2854 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-               fc != md->lcc[*eptr++])
+           if (eptr >= md->end_subject)
-             RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2419 
 for (;;)
+Line 2869 
 for (;;)
          pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
+           if (fc != md->lcc[*eptr]) break;
            eptr++;
            }
          if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2438 
 for (;;)
+Line 2895 
 for (;;)
      else
        {
-       for (i = 1; i <= min; i++) if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
+       for (i = 1; i <= min; i++)
+         {
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
+         if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
+         }
        if (min == max) continue;
        if (minimize)
          {
          for (fi = min;; fi++)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2456 
 for (;;)
+Line 2928 
 for (;;)
          pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || fc != *eptr) break;
+           if (eptr >= md->end_subject)
-           eptr++;
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
+           if (fc != *eptr) break;
+           eptr++;
            }
          if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2475 
 for (;;)
+Line 2953 
 for (;;)
      checking can be multibyte. */
      case OP_NOT:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
+       }
      ecode++;
      GETCHARINCTEST(c, eptr);
      if ((ims & PCRE_CASELESS) != 0)
-Line 2484 
 for (;;)
+Line 2966 
 for (;;)
        if (c < 256)
  #endif
        c = md->lcc[c];
-       if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);
+       if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
        }
      else
        {
-       if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
+       if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
        }
      break;
-Line 2552 
 for (;;)
+Line 3034 
 for (;;)
      max = rep_max[c];                 /* zero for max => infinity */
      if (max == 0) max = INT_MAX;
-     /* Common code for all repeated single-byte matches. We can give up quickly
+     /* Common code for all repeated single-byte matches. */
-     if there are fewer than the minimum number of bytes left in the
-     subject. */
      REPEATNOTCHAR:
-     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
      fc = *ecode++;
      /* The code is duplicated for the caseless and caseful cases, for speed,
-Line 2582 
 for (;;)
+Line 3061 
 for (;;)
          register unsigned int d;
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(d, eptr);
            if (d < 256) d = md->lcc[d];
-           if (fc == d) RRETURN(MATCH_NOMATCH);
+           if (fc == d) MRRETURN(MATCH_NOMATCH);
            }
          }
        else
-Line 2593 
 for (;;)
+Line 3077 
 for (;;)
        /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
-           if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
+           }
          }
        if (min == max) continue;
-Line 2609 
 for (;;)
+Line 3100 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(d, eptr);
              if (d < 256) d = md->lcc[d];
-             if (fc == d) RRETURN(MATCH_NOMATCH);
+             if (fc == d) MRRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 2624 
 for (;;)
+Line 3119 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
-               RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 2645 
 for (;;)
+Line 3145 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(d, eptr, len);
              if (d < 256) d = md->lcc[d];
              if (fc == d) break;
-Line 2666 
 for (;;)
+Line 3170 
 for (;;)
            {
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             if (fc == md->lcc[*eptr]) break;
              eptr++;
              }
            if (possessive) continue;
-Line 2678 
 for (;;)
+Line 3187 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2694 
 for (;;)
+Line 3203 
 for (;;)
          register unsigned int d;
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(d, eptr);
-           if (fc == d) RRETURN(MATCH_NOMATCH);
+           if (fc == d) MRRETURN(MATCH_NOMATCH);
            }
          }
        else
-Line 2703 
 for (;;)
+Line 3217 
 for (;;)
        /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
-           if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
+           }
          }
        if (min == max) continue;
-Line 2719 
 for (;;)
+Line 3240 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(d, eptr);
-             if (fc == d) RRETURN(MATCH_NOMATCH);
+             if (fc == d) MRRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 2732 
 for (;;)
+Line 3258 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
-               RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 2753 
 for (;;)
+Line 3284 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(d, eptr, len);
              if (fc == d) break;
              eptr += len;
-Line 2773 
 for (;;)
+Line 3308 
 for (;;)
            {
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || fc == *eptr) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             if (fc == *eptr) break;
              eptr++;
              }
            if (possessive) continue;
-Line 2785 
 for (;;)
+Line 3325 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2867 
 for (;;)
+Line 3407 
 for (;;)
      /* First, ensure the minimum number of matches are present. Use inline
      code for maximizing the speed, and do the type test once at the start
-     (i.e. keep it out of the loop). Also we can test that there are at least
+     (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
-     the minimum number of bytes before we start. This isn't as effective in
-     UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
      is tidier. Also separate the UCP code, which can be the same for both UTF-8
      and single-bytes. */
-     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
      if (min > 0)
        {
  #ifdef SUPPORT_UCP
-Line 2882 
 for (;;)
+Line 3419 
 for (;;)
          switch(prop_type)
            {
            case PT_ANY:
-           if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+           if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              }
            break;
-Line 2893 
 for (;;)
+Line 3434 
 for (;;)
            case PT_LAMP:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
                   prop_chartype == ucp_Lt) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
            case PT_GC:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
            case PT_PC:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
            case PT_SC:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 2948 
 for (;;)
+Line 3505 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
-           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
+           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr; else
+             if (!utf8) c = *eptr;
-               {
+               else { GETCHARLEN(c, eptr, len); }
-               GETCHARLEN(c, eptr, len);
-               }
              prop_category = UCD_CATEGORY(c);
              if (prop_category != ucp_M) break;
              eptr += len;
-Line 2976 
 for (;;)
+Line 3536 
 for (;;)
          case OP_ANY:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject || IS_NEWLINE(eptr))
+           if (eptr >= md->end_subject)
-             RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
-Line 2986 
 for (;;)
+Line 3550 
 for (;;)
          case OP_ALLANY:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
          break;
          case OP_ANYBYTE:
+         if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
          eptr += min;
          break;
          case OP_ANYNL:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
-Line 3016 
 for (;;)
+Line 3589 
 for (;;)
              case 0x0085:
              case 0x2028:
              case 0x2029:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3025 
 for (;;)
+Line 3598 
 for (;;)
          case OP_NOT_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3049 
 for (;;)
+Line 3626 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3057 
 for (;;)
+Line 3634 
 for (;;)
          case OP_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-Line 3089 
 for (;;)
+Line 3670 
 for (;;)
          case OP_NOT_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3101 
 for (;;)
+Line 3686 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3109 
 for (;;)
+Line 3694 
 for (;;)
          case OP_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x0a:      /* LF */
              case 0x0b:      /* VT */
              case 0x0c:      /* FF */
-Line 3129 
 for (;;)
+Line 3718 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          break;
          case OP_DIGIT:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3149 
 for (;;)
+Line 3746 
 for (;;)
          case OP_NOT_WHITESPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
+             MRRETURN(MATCH_NOMATCH);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 3159 
 for (;;)
+Line 3760 
 for (;;)
          case OP_WHITESPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3169 
 for (;;)
+Line 3774 
 for (;;)
          case OP_NOT_WORDCHAR:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
+             MRRETURN(MATCH_NOMATCH);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 3179 
 for (;;)
+Line 3788 
 for (;;)
          case OP_WORDCHAR:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3194 
 for (;;)
+Line 3807 
 for (;;)
  #endif     /* SUPPORT_UTF8 */
        /* Code for the non-UTF-8 case for minimum matching of operators other
-       than OP_PROP and OP_NOTPROP. We can assume that there are the minimum
+       than OP_PROP and OP_NOTPROP. */
-       number of bytes present, as this was tested above. */
        switch(ctype)
          {
          case OP_ANY:
          for (i = 1; i <= min; i++)
            {
-           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
            eptr++;
            }
          break;
          case OP_ALLANY:
+         if (eptr > md->end_subject - min)
+           {
+           SCHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
          eptr += min;
          break;
          case OP_ANYBYTE:
+         if (eptr > md->end_subject - min)
+           {
+           SCHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
          eptr += min;
          break;
-         /* Because of the CRLF case, we can't assume the minimum number of
-         bytes are present in this case. */
          case OP_ANYNL:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
-Line 3234 
 for (;;)
+Line 3862 
 for (;;)
              case 0x000b:
              case 0x000c:
              case 0x0085:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3243 
 for (;;)
+Line 3871 
 for (;;)
          case OP_NOT_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: break;
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3258 
 for (;;)
+Line 3890 
 for (;;)
          case OP_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-Line 3273 
 for (;;)
+Line 3909 
 for (;;)
          case OP_NOT_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: break;
-Line 3282 
 for (;;)
+Line 3922 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3290 
 for (;;)
+Line 3930 
 for (;;)
          case OP_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x0a:      /* LF */
              case 0x0b:      /* VT */
              case 0x0c:      /* FF */
-Line 3306 
 for (;;)
+Line 3950 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_DIGIT:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_NOT_WHITESPACE:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_WHITESPACE:
          for (i = 1; i <= min; i++)
-           if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_NOT_WORDCHAR:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_word) != 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_WORDCHAR:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_word) == 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
+           }
          break;
          default:
-Line 3361 
 for (;;)
+Line 4047 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
-             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+             if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3372 
 for (;;)
+Line 4063 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
                   prop_chartype == ucp_Lt) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3387 
 for (;;)
+Line 4083 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3400 
 for (;;)
+Line 4101 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3413 
 for (;;)
+Line 4119 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3435 
 for (;;)
+Line 4146 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
-           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
+           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr; else
+             if (!utf8) c = *eptr;
-               {
+               else { GETCHARLEN(c, eptr, len); }
-               GETCHARLEN(c, eptr, len);
-               }
              prop_category = UCD_CATEGORY(c);
              if (prop_category != ucp_M) break;
              eptr += len;
-Line 3464 
 for (;;)
+Line 4178 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-                (ctype == OP_ANY && IS_NEWLINE(eptr)))
+           if (eptr >= md->end_subject)
-             RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (ctype == OP_ANY && IS_NEWLINE(eptr))
+             MRRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            switch(ctype)
              {
-Line 3479 
 for (;;)
+Line 4197 
 for (;;)
              case OP_ANYNL:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x000d:
                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
                break;
-Line 3491 
 for (;;)
+Line 4209 
 for (;;)
                case 0x0085:
                case 0x2028:
                case 0x2029:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 3519 
 for (;;)
+Line 4237 
 for (;;)
                case 0x202f:    /* NARROW NO-BREAK SPACE */
                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
                case 0x3000:    /* IDEOGRAPHIC SPACE */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_HSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x09:      /* HT */
                case 0x20:      /* SPACE */
                case 0xa0:      /* NBSP */
-Line 3561 
 for (;;)
+Line 4279 
 for (;;)
                case 0x85:      /* NEL */
                case 0x2028:    /* LINE SEPARATOR */
                case 0x2029:    /* PARAGRAPH SEPARATOR */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_VSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x0a:      /* LF */
                case 0x0b:      /* VT */
                case 0x0c:      /* FF */
-Line 3582 
 for (;;)
+Line 4300 
 for (;;)
              case OP_NOT_DIGIT:
              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_DIGIT:
              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WHITESPACE:
              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WHITESPACE:
              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WORDCHAR:
              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WORDCHAR:
              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              default:
-Line 3623 
 for (;;)
+Line 4341 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-                (ctype == OP_ANY && IS_NEWLINE(eptr)))
+           if (eptr >= md->end_subject)
-             RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (ctype == OP_ANY && IS_NEWLINE(eptr))
+             MRRETURN(MATCH_NOMATCH);
            c = *eptr++;
            switch(ctype)
              {
-Line 3638 
 for (;;)
+Line 4360 
 for (;;)
              case OP_ANYNL:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x000d:
                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
                break;
-Line 3649 
 for (;;)
+Line 4371 
 for (;;)
                case 0x000b:
                case 0x000c:
                case 0x0085:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 3661 
 for (;;)
+Line 4383 
 for (;;)
                case 0x09:      /* HT */
                case 0x20:      /* SPACE */
                case 0xa0:      /* NBSP */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_HSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x09:      /* HT */
                case 0x20:      /* SPACE */
                case 0xa0:      /* NBSP */
-Line 3685 
 for (;;)
+Line 4407 
 for (;;)
                case 0x0c:      /* FF */
                case 0x0d:      /* CR */
                case 0x85:      /* NEL */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_VSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x0a:      /* LF */
                case 0x0b:      /* VT */
                case 0x0c:      /* FF */
-Line 3703 
 for (;;)
+Line 4425 
 for (;;)
              break;
              case OP_NOT_DIGIT:
-             if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_DIGIT:
-             if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WHITESPACE:
-             if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WHITESPACE:
-             if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+             if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WORDCHAR:
-             if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WORDCHAR:
-             if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
              break;
              default:
-Line 3751 
 for (;;)
+Line 4473 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (prop_fail_result) break;
              eptr+= len;
-Line 3762 
 for (;;)
+Line 4488 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
-Line 3777 
 for (;;)
+Line 4507 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
-Line 3790 
 for (;;)
+Line 4524 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
-Line 3803 
 for (;;)
+Line 4541 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
-Line 3832 
 for (;;)
+Line 4574 
 for (;;)
          {
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject) break;
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
            if (prop_category == ucp_M) break;
-Line 3852 
 for (;;)
+Line 4598 
 for (;;)
          /* eptr is now past the end of the maximum run */
          if (possessive) continue;
          for(;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
-Line 3887 
 for (;;)
+Line 4634 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
+               if (IS_NEWLINE(eptr)) break;
                eptr++;
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
-Line 3899 
 for (;;)
+Line 4651 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
+               if (IS_NEWLINE(eptr)) break;
                eptr++;
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
-Line 3911 
 for (;;)
+Line 4668 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
                eptr++;
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
-Line 3924 
 for (;;)
+Line 4685 
 for (;;)
            case OP_ANYBYTE:
            c = max - min;
            if (c > (unsigned int)(md->end_subject - eptr))
-             c = md->end_subject - eptr;
+             {
-           eptr += c;
+             eptr = md->end_subject;
+             SCHECK_PARTIAL();
+             }
+           else eptr += c;
            break;
            case OP_ANYNL:
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c == 0x000d)
                {
-Line 3957 
 for (;;)
+Line 4725 
 for (;;)
              {
              BOOL gotspace;
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              switch(c)
                {
-Line 3995 
 for (;;)
+Line 4767 
 for (;;)
              {
              BOOL gotspace;
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              switch(c)
                {
-Line 4019 
 for (;;)
+Line 4795 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
              eptr+= len;
-Line 4030 
 for (;;)
+Line 4810 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
              eptr+= len;
-Line 4041 
 for (;;)
+Line 4825 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
              eptr+= len;
-Line 4052 
 for (;;)
+Line 4840 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
              eptr+= len;
-Line 4063 
 for (;;)
+Line 4855 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
              eptr+= len;
-Line 4074 
 for (;;)
+Line 4870 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
              eptr+= len;
-Line 4106 
 for (;;)
+Line 4906 
 for (;;)
            case OP_ANY:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             if (IS_NEWLINE(eptr)) break;
              eptr++;
              }
            break;
-Line 4115 
 for (;;)
+Line 4920 
 for (;;)
            case OP_ANYBYTE:
            c = max - min;
            if (c > (unsigned int)(md->end_subject - eptr))
-             c = md->end_subject - eptr;
+             {
-           eptr += c;
+             eptr = md->end_subject;
+             SCHECK_PARTIAL();
+             }
+           else eptr += c;
            break;
            case OP_ANYNL:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              c = *eptr;
              if (c == 0x000d)
                {
-Line 4143 
 for (;;)
+Line 4955 
 for (;;)
            case OP_NOT_HSPACE:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              c = *eptr;
              if (c == 0x09 || c == 0x20 || c == 0xa0) break;
              eptr++;
-Line 4153 
 for (;;)
+Line 4969 
 for (;;)
            case OP_HSPACE:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              c = *eptr;
              if (c != 0x09 && c != 0x20 && c != 0xa0) break;
              eptr++;
-Line 4163 
 for (;;)
+Line 4983 
 for (;;)
            case OP_NOT_VSPACE:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              c = *eptr;
              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
                break;
-Line 4174 
 for (;;)
+Line 4998 
 for (;;)
            case OP_VSPACE:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              c = *eptr;
              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
                break;
-Line 4185 
 for (;;)
+Line 5013 
 for (;;)
            case OP_NOT_DIGIT:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                break;
+               }
+             if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
              eptr++;
              }
            break;
-Line 4194 
 for (;;)
+Line 5026 
 for (;;)
            case OP_DIGIT:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                break;
+               }
+             if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
              eptr++;
              }
            break;
-Line 4203 
 for (;;)
+Line 5039 
 for (;;)
            case OP_NOT_WHITESPACE:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                break;
+               }
+             if ((md->ctypes[*eptr] & ctype_space) != 0) break;
              eptr++;
              }
            break;
-Line 4212 
 for (;;)
+Line 5052 
 for (;;)
            case OP_WHITESPACE:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                break;
+               }
+             if ((md->ctypes[*eptr] & ctype_space) == 0) break;
              eptr++;
              }
            break;
-Line 4221 
 for (;;)
+Line 5065 
 for (;;)
            case OP_NOT_WORDCHAR:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                break;
+               }
+             if ((md->ctypes[*eptr] & ctype_word) != 0) break;
              eptr++;
              }
            break;
-Line 4230 
 for (;;)
+Line 5078 
 for (;;)
            case OP_WORDCHAR:
            for (i = min; i < max; i++)
              {
-             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                break;
+               }
+             if ((md->ctypes[*eptr] & ctype_word) == 0) break;
              eptr++;
              }
            break;
-Line 4253 
 for (;;)
+Line 5105 
 for (;;)
        /* Get here if we can't make it match with any permitted repetitions */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 4286 
 switch (frame->Xwhere)
+Line 5138 
 switch (frame->Xwhere)
    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
-   LBL(53) LBL(54)
+   LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
  #ifdef SUPPORT_UTF8
    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
    LBL(32) LBL(34) LBL(42) LBL(46)
-Line 4409 
 const uschar *tables;
+Line 5261 
 const uschar *tables;
  const uschar *start_bits = NULL;
  USPTR start_match = (USPTR)subject + start_offset;
  USPTR end_subject;
+ USPTR start_partial = NULL;
  USPTR req_byte_ptr = start_match - 1;
  pcre_study_data internal_study;
-Line 4425 
 if (re == NULL || subject == NULL ||
+Line 5278 
 if (re == NULL || subject == NULL ||
     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
+ /* This information is for finding all the numbers associated with a given
+ name, for condition testing. */
+ md->name_table = (uschar *)re + re->name_table_offset;
+ md->name_count = re->name_count;
+ md->name_entry_size = re->name_entry_size;
  /* Fish out the optional data from the extra_data structure, first setting
  the default values. */
-Line 4492 
 md->jscript_compat = (re->options & PCRE
+Line 5352 
 md->jscript_compat = (re->options & PCRE
  md->notbol = (options & PCRE_NOTBOL) != 0;
  md->noteol = (options & PCRE_NOTEOL) != 0;
  md->notempty = (options & PCRE_NOTEMPTY) != 0;
- md->partial = (options & PCRE_PARTIAL) != 0;
+ md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
+ md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
+               ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
  md->hitend = FALSE;
+ md->mark = NULL;                        /* In case never set */
  md->recursive = NULL;                   /* No recursion at top level */
-Line 4533 
 switch ((((options & PCRE_NEWLINE_BITS)
+Line 5396 
 switch ((((options & PCRE_NEWLINE_BITS)
          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
    {
    case 0: newline = NEWLINE; break;   /* Compile-time default */
-   case PCRE_NEWLINE_CR: newline = '\r'; break;
+   case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
-   case PCRE_NEWLINE_LF: newline = '\n'; break;
+   case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
    case PCRE_NEWLINE_CR+
-        PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
+        PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
    case PCRE_NEWLINE_ANY: newline = -1; break;
    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
    default: return PCRE_ERROR_BADNEWLINE;
-Line 4566 
 else
+Line 5429 
 else
      }
    }
- /* Partial matching is supported only for a restricted set of regexes at the
+ /* Partial matching was originally supported only for a restricted set of
- moment. */
+ regexes; from release 8.00 there are no restrictions, but the bits are still
+ defined (though never set). So there's no harm in leaving this code. */
  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)