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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 190 by ph10,
Thu Jul 19 10:38:20 2007 UTC
+revision 550 by ph10,
Sun Oct 10 16:24:11 2010 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2007 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 42 
 POSSIBILITY OF SUCH DAMAGE.
  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
  possible. There are also some static supporting functions. */
+ #ifdef HAVE_CONFIG_H
+ #include "config.h"
+ #endif
  #define NLBLOCK md             /* Block containing newline information */
  #define PSSTART start_subject  /* Field containing processed string start */
  #define PSEND   end_subject    /* Field containing processed string end */
-Line 53 
 possible. There are also some static sup
+Line 57 
 possible. There are also some static sup
  #undef min
  #undef max
- /* The chain of eptrblocks for tail recursions uses memory in stack workspace,
- obtained at top level, the size of which is defined by EPTR_WORK_SIZE. */
- #define EPTR_WORK_SIZE (1000)
  /* Flag bits for the match() function */
  #define match_condassert     0x01  /* Called to check a condition assertion */
  #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
- #define match_tail_recursed  0x04  /* Tail recursive call */
  /* Non-error returns from the match() function. Error returns are externally
  defined PCRE_ERROR_xxx codes, which are all negative. */
-Line 70 
 defined PCRE_ERROR_xxx codes, which are
+Line 68 
 defined PCRE_ERROR_xxx codes, which are
  #define MATCH_MATCH        1
  #define MATCH_NOMATCH      0
+ /* Special internal returns from the match() function. Make them sufficiently
+ negative to avoid the external error codes. */
+ #define MATCH_ACCEPT       (-999)
+ #define MATCH_COMMIT       (-998)
+ #define MATCH_PRUNE        (-997)
+ #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,
  because the offset vector is always a multiple of 3 long. */
-Line 83 
 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 135 
 match_ref(int offset, register USPTR ept
+Line 151 
 match_ref(int offset, register USPTR ept
  {
  USPTR p = md->start_subject + md->offset_vector[offset];
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (eptr >= md->end_subject)
    printf("matching subject <null>");
  else
-Line 152 
 printf("\n");
+Line 168 
 printf("\n");
  if (length > md->end_subject - eptr) return FALSE;
- /* Separate the caselesss case for speed */
+ /* 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
+ ASCII characters. */
  if ((ims & PCRE_CASELESS) != 0)
    {
+ #ifdef SUPPORT_UTF8
+ #ifdef SUPPORT_UCP
+   if (md->utf8)
+     {
+     USPTR endptr = eptr + length;
+     while (eptr < endptr)
+       {
+       int c, d;
+       GETCHARINC(c, eptr);
+       GETCHARINC(d, p);
+       if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
+       }
+     }
+   else
+ #endif
+ #endif
+   /* 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 (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;
+     { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
    }
+ /* 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; }
-Line 205 
 variable instead of being passed in the
+Line 247 
 variable instead of being passed in the
  ****************************************************************************
  ***************************************************************************/
+ /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
- /* Numbers for RMATCH calls */
+ below must be updated in sync.  */
  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
         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 };
+        RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
+        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 236 
 actuall used in this definition. */
+Line 279 
 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 252 
 argument of match(), which never changes
+Line 295 
 argument of match(), which never changes
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
    {\
    heapframe *newframe = (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 271 
 argument of match(), which never changes
+Line 316 
 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 290 
 typedef struct heapframe {
+Line 335 
 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 301 
 typedef struct heapframe {
+Line 347 
 typedef struct heapframe {
    /* Function local variables */
-   const uschar *Xcallpat;
+   USPTR Xcallpat;
-   const uschar *Xcharptr;
+ #ifdef SUPPORT_UTF8
-   const uschar *Xdata;
+   USPTR Xcharptr;
-   const uschar *Xnext;
+ #endif
-   const uschar *Xpp;
+   USPTR Xdata;
-   const uschar *Xprev;
+   USPTR Xnext;
-   const uschar *Xsaved_eptr;
+   USPTR Xpp;
+   USPTR Xprev;
+   USPTR Xsaved_eptr;
    recursion_info Xnew_recursive;
-Line 328 
 typedef struct heapframe {
+Line 376 
 typedef struct heapframe {
    uschar Xocchars[8];
  #endif
+   int Xcodelink;
    int Xctype;
    unsigned int Xfc;
    int Xfi;
-Line 363 
 typedef struct heapframe {
+Line 412 
 typedef struct heapframe {
  /* This function is called recursively in many circumstances. Whenever it
  returns a negative (error) response, the outer incarnation must also return the
- same response.
+ same response. */
+ /* These macros pack up tests that are used for partial matching, and which
+ appears several times in the code. We set the "hit end" flag if the pointer is
+ at the end of the subject and also past the start of the subject (i.e.
+ something has been matched). For hard partial matching, we then return
+ immediately. The second one is used when we already know we are past the end of
+ the subject. */
+ #define CHECK_PARTIAL()\
+   if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
+     {\
+     md->hitend = TRUE;\
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
+     }
+ #define SCHECK_PARTIAL()\
+   if (md->partial != 0 && eptr > mstart)\
+     {\
+     md->hitend = TRUE;\
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
+     }
- Performance note: It might be tempting to extract commonly used fields from the
- md structure (e.g. utf8, end_subject) into individual variables to improve
+ /* 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 375 
 Arguments:
+Line 446 
 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 384 
 Arguments:
+Line 456 
 Arguments:
                   match_condassert - this is an assertion condition
                   match_cbegroup - this is the start of an unlimited repeat
                     group that can match an empty string
-                  match_tail_recursed - this is a tail_recursed group
     rdepth      the recursion depth
  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 408 
 register unsigned int c;   /* Character
+Line 480 
 register unsigned int c;   /* Character
  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
  BOOL minimize, possessive; /* Quantifier options */
+ int condcode;
  /* When recursion is not being used, all "local" variables that have to be
  preserved over calls to RMATCH() are part of a "frame" which is obtained from
-Line 416 
 heap whenever RMATCH() does a "recursion
+Line 489 
 heap whenever RMATCH() does a "recursion
  #ifdef NO_RECURSE
  heapframe *frame = (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 423 
 frame->Xprevframe = NULL;            /*
+Line 497 
 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 438 
 HEAP_RECURSE:
+Line 513 
 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 450 
 HEAP_RECURSE:
+Line 526 
 HEAP_RECURSE:
  #define charptr            frame->Xcharptr
  #endif
  #define callpat            frame->Xcallpat
+ #define codelink           frame->Xcodelink
  #define data               frame->Xdata
  #define next               frame->Xnext
  #define pp                 frame->Xpp
-Line 530 
 int oclength;
+Line 607 
 int oclength;
  uschar occhars[8];
  #endif
+ int codelink;
  int ctype;
  int length;
  int max;
-Line 563 
 TAIL_RECURSE:
+Line 641 
 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 586 
 original_ims = ims;    /* Save for reset
+Line 664 
 original_ims = ims;    /* Save for reset
  string, the match_cbegroup flag is set. When this is the case, add the current
  subject pointer to the chain of such remembered pointers, to be checked when we
  hit the closing ket, in order to break infinite loops that match no characters.
- When match() is called in other circumstances, don't add to the chain. If this
+ When match() is called in other circumstances, don't add to the chain. The
- is a tail recursion, use a block from the workspace, as the one on the stack is
+ match_cbegroup flag must NOT be used with tail recursion, because the memory
- already used. */
+ block that is used is on the stack, so a new one may be required for each
+ match(). */
  if ((flags & match_cbegroup) != 0)
    {
-   eptrblock *p;
+   newptrb.epb_saved_eptr = eptr;
-   if ((flags & match_tail_recursed) != 0)
+   newptrb.epb_prev = eptrb;
-     {
+   eptrb = &newptrb;
-     if (md->eptrn >= EPTR_WORK_SIZE) RRETURN(PCRE_ERROR_NULLWSLIMIT);
-     p = md->eptrchain + md->eptrn++;
-     }
-   else p = &newptrb;
-   p->epb_saved_eptr = eptr;
-   p->epb_prev = eptrb;
-   eptrb = p;
    }
  /* Now start processing the opcodes. */
-Line 611 
 for (;;)
+Line 683 
 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:
+     MRRETURN(MATCH_NOMATCH);
+     case OP_COMMIT:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM52);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     MRRETURN(MATCH_COMMIT);
+     case OP_PRUNE:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM51);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     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) RRETURN(rrc);
+     md->mark = ecode + 2;
+     RRETURN(MATCH_PRUNE);
+     case OP_SKIP:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM53);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->start_match_ptr = eptr;   /* Pass back current position */
+     MRRETURN(MATCH_SKIP);
+     case OP_SKIP_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM57);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     /* Pass back the current skip name by overloading md->start_match_ptr and
+     returning the special MATCH_SKIP_ARG return code. This will either be
+     caught by a matching MARK, or get to the top, where it is treated the same
+     as PRUNE. */
+     md->start_match_ptr = ecode + 2;
+     RRETURN(MATCH_SKIP_ARG);
+     /* 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
      the current subject position in the working slot at the top of the vector.
      We mustn't change the current values of the data slot, because they may be
-Line 640 
 for (;;)
+Line 788 
 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 655 
 for (;;)
+Line 803 
 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) 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 674 
 for (;;)
+Line 825 
 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);
        }
-     /* Insufficient room for saving captured contents. Treat as a non-capturing
+     /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
-     bracket. */
+     as a non-capturing bracket. */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      DPRINTF(("insufficient capture room: treat as non-capturing\n"));
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* Non-capturing bracket. Loop for all the alternatives. When we get to the
      final alternative within the brackets, we would return the result of a
      recursive call to match() whatever happened. We can reduce stack usage by
-     turning this into a tail recursion. */
+     turning this into a tail recursion, except in the case when match_cbegroup
+     is set.*/
      case OP_BRA:
      case OP_SBRA:
-Line 693 
 for (;;)
+Line 852 
 for (;;)
      flags = (op >= OP_SBRA)? match_cbegroup : 0;
      for (;;)
        {
-       if (ecode[GET(ecode, 1)] != OP_ALT)
+       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
          {
-         ecode += _pcre_OP_lengths[*ecode];
+         if (flags == 0)    /* Not a possibly empty group */
-         flags |= match_tail_recursed;
+           {
-         DPRINTF(("bracket 0 tail recursion\n"));
+           ecode += _pcre_OP_lengths[*ecode];
-         goto TAIL_RECURSE;
+           DPRINTF(("bracket 0 tail recursion\n"));
+           goto TAIL_RECURSE;
+           }
+         /* Possibly empty group; can't use tail recursion. */
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+           eptrb, flags, RM48);
+         if (rrc == MATCH_NOMATCH) md->mark = markptr;
+         RRETURN(rrc);
          }
        /* For non-final alternatives, continue the loop for a NOMATCH result;
-Line 706 
 for (;;)
+Line 874 
 for (;;)
        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
          eptrb, flags, RM2);
-       if (rrc != MATCH_NOMATCH) 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 719 
 for (;;)
+Line 889 
 for (;;)
      case OP_COND:
      case OP_SCOND:
-     if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */
+     codelink= GET(ecode, 1);
+     /* Because of the way auto-callout works during compile, a callout item is
+     inserted between OP_COND and an assertion condition. */
+     if (ecode[LINK_SIZE+1] == OP_CALLOUT)
        {
-       offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
+       if (pcre_callout != NULL)
-       condition = md->recursive != NULL &&
+         {
-         (offset == RREF_ANY || offset == md->recursive->group_num);
+         pcre_callout_block cb;
-       ecode += condition? 3 : GET(ecode, 1);
+         cb.version          = 1;   /* Version 1 of the callout block */
+         cb.callout_number   = ecode[LINK_SIZE+2];
+         cb.offset_vector    = md->offset_vector;
+         cb.subject          = (PCRE_SPTR)md->start_subject;
+         cb.subject_length   = (int)(md->end_subject - md->start_subject);
+         cb.start_match      = (int)(mstart - 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) MRRETURN(MATCH_NOMATCH);
+         if (rrc < 0) RRETURN(rrc);
+         }
+       ecode += _pcre_OP_lengths[OP_CALLOUT];
+       }
+     condcode = ecode[LINK_SIZE+1];
+     /* Now see what the actual condition is */
+     if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
+       {
+       if (md->recursive == NULL)                /* Not recursing => FALSE */
+         {
+         condition = FALSE;
+         ecode += GET(ecode, 1);
+         }
+       else
+         {
+         int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
+         condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
+         /* If the test is for recursion into a specific subpattern, and it is
+         false, but the test was set up by name, scan the table to see if the
+         name refers to any other numbers, and test them. The condition is true
+         if any one is set. */
+         if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
+           {
+           uschar *slotA = md->name_table;
+           for (i = 0; i < md->name_count; i++)
+             {
+             if (GET2(slotA, 0) == recno) break;
+             slotA += md->name_entry_size;
+             }
+           /* Found a name for the number - there can be only one; duplicate
+           names for different numbers are allowed, but not vice versa. First
+           scan down for duplicates. */
+           if (i < md->name_count)
+             {
+             uschar *slotB = slotA;
+             while (slotB > md->name_table)
+               {
+               slotB -= md->name_entry_size;
+               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                 {
+                 condition = GET2(slotB, 0) == md->recursive->group_num;
+                 if (condition) break;
+                 }
+               else break;
+               }
+             /* Scan up for duplicates */
+             if (!condition)
+               {
+               slotB = slotA;
+               for (i++; i < md->name_count; i++)
+                 {
+                 slotB += md->name_entry_size;
+                 if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                   {
+                   condition = GET2(slotB, 0) == md->recursive->group_num;
+                   if (condition) break;
+                   }
+                 else break;
+                 }
+               }
+             }
+           }
+         /* Chose branch according to the condition */
+         ecode += condition? 3 : GET(ecode, 1);
+         }
        }
-     else if (ecode[LINK_SIZE+1] == OP_CREF)    /* Group used test */
+     else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
        {
        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
        condition = offset < offset_top && md->offset_vector[offset] >= 0;
+       /* If the numbered capture is unset, but the reference was by name,
+       scan the table to see if the name refers to any other numbers, and test
+       them. The condition is true if any one is set. This is tediously similar
+       to the code above, but not close enough to try to amalgamate. */
+       if (!condition && condcode == OP_NCREF)
+         {
+         int refno = offset >> 1;
+         uschar *slotA = md->name_table;
+         for (i = 0; i < md->name_count; i++)
+           {
+           if (GET2(slotA, 0) == refno) break;
+           slotA += md->name_entry_size;
+           }
+         /* Found a name for the number - there can be only one; duplicate names
+         for different numbers are allowed, but not vice versa. First scan down
+         for duplicates. */
+         if (i < md->name_count)
+           {
+           uschar *slotB = slotA;
+           while (slotB > md->name_table)
+             {
+             slotB -= md->name_entry_size;
+             if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+               {
+               offset = GET2(slotB, 0) << 1;
+               condition = offset < offset_top &&
+                 md->offset_vector[offset] >= 0;
+               if (condition) break;
+               }
+             else break;
+             }
+           /* Scan up for duplicates */
+           if (!condition)
+             {
+             slotB = slotA;
+             for (i++; i < md->name_count; i++)
+               {
+               slotB += md->name_entry_size;
+               if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
+                 {
+                 offset = GET2(slotB, 0) << 1;
+                 condition = offset < offset_top &&
+                   md->offset_vector[offset] >= 0;
+                 if (condition) break;
+                 }
+               else break;
+               }
+             }
+           }
+         }
+       /* Chose branch according to the condition */
        ecode += condition? 3 : GET(ecode, 1);
        }
-     else if (ecode[LINK_SIZE+1] == OP_DEF)     /* DEFINE - always false */
+     else if (condcode == OP_DEF)     /* DEFINE - always false */
        {
        condition = FALSE;
        ecode += GET(ecode, 1);
-Line 754 
 for (;;)
+Line 1077 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH)
+       else if (rrc != MATCH_NOMATCH &&
+               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
        else
          {
          condition = FALSE;
-         ecode += GET(ecode, 1);
+         ecode += codelink;
          }
        }
      /* We are now at the branch that is to be obeyed. As there is only one,
-     we can use tail recursion to avoid using another stack frame. If the second
+     we can use tail recursion to avoid using another stack frame, except when
-     alternative doesn't exist, we can just plough on. */
+     match_cbegroup is required for an unlimited repeat of a possibly empty
+     group. If the second alternative doesn't exist, we can just plough on. */
      if (condition || *ecode == OP_ALT)
        {
        ecode += 1 + LINK_SIZE;
-       flags = match_tail_recursed | ((op == OP_SCOND)? match_cbegroup : 0);
+       if (op == OP_SCOND)        /* Possibly empty group */
-       goto TAIL_RECURSE;
+         {
+         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
+         RRETURN(rrc);
+         }
+       else                       /* Group must match something */
+         {
+         flags = 0;
+         goto TAIL_RECURSE;
+         }
        }
-     else
+     else                         /* Condition false & no alternative */
        {
        ecode += 1 + LINK_SIZE;
        }
      break;
-     /* End of the pattern. If we are in a top-level recursion, we should
+     /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
-     restore the offsets appropriately and continue from after the call. */
+     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. */
+     case OP_ACCEPT:
      case OP_END:
      if (md->recursive != NULL && md->recursive->group_num == 0)
        {
-Line 793 
 for (;;)
+Line 1152 
 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) */
+     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 828 
 for (;;)
+Line 1201 
 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) 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 847 
 for (;;)
+Line 1226 
 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 855 
 for (;;)
+Line 1236 
 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) 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 879 
 for (;;)
+Line 1267 
 for (;;)
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
-         BACKCHAR(eptr)
+         BACKCHAR(eptr);
          }
        }
      else
-Line 890 
 for (;;)
+Line 1278 
 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 910 
 for (;;)
+Line 1299 
 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 973 
 for (;;)
+Line 1362 
 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 985 
 for (;;)
+Line 1373 
 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)
+         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)
+             (pcre_free)(new_recursive.offset_save);
            RRETURN(rrc);
            }
-Line 1010 
 for (;;)
+Line 1401 
 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 1019 
 for (;;)
+Line 1410 
 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 1027 
 for (;;)
+Line 1419 
 for (;;)
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
-         eptrb, 0, RM7);
+       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
-       if (rrc == MATCH_MATCH) break;
+         {
-       if (rrc != MATCH_NOMATCH) 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 1073 
 for (;;)
+Line 1470 
 for (;;)
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);
-         RM8);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode = prev;
-       flags = match_tail_recursed;
+       flags = 0;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
-Line 1085 
 for (;;)
+Line 1481 
 for (;;)
        RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = match_tail_recursed;
+       flags = 0;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1097 
 for (;;)
+Line 1493 
 for (;;)
      do ecode += GET(ecode,1); while (*ecode == OP_ALT);
      break;
-     /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
+     /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
-     that it may occur zero times. It may repeat infinitely, or not at all -
+     indicating that it may occur zero times. It may repeat infinitely, or not
-     i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
+     at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
-     repeat limits are compiled as a number of copies, with the optional ones
+     with fixed upper repeat limits are compiled as a number of copies, with the
-     preceded by BRAZERO or BRAMINZERO. */
+     optional ones preceded by BRAZERO or BRAMINZERO. */
      case OP_BRAZERO:
        {
-Line 1123 
 for (;;)
+Line 1519 
 for (;;)
        }
      break;
+     case OP_SKIPZERO:
+       {
+       next = ecode+1;
+       do next += GET(next,1); while (*next == OP_ALT);
+       ecode = next + 1 + LINK_SIZE;
+       }
+     break;
      /* End of a group, repeated or non-repeating. */
      case OP_KET:
-Line 1141 
 for (;;)
+Line 1545 
 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 1151 
 for (;;)
+Line 1556 
 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 1165 
 for (;;)
+Line 1571 
 for (;;)
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
        printf("end bracket %d", number);
        printf("\n");
  #endif
-Line 1175 
 for (;;)
+Line 1581 
 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 1187 
 for (;;)
+Line 1593 
 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 1216 
 for (;;)
+Line 1622 
 for (;;)
      /* The repeating kets try the rest of the pattern or restart from the
      preceding bracket, in the appropriate order. In the second case, we can use
-     tail recursion to avoid using another stack frame. */
+     tail recursion to avoid using another stack frame, unless we have an
+     unlimited repeat of a group that can match an empty string. */
      flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
-         RM12);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (flags != 0)    /* Could match an empty string */
+         {
+         RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
+         RRETURN(rrc);
+         }
        ecode = prev;
-       flags |= match_tail_recursed;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
-Line 1234 
 for (;;)
+Line 1644 
 for (;;)
        RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = match_tail_recursed;
+       flags = 0;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1242 
 for (;;)
+Line 1652 
 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 1256 
 for (;;)
+Line 1666 
 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 1281 
 for (;;)
+Line 1691 
 for (;;)
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr < md->end_subject)
-         { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
+         { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
        else
-         { if (md->noteol) RRETURN(MATCH_NOMATCH); }
+         { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
        ecode++;
        break;
        }
      else
        {
-       if (md->noteol) RRETURN(MATCH_NOMATCH);
+       if (md->noteol) MRRETURN(MATCH_NOMATCH);
        if (!md->endonly)
          {
          if (eptr != md->end_subject &&
              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          ecode++;
          break;
          }
-Line 1304 
 for (;;)
+Line 1714 
 for (;;)
      /* End of subject assertion (\z) */
      case OP_EOD:
-     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1313 
 for (;;)
+Line 1723 
 for (;;)
      case OP_EODN:
      if (eptr != md->end_subject &&
          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1325 
 for (;;)
+Line 1735 
 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 ((ims & PCRE_DOTALL) == 0)
+     if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
+     /* Fall through */
+     case OP_ALLANY:
+     if (eptr++ >= md->end_subject)
        {
-       if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+       SCHECK_PARTIAL();
+       MRRETURN(MATCH_NOMATCH);
        }
-     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
-     if (utf8)
-       while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
      ecode++;
      break;
-Line 1380 
 for (;;)
+Line 1865 
 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 1393 
 for (;;)
+Line 1886 
 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 1406 
 for (;;)
+Line 1903 
 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 1419 
 for (;;)
+Line 1920 
 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 1432 
 for (;;)
+Line 1937 
 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 1445 
 for (;;)
+Line 1954 
 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 1458 
 for (;;)
+Line 1971 
 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;
        case 0x000a:
+       break;
        case 0x000b:
        case 0x000c:
        case 0x0085:
        case 0x2028:
        case 0x2029:
+       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 1507 
 for (;;)
+Line 2032 
 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 1543 
 for (;;)
+Line 2072 
 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 1555 
 for (;;)
+Line 2088 
 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 1584 
 for (;;)
+Line 2121 
 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);
        {
-       int chartype, script;
+       const ucd_record *prop = GET_UCD(c);
-       int category = _pcre_ucp_findprop(c, &chartype, &script);
        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 ((chartype == ucp_Lu ||
+         if ((prop->chartype == ucp_Lu ||
-              chartype == ucp_Ll ||
+              prop->chartype == ucp_Ll ||
-              chartype == ucp_Lt) == (op == OP_NOTPROP))
+              prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
-          break;
+         break;
          case PT_GC:
-         if ((ecode[2] != category) == (op == OP_PROP))
+         if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          case PT_PC:
-         if ((ecode[2] != chartype) == (op == OP_PROP))
+         if ((ecode[2] != prop->chartype) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          case PT_SC:
-         if ((ecode[2] != script) == (op == OP_PROP))
+         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 1630 
 for (;;)
+Line 2202 
 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 chartype, script;
+       int category = UCD_CATEGORY(c);
-       int category = _pcre_ucp_findprop(c, &chartype, &script);
+       if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
-       if (category == ucp_M) RRETURN(MATCH_NOMATCH);
        while (eptr < md->end_subject)
          {
          int len = 1;
-Line 1643 
 for (;;)
+Line 2218 
 for (;;)
            {
            GETCHARLEN(c, eptr, len);
            }
-         category = _pcre_ucp_findprop(c, &chartype, &script);
+         category = UCD_CATEGORY(c);
          if (category != ucp_M) break;
          eptr += len;
          }
-Line 1664 
 for (;;)
+Line 2239 
 for (;;)
      case OP_REF:
        {
        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
-       ecode += 3;                                 /* Advance past item */
+       ecode += 3;
+       /* If the reference is unset, there are two possibilities:
-       /* If the reference is unset, set the length to be longer than the amount
+       (a) In the default, Perl-compatible state, set the length to be longer
-       of subject left; this ensures that every attempt at a match fails. We
+       than the amount of subject left; this ensures that every attempt at a
-       can't just fail here, because of the possibility of quantifiers with zero
+       match fails. We can't just fail here, because of the possibility of
-       minima. */
+       quantifiers with zero minima.
-       length = (offset >= offset_top || md->offset_vector[offset] < 0)?
+       (b) If the JavaScript compatibility flag is set, set the length to zero
-         md->end_subject - eptr + 1 :
+       so that the back reference matches an empty string.
-         md->offset_vector[offset+1] - md->offset_vector[offset];
+       Otherwise, set the length to the length of what was matched by the
+       referenced subpattern. */
+       if (offset >= offset_top || md->offset_vector[offset] < 0)
+         length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1);
+       else
+         length = md->offset_vector[offset+1] - md->offset_vector[offset];
        /* Set up for repetition, or handle the non-repeated case */
-Line 1702 
 for (;;)
+Line 2286 
 for (;;)
          break;
          default:               /* No repeat follows */
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         if (!match_ref(offset, eptr, length, md, ims))
+           {
+           CHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
          eptr += length;
          continue;              /* With the main loop */
          }
-Line 1718 
 for (;;)
+Line 2306 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         if (!match_ref(offset, eptr, length, md, ims))
+           {
+           CHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
          eptr += length;
          }
-Line 1735 
 for (;;)
+Line 2327 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || !match_ref(offset, eptr, length, md, ims))
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             RRETURN(MATCH_NOMATCH);
+           if (!match_ref(offset, eptr, length, md, ims))
+             {
+             CHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            eptr += length;
            }
          /* Control never gets here */
-Line 1749 
 for (;;)
+Line 2345 
 for (;;)
          pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (!match_ref(offset, eptr, length, md, ims)) break;
+           if (!match_ref(offset, eptr, length, md, ims))
+             {
+             CHECK_PARTIAL();
+             break;
+             }
            eptr += length;
            }
          while (eptr >= pp)
-Line 1758 
 for (;;)
+Line 2358 
 for (;;)
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            eptr -= length;
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
      /* Match a bit-mapped character class, possibly repeatedly. This op code is
      used when all the characters in the class have values in the range 0-255,
      and either the matching is caseful, or the characters are in the range
-Line 1819 
 for (;;)
+Line 2417 
 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 1837 
 for (;;)
+Line 2439 
 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 1861 
 for (;;)
+Line 2467 
 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 1881 
 for (;;)
+Line 2492 
 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 1902 
 for (;;)
+Line 2518 
 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 1928 
 for (;;)
+Line 2548 
 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 1941 
 for (;;)
+Line 2565 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
      /* Match an extended character class. This opcode is encountered only
-     in UTF-8 mode, because that's the only time it is compiled. */
+     when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
+     mode, because Unicode properties are supported in non-UTF-8 mode. */
  #ifdef SUPPORT_UTF8
      case OP_XCLASS:
-Line 1989 
 for (;;)
+Line 2614 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr >= md->end_subject)
-         GETCHARINC(c, eptr);
+           {
-         if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+           SCHECK_PARTIAL();
+           MRRETURN(MATCH_NOMATCH);
+           }
+         GETCHARINCTEST(c, eptr);
+         if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
          }
        /* If max == min we can continue with the main loop without the
-Line 2008 
 for (;;)
+Line 2637 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-           GETCHARINC(c, eptr);
+           if (eptr >= md->end_subject)
-           if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           GETCHARINCTEST(c, eptr);
+           if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2023 
 for (;;)
+Line 2657 
 for (;;)
          for (i = min; i < max; i++)
            {
            int len = 1;
-           if (eptr >= md->end_subject) break;
+           if (eptr >= md->end_subject)
-           GETCHARLEN(c, eptr, len);
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
+           GETCHARLENTEST(c, eptr, len);
            if (!_pcre_xclass(c, data)) break;
            eptr += len;
            }
-Line 2033 
 for (;;)
+Line 2671 
 for (;;)
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
-           BACKCHAR(eptr)
+           if (utf8) BACKCHAR(eptr);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
-Line 2051 
 for (;;)
+Line 2689 
 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 2075 
 for (;;)
+Line 2721 
 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 2099 
 for (;;)
+Line 2749 
 for (;;)
          if (fc != dc)
            {
  #ifdef SUPPORT_UCP
-           if (dc != _pcre_ucp_othercase(fc))
+           if (dc != UCD_OTHERCASE(fc))
  #endif
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          }
        }
-Line 2110 
 for (;;)
+Line 2760 
 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 2164 
 for (;;)
+Line 2818 
 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 2179 
 for (;;)
+Line 2832 
 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 2190 
 for (;;)
+Line 2842 
 for (;;)
  #ifdef SUPPORT_UCP
          unsigned int othercase;
          if ((ims & PCRE_CASELESS) != 0 &&
-             (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)
+             (othercase = UCD_OTHERCASE(fc)) != fc)
            oclength = _pcre_ord2utf8(othercase, occhars);
          else oclength = 0;
  #endif  /* SUPPORT_UCP */
          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 2219 
 for (;;)
+Line 2871 
 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 2241 
 for (;;)
+Line 2893 
 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 2280 
 for (;;)
+Line 2933 
 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 2301 
 for (;;)
+Line 2952 
 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 2309 
 for (;;)
+Line 2967 
 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 2320 
 for (;;)
+Line 2982 
 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 2339 
 for (;;)
+Line 3008 
 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 2357 
 for (;;)
+Line 3041 
 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 2376 
 for (;;)
+Line 3066 
 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 2385 
 for (;;)
+Line 3079 
 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 2453 
 for (;;)
+Line 3147 
 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 2483 
 for (;;)
+Line 3174 
 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 2494 
 for (;;)
+Line 3190 
 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 2510 
 for (;;)
+Line 3213 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             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 (fi >= max || eptr >= md->end_subject || fc == d)
+             if (fc == d) MRRETURN(MATCH_NOMATCH);
-               RRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 2524 
 for (;;)
+Line 3232 
 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 2545 
 for (;;)
+Line 3258 
 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 2566 
 for (;;)
+Line 3283 
 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 2578 
 for (;;)
+Line 3300 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2594 
 for (;;)
+Line 3316 
 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 2603 
 for (;;)
+Line 3330 
 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 2619 
 for (;;)
+Line 3353 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(d, eptr);
-             if (fi >= max || eptr >= md->end_subject || fc == d)
+             if (fc == d) MRRETURN(MATCH_NOMATCH);
-               RRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 2632 
 for (;;)
+Line 3371 
 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 2653 
 for (;;)
+Line 3397 
 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 2673 
 for (;;)
+Line 3421 
 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 2685 
 for (;;)
+Line 3438 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2767 
 for (;;)
+Line 3520 
 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 2782 
 for (;;)
+Line 3532 
 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 2793 
 for (;;)
+Line 3547 
 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_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+             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 = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+             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_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+             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_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+             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 2848 
 for (;;)
+Line 3687 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
-           prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+           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);
-               }
-             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
              if (prop_category != ucp_M) break;
              eptr += len;
              }
-Line 2876 
 for (;;)
+Line 3718 
 for (;;)
          case OP_ANY:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
+             {
-             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++;
+           }
+         break;
+         case OP_ALLANY:
+         for (i = 1; i <= min; i++)
+           {
+           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;
              case 0x000a:
+             break;
              case 0x000b:
              case 0x000c:
              case 0x0085:
              case 0x2028:
              case 0x2029:
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 2913 
 for (;;)
+Line 3780 
 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 2937 
 for (;;)
+Line 3808 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 2945 
 for (;;)
+Line 3816 
 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 2977 
 for (;;)
+Line 3852 
 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 2989 
 for (;;)
+Line 3868 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 2997 
 for (;;)
+Line 3876 
 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 3017 
 for (;;)
+Line 3900 
 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 3037 
 for (;;)
+Line 3928 
 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();
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
+             MRRETURN(MATCH_NOMATCH);
+           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
          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 3057 
 for (;;)
+Line 3956 
 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();
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
+             MRRETURN(MATCH_NOMATCH);
+           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
          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 3082 
 for (;;)
+Line 3989 
 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:
-         if ((ims & PCRE_DOTALL) == 0)
+         for (i = 1; i <= min; i++)
            {
-           for (i = 1; i <= min; i++)
+           if (eptr >= md->end_subject)
              {
-             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
-             eptr++;
+             MRRETURN(MATCH_NOMATCH);
              }
+           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
+           eptr++;
            }
-         else eptr += min;
          break;
-         case OP_ANYBYTE:
+         case OP_ALLANY:
+         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
+         case OP_ANYBYTE:
-         bytes are present in this case. */
+         if (eptr > md->end_subject - min)
+           {
+           SCHECK_PARTIAL();
+           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);
+             }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
              case 0x000a:
+             break;
              case 0x000b:
              case 0x000c:
              case 0x0085:
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3128 
 for (;;)
+Line 4053 
 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 3143 
 for (;;)
+Line 4072 
 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 3158 
 for (;;)
+Line 4091 
 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 3167 
 for (;;)
+Line 4104 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3175 
 for (;;)
+Line 4112 
 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 3191 
 for (;;)
+Line 4132 
 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);
+           {
-         break;
+           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 3246 
 for (;;)
+Line 4229 
 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 3257 
 for (;;)
+Line 4245 
 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)
-             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+               {
+               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 */
-Line 3272 
 for (;;)
+Line 4265 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             if (eptr >= md->end_subject)
-             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+               {
+               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);
              }
            /* Control never gets here */
-Line 3285 
 for (;;)
+Line 4283 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             if (eptr >= md->end_subject)
-             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+               {
+               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);
              }
            /* Control never gets here */
-Line 3298 
 for (;;)
+Line 4301 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             if (eptr >= md->end_subject)
-             prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
+               {
+               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);
+             }
+           /* 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_SPACE:    /* Perl space */
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
+             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);