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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 403 by ph10,
Sat Mar 21 17:33:11 2009 UTC
+revision 597 by ph10,
Mon May  2 17:08:52 2011 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2009 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 122 
 while (length-- > 0)
+Line 132 
 while (length-- > 0)
  *          Match a back-reference                *
  *************************************************/
- /* If a back reference hasn't been set, the length that is passed is greater
+ /* Normally, if a back reference hasn't been set, the length that is passed is
- than the number of characters left in the string, so the match fails.
+ negative, so the match always fails. However, in JavaScript compatibility mode,
+ the length passed is zero. Note that in caseless UTF-8 mode, the number of
+ subject bytes matched may be different to the number of reference bytes.
  Arguments:
    offset      index into the offset vector
-   eptr        points into the subject
+   eptr        pointer into the subject
-   length      length to be matched
+   length      length of reference to be matched (number of bytes)
    md          points to match data block
    ims         the ims flags
- Returns:      TRUE if matched
+ Returns:      < 0 if not matched, otherwise the number of subject bytes matched
  */
- static BOOL
+ static int
  match_ref(int offset, register USPTR eptr, int length, match_data *md,
    unsigned long int ims)
  {
- USPTR p = md->start_subject + md->offset_vector[offset];
+ USPTR eptr_start = eptr;
+ register 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 154 
 pchars(p, length, FALSE, md);
+Line 167 
 pchars(p, length, FALSE, md);
  printf("\n");
  #endif
- /* Always fail if not enough characters left */
+ /* Always fail if reference not set (and not JavaScript compatible). */
- if (length > md->end_subject - eptr) return FALSE;
+ if (length < 0) return -1;
  /* Separate the caseless case for speed. In UTF-8 mode we can only do this
  properly if Unicode properties are supported. Otherwise, we can check only
-Line 168 
 if ((ims & PCRE_CASELESS) != 0)
+Line 181 
 if ((ims & PCRE_CASELESS) != 0)
  #ifdef SUPPORT_UCP
    if (md->utf8)
      {
-     USPTR endptr = eptr + length;
+     /* Match characters up to the end of the reference. NOTE: the number of
-     while (eptr < endptr)
+     bytes matched may differ, because there are some characters whose upper and
+     lower case versions code as different numbers of bytes. For example, U+023A
+     (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);
+     a sequence of 3 of the former uses 6 bytes, as does a sequence of two of
+     the latter. It is important, therefore, to check the length along the
+     reference, not along the subject (earlier code did this wrong). */
+     USPTR endptr = p + length;
+     while (p < endptr)
        {
        int c, d;
+       if (eptr >= md->end_subject) return -1;
        GETCHARINC(c, eptr);
        GETCHARINC(d, p);
-       if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
+       if (c != d && c != UCD_OTHERCASE(d)) return -1;
        }
      }
    else
-Line 183 
 if ((ims & PCRE_CASELESS) != 0)
+Line 205 
 if ((ims & PCRE_CASELESS) != 0)
    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
    is no UCP support. */
+     {
-   while (length-- > 0)
+     if (eptr + length > md->end_subject) return -1;
-     { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
+     while (length-- > 0)
+       { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
+     }
    }
  /* In the caseful case, we can just compare the bytes, whether or not we
  are in UTF-8 mode. */
  else
-   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
+   {
+   if (eptr + length > md->end_subject) return -1;
+   while (length-- > 0) if (*p++ != *eptr++) return -1;
+   }
- return TRUE;
+ return eptr - eptr_start;
  }
-Line 245 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 272 
 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, RM59, RM60,
+        RM61,  RM62 };
  /* 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 296 
 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 283 
 argument of match(), which never changes
+Line 311 
 argument of match(), which never changes
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
    {\
-   heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
+   heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
+   if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
    frame->Xwhere = rw; \
    newframe->Xeptr = ra;\
    newframe->Xecode = rb;\
    newframe->Xmstart = mstart;\
+   newframe->Xmarkptr = markptr;\
    newframe->Xoffset_top = rc;\
    newframe->Xims = re;\
    newframe->Xeptrb = rf;\
-Line 303 
 argument of match(), which never changes
+Line 333 
 argument of match(), which never changes
  #define RRETURN(ra)\
    {\
-   heapframe *newframe = frame;\
+   heapframe *oldframe = frame;\
-   frame = newframe->Xprevframe;\
+   frame = oldframe->Xprevframe;\
-   (pcre_stack_free)(newframe);\
+   (pcre_stack_free)(oldframe);\
    if (frame != NULL)\
      {\
      rrc = ra;\
-Line 322 
 typedef struct heapframe {
+Line 352 
 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 364 
 typedef struct heapframe {
    /* Function local variables */
-   const uschar *Xcallpat;
+   USPTR Xcallpat;
  #ifdef SUPPORT_UTF8
-   const uschar *Xcharptr;
+   USPTR Xcharptr;
  #endif
-   const uschar *Xdata;
+   USPTR Xdata;
-   const uschar *Xnext;
+   USPTR Xnext;
-   const uschar *Xpp;
+   USPTR Xpp;
-   const uschar *Xprev;
+   USPTR Xprev;
-   const uschar *Xsaved_eptr;
+   USPTR Xsaved_eptr;
    recursion_info Xnew_recursive;
-Line 398 
 typedef struct heapframe {
+Line 429 
 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 > md->start_used_ptr) \
+     { \
+     md->hitend = TRUE; \
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
+     }
- Performance note: It might be tempting to extract commonly used fields from the
+ #define SCHECK_PARTIAL()\
- md structure (e.g. utf8, end_subject) into individual variables to improve
+   if (md->partial != 0 && eptr > md->start_used_ptr) \
+     { \
+     md->hitend = TRUE; \
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
+     }
+ /* Performance note: It might be tempting to extract commonly used fields from
+ the md structure (e.g. utf8, end_subject) into individual variables to improve
  performance. Tests using gcc on a SPARC disproved this; in the first case, it
  made performance worse.
-Line 410 
 Arguments:
+Line 464 
 Arguments:
     ecode       pointer to current position in compiled code
     mstart      pointer to the current match start position (can be modified
                   by encountering \K)
+    markptr     pointer to the most recent MARK name, or NULL
     offset_top  current top pointer
     md          pointer to "static" info for the match
     ims         current /i, /m, and /s options
-Line 423 
 Arguments:
+Line 478 
 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 450 
 heap storage. Set up the top-level frame
+Line 506 
 heap storage. Set up the top-level frame
  heap whenever RMATCH() does a "recursion". See the macro definitions above. */
  #ifdef NO_RECURSE
- heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
+ heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
+ if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
  frame->Xprevframe = NULL;            /* Marks the top level */
  /* Copy in the original argument variables */
-Line 458 
 frame->Xprevframe = NULL;            /*
+Line 515 
 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 473 
 HEAP_RECURSE:
+Line 531 
 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 600 
 TAIL_RECURSE:
+Line 659 
 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 641 
 for (;;)
+Line 700 
 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);
+     /* COMMIT overrides PRUNE, SKIP, and THEN */
+     case OP_COMMIT:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM52);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
+         rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
+         rrc != MATCH_THEN)
+       RRETURN(rrc);
+     MRRETURN(MATCH_COMMIT);
+     /* PRUNE overrides THEN */
      case OP_PRUNE:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM51);
-     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+     MRRETURN(MATCH_PRUNE);
+     case OP_PRUNE_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM56);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+     md->mark = ecode + 2;
      RRETURN(MATCH_PRUNE);
-     case OP_COMMIT:
+     /* SKIP overrides PRUNE and THEN */
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-       ims, eptrb, flags, RM52);
-     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     RRETURN(MATCH_COMMIT);
      case OP_SKIP:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM53);
-     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
+       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 && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
+       RRETURN(rrc);
+     /* Pass back the current skip name by overloading md->start_match_ptr and
+     returning the special MATCH_SKIP_ARG return code. This will either be
+     caught by a matching MARK, or get to the top, where it is treated the same
+     as PRUNE. */
+     md->start_match_ptr = ecode + 2;
+     RRETURN(MATCH_SKIP_ARG);
+     /* For THEN (and THEN_ARG) we pass back the address of the bracket or
+     the alt that is at the start of the current branch. This makes it possible
+     to skip back past alternatives that precede the THEN within the current
+     branch. */
      case OP_THEN:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->start_match_ptr = ecode - GET(ecode, 1);
+     MRRETURN(MATCH_THEN);
+     case OP_THEN_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
+       offset_top, md, ims, eptrb, flags, RM58);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->mark = ecode + LINK_SIZE + 2;
      RRETURN(MATCH_THEN);
      /* Handle a capturing bracket. If there is space in the offset vector, save
-Line 699 
 for (;;)
+Line 817 
 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 714 
 for (;;)
+Line 832 
 for (;;)
        save_capture_last = md->capture_last;
        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
-       md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
+       md->offset_vector[md->offset_end - number] =
+         (int)(eptr - md->start_subject);
        flags = (op == OP_SCBRA)? match_cbegroup : 0;
        do
          {
          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
            ims, eptrb, flags, RM1);
-         if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+         if (rrc != MATCH_NOMATCH &&
+             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+           RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          }
-Line 733 
 for (;;)
+Line 854 
 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 772 
 for (;;)
+Line 894 
 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 780 
 for (;;)
+Line 903 
 for (;;)
        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
          eptrb, flags, RM2);
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      /* Control never reaches here. */
-Line 794 
 for (;;)
+Line 919 
 for (;;)
      case OP_COND:
      case OP_SCOND:
      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. */
-Line 807 
 for (;;)
+Line 932 
 for (;;)
          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.subject_length   = (int)(md->end_subject - md->start_subject);
-         cb.start_match      = mstart - md->start_subject;
+         cb.start_match      = (int)(mstart - md->start_subject);
-         cb.current_position = eptr - md->start_subject;
+         cb.current_position = (int)(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) RRETURN(MATCH_NOMATCH);
+         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)         /* Recursion test */
+     if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
        {
-       offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
+       if (md->recursive == NULL)                /* Not recursing => FALSE */
-       condition = md->recursive != NULL &&
+         {
-         (offset == RREF_ANY || offset == md->recursive->group_num);
+         condition = FALSE;
-       ecode += condition? 3 : GET(ecode, 1);
+         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 (condcode == 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);
        }
-Line 860 
 for (;;)
+Line 1106 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+       else if (rrc != MATCH_NOMATCH &&
+               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
-Line 897 
 for (;;)
+Line 1144 
 for (;;)
      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] = (int)(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 910 
 for (;;)
+Line 1181 
 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 945 
 for (;;)
+Line 1230 
 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)
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+         {
+         mstart = md->start_match_ptr;   /* In case \K reset it */
+         break;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         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 964 
 for (;;)
+Line 1255 
 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 972 
 for (;;)
+Line 1265 
 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_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+       if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
+         {
+         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+         break;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 996 
 for (;;)
+Line 1296 
 for (;;)
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr);
          }
        }
-Line 1007 
 for (;;)
+Line 1307 
 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 1027 
 for (;;)
+Line 1328 
 for (;;)
        cb.callout_number   = ecode[1];
        cb.offset_vector    = md->offset_vector;
        cb.subject          = (PCRE_SPTR)md->start_subject;
-       cb.subject_length   = md->end_subject - md->start_subject;
+       cb.subject_length   = (int)(md->end_subject - md->start_subject);
-       cb.start_match      = mstart - md->start_subject;
+       cb.start_match      = (int)(mstart - md->start_subject);
-       cb.current_position = eptr - md->start_subject;
+       cb.current_position = (int)(eptr - md->start_subject);
        cb.pattern_position = GET(ecode, 2);
        cb.next_item_length = GET(ecode, 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) RRETURN(MATCH_NOMATCH);
+       if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
        if (rrc < 0) RRETURN(rrc);
        }
      ecode += 2 + 2*LINK_SIZE;
-Line 1090 
 for (;;)
+Line 1391 
 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 1102 
 for (;;)
+Line 1402 
 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)
+         else if (rrc != MATCH_NOMATCH &&
+                 (rrc != MATCH_THEN || md->start_match_ptr != ecode))
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
            if (new_recursive.offset_save != stacksave)
-Line 1129 
 for (;;)
+Line 1430 
 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 1138 
 for (;;)
+Line 1439 
 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 1147 
 for (;;)
+Line 1449 
 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 */
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+         {
+         mstart = md->start_match_ptr;
+         break;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 1266 
 for (;;)
+Line 1574 
 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 1276 
 for (;;)
+Line 1585 
 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 1290 
 for (;;)
+Line 1600 
 for (;;)
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
        printf("end bracket %d", number);
        printf("\n");
  #endif
-Line 1300 
 for (;;)
+Line 1610 
 for (;;)
          {
          md->offset_vector[offset] =
            md->offset_vector[md->offset_end - number];
-         md->offset_vector[offset+1] = eptr - md->start_subject;
+         md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
          if (offset_top <= offset) offset_top = offset + 2;
          }
-Line 1312 
 for (;;)
+Line 1622 
 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 1371 
 for (;;)
+Line 1681 
 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 1385 
 for (;;)
+Line 1695 
 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 1410 
 for (;;)
+Line 1720 
 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);
+         SCHECK_PARTIAL();
+         }
        ecode++;
        break;
        }
-     else
+     else  /* Not multiline */
        {
-       if (md->noteol) RRETURN(MATCH_NOMATCH);
+       if (md->noteol) MRRETURN(MATCH_NOMATCH);
-       if (!md->endonly)
+       if (!md->endonly) goto ASSERT_NL_OR_EOS;
-         {
-         if (eptr != md->end_subject &&
-             (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-           RRETURN(MATCH_NOMATCH);
-         ecode++;
-         break;
-         }
        }
      /* ... else fall through for endonly */
      /* End of subject assertion (\z) */
      case OP_EOD:
-     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
+     SCHECK_PARTIAL();
      ecode++;
      break;
      /* End of subject or ending \n assertion (\Z) */
      case OP_EODN:
-     if (eptr != md->end_subject &&
+     ASSERT_NL_OR_EOS:
+     if (eptr < md->end_subject &&
          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
+     /* Either at end of string or \n before end. */
+     SCHECK_PARTIAL();
      ecode++;
      break;
-Line 1454 
 for (;;)
+Line 1767 
 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)
          {
+         /* Get status of previous character */
          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);
+ #ifdef SUPPORT_UCP
+           if (md->use_ucp)
+             {
+             if (c == '_') prev_is_word = TRUE; else
+               {
+               int cat = UCD_CATEGORY(c);
+               prev_is_word = (cat == ucp_L || cat == ucp_N);
+               }
+             }
+           else
+ #endif
            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
            }
-         if (eptr >= md->end_subject) cur_is_word = FALSE; else
+         /* Get status of next character */
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           cur_is_word = FALSE;
+           }
+         else
            {
            GETCHAR(c, eptr);
+ #ifdef SUPPORT_UCP
+           if (md->use_ucp)
+             {
+             if (c == '_') cur_is_word = TRUE; else
+               {
+               int cat = UCD_CATEGORY(c);
+               cur_is_word = (cat == ucp_L || cat == ucp_N);
+               }
+             }
+           else
+ #endif
            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
            }
          }
        else
  #endif
-       /* More streamlined when not in UTF-8 mode */
+       /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
+       consistency with the behaviour of \w we do use it in this case. */
          {
-         prev_is_word = (eptr != md->start_subject) &&
+         /* Get status of previous character */
-           ((md->ctypes[eptr[-1]] & ctype_word) != 0);
-         cur_is_word = (eptr < md->end_subject) &&
+         if (eptr == md->start_subject) prev_is_word = FALSE; else
-           ((md->ctypes[*eptr] & ctype_word) != 0);
+           {
+           if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
+ #ifdef SUPPORT_UCP
+           if (md->use_ucp)
+             {
+             c = eptr[-1];
+             if (c == '_') prev_is_word = TRUE; else
+               {
+               int cat = UCD_CATEGORY(c);
+               prev_is_word = (cat == ucp_L || cat == ucp_N);
+               }
+             }
+           else
+ #endif
+           prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+           }
+         /* Get status of next character */
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           cur_is_word = FALSE;
+           }
+         else
+ #ifdef SUPPORT_UCP
+         if (md->use_ucp)
+           {
+           c = *eptr;
+           if (c == '_') cur_is_word = TRUE; else
+             {
+             int cat = UCD_CATEGORY(c);
+             cur_is_word = (cat == ucp_L || cat == ucp_N);
+             }
+           }
+         else
+ #endif
+         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 1508 
 for (;;)
+Line 1897 
 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 1521 
 for (;;)
+Line 1918 
 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 1534 
 for (;;)
+Line 1935 
 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 1547 
 for (;;)
+Line 1952 
 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 1560 
 for (;;)
+Line 1969 
 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 1573 
 for (;;)
+Line 1986 
 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 1586 
 for (;;)
+Line 2003 
 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 1608 
 for (;;)
+Line 2029 
 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 1639 
 for (;;)
+Line 2064 
 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 1675 
 for (;;)
+Line 2104 
 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 1687 
 for (;;)
+Line 2120 
 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 1716 
 for (;;)
+Line 2153 
 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);
-Line 1724 
 for (;;)
+Line 2165 
 for (;;)
        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;
+         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;
+         /* These are specials */
+         case PT_ALNUM:
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+              _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         case PT_SPACE:    /* Perl space */
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+              c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
+                == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         case PT_PXSPACE:  /* POSIX space */
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+              c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+              c == CHAR_FF || c == CHAR_CR)
+                == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         case PT_WORD:
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+              _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+              c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
          break;
+         /* This should never occur */
          default:
          RRETURN(PCRE_ERROR_INTERNAL);
          }
-Line 1761 
 for (;;)
+Line 2234 
 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 1792 
 for (;;)
+Line 2269 
 for (;;)
      loops). */
      case OP_REF:
-       {
+     offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
-       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
+     ecode += 3;
-       ecode += 3;
-       /* If the reference is unset, there are two possibilities:
+     /* If the reference is unset, there are two possibilities:
-       (a) In the default, Perl-compatible state, set the length to be longer
+     (a) In the default, Perl-compatible state, set the length negative;
-       than the amount of subject left; this ensures that every attempt at a
+     this ensures that every attempt at a match fails. We can't just fail
-       match fails. We can't just fail here, because of the possibility of
+     here, because of the possibility of quantifiers with zero minima.
-       quantifiers with zero minima.
-       (b) If the JavaScript compatibility flag is set, set the length to zero
+     (b) If the JavaScript compatibility flag is set, set the length to zero
-       so that the back reference matches an empty string.
+     so that the back reference matches an empty string.
-       Otherwise, set the length to the length of what was matched by the
+     Otherwise, set the length to the length of what was matched by the
-       referenced subpattern. */
+     referenced subpattern. */
-       if (offset >= offset_top || md->offset_vector[offset] < 0)
+     if (offset >= offset_top || md->offset_vector[offset] < 0)
-         length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;
+       length = (md->jscript_compat)? 0 : -1;
-       else
+     else
-         length = md->offset_vector[offset+1] - md->offset_vector[offset];
+       length = md->offset_vector[offset+1] - md->offset_vector[offset];
-       /* Set up for repetition, or handle the non-repeated case */
+     /* Set up for repetition, or handle the non-repeated case */
-       switch (*ecode)
+     switch (*ecode)
-         {
+       {
-         case OP_CRSTAR:
+       case OP_CRSTAR:
-         case OP_CRMINSTAR:
+       case OP_CRMINSTAR:
-         case OP_CRPLUS:
+       case OP_CRPLUS:
-         case OP_CRMINPLUS:
+       case OP_CRMINPLUS:
-         case OP_CRQUERY:
+       case OP_CRQUERY:
-         case OP_CRMINQUERY:
+       case OP_CRMINQUERY:
-         c = *ecode++ - OP_CRSTAR;
+       c = *ecode++ - OP_CRSTAR;
-         minimize = (c & 1) != 0;
+       minimize = (c & 1) != 0;
-         min = rep_min[c];                 /* Pick up values from tables; */
+       min = rep_min[c];                 /* Pick up values from tables; */
-         max = rep_max[c];                 /* zero for max => infinity */
+       max = rep_max[c];                 /* zero for max => infinity */
-         if (max == 0) max = INT_MAX;
+       if (max == 0) max = INT_MAX;
-         break;
+       break;
-         case OP_CRRANGE:
+       case OP_CRRANGE:
-         case OP_CRMINRANGE:
+       case OP_CRMINRANGE:
-         minimize = (*ecode == OP_CRMINRANGE);
+       minimize = (*ecode == OP_CRMINRANGE);
-         min = GET2(ecode, 1);
+       min = GET2(ecode, 1);
-         max = GET2(ecode, 3);
+       max = GET2(ecode, 3);
-         if (max == 0) max = INT_MAX;
+       if (max == 0) max = INT_MAX;
-         ecode += 5;
+       ecode += 5;
-         break;
+       break;
-         default:               /* No repeat follows */
+       default:               /* No repeat follows */
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+       if ((length = match_ref(offset, eptr, length, md, ims)) < 0)
-         eptr += length;
+         {
-         continue;              /* With the main loop */
+         CHECK_PARTIAL();
+         MRRETURN(MATCH_NOMATCH);
          }
+       eptr += length;
+       continue;              /* With the main loop */
+       }
-       /* If the length of the reference is zero, just continue with the
+     /* Handle repeated back references. If the length of the reference is
-       main loop. */
+     zero, just continue with the main loop. */
-       if (length == 0) continue;
+     if (length == 0) continue;
-       /* First, ensure the minimum number of matches are present. We get back
+     /* First, ensure the minimum number of matches are present. We get back
-       the length of the reference string explicitly rather than passing the
+     the length of the reference string explicitly rather than passing the
-       address of eptr, so that eptr can be a register variable. */
+     address of eptr, so that eptr can be a register variable. */
-       for (i = 1; i <= min; i++)
+     for (i = 1; i <= min; i++)
+       {
+       int slength;
+       if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
          {
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         CHECK_PARTIAL();
-         eptr += length;
+         MRRETURN(MATCH_NOMATCH);
          }
+       eptr += slength;
+       }
-       /* If min = max, continue at the same level without recursion.
+     /* If min = max, continue at the same level without recursion.
-       They are not both allowed to be zero. */
+     They are not both allowed to be zero. */
-       if (min == max) continue;
+     if (min == max) continue;
-       /* If minimizing, keep trying and advancing the pointer */
+     /* If minimizing, keep trying and advancing the pointer */
-       if (minimize)
+     if (minimize)
+       {
+       for (fi = min;; fi++)
          {
-         for (fi = min;; fi++)
+         int slength;
+         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         if (fi >= max) MRRETURN(MATCH_NOMATCH);
+         if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
+           CHECK_PARTIAL();
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           MRRETURN(MATCH_NOMATCH);
-           if (fi >= max || !match_ref(offset, eptr, length, md, ims))
-             RRETURN(MATCH_NOMATCH);
-           eptr += length;
            }
-         /* Control never gets here */
+         eptr += slength;
          }
+       /* Control never gets here */
+       }
-       /* If maximizing, find the longest string and work backwards */
+     /* If maximizing, find the longest string and work backwards */
-       else
+     else
+       {
+       pp = eptr;
+       for (i = min; i < max; i++)
          {
-         pp = eptr;
+         int slength;
-         for (i = min; i < max; i++)
+         if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
            {
-           if (!match_ref(offset, eptr, length, md, ims)) break;
+           CHECK_PARTIAL();
-           eptr += length;
+           break;
-           }
-         while (eptr >= pp)
-           {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           eptr -= length;
            }
-         RRETURN(MATCH_NOMATCH);
+         eptr += slength;
          }
+       while (eptr >= pp)
+         {
+         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         eptr -= length;
+         }
+       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 1958 
 for (;;)
+Line 2449 
 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 1976 
 for (;;)
+Line 2471 
 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 2000 
 for (;;)
+Line 2499 
 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 2020 
 for (;;)
+Line 2524 
 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 2041 
 for (;;)
+Line 2550 
 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 2067 
 for (;;)
+Line 2580 
 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 2080 
 for (;;)
+Line 2597 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2129 
 for (;;)
+Line 2646 
 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);
+           }
          GETCHARINCTEST(c, eptr);
-         if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+         if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
          }
        /* If max == min we can continue with the main loop without the
-Line 2148 
 for (;;)
+Line 2669 
 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);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
-           if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+           if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2163 
 for (;;)
+Line 2689 
 for (;;)
          for (i = min; i < max; i++)
            {
            int len = 1;
-           if (eptr >= md->end_subject) break;
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
            GETCHARLENTEST(c, eptr, len);
            if (!_pcre_xclass(c, data)) break;
            eptr += len;
-Line 2175 
 for (;;)
+Line 2705 
 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 2191 
 for (;;)
+Line 2721 
 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 2215 
 for (;;)
+Line 2753 
 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 2241 
 for (;;)
+Line 2783 
 for (;;)
  #ifdef SUPPORT_UCP
            if (dc != UCD_OTHERCASE(fc))
  #endif
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          }
        }
-Line 2250 
 for (;;)
+Line 2792 
 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 2304 
 for (;;)
+Line 2850 
 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 2319 
 for (;;)
+Line 2864 
 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 2337 
 for (;;)
+Line 2881 
 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 2359 
 for (;;)
+Line 2903 
 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 2381 
 for (;;)
+Line 2925 
 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 2420 
 for (;;)
+Line 2965 
 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 2441 
 for (;;)
+Line 2984 
 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 2449 
 for (;;)
+Line 2999 
 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 2460 
 for (;;)
+Line 3014 
 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 2479 
 for (;;)
+Line 3040 
 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 2497 
 for (;;)
+Line 3073 
 for (;;)
          pp = eptr;
          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;
          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 2516 
 for (;;)
+Line 3098 
 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 2525 
 for (;;)
+Line 3111 
 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 2593 
 for (;;)
+Line 3179 
 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 2623 
 for (;;)
+Line 3206 
 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 2634 
 for (;;)
+Line 3222 
 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 2650 
 for (;;)
+Line 3245 
 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 2665 
 for (;;)
+Line 3264 
 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 2686 
 for (;;)
+Line 3290 
 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 2707 
 for (;;)
+Line 3315 
 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 2719 
 for (;;)
+Line 3332 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2735 
 for (;;)
+Line 3348 
 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 2744 
 for (;;)
+Line 3362 
 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 2760 
 for (;;)
+Line 3385 
 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 2773 
 for (;;)
+Line 3403 
 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 2794 
 for (;;)
+Line 3429 
 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 2814 
 for (;;)
+Line 3453 
 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 2826 
 for (;;)
+Line 3470 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2908 
 for (;;)
+Line 3552 
 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 2923 
 for (;;)
+Line 3564 
 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 2934 
 for (;;)
+Line 3579 
 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;
+           case PT_ALNUM:
+           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_L || prop_category == ucp_N)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           case PT_SPACE:    /* Perl space */
+           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_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           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_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
+           case PT_WORD:
+           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_L || prop_category == ucp_N ||
+                  c == CHAR_UNDERSCORE)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           /* This should not occur */
            default:
            RRETURN(PCRE_ERROR_INTERNAL);
            }
-Line 2989 
 for (;;)
+Line 3719 
 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 3017 
 for (;;)
+Line 3750 
 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 3027 
 for (;;)
+Line 3764 
 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 3057 
 for (;;)
+Line 3803 
 for (;;)
              case 0x0085:
              case 0x2028:
              case 0x2029:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3066 
 for (;;)
+Line 3812 
 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 3090 
 for (;;)
+Line 3840 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3098 
 for (;;)
+Line 3848 
 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 3130 
 for (;;)
+Line 3884 
 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 3142 
 for (;;)
+Line 3900 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3150 
 for (;;)
+Line 3908 
 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 3170 
 for (;;)
+Line 3932 
 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 3190 
 for (;;)
+Line 3960 
 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 3200 
 for (;;)
+Line 3974 
 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 3210 
 for (;;)
+Line 3988 
 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 3220 
 for (;;)
+Line 4002 
 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 3235 
 for (;;)
+Line 4021 
 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 3275 
 for (;;)
+Line 4076 
 for (;;)
              case 0x000b:
              case 0x000c:
              case 0x0085:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3284 
 for (;;)
+Line 4085 
 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 3299 
 for (;;)
+Line 4104 
 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 3314 
 for (;;)
+Line 4123 
 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 3323 
 for (;;)
+Line 4136 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3331 
 for (;;)
+Line 4144 
 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 3347 
 for (;;)
+Line 4164 
 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 3402 
 for (;;)
+Line 4261 
 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);
-             GETCHARINC(c, eptr);
+             if (eptr >= md->end_subject)
-             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3413 
 for (;;)
+Line 4277 
 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);
-             GETCHARINC(c, eptr);
+             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);
+             }
+           /* Control never gets here */
+           case PT_GC:
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             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 == prop_value) == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           /* Control never gets here */
+           case PT_PC:
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             if (fi >= max) MRRETURN(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)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           /* Control never gets here */
+           case PT_SC:
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             if (fi >= max) MRRETURN(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)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           /* Control never gets here */
+           case PT_ALNUM:
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59);
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             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_L || prop_category == ucp_N)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-           case PT_GC:
+           case PT_SPACE:    /* Perl space */
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
              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)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
              prop_category = UCD_CATEGORY(c);
-             if ((prop_category == prop_value) == prop_fail_result)
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-               RRETURN(MATCH_NOMATCH);
+                  c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-           case PT_PC:
+           case PT_PXSPACE:  /* POSIX space */
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
              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)
-             prop_chartype = UCD_CHARTYPE(c);
+               {
-             if ((prop_chartype == prop_value) == prop_fail_result)
+               SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-           case PT_SC:
+           case PT_WORD:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
              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)
-             prop_script = UCD_SCRIPT(c);
+               {
-             if ((prop_script == prop_value) == prop_fail_result)
+               SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L ||
+                  prop_category == ucp_N ||
+                  c == CHAR_UNDERSCORE)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
+           /* This should never occur */
            default:
            RRETURN(PCRE_ERROR_INTERNAL);
            }
-Line 3476 
 for (;;)
+Line 4442 
 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 3505 
 for (;;)
+Line 4474 
 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 3520 
 for (;;)
+Line 4493 
 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 3532 
 for (;;)
+Line 4505 
 for (;;)
                case 0x0085:
                case 0x2028:
                case 0x2029:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 3560 
 for (;;)
+Line 4533 
 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 3602 
 for (;;)
+Line 4575 
 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 3623 
 for (;;)
+Line 4596 
 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 3664 
 for (;;)
+Line 4637 
 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 3679 
 for (;;)
+Line 4656 
 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 3690 
 for (;;)
+Line 4667 
 for (;;)
                case 0x000b:
                case 0x000c:
                case 0x0085:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 3702 
 for (;;)
+Line 4679 
 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 3726 
 for (;;)
+Line 4703 
 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 3744 
 for (;;)
+Line 4721 
 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 3792 
 for (;;)
+Line 4769 
 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 (prop_fail_result) break;
              eptr+= len;
              }
-Line 3803 
 for (;;)
+Line 4784 
 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);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
-Line 3818 
 for (;;)
+Line 4803 
 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);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
                break;
-Line 3831 
 for (;;)
+Line 4820 
 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);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
                break;
-Line 3844 
 for (;;)
+Line 4837 
 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);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
                break;
              eptr+= len;
              }
            break;
+           case PT_ALNUM:
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L || prop_category == ucp_N)
+                  == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           case PT_SPACE:    /* Perl space */
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_FF || c == CHAR_CR)
+                  == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
+                  == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           case PT_WORD:
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L || prop_category == ucp_N ||
+                  c == CHAR_UNDERSCORE) == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           default:
+           RRETURN(PCRE_ERROR_INTERNAL);
            }
          /* eptr is now past the end of the maximum run */
-Line 3873 
 for (;;)
+Line 4947 
 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 3893 
 for (;;)
+Line 4971 
 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 3928 
 for (;;)
+Line 5007 
 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 3940 
 for (;;)
+Line 5024 
 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 3952 
 for (;;)
+Line 5041 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
                eptr++;