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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 227 by ph10,
Tue Aug 21 15:00:15 2007 UTC
+revision 579 by ph10,
Wed Nov 24 17:39:25 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 43 
 pattern matching using an NFA algorithm,
  possible. There are also some static supporting functions. */
  #ifdef HAVE_CONFIG_H
- #include <config.h>
+ #include "config.h"
  #endif
  #define NLBLOCK md             /* Block containing newline information */
 Line 71 
 defined PCRE_ERROR_xxx codes, which are
  /* Special internal returns from the match() function. Make them sufficiently
  negative to avoid the external error codes. */
- #define MATCH_COMMIT       (-999)
+ #define MATCH_ACCEPT       (-999)
- #define MATCH_PRUNE        (-998)
+ #define MATCH_COMMIT       (-998)
- #define MATCH_SKIP         (-997)
+ #define MATCH_PRUNE        (-997)
- #define MATCH_THEN         (-996)
+ #define MATCH_SKIP         (-996)
+ #define MATCH_SKIP_ARG     (-995)
+ #define MATCH_THEN         (-994)
+ /* This is a convenience macro for code that occurs many times. */
+ #define MRRETURN(ra) \
+   { \
+   md->mark = markptr; \
+   RRETURN(ra); \
+   }
  /* Maximum number of ints of offset to save on the stack for recursive calls.
  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
-Line 89 
 static const char rep_max[] = { 0, 0, 0,
+Line 99 
 static const char rep_max[] = { 0, 0, 0,
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  /*************************************************
  *        Debugging function to print chars       *
  *************************************************/
-Line 141 
 match_ref(int offset, register USPTR ept
+Line 151 
 match_ref(int offset, register USPTR ept
  {
  USPTR p = md->start_subject + md->offset_vector[offset];
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (eptr >= md->end_subject)
    printf("matching subject <null>");
  else
-Line 158 
 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 219 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 255 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
-        RM51,  RM52, RM53, RM54 };
+        RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, 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 242 
 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 257 
 argument of match(), which never changes
+Line 294 
 argument of match(), which never changes
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
    {\
-   heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
+   heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
+   if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
    frame->Xwhere = rw; \
    newframe->Xeptr = ra;\
    newframe->Xecode = rb;\
    newframe->Xmstart = mstart;\
+   newframe->Xmarkptr = markptr;\
    newframe->Xoffset_top = rc;\
    newframe->Xims = re;\
    newframe->Xeptrb = rf;\
-Line 277 
 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 296 
 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 307 
 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 334 
 typedef struct heapframe {
+Line 376 
 typedef struct heapframe {
    uschar Xocchars[8];
  #endif
+   int Xcodelink;
    int Xctype;
    unsigned int Xfc;
    int Xfi;
-Line 369 
 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 > md->start_used_ptr) \
+     { \
+     md->hitend = TRUE; \
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
+     }
+ #define SCHECK_PARTIAL()\
+   if (md->partial != 0 && eptr > md->start_used_ptr) \
+     { \
+     md->hitend = TRUE; \
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
+     }
- Performance note: It might be tempting to extract commonly used fields from the
+ /* Performance note: It might be tempting to extract commonly used fields from
- md structure (e.g. utf8, end_subject) into individual variables to improve
+ the md structure (e.g. utf8, end_subject) into individual variables to improve
  performance. Tests using gcc on a SPARC disproved this; in the first case, it
  made performance worse.
-Line 381 
 Arguments:
+Line 447 
 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 394 
 Arguments:
+Line 461 
 Arguments:
  Returns:       MATCH_MATCH if matched            )  these values are >= 0
                 MATCH_NOMATCH if failed to match  )
+                a negative MATCH_xxx value for PRUNE, SKIP, etc
                 a negative PCRE_ERROR_xxx value if aborted by an error condition
                   (e.g. stopped by repeated call or recursion limit)
  */
  static int
- match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
+ match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
-   int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
+   const uschar *markptr, int offset_top, match_data *md, unsigned long int ims,
-   int flags, unsigned int rdepth)
+   eptrblock *eptrb, int flags, unsigned int rdepth)
  {
  /* These variables do not need to be preserved over recursion in this function,
  so they can be ordinary variables in all cases. Mark some of them with
-Line 413 
 register unsigned int c;   /* Character
+Line 481 
 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 420 
 heap storage. Set up the top-level frame
+Line 489 
 heap storage. Set up the top-level frame
  heap whenever RMATCH() does a "recursion". See the macro definitions above. */
  #ifdef NO_RECURSE
- heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
+ heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
+ if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
  frame->Xprevframe = NULL;            /* Marks the top level */
  /* Copy in the original argument variables */
-Line 428 
 frame->Xprevframe = NULL;            /*
+Line 498 
 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 443 
 HEAP_RECURSE:
+Line 514 
 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 455 
 HEAP_RECURSE:
+Line 527 
 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 535 
 int oclength;
+Line 608 
 int oclength;
  uschar occhars[8];
  #endif
+ int codelink;
  int ctype;
  int length;
  int max;
-Line 568 
 TAIL_RECURSE:
+Line 642 
 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 610 
 for (;;)
+Line 684 
 for (;;)
    minimize = possessive = FALSE;
    op = *ecode;
-   /* For partial matching, remember if we ever hit the end of the subject after
-   matching at least one subject character. */
-   if (md->partial &&
-       eptr >= md->end_subject &&
-       eptr > mstart)
-     md->hitend = TRUE;
    switch(op)
      {
+     case OP_MARK:
+     markptr = ecode + 2;
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM55);
+     /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
+     argument, and we must check whether that argument matches this MARK's
+     argument. It is passed back in md->start_match_ptr (an overloading of that
+     variable). If it does match, we reset that variable to the current subject
+     position and return MATCH_SKIP. Otherwise, pass back the return code
+     unaltered. */
+     if (rrc == MATCH_SKIP_ARG &&
+         strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
+       {
+       md->start_match_ptr = eptr;
+       RRETURN(MATCH_SKIP);
+       }
+     if (md->mark == NULL) md->mark = markptr;
+     RRETURN(rrc);
      case OP_FAIL:
-     RRETURN(MATCH_NOMATCH);
+     MRRETURN(MATCH_NOMATCH);
+     /* COMMIT overrides PRUNE, SKIP, and THEN */
+     case OP_COMMIT:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM52);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
+         rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
+         rrc != MATCH_THEN)
+       RRETURN(rrc);
+     MRRETURN(MATCH_COMMIT);
+     /* PRUNE overrides THEN */
      case OP_PRUNE:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM51);
-     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+     MRRETURN(MATCH_PRUNE);
+     case OP_PRUNE_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM56);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+     md->mark = ecode + 2;
      RRETURN(MATCH_PRUNE);
-     case OP_COMMIT:
+     /* SKIP overrides PRUNE and THEN */
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-       ims, eptrb, flags, RM52);
-     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     RRETURN(MATCH_COMMIT);
      case OP_SKIP:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM53);
-     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
+       RRETURN(rrc);
      md->start_match_ptr = eptr;   /* Pass back current position */
-     RRETURN(MATCH_SKIP);
+     MRRETURN(MATCH_SKIP);
+     case OP_SKIP_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       ims, eptrb, flags, RM57);
+     if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
+       RRETURN(rrc);
+     /* Pass back the current skip name by overloading md->start_match_ptr and
+     returning the special MATCH_SKIP_ARG return code. This will either be
+     caught by a matching MARK, or get to the top, where it is treated the same
+     as PRUNE. */
+     md->start_match_ptr = ecode + 2;
+     RRETURN(MATCH_SKIP_ARG);
+     /* For THEN (and THEN_ARG) we pass back the address of the bracket or
+     the alt that is at the start of the current branch. This makes it possible
+     to skip back past alternatives that precede the THEN within the current
+     branch. */
      case OP_THEN:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        ims, eptrb, flags, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->start_match_ptr = ecode - GET(ecode, 1);
+     MRRETURN(MATCH_THEN);
+     case OP_THEN_ARG:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
+       offset_top, md, ims, eptrb, flags, RM58);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->mark = ecode + LINK_SIZE + 2;
      RRETURN(MATCH_THEN);
      /* Handle a capturing bracket. If there is space in the offset vector, save
-Line 667 
 for (;;)
+Line 800 
 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 682 
 for (;;)
+Line 815 
 for (;;)
        save_capture_last = md->capture_last;
        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
-       md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
+       md->offset_vector[md->offset_end - number] =
+         (int)(eptr - md->start_subject);
        flags = (op == OP_SCBRA)? match_cbegroup : 0;
        do
          {
          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
            ims, eptrb, flags, RM1);
-         if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+         if (rrc != MATCH_NOMATCH &&
+             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+           RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          }
-Line 701 
 for (;;)
+Line 837 
 for (;;)
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
+       if (rrc != MATCH_THEN) md->mark = markptr;
        RRETURN(MATCH_NOMATCH);
        }
-Line 740 
 for (;;)
+Line 877 
 for (;;)
          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
            eptrb, flags, RM48);
+         if (rrc == MATCH_NOMATCH) md->mark = markptr;
          RRETURN(rrc);
          }
-Line 748 
 for (;;)
+Line 886 
 for (;;)
        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
          eptrb, flags, RM2);
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      /* Control never reaches here. */
-Line 761 
 for (;;)
+Line 901 
 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 796 
 for (;;)
+Line 1089 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+       else if (rrc != MATCH_NOMATCH &&
+               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
        else
          {
          condition = FALSE;
-         ecode += GET(ecode, 1);
+         ecode += codelink;
          }
        }
-Line 826 
 for (;;)
+Line 1120 
 for (;;)
          goto TAIL_RECURSE;
          }
        }
-     else                         /* Condition false & no 2nd alternative */
+     else                         /* Condition false & no alternative */
        {
        ecode += 1 + LINK_SIZE;
        }
      break;
+     /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
+     to close any currently open capturing brackets. */
+     case OP_CLOSE:
+     number = GET2(ecode, 1);
+     offset = number << 1;
+ #ifdef PCRE_DEBUG
+       printf("end bracket %d at *ACCEPT", number);
+       printf("\n");
+ #endif
+     md->capture_last = number;
+     if (offset >= md->offset_max) md->offset_overflow = TRUE; else
+       {
+       md->offset_vector[offset] =
+         md->offset_vector[md->offset_end - number];
+       md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
+       if (offset_top <= offset) offset_top = offset + 2;
+       }
+     ecode += 3;
+     break;
      /* End of the pattern, either real or forced. If we are in a top-level
      recursion, we should restore the offsets appropriately and continue from
      after the call. */
-Line 846 
 for (;;)
+Line 1164 
 for (;;)
        md->recursive = rec->prevrec;
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
-       mstart = rec->save_start;
+       offset_top = rec->save_offset_top;
        ims = original_ims;
        ecode = rec->after_call;
        break;
        }
-     /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
+     /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
-     string - backtracking will then try other alternatives, if any. */
+     set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
+     the subject. In both cases, backtracking will then try other alternatives,
+     if any. */
+     if (eptr == mstart &&
+         (md->notempty ||
+           (md->notempty_atstart &&
+             mstart == md->start_subject + md->start_offset)))
+       MRRETURN(MATCH_NOMATCH);
+     /* Otherwise, we have a match. */
-     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
      md->end_match_ptr = eptr;           /* Record where we ended */
      md->end_offset_top = offset_top;    /* and how many extracts were taken */
      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
-     RRETURN(MATCH_MATCH);
+     /* For some reason, the macros don't work properly if an expression is
+     given as the argument to MRRETURN when the heap is in use. */
+     rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
+     MRRETURN(rrc);
      /* Change option settings */
-Line 881 
 for (;;)
+Line 1213 
 for (;;)
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
          RM4);
-       if (rrc == MATCH_MATCH) break;
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+         {
+         mstart = md->start_match_ptr;   /* In case \K reset it */
+         break;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      while (*ecode == OP_ALT);
-     if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
+     if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
      /* If checking an assertion for a condition, return MATCH_MATCH. */
-Line 900 
 for (;;)
+Line 1238 
 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 908 
 for (;;)
+Line 1248 
 for (;;)
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
          RM5);
-       if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+       if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
+         {
+         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+         break;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 932 
 for (;;)
+Line 1279 
 for (;;)
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr);
          }
        }
-Line 943 
 for (;;)
+Line 1290 
 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 963 
 for (;;)
+Line 1311 
 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 1026 
 for (;;)
+Line 1374 
 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 1038 
 for (;;)
+Line 1385 
 for (;;)
          {
          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
            md, ims, eptrb, flags, RM6);
-         if (rrc == MATCH_MATCH)
+         if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
            {
            DPRINTF(("Recursion matched\n"));
            md->recursive = new_recursive.prevrec;
            if (new_recursive.offset_save != stacksave)
              (pcre_free)(new_recursive.offset_save);
-           RRETURN(MATCH_MATCH);
+           MRRETURN(MATCH_MATCH);
            }
-         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+         else if (rrc != MATCH_NOMATCH &&
+                 (rrc != MATCH_THEN || md->start_match_ptr != ecode))
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
+           if (new_recursive.offset_save != stacksave)
+             (pcre_free)(new_recursive.offset_save);
            RRETURN(rrc);
            }
-Line 1063 
 for (;;)
+Line 1413 
 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 1072 
 for (;;)
+Line 1422 
 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 1081 
 for (;;)
+Line 1432 
 for (;;)
      do
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
-       if (rrc == MATCH_MATCH) break;
+       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+         {
+         mstart = md->start_match_ptr;
+         break;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 1148 
 for (;;)
+Line 1505 
 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 1174 
 for (;;)
+Line 1531 
 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 1192 
 for (;;)
+Line 1557 
 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 1202 
 for (;;)
+Line 1568 
 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 1216 
 for (;;)
+Line 1583 
 for (;;)
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
        printf("end bracket %d", number);
        printf("\n");
  #endif
-Line 1226 
 for (;;)
+Line 1593 
 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 1238 
 for (;;)
+Line 1605 
 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 1297 
 for (;;)
+Line 1664 
 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 1311 
 for (;;)
+Line 1678 
 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 1336 
 for (;;)
+Line 1703 
 for (;;)
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr < md->end_subject)
-         { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
+         { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
        else
-         { if (md->noteol) RRETURN(MATCH_NOMATCH); }
+         {
+         if (md->noteol) MRRETURN(MATCH_NOMATCH);
+         SCHECK_PARTIAL();
+         }
        ecode++;
        break;
        }
-     else
+     else  /* Not multiline */
        {
-       if (md->noteol) RRETURN(MATCH_NOMATCH);
+       if (md->noteol) MRRETURN(MATCH_NOMATCH);
-       if (!md->endonly)
+       if (!md->endonly) goto ASSERT_NL_OR_EOS;
-         {
-         if (eptr != md->end_subject &&
-             (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-           RRETURN(MATCH_NOMATCH);
-         ecode++;
-         break;
-         }
        }
      /* ... else fall through for endonly */
      /* End of subject assertion (\z) */
      case OP_EOD:
-     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
+     SCHECK_PARTIAL();
      ecode++;
      break;
      /* End of subject or ending \n assertion (\Z) */
      case OP_EODN:
-     if (eptr != md->end_subject &&
+     ASSERT_NL_OR_EOS:
+     if (eptr < md->end_subject &&
          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
+     /* Either at end of string or \n before end. */
+     SCHECK_PARTIAL();
      ecode++;
      break;
-Line 1380 
 for (;;)
+Line 1750 
 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 1435 
 for (;;)
+Line 1880 
 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 1448 
 for (;;)
+Line 1901 
 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 1461 
 for (;;)
+Line 1918 
 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 1474 
 for (;;)
+Line 1935 
 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 1487 
 for (;;)
+Line 1952 
 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 1500 
 for (;;)
+Line 1969 
 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 1513 
 for (;;)
+Line 1986 
 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 1562 
 for (;;)
+Line 2047 
 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 1598 
 for (;;)
+Line 2087 
 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 1610 
 for (;;)
+Line 2103 
 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 1639 
 for (;;)
+Line 2136 
 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 1685 
 for (;;)
+Line 2217 
 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)
-     GETCHARINCTEST(c, eptr);
        {
-       int chartype, script;
+       SCHECK_PARTIAL();
-       int category = _pcre_ucp_findprop(c, &chartype, &script);
+       MRRETURN(MATCH_NOMATCH);
-       if (category == ucp_M) RRETURN(MATCH_NOMATCH);
+       }
+     GETCHARINCTEST(c, eptr);
+       {
+       int category = UCD_CATEGORY(c);
+       if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
        while (eptr < md->end_subject)
          {
          int len = 1;
-Line 1698 
 for (;;)
+Line 2233 
 for (;;)
            {
            GETCHARLEN(c, eptr, len);
            }
-         category = _pcre_ucp_findprop(c, &chartype, &script);
+         category = UCD_CATEGORY(c);
          if (category != ucp_M) break;
          eptr += len;
          }
-Line 1719 
 for (;;)
+Line 2254 
 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:
+       (a) In the default, Perl-compatible state, set the length to be longer
+       than the amount of subject left; this ensures that every attempt at a
+       match fails. We can't just fail here, because of the possibility of
+       quantifiers with zero minima.
+       (b) If the JavaScript compatibility flag is set, set the length to zero
+       so that the back reference matches an empty string.
+       Otherwise, set the length to the length of what was matched by the
+       referenced subpattern. */
-       /* If the reference is unset, set the length to be longer than the amount
+       if (offset >= offset_top || md->offset_vector[offset] < 0)
-       of subject left; this ensures that every attempt at a match fails. We
+         length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1);
-       can't just fail here, because of the possibility of quantifiers with zero
+       else
-       minima. */
+         length = md->offset_vector[offset+1] - md->offset_vector[offset];
-       length = (offset >= offset_top || md->offset_vector[offset] < 0)?
-         md->end_subject - eptr + 1 :
-         md->offset_vector[offset+1] - md->offset_vector[offset];
        /* Set up for repetition, or handle the non-repeated case */
-Line 1757 
 for (;;)
+Line 2301 
 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 1773 
 for (;;)
+Line 2321 
 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 1790 
 for (;;)
+Line 2342 
 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 1804 
 for (;;)
+Line 2360 
 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 1813 
 for (;;)
+Line 2373 
 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 1874 
 for (;;)
+Line 2432 
 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 1892 
 for (;;)
+Line 2454 
 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 1916 
 for (;;)
+Line 2482 
 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 1936 
 for (;;)
+Line 2507 
 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 1957 
 for (;;)
+Line 2533 
 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 1983 
 for (;;)
+Line 2563 
 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 1996 
 for (;;)
+Line 2580 
 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 2044 
 for (;;)
+Line 2629 
 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 2063 
 for (;;)
+Line 2652 
 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 2078 
 for (;;)
+Line 2672 
 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 2090 
 for (;;)
+Line 2688 
 for (;;)
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            if (utf8) BACKCHAR(eptr);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
-Line 2106 
 for (;;)
+Line 2704 
 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 2130 
 for (;;)
+Line 2736 
 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 2154 
 for (;;)
+Line 2764 
 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 2165 
 for (;;)
+Line 2775 
 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 2219 
 for (;;)
+Line 2833 
 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 2234 
 for (;;)
+Line 2847 
 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 2245 
 for (;;)
+Line 2857 
 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 2274 
 for (;;)
+Line 2886 
 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 2296 
 for (;;)
+Line 2908 
 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 2335 
 for (;;)
+Line 2948 
 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 2356 
 for (;;)
+Line 2967 
 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 2364 
 for (;;)
+Line 2982 
 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 2375 
 for (;;)
+Line 2997 
 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 2394 
 for (;;)
+Line 3023 
 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 2412 
 for (;;)
+Line 3056 
 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 2431 
 for (;;)
+Line 3081 
 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 2440 
 for (;;)
+Line 3094 
 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 2508 
 for (;;)
+Line 3162 
 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 2538 
 for (;;)
+Line 3189 
 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 2549 
 for (;;)
+Line 3205 
 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 2565 
 for (;;)
+Line 3228 
 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 2579 
 for (;;)
+Line 3247 
 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 2600 
 for (;;)
+Line 3273 
 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 2621 
 for (;;)
+Line 3298 
 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 2633 
 for (;;)
+Line 3315 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2649 
 for (;;)
+Line 3331 
 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 2658 
 for (;;)
+Line 3345 
 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 2674 
 for (;;)
+Line 3368 
 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 2687 
 for (;;)
+Line 3386 
 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 2708 
 for (;;)
+Line 3412 
 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 2728 
 for (;;)
+Line 3436 
 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 2740 
 for (;;)
+Line 3453 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2822 
 for (;;)
+Line 3535 
 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 2837 
 for (;;)
+Line 3547 
 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 2848 
 for (;;)
+Line 3562 
 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 2903 
 for (;;)
+Line 3702 
 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 2931 
 for (;;)
+Line 3733 
 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 2968 
 for (;;)
+Line 3795 
 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 2992 
 for (;;)
+Line 3823 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3000 
 for (;;)
+Line 3831 
 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 3032 
 for (;;)
+Line 3867 
 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 3044 
 for (;;)
+Line 3883 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3052 
 for (;;)
+Line 3891 
 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 3072 
 for (;;)
+Line 3915 
 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 3092 
 for (;;)
+Line 3943 
 for (;;)
          case OP_NOT_WHITESPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
+             MRRETURN(MATCH_NOMATCH);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 3102 
 for (;;)
+Line 3957 
 for (;;)
          case OP_WHITESPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3112 
 for (;;)
+Line 3971 
 for (;;)
          case OP_NOT_WORDCHAR:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
+             MRRETURN(MATCH_NOMATCH);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 3122 
 for (;;)
+Line 3985 
 for (;;)
          case OP_WORDCHAR:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3137 
 for (;;)
+Line 4004 
 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 3183 
 for (;;)
+Line 4068 
 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 3198 
 for (;;)
+Line 4087 
 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 3213 
 for (;;)
+Line 4106 
 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 3222 
 for (;;)
+Line 4119 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3230 
 for (;;)
+Line 4127 
 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 3246 
 for (;;)
+Line 4147 
 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)
+             {
-         case OP_NOT_WORDCHAR:
+             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 3301 
 for (;;)
+Line 4244 
 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 3312 
 for (;;)
+Line 4260 
 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 3327 
 for (;;)
+Line 4280 
 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 3340 
 for (;;)
+Line 4298 
 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 3353 
 for (;;)
+Line 4316 
 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);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           /* Control never gets here */
+           case PT_PXSPACE:  /* POSIX space */
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
+             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_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           /* Control never gets here */
+           case PT_WORD:
+           for (fi = min;; fi++)
+             {
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
+             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 ||
+                  c == CHAR_UNDERSCORE)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           /* Control never gets here */
+           /* This should never occur */
            default:
            RRETURN(PCRE_ERROR_INTERNAL);
            }
-Line 3375 
 for (;;)
+Line 4425 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
-           prop_category = _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 3404 
 for (;;)
+Line 4457 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-                (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&
+           if (eptr >= md->end_subject)
-                 IS_NEWLINE(eptr)))
+             {
-             RRETURN(MATCH_NOMATCH);
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (ctype == OP_ANY && IS_NEWLINE(eptr))
+             MRRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            switch(ctype)
              {
-             case OP_ANY:        /* This is the DOTALL case */
+             case OP_ANY:        /* This is the non-NL case */
-             break;
+             case OP_ALLANY:
              case OP_ANYBYTE:
              break;
              case OP_ANYNL:
              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;
                }
              break;
-Line 3458 
 for (;;)
+Line 4516 
 for (;;)
                case 0x202f:    /* NARROW NO-BREAK SPACE */
                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
                case 0x3000:    /* IDEOGRAPHIC SPACE */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_HSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x09:      /* HT */
                case 0x20:      /* SPACE */
                case 0xa0:      /* NBSP */
-Line 3500 
 for (;;)
+Line 4558 
 for (;;)
                case 0x85:      /* NEL */
                case 0x2028:    /* LINE SEPARATOR */
                case 0x2029:    /* PARAGRAPH SEPARATOR */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_VSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x0a:      /* LF */
                case 0x0b:      /* VT */
                case 0x0c:      /* FF */
-Line 3521 
 for (;;)
+Line 4579 
 for (;;)
              case OP_NOT_DIGIT:
              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_DIGIT:
              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WHITESPACE:
              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WHITESPACE:
              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WORDCHAR:
              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WORDCHAR:
              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              break;
              default:
-Line 3562 
 for (;;)
+Line 4620 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
-                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
+           if (eptr >= md->end_subject)
-             RRETURN(MATCH_NOMATCH);
+             {
+             SCHECK_PARTIAL();
+             MRRETURN(MATCH_NOMATCH);
+             }
+           if (ctype == OP_ANY && IS_NEWLINE(eptr))
+             MRRETURN(MATCH_NOMATCH);
            c = *eptr++;
            switch(ctype)
              {
-             case OP_ANY:   /* This is the DOTALL case */
+             case OP_ANY:     /* This is the non-NL case */
-             break;
+             case OP_ALLANY:
              case OP_ANYBYTE:
              break;
              case OP_ANYNL:
              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:
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 3597 
 for (;;)
+Line 4662 
 for (;;)
                case 0x09:      /* HT */
                case 0x20:      /* SPACE */
                case 0xa0:      /* NBSP */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_HSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x09:      /* HT */
                case 0x20:      /* SPACE */
                case 0xa0:      /* NBSP */
-Line 3621 
 for (;;)
+Line 4686 
 for (;;)
                case 0x0c:      /* FF */
                case 0x0d:      /* CR */
                case 0x85:      /* NEL */
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              break;
              case OP_VSPACE:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x0a:      /* LF */
                case 0x0b:      /* VT */
                case 0x0c:      /* FF */
-Line 3639 
 for (;;)
+Line 4704 
 for (;;)
              break;
              case OP_NOT_DIGIT:
-             if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_DIGIT:
-             if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WHITESPACE:
-             if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WHITESPACE:
-             if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+             if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_NOT_WORDCHAR:
-             if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
              break;
              case OP_WORDCHAR:
-             if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
+             if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
              break;
              default:
-Line 3687 
 for (;;)
+Line 4752 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;