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

Diff of /code/trunk/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 482 by ph10, Mon Jan 4 15:55:46 2010 UTC revision 518 by ph10, Tue May 18 15:47:01 2010 UTC
# Line 71  defined PCRE_ERROR_xxx codes, which are Line 71  defined PCRE_ERROR_xxx codes, which are
71  /* Special internal returns from the match() function. Make them sufficiently  /* Special internal returns from the match() function. Make them sufficiently
72  negative to avoid the external error codes. */  negative to avoid the external error codes. */
73    
74  #define MATCH_COMMIT       (-999)  #define MATCH_ACCEPT       (-999)
75  #define MATCH_PRUNE        (-998)  #define MATCH_COMMIT       (-998)
76  #define MATCH_SKIP         (-997)  #define MATCH_PRUNE        (-997)
77  #define MATCH_THEN         (-996)  #define MATCH_SKIP         (-996)
78    #define MATCH_SKIP_ARG     (-995)
79    #define MATCH_THEN         (-994)
80    
81    /* This is a convenience macro for code that occurs many times. */
82    
83    #define MRRETURN(ra) \
84      { \
85      md->mark = markptr; \
86      RRETURN(ra); \
87      }
88    
89  /* Maximum number of ints of offset to save on the stack for recursive calls.  /* Maximum number of ints of offset to save on the stack for recursive calls.
90  If the offset vector is bigger, malloc is used. This should be a multiple of 3,  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
# Line 245  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 255  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
255         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
256         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
257         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
258         RM51,  RM52, RM53, RM54 };         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58 };
259    
260  /* These versions of the macros use the stack, as normal. There are debugging  /* These versions of the macros use the stack, as normal. There are debugging
261  versions and production versions. Note that the "rw" argument of RMATCH isn't  versions and production versions. Note that the "rw" argument of RMATCH isn't
262  actuall used in this definition. */  actually used in this definition. */
263    
264  #ifndef NO_RECURSE  #ifndef NO_RECURSE
265  #define REGISTER register  #define REGISTER register
# Line 258  actuall used in this definition. */ Line 268  actuall used in this definition. */
268  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
269    { \    { \
270    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
271    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
272    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
273    }    }
274  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 268  actuall used in this definition. */ Line 278  actuall used in this definition. */
278    }    }
279  #else  #else
280  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
281    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
282  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
283  #endif  #endif
284    
# Line 288  argument of match(), which never changes Line 298  argument of match(), which never changes
298    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
299    newframe->Xecode = rb;\    newframe->Xecode = rb;\
300    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
301      newframe->Xmarkptr = markptr;\
302    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
303    newframe->Xims = re;\    newframe->Xims = re;\
304    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 325  typedef struct heapframe { Line 336  typedef struct heapframe {
336    USPTR Xeptr;    USPTR Xeptr;
337    const uschar *Xecode;    const uschar *Xecode;
338    USPTR Xmstart;    USPTR Xmstart;
339      USPTR Xmarkptr;
340    int Xoffset_top;    int Xoffset_top;
341    long int Xims;    long int Xims;
342    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 411  the subject. */ Line 423  the subject. */
423    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
424      {\      {\
425      md->hitend = TRUE;\      md->hitend = TRUE;\
426      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
427      }      }
428    
429  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
430    if (md->partial != 0 && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
431      {\      {\
432      md->hitend = TRUE;\      md->hitend = TRUE;\
433      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
434      }      }
435    
436    
# Line 432  Arguments: Line 444  Arguments:
444     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
445     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
446                   by encountering \K)                   by encountering \K)
447       markptr     pointer to the most recent MARK name, or NULL
448     offset_top  current top pointer     offset_top  current top pointer
449     md          pointer to "static" info for the match     md          pointer to "static" info for the match
450     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 445  Arguments: Line 458  Arguments:
458    
459  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
460                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
461                   a negative MATCH_xxx value for PRUNE, SKIP, etc
462                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
463                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
464  */  */
465    
466  static int  static int
467  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
468    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,    const uschar *markptr, int offset_top, match_data *md, unsigned long int ims,
469    int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
470  {  {
471  /* These variables do not need to be preserved over recursion in this function,  /* These variables do not need to be preserved over recursion in this function,
472  so they can be ordinary variables in all cases. Mark some of them with  so they can be ordinary variables in all cases. Mark some of them with
# Line 480  frame->Xprevframe = NULL;            /* Line 494  frame->Xprevframe = NULL;            /*
494  frame->Xeptr = eptr;  frame->Xeptr = eptr;
495  frame->Xecode = ecode;  frame->Xecode = ecode;
496  frame->Xmstart = mstart;  frame->Xmstart = mstart;
497    frame->Xmarkptr = markptr;
498  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
499  frame->Xims = ims;  frame->Xims = ims;
500  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 495  HEAP_RECURSE: Line 510  HEAP_RECURSE:
510  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
511  #define ecode              frame->Xecode  #define ecode              frame->Xecode
512  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
513    #define markptr            frame->Xmarkptr
514  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
515  #define ims                frame->Xims  #define ims                frame->Xims
516  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 666  for (;;) Line 682  for (;;)
682    
683    switch(op)    switch(op)
684      {      {
685        case OP_MARK:
686        markptr = ecode + 2;
687        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
688          ims, eptrb, flags, RM55);
689    
690        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
691        argument, and we must check whether that argument matches this MARK's
692        argument. It is passed back in md->start_match_ptr (an overloading of that
693        variable). If it does match, we reset that variable to the current subject
694        position and return MATCH_SKIP. Otherwise, pass back the return code
695        unaltered. */
696    
697        if (rrc == MATCH_SKIP_ARG &&
698            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
699          {
700          md->start_match_ptr = eptr;
701          RRETURN(MATCH_SKIP);
702          }
703    
704        if (md->mark == NULL) md->mark = markptr;
705        RRETURN(rrc);
706    
707      case OP_FAIL:      case OP_FAIL:
708      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
709    
710        case OP_COMMIT:
711        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
712          ims, eptrb, flags, RM52);
713        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
714        MRRETURN(MATCH_COMMIT);
715    
716      case OP_PRUNE:      case OP_PRUNE:
717      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
718        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
719      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
720      RRETURN(MATCH_PRUNE);      MRRETURN(MATCH_PRUNE);
721    
722      case OP_COMMIT:      case OP_PRUNE_ARG:
723      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
724        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM56);
725      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
726      RRETURN(MATCH_COMMIT);      md->mark = ecode + 2;
727        RRETURN(MATCH_PRUNE);
728    
729      case OP_SKIP:      case OP_SKIP:
730      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
731        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
732      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
733      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
734      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
735    
736        case OP_SKIP_ARG:
737        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
738          ims, eptrb, flags, RM57);
739        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
740    
741        /* Pass back the current skip name by overloading md->start_match_ptr and
742        returning the special MATCH_SKIP_ARG return code. This will either be
743        caught by a matching MARK, or get to the top, where it is treated the same
744        as PRUNE. */
745    
746        md->start_match_ptr = ecode + 2;
747        RRETURN(MATCH_SKIP_ARG);
748    
749      case OP_THEN:      case OP_THEN:
750      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
751        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
752      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
753        MRRETURN(MATCH_THEN);
754    
755        case OP_THEN_ARG:
756        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
757          ims, eptrb, flags, RM58);
758        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
759        md->mark = ecode + 2;
760      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
761    
762      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
# Line 747  for (;;) Line 812  for (;;)
812        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
813        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
814    
815          if (rrc != MATCH_THEN) md->mark = markptr;
816        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
817        }        }
818    
# Line 786  for (;;) Line 852  for (;;)
852    
853          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
854            eptrb, flags, RM48);            eptrb, flags, RM48);
855            if (rrc == MATCH_NOMATCH) md->mark = markptr;
856          RRETURN(rrc);          RRETURN(rrc);
857          }          }
858    
# Line 829  for (;;) Line 896  for (;;)
896          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
897          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
898          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
899          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
900          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
901          }          }
902        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 1070  for (;;) Line 1137  for (;;)
1137        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1138          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1139        offset_top = rec->save_offset_top;        offset_top = rec->save_offset_top;
       mstart = rec->save_start;  
1140        ims = original_ims;        ims = original_ims;
1141        ecode = rec->after_call;        ecode = rec->after_call;
1142        break;        break;
# Line 1085  for (;;) Line 1151  for (;;)
1151          (md->notempty ||          (md->notempty ||
1152            (md->notempty_atstart &&            (md->notempty_atstart &&
1153              mstart == md->start_subject + md->start_offset)))              mstart == md->start_subject + md->start_offset)))
1154        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1155    
1156      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1157    
1158      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1159      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1160      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1161      RRETURN(MATCH_MATCH);  
1162        /* For some reason, the macros don't work properly if an expression is
1163        given as the argument to MRRETURN when the heap is in use. */
1164    
1165        rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1166        MRRETURN(rrc);
1167    
1168      /* Change option settings */      /* Change option settings */
1169    
# Line 1114  for (;;) Line 1185  for (;;)
1185        {        {
1186        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1187          RM4);          RM4);
1188        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1189            {
1190            mstart = md->start_match_ptr;   /* In case \K reset it */
1191            break;
1192            }
1193        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1194        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1195        }        }
1196      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1197      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1198    
1199      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1200    
# Line 1143  for (;;) Line 1218  for (;;)
1218        {        {
1219        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1220          RM5);          RM5);
1221        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1222        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1223          {          {
1224          do ecode += GET(ecode,1); while (*ecode == OP_ALT);          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
# Line 1172  for (;;) Line 1247  for (;;)
1247        while (i-- > 0)        while (i-- > 0)
1248          {          {
1249          eptr--;          eptr--;
1250          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1251          BACKCHAR(eptr);          BACKCHAR(eptr);
1252          }          }
1253        }        }
# Line 1183  for (;;) Line 1258  for (;;)
1258    
1259        {        {
1260        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1261        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1262        }        }
1263    
1264      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1212  for (;;) Line 1287  for (;;)
1287        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1288        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1289        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1290        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1291        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1292        }        }
1293      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1267  for (;;) Line 1342  for (;;)
1342    
1343        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1344              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
       new_recursive.save_start = mstart;  
1345        new_recursive.save_offset_top = offset_top;        new_recursive.save_offset_top = offset_top;
       mstart = eptr;  
1346    
1347        /* OK, now we can do the recursion. For each top-level alternative we        /* OK, now we can do the recursion. For each top-level alternative we
1348        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1280  for (;;) Line 1353  for (;;)
1353          {          {
1354          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1355            md, ims, eptrb, flags, RM6);            md, ims, eptrb, flags, RM6);
1356          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1357            {            {
1358            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1359            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1360            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1361              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1362            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1363            }            }
1364          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1365            {            {
# Line 1307  for (;;) Line 1380  for (;;)
1380        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1381        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1382          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1383        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1384        }        }
1385      /* Control never reaches here */      /* Control never reaches here */
1386    
# Line 1316  for (;;) Line 1389  for (;;)
1389      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1390      Check the alternative branches in turn - the matching won't pass the KET      Check the alternative branches in turn - the matching won't pass the KET
1391      for this kind of subpattern. If any one branch matches, we carry on as at      for this kind of subpattern. If any one branch matches, we carry on as at
1392      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1393        the start-of-match value in case it was changed by \K. */
1394    
1395      case OP_ONCE:      case OP_ONCE:
1396      prev = ecode;      prev = ecode;
# Line 1325  for (;;) Line 1399  for (;;)
1399      do      do
1400        {        {
1401        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
1402        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1403            {
1404            mstart = md->start_match_ptr;
1405            break;
1406            }
1407        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1408        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1409        }        }
# Line 1444  for (;;) Line 1522  for (;;)
1522        }        }
1523      else saved_eptr = NULL;      else saved_eptr = NULL;
1524    
1525      /* If we are at the end of an assertion group, stop matching and return      /* If we are at the end of an assertion group or an atomic group, stop
1526      MATCH_MATCH, but record the current high water mark for use by positive      matching and return MATCH_MATCH, but record the current high water mark for
1527      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1528        it was changed by \K. */
1529    
1530      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1531          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1454  for (;;) Line 1533  for (;;)
1533        {        {
1534        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1535        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1536        RRETURN(MATCH_MATCH);        md->start_match_ptr = mstart;
1537          MRRETURN(MATCH_MATCH);
1538        }        }
1539    
1540      /* For capturing groups we have to check the group number back at the start      /* For capturing groups we have to check the group number back at the start
# Line 1490  for (;;) Line 1570  for (;;)
1570          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1571          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1572          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1573          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1574            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1575          offset_top = rec->save_offset_top;          offset_top = rec->save_offset_top;
# Line 1550  for (;;) Line 1629  for (;;)
1629      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1630    
1631      case OP_CIRC:      case OP_CIRC:
1632      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1633      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1634        {        {
1635        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1636            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1637          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1638        ecode++;        ecode++;
1639        break;        break;
1640        }        }
# Line 1564  for (;;) Line 1643  for (;;)
1643      /* Start of subject assertion */      /* Start of subject assertion */
1644    
1645      case OP_SOD:      case OP_SOD:
1646      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1647      ecode++;      ecode++;
1648      break;      break;
1649    
1650      /* Start of match assertion */      /* Start of match assertion */
1651    
1652      case OP_SOM:      case OP_SOM:
1653      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1654      ecode++;      ecode++;
1655      break;      break;
1656    
# Line 1589  for (;;) Line 1668  for (;;)
1668      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1669        {        {
1670        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1671          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1672        else        else
1673          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
1674        ecode++;        ecode++;
1675        break;        break;
1676        }        }
1677      else      else
1678        {        {
1679        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1680        if (!md->endonly)        if (!md->endonly)
1681          {          {
1682          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1683              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1684            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
1685          ecode++;          ecode++;
1686          break;          break;
1687          }          }
# Line 1612  for (;;) Line 1691  for (;;)
1691      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1692    
1693      case OP_EOD:      case OP_EOD:
1694      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1695      ecode++;      ecode++;
1696      break;      break;
1697    
# Line 1621  for (;;) Line 1700  for (;;)
1700      case OP_EODN:      case OP_EODN:
1701      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1702          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1703        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1704      ecode++;      ecode++;
1705      break;      break;
1706    
# Line 1639  for (;;) Line 1718  for (;;)
1718  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1719        if (utf8)        if (utf8)
1720          {          {
1721            /* Get status of previous character */
1722    
1723          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1724            {            {
1725            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1726            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1727            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1728            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1729    #ifdef SUPPORT_UCP
1730              if (md->use_ucp)
1731                {
1732                if (c == '_') prev_is_word = TRUE; else
1733                  {
1734                  int cat = UCD_CATEGORY(c);
1735                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1736                  }
1737                }
1738              else
1739    #endif
1740            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1741            }            }
1742    
1743            /* Get status of next character */
1744    
1745          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1746            {            {
1747            SCHECK_PARTIAL();            SCHECK_PARTIAL();
# Line 1655  for (;;) Line 1750  for (;;)
1750          else          else
1751            {            {
1752            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1753    #ifdef SUPPORT_UCP
1754              if (md->use_ucp)
1755                {
1756                if (c == '_') cur_is_word = TRUE; else
1757                  {
1758                  int cat = UCD_CATEGORY(c);
1759                  cur_is_word = (cat == ucp_L || cat == ucp_N);
1760                  }
1761                }
1762              else
1763    #endif
1764            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1765            }            }
1766          }          }
1767        else        else
1768  #endif  #endif
1769    
1770        /* Not in UTF-8 mode */        /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
1771          consistency with the behaviour of \w we do use it in this case. */
1772    
1773          {          {
1774            /* Get status of previous character */
1775    
1776          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1777            {            {
1778            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1779    #ifdef SUPPORT_UCP
1780              if (md->use_ucp)
1781                {
1782                c = eptr[-1];
1783                if (c == '_') prev_is_word = TRUE; else
1784                  {
1785                  int cat = UCD_CATEGORY(c);
1786                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1787                  }
1788                }
1789              else
1790    #endif
1791            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1792            }            }
1793    
1794            /* Get status of next character */
1795    
1796          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1797            {            {
1798            SCHECK_PARTIAL();            SCHECK_PARTIAL();
1799            cur_is_word = FALSE;            cur_is_word = FALSE;
1800            }            }
1801          else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);          else
1802    #ifdef SUPPORT_UCP
1803            if (md->use_ucp)
1804              {
1805              c = *eptr;
1806              if (c == '_') cur_is_word = TRUE; else
1807                {
1808                int cat = UCD_CATEGORY(c);
1809                cur_is_word = (cat == ucp_L || cat == ucp_N);
1810                }
1811              }
1812            else
1813    #endif
1814            cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1815          }          }
1816    
1817        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
1818    
1819        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1820             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1821          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1822        }        }
1823      break;      break;
1824    
1825      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1826    
1827      case OP_ANY:      case OP_ANY:
1828      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1829      /* Fall through */      /* Fall through */
1830    
1831      case OP_ALLANY:      case OP_ALLANY:
1832      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1833        {        {
1834        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1835        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1836        }        }
1837      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1838      ecode++;      ecode++;
# Line 1708  for (;;) Line 1845  for (;;)
1845      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1846        {        {
1847        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1848        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1849        }        }
1850      ecode++;      ecode++;
1851      break;      break;
# Line 1717  for (;;) Line 1854  for (;;)
1854      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1855        {        {
1856        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1857        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1858        }        }
1859      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1860      if (      if (
# Line 1726  for (;;) Line 1863  for (;;)
1863  #endif  #endif
1864         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1865         )         )
1866        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1867      ecode++;      ecode++;
1868      break;      break;
1869    
# Line 1734  for (;;) Line 1871  for (;;)
1871      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1872        {        {
1873        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1874        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1875        }        }
1876      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1877      if (      if (
# Line 1743  for (;;) Line 1880  for (;;)
1880  #endif  #endif
1881         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1882         )         )
1883        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1884      ecode++;      ecode++;
1885      break;      break;
1886    
# Line 1751  for (;;) Line 1888  for (;;)
1888      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1889        {        {
1890        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1891        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1892        }        }
1893      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1894      if (      if (
# Line 1760  for (;;) Line 1897  for (;;)
1897  #endif  #endif
1898         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1899         )         )
1900        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1901      ecode++;      ecode++;
1902      break;      break;
1903    
# Line 1768  for (;;) Line 1905  for (;;)
1905      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1906        {        {
1907        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1908        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1909        }        }
1910      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1911      if (      if (
# Line 1777  for (;;) Line 1914  for (;;)
1914  #endif  #endif
1915         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1916         )         )
1917        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1918      ecode++;      ecode++;
1919      break;      break;
1920    
# Line 1785  for (;;) Line 1922  for (;;)
1922      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1923        {        {
1924        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1925        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1926        }        }
1927      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1928      if (      if (
# Line 1794  for (;;) Line 1931  for (;;)
1931  #endif  #endif
1932         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1933         )         )
1934        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1935      ecode++;      ecode++;
1936      break;      break;
1937    
# Line 1802  for (;;) Line 1939  for (;;)
1939      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1940        {        {
1941        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1942        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1943        }        }
1944      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1945      if (      if (
# Line 1811  for (;;) Line 1948  for (;;)
1948  #endif  #endif
1949         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1950         )         )
1951        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1952      ecode++;      ecode++;
1953      break;      break;
1954    
# Line 1819  for (;;) Line 1956  for (;;)
1956      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1957        {        {
1958        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1959        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1960        }        }
1961      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1962      switch(c)      switch(c)
1963        {        {
1964        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1965        case 0x000d:        case 0x000d:
1966        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1967        break;        break;
# Line 1837  for (;;) Line 1974  for (;;)
1974        case 0x0085:        case 0x0085:
1975        case 0x2028:        case 0x2028:
1976        case 0x2029:        case 0x2029:
1977        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
1978        break;        break;
1979        }        }
1980      ecode++;      ecode++;
# Line 1847  for (;;) Line 1984  for (;;)
1984      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1985        {        {
1986        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1987        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1988        }        }
1989      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1990      switch(c)      switch(c)
# Line 1872  for (;;) Line 2009  for (;;)
2009        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2010        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2011        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2012        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2013        }        }
2014      ecode++;      ecode++;
2015      break;      break;
# Line 1881  for (;;) Line 2018  for (;;)
2018      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2019        {        {
2020        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2021        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2022        }        }
2023      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2024      switch(c)      switch(c)
2025        {        {
2026        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2027        case 0x09:      /* HT */        case 0x09:      /* HT */
2028        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2029        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1915  for (;;) Line 2052  for (;;)
2052      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2053        {        {
2054        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2055        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2056        }        }
2057      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2058      switch(c)      switch(c)
# Line 1928  for (;;) Line 2065  for (;;)
2065        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2066        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2067        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2068        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2069        }        }
2070      ecode++;      ecode++;
2071      break;      break;
# Line 1937  for (;;) Line 2074  for (;;)
2074      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2075        {        {
2076        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2077        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2078        }        }
2079      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2080      switch(c)      switch(c)
2081        {        {
2082        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2083        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2084        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2085        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1964  for (;;) Line 2101  for (;;)
2101      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2102        {        {
2103        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2104        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2105        }        }
2106      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2107        {        {
# Line 1973  for (;;) Line 2110  for (;;)
2110        switch(ecode[1])        switch(ecode[1])
2111          {          {
2112          case PT_ANY:          case PT_ANY:
2113          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2114          break;          break;
2115    
2116          case PT_LAMP:          case PT_LAMP:
2117          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2118               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2119               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2120            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2121           break;          break;
2122    
2123          case PT_GC:          case PT_GC:
2124          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2125            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2126          break;          break;
2127    
2128          case PT_PC:          case PT_PC:
2129          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2130            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2131          break;          break;
2132    
2133          case PT_SC:          case PT_SC:
2134          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2135            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2136          break;          break;
2137    
2138            /* These are specials */
2139    
2140            case PT_ALNUM:
2141            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2142                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2143              MRRETURN(MATCH_NOMATCH);
2144            break;
2145    
2146            case PT_SPACE:    /* Perl space */
2147            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2148                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2149                   == (op == OP_NOTPROP))
2150              MRRETURN(MATCH_NOMATCH);
2151            break;
2152    
2153            case PT_PXSPACE:  /* POSIX space */
2154            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2155                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2156                 c == CHAR_FF || c == CHAR_CR)
2157                   == (op == OP_NOTPROP))
2158              MRRETURN(MATCH_NOMATCH);
2159            break;
2160    
2161            case PT_WORD:
2162            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2163                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2164                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2165              MRRETURN(MATCH_NOMATCH);
2166            break;
2167    
2168            /* This should never occur */
2169    
2170          default:          default:
2171          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
# Line 2013  for (;;) Line 2182  for (;;)
2182      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2183        {        {
2184        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2185        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2186        }        }
2187      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2188        {        {
2189        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2190        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2191        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2192          {          {
2193          int len = 1;          int len = 1;
# Line 2097  for (;;) Line 2266  for (;;)
2266          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2267            {            {
2268            CHECK_PARTIAL();            CHECK_PARTIAL();
2269            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2270            }            }
2271          eptr += length;          eptr += length;
2272          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 2117  for (;;) Line 2286  for (;;)
2286          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2287            {            {
2288            CHECK_PARTIAL();            CHECK_PARTIAL();
2289            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2290            }            }
2291          eptr += length;          eptr += length;
2292          }          }
# Line 2135  for (;;) Line 2304  for (;;)
2304            {            {
2305            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2306            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2307            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2308            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2309              {              {
2310              CHECK_PARTIAL();              CHECK_PARTIAL();
2311              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2312              }              }
2313            eptr += length;            eptr += length;
2314            }            }
# Line 2166  for (;;) Line 2335  for (;;)
2335            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2336            eptr -= length;            eptr -= length;
2337            }            }
2338          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2339          }          }
2340        }        }
2341      /* Control never gets here */      /* Control never gets here */
# Line 2228  for (;;) Line 2397  for (;;)
2397            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2398              {              {
2399              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2400              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2401              }              }
2402            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2403            if (c > 255)            if (c > 255)
2404              {              {
2405              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2406              }              }
2407            else            else
2408              {              {
2409              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2410              }              }
2411            }            }
2412          }          }
# Line 2250  for (;;) Line 2419  for (;;)
2419            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2420              {              {
2421              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2422              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2423              }              }
2424            c = *eptr++;            c = *eptr++;
2425            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2426            }            }
2427          }          }
2428    
# Line 2275  for (;;) Line 2444  for (;;)
2444              {              {
2445              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2446              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2447              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2448              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2449                {                {
2450                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2451                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2452                }                }
2453              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2454              if (c > 255)              if (c > 255)
2455                {                {
2456                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2457                }                }
2458              else              else
2459                {                {
2460                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2461                }                }
2462              }              }
2463            }            }
# Line 2300  for (;;) Line 2469  for (;;)
2469              {              {
2470              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2471              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2472              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2473              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2474                {                {
2475                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2476                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2477                }                }
2478              c = *eptr++;              c = *eptr++;
2479              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2480              }              }
2481            }            }
2482          /* Control never gets here */          /* Control never gets here */
# Line 2373  for (;;) Line 2542  for (;;)
2542              }              }
2543            }            }
2544    
2545          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2546          }          }
2547        }        }
2548      /* Control never gets here */      /* Control never gets here */
# Line 2425  for (;;) Line 2594  for (;;)
2594          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2595            {            {
2596            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2597            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2598            }            }
2599          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2600          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2601          }          }
2602    
2603        /* If max == min we can continue with the main loop without the        /* If max == min we can continue with the main loop without the
# Line 2445  for (;;) Line 2614  for (;;)
2614            {            {
2615            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2616            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2617            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2618            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2619              {              {
2620              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2621              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2622              }              }
2623            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2624            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2625            }            }
2626          /* Control never gets here */          /* Control never gets here */
2627          }          }
# Line 2481  for (;;) Line 2650  for (;;)
2650            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2651            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2652            }            }
2653          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2654          }          }
2655    
2656        /* Control never gets here */        /* Control never gets here */
# Line 2500  for (;;) Line 2669  for (;;)
2669        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2670          {          {
2671          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2672          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2673          }          }
2674        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2675        }        }
2676      else      else
2677  #endif  #endif
# Line 2512  for (;;) Line 2681  for (;;)
2681        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2682          {          {
2683          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2684          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2685          }          }
2686        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2687        ecode += 2;        ecode += 2;
2688        }        }
2689      break;      break;
# Line 2532  for (;;) Line 2701  for (;;)
2701        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2702          {          {
2703          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2704          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2705          }          }
2706    
2707        /* If the pattern character's value is < 128, we have only one byte, and        /* If the pattern character's value is < 128, we have only one byte, and
# Line 2540  for (;;) Line 2709  for (;;)
2709    
2710        if (fc < 128)        if (fc < 128)
2711          {          {
2712          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2713          }          }
2714    
2715        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2559  for (;;) Line 2728  for (;;)
2728  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2729            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2730  #endif  #endif
2731              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2732            }            }
2733          }          }
2734        }        }
# Line 2571  for (;;) Line 2740  for (;;)
2740        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2741          {          {
2742          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2743          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2744          }          }
2745        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2746        ecode += 2;        ecode += 2;
2747        }        }
2748      break;      break;
# Line 2667  for (;;) Line 2836  for (;;)
2836            else            else
2837              {              {
2838              CHECK_PARTIAL();              CHECK_PARTIAL();
2839              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2840              }              }
2841            }            }
2842    
# Line 2679  for (;;) Line 2848  for (;;)
2848              {              {
2849              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2850              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2851              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2852              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2853                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2854  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2690  for (;;) Line 2859  for (;;)
2859              else              else
2860                {                {
2861                CHECK_PARTIAL();                CHECK_PARTIAL();
2862                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2863                }                }
2864              }              }
2865            /* Control never gets here */            /* Control never gets here */
# Line 2721  for (;;) Line 2890  for (;;)
2890              {              {
2891              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2892              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2893              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2894  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2895              eptr--;              eptr--;
2896              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2764  for (;;) Line 2933  for (;;)
2933          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2934            {            {
2935            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2936            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2937            }            }
2938          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2939          }          }
2940        if (min == max) continue;        if (min == max) continue;
2941        if (minimize)        if (minimize)
# Line 2775  for (;;) Line 2944  for (;;)
2944            {            {
2945            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2946            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2947            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2948            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2949              {              {
2950              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2951              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2952              }              }
2953            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2954            }            }
2955          /* Control never gets here */          /* Control never gets here */
2956          }          }
# Line 2807  for (;;) Line 2976  for (;;)
2976            eptr--;            eptr--;
2977            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2978            }            }
2979          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2980          }          }
2981        /* Control never gets here */        /* Control never gets here */
2982        }        }
# Line 2821  for (;;) Line 2990  for (;;)
2990          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2991            {            {
2992            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2993            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2994            }            }
2995          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2996          }          }
2997    
2998        if (min == max) continue;        if (min == max) continue;
# Line 2834  for (;;) Line 3003  for (;;)
3003            {            {
3004            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
3005            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3006            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
3007            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3008              {              {
3009              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3010              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3011              }              }
3012            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3013            }            }
3014          /* Control never gets here */          /* Control never gets here */
3015          }          }
# Line 2865  for (;;) Line 3034  for (;;)
3034            eptr--;            eptr--;
3035            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3036            }            }
3037          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3038          }          }
3039        }        }
3040      /* Control never gets here */      /* Control never gets here */
# Line 2877  for (;;) Line 3046  for (;;)
3046      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
3047        {        {
3048        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3049        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
3050        }        }
3051      ecode++;      ecode++;
3052      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2887  for (;;) Line 3056  for (;;)
3056        if (c < 256)        if (c < 256)
3057  #endif  #endif
3058        c = md->lcc[c];        c = md->lcc[c];
3059        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3060        }        }
3061      else      else
3062        {        {
3063        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3064        }        }
3065      break;      break;
3066    
# Line 2985  for (;;) Line 3154  for (;;)
3154            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3155              {              {
3156              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3157              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3158              }              }
3159            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3160            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3161            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3162            }            }
3163          }          }
3164        else        else
# Line 3002  for (;;) Line 3171  for (;;)
3171            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3172              {              {
3173              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3174              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3175              }              }
3176            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3177            }            }
3178          }          }
3179    
# Line 3021  for (;;) Line 3190  for (;;)
3190              {              {
3191              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3192              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3193              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3194              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3195                {                {
3196                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3197                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3198                }                }
3199              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3200              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3201              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3202              }              }
3203            }            }
3204          else          else
# Line 3040  for (;;) Line 3209  for (;;)
3209              {              {
3210              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3211              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3212              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3213              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3214                {                {
3215                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3216                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3217                }                }
3218              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3219              }              }
3220            }            }
3221          /* Control never gets here */          /* Control never gets here */
# Line 3108  for (;;) Line 3277  for (;;)
3277              }              }
3278            }            }
3279    
3280          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3281          }          }
3282        /* Control never gets here */        /* Control never gets here */
3283        }        }
# Line 3127  for (;;) Line 3296  for (;;)
3296            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3297              {              {
3298              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3299              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3300              }              }
3301            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3302            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3303            }            }
3304          }          }
3305        else        else
# Line 3142  for (;;) Line 3311  for (;;)
3311            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3312              {              {
3313              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3314              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3315              }              }
3316            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3317            }            }
3318          }          }
3319    
# Line 3161  for (;;) Line 3330  for (;;)
3330              {              {
3331              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3332              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3333              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3334              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3335                {                {
3336                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3337                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3338                }                }
3339              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3340              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3341              }              }
3342            }            }
3343          else          else
# Line 3179  for (;;) Line 3348  for (;;)
3348              {              {
3349              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3350              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3351              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3352              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3353                {                {
3354                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3355                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3356                }                }
3357              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3358              }              }
3359            }            }
3360          /* Control never gets here */          /* Control never gets here */
# Line 3246  for (;;) Line 3415  for (;;)
3415              }              }
3416            }            }
3417    
3418          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3419          }          }
3420        }        }
3421      /* Control never gets here */      /* Control never gets here */
# Line 3340  for (;;) Line 3509  for (;;)
3509          switch(prop_type)          switch(prop_type)
3510            {            {
3511            case PT_ANY:            case PT_ANY:
3512            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3513            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3514              {              {
3515              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3516                {                {
3517                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3518                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3519                }                }
3520              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3521              }              }
# Line 3358  for (;;) Line 3527  for (;;)
3527              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3528                {                {
3529                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3530                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3531                }                }
3532              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3533              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3534              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3535                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3536                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3537                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3538              }              }
3539            break;            break;
3540    
# Line 3375  for (;;) Line 3544  for (;;)
3544              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3545                {                {
3546                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3547                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3548                }                }
3549              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3550              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3551              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3552                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3553              }              }
3554            break;            break;
3555    
# Line 3390  for (;;) Line 3559  for (;;)
3559              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3560                {                {
3561                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3562                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3563                }                }
3564              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3565              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3566              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3567                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3568              }              }
3569            break;            break;
3570    
# Line 3405  for (;;) Line 3574  for (;;)
3574              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3575                {                {
3576                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3577                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3578                }                }
3579              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3580              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3581              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3582                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3583                }
3584              break;
3585    
3586              case PT_ALNUM:
3587              for (i = 1; i <= min; i++)
3588                {
3589                if (eptr >= md->end_subject)
3590                  {
3591                  SCHECK_PARTIAL();
3592                  MRRETURN(MATCH_NOMATCH);
3593                  }
3594                GETCHARINCTEST(c, eptr);
3595                prop_category = UCD_CATEGORY(c);
3596                if ((prop_category == ucp_L || prop_category == ucp_N)
3597                       == prop_fail_result)
3598                  MRRETURN(MATCH_NOMATCH);
3599                }
3600              break;
3601    
3602              case PT_SPACE:    /* Perl space */
3603              for (i = 1; i <= min; i++)
3604                {
3605                if (eptr >= md->end_subject)
3606                  {
3607                  SCHECK_PARTIAL();
3608                  MRRETURN(MATCH_NOMATCH);
3609                  }
3610                GETCHARINCTEST(c, eptr);
3611                prop_category = UCD_CATEGORY(c);
3612                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3613                     c == CHAR_FF || c == CHAR_CR)
3614                       == prop_fail_result)
3615                  MRRETURN(MATCH_NOMATCH);
3616              }              }
3617            break;            break;
3618    
3619              case PT_PXSPACE:  /* POSIX space */
3620              for (i = 1; i <= min; i++)
3621                {
3622                if (eptr >= md->end_subject)
3623                  {
3624                  SCHECK_PARTIAL();
3625                  MRRETURN(MATCH_NOMATCH);
3626                  }
3627                GETCHARINCTEST(c, eptr);
3628                prop_category = UCD_CATEGORY(c);
3629                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3630                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3631                       == prop_fail_result)
3632                  MRRETURN(MATCH_NOMATCH);
3633                }
3634              break;
3635    
3636              case PT_WORD:
3637              for (i = 1; i <= min; i++)
3638                {
3639                if (eptr >= md->end_subject)
3640                  {
3641                  SCHECK_PARTIAL();
3642                  MRRETURN(MATCH_NOMATCH);
3643                  }
3644                GETCHARINCTEST(c, eptr);
3645                prop_category = UCD_CATEGORY(c);
3646                if ((prop_category == ucp_L || prop_category == ucp_N ||
3647                     c == CHAR_UNDERSCORE)
3648                       == prop_fail_result)
3649                  MRRETURN(MATCH_NOMATCH);
3650                }
3651              break;
3652    
3653              /* This should not occur */
3654    
3655            default:            default:
3656            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
# Line 3429  for (;;) Line 3667  for (;;)
3667            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3668              {              {
3669              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3670              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3671              }              }
3672            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3673            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3674            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3675            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3676              {              {
3677              int len = 1;              int len = 1;
# Line 3460  for (;;) Line 3698  for (;;)
3698            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3699              {              {
3700              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3701              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3702              }              }
3703            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3704            eptr++;            eptr++;
3705            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3706            }            }
# Line 3474  for (;;) Line 3712  for (;;)
3712            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3713              {              {
3714              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3715              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3716              }              }
3717            eptr++;            eptr++;
3718            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3482  for (;;) Line 3720  for (;;)
3720          break;          break;
3721    
3722          case OP_ANYBYTE:          case OP_ANYBYTE:
3723          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3724          eptr += min;          eptr += min;
3725          break;          break;
3726    
# Line 3492  for (;;) Line 3730  for (;;)
3730            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3731              {              {
3732              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3733              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3734              }              }
3735            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3736            switch(c)            switch(c)
3737              {              {
3738              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3739              case 0x000d:              case 0x000d:
3740              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3741              break;              break;
# Line 3510  for (;;) Line 3748  for (;;)
3748              case 0x0085:              case 0x0085:
3749              case 0x2028:              case 0x2028:
3750              case 0x2029:              case 0x2029:
3751              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3752              break;              break;
3753              }              }
3754            }            }
# Line 3522  for (;;) Line 3760  for (;;)
3760            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3761              {              {
3762              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3763              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3764              }              }
3765            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3766            switch(c)            switch(c)
# Line 3547  for (;;) Line 3785  for (;;)
3785              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3786              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3787              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3788              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3789              }              }
3790            }            }
3791          break;          break;
# Line 3558  for (;;) Line 3796  for (;;)
3796            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3797              {              {
3798              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3799              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3800              }              }
3801            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3802            switch(c)            switch(c)
3803              {              {
3804              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3805              case 0x09:      /* HT */              case 0x09:      /* HT */
3806              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3807              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3594  for (;;) Line 3832  for (;;)
3832            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3833              {              {
3834              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3835              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3836              }              }
3837            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3838            switch(c)            switch(c)
# Line 3607  for (;;) Line 3845  for (;;)
3845              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3846              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3847              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3848              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3849              }              }
3850            }            }
3851          break;          break;
# Line 3618  for (;;) Line 3856  for (;;)
3856            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3857              {              {
3858              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3859              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3860              }              }
3861            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3862            switch(c)            switch(c)
3863              {              {
3864              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3865              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3866              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3867              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3642  for (;;) Line 3880  for (;;)
3880            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3881              {              {
3882              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3883              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3884              }              }
3885            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3886            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3887              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3888            }            }
3889          break;          break;
3890    
# Line 3656  for (;;) Line 3894  for (;;)
3894            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3895              {              {
3896              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3897              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3898              }              }
3899            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3900              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3901            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
3902            }            }
3903          break;          break;
# Line 3670  for (;;) Line 3908  for (;;)
3908            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3909              {              {
3910              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3911              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3912              }              }
3913            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3914              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3915            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3916            }            }
3917          break;          break;
# Line 3684  for (;;) Line 3922  for (;;)
3922            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3923              {              {
3924              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3925              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3926              }              }
3927            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3928              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3929            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
3930            }            }
3931          break;          break;
# Line 3698  for (;;) Line 3936  for (;;)
3936            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3937              {              {
3938              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3939              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3940              }              }
3941            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3942              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3943            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3944            }            }
3945          break;          break;
# Line 3712  for (;;) Line 3950  for (;;)
3950            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3951              {              {
3952              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3953              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3954              }              }
3955            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3956              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3957            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
3958            }            }
3959          break;          break;
# Line 3738  for (;;) Line 3976  for (;;)
3976            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3977              {              {
3978              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3979              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3980              }              }
3981            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3982            eptr++;            eptr++;
3983            }            }
3984          break;          break;
# Line 3749  for (;;) Line 3987  for (;;)
3987          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3988            {            {
3989            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3990            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3991            }            }
3992          eptr += min;          eptr += min;
3993          break;          break;
# Line 3758  for (;;) Line 3996  for (;;)
3996          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3997            {            {
3998            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3999            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
4000            }            }
4001          eptr += min;          eptr += min;
4002          break;          break;
# Line 3769  for (;;) Line 4007  for (;;)
4007            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4008              {              {
4009              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4010              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4011              }              }
4012            switch(*eptr++)            switch(*eptr++)
4013              {              {
4014              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4015              case 0x000d:              case 0x000d:
4016              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4017              break;              break;
# Line 3783  for (;;) Line 4021  for (;;)
4021              case 0x000b:              case 0x000b:
4022              case 0x000c:              case 0x000c:
4023              case 0x0085:              case 0x0085:
4024              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4025              break;              break;
4026              }              }
4027            }            }
# Line 3795  for (;;) Line 4033  for (;;)
4033            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4034              {              {
4035              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4036              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4037              }              }
4038            switch(*eptr++)            switch(*eptr++)
4039              {              {
# Line 3803  for (;;) Line 4041  for (;;)
4041              case 0x09:      /* HT */              case 0x09:      /* HT */
4042              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4043              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4044              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4045              }              }
4046            }            }
4047          break;          break;
# Line 3814  for (;;) Line 4052  for (;;)
4052            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4053              {              {
4054              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4055              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4056              }              }
4057            switch(*eptr++)            switch(*eptr++)
4058              {              {
4059              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4060              case 0x09:      /* HT */              case 0x09:      /* HT */
4061              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4062              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3833  for (;;) Line 4071  for (;;)
4071            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4072              {              {
4073              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4074              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4075              }              }
4076            switch(*eptr++)            switch(*eptr++)
4077              {              {
# Line 3843  for (;;) Line 4081  for (;;)
4081              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4082              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4083              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4084              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4085              }              }
4086            }            }
4087          break;          break;
# Line 3854  for (;;) Line 4092  for (;;)
4092            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4093              {              {
4094              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4095              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4096              }              }
4097            switch(*eptr++)            switch(*eptr++)
4098              {              {
4099              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4100              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4101              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4102              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3875  for (;;) Line 4113  for (;;)
4113            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4114              {              {
4115              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4116              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4117              }              }
4118            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4119            }            }
4120          break;          break;
4121    
# Line 3887  for (;;) Line 4125  for (;;)
4125            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4126              {              {
4127              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4128              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4129              }              }
4130            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4131            }            }
4132          break;          break;
4133    
# Line 3899  for (;;) Line 4137  for (;;)
4137            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4138              {              {
4139              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4140              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4141              }              }
4142            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4143            }            }
4144          break;          break;
4145    
# Line 3911  for (;;) Line 4149  for (;;)
4149            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4150              {              {
4151              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4152              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4153              }              }
4154            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4155            }            }
4156          break;          break;
4157    
# Line 3923  for (;;) Line 4161  for (;;)
4161            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4162              {              {
4163              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4164              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4165              }              }
4166            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4167              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4168            }            }
4169          break;          break;
4170    
# Line 3936  for (;;) Line 4174  for (;;)
4174            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4175              {              {
4176              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4177              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4178              }              }
4179            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4180              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4181            }            }
4182          break;          break;
4183    
# Line 3968  for (;;) Line 4206  for (;;)
4206              {              {
4207              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4208              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4209              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4210              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4211                {                {
4212                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4213                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4214                }                }
4215              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4216              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4217              }              }
4218            /* Control never gets here */            /* Control never gets here */
4219    
# Line 3984  for (;;) Line 4222  for (;;)
4222              {              {
4223              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4224              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4225              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4226              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4227                {                {
4228                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4229                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4230                }                }
4231              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4232              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4233              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4234                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4235                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4236                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4237              }              }
4238            /* Control never gets here */            /* Control never gets here */
4239    
# Line 4004  for (;;) Line 4242  for (;;)
4242              {              {
4243              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4244              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4245              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4246              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4247                {                {
4248                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4249                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4250                }                }
4251              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4252              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4253              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4254                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4255              }              }
4256            /* Control never gets here */            /* Control never gets here */
4257    
# Line 4022  for (;;) Line 4260  for (;;)
4260              {              {
4261              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4262              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4263              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4264              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4265                {                {
4266                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4267                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4268                }                }
4269              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4270              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4271              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4272                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4273              }              }
4274            /* Control never gets here */            /* Control never gets here */
4275    
# Line 4040  for (;;) Line 4278  for (;;)
4278              {              {
4279              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4280              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4281              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4282              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4283                {                {
4284                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4285                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4286                }                }
4287              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4288              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4289              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4290                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4291                }
4292              /* Control never gets here */
4293    
4294              case PT_ALNUM:
4295              for (fi = min;; fi++)
4296                {
4297                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4298                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4299                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4300                if (eptr >= md->end_subject)
4301                  {
4302                  SCHECK_PARTIAL();
4303                  MRRETURN(MATCH_NOMATCH);
4304                  }
4305                GETCHARINC(c, eptr);
4306                prop_category = UCD_CATEGORY(c);
4307                if ((prop_category == ucp_L || prop_category == ucp_N)
4308                       == prop_fail_result)
4309                  MRRETURN(MATCH_NOMATCH);
4310                }
4311              /* Control never gets here */
4312    
4313              case PT_SPACE:    /* Perl space */
4314              for (fi = min;; fi++)
4315                {
4316                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4317                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4318                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4319                if (eptr >= md->end_subject)
4320                  {
4321                  SCHECK_PARTIAL();
4322                  MRRETURN(MATCH_NOMATCH);
4323                  }
4324                GETCHARINC(c, eptr);
4325                prop_category = UCD_CATEGORY(c);
4326                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4327                     c == CHAR_FF || c == CHAR_CR)
4328                       == prop_fail_result)
4329                  MRRETURN(MATCH_NOMATCH);
4330                }
4331              /* Control never gets here */
4332    
4333              case PT_PXSPACE:  /* POSIX space */
4334              for (fi = min;; fi++)
4335                {
4336                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4337                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4338                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4339                if (eptr >= md->end_subject)
4340                  {
4341                  SCHECK_PARTIAL();
4342                  MRRETURN(MATCH_NOMATCH);
4343                  }
4344                GETCHARINC(c, eptr);
4345                prop_category = UCD_CATEGORY(c);
4346                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4347                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4348                       == prop_fail_result)
4349                  MRRETURN(MATCH_NOMATCH);
4350                }
4351              /* Control never gets here */
4352    
4353              case PT_WORD:
4354              for (fi = min;; fi++)
4355                {
4356                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4357                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4358                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4359                if (eptr >= md->end_subject)
4360                  {
4361                  SCHECK_PARTIAL();
4362                  MRRETURN(MATCH_NOMATCH);
4363                  }
4364                GETCHARINC(c, eptr);
4365                prop_category = UCD_CATEGORY(c);
4366                if ((prop_category == ucp_L ||
4367                     prop_category == ucp_N ||
4368                     c == CHAR_UNDERSCORE)
4369                       == prop_fail_result)
4370                  MRRETURN(MATCH_NOMATCH);
4371              }              }
4372            /* Control never gets here */            /* Control never gets here */
4373    
4374              /* This should never occur */
4375    
4376            default:            default:
4377            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4378            }            }
# Line 4067  for (;;) Line 4387  for (;;)
4387            {            {
4388            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4389            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4390            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4391            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4392              {              {
4393              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4394              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4395              }              }
4396            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4397            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4398            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4399            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4400              {              {
4401              int len = 1;              int len = 1;
# Line 4099  for (;;) Line 4419  for (;;)
4419            {            {
4420            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4421            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4422            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4423            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4424              {              {
4425              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4426              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4427              }              }
4428            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4429              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4430            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4431            switch(ctype)            switch(ctype)
4432              {              {
# Line 4118  for (;;) Line 4438  for (;;)
4438              case OP_ANYNL:              case OP_ANYNL:
4439              switch(c)              switch(c)
4440                {                {
4441                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4442                case 0x000d:                case 0x000d:
4443                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4444                break;                break;
# Line 4130  for (;;) Line 4450  for (;;)
4450                case 0x0085:                case 0x0085:
4451                case 0x2028:                case 0x2028:
4452                case 0x2029:                case 0x2029:
4453                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4454                break;                break;
4455                }                }
4456              break;              break;
# Line 4158  for (;;) Line 4478  for (;;)
4478                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4479                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4480                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4481                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4482                }                }
4483              break;              break;
4484    
4485              case OP_HSPACE:              case OP_HSPACE:
4486              switch(c)              switch(c)
4487                {                {
4488                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4489                case 0x09:      /* HT */                case 0x09:      /* HT */
4490                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4491                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4200  for (;;) Line 4520  for (;;)
4520                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4521                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4522                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4523                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4524                }                }
4525              break;              break;
4526    
4527              case OP_VSPACE:              case OP_VSPACE:
4528              switch(c)              switch(c)
4529                {                {
4530                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4531                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4532                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4533                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4221  for (;;) Line 4541  for (;;)
4541    
4542              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4543              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4544                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4545              break;              break;
4546    
4547              case OP_DIGIT:              case OP_DIGIT:
4548              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4549                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4550              break;              break;
4551    
4552              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4553              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4554                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4555              break;              break;
4556    
4557              case OP_WHITESPACE:              case OP_WHITESPACE:
4558              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4559                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4560              break;              break;
4561    
4562              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4563              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4564                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4565              break;              break;
4566    
4567              case OP_WORDCHAR:              case OP_WORDCHAR:
4568              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4569                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4570              break;              break;
4571    
4572              default:              default:
# Line 4262  for (;;) Line 4582  for (;;)
4582            {            {
4583            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4584            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4585            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4586            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4587              {              {
4588              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4589              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4590              }              }
4591            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4592              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4593            c = *eptr++;            c = *eptr++;
4594            switch(ctype)            switch(ctype)
4595              {              {
# Line 4281  for (;;) Line 4601  for (;;)
4601              case OP_ANYNL:              case OP_ANYNL:
4602              switch(c)              switch(c)
4603                {                {
4604                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4605                case 0x000d:                case 0x000d:
4606                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4607                break;                break;
# Line 4292  for (;;) Line 4612  for (;;)
4612                case 0x000b:                case 0x000b:
4613                case 0x000c:                case 0x000c:
4614                case 0x0085:                case 0x0085:
4615                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4616                break;                break;
4617                }                }
4618              break;              break;
# Line 4304  for (;;) Line 4624  for (;;)
4624                case 0x09:      /* HT */                case 0x09:      /* HT */
4625                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4626                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4627                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4628                }                }
4629              break;              break;
4630    
4631              case OP_HSPACE:              case OP_HSPACE:
4632              switch(c)              switch(c)
4633                {                {
4634                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4635                case 0x09:      /* HT */                case 0x09:      /* HT */
4636                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4637                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4328  for (;;) Line 4648  for (;;)
4648                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4649                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4650                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4651                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4652                }                }
4653              break;              break;
4654    
4655              case OP_VSPACE:              case OP_VSPACE:
4656              switch(c)              switch(c)
4657                {                {
4658                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4659                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4660                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4661                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4346  for (;;) Line 4666  for (;;)
4666              break;              break;
4667    
4668              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4669              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4670              break;              break;
4671    
4672              case OP_DIGIT:              case OP_DIGIT:
4673              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4674              break;              break;
4675    
4676              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4677              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4678              break;              break;
4679    
4680              case OP_WHITESPACE:              case OP_WHITESPACE:
4681              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4682              break;              break;
4683    
4684              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4685              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4686              break;              break;
4687    
4688              case OP_WORDCHAR:              case OP_WORDCHAR:
4689              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4690              break;              break;
4691    
4692              default:              default:
# Line 4474  for (;;) Line 4794  for (;;)
4794              eptr+= len;              eptr+= len;
4795              }              }
4796            break;            break;
4797    
4798              case PT_ALNUM:
4799              for (i = min; i < max; i++)
4800                {
4801                int len = 1;
4802                if (eptr >= md->end_subject)
4803                  {
4804                  SCHECK_PARTIAL();
4805                  break;
4806                  }
4807                GETCHARLEN(c, eptr, len);
4808                prop_category = UCD_CATEGORY(c);
4809                if ((prop_category == ucp_L || prop_category == ucp_N)
4810                     == prop_fail_result)
4811                  break;
4812                eptr+= len;
4813                }
4814              break;
4815    
4816              case PT_SPACE:    /* Perl space */
4817              for (i = min; i < max; i++)
4818                {
4819                int len = 1;
4820                if (eptr >= md->end_subject)
4821                  {
4822                  SCHECK_PARTIAL();
4823                  break;
4824                  }
4825                GETCHARLEN(c, eptr, len);
4826                prop_category = UCD_CATEGORY(c);
4827                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4828                     c == CHAR_FF || c == CHAR_CR)
4829                     == prop_fail_result)
4830                  break;
4831                eptr+= len;
4832                }
4833              break;
4834    
4835              case PT_PXSPACE:  /* POSIX space */
4836              for (i = min; i < max; i++)
4837                {
4838                int len = 1;
4839                if (eptr >= md->end_subject)
4840                  {
4841                  SCHECK_PARTIAL();
4842                  break;
4843                  }
4844                GETCHARLEN(c, eptr, len);
4845                prop_category = UCD_CATEGORY(c);
4846                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4847                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4848                     == prop_fail_result)
4849                  break;
4850                eptr+= len;
4851                }
4852              break;
4853    
4854              case PT_WORD:
4855              for (i = min; i < max; i++)
4856                {
4857                int len = 1;
4858                if (eptr >= md->end_subject)
4859                  {
4860                  SCHECK_PARTIAL();
4861                  break;
4862                  }
4863                GETCHARLEN(c, eptr, len);
4864                prop_category = UCD_CATEGORY(c);
4865                if ((prop_category == ucp_L || prop_category == ucp_N ||
4866                     c == CHAR_UNDERSCORE) == prop_fail_result)
4867                  break;
4868                eptr+= len;
4869                }
4870              break;
4871    
4872              default:
4873              RRETURN(PCRE_ERROR_INTERNAL);
4874            }            }
4875    
4876          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5026  for (;;) Line 5423  for (;;)
5423    
5424        /* Get here if we can't make it match with any permitted repetitions */        /* Get here if we can't make it match with any permitted repetitions */
5425    
5426        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5427        }        }
5428      /* Control never gets here */      /* Control never gets here */
5429    
# Line 5059  switch (frame->Xwhere) Line 5456  switch (frame->Xwhere)
5456    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
5457    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
5458    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
5459    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5460  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5461    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
5462    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
# Line 5268  end_subject = md->end_subject; Line 5665  end_subject = md->end_subject;
5665    
5666  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
5667  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
5668    md->use_ucp = (re->options & PCRE_UCP) != 0;
5669  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
5670    
5671  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
# Line 5277  md->notempty_atstart = (options & PCRE_N Line 5675  md->notempty_atstart = (options & PCRE_N
5675  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5676                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5677  md->hitend = FALSE;  md->hitend = FALSE;
5678    md->mark = NULL;                        /* In case never set */
5679    
5680  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5681    
# Line 5651  for(;;) Line 6050  for(;;)
6050    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
6051    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
6052    md->match_call_count = 0;    md->match_call_count = 0;
6053    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);    rc = match(start_match, md->start_code, start_match, NULL, 2, md, ims, NULL,
6054        0, 0);
6055    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
6056    
6057    switch(rc)    switch(rc)
6058      {      {
6059      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. If MATCH_SKIP_ARG reaches
6060      exactly like PRUNE. */      this level it means that a MARK that matched the SKIP's arg was not found.
6061        We treat this as NOMATCH. THEN at this level acts exactly like PRUNE. */
6062    
6063      case MATCH_NOMATCH:      case MATCH_NOMATCH:
6064      case MATCH_PRUNE:      case MATCH_PRUNE:
6065        case MATCH_SKIP_ARG:
6066      case MATCH_THEN:      case MATCH_THEN:
6067      new_start_match = start_match + 1;      new_start_match = start_match + 1;
6068  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 5721  for(;;) Line 6123  for(;;)
6123           md->nllen == 2))           md->nllen == 2))
6124      start_match++;      start_match++;
6125    
6126    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
6127      }                  /* End of for(;;) "bumpalong" loop */
6128    
6129  /* ==========================================================================*/  /* ==========================================================================*/
6130    
# Line 5745  capturing parentheses than vector slots. Line 6148  capturing parentheses than vector slots.
6148    
6149  ENDLOOP:  ENDLOOP:
6150    
6151  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
6152    {    {
6153    if (using_temporary_offsets)    if (using_temporary_offsets)
6154      {      {
# Line 5776  if (rc == MATCH_MATCH) Line 6179  if (rc == MATCH_MATCH)
6179      }      }
6180    
6181    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6182    return rc;    goto RETURN_MARK;
6183    }    }
6184    
6185  /* Control gets here if there has been an error, or if the overall match  /* Control gets here if there has been an error, or if the overall match
# Line 5788  if (using_temporary_offsets) Line 6191  if (using_temporary_offsets)
6191    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
6192    }    }
6193    
6194    /* For anything other than nomatch or partial match, just return the code. */
6195    
6196  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6197    {    {
6198    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6199    return rc;    return rc;
6200    }    }
6201  else if (start_partial != NULL)  
6202    /* Handle partial matches - disable any mark data */
6203    
6204    if (start_partial != NULL)
6205    {    {
6206    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
6207      md->mark = NULL;
6208    if (offsetcount > 1)    if (offsetcount > 1)
6209      {      {
6210      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = start_partial - (USPTR)subject;
6211      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = end_subject - (USPTR)subject;
6212      }      }
6213    return PCRE_ERROR_PARTIAL;    rc = PCRE_ERROR_PARTIAL;
6214    }    }
6215    
6216    /* This is the classic nomatch case */
6217    
6218  else  else
6219    {    {
6220    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
6221    return PCRE_ERROR_NOMATCH;    rc = PCRE_ERROR_NOMATCH;
6222    }    }
6223    
6224    /* Return the MARK data if it has been requested. */
6225    
6226    RETURN_MARK:
6227    
6228    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6229      *(extra_data->mark) = (unsigned char *)(md->mark);
6230    return rc;
6231  }  }
6232    
6233  /* End of pcre_exec.c */  /* End of pcre_exec.c */

Legend:
Removed from v.482  
changed lines
  Added in v.518

  ViewVC Help
Powered by ViewVC 1.1.5