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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 459 by ph10,
Sun Oct  4 09:21:39 2009 UTC
+revision 595 by ph10,
Mon May  2 10:33:29 2011 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2009 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 71 
 defined PCRE_ERROR_xxx codes, which are
  /* Special internal returns from the match() function. Make them sufficiently
  negative to avoid the external error codes. */
- #define MATCH_COMMIT       (-999)
+ #define MATCH_ACCEPT       (-999)
- #define MATCH_PRUNE        (-998)
+ #define MATCH_COMMIT       (-998)
- #define MATCH_SKIP         (-997)
+ #define MATCH_PRUNE        (-997)
- #define MATCH_THEN         (-996)
+ #define MATCH_SKIP         (-996)
+ #define MATCH_SKIP_ARG     (-995)
+ #define MATCH_THEN         (-994)
+ /* This is a convenience macro for code that occurs many times. */
+ #define MRRETURN(ra) \
+   { \
+   md->mark = markptr; \
+   RRETURN(ra); \
+   }
  /* Maximum number of ints of offset to save on the stack for recursive calls.
  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
-Line 89 
 static const char rep_max[] = { 0, 0, 0,
+Line 99 
 static const char rep_max[] = { 0, 0, 0,
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  /*************************************************
  *        Debugging function to print chars       *
  *************************************************/
-Line 122 
 while (length-- > 0)
+Line 132 
 while (length-- > 0)
  *          Match a back-reference                *
  *************************************************/
- /* If a back reference hasn't been set, the length that is passed is greater
+ /* Normally, if a back reference hasn't been set, the length that is passed is
- than the number of characters left in the string, so the match fails.
+ negative, so the match always fails. However, in JavaScript compatibility mode,
+ the length passed is zero. Note that in caseless UTF-8 mode, the number of
+ subject bytes matched may be different to the number of reference bytes.
  Arguments:
    offset      index into the offset vector
-   eptr        points into the subject
+   eptr        pointer into the subject
-   length      length to be matched
+   length      length of reference to be matched (number of bytes)
    md          points to match data block
    ims         the ims flags
- Returns:      TRUE if matched
+ Returns:      < 0 if not matched, otherwise the number of subject bytes matched
  */
- static BOOL
+ static int
  match_ref(int offset, register USPTR eptr, int length, match_data *md,
    unsigned long int ims)
  {
- USPTR p = md->start_subject + md->offset_vector[offset];
+ USPTR eptr_start = eptr;
+ register USPTR p = md->start_subject + md->offset_vector[offset];
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (eptr >= md->end_subject)
    printf("matching subject <null>");
  else
-Line 154 
 pchars(p, length, FALSE, md);
+Line 167 
 pchars(p, length, FALSE, md);
  printf("\n");
  #endif
- /* Always fail if not enough characters left */
+ /* Always fail if reference not set (and not JavaScript compatible). */
- if (length > md->end_subject - eptr) return FALSE;
+ if (length < 0) return -1;
  /* Separate the caseless case for speed. In UTF-8 mode we can only do this
  properly if Unicode properties are supported. Otherwise, we can check only
-Line 168 
 if ((ims & PCRE_CASELESS) != 0)
+Line 181 
 if ((ims & PCRE_CASELESS) != 0)
  #ifdef SUPPORT_UCP
    if (md->utf8)
      {
-     USPTR endptr = eptr + length;
+     /* Match characters up to the end of the reference. NOTE: the number of
-     while (eptr < endptr)
+     bytes matched may differ, because there are some characters whose upper and
+     lower case versions code as different numbers of bytes. For example, U+023A
+     (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);
+     a sequence of 3 of the former uses 6 bytes, as does a sequence of two of
+     the latter. It is important, therefore, to check the length along the
+     reference, not along the subject (earlier code did this wrong). */
+     USPTR endptr = p + length;
+     while (p < endptr)
        {
        int c, d;
        GETCHARINC(c, eptr);
        GETCHARINC(d, p);
-       if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
+       if (c != d && c != UCD_OTHERCASE(d)) return -1;
        }
      }
    else
-Line 185 
 if ((ims & PCRE_CASELESS) != 0)
+Line 206 
 if ((ims & PCRE_CASELESS) != 0)
    is no UCP support. */
    while (length-- > 0)
-     { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
+     { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
    }
  /* In the caseful case, we can just compare the bytes, whether or not we
  are in UTF-8 mode. */
  else
-   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
+   { while (length-- > 0) if (*p++ != *eptr++) return -1; }
- return TRUE;
+ return eptr - eptr_start;
  }
-Line 245 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 266 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
-        RM51,  RM52, RM53, RM54 };
+        RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
+        RM61,  RM62 };
  /* These versions of the macros use the stack, as normal. There are debugging
  versions and production versions. Note that the "rw" argument of RMATCH isn't
- actuall used in this definition. */
+ actually used in this definition. */
  #ifndef NO_RECURSE
  #define REGISTER register
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
    { \
    printf("match() called in line %d\n", __LINE__); \
-   rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 268 
 actuall used in this definition. */
+Line 290 
 actuall used in this definition. */
    }
  #else
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
-   rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
-Line 283 
 argument of match(), which never changes
+Line 305 
 argument of match(), which never changes
  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
    {\
-   heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
+   heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
+   if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
    frame->Xwhere = rw; \
    newframe->Xeptr = ra;\
    newframe->Xecode = rb;\
    newframe->Xmstart = mstart;\
+   newframe->Xmarkptr = markptr;\
    newframe->Xoffset_top = rc;\
    newframe->Xims = re;\
    newframe->Xeptrb = rf;\
-Line 303 
 argument of match(), which never changes
+Line 327 
 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 325 
 typedef struct heapframe {
+Line 349 
 typedef struct heapframe {
    USPTR Xeptr;
    const uschar *Xecode;
    USPTR Xmstart;
+   USPTR Xmarkptr;
    int Xoffset_top;
    long int Xims;
    eptrblock *Xeptrb;
-Line 408 
 immediately. The second one is used when
+Line 433 
 immediately. The second one is used when
  the subject. */
  #define CHECK_PARTIAL()\
-   if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
+   if (md->partial != 0 && eptr >= md->end_subject && \
-     {\
+       eptr > md->start_used_ptr) \
-     md->hitend = TRUE;\
+     { \
-     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
+     md->hitend = TRUE; \
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
      }
  #define SCHECK_PARTIAL()\
-   if (md->partial && eptr > mstart)\
+   if (md->partial != 0 && eptr > md->start_used_ptr) \
-     {\
+     { \
-     md->hitend = TRUE;\
+     md->hitend = TRUE; \
-     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
+     if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
      }
-Line 432 
 Arguments:
+Line 458 
 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 445 
 Arguments:
+Line 472 
 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, 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 472 
 heap storage. Set up the top-level frame
+Line 500 
 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 480 
 frame->Xprevframe = NULL;            /*
+Line 509 
 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 495 
 HEAP_RECURSE:
+Line 525 
 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 622 
 TAIL_RECURSE:
+Line 653 
 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 666 
 for (;;)
+Line 697 
 for (;;)
    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 713 
 for (;;)
+Line 811 
 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 728 
 for (;;)
+Line 826 
 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 747 
 for (;;)
+Line 848 
 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 786 
 for (;;)
+Line 888 
 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 794 
 for (;;)
+Line 897 
 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 821 
 for (;;)
+Line 926 
 for (;;)
          cb.callout_number   = ecode[LINK_SIZE+2];
          cb.offset_vector    = md->offset_vector;
          cb.subject          = (PCRE_SPTR)md->start_subject;
-         cb.subject_length   = md->end_subject - md->start_subject;
+         cb.subject_length   = (int)(md->end_subject - md->start_subject);
-         cb.start_match      = mstart - md->start_subject;
+         cb.start_match      = (int)(mstart - md->start_subject);
-         cb.current_position = eptr - md->start_subject;
+         cb.current_position = (int)(eptr - md->start_subject);
          cb.pattern_position = GET(ecode, LINK_SIZE + 3);
          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
          cb.capture_top      = offset_top/2;
          cb.capture_last     = md->capture_last;
          cb.callout_data     = md->callout_data;
-         if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
+         if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
          if (rrc < 0) RRETURN(rrc);
          }
        ecode += _pcre_OP_lengths[OP_CALLOUT];
-Line 843 
 for (;;)
+Line 948 
 for (;;)
        {
        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)
                {
-Line 878 
 for (;;)
+Line 983 
 for (;;)
                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++)
                  {
-Line 895 
 for (;;)
+Line 1000 
 for (;;)
                    {
                    condition = GET2(slotB, 0) == md->recursive->group_num;
                    if (condition) break;
                    }
                  else break;
                  }
                }
              }
            }
          /* Chose branch according to the condition */
          ecode += condition? 3 : GET(ecode, 1);
          }
        }
      else if (condcode == OP_CREF || 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)
              {
-Line 942 
 for (;;)
+Line 1047 
 for (;;)
              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++)
                {
-Line 960 
 for (;;)
+Line 1065 
 for (;;)
                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
                  {
                  offset = GET2(slotB, 0) << 1;
                  condition = offset < offset_top &&
                    md->offset_vector[offset] >= 0;
                  if (condition) break;
                  }
                else break;
                }
              }
            }
          }
        /* Chose branch according to the condition */
        ecode += condition? 3 : GET(ecode, 1);
-Line 995 
 for (;;)
+Line 1100 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+       else if (rrc != MATCH_NOMATCH &&
+               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
-Line 1030 
 for (;;)
+Line 1136 
 for (;;)
        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 DEBUG
+ #ifdef PCRE_DEBUG
        printf("end bracket %d at *ACCEPT", number);
        printf("\n");
  #endif
-Line 1049 
 for (;;)
+Line 1155 
 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;
        }
      ecode += 3;
      break;
      /* End of the pattern, either real or forced. If we are in a top-level
-Line 1069 
 for (;;)
+Line 1175 
 for (;;)
        md->recursive = rec->prevrec;
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
-       offset_top = rec->offset_top;
+       offset_top = rec->save_offset_top;
-       mstart = rec->save_start;
        ims = original_ims;
        ecode = rec->after_call;
        break;
-Line 1085 
 for (;;)
+Line 1190 
 for (;;)
          (md->notempty ||
            (md->notempty_atstart &&
              mstart == md->start_subject + md->start_offset)))
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      /* Otherwise, we have a match. */
      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 1114 
 for (;;)
+Line 1224 
 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 1133 
 for (;;)
+Line 1249 
 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 1141 
 for (;;)
+Line 1259 
 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 1165 
 for (;;)
+Line 1290 
 for (;;)
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr);
          }
        }
-Line 1176 
 for (;;)
+Line 1301 
 for (;;)
        {
        eptr -= GET(ecode, 1);
-       if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+       if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
        }
      /* Save the earliest consulted character, then skip to next op code */
-Line 1197 
 for (;;)
+Line 1322 
 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 1260 
 for (;;)
+Line 1385 
 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;
-       new_recursive.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 1273 
 for (;;)
+Line 1396 
 for (;;)
          {
          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
            md, ims, eptrb, flags, RM6);
-         if (rrc == MATCH_MATCH)
+         if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
            {
            DPRINTF(("Recursion matched\n"));
            md->recursive = new_recursive.prevrec;
            if (new_recursive.offset_save != stacksave)
              (pcre_free)(new_recursive.offset_save);
-           RRETURN(MATCH_MATCH);
+           MRRETURN(MATCH_MATCH);
            }
-         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+         else if (rrc != MATCH_NOMATCH &&
+                 (rrc != MATCH_THEN || md->start_match_ptr != ecode))
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
            if (new_recursive.offset_save != stacksave)
-Line 1300 
 for (;;)
+Line 1424 
 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 1309 
 for (;;)
+Line 1433 
 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 1318 
 for (;;)
+Line 1443 
 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 1437 
 for (;;)
+Line 1568 
 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 1447 
 for (;;)
+Line 1579 
 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 1460 
 for (;;)
+Line 1593 
 for (;;)
        {
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
        printf("end bracket %d", number);
        printf("\n");
  #endif
-Line 1471 
 for (;;)
+Line 1604 
 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 1483 
 for (;;)
+Line 1616 
 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->offset_top;
+         offset_top = rec->save_offset_top;
          ecode = rec->after_call;
          ims = original_ims;
          break;
-Line 1543 
 for (;;)
+Line 1675 
 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 1557 
 for (;;)
+Line 1689 
 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 1582 
 for (;;)
+Line 1714 
 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 1632 
 for (;;)
+Line 1767 
 for (;;)
  #ifdef SUPPORT_UTF8
        if (utf8)
          {
+         /* Get status of previous character */
          if (eptr == md->start_subject) prev_is_word = FALSE; else
            {
            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;
            }
+         /* Get status of next character */
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-Line 1648 
 for (;;)
+Line 1799 
 for (;;)
          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
-       /* 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. */
          {
+         /* Get status of previous character */
          if (eptr == md->start_subject) prev_is_word = FALSE; else
            {
            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 cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
+         else
+ #ifdef SUPPORT_UCP
+         if (md->use_ucp)
+           {
+           c = *eptr;
+           if (c == '_') cur_is_word = TRUE; else
+             {
+             int cat = UCD_CATEGORY(c);
+             cur_is_word = (cat == ucp_L || cat == ucp_N);
+             }
+           }
+         else
+ #endif
+         cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
          }
        /* Now see if the situation is what we want */
        if ((*ecode++ == OP_WORD_BOUNDARY)?
             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
        }
      break;
      /* Match a single character type; inline for speed */
      case OP_ANY:
-     if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+     if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
      /* Fall through */
      case OP_ALLANY:
      if (eptr++ >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
      ecode++;
-Line 1701 
 for (;;)
+Line 1894 
 for (;;)
      if (eptr++ >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1710 
 for (;;)
+Line 1903 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1719 
 for (;;)
+Line 1912 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1727 
 for (;;)
+Line 1920 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1736 
 for (;;)
+Line 1929 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1744 
 for (;;)
+Line 1937 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1753 
 for (;;)
+Line 1946 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1761 
 for (;;)
+Line 1954 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1770 
 for (;;)
+Line 1963 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1778 
 for (;;)
+Line 1971 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1787 
 for (;;)
+Line 1980 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1795 
 for (;;)
+Line 1988 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1804 
 for (;;)
+Line 1997 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1812 
 for (;;)
+Line 2005 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-       default: RRETURN(MATCH_NOMATCH);
+       default: MRRETURN(MATCH_NOMATCH);
        case 0x000d:
        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
        break;
-Line 1830 
 for (;;)
+Line 2023 
 for (;;)
        case 0x0085:
        case 0x2028:
        case 0x2029:
-       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+       if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
        break;
        }
      ecode++;
-Line 1840 
 for (;;)
+Line 2033 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 1865 
 for (;;)
+Line 2058 
 for (;;)
        case 0x202f:    /* NARROW NO-BREAK SPACE */
        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
        case 0x3000:    /* IDEOGRAPHIC SPACE */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1874 
 for (;;)
+Line 2067 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       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 1908 
 for (;;)
+Line 2101 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 1921 
 for (;;)
+Line 2114 
 for (;;)
        case 0x85:      /* NEL */
        case 0x2028:    /* LINE SEPARATOR */
        case 0x2029:    /* PARAGRAPH SEPARATOR */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1930 
 for (;;)
+Line 2123 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       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 1957 
 for (;;)
+Line 2150 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
        {
-Line 1966 
 for (;;)
+Line 2159 
 for (;;)
        switch(ecode[1])
          {
          case PT_ANY:
-         if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
+         if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
          break;
          case PT_LAMP:
          if ((prop->chartype == ucp_Lu ||
               prop->chartype == ucp_Ll ||
               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
-          break;
+         break;
          case PT_GC:
          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          case PT_PC:
          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
          break;
          case PT_SC:
          if ((ecode[2] != prop->script) == (op == OP_PROP))
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         /* These are specials */
+         case PT_ALNUM:
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+              _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         case PT_SPACE:    /* Perl space */
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+              c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
+                == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         case PT_PXSPACE:  /* POSIX space */
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+              c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+              c == CHAR_FF || c == CHAR_CR)
+                == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
+         break;
+         case PT_WORD:
+         if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+              _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+              c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
+           MRRETURN(MATCH_NOMATCH);
          break;
+         /* This should never occur */
          default:
          RRETURN(PCRE_ERROR_INTERNAL);
          }
-Line 2006 
 for (;;)
+Line 2231 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
        {
        int category = UCD_CATEGORY(c);
-       if (category == ucp_M) RRETURN(MATCH_NOMATCH);
+       if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
        while (eptr < md->end_subject)
          {
          int len = 1;
-Line 2038 
 for (;;)
+Line 2263 
 for (;;)
      loops). */
      case OP_REF:
-       {
+     offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
-       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
+     ecode += 3;
-       ecode += 3;
-       /* If the reference is unset, there are two possibilities:
+     /* If the reference is unset, there are two possibilities:
-       (a) In the default, Perl-compatible state, set the length to be longer
+     (a) In the default, Perl-compatible state, set the length negative;
-       than the amount of subject left; this ensures that every attempt at a
+     this ensures that every attempt at a match fails. We can't just fail
-       match fails. We can't just fail here, because of the possibility of
+     here, because of the possibility of quantifiers with zero minima.
-       quantifiers with zero minima.
-       (b) If the JavaScript compatibility flag is set, set the length to zero
+     (b) If the JavaScript compatibility flag is set, set the length to zero
-       so that the back reference matches an empty string.
+     so that the back reference matches an empty string.
-       Otherwise, set the length to the length of what was matched by the
+     Otherwise, set the length to the length of what was matched by the
-       referenced subpattern. */
+     referenced subpattern. */
-       if (offset >= offset_top || md->offset_vector[offset] < 0)
+     if (offset >= offset_top || md->offset_vector[offset] < 0)
-         length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;
+       length = (md->jscript_compat)? 0 : -1;
-       else
+     else
-         length = md->offset_vector[offset+1] - md->offset_vector[offset];
+       length = md->offset_vector[offset+1] - md->offset_vector[offset];
-       /* Set up for repetition, or handle the non-repeated case */
+     /* Set up for repetition, or handle the non-repeated case */
-       switch (*ecode)
+     switch (*ecode)
-         {
+       {
-         case OP_CRSTAR:
+       case OP_CRSTAR:
-         case OP_CRMINSTAR:
+       case OP_CRMINSTAR:
-         case OP_CRPLUS:
+       case OP_CRPLUS:
-         case OP_CRMINPLUS:
+       case OP_CRMINPLUS:
-         case OP_CRQUERY:
+       case OP_CRQUERY:
-         case OP_CRMINQUERY:
+       case OP_CRMINQUERY:
-         c = *ecode++ - OP_CRSTAR;
+       c = *ecode++ - OP_CRSTAR;
-         minimize = (c & 1) != 0;
+       minimize = (c & 1) != 0;
-         min = rep_min[c];                 /* Pick up values from tables; */
+       min = rep_min[c];                 /* Pick up values from tables; */
-         max = rep_max[c];                 /* zero for max => infinity */
+       max = rep_max[c];                 /* zero for max => infinity */
-         if (max == 0) max = INT_MAX;
+       if (max == 0) max = INT_MAX;
-         break;
+       break;
-         case OP_CRRANGE:
+       case OP_CRRANGE:
-         case OP_CRMINRANGE:
+       case OP_CRMINRANGE:
-         minimize = (*ecode == OP_CRMINRANGE);
+       minimize = (*ecode == OP_CRMINRANGE);
-         min = GET2(ecode, 1);
+       min = GET2(ecode, 1);
-         max = GET2(ecode, 3);
+       max = GET2(ecode, 3);
-         if (max == 0) max = INT_MAX;
+       if (max == 0) max = INT_MAX;
-         ecode += 5;
+       ecode += 5;
-         break;
+       break;
-         default:               /* No repeat follows */
+       default:               /* No repeat follows */
-         if (!match_ref(offset, eptr, length, md, ims))
+       if ((length = match_ref(offset, eptr, length, md, ims)) < 0)
-           {
+         {
-           CHECK_PARTIAL();
+         CHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
-           }
-         eptr += length;
-         continue;              /* With the main loop */
          }
+       eptr += length;
+       continue;              /* With the main loop */
+       }
-       /* If the length of the reference is zero, just continue with the
+     /* Handle repeated back references. If the length of the reference is
-       main loop. */
+     zero, just continue with the main loop. */
-       if (length == 0) continue;
+     if (length == 0) continue;
-       /* First, ensure the minimum number of matches are present. We get back
+     /* First, ensure the minimum number of matches are present. We get back
-       the length of the reference string explicitly rather than passing the
+     the length of the reference string explicitly rather than passing the
-       address of eptr, so that eptr can be a register variable. */
+     address of eptr, so that eptr can be a register variable. */
-       for (i = 1; i <= min; i++)
+     for (i = 1; i <= min; i++)
+       {
+       int slength;
+       if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
          {
-         if (!match_ref(offset, eptr, length, md, ims))
+         CHECK_PARTIAL();
-           {
+         MRRETURN(MATCH_NOMATCH);
-           CHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
-           }
-         eptr += length;
          }
+       eptr += slength;
+       }
-       /* If min = max, continue at the same level without recursion.
+     /* If min = max, continue at the same level without recursion.
-       They are not both allowed to be zero. */
+     They are not both allowed to be zero. */
-       if (min == max) continue;
+     if (min == max) continue;
-       /* If minimizing, keep trying and advancing the pointer */
+     /* If minimizing, keep trying and advancing the pointer */
-       if (minimize)
+     if (minimize)
+       {
+       for (fi = min;; fi++)
          {
-         for (fi = min;; fi++)
+         int slength;
+         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         if (fi >= max) MRRETURN(MATCH_NOMATCH);
+         if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
+           CHECK_PARTIAL();
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           MRRETURN(MATCH_NOMATCH);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
-           if (!match_ref(offset, eptr, length, md, ims))
-             {
-             CHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
-             }
-           eptr += length;
            }
-         /* Control never gets here */
+         eptr += slength;
          }
+       /* Control never gets here */
+       }
-       /* If maximizing, find the longest string and work backwards */
+     /* If maximizing, find the longest string and work backwards */
-       else
+     else
+       {
+       pp = eptr;
+       for (i = min; i < max; i++)
          {
-         pp = eptr;
+         int slength;
-         for (i = min; i < max; i++)
+         if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
-           {
-           if (!match_ref(offset, eptr, length, md, ims)) break;
-           eptr += length;
-           }
-         while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
+           CHECK_PARTIAL();
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           break;
-           eptr -= length;
            }
-         RRETURN(MATCH_NOMATCH);
+         eptr += slength;
          }
+       while (eptr >= pp)
+         {
+         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         eptr -= length;
+         }
+       MRRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 2217 
 for (;;)
+Line 2446 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             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 2239 
 for (;;)
+Line 2468 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             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 2264 
 for (;;)
+Line 2493 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               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 2289 
 for (;;)
+Line 2518 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               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 2315 
 for (;;)
+Line 2544 
 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 2341 
 for (;;)
+Line 2574 
 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 2354 
 for (;;)
+Line 2591 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2406 
 for (;;)
+Line 2643 
 for (;;)
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          GETCHARINCTEST(c, eptr);
-         if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+         if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
          }
        /* If max == min we can continue with the main loop without the
-Line 2426 
 for (;;)
+Line 2663 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
-           if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+           if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2446 
 for (;;)
+Line 2683 
 for (;;)
          for (i = min; i < max; i++)
            {
            int len = 1;
-           if (eptr >= md->end_subject) break;
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
            GETCHARLENTEST(c, eptr, len);
            if (!_pcre_xclass(c, data)) break;
            eptr += len;
-Line 2458 
 for (;;)
+Line 2699 
 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 2477 
 for (;;)
+Line 2718 
 for (;;)
        if (length > md->end_subject - eptr)
          {
          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
-       while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
+       while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
        }
      else
  #endif
-Line 2489 
 for (;;)
+Line 2730 
 for (;;)
        if (md->end_subject - eptr < 1)
          {
          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
-       if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
+       if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
      break;
-Line 2509 
 for (;;)
+Line 2750 
 for (;;)
        if (length > md->end_subject - eptr)
          {
          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* If the pattern character's value is < 128, we have only one byte, and
-Line 2517 
 for (;;)
+Line 2758 
 for (;;)
        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 2536 
 for (;;)
+Line 2777 
 for (;;)
  #ifdef SUPPORT_UCP
            if (dc != UCD_OTHERCASE(fc))
  #endif
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          }
        }
-Line 2548 
 for (;;)
+Line 2789 
 for (;;)
        if (md->end_subject - eptr < 1)
          {
          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
-       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
      break;
-Line 2644 
 for (;;)
+Line 2885 
 for (;;)
            else
              {
              CHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
-Line 2656 
 for (;;)
+Line 2897 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr <= md->end_subject - length &&
                memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-Line 2667 
 for (;;)
+Line 2908 
 for (;;)
              else
                {
                CHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              }
            /* Control never gets here */
-Line 2685 
 for (;;)
+Line 2926 
 for (;;)
                       eptr <= md->end_subject - oclength &&
                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
  #endif  /* SUPPORT_UCP */
-             else break;
+             else
+               {
+               CHECK_PARTIAL();
+               break;
+               }
              }
            if (possessive) continue;
-Line 2694 
 for (;;)
+Line 2939 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (eptr == pp) { RRETURN(MATCH_NOMATCH); }
+             if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
  #ifdef SUPPORT_UCP
              eptr--;
              BACKCHAR(eptr);
-Line 2737 
 for (;;)
+Line 2982 
 for (;;)
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
-         if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+         if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
          }
        if (min == max) continue;
        if (minimize)
-Line 2748 
 for (;;)
+Line 2993 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+           if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2763 
 for (;;)
+Line 3008 
 for (;;)
          pp = eptr;
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
+           if (eptr >= md->end_subject)
-           eptr++;
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
+           if (fc != md->lcc[*eptr]) break;
+           eptr++;
            }
          if (possessive) continue;
-Line 2775 
 for (;;)
+Line 3025 
 for (;;)
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2789 
 for (;;)
+Line 3039 
 for (;;)
          if (eptr >= md->end_subject)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
-         if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
+         if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
          }
        if (min == max) continue;
-Line 2802 
 for (;;)
+Line 3052 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
+           if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2817 
 for (;;)
+Line 3067 
 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;
-Line 2828 
 for (;;)
+Line 3083 
 for (;;)
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2840 
 for (;;)
+Line 3095 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      GETCHARINCTEST(c, eptr);
-Line 2850 
 for (;;)
+Line 3105 
 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 2948 
 for (;;)
+Line 3203 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             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 2965 
 for (;;)
+Line 3220 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+           if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
            }
          }
-Line 2984 
 for (;;)
+Line 3239 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               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 3003 
 for (;;)
+Line 3258 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+             if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 3029 
 for (;;)
+Line 3284 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(d, eptr, len);
              if (d < 256) d = md->lcc[d];
              if (fc == d) break;
-Line 3050 
 for (;;)
+Line 3309 
 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 3062 
 for (;;)
+Line 3326 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3081 
 for (;;)
+Line 3345 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(d, eptr);
-           if (fc == d) RRETURN(MATCH_NOMATCH);
+           if (fc == d) MRRETURN(MATCH_NOMATCH);
            }
          }
        else
-Line 3096 
 for (;;)
+Line 3360 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+           if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
            }
          }
-Line 3115 
 for (;;)
+Line 3379 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINC(d, eptr);
-             if (fc == d) RRETURN(MATCH_NOMATCH);
+             if (fc == d) MRRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 3133 
 for (;;)
+Line 3397 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+             if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 3159 
 for (;;)
+Line 3423 
 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 3179 
 for (;;)
+Line 3447 
 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 3191 
 for (;;)
+Line 3464 
 for (;;)
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3285 
 for (;;)
+Line 3558 
 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)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              }
-Line 3303 
 for (;;)
+Line 3576 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
                   prop_chartype == ucp_Lt) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3320 
 for (;;)
+Line 3593 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3335 
 for (;;)
+Line 3608 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3350 
 for (;;)
+Line 3623 
 for (;;)
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
              }
            break;
+           case PT_ALNUM:
+           for (i = 1; i <= min; i++)
+             {
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L || prop_category == ucp_N)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           case PT_SPACE:    /* Perl space */
+           for (i = 1; i <= min; i++)
+             {
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           for (i = 1; i <= min; i++)
+             {
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           case PT_WORD:
+           for (i = 1; i <= min; i++)
+             {
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               MRRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINCTEST(c, eptr);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L || prop_category == ucp_N ||
+                  c == CHAR_UNDERSCORE)
+                    == prop_fail_result)
+               MRRETURN(MATCH_NOMATCH);
+             }
+           break;
+           /* This should not occur */
            default:
            RRETURN(PCRE_ERROR_INTERNAL);
            }
-Line 3374 
 for (;;)
+Line 3716 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
-           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
+           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-Line 3405 
 for (;;)
+Line 3747 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
-Line 3419 
 for (;;)
+Line 3761 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
-Line 3427 
 for (;;)
+Line 3769 
 for (;;)
          break;
          case OP_ANYBYTE:
-         if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
+         if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
          eptr += min;
          break;
-Line 3437 
 for (;;)
+Line 3779 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
-Line 3455 
 for (;;)
+Line 3797 
 for (;;)
              case 0x0085:
              case 0x2028:
              case 0x2029:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3467 
 for (;;)
+Line 3809 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3492 
 for (;;)
+Line 3834 
 for (;;)
              case 0x202f:    /* NARROW NO-BREAK SPACE */
              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
              case 0x3000:    /* IDEOGRAPHIC SPACE */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3503 
 for (;;)
+Line 3845 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             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 3539 
 for (;;)
+Line 3881 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3552 
 for (;;)
+Line 3894 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3563 
 for (;;)
+Line 3905 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             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 3587 
 for (;;)
+Line 3929 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3601 
 for (;;)
+Line 3943 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3615 
 for (;;)
+Line 3957 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 3629 
 for (;;)
+Line 3971 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3640 
 for (;;)
+Line 3982 
 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 3653 
 for (;;)
+Line 3999 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
          break;
-Line 3679 
 for (;;)
+Line 4025 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+           if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
            eptr++;
            }
          break;
-Line 3690 
 for (;;)
+Line 4036 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 3699 
 for (;;)
+Line 4045 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 3710 
 for (;;)
+Line 4056 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
-Line 3724 
 for (;;)
+Line 4070 
 for (;;)
              case 0x000b:
              case 0x000c:
              case 0x0085:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3736 
 for (;;)
+Line 4082 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 3744 
 for (;;)
+Line 4090 
 for (;;)
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3755 
 for (;;)
+Line 4101 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-Line 3774 
 for (;;)
+Line 4120 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 3784 
 for (;;)
+Line 4130 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3795 
 for (;;)
+Line 4141 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-             default: RRETURN(MATCH_NOMATCH);
+             default: MRRETURN(MATCH_NOMATCH);
              case 0x0a:      /* LF */
              case 0x0b:      /* VT */
              case 0x0c:      /* FF */
-Line 3816 
 for (;;)
+Line 4162 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+           if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3828 
 for (;;)
+Line 4174 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+           if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3840 
 for (;;)
+Line 4186 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+           if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3852 
 for (;;)
+Line 4198 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
-           if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+           if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3864 
 for (;;)
+Line 4210 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if ((md->ctypes[*eptr++] & ctype_word) != 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3877 
 for (;;)
+Line 4223 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if ((md->ctypes[*eptr++] & ctype_word) == 0)
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          break;
-Line 3909 
 for (;;)
+Line 4255 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             GETCHARINC(c, eptr);
+             GETCHARINCTEST(c, eptr);
-             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+             if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 3925 
 for (;;)
+Line 4271 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             GETCHARINC(c, eptr);
+             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 3945 
 for (;;)
+Line 4291 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             GETCHARINC(c, eptr);
+             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 3963 
 for (;;)
+Line 4309 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             GETCHARINC(c, eptr);
+             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 3981 
 for (;;)
+Line 4327 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
-             GETCHARINC(c, eptr);
+             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 4008 
 for (;;)
+Line 4436 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
-           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
+           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-Line 4040 
 for (;;)
+Line 4468 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if (ctype == OP_ANY && IS_NEWLINE(eptr))
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            switch(ctype)
              {
-Line 4059 
 for (;;)
+Line 4487 
 for (;;)
              case OP_ANYNL:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x000d:
                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
                break;
-Line 4071 
 for (;;)
+Line 4499 
 for (;;)
                case 0x0085:
                case 0x2028:
                case 0x2029:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 4099 
 for (;;)
+Line 4527 
 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 4141 
 for (;;)
+Line 4569 
 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 4162 
 for (;;)
+Line 4590 
 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 4203 
 for (;;)
+Line 4631 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            if (ctype == OP_ANY && IS_NEWLINE(eptr))
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            c = *eptr++;
            switch(ctype)
              {
-Line 4222 
 for (;;)
+Line 4650 
 for (;;)
              case OP_ANYNL:
              switch(c)
                {
-               default: RRETURN(MATCH_NOMATCH);
+               default: MRRETURN(MATCH_NOMATCH);
                case 0x000d:
                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
                break;
-Line 4233 
 for (;;)
+Line 4661 
 for (;;)
                case 0x000b:
                case 0x000c:
                case 0x0085:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 4245 
 for (;;)
+Line 4673 
 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 4269 
 for (;;)
+Line 4697 
 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 4287 
 for (;;)
+Line 4715 
 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 4335 
 for (;;)
+Line 4763 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
-             GETCHARLEN(c, eptr, len);
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
              if (prop_fail_result) break;
              eptr+= len;
              }
-Line 4346 
 for (;;)
+Line 4778 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
-             GETCHARLEN(c, eptr, len);
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
-Line 4361 
 for (;;)
+Line 4797 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
-             GETCHARLEN(c, eptr, len);
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
                break;
-Line 4374 
 for (;;)
+Line 4814 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
-             GETCHARLEN(c, eptr, len);
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
                break;
-Line 4387 
 for (;;)
+Line 4831 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
-             GETCHARLEN(c, eptr, len);
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
                break;
              eptr+= len;
              }
            break;
+           case PT_ALNUM:
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L || prop_category == ucp_N)
+                  == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           case PT_SPACE:    /* Perl space */
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_FF || c == CHAR_CR)
+                  == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
+                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
+                  == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           case PT_WORD:
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
+             GETCHARLENTEST(c, eptr, len);
+             prop_category = UCD_CATEGORY(c);
+             if ((prop_category == ucp_L || prop_category == ucp_N ||
+                  c == CHAR_UNDERSCORE) == prop_fail_result)
+               break;
+             eptr+= len;
+             }
+           break;
+           default:
+           RRETURN(PCRE_ERROR_INTERNAL);
            }
          /* eptr is now past the end of the maximum run */
-Line 4416 
 for (;;)
+Line 4941 
 for (;;)
          {
          for (i = min; i < max; i++)
            {
-           if (eptr >= md->end_subject) break;
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             break;
+             }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
            if (prop_category == ucp_M) break;
-Line 4436 
 for (;;)
+Line 4965 
 for (;;)
          /* eptr is now past the end of the maximum run */
          if (possessive) continue;
          for(;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
-Line 4471 
 for (;;)
+Line 5001 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
+               if (IS_NEWLINE(eptr)) break;
                eptr++;
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
-Line 4483 
 for (;;)
+Line 5018 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
+               if (IS_NEWLINE(eptr)) break;
                eptr++;
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
-Line 4495 
 for (;;)
+Line 5035 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject) break;
+               if (eptr >= md->end_subject)
+                 {
+                 SCHECK_PARTIAL();
+                 break;
+                 }
                eptr++;
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
-Line 4508 
 for (;;)
+Line 5052 
 for (;;)
            case OP_ANYBYTE:
            c = max - min;
            if (c > (unsigned int)(md->end_subject - eptr))
-             c = md->end_subject - eptr;
+             {
-           eptr += c;
+             eptr = md->end_subject;
+             SCHECK_PARTIAL();
+             }
+           else eptr += c;
            break;
            case OP_ANYNL:
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c == 0x000d)
                {
-Line 4541 
 for (;;)
+Line 5092 
 for (;;)
              {
              BOOL gotspace;
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              switch(c)
                {
-Line 4579 
 for (;;)
+Line 5134 
 for (;;)
              {
              BOOL gotspace;
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              switch(c)
                {
-Line 4603 
 for (;;)
+Line 5162 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
              eptr+= len;
-Line 4614 
 for (;;)
+Line 5177 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
              eptr+= len;
-Line 4625 
 for (;;)
+Line 5192 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
              eptr+= len;
-Line 4636 
 for (;;)
+Line 5207 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
              eptr+= len;
-Line 4647 
 for (;;)
+Line 5222 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
              eptr+= len;
-Line 4658 
 for (;;)
+Line 5237 
 for (;;)
            for (i = min; i < max; i++)
              {
              int len = 1;
-             if (eptr >= md->end_subject) break;
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               break;
+               }
              GETCHARLEN(c, eptr, len);
              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
              eptr+= len;
-Line 4690 
 for (;;)
+Line 5273 
 for (;;)
            case OP_ANY:
            for (i = min; i < max; i++)