/[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 473 by ph10, Sat Jan 2 12:40:07 2010 UTC revision 512 by ph10, Tue Mar 30 11:11:52 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 89  static const char rep_max[] = { 0, 0, 0, Line 99  static const char rep_max[] = { 0, 0, 0,
99    
100    
101    
102  #ifdef DEBUG  #ifdef PCRE_DEBUG
103  /*************************************************  /*************************************************
104  *        Debugging function to print chars       *  *        Debugging function to print chars       *
105  *************************************************/  *************************************************/
# Line 141  match_ref(int offset, register USPTR ept Line 151  match_ref(int offset, register USPTR ept
151  {  {
152  USPTR p = md->start_subject + md->offset_vector[offset];  USPTR p = md->start_subject + md->offset_vector[offset];
153    
154  #ifdef DEBUG  #ifdef PCRE_DEBUG
155  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
156    printf("matching subject <null>");    printf("matching subject <null>");
157  else  else
# 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
266    
267  #ifdef DEBUG  #ifdef PCRE_DEBUG
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 622  TAIL_RECURSE: Line 638  TAIL_RECURSE:
638  /* OK, now we can get on with the real code of the function. Recursive calls  /* OK, now we can get on with the real code of the function. Recursive calls
639  are specified by the macro RMATCH and RRETURN is used to return. When  are specified by the macro RMATCH and RRETURN is used to return. When
640  NO_RECURSE is *not* defined, these just turn into a recursive call to match()  NO_RECURSE is *not* defined, these just turn into a recursive call to match()
641  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
642  defined). However, RMATCH isn't like a function call because it's quite a  defined). However, RMATCH isn't like a function call because it's quite a
643  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
644  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# 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 713  for (;;) Line 778  for (;;)
778      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
779      offset = number << 1;      offset = number << 1;
780    
781  #ifdef DEBUG  #ifdef PCRE_DEBUG
782      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
783      printf("subject=");      printf("subject=");
784      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# 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 1039  for (;;) Line 1106  for (;;)
1106      number = GET2(ecode, 1);      number = GET2(ecode, 1);
1107      offset = number << 1;      offset = number << 1;
1108    
1109  #ifdef DEBUG  #ifdef PCRE_DEBUG
1110        printf("end bracket %d at *ACCEPT", number);        printf("end bracket %d at *ACCEPT", number);
1111        printf("\n");        printf("\n");
1112  #endif  #endif
# 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 1134  for (;;) Line 1209  for (;;)
1209      continue;      continue;
1210    
1211      /* Negative assertion: all branches must fail to match. Encountering SKIP,      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1212      PRUNE, or COMMIT means we must assume failure without checking subsequent      PRUNE, or COMMIT means we must assume failure without checking subsequent
1213      branches. */      branches. */
1214    
1215      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
# 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);
1225          break;          break;
1226          }          }
1227        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1228        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1229        }        }
# 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 1468  for (;;) Line 1548  for (;;)
1548        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1549        offset = number << 1;        offset = number << 1;
1550    
1551  #ifdef DEBUG  #ifdef PCRE_DEBUG
1552        printf("end bracket %d", number);        printf("end bracket %d", number);
1553        printf("\n");        printf("\n");
1554  #endif  #endif
# 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 1681  for (;;) Line 1760  for (;;)
1760    
1761        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1762             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1763          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1764        }        }
1765      break;      break;
1766    
1767      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1768    
1769      case OP_ANY:      case OP_ANY:
1770      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1771      /* Fall through */      /* Fall through */
1772    
1773      case OP_ALLANY:      case OP_ALLANY:
1774      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1775        {        {
1776        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1777        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1778        }        }
1779      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1780      ecode++;      ecode++;
# Line 1708  for (;;) Line 1787  for (;;)
1787      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1788        {        {
1789        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1790        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1791        }        }
1792      ecode++;      ecode++;
1793      break;      break;
# Line 1717  for (;;) Line 1796  for (;;)
1796      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1797        {        {
1798        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1799        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1800        }        }
1801      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1802      if (      if (
# Line 1726  for (;;) Line 1805  for (;;)
1805  #endif  #endif
1806         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1807         )         )
1808        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1809      ecode++;      ecode++;
1810      break;      break;
1811    
# Line 1734  for (;;) Line 1813  for (;;)
1813      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1814        {        {
1815        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1816        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1817        }        }
1818      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1819      if (      if (
# Line 1743  for (;;) Line 1822  for (;;)
1822  #endif  #endif
1823         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1824         )         )
1825        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1826      ecode++;      ecode++;
1827      break;      break;
1828    
# Line 1751  for (;;) Line 1830  for (;;)
1830      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1831        {        {
1832        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1833        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1834        }        }
1835      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1836      if (      if (
# Line 1760  for (;;) Line 1839  for (;;)
1839  #endif  #endif
1840         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1841         )         )
1842        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1843      ecode++;      ecode++;
1844      break;      break;
1845    
# Line 1768  for (;;) Line 1847  for (;;)
1847      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1848        {        {
1849        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1850        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1851        }        }
1852      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1853      if (      if (
# Line 1777  for (;;) Line 1856  for (;;)
1856  #endif  #endif
1857         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1858         )         )
1859        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1860      ecode++;      ecode++;
1861      break;      break;
1862    
# Line 1785  for (;;) Line 1864  for (;;)
1864      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1865        {        {
1866        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1867        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1868        }        }
1869      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1870      if (      if (
# Line 1794  for (;;) Line 1873  for (;;)
1873  #endif  #endif
1874         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1875         )         )
1876        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1877      ecode++;      ecode++;
1878      break;      break;
1879    
# Line 1802  for (;;) Line 1881  for (;;)
1881      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1882        {        {
1883        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1884        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1885        }        }
1886      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1887      if (      if (
# Line 1811  for (;;) Line 1890  for (;;)
1890  #endif  #endif
1891         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1892         )         )
1893        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1894      ecode++;      ecode++;
1895      break;      break;
1896    
# Line 1819  for (;;) Line 1898  for (;;)
1898      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1899        {        {
1900        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1901        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1902        }        }
1903      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1904      switch(c)      switch(c)
1905        {        {
1906        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1907        case 0x000d:        case 0x000d:
1908        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1909        break;        break;
# Line 1837  for (;;) Line 1916  for (;;)
1916        case 0x0085:        case 0x0085:
1917        case 0x2028:        case 0x2028:
1918        case 0x2029:        case 0x2029:
1919        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
1920        break;        break;
1921        }        }
1922      ecode++;      ecode++;
# Line 1847  for (;;) Line 1926  for (;;)
1926      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1927        {        {
1928        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1929        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1930        }        }
1931      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1932      switch(c)      switch(c)
# Line 1872  for (;;) Line 1951  for (;;)
1951        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
1952        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1953        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
1954        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1955        }        }
1956      ecode++;      ecode++;
1957      break;      break;
# Line 1881  for (;;) Line 1960  for (;;)
1960      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1961        {        {
1962        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1963        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1964        }        }
1965      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1966      switch(c)      switch(c)
1967        {        {
1968        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1969        case 0x09:      /* HT */        case 0x09:      /* HT */
1970        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
1971        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1915  for (;;) Line 1994  for (;;)
1994      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1995        {        {
1996        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1997        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1998        }        }
1999      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2000      switch(c)      switch(c)
# Line 1928  for (;;) Line 2007  for (;;)
2007        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2008        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2009        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2010        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2011        }        }
2012      ecode++;      ecode++;
2013      break;      break;
# Line 1937  for (;;) Line 2016  for (;;)
2016      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2017        {        {
2018        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2019        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2020        }        }
2021      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2022      switch(c)      switch(c)
2023        {        {
2024        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2025        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2026        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2027        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1964  for (;;) Line 2043  for (;;)
2043      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2044        {        {
2045        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2046        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2047        }        }
2048      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2049        {        {
# Line 1973  for (;;) Line 2052  for (;;)
2052        switch(ecode[1])        switch(ecode[1])
2053          {          {
2054          case PT_ANY:          case PT_ANY:
2055          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2056          break;          break;
2057    
2058          case PT_LAMP:          case PT_LAMP:
2059          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2060               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2061               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2062            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2063           break;           break;
2064    
2065          case PT_GC:          case PT_GC:
2066          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2067            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2068          break;          break;
2069    
2070          case PT_PC:          case PT_PC:
2071          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2072            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2073          break;          break;
2074    
2075          case PT_SC:          case PT_SC:
2076          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2077            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2078          break;          break;
2079    
2080          default:          default:
# Line 2013  for (;;) Line 2092  for (;;)
2092      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2093        {        {
2094        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2095        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2096        }        }
2097      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2098        {        {
2099        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2100        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2101        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2102          {          {
2103          int len = 1;          int len = 1;
# Line 2097  for (;;) Line 2176  for (;;)
2176          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2177            {            {
2178            CHECK_PARTIAL();            CHECK_PARTIAL();
2179            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2180            }            }
2181          eptr += length;          eptr += length;
2182          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 2117  for (;;) Line 2196  for (;;)
2196          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2197            {            {
2198            CHECK_PARTIAL();            CHECK_PARTIAL();
2199            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2200            }            }
2201          eptr += length;          eptr += length;
2202          }          }
# Line 2135  for (;;) Line 2214  for (;;)
2214            {            {
2215            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2216            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2217            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2218            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2219              {              {
2220              CHECK_PARTIAL();              CHECK_PARTIAL();
2221              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2222              }              }
2223            eptr += length;            eptr += length;
2224            }            }
# Line 2166  for (;;) Line 2245  for (;;)
2245            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2246            eptr -= length;            eptr -= length;
2247            }            }
2248          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2249          }          }
2250        }        }
2251      /* Control never gets here */      /* Control never gets here */
# Line 2228  for (;;) Line 2307  for (;;)
2307            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2308              {              {
2309              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2310              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2311              }              }
2312            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2313            if (c > 255)            if (c > 255)
2314              {              {
2315              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2316              }              }
2317            else            else
2318              {              {
2319              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2320              }              }
2321            }            }
2322          }          }
# Line 2250  for (;;) Line 2329  for (;;)
2329            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2330              {              {
2331              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2332              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2333              }              }
2334            c = *eptr++;            c = *eptr++;
2335            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2336            }            }
2337          }          }
2338    
# Line 2275  for (;;) Line 2354  for (;;)
2354              {              {
2355              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2356              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2357              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2358              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2359                {                {
2360                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2361                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2362                }                }
2363              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2364              if (c > 255)              if (c > 255)
2365                {                {
2366                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2367                }                }
2368              else              else
2369                {                {
2370                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2371                }                }
2372              }              }
2373            }            }
# Line 2300  for (;;) Line 2379  for (;;)
2379              {              {
2380              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2381              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2382              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2383              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2384                {                {
2385                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2386                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2387                }                }
2388              c = *eptr++;              c = *eptr++;
2389              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2390              }              }
2391            }            }
2392          /* Control never gets here */          /* Control never gets here */
# Line 2373  for (;;) Line 2452  for (;;)
2452              }              }
2453            }            }
2454    
2455          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2456          }          }
2457        }        }
2458      /* Control never gets here */      /* Control never gets here */
# Line 2425  for (;;) Line 2504  for (;;)
2504          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2505            {            {
2506            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2507            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2508            }            }
2509          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2510          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2511          }          }
2512    
2513        /* 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 2524  for (;;)
2524            {            {
2525            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2526            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2527            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2528            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2529              {              {
2530              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2531              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2532              }              }
2533            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2534            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2535            }            }
2536          /* Control never gets here */          /* Control never gets here */
2537          }          }
# Line 2481  for (;;) Line 2560  for (;;)
2560            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2561            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2562            }            }
2563          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2564          }          }
2565    
2566        /* Control never gets here */        /* Control never gets here */
# Line 2500  for (;;) Line 2579  for (;;)
2579        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2580          {          {
2581          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2582          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2583          }          }
2584        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2585        }        }
2586      else      else
2587  #endif  #endif
# Line 2512  for (;;) Line 2591  for (;;)
2591        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2592          {          {
2593          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2594          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2595          }          }
2596        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2597        ecode += 2;        ecode += 2;
2598        }        }
2599      break;      break;
# Line 2532  for (;;) Line 2611  for (;;)
2611        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2612          {          {
2613          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2614          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2615          }          }
2616    
2617        /* 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 2619  for (;;)
2619    
2620        if (fc < 128)        if (fc < 128)
2621          {          {
2622          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2623          }          }
2624    
2625        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2559  for (;;) Line 2638  for (;;)
2638  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2639            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2640  #endif  #endif
2641              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2642            }            }
2643          }          }
2644        }        }
# Line 2571  for (;;) Line 2650  for (;;)
2650        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2651          {          {
2652          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2653          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2654          }          }
2655        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2656        ecode += 2;        ecode += 2;
2657        }        }
2658      break;      break;
# Line 2667  for (;;) Line 2746  for (;;)
2746            else            else
2747              {              {
2748              CHECK_PARTIAL();              CHECK_PARTIAL();
2749              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2750              }              }
2751            }            }
2752    
# Line 2679  for (;;) Line 2758  for (;;)
2758              {              {
2759              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2760              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2761              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2762              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2763                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2764  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2690  for (;;) Line 2769  for (;;)
2769              else              else
2770                {                {
2771                CHECK_PARTIAL();                CHECK_PARTIAL();
2772                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2773                }                }
2774              }              }
2775            /* Control never gets here */            /* Control never gets here */
# Line 2721  for (;;) Line 2800  for (;;)
2800              {              {
2801              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2802              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2803              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2804  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2805              eptr--;              eptr--;
2806              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2764  for (;;) Line 2843  for (;;)
2843          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2844            {            {
2845            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2846            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2847            }            }
2848          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2849          }          }
2850        if (min == max) continue;        if (min == max) continue;
2851        if (minimize)        if (minimize)
# Line 2775  for (;;) Line 2854  for (;;)
2854            {            {
2855            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2856            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2857            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2858            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2859              {              {
2860              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2861              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2862              }              }
2863            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2864            }            }
2865          /* Control never gets here */          /* Control never gets here */
2866          }          }
# Line 2807  for (;;) Line 2886  for (;;)
2886            eptr--;            eptr--;
2887            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2888            }            }
2889          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2890          }          }
2891        /* Control never gets here */        /* Control never gets here */
2892        }        }
# Line 2821  for (;;) Line 2900  for (;;)
2900          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2901            {            {
2902            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2903            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2904            }            }
2905          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2906          }          }
2907    
2908        if (min == max) continue;        if (min == max) continue;
# Line 2834  for (;;) Line 2913  for (;;)
2913            {            {
2914            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2915            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2916            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2917            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2918              {              {
2919              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2920              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2921              }              }
2922            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2923            }            }
2924          /* Control never gets here */          /* Control never gets here */
2925          }          }
# Line 2865  for (;;) Line 2944  for (;;)
2944            eptr--;            eptr--;
2945            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2946            }            }
2947          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2948          }          }
2949        }        }
2950      /* Control never gets here */      /* Control never gets here */
# Line 2877  for (;;) Line 2956  for (;;)
2956      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2957        {        {
2958        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2959        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2960        }        }
2961      ecode++;      ecode++;
2962      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2887  for (;;) Line 2966  for (;;)
2966        if (c < 256)        if (c < 256)
2967  #endif  #endif
2968        c = md->lcc[c];        c = md->lcc[c];
2969        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
2970        }        }
2971      else      else
2972        {        {
2973        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
2974        }        }
2975      break;      break;
2976    
# Line 2985  for (;;) Line 3064  for (;;)
3064            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3065              {              {
3066              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3067              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3068              }              }
3069            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3070            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3071            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3072            }            }
3073          }          }
3074        else        else
# Line 3002  for (;;) Line 3081  for (;;)
3081            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3082              {              {
3083              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3084              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3085              }              }
3086            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3087            }            }
3088          }          }
3089    
# Line 3021  for (;;) Line 3100  for (;;)
3100              {              {
3101              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3102              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3103              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3104              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3105                {                {
3106                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3107                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3108                }                }
3109              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3110              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3111              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3112              }              }
3113            }            }
3114          else          else
# Line 3040  for (;;) Line 3119  for (;;)
3119              {              {
3120              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3121              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3122              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3123              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3124                {                {
3125                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3126                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3127                }                }
3128              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3129              }              }
3130            }            }
3131          /* Control never gets here */          /* Control never gets here */
# Line 3108  for (;;) Line 3187  for (;;)
3187              }              }
3188            }            }
3189    
3190          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3191          }          }
3192        /* Control never gets here */        /* Control never gets here */
3193        }        }
# Line 3127  for (;;) Line 3206  for (;;)
3206            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3207              {              {
3208              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3209              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3210              }              }
3211            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3212            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3213            }            }
3214          }          }
3215        else        else
# Line 3142  for (;;) Line 3221  for (;;)
3221            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3222              {              {
3223              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3224              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3225              }              }
3226            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3227            }            }
3228          }          }
3229    
# Line 3161  for (;;) Line 3240  for (;;)
3240              {              {
3241              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3242              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3243              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3244              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3245                {                {
3246                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3247                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3248                }                }
3249              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3250              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3251              }              }
3252            }            }
3253          else          else
# Line 3179  for (;;) Line 3258  for (;;)
3258              {              {
3259              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3260              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3261              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3262              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3263                {                {
3264                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3265                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3266                }                }
3267              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3268              }              }
3269            }            }
3270          /* Control never gets here */          /* Control never gets here */
# Line 3246  for (;;) Line 3325  for (;;)
3325              }              }
3326            }            }
3327    
3328          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3329          }          }
3330        }        }
3331      /* Control never gets here */      /* Control never gets here */
# Line 3340  for (;;) Line 3419  for (;;)
3419          switch(prop_type)          switch(prop_type)
3420            {            {
3421            case PT_ANY:            case PT_ANY:
3422            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3423            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3424              {              {
3425              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3426                {                {
3427                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3428                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3429                }                }
3430              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3431              }              }
# Line 3358  for (;;) Line 3437  for (;;)
3437              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3438                {                {
3439                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3440                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3441                }                }
3442              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3443              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3444              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3445                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3446                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3447                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3448              }              }
3449            break;            break;
3450    
# Line 3375  for (;;) Line 3454  for (;;)
3454              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3455                {                {
3456                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3457                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3458                }                }
3459              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3460              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3461              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3462                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3463              }              }
3464            break;            break;
3465    
# Line 3390  for (;;) Line 3469  for (;;)
3469              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3470                {                {
3471                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3472                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3473                }                }
3474              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3475              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3476              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3477                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3478              }              }
3479            break;            break;
3480    
# Line 3405  for (;;) Line 3484  for (;;)
3484              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3485                {                {
3486                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3487                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3488                }                }
3489              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3490              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3491              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3492                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3493              }              }
3494            break;            break;
3495    
# Line 3429  for (;;) Line 3508  for (;;)
3508            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3509              {              {
3510              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3511              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3512              }              }
3513            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3514            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3515            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3516            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3517              {              {
3518              int len = 1;              int len = 1;
# Line 3460  for (;;) Line 3539  for (;;)
3539            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3540              {              {
3541              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3542              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3543              }              }
3544            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3545            eptr++;            eptr++;
3546            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3547            }            }
# Line 3474  for (;;) Line 3553  for (;;)
3553            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3554              {              {
3555              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3556              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3557              }              }
3558            eptr++;            eptr++;
3559            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3482  for (;;) Line 3561  for (;;)
3561          break;          break;
3562    
3563          case OP_ANYBYTE:          case OP_ANYBYTE:
3564          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3565          eptr += min;          eptr += min;
3566          break;          break;
3567    
# Line 3492  for (;;) Line 3571  for (;;)
3571            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3572              {              {
3573              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3574              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3575              }              }
3576            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3577            switch(c)            switch(c)
3578              {              {
3579              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3580              case 0x000d:              case 0x000d:
3581              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3582              break;              break;
# Line 3510  for (;;) Line 3589  for (;;)
3589              case 0x0085:              case 0x0085:
3590              case 0x2028:              case 0x2028:
3591              case 0x2029:              case 0x2029:
3592              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3593              break;              break;
3594              }              }
3595            }            }
# Line 3522  for (;;) Line 3601  for (;;)
3601            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3602              {              {
3603              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3604              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3605              }              }
3606            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3607            switch(c)            switch(c)
# Line 3547  for (;;) Line 3626  for (;;)
3626              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3627              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3628              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3629              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3630              }              }
3631            }            }
3632          break;          break;
# Line 3558  for (;;) Line 3637  for (;;)
3637            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3638              {              {
3639              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3640              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3641              }              }
3642            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3643            switch(c)            switch(c)
3644              {              {
3645              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3646              case 0x09:      /* HT */              case 0x09:      /* HT */
3647              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3648              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3594  for (;;) Line 3673  for (;;)
3673            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3674              {              {
3675              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3676              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3677              }              }
3678            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3679            switch(c)            switch(c)
# Line 3607  for (;;) Line 3686  for (;;)
3686              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3687              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3688              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3689              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3690              }              }
3691            }            }
3692          break;          break;
# Line 3618  for (;;) Line 3697  for (;;)
3697            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3698              {              {
3699              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3700              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3701              }              }
3702            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3703            switch(c)            switch(c)
3704              {              {
3705              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3706              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3707              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3708              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3642  for (;;) Line 3721  for (;;)
3721            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3722              {              {
3723              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3724              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3725              }              }
3726            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3727            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3728              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3729            }            }
3730          break;          break;
3731    
# Line 3656  for (;;) Line 3735  for (;;)
3735            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3736              {              {
3737              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3738              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3739              }              }
3740            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3741              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3742            /* 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 */
3743            }            }
3744          break;          break;
# Line 3670  for (;;) Line 3749  for (;;)
3749            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3750              {              {
3751              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3752              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3753              }              }
3754            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3755              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3756            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3757            }            }
3758          break;          break;
# Line 3684  for (;;) Line 3763  for (;;)
3763            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3764              {              {
3765              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3766              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3767              }              }
3768            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3769              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3770            /* 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 */
3771            }            }
3772          break;          break;
# Line 3695  for (;;) Line 3774  for (;;)
3774          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3775          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3776            {            {
3777            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3778               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3779              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3780                MRRETURN(MATCH_NOMATCH);
3781                }
3782              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3783                MRRETURN(MATCH_NOMATCH);
3784            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3785            }            }
3786          break;          break;
# Line 3708  for (;;) Line 3791  for (;;)
3791            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3792              {              {
3793              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3794              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3795              }              }
3796            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3797              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3798            /* 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 */
3799            }            }
3800          break;          break;
# Line 3734  for (;;) Line 3817  for (;;)
3817            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3818              {              {
3819              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3820              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3821              }              }
3822            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3823            eptr++;            eptr++;
3824            }            }
3825          break;          break;
# Line 3745  for (;;) Line 3828  for (;;)
3828          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3829            {            {
3830            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3831            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3832            }            }
3833          eptr += min;          eptr += min;
3834          break;          break;
# Line 3754  for (;;) Line 3837  for (;;)
3837          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3838            {            {
3839            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3840            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3841            }            }
3842          eptr += min;          eptr += min;
3843          break;          break;
# Line 3765  for (;;) Line 3848  for (;;)
3848            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3849              {              {
3850              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3851              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3852              }              }
3853            switch(*eptr++)            switch(*eptr++)
3854              {              {
3855              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3856              case 0x000d:              case 0x000d:
3857              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3858              break;              break;
# Line 3779  for (;;) Line 3862  for (;;)
3862              case 0x000b:              case 0x000b:
3863              case 0x000c:              case 0x000c:
3864              case 0x0085:              case 0x0085:
3865              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3866              break;              break;
3867              }              }
3868            }            }
# Line 3791  for (;;) Line 3874  for (;;)
3874            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3875              {              {
3876              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3877              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3878              }              }
3879            switch(*eptr++)            switch(*eptr++)
3880              {              {
# Line 3799  for (;;) Line 3882  for (;;)
3882              case 0x09:      /* HT */              case 0x09:      /* HT */
3883              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3884              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
3885              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3886              }              }
3887            }            }
3888          break;          break;
# Line 3810  for (;;) Line 3893  for (;;)
3893            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3894              {              {
3895              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3896              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3897              }              }
3898            switch(*eptr++)            switch(*eptr++)
3899              {              {
3900              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3901              case 0x09:      /* HT */              case 0x09:      /* HT */
3902              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3903              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3829  for (;;) Line 3912  for (;;)
3912            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3913              {              {
3914              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3915              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3916              }              }
3917            switch(*eptr++)            switch(*eptr++)
3918              {              {
# Line 3839  for (;;) Line 3922  for (;;)
3922              case 0x0c:      /* FF */              case 0x0c:      /* FF */
3923              case 0x0d:      /* CR */              case 0x0d:      /* CR */
3924              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3925              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3926              }              }
3927            }            }
3928          break;          break;
# Line 3850  for (;;) Line 3933  for (;;)
3933            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3934              {              {
3935              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3936              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3937              }              }
3938            switch(*eptr++)            switch(*eptr++)
3939              {              {
3940              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3941              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3942              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3943              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3871  for (;;) Line 3954  for (;;)
3954            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3955              {              {
3956              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3957              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3958              }              }
3959            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
3960            }            }
3961          break;          break;
3962    
# Line 3883  for (;;) Line 3966  for (;;)
3966            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3967              {              {
3968              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3969              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3970              }              }
3971            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
3972            }            }
3973          break;          break;
3974    
# Line 3895  for (;;) Line 3978  for (;;)
3978            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3979              {              {
3980              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3981              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3982              }              }
3983            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
3984            }            }
3985          break;          break;
3986    
# Line 3907  for (;;) Line 3990  for (;;)
3990            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3991              {              {
3992              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3993              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3994              }              }
3995            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
3996            }            }
3997          break;          break;
3998    
# Line 3919  for (;;) Line 4002  for (;;)
4002            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4003              {              {
4004              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4005              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4006              }              }
4007            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4008              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4009            }            }
4010          break;          break;
4011    
# Line 3932  for (;;) Line 4015  for (;;)
4015            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4016              {              {
4017              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4018              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4019              }              }
4020            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4021              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4022            }            }
4023          break;          break;
4024    
# Line 3964  for (;;) Line 4047  for (;;)
4047              {              {
4048              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4049              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4050              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4051              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4052                {                {
4053                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4054                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4055                }                }
4056              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4057              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4058              }              }
4059            /* Control never gets here */            /* Control never gets here */
4060    
# Line 3980  for (;;) Line 4063  for (;;)
4063              {              {
4064              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4065              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4066              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4067              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4068                {                {
4069                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4070                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4071                }                }
4072              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4073              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4074              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4075                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4076                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4077                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4078              }              }
4079            /* Control never gets here */            /* Control never gets here */
4080    
# Line 4000  for (;;) Line 4083  for (;;)
4083              {              {
4084              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4085              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4086              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4087              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4088                {                {
4089                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4090                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4091                }                }
4092              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4093              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4094              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4095                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4096              }              }
4097            /* Control never gets here */            /* Control never gets here */
4098    
# Line 4018  for (;;) Line 4101  for (;;)
4101              {              {
4102              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4103              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4104              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4105              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4106                {                {
4107                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4108                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4109                }                }
4110              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4111              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4112              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4113                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4114              }              }
4115            /* Control never gets here */            /* Control never gets here */
4116    
# Line 4036  for (;;) Line 4119  for (;;)
4119              {              {
4120              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4121              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4122              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4123              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4124                {                {
4125                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4126                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4127                }                }
4128              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4129              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4130              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4131                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4132              }              }
4133            /* Control never gets here */            /* Control never gets here */
4134    
# Line 4063  for (;;) Line 4146  for (;;)
4146            {            {
4147            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4148            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4149            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4150            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4151              {              {
4152              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4153              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4154              }              }
4155            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4156            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4157            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4158            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4159              {              {
4160              int len = 1;              int len = 1;
# Line 4095  for (;;) Line 4178  for (;;)
4178            {            {
4179            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4180            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4181            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4182            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4183              {              {
4184              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4185              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4186              }              }
4187            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4188              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4189            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4190            switch(ctype)            switch(ctype)
4191              {              {
# Line 4114  for (;;) Line 4197  for (;;)
4197              case OP_ANYNL:              case OP_ANYNL:
4198              switch(c)              switch(c)
4199                {                {
4200                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4201                case 0x000d:                case 0x000d:
4202                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4203                break;                break;
# Line 4126  for (;;) Line 4209  for (;;)
4209                case 0x0085:                case 0x0085:
4210                case 0x2028:                case 0x2028:
4211                case 0x2029:                case 0x2029:
4212                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4213                break;                break;
4214                }                }
4215              break;              break;
# Line 4154  for (;;) Line 4237  for (;;)
4237                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4238                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4239                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4240                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4241                }                }
4242              break;              break;
4243    
4244              case OP_HSPACE:              case OP_HSPACE:
4245              switch(c)              switch(c)
4246                {                {
4247                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4248                case 0x09:      /* HT */                case 0x09:      /* HT */
4249                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4250                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4196  for (;;) Line 4279  for (;;)
4279                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4280                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4281                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4282                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4283                }                }
4284              break;              break;
4285    
4286              case OP_VSPACE:              case OP_VSPACE:
4287              switch(c)              switch(c)
4288                {                {
4289                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4290                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4291                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4292                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4217  for (;;) Line 4300  for (;;)
4300    
4301              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4302              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4303                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4304              break;              break;
4305    
4306              case OP_DIGIT:              case OP_DIGIT:
4307              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4308                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4309              break;              break;
4310    
4311              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4312              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4313                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4314              break;              break;
4315    
4316              case OP_WHITESPACE:              case OP_WHITESPACE:
4317              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4318                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4319              break;              break;
4320    
4321              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4322              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4323                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4324              break;              break;
4325    
4326              case OP_WORDCHAR:              case OP_WORDCHAR:
4327              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4328                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4329              break;              break;
4330    
4331              default:              default:
# Line 4258  for (;;) Line 4341  for (;;)
4341            {            {
4342            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4343            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4344            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4345            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4346              {              {
4347              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4348              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4349              }              }
4350            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4351              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4352            c = *eptr++;            c = *eptr++;
4353            switch(ctype)            switch(ctype)
4354              {              {
# Line 4277  for (;;) Line 4360  for (;;)
4360              case OP_ANYNL:              case OP_ANYNL:
4361              switch(c)              switch(c)
4362                {                {
4363                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4364                case 0x000d:                case 0x000d:
4365                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4366                break;                break;
# Line 4288  for (;;) Line 4371  for (;;)
4371                case 0x000b:                case 0x000b:
4372                case 0x000c:                case 0x000c:
4373                case 0x0085:                case 0x0085:
4374                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4375                break;                break;
4376                }                }
4377              break;              break;
# Line 4300  for (;;) Line 4383  for (;;)
4383                case 0x09:      /* HT */                case 0x09:      /* HT */
4384                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4385                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4386                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4387                }                }
4388              break;              break;
4389    
4390              case OP_HSPACE:              case OP_HSPACE:
4391              switch(c)              switch(c)
4392                {                {
4393                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4394                case 0x09:      /* HT */                case 0x09:      /* HT */
4395                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4396                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4324  for (;;) Line 4407  for (;;)
4407                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4408                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4409                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4410                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4411                }                }
4412              break;              break;
4413    
4414              case OP_VSPACE:              case OP_VSPACE:
4415              switch(c)              switch(c)
4416                {                {
4417                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4418                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4419                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4420                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4342  for (;;) Line 4425  for (;;)
4425              break;              break;
4426    
4427              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4428              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4429              break;              break;
4430    
4431              case OP_DIGIT:              case OP_DIGIT:
4432              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4433              break;              break;
4434    
4435              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4436              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4437              break;              break;
4438    
4439              case OP_WHITESPACE:              case OP_WHITESPACE:
4440              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4441              break;              break;
4442    
4443              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4444              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4445              break;              break;
4446    
4447              case OP_WORDCHAR:              case OP_WORDCHAR:
4448              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4449              break;              break;
4450    
4451              default:              default:
# Line 5022  for (;;) Line 5105  for (;;)
5105    
5106        /* 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 */
5107    
5108        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5109        }        }
5110      /* Control never gets here */      /* Control never gets here */
5111    
# Line 5055  switch (frame->Xwhere) Line 5138  switch (frame->Xwhere)
5138    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)
5139    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)
5140    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)
5141    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5142  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5143    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)
5144    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
# Line 5273  md->notempty_atstart = (options & PCRE_N Line 5356  md->notempty_atstart = (options & PCRE_N
5356  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5357                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5358  md->hitend = FALSE;  md->hitend = FALSE;
5359    md->mark = NULL;                        /* In case never set */
5360    
5361  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5362    
# Line 5572  for(;;) Line 5656  for(;;)
5656      bytes to avoid spending too much time in this optimization. */      bytes to avoid spending too much time in this optimization. */
5657    
5658      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5659          end_subject - start_match < study->minlength)          (pcre_uint32)(end_subject - start_match) < study->minlength)
5660        {        {
5661        rc = MATCH_NOMATCH;        rc = MATCH_NOMATCH;
5662        break;        break;
# Line 5635  for(;;) Line 5719  for(;;)
5719        }        }
5720      }      }
5721    
5722  #ifdef DEBUG  /* Sigh. Some compilers never learn. */  #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
5723    printf(">>>> Match against: ");    printf(">>>> Match against: ");
5724    pchars(start_match, end_subject - start_match, TRUE, md);    pchars(start_match, end_subject - start_match, TRUE, md);
5725    printf("\n");    printf("\n");
# Line 5647  for(;;) Line 5731  for(;;)
5731    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5732    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
5733    md->match_call_count = 0;    md->match_call_count = 0;
5734    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,
5735        0, 0);
5736    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
5737    
5738    switch(rc)    switch(rc)
5739      {      {
5740      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. If MATCH_SKIP_ARG reaches
5741      exactly like PRUNE. */      this level it means that a MARK that matched the SKIP's arg was not found.
5742        We treat this as NOMATCH. THEN at this level acts exactly like PRUNE. */
5743    
5744      case MATCH_NOMATCH:      case MATCH_NOMATCH:
5745      case MATCH_PRUNE:      case MATCH_PRUNE:
5746        case MATCH_SKIP_ARG:
5747      case MATCH_THEN:      case MATCH_THEN:
5748      new_start_match = start_match + 1;      new_start_match = start_match + 1;
5749  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 5717  for(;;) Line 5804  for(;;)
5804           md->nllen == 2))           md->nllen == 2))
5805      start_match++;      start_match++;
5806    
5807    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
5808      }                  /* End of for(;;) "bumpalong" loop */
5809    
5810  /* ==========================================================================*/  /* ==========================================================================*/
5811    
# Line 5741  capturing parentheses than vector slots. Line 5829  capturing parentheses than vector slots.
5829    
5830  ENDLOOP:  ENDLOOP:
5831    
5832  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
5833    {    {
5834    if (using_temporary_offsets)    if (using_temporary_offsets)
5835      {      {
# Line 5772  if (rc == MATCH_MATCH) Line 5860  if (rc == MATCH_MATCH)
5860      }      }
5861    
5862    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
5863    return rc;    goto RETURN_MARK;
5864    }    }
5865    
5866  /* 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 5784  if (using_temporary_offsets) Line 5872  if (using_temporary_offsets)
5872    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
5873    }    }
5874    
5875    /* For anything other than nomatch or partial match, just return the code. */
5876    
5877  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
5878    {    {
5879    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
5880    return rc;    return rc;
5881    }    }
5882  else if (start_partial != NULL)  
5883    /* Handle partial matches - disable any mark data */
5884    
5885    if (start_partial != NULL)
5886    {    {
5887    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
5888      md->mark = NULL;
5889    if (offsetcount > 1)    if (offsetcount > 1)
5890      {      {
5891      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = start_partial - (USPTR)subject;
5892      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = end_subject - (USPTR)subject;
5893      }      }
5894    return PCRE_ERROR_PARTIAL;    rc = PCRE_ERROR_PARTIAL;
5895    }    }
5896    
5897    /* This is the classic nomatch case */
5898    
5899  else  else
5900    {    {
5901    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
5902    return PCRE_ERROR_NOMATCH;    rc = PCRE_ERROR_NOMATCH;
5903    }    }
5904    
5905    /* Return the MARK data if it has been requested. */
5906    
5907    RETURN_MARK:
5908    
5909    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
5910      *(extra_data->mark) = (unsigned char *)(md->mark);
5911    return rc;
5912  }  }
5913    
5914  /* End of pcre_exec.c */  /* End of pcre_exec.c */

Legend:
Removed from v.473  
changed lines
  Added in v.512

  ViewVC Help
Powered by ViewVC 1.1.5