/[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 615 by ph10,
Mon Jul 11 14:23:06 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 57 
 possible. There are also some static sup
  #undef min
  #undef max
- /* Flag bits for the match() function */
+ /* Values for setting in md->match_function_type to indicate two special types
+ of call to match(). We do it this way to save on using another stack variable,
+ as stack usage is to be discouraged. */
- #define match_condassert     0x01  /* Called to check a condition assertion */
+ #define MATCH_CONDASSERT     1  /* Called to check a condition assertion */
- #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
+ #define MATCH_CBEGROUP       2  /* Could-be-empty unlimited repeat group */
  /* Non-error returns from the match() function. Error returns are externally
  defined PCRE_ERROR_xxx codes, which are all negative. */
-Line 71 
 defined PCRE_ERROR_xxx codes, which are
+Line 73 
 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_KETRPOS      (-997)
- #define MATCH_THEN         (-996)
+ #define MATCH_PRUNE        (-996)
+ #define MATCH_SKIP         (-995)
+ #define MATCH_SKIP_ARG     (-994)
+ #define MATCH_THEN         (-993)
+ /* 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 135 
 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 170 
 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 208 
 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 275 
 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, RM63};
  /* 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 286 
 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,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,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 267 
 actually used in this definition. */
+Line 298 
 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,rw) \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
-Line 281 
 argument of match(), which never changes
+Line 312 
 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,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 = rg;\
    newframe->Xrdepth = frame->Xrdepth + 1;\
    newframe->Xprevframe = frame;\
    frame = newframe;\
-Line 304 
 argument of match(), which never changes
+Line 334 
 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 358 
 typedef struct heapframe {
    USPTR Xmstart;
    USPTR Xmarkptr;
    int Xoffset_top;
-   long int Xims;
    eptrblock *Xeptrb;
-   int Xflags;
    unsigned int Xrdepth;
    /* Function local variables */
-Line 351 
 typedef struct heapframe {
+Line 379 
 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 436 
 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 464 
 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
-                  match_condassert - this is an assertion condition
-                  match_cbegroup - this is the start of an unlimited repeat
-                    group that can match an empty string
     rdepth      the recursion depth
  Returns:       MATCH_MATCH if matched            )  these values are >= 0
                 MATCH_NOMATCH if failed to match  )
+                a negative MATCH_xxx value for PRUNE, SKIP, etc
                 a negative PCRE_ERROR_xxx value if aborted by an error condition
                   (e.g. stopped by repeated call or recursion limit)
  */
  static int
- match(REGISTER USPTR eptr, REGISTER const uschar *ecode, 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)
+   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 490 
 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 499 
 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 510 
 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;
  /* This is where control jumps back to to effect "recursion" */
-Line 501 
 HEAP_RECURSE:
+Line 524 
 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
  /* Ditto for the local variables */
-Line 525 
 HEAP_RECURSE:
+Line 546 
 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 563 
 i, and fc and c, can be the same variabl
+Line 582 
 i, and fc and c, can be the same variabl
  #define fi i
  #define fc c
+ /* Many of the following variables are used only in small blocks of the code.
- #ifdef SUPPORT_UTF8                /* Many of these variables are used only  */
+ My normal style of coding would have declared them within each of those blocks.
- const uschar *charptr;             /* in small blocks of the code. My normal */
+ However, in order to accommodate the version of this code that uses an external
- #endif                             /* style of coding would have declared    */
+ "stack" implemented on the heap, it is easier to declare them all here, so the
- const uschar *callpat;             /* them within each of those blocks.      */
+ declarations can be cut out in a block. The only declarations within blocks
- const uschar *data;                /* However, in order to accommodate the   */
+ below are for variables that do not have to be preserved over a recursive call
- const uschar *next;                /* version of this code that uses an      */
+ to RMATCH(). */
- USPTR         pp;                  /* external "stack" implemented on the    */
- const uschar *prev;                /* heap, it is easier to declare them all */
+ #ifdef SUPPORT_UTF8
- USPTR         saved_eptr;          /* here, so the declarations can be cut   */
+ const uschar *charptr;
-                                    /* out in a block. The only declarations  */
+ #endif
- recursion_info new_recursive;      /* within blocks below are for variables  */
+ const uschar *callpat;
-                                    /* that do not have to be preserved over  */
+ const uschar *data;
- BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
+ const uschar *next;
+ USPTR         pp;
+ const uschar *prev;
+ USPTR         saved_eptr;
+ recursion_info new_recursive;
+ BOOL cur_is_word;
  BOOL condition;
  BOOL prev_is_word;
- unsigned long int original_ims;
  #ifdef SUPPORT_UCP
  int prop_type;
  int prop_value;
-Line 608 
 int stacksave[REC_STACK_SAVE_MAX];
+Line 632 
 int stacksave[REC_STACK_SAVE_MAX];
  eptrblock newptrb;
  #endif     /* NO_RECURSE */
+ /* To save space on the stack and in the heap frame, I have doubled up on some
+ of the local variables that are used only in localised parts of the code, but
+ still need to be preserved over recursive calls of match(). These macros define
+ the alternative names that are used. */
+ #define allow_zero    cur_is_word
+ #define cbegroup      condition
+ #define code_offset   codelink
+ #define condassert    condition
+ #define matched_once  prev_is_word
  /* These statements are here to stop the compiler complaining about unitialized
  variables. */
-Line 644 
 haven't exceeded the recursive call limi
+Line 679 
 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
+ string, the variable md->match_function_type is set to MATCH_CBEGROUP. It is
- subject pointer to the chain of such remembered pointers, to be checked when we
+ done this way to save having to use another function argument, which would take
- hit the closing ket, in order to break infinite loops that match no characters.
+ up space on the stack. See also MATCH_CONDASSERT below.
- When match() is called in other circumstances, don't add to the chain. The
- match_cbegroup flag must NOT be used with tail recursion, because the memory
+ When MATCH_CBEGROUP is set, add the current subject pointer to the chain of
- block that is used is on the stack, so a new one may be required for each
+ such remembered pointers, to be checked when we hit the closing ket, in order
- match(). */
+ to break infinite loops that match no characters. When match() is called in
+ other circumstances, don't add to the chain. The MATCH_CBEGROUP feature must
+ NOT be used with tail recursion, because the memory block that is used is on
+ the stack, so a new one may be required for each match(). */
- if ((flags & match_cbegroup) != 0)
+ if (md->match_function_type == MATCH_CBEGROUP)
    {
    newptrb.epb_saved_eptr = eptr;
    newptrb.epb_prev = eptrb;
    eptrb = &newptrb;
+   md->match_function_type = 0;
    }
  /* Now start processing the opcodes. */
-Line 668 
 for (;;)
+Line 705 
 for (;;)
    {
    minimize = possessive = FALSE;
    op = *ecode;
    switch(op)
      {
+     case OP_MARK:
+     markptr = ecode + 2;
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
+       eptrb, 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, 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, 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, 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, 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, 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, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     RRETURN(MATCH_THEN);
+     md->start_match_ptr = ecode - GET(ecode, 1);
+     MRRETURN(MATCH_THEN);
-     /* Handle a capturing bracket. If there is space in the offset vector, save
+     case OP_THEN_ARG:
-     the current subject position in the working slot at the top of the vector.
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
-     We mustn't change the current values of the data slot, because they may be
+       offset_top, md, eptrb, RM58);
-     set from a previous iteration of this group, and be referred to by a
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     reference inside the group.
+     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->mark = ecode + LINK_SIZE + 2;
+     RRETURN(MATCH_THEN);
-     If the bracket fails to match, we need to restore this value and also the
+     /* Handle a capturing bracket, other than those that are possessive with an
+     unlimited repeat. If there is space in the offset vector, save the current
+     subject position in the working slot at the top of the vector. We mustn't
+     change the current values of the data slot, because they may be set from a
+     previous iteration of this group, and be referred to by a reference inside
+     the group. If we fail to match, we need to restore this value and also the
      values of the final offsets, in case they were set by a previous iteration
      of the same bracket.
-Line 717 
 for (;;)
+Line 820 
 for (;;)
      case OP_SCBRA:
      number = GET2(ecode, 1+LINK_SIZE);
      offset = number << 1;
  #ifdef PCRE_DEBUG
      printf("start bracket %d\n", number);
      printf("subject=");
-Line 733 
 for (;;)
+Line 836 
 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;
+       for (;;)
-       do
          {
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
-           ims, eptrb, flags, RM1);
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-         if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+           eptrb, RM1);
+         if (rrc != MATCH_NOMATCH &&
+             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+           RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
+         if (*ecode != OP_ALT) break;
          }
-       while (*ecode == OP_ALT);
        DPRINTF(("bracket %d failed\n", number));
-Line 752 
 for (;;)
+Line 858 
 for (;;)
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
+       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
        RRETURN(MATCH_NOMATCH);
        }
-Line 766 
 for (;;)
+Line 873 
 for (;;)
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
-     /* Non-capturing bracket. Loop for all the alternatives. When we get to the
+     /* Non-capturing bracket, except for possessive with unlimited repeat. Loop
-     final alternative within the brackets, we would return the result of a
+     for all the alternatives. When we get to the final alternative within the
-     recursive call to match() whatever happened. We can reduce stack usage by
+     brackets, we used to return the result of a recursive call to match()
-     turning this into a tail recursion, except in the case when match_cbegroup
+     whatever happened so it was possible to reduce stack usage by turning this
-     is set.*/
+     into a tail recursion, except in the case of a possibly empty group.
+     However, now that there is the possiblity of (*THEN) occurring in the final
+     alternative, this optimization is no longer possible. */
      case OP_BRA:
      case OP_SBRA:
      DPRINTF(("start non-capturing bracket\n"));
-     flags = (op >= OP_SBRA)? match_cbegroup : 0;
      for (;;)
        {
-       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
+       if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
-         {
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
-         if (flags == 0)    /* Not a possibly empty group */
+         RM2);
-           {
+       if (rrc != MATCH_NOMATCH &&
-           ecode += _pcre_OP_lengths[*ecode];
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
-           DPRINTF(("bracket 0 tail recursion\n"));
+         RRETURN(rrc);
-           goto TAIL_RECURSE;
+       ecode += GET(ecode, 1);
-           }
+       if (*ecode != OP_ALT) break;
+       }
-         /* Possibly empty group; can't use tail recursion. */
+     if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
+     RRETURN(MATCH_NOMATCH);
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+     /* Handle possessive capturing brackets with an unlimited repeat. We come
-           eptrb, flags, RM48);
+     here from BRAZERO with allow_zero set TRUE. The offset_vector values are
-         RRETURN(rrc);
+     handled similarly to the normal case above. However, the matching is
+     different. The end of these brackets will always be OP_KETRPOS, which
+     returns MATCH_KETRPOS without going further in the pattern. By this means
+     we can handle the group by iteration rather than recursion, thereby
+     reducing the amount of stack needed. */
+     case OP_CBRAPOS:
+     case OP_SCBRAPOS:
+     allow_zero = FALSE;
+     POSSESSIVE_CAPTURE:
+     number = GET2(ecode, 1+LINK_SIZE);
+     offset = number << 1;
+ #ifdef PCRE_DEBUG
+     printf("start possessive bracket %d\n", number);
+     printf("subject=");
+     pchars(eptr, 16, TRUE, md);
+     printf("\n");
+ #endif
+     if (offset < md->offset_max)
+       {
+       matched_once = FALSE;
+       code_offset = ecode - md->start_code;
+       save_offset1 = md->offset_vector[offset];
+       save_offset2 = md->offset_vector[offset+1];
+       save_offset3 = md->offset_vector[md->offset_end - number];
+       save_capture_last = md->capture_last;
+       DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
+       /* Each time round the loop, save the current subject position for use
+       when the group matches. For MATCH_MATCH, the group has matched, so we
+       restart it with a new subject starting position, remembering that we had
+       at least one match. For MATCH_NOMATCH, carry on with the alternatives, as
+       usual. If we haven't matched any alternatives in any iteration, check to
+       see if a previous iteration matched. If so, the group has matched;
+       continue from afterwards. Otherwise it has failed; restore the previous
+       capture values before returning NOMATCH. */
+       for (;;)
+         {
+         md->offset_vector[md->offset_end - number] =
+           (int)(eptr - md->start_subject);
+         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+           eptrb, RM63);
+         if (rrc == MATCH_KETRPOS)
+           {
+           offset_top = md->end_offset_top;
+           eptr = md->end_match_ptr;
+           ecode = md->start_code + code_offset;
+           save_capture_last = md->capture_last;
+           matched_once = TRUE;
+           continue;
+           }
+         if (rrc != MATCH_NOMATCH &&
+             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+           RRETURN(rrc);
+         md->capture_last = save_capture_last;
+         ecode += GET(ecode, 1);
+         if (*ecode != OP_ALT) break;
          }
-       /* For non-final alternatives, continue the loop for a NOMATCH result;
+       if (!matched_once)
-       otherwise return. */
+         {
+         md->offset_vector[offset] = save_offset1;
+         md->offset_vector[offset+1] = save_offset2;
+         md->offset_vector[md->offset_end - number] = save_offset3;
+         }
+       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
+       if (allow_zero || matched_once)
+         {
+         ecode += 1 + LINK_SIZE;
+         break;
+         }
+       RRETURN(MATCH_NOMATCH);
+       }
+     /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
+     as a non-capturing bracket. */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
-       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+     /* Non-capturing possessive bracket with unlimited repeat. We come here
-         eptrb, flags, RM2);
+     from BRAZERO with allow_zero = TRUE. The code is similar to the above,
-       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
+     without the capturing complication. It is written out separately for speed
+     and cleanliness. */
+     case OP_BRAPOS:
+     case OP_SBRAPOS:
+     allow_zero = FALSE;
+     POSSESSIVE_NON_CAPTURE:
+     matched_once = FALSE;
+     code_offset = ecode - md->start_code;
+     for (;;)
+       {
+       if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         eptrb, RM48);
+       if (rrc == MATCH_KETRPOS)
+         {
+         offset_top = md->end_offset_top;
+         eptr = md->end_match_ptr;
+         ecode = md->start_code + code_offset;
+         matched_once = TRUE;
+         continue;
+         }
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         RRETURN(rrc);
        ecode += GET(ecode, 1);
+       if (*ecode != OP_ALT) break;
        }
+     if (matched_once || allow_zero)
+       {
+       ecode += 1 + LINK_SIZE;
+       break;
+       }
+     RRETURN(MATCH_NOMATCH);
      /* Control never reaches here. */
      /* Conditional group: compilation checked that there are no more than
      two branches. If the condition is false, skipping the first branch takes us
      past the end if there is only one branch, but that's OK because that is
-     exactly what going to the ket would do. As there is only one branch to be
+     exactly what going to the ket would do. */
-     obeyed, we can use tail recursion to avoid using another stack frame. */
      case OP_COND:
      case OP_SCOND:
-     codelink= GET(ecode, 1);
+     codelink = GET(ecode, 1);
      /* Because of the way auto-callout works during compile, a callout item is
      inserted between OP_COND and an assertion condition. */
-Line 826 
 for (;;)
+Line 1058 
 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 987 
 for (;;)
+Line 1219 
 for (;;)
        }
      /* The condition is an assertion. Call match() to evaluate it - setting
-     the final argument match_condassert causes it to stop at the end of an
+     md->match_function_type to MATCH_CONDASSERT causes it to stop at the end of
-     assertion. */
+     an assertion. */
      else
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       md->match_function_type = MATCH_CONDASSERT;
-           match_condassert, RM3);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM3);
        if (rrc == MATCH_MATCH)
          {
          condition = TRUE;
          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 1012 
 for (;;)
+Line 1245 
 for (;;)
        }
      /* We are now at the branch that is to be obeyed. As there is only one,
-     we can use tail recursion to avoid using another stack frame, except when
+     we used to use tail recursion to avoid using another stack frame, except
-     match_cbegroup is required for an unlimited repeat of a possibly empty
+     when there was unlimited repeat of a possibly empty group. However, that
-     group. If the second alternative doesn't exist, we can just plough on. */
+     strategy no longer works because of the possibilty of (*THEN) being
+     encountered in the branch. A recursive call to match() is always required,
+     unless the second alternative doesn't exist, in which case we can just
+     plough on. */
      if (condition || *ecode == OP_ALT)
        {
-       ecode += 1 + LINK_SIZE;
+       if (op == OP_SCOND) md->match_function_type = MATCH_CBEGROUP;
-       if (op == OP_SCOND)        /* Possibly empty group */
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
-         {
+       if (rrc == MATCH_THEN && md->start_match_ptr == ecode)
-         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
+         rrc = MATCH_NOMATCH;
-         RRETURN(rrc);
+       RRETURN(rrc);
-         }
-       else                       /* Group must match something */
-         {
-         flags = 0;
-         goto TAIL_RECURSE;
-         }
        }
      else                         /* Condition false & no alternative */
        {
-Line 1054 
 for (;;)
+Line 1284 
 for (;;)
        {
        md->offset_vector[offset] =
          md->offset_vector[md->offset_end - number];
-       md->offset_vector[offset+1] = eptr - md->start_subject;
+       md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
        if (offset_top <= offset) offset_top = offset + 2;
        }
      ecode += 3;
      break;
-     /* End of the pattern, either real or forced. If we are in a top-level
+     /* End of the pattern, either real or forced. If we are in a recursion, we
-     recursion, we should restore the offsets appropriately and continue from
+     should restore the offsets appropriately, and if it's a top-level
-     after the call. */
+     recursion, continue from after the call. */
      case OP_ACCEPT:
+     case OP_ASSERT_ACCEPT:
      case OP_END:
-     if (md->recursive != NULL && md->recursive->group_num == 0)
+     if (md->recursive != NULL)
        {
        recursion_info *rec = md->recursive;
-       DPRINTF(("End of pattern in a (?0) recursion\n"));
        md->recursive = rec->prevrec;
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
        offset_top = rec->save_offset_top;
-       ims = original_ims;
+       if (rec->group_num == 0)
-       ecode = rec->after_call;
+         {
-       break;
+         ecode = rec->after_call;
+         break;
+         }
        }
-     /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
+     /* Otherwise, if we have matched an empty string, fail if not in an
-     set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
+     assertion and if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
-     the subject. In both cases, backtracking will then try other alternatives,
+     is set and we have matched at the start of the subject. In both cases,
-     if any. */
+     backtracking will then try other alternatives, if any. */
-     if (eptr == mstart &&
+     else if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
          (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,
      the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
      start of each branch to move the current point backwards, so the code at
-     this level is identical to the lookahead case. */
+     this level is identical to the lookahead case. When the assertion is part
+     of a condition, we want to return immediately afterwards. The caller of
+     this incarnation of the match() function will have set MATCH_CONDASSERT in
+     md->match_function type, and one of these opcodes will be the first opcode
+     that is processed. We use a local variable that is preserved over calls to
+     match() to remember this case. */
      case OP_ASSERT:
      case OP_ASSERTBACK:
+     if (md->match_function_type == MATCH_CONDASSERT)
+       {
+       condassert = TRUE;
+       md->match_function_type = 0;
+       }
+     else condassert = FALSE;
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
-         RM4);
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
-       if (rrc == MATCH_MATCH)
          {
          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. */
-     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
+     if (condassert) RRETURN(MATCH_MATCH);
      /* Continue from after the assertion, updating the offsets high water
      mark, since extracts may have been taken during the assertion. */
-Line 1147 
 for (;;)
+Line 1390 
 for (;;)
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK_NOT:
+     if (md->match_function_type == MATCH_CONDASSERT)
+       {
+       condassert = TRUE;
+       md->match_function_type = 0;
+       }
+     else condassert = FALSE;
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
-         RM5);
+       if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
-       if (rrc == MATCH_MATCH) RRETURN(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);
-     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
+     if (condassert) RRETURN(MATCH_MATCH);  /* Condition assertion */
      ecode += 1 + LINK_SIZE;
      continue;
-Line 1180 
 for (;;)
+Line 1431 
 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 1442 
 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 1463 
 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 1276 
 for (;;)
+Line 1527 
 for (;;)
        memcpy(new_recursive.offset_save, md->offset_vector,
              new_recursive.saved_max * sizeof(int));
        new_recursive.save_offset_top = offset_top;
        /* OK, now we can do the recursion. For each top-level alternative we
        restore the offset and recursion data. */
        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
-       flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
+       cbegroup = (*callpat >= OP_SBRA);
        do
          {
+         if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
-           md, ims, eptrb, flags, RM6);
+           md, eptrb, 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 1566 
 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 1584 
 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, 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 1346 
 for (;;)
+Line 1601 
 for (;;)
      if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
-     /* Continue as from after the assertion, updating the offsets high water
+     /* Continue after the group, updating the offsets high water mark, since
-     mark, since extracts may have been taken. */
+     extracts may have been taken. */
      do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
-Line 1368 
 for (;;)
+Line 1623 
 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, RM8);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode = prev;
-       flags = 0;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
+       md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, prev, offset_top, md, eptrb, RM9);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = 0;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1408 
 for (;;)
+Line 1654 
 for (;;)
      at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
      with fixed upper repeat limits are compiled as a number of copies, with the
      optional ones preceded by BRAZERO or BRAMINZERO. */
      case OP_BRAZERO:
-       {
+     next = ecode + 1;
-       next = ecode+1;
+     RMATCH(eptr, next, offset_top, md, eptrb, RM10);
-       RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     do next += GET(next, 1); while (*next == OP_ALT);
-       do next += GET(next,1); while (*next == OP_ALT);
+     ecode = next + 1 + LINK_SIZE;
-       ecode = next + 1 + LINK_SIZE;
-       }
      break;
      case OP_BRAMINZERO:
-       {
+     next = ecode + 1;
-       next = ecode+1;
+     do next += GET(next, 1); while (*next == OP_ALT);
-       do next += GET(next, 1); while (*next == OP_ALT);
+     RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
-       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0, RM11);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     ecode++;
-       ecode++;
-       }
      break;
      case OP_SKIPZERO:
-       {
+     next = ecode+1;
-       next = ecode+1;
+     do next += GET(next,1); while (*next == OP_ALT);
-       do next += GET(next,1); while (*next == OP_ALT);
+     ecode = next + 1 + LINK_SIZE;
-       ecode = next + 1 + LINK_SIZE;
-       }
      break;
+     /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
+     here; just jump to the group, with allow_zero set TRUE. */
+     case OP_BRAPOSZERO:
+     op = *(++ecode);
+     allow_zero = TRUE;
+     if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
+       goto POSSESSIVE_NON_CAPTURE;
      /* End of a group, repeated or non-repeating. */
      case OP_KET:
      case OP_KETRMIN:
      case OP_KETRMAX:
+     case OP_KETRPOS:
      prev = ecode - GET(ecode, 1);
      /* If this was a group that remembered the subject start, in order to break
-Line 1467 
 for (;;)
+Line 1717 
 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 1476 
 for (;;)
+Line 1726 
 for (;;)
      a recurse into group 0, so it won't be picked up here. Instead, we catch it
      when the OP_END is reached. Other recursion is handled here. */
-     if (*prev == OP_CBRA || *prev == OP_SCBRA)
+     if (*prev == OP_CBRA || *prev == OP_SCBRA ||
+         *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
        {
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
-Line 1489 
 for (;;)
+Line 1740 
 for (;;)
        md->capture_last = number;
        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
          {
+         /* If offset is greater than offset_top, it means that we are
+         "skipping" a capturing group, and that group's offsets must be marked
+         unset. In earlier versions of PCRE, all the offsets were unset at the
+         start of matching, but this doesn't work because atomic groups and
+         assertions can cause a value to be set that should later be unset.
+         Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
+         part of the atomic group, but this is not on the final matching path,
+         so must be unset when 2 is set. (If there is no group 2, there is no
+         problem, because offset_top will then be 2, indicating no capture.) */
+         if (offset > offset_top)
+           {
+           register int *iptr = md->offset_vector + offset_top;
+           register int *iend = md->offset_vector + offset;
+           while (iptr < iend) *iptr++ = -1;
+           }
+         /* Now make the extraction */
          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 1777 
 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 1529 
 for (;;)
+Line 1792 
 for (;;)
        ecode += 1 + LINK_SIZE;
        break;
        }
-     /* The repeating kets try the rest of the pattern or restart from the
+     /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
-     preceding bracket, in the appropriate order. In the second case, we can use
+     and return the MATCH_KETRPOS. This makes it possible to do the repeats one
-     tail recursion to avoid using another stack frame, unless we have an
+     at a time from the outer level, thus saving stack. */
+     if (*ecode == OP_KETRPOS)
+       {
+       md->end_match_ptr = eptr;
+       md->end_offset_top = offset_top;
+       RRETURN(MATCH_KETRPOS);
+       }
+     /* The normal repeating kets try the rest of the pattern or restart from
+     the preceding bracket, in the appropriate order. In the second case, we can
+     use tail recursion to avoid using another stack frame, unless we have an
      unlimited repeat of a group that can match an empty string. */
-     flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       if (flags != 0)    /* Could match an empty string */
+       if (*prev >= OP_SBRA)    /* Could match an empty string */
          {
-         RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
+         md->match_function_type = MATCH_CBEGROUP;
+         RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
          RRETURN(rrc);
          }
        ecode = prev;
-Line 1551 
 for (;;)
+Line 1824 
 for (;;)
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
+       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = 0;
        goto TAIL_RECURSE;
        }
      /* 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 1868 
 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 1927 
 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 1959 
 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 2054 
 for (;;)
      if (eptr++ >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1729 
 for (;;)
+Line 2063 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1738 
 for (;;)
+Line 2072 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1746 
 for (;;)
+Line 2080 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1755 
 for (;;)
+Line 2089 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_digit) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1763 
 for (;;)
+Line 2097 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1772 
 for (;;)
+Line 2106 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1780 
 for (;;)
+Line 2114 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1789 
 for (;;)
+Line 2123 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_space) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1797 
 for (;;)
+Line 2131 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1806 
 for (;;)
+Line 2140 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) != 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1814 
 for (;;)
+Line 2148 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      if (
-Line 1823 
 for (;;)
+Line 2157 
 for (;;)
  #endif
         (md->ctypes[c] & ctype_word) == 0
         )
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1831 
 for (;;)
+Line 2165 
 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 2184 
 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 2194 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 1884 
 for (;;)
+Line 2219 
 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 2228 
 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 2262 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
      switch(c)
-Line 1940 
 for (;;)
+Line 2275 
 for (;;)
        case 0x85:      /* NEL */
        case 0x2028:    /* LINE SEPARATOR */
        case 0x2029:    /* PARAGRAPH SEPARATOR */
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      ecode++;
      break;
-Line 1949 
 for (;;)
+Line 2284 
 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 2311 
 for (;;)
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-       RRETURN(MATCH_NOMATCH);
+       MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
        {
-Line 1985 
 for (;;)
+Line 2320 
 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 2392 
 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 2424 
 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_CRMINSTAR:
+       case OP_CRPLUS:
+       case OP_CRMINPLUS:
+       case OP_CRQUERY:
+       case OP_CRMINQUERY:
+       c = *ecode++ - OP_CRSTAR;
+       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;
+       break;
+       case OP_CRRANGE:
+       case OP_CRMINRANGE:
+       minimize = (*ecode == OP_CRMINRANGE);
+       min = GET2(ecode, 1);
+       max = GET2(ecode, 3);
+       if (max == 0) max = INT_MAX;
+       ecode += 5;
+       break;
+       default:               /* No repeat follows */
+       if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
          {
-         case OP_CRSTAR:
+         CHECK_PARTIAL();
-         case OP_CRMINSTAR:
+         MRRETURN(MATCH_NOMATCH);
-         case OP_CRPLUS:
+         }
-         case OP_CRMINPLUS:
+       eptr += length;
-         case OP_CRQUERY:
+       continue;              /* With the main loop */
-         case OP_CRMINQUERY:
+       }
-         c = *ecode++ - OP_CRSTAR;
-         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;
-         break;
-         case OP_CRRANGE:
+     /* Handle repeated back references. If the length of the reference is
-         case OP_CRMINRANGE:
+     zero, just continue with the main loop. */
-         minimize = (*ecode == OP_CRMINRANGE);
-         min = GET2(ecode, 1);
-         max = GET2(ecode, 3);
-         if (max == 0) max = INT_MAX;
-         ecode += 5;
-         break;
-         default:               /* No repeat follows */
+     if (length == 0) continue;
-         if (!match_ref(offset, eptr, length, md, ims))
-           {
+     /* First, ensure the minimum number of matches are present. We get back
-           CHECK_PARTIAL();
+     the length of the reference string explicitly rather than passing the
-           RRETURN(MATCH_NOMATCH);
+     address of eptr, so that eptr can be a register variable. */
-           }
-         eptr += length;
+     for (i = 1; i <= min; i++)
-         continue;              /* With the main loop */
+       {
+       int slength;
+       if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
+         {
+         CHECK_PARTIAL();
+         MRRETURN(MATCH_NOMATCH);
          }
+       eptr += slength;
+       }
-       /* If the length of the reference is zero, just continue with the
+     /* If min = max, continue at the same level without recursion.
-       main loop. */
+     They are not both allowed to be zero. */
-       if (length == 0) continue;
+     if (min == max) continue;
-       /* First, ensure the minimum number of matches are present. We get back
+     /* If minimizing, keep trying and advancing the pointer */
-       the length of the reference string explicitly rather than passing the
-       address of eptr, so that eptr can be a register variable. */
-       for (i = 1; i <= min; i++)
+     if (minimize)
+       {
+       for (fi = min;; fi++)
          {
-         if (!match_ref(offset, eptr, length, md, ims))
+         int slength;
+         RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         if (fi >= max) MRRETURN(MATCH_NOMATCH);
+         if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
            {
            CHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
-         eptr += length;
+         eptr += slength;
          }
+       /* Control never gets here */
+       }
-       /* If min = max, continue at the same level without recursion.
+     /* If maximizing, find the longest string and work backwards */
-       They are not both allowed to be zero. */
-       if (min == max) continue;
-       /* If minimizing, keep trying and advancing the pointer */
-       if (minimize)
+     else
+       {
+       pp = eptr;
+       for (i = min; i < max; i++)
          {
-         for (fi = min;; fi++)
+         int slength;
+         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);
+           break;
-           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;
          }
+       while (eptr >= pp)
-       /* If maximizing, find the longest string and work backwards */
-       else
          {
-         pp = eptr;
+         RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
-         for (i = min; i < max; i++)
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           {
+         eptr -= length;
-           if (!match_ref(offset, eptr, length, md, ims))
-             {
-             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);
          }
+       MRRETURN(MATCH_NOMATCH);
        }
      /* Control never gets here */
-Line 2240 
 for (;;)
+Line 2609 
 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 2631 
 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 2654 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 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 2679 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 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 2725 
 for (;;)
              }
            for (;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 2379 
 for (;;)
+Line 2748 
 for (;;)
              }
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2437 
 for (;;)
+Line 2806 
 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 2824 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 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 2857 
 for (;;)
            }
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 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 2881 
 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 2893 
 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 2913 
 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 2921 
 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 2940 
 for (;;)
  #ifdef SUPPORT_UCP
            if (dc != UCD_OTHERCASE(fc))
  #endif
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
            }
          }
        }
-Line 2583 
 for (;;)
+Line 2952 
 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 2962 
 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 2991 
 for (;;)
      goto REPEATCHAR;
      case OP_POSPLUS:
+     case OP_POSPLUSI:
      possessive = TRUE;
      min = 1;
      max = INT_MAX;
-Line 2624 
 for (;;)
+Line 2999 
 for (;;)
      goto REPEATCHAR;
      case OP_POSQUERY:
+     case OP_POSQUERYI:
      possessive = TRUE;
      min = 0;
      max = 1;
-Line 2631 
 for (;;)
+Line 3007 
 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 3042 
 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 3060 
 for (;;)
            else
              {
              CHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
-Line 2689 
 for (;;)
+Line 3070 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 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 3083 
 for (;;)
              else
                {
                CHECK_PARTIAL();
-               RRETURN(MATCH_NOMATCH);
+               MRRETURN(MATCH_NOMATCH);
                }
              }
            /* Control never gets here */
-Line 2731 
 for (;;)
+Line 3112 
 for (;;)
            for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 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 3149 
 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 3157 
 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, 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 3196 
 for (;;)
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 2833 
 for (;;)
+Line 3214 
 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 3225 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 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 3254 
 for (;;)
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 2886 
 for (;;)
+Line 3267 
 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 3297 
 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 3321 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTPOSPLUS:
+     case OP_NOTPOSPLUSI:
      possessive = TRUE;
      min = 1;
      max = INT_MAX;
-Line 2942 
 for (;;)
+Line 3329 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTPOSQUERY:
+     case OP_NOTPOSQUERYI:
      possessive = TRUE;
      min = 0;
      max = 1;
-Line 2949 
 for (;;)
+Line 3337 
 for (;;)
      goto REPEATNOTCHAR;
      case OP_NOTPOSUPTO:
+     case OP_NOTPOSUPTOI:
      possessive = TRUE;
      min = 0;
      max = GET2(ecode, 1);
-Line 2956 
 for (;;)
+Line 3345 
 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 3378 
 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 3392 
 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 3409 
 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 3426 
 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, 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 3445 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 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 3486 
 for (;;)
          if (possessive) continue;
          for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 3114 
 for (;;)
+Line 3509 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        /* Control never gets here */
        }
-Line 3139 
 for (;;)
+Line 3534 
 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 3549 
 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 3566 
 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, 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 3584 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, 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 3624 
 for (;;)
            if (possessive) continue;
            for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 3252 
 for (;;)
+Line 3647 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
            }
-         RRETURN(MATCH_NOMATCH);
+         MRRETURN(MATCH_NOMATCH);
          }
        }
      /* Control never gets here */
-Line 3352 
 for (;;)
+Line 3747 
 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 3765 
 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 3782 
 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 3797 
 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 3812 
 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 3905 
 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 3936 
 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 3950 
 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 3958 
 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 3968 
 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 3987 
 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 3999 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3559 
 for (;;)
+Line 4024 
 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 4035 
 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 4071 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINC(c, eptr);
            switch(c)
-Line 3619 
 for (;;)
+Line 4084 
 for (;;)
              case 0x85:      /* NEL */
              case 0x2028:    /* LINE SEPARATOR */
              case 0x2029:    /* PARAGRAPH SEPARATOR */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3630 
 for (;;)
+Line 4095 
 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 4119 
 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 4133 
 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 4147 
 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 4161 
 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 4175 
 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 4189 
 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 4215 
 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 4226 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 3770 
 for (;;)
+Line 4235 
 for (;;)
          if (eptr > md->end_subject - min)
            {
            SCHECK_PARTIAL();
-           RRETURN(MATCH_NOMATCH);
+           MRRETURN(MATCH_NOMATCH);
            }
          eptr += min;
          break;
-Line 3781 
 for (;;)
+Line 4246 
 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 4274 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 3815 
 for (;;)
+Line 4282 
 for (;;)
              case 0x09:      /* HT */
              case 0x20:      /* SPACE */
              case 0xa0:      /* NBSP */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3826 
 for (;;)
+Line 4293 
 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 4312 
 for (;;)
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            switch(*eptr++)
              {
-Line 3855 
 for (;;)
+Line 4322 
 for (;;)
              case 0x0c:      /* FF */
              case 0x0d:      /* CR */
              case 0x85:      /* NEL */
-             RRETURN(MATCH_NOMATCH);
+             MRRETURN(MATCH_NOMATCH);
              }
            }
          break;
-Line 3866 
 for (;;)
+Line 4333 
 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 4354 
 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 4366 
 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 4378 
 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 4390 
 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 4402 
 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 4415 
 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 4445 
 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 4626 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 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 4658 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, 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 4679 
 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 4691 
 for (;;)
                case 0x0085:
                case 0x2028:
                case 0x2029:
-               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
                break;
                }