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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 501 by ph10,
Sun Mar  7 11:49:54 2010 UTC
+revision 602 by ph10,
Wed May 25 08:29:03 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-2010 University of Cambridge
+            Copyright (c) 1997-2011 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 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
+   caseless    TRUE if caseless
- 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)
+   BOOL caseless)
  {
- USPTR p = md->start_subject + md->offset_vector[offset];
+ USPTR eptr_start = eptr;
+ register USPTR p = md->start_subject + md->offset_vector[offset];
  #ifdef PCRE_DEBUG
  if (eptr >= md->end_subject)
-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
  ASCII characters. */
- if ((ims & PCRE_CASELESS) != 0)
+ if (caseless)
    {
  #ifdef SUPPORT_UTF8
  #ifdef SUPPORT_UCP
    if (md->utf8)
      {
-     USPTR endptr = eptr + length;
+     /* Match characters up to the end of the reference. NOTE: the number of
-     while (eptr < endptr)
+     bytes matched may differ, because there are some characters whose upper and
+     lower case versions code as different numbers of bytes. For example, U+023A
+     (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);
+     a sequence of 3 of the former uses 6 bytes, as does a sequence of two of
+     the latter. It is important, therefore, to check the length along the
+     reference, not along the subject (earlier code did this wrong). */
+     USPTR endptr = p + length;
+     while (p < endptr)
        {
        int c, d;
+       if (eptr >= md->end_subject) return -1;
        GETCHARINC(c, eptr);
        GETCHARINC(d, p);
-       if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
+       if (c != d && c != UCD_OTHERCASE(d)) return -1;
        }
      }
    else
-Line 183 
 if ((ims & PCRE_CASELESS) != 0)
+Line 205 
 if ((ims & PCRE_CASELESS) != 0)
    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
    is no UCP support. */
+     {
-   while (length-- > 0)
+     if (eptr + length > md->end_subject) return -1;
-     { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
+     while (length-- > 0)
+       { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
+     }
    }
  /* In the caseful case, we can just compare the bytes, whether or not we
  are in UTF-8 mode. */
  else
-   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
+   {
+   if (eptr + length > md->end_subject) return -1;
+   while (length-- > 0) if (*p++ != *eptr++) return -1;
+   }
- return TRUE;
+ return eptr - eptr_start;
  }
-Line 245 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 272 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
-        RM51,  RM52, RM53, RM54 };
+        RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
+        RM61,  RM62 };
  /* These versions of the macros use the stack, as normal. There are debugging
  versions and production versions. Note that the "rw" argument of RMATCH isn't
-Line 255 
 actually used in this definition. */
+Line 283 
 actually used in this definition. */
  #define REGISTER register
  #ifdef PCRE_DEBUG
- #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
+ #define RMATCH(ra,rb,rc,rd,re,rf,rw) \
    { \
    printf("match() called in line %d\n", __LINE__); \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 267 
 actually used in this definition. */
+Line 295 
 actually used in this definition. */
    return ra; \
    }
  #else
- #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
+ #define RMATCH(ra,rb,rc,rd,re,rf,rw) \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
-Line 281 
 argument of match(), which never changes
+Line 309 
 argument of match(), which never changes
  #define REGISTER
- #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
+ #define RMATCH(ra,rb,rc,rd,re,rf,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 = re;\
-   newframe->Xeptrb = rf;\
+   newframe->Xflags = rf;\
-   newframe->Xflags = rg;\
    newframe->Xrdepth = frame->Xrdepth + 1;\
    newframe->Xprevframe = frame;\
    frame = newframe;\
-Line 304 
 argument of match(), which never changes
+Line 332 
 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 328 
 typedef struct heapframe {
+Line 356 
 typedef struct heapframe {
    USPTR Xmstart;
    USPTR Xmarkptr;
    int Xoffset_top;
-   long int Xims;
    eptrblock *Xeptrb;
    int Xflags;
    unsigned int Xrdepth;
-Line 351 
 typedef struct heapframe {
+Line 378 
 typedef struct heapframe {
    BOOL Xcondition;
    BOOL Xprev_is_word;
-   unsigned long int Xoriginal_ims;
  #ifdef SUPPORT_UCP
    int Xprop_type;
    int Xprop_value;
-Line 410 
 immediately. The second one is used when
+Line 435 
 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 != 0 && 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 437 
 Arguments:
+Line 463 
 Arguments:
     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
     eptrb       pointer to chain of blocks containing eptr at start of
                   brackets - for testing for empty matches
     flags       can contain
-Line 448 
 Arguments:
+Line 473 
 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, USPTR
+ match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
-   markptr, int offset_top, match_data *md, unsigned long int ims,
+   const uschar *markptr, int offset_top, match_data *md, eptrblock *eptrb,
-   eptrblock *eptrb, int flags, unsigned int rdepth)
+   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 467 
 register unsigned int c;   /* Character
+Line 493 
 register unsigned int c;   /* Character
  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
  BOOL minimize, possessive; /* Quantifier options */
+ BOOL caseless;
  int condcode;
  /* When recursion is not being used, all "local" variables that have to be
-Line 475 
 heap storage. Set up the top-level frame
+Line 502 
 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 485 
 frame->Xecode = ecode;
+Line 513 
 frame->Xecode = ecode;
  frame->Xmstart = mstart;
  frame->Xmarkptr = markptr;
  frame->Xoffset_top = offset_top;
- frame->Xims = ims;
  frame->Xeptrb = eptrb;
  frame->Xflags = flags;
  frame->Xrdepth = rdepth;
-Line 501 
 HEAP_RECURSE:
+Line 528 
 HEAP_RECURSE:
  #define mstart             frame->Xmstart
  #define markptr            frame->Xmarkptr
  #define offset_top         frame->Xoffset_top
- #define ims                frame->Xims
  #define eptrb              frame->Xeptrb
  #define flags              frame->Xflags
  #define rdepth             frame->Xrdepth
-Line 525 
 HEAP_RECURSE:
+Line 551 
 HEAP_RECURSE:
  #define condition          frame->Xcondition
  #define prev_is_word       frame->Xprev_is_word
- #define original_ims       frame->Xoriginal_ims
  #ifdef SUPPORT_UCP
  #define prop_type          frame->Xprop_type
  #define prop_value         frame->Xprop_value
-Line 580 
 BOOL cur_is_word;                  /* a
+Line 604 
 BOOL cur_is_word;                  /* a
  BOOL condition;
  BOOL prev_is_word;
- unsigned long int original_ims;
  #ifdef SUPPORT_UCP
  int prop_type;
  int prop_value;
-Line 644 
 haven't exceeded the recursive call limi
+Line 666 
 haven't exceeded the recursive call limi
  if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
  if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
- original_ims = ims;    /* Save for resetting on ')' */
  /* At the start of a group with an unlimited repeat that may match an empty
  string, the match_cbegroup flag is set. When this is the case, add the current
  subject pointer to the chain of such remembered pointers, to be checked when we
-Line 671 
 for (;;)
+Line 691 
 for (;;)
    switch(op)
      {
+     case OP_MARK:
+     markptr = ecode + 2;
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       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,
+       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);
+       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,
+       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);
+       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,
+       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);
+       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, 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 733 
 for (;;)
+Line 820 
 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);
+           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 752 
 for (;;)
+Line 842 
 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 789 
 for (;;)
+Line 880 
 for (;;)
          /* Possibly empty group; can't use tail recursion. */
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
-           eptrb, flags, RM48);
+           flags, RM48);
+         if (rrc == MATCH_NOMATCH) md->mark = markptr;
          RRETURN(rrc);
          }
        /* For non-final alternatives, continue the loop for a NOMATCH result;
        otherwise return. */
-       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
-         eptrb, flags, RM2);
+         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 826 
 for (;;)
+Line 920 
 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 992 
 for (;;)
+Line 1086 
 for (;;)
      else
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL,
            match_condassert, RM3);
        if (rrc == MATCH_MATCH)
          {
-Line 1000 
 for (;;)
+Line 1094 
 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 1021 
 for (;;)
+Line 1116 
 for (;;)
        ecode += 1 + LINK_SIZE;
        if (op == OP_SCOND)        /* Possibly empty group */
          {
-         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
+         RMATCH(eptr, ecode, offset_top, md, eptrb, match_cbegroup, RM49);
          RRETURN(rrc);
          }
        else                       /* Group must match something */
-Line 1054 
 for (;;)
+Line 1149 
 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;
-Line 1075 
 for (;;)
+Line 1170 
 for (;;)
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
        offset_top = rec->save_offset_top;
-       ims = original_ims;
        ecode = rec->after_call;
        break;
        }
-Line 1089 
 for (;;)
+Line 1183 
 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);
-     /* Change option settings */
+     /* 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. */
-     case OP_OPT:
+     rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
-     ims = ecode[1];
+     MRRETURN(rrc);
-     ecode += 2;
-     DPRINTF(("ims set to %02lx\n", ims));
-     break;
      /* Assertion brackets. Check the alternative branches in turn - the
      matching won't pass the KET for an assertion. If any one branch matches,
-Line 1116 
 for (;;)
+Line 1207 
 for (;;)
      case OP_ASSERTBACK:
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, 0,
          RM4);
-       if (rrc == MATCH_MATCH)
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
          {
          mstart = md->start_match_ptr;   /* In case \K reset it */
          break;
          }
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+       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 1149 
 for (;;)
+Line 1242 
 for (;;)
      case OP_ASSERTBACK_NOT:
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, 0,
          RM5);
-       if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
          {
          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
          break;
          }
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 1180 
 for (;;)
+Line 1275 
 for (;;)
        while (i-- > 0)
          {
          eptr--;
-         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
          BACKCHAR(eptr);
          }
        }
-Line 1191 
 for (;;)
+Line 1286 
 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 1212 
 for (;;)
+Line 1307 
 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 1285 
 for (;;)
+Line 1380 
 for (;;)
        do
          {
          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
-           md, ims, eptrb, flags, RM6);
+           md, 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 1313 
 for (;;)
+Line 1409 
 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 1331 
 for (;;)
+Line 1427 
 for (;;)
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, 0, RM7);
-       if (rrc == MATCH_MATCH)
+       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
          {
          mstart = md->start_match_ptr;
          break;
          }
-       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);
        }
      while (*ecode == OP_ALT);
-Line 1368 
 for (;;)
+Line 1466 
 for (;;)
      /* The repeating kets try the rest of the pattern or restart from the
      preceding bracket, in the appropriate order. The second "call" of match()
-     uses tail recursion, to avoid using another stack frame. We need to reset
+     uses tail recursion, to avoid using another stack frame. */
-     any options that changed within the bracket before re-running it, so
-     check the next opcode. */
-     if (ecode[1+LINK_SIZE] == OP_OPT)
-       {
-       ims = (ims & ~PCRE_IMS) | ecode[4];
-       DPRINTF(("ims set to %02lx at group repeat\n", ims));
-       }
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, 0, RM8);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode = prev;
        flags = 0;
-Line 1388 
 for (;;)
+Line 1478 
 for (;;)
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
+       RMATCH(eptr, prev, offset_top, md, eptrb, match_cbegroup, RM9);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
        flags = 0;
-Line 1412 
 for (;;)
+Line 1502 
 for (;;)
      case OP_BRAZERO:
        {
        next = ecode+1;
-       RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);
+       RMATCH(eptr, next, offset_top, md, eptrb, 0, RM10);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        do next += GET(next,1); while (*next == OP_ALT);
        ecode = next + 1 + LINK_SIZE;
-Line 1423 
 for (;;)
+Line 1513 
 for (;;)
        {
        next = ecode+1;
        do next += GET(next, 1); while (*next == OP_ALT);
-       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0, RM11);
+       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, 0, RM11);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode++;
        }
-Line 1467 
 for (;;)
+Line 1557 
 for (;;)
        md->end_match_ptr = eptr;      /* For ONCE */
        md->end_offset_top = offset_top;
        md->start_match_ptr = mstart;
-       RRETURN(MATCH_MATCH);
+       MRRETURN(MATCH_MATCH);
        }
      /* For capturing groups we have to check the group number back at the start
-Line 1491 
 for (;;)
+Line 1581 
 for (;;)
          {
          md->offset_vector[offset] =
            md->offset_vector[md->offset_end - number];
-         md->offset_vector[offset+1] = eptr - md->start_subject;
+         md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
          if (offset_top <= offset) offset_top = offset + 2;
          }
-Line 1507 
 for (;;)
+Line 1597 
 for (;;)
            rec->saved_max * sizeof(int));
          offset_top = rec->save_offset_top;
          ecode = rec->after_call;
-         ims = original_ims;
          break;
          }
        }
-     /* For both capturing and non-capturing groups, reset the value of the ims
-     flags, in case they got changed during the group. */
-     ims = original_ims;
-     DPRINTF(("ims reset to %02lx\n", ims));
      /* For a non-repeating ket, just continue at this level. This also
      happens for a repeating ket if no characters were matched in the group.
      This is the forcible breaking of infinite loops as implemented in Perl
-Line 1539 
 for (;;)
+Line 1622 
 for (;;)
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, 0, RM12);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        if (flags != 0)    /* Could match an empty string */
          {
-         RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
+         RMATCH(eptr, prev, offset_top, md, eptrb, flags, RM50);
          RRETURN(rrc);
          }
        ecode = prev;
-Line 1551 
 for (;;)
+Line 1634 
 for (;;)
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
+       RMATCH(eptr, prev, offset_top, md, eptrb, flags, RM13);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
        flags = 0;
-Line 1559 
 for (;;)
+Line 1642 
 for (;;)
        }
      /* Control never gets here */
-     /* Start of subject unless notbol, or after internal newline if multiline */
+     /* Not multiline mode: start of subject assertion, unless notbol. */
      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);
-       ecode++;
-       break;
-       }
-     /* ... else fall through */
      /* 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;
+     /* Multiline mode: start of subject unless notbol, or after any newline. */
+     case OP_CIRCM:
+     if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
+     if (eptr != md->start_subject &&
+         (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
+       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 1594 
 for (;;)
+Line 1678 
 for (;;)
      ecode++;
      break;
-     /* Assert before internal newline if multiline, or before a terminating
+     /* Multiline mode: assert before any newline, or before end of subject
-     newline unless endonly is set, else end of subject unless noteol is set. */
+     unless noteol is set. */
-     case OP_DOLL:
+     case OP_DOLLM:
-     if ((ims & PCRE_MULTILINE) != 0)
+     if (eptr < md->end_subject)
-       {
+       { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
-       if (eptr < md->end_subject)
-         { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
-       else
-         { if (md->noteol) RRETURN(MATCH_NOMATCH); }
-       ecode++;
-       break;
-       }
      else
        {
-       if (md->noteol) RRETURN(MATCH_NOMATCH);
+       if (md->noteol) MRRETURN(MATCH_NOMATCH);
-       if (!md->endonly)
+       SCHECK_PARTIAL();
-         {
-         if (eptr != md->end_subject &&
-             (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
-           RRETURN(MATCH_NOMATCH);
-         ecode++;
-         break;
-         }
        }
+     ecode++;
+     break;
+     /* Not multiline mode: assert before a terminating newline or before end of
+     subject unless noteol is set. */
+     case OP_DOLL:
+     if (md->noteol) MRRETURN(MATCH_NOMATCH);
+     if (!md->endonly) goto ASSERT_NL_OR_EOS;
      /* ... 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 1651 
 for (;;)
+Line 1737 
 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 1667 
 for (;;)
+Line 1769 
 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 1720 
 for (;;)
+Line 1864 
 for (;;)
      if (eptr++ >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1729 
 for (;;)
+Line 1873 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1738 
 for (;;)
+Line 1882 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1746 
 for (;;)
+Line 1890 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1755 
 for (;;)
+Line 1899 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1763 
 for (;;)
+Line 1907 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1772 
 for (;;)
+Line 1916 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1780 
 for (;;)
+Line 1924 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1789 
 for (;;)
+Line 1933 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1797 
 for (;;)
+Line 1941 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1806 
 for (;;)
+Line 1950 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1814 
 for (;;)
+Line 1958 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1823 
 for (;;)
+Line 1967 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1831 
 for (;;)
+Line 1975 
 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 1849 
 for (;;)
+Line 1994 
 for (;;)
        case 0x0085:
        case 0x2028:
        case 0x2029:
-       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+       if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
        break;
        }
      ecode++;
-Line 1859 
 for (;;)
+Line 2004 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 1884 
 for (;;)
+Line 2029 
 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 1893 
 for (;;)
+Line 2038 
 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 1927 
 for (;;)
+Line 2072 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 1940 
 for (;;)
+Line 2085 
 for (;;)
        case 0x85:      /* NEL */
        case 0x2028:    /* LINE SEPARATOR */
        case 0x2029:    /* PARAGRAPH SEPARATOR */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1949 
 for (;;)
+Line 2094 
 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 1976 
 for (;;)
+Line 2121 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
        {
-Line 1985 
 for (;;)
+Line 2130 
 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 2025 
 for (;;)
+Line 2202 
 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 2057 
 for (;;)
+Line 2234 
 for (;;)
      loops). */
      case OP_REF:
-       {
+     case OP_REFI:
-       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
+     caseless = op == OP_REFI;
-       ecode += 3;
+     offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
+     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, caseless)) < 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, caseless)) < 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, eptrb, 0, RM14);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         if (fi >= max) MRRETURN(MATCH_NOMATCH);
+         if ((slength = match_ref(offset, eptr, length, md, caseless)) < 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, caseless)) < 0)
            {
-           if (!match_ref(offset, eptr, length, md, ims))
+           CHECK_PARTIAL();
-             {
+           break;
-             CHECK_PARTIAL();
-             break;
-             }
-           eptr += length;
-           }
-         while (eptr >= pp)
-           {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
-           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           eptr -= length;
            }
-         RRETURN(MATCH_NOMATCH);
+         eptr += slength;
+         }
+       while (eptr >= pp)
+         {
+         RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM15);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         eptr -= length;
          }
+       MRRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 2240 
 for (;;)
+Line 2419 
 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 2262 
 for (;;)
+Line 2441 
 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 2285 
 for (;;)
+Line 2464 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
+             RMATCH(eptr, ecode, offset_top, md, 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 2310 
 for (;;)
+Line 2489 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
+             RMATCH(eptr, ecode, offset_top, md, 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 2356 
 for (;;)
+Line 2535 
 for (;;)
              }
            for (;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM18);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 2379 
 for (;;)
+Line 2558 
 for (;;)
              }
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM19);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2437 
 for (;;)
+Line 2616 
 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 2455 
 for (;;)
+Line 2634 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
+           RMATCH(eptr, ecode, offset_top, md, 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 2488 
 for (;;)
+Line 2667 
 for (;;)
            }
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM21);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            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 2512 
 for (;;)
+Line 2691 
 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 2524 
 for (;;)
+Line 2703 
 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;
      /* Match a single character, caselessly */
-     case OP_CHARNC:
+     case OP_CHARI:
  #ifdef SUPPORT_UTF8
      if (utf8)
        {
-Line 2544 
 for (;;)
+Line 2723 
 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 2552 
 for (;;)
+Line 2731 
 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 2571 
 for (;;)
+Line 2750 
 for (;;)
  #ifdef SUPPORT_UCP
            if (dc != UCD_OTHERCASE(fc))
  #endif
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          }
        }
-Line 2583 
 for (;;)
+Line 2762 
 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 2593 
 for (;;)
+Line 2772 
 for (;;)
      /* Match a single character repeatedly. */
      case OP_EXACT:
+     case OP_EXACTI:
      min = max = GET2(ecode, 1);
      ecode += 3;
      goto REPEATCHAR;
      case OP_POSUPTO:
+     case OP_POSUPTOI:
      possessive = TRUE;
      /* Fall through */
      case OP_UPTO:
+     case OP_UPTOI:
      case OP_MINUPTO:
+     case OP_MINUPTOI:
      min = 0;
      max = GET2(ecode, 1);
-     minimize = *ecode == OP_MINUPTO;
+     minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
      ecode += 3;
      goto REPEATCHAR;
      case OP_POSSTAR:
+     case OP_POSSTARI:
      possessive = TRUE;
      min = 0;
      max = INT_MAX;
-Line 2617 
 for (;;)
+Line 2801 
 for (;;)
      goto REPEATCHAR;
      case OP_POSPLUS:
+     case OP_POSPLUSI:
      possessive = TRUE;
      min = 1;
      max = INT_MAX;
-Line 2624 
 for (;;)
+Line 2809 
 for (;;)
      goto REPEATCHAR;
      case OP_POSQUERY:
+     case OP_POSQUERYI:
      possessive = TRUE;
      min = 0;
      max = 1;
-Line 2631 
 for (;;)
+Line 2817 
 for (;;)
      goto REPEATCHAR;
      case OP_STAR:
+     case OP_STARI:
      case OP_MINSTAR:
+     case OP_MINSTARI:
      case OP_PLUS:
+     case OP_PLUSI:
      case OP_MINPLUS:
+     case OP_MINPLUSI:
      case OP_QUERY:
+     case OP_QUERYI:
      case OP_MINQUERY:
-     c = *ecode++ - OP_STAR;
+     case OP_MINQUERYI:
+     c = *ecode++ - ((op < OP_STARI)? OP_STAR : OP_STARI);
      minimize = (c & 1) != 0;
      min = rep_min[c];                 /* Pick up values from tables; */
      max = rep_max[c];                 /* zero for max => infinity */
      if (max == 0) max = INT_MAX;
-Line 2661 
 for (;;)
+Line 2852 
 for (;;)
          {
  #ifdef SUPPORT_UCP
          unsigned int othercase;
-         if ((ims & PCRE_CASELESS) != 0 &&
+         if (op >= OP_STARI &&     /* Caseless */
              (othercase = UCD_OTHERCASE(fc)) != fc)
            oclength = _pcre_ord2utf8(othercase, occhars);
          else oclength = 0;
-Line 2679 
 for (;;)
+Line 2870 
 for (;;)
            else
              {
              CHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
-Line 2689 
 for (;;)
+Line 2880 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
+             RMATCH(eptr, ecode, offset_top, md, 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 2702 
 for (;;)
+Line 2893 
 for (;;)
              else
                {
                CHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              }
            /* Control never gets here */
-Line 2731 
 for (;;)
+Line 2922 
 for (;;)
            for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
+             RMATCH(eptr, ecode, offset_top, md, 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 2768 
 for (;;)
+Line 2959 
 for (;;)
      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
        max, eptr));
-     if ((ims & PCRE_CASELESS) != 0)
+     if (op >= OP_STARI)  /* Caseless */
        {
        fc = md->lcc[fc];
        for (i = 1; i <= min; i++)
-Line 2776 
 for (;;)
+Line 2967 
 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)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
+           RMATCH(eptr, ecode, offset_top, md, 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 2815 
 for (;;)
+Line 3006 
 for (;;)
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM25);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2833 
 for (;;)
+Line 3024 
 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 2844 
 for (;;)
+Line 3035 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
+           RMATCH(eptr, ecode, offset_top, md, 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 2873 
 for (;;)
+Line 3064 
 for (;;)
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM27);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2886 
 for (;;)
+Line 3077 
 for (;;)
      checking can be multibyte. */
      case OP_NOT:
+     case OP_NOTI:
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      GETCHARINCTEST(c, eptr);
-     if ((ims & PCRE_CASELESS) != 0)
+     if (op == OP_NOTI)         /* The caseless case */
        {
  #ifdef SUPPORT_UTF8
        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
+     else    /* Caseful */
        {
-       if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
+       if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
        }
      break;
-Line 2915 
 for (;;)
+Line 3107 
 for (;;)
      about... */
      case OP_NOTEXACT:
+     case OP_NOTEXACTI:
      min = max = GET2(ecode, 1);
      ecode += 3;
      goto REPEATNOTCHAR;
      case OP_NOTUPTO:
+     case OP_NOTUPTOI:
      case OP_NOTMINUPTO:
+     case OP_NOTMINUPTOI:
      min = 0;
      max = GET2(ecode, 1);
-     minimize = *ecode == OP_NOTMINUPTO;
+     minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
      ecode += 3;
      goto REPEATNOTCHAR;
      case OP_NOTPOSSTAR:
+     case OP_NOTPOSSTARI:
      possessive = TRUE;
      min = 0;
      max = INT_MAX;
-Line 2935 
 for (;;)
+Line 3131 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTPOSPLUS:
+     case OP_NOTPOSPLUSI:
      possessive = TRUE;
      min = 1;
      max = INT_MAX;
-Line 2942 
 for (;;)
+Line 3139 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTPOSQUERY:
+     case OP_NOTPOSQUERYI:
      possessive = TRUE;
      min = 0;
      max = 1;
-Line 2949 
 for (;;)
+Line 3147 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTPOSUPTO:
+     case OP_NOTPOSUPTOI:
      possessive = TRUE;
      min = 0;
      max = GET2(ecode, 1);
-Line 2956 
 for (;;)
+Line 3155 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTSTAR:
+     case OP_NOTSTARI:
      case OP_NOTMINSTAR:
+     case OP_NOTMINSTARI:
      case OP_NOTPLUS:
+     case OP_NOTPLUSI:
      case OP_NOTMINPLUS:
+     case OP_NOTMINPLUSI:
      case OP_NOTQUERY:
+     case OP_NOTQUERYI:
      case OP_NOTMINQUERY:
-     c = *ecode++ - OP_NOTSTAR;
+     case OP_NOTMINQUERYI:
+     c = *ecode++ - ((op >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
      minimize = (c & 1) != 0;
      min = rep_min[c];                 /* Pick up values from tables; */
      max = rep_max[c];                 /* zero for max => infinity */
-Line 2983 
 for (;;)
+Line 3188 
 for (;;)
      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
        max, eptr));
-     if ((ims & PCRE_CASELESS) != 0)
+     if (op >= OP_NOTSTARI)     /* Caseless */
        {
        fc = md->lcc[fc];
-Line 2997 
 for (;;)
+Line 3202 
 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 3014 
 for (;;)
+Line 3219 
 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 3031 
 for (;;)
+Line 3236 
 for (;;)
            register unsigned int d;
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
+             RMATCH(eptr, ecode, offset_top, md, 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 3050 
 for (;;)
+Line 3255 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
+             RMATCH(eptr, ecode, offset_top, md, 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 3091 
 for (;;)
+Line 3296 
 for (;;)
          if (possessive) continue;
          for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM30);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 3114 
 for (;;)
+Line 3319 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM31);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3139 
 for (;;)
+Line 3344 
 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 3154 
 for (;;)
+Line 3359 
 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 3171 
 for (;;)
+Line 3376 
 for (;;)
            register unsigned int d;
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
+             RMATCH(eptr, ecode, offset_top, md, 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 3189 
 for (;;)
+Line 3394 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
+             RMATCH(eptr, ecode, offset_top, md, 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 3229 
 for (;;)
+Line 3434 
 for (;;)
            if (possessive) continue;
            for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM34);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 3252 
 for (;;)
+Line 3457 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM35);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3352 
 for (;;)
+Line 3557 
 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 3370 
 for (;;)
+Line 3575 
 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 3387 
 for (;;)
+Line 3592 
 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 3402 
 for (;;)
+Line 3607 
 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 3417 
 for (;;)
+Line 3622 
 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 3441 
 for (;;)
+Line 3715 
 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 3472 
 for (;;)
+Line 3746 
 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 3486 
 for (;;)
+Line 3760 
 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 3494 
 for (;;)
+Line 3768 
 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 3504 
 for (;;)
+Line 3778 
 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 3522 
 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 3534 
 for (;;)
+Line 3809 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3559 
 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 3570 
 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 3606 
 for (;;)
+Line 3881 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3619 
 for (;;)
+Line 3894 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3630 
 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 3654 
 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 3668 
 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 3682 
 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 3696 
 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 3710 
 for (;;)
+Line 3985 
 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);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 3724 
 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 3750 
 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 3761 
 for (;;)
+Line 4036 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 3770 
 for (;;)
+Line 4045 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 3781 
 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;
              case 0x000a:
              break;
              case 0x000b:
              case 0x000c:
              case 0x0085:
-             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
              break;
              }
            }
-Line 3807 
 for (;;)
+Line 4084 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 3815 
 for (;;)
+Line 4092 
 for (;;)
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3826 
 for (;;)
+Line 4103 
 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 3845 
 for (;;)
+Line 4122 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 3855 
 for (;;)
+Line 4132 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3866 
 for (;;)
+Line 4143 
 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 3887 
 for (;;)
+Line 4164 
 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 3899 
 for (;;)
+Line 4176 
 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 3911 
 for (;;)
+Line 4188 
 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 3923 
 for (;;)
+Line 4200 
 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 3935 
 for (;;)
+Line 4212 
 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 3948 
 for (;;)
+Line 4225 
 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 3978 
 for (;;)
+Line 4255 
 for (;;)
            case PT_ANY:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
+             RMATCH(eptr, ecode, offset_top, md, 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 */
            case PT_LAMP:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
+             RMATCH(eptr, ecode, offset_top, md, 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 */
            case PT_GC:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
+             RMATCH(eptr, ecode, offset_top, md, 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 */
            case PT_PC:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
+             RMATCH(eptr, ecode, offset_top, md, 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 */
            case PT_SC:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
+             RMATCH(eptr, ecode, offset_top, md, 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, 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, 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, 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, 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 4077 
 for (;;)
+Line 4436 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
+           RMATCH(eptr, ecode, offset_top, md, 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 4109 
 for (;;)
+Line 4468 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
+           RMATCH(eptr, ecode, offset_top, md, 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 4130 
 for (;;)
+Line 4489 
 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 4142 
 for (;;)
+Line 4501 
 for (;;)
                case 0x0085:
                case 0x2028:
                case 0x2029:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 4170 
 for (;;)
+Line 4529 
 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 4212 
 for (;;)
+Line 4571 
 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 4233 
 for (;;)
+Line 4592 
 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 4272 
 for (;;)
+Line 4631 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
+           RMATCH(eptr, ecode, offset_top, md, 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 4293 
 for (;;)
+Line 4652 
 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 4304 
 for (;;)
+Line 4663 
 for (;;)
                case 0x000b:
                case 0x000c:
                case 0x0085:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }
              break;
-Line 4316 
 for (;;)
+Line 4675 
 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 4340 
 for (;;)
+Line 4699 
 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 4358 
 for (;;)
+Line 4717 
 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 4411 
 for (;;)
+Line 4770 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             GETCHARLEN(c, eptr, len);
+             GETCHARLENTEST(c, eptr, len);
              if (prop_fail_result) break;
              eptr+= len;
              }
-Line 4426 
 for (;;)
+Line 4785 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             GETCHARLEN(c, eptr, len);
+             GETCHARLENTEST(c, eptr, len);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
-Line 4445 
 for (;;)
+Line 4804 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             GETCHARLEN(c, eptr, len);
+             GETCHARLENTEST(c, eptr, len);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
                break;
-Line 4462 
 for (;;)
+Line 4821 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             GETCHARLEN(c, eptr, len);
+             GETCHARLENTEST(c, eptr, len);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
                break;
-Line 4479 
 for (;;)
+Line 4838 
 for (;;)
                SCHECK_PARTIAL();
                break;
                }
-             GETCHARLEN(c, eptr, len);
+             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 4493 
 for (;;)
+Line 4929 
 for (;;)
          if (possessive) continue;
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM44);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            if (utf8) BACKCHAR(eptr);
-Line 4534 
 for (;;)
+Line 4970 
 for (;;)
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM45);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            for (;;)                        /* Move back over one extended */
-Line 4818 
 for (;;)
+Line 5254 
 for (;;)
            RRETURN(PCRE_ERROR_INTERNAL);
            }