/[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 517 by ph10, Wed May 5 10:44:20 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            /* These are specials */
2081    
2082            case PT_ALNUM:
2083            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2084                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2085              MRRETURN(MATCH_NOMATCH);
2086            break;
2087    
2088            case PT_SPACE:    /* Perl space */
2089            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2090                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2091                   == (op == OP_NOTPROP))
2092              MRRETURN(MATCH_NOMATCH);
2093            break;
2094    
2095            case PT_PXSPACE:  /* POSIX space */
2096            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2097                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2098                 c == CHAR_FF || c == CHAR_CR)
2099                   == (op == OP_NOTPROP))
2100              MRRETURN(MATCH_NOMATCH);
2101            break;
2102    
2103            case PT_WORD:
2104            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2105                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2106                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2107              MRRETURN(MATCH_NOMATCH);
2108            break;
2109    
2110            /* This should never occur */
2111    
2112          default:          default:
2113          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
# Line 2013  for (;;) Line 2124  for (;;)
2124      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2125        {        {
2126        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2127        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2128        }        }
2129      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2130        {        {
2131        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2132        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2133        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2134          {          {
2135          int len = 1;          int len = 1;
# Line 2097  for (;;) Line 2208  for (;;)
2208          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2209            {            {
2210            CHECK_PARTIAL();            CHECK_PARTIAL();
2211            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2212            }            }
2213          eptr += length;          eptr += length;
2214          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 2117  for (;;) Line 2228  for (;;)
2228          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2229            {            {
2230            CHECK_PARTIAL();            CHECK_PARTIAL();
2231            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2232            }            }
2233          eptr += length;          eptr += length;
2234          }          }
# Line 2135  for (;;) Line 2246  for (;;)
2246            {            {
2247            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2248            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2249            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2250            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2251              {              {
2252              CHECK_PARTIAL();              CHECK_PARTIAL();
2253              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2254              }              }
2255            eptr += length;            eptr += length;
2256            }            }
# Line 2166  for (;;) Line 2277  for (;;)
2277            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2278            eptr -= length;            eptr -= length;
2279            }            }
2280          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2281          }          }
2282        }        }
2283      /* Control never gets here */      /* Control never gets here */
# Line 2228  for (;;) Line 2339  for (;;)
2339            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2340              {              {
2341              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2342              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2343              }              }
2344            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2345            if (c > 255)            if (c > 255)
2346              {              {
2347              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2348              }              }
2349            else            else
2350              {              {
2351              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2352              }              }
2353            }            }
2354          }          }
# Line 2250  for (;;) Line 2361  for (;;)
2361            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2362              {              {
2363              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2364              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2365              }              }
2366            c = *eptr++;            c = *eptr++;
2367            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2368            }            }
2369          }          }
2370    
# Line 2275  for (;;) Line 2386  for (;;)
2386              {              {
2387              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2388              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2389              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2390              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2391                {                {
2392                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2393                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2394                }                }
2395              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2396              if (c > 255)              if (c > 255)
2397                {                {
2398                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2399                }                }
2400              else              else
2401                {                {
2402                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2403                }                }
2404              }              }
2405            }            }
# Line 2300  for (;;) Line 2411  for (;;)
2411              {              {
2412              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2413              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2414              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2415              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2416                {                {
2417                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2418                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2419                }                }
2420              c = *eptr++;              c = *eptr++;
2421              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2422              }              }
2423            }            }
2424          /* Control never gets here */          /* Control never gets here */
# Line 2373  for (;;) Line 2484  for (;;)
2484              }              }
2485            }            }
2486    
2487          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2488          }          }
2489        }        }
2490      /* Control never gets here */      /* Control never gets here */
# Line 2425  for (;;) Line 2536  for (;;)
2536          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2537            {            {
2538            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2539            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2540            }            }
2541          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2542          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2543          }          }
2544    
2545        /* 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 2556  for (;;)
2556            {            {
2557            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2558            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2559            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2560            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2561              {              {
2562              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2563              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2564              }              }
2565            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2566            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2567            }            }
2568          /* Control never gets here */          /* Control never gets here */
2569          }          }
# Line 2481  for (;;) Line 2592  for (;;)
2592            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2593            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2594            }            }
2595          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2596          }          }
2597    
2598        /* Control never gets here */        /* Control never gets here */
# Line 2500  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        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2617        }        }
2618      else      else
2619  #endif  #endif
# Line 2512  for (;;) Line 2623  for (;;)
2623        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2624          {          {
2625          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2626          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2627          }          }
2628        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2629        ecode += 2;        ecode += 2;
2630        }        }
2631      break;      break;
# Line 2532  for (;;) Line 2643  for (;;)
2643        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2644          {          {
2645          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2646          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2647          }          }
2648    
2649        /* 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 2651  for (;;)
2651    
2652        if (fc < 128)        if (fc < 128)
2653          {          {
2654          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2655          }          }
2656    
2657        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2559  for (;;) Line 2670  for (;;)
2670  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2671            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2672  #endif  #endif
2673              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2674            }            }
2675          }          }
2676        }        }
# Line 2571  for (;;) Line 2682  for (;;)
2682        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2683          {          {
2684          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2685          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2686          }          }
2687        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2688        ecode += 2;        ecode += 2;
2689        }        }
2690      break;      break;
# Line 2667  for (;;) Line 2778  for (;;)
2778            else            else
2779              {              {
2780              CHECK_PARTIAL();              CHECK_PARTIAL();
2781              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2782              }              }
2783            }            }
2784    
# Line 2679  for (;;) Line 2790  for (;;)
2790              {              {
2791              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2792              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2793              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2794              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2795                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2796  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2690  for (;;) Line 2801  for (;;)
2801              else              else
2802                {                {
2803                CHECK_PARTIAL();                CHECK_PARTIAL();
2804                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2805                }                }
2806              }              }
2807            /* Control never gets here */            /* Control never gets here */
# Line 2721  for (;;) Line 2832  for (;;)
2832              {              {
2833              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2834              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2835              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2836  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2837              eptr--;              eptr--;
2838              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2764  for (;;) Line 2875  for (;;)
2875          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2876            {            {
2877            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2878            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2879            }            }
2880          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2881          }          }
2882        if (min == max) continue;        if (min == max) continue;
2883        if (minimize)        if (minimize)
# Line 2775  for (;;) Line 2886  for (;;)
2886            {            {
2887            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2888            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2889            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2890            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2891              {              {
2892              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2893              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2894              }              }
2895            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2896            }            }
2897          /* Control never gets here */          /* Control never gets here */
2898          }          }
# Line 2807  for (;;) Line 2918  for (;;)
2918            eptr--;            eptr--;
2919            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2920            }            }
2921          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2922          }          }
2923        /* Control never gets here */        /* Control never gets here */
2924        }        }
# Line 2821  for (;;) Line 2932  for (;;)
2932          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2933            {            {
2934            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2935            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2936            }            }
2937          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2938          }          }
2939    
2940        if (min == max) continue;        if (min == max) continue;
# Line 2834  for (;;) Line 2945  for (;;)
2945            {            {
2946            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2947            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2948            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2949            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2950              {              {
2951              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2952              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2953              }              }
2954            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2955            }            }
2956          /* Control never gets here */          /* Control never gets here */
2957          }          }
# Line 2865  for (;;) Line 2976  for (;;)
2976            eptr--;            eptr--;
2977            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2978            }            }
2979          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2980          }          }
2981        }        }
2982      /* Control never gets here */      /* Control never gets here */
# Line 2877  for (;;) Line 2988  for (;;)
2988      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2989        {        {
2990        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2991        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2992        }        }
2993      ecode++;      ecode++;
2994      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2887  for (;;) Line 2998  for (;;)
2998        if (c < 256)        if (c < 256)
2999  #endif  #endif
3000        c = md->lcc[c];        c = md->lcc[c];
3001        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3002        }        }
3003      else      else
3004        {        {
3005        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3006        }        }
3007      break;      break;
3008    
# Line 2985  for (;;) Line 3096  for (;;)
3096            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3097              {              {
3098              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3099              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3100              }              }
3101            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3102            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3103            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3104            }            }
3105          }          }
3106        else        else
# Line 3002  for (;;) Line 3113  for (;;)
3113            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3114              {              {
3115              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3116              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3117              }              }
3118            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3119            }            }
3120          }          }
3121    
# Line 3021  for (;;) Line 3132  for (;;)
3132              {              {
3133              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3134              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3135              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3136              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3137                {                {
3138                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3139                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3140                }                }
3141              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3142              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3143              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3144              }              }
3145            }            }
3146          else          else
# Line 3040  for (;;) Line 3151  for (;;)
3151              {              {
3152              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3153              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3154              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3155              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3156                {                {
3157                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3158                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3159                }                }
3160              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3161              }              }
3162            }            }
3163          /* Control never gets here */          /* Control never gets here */
# Line 3108  for (;;) Line 3219  for (;;)
3219              }              }
3220            }            }
3221    
3222          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3223          }          }
3224        /* Control never gets here */        /* Control never gets here */
3225        }        }
# Line 3127  for (;;) Line 3238  for (;;)
3238            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3239              {              {
3240              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3241              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3242              }              }
3243            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3244            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3245            }            }
3246          }          }
3247        else        else
# Line 3142  for (;;) Line 3253  for (;;)
3253            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3254              {              {
3255              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3256              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3257              }              }
3258            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3259            }            }
3260          }          }
3261    
# Line 3161  for (;;) Line 3272  for (;;)
3272              {              {
3273              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3274              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3275              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3276              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3277                {                {
3278                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3279                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3280                }                }
3281              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3282              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3283              }              }
3284            }            }
3285          else          else
# Line 3179  for (;;) Line 3290  for (;;)
3290              {              {
3291              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3292              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3293              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3294              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3295                {                {
3296                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3297                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3298                }                }
3299              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3300              }              }
3301            }            }
3302          /* Control never gets here */          /* Control never gets here */
# Line 3246  for (;;) Line 3357  for (;;)
3357              }              }
3358            }            }
3359    
3360          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3361          }          }
3362        }        }
3363      /* Control never gets here */      /* Control never gets here */
# Line 3340  for (;;) Line 3451  for (;;)
3451          switch(prop_type)          switch(prop_type)
3452            {            {
3453            case PT_ANY:            case PT_ANY:
3454            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3455            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3456              {              {
3457              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3458                {                {
3459                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3460                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3461                }                }
3462              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3463              }              }
# Line 3358  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 == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3477                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3478                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3479                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3480              }              }
3481            break;            break;
3482    
# Line 3375  for (;;) Line 3486  for (;;)
3486              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3487                {                {
3488                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3489                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3490                }                }
3491              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3492              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3493              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3494                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3495              }              }
3496            break;            break;
3497    
# Line 3390  for (;;) Line 3501  for (;;)
3501              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3502                {                {
3503                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3504                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3505                }                }
3506              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3507              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3508              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3509                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3510              }              }
3511            break;            break;
3512    
# Line 3405  for (;;) Line 3516  for (;;)
3516              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3517                {                {
3518                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3519                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3520                }                }
3521              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3522              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3523              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3524                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3525                }
3526              break;
3527    
3528              case PT_ALNUM:
3529              for (i = 1; i <= min; i++)
3530                {
3531                if (eptr >= md->end_subject)
3532                  {
3533                  SCHECK_PARTIAL();
3534                  MRRETURN(MATCH_NOMATCH);
3535                  }
3536                GETCHARINCTEST(c, eptr);
3537                prop_category = UCD_CATEGORY(c);
3538                if ((prop_category == ucp_L || prop_category == ucp_N)
3539                       == prop_fail_result)
3540                  MRRETURN(MATCH_NOMATCH);
3541                }
3542              break;
3543    
3544              case PT_SPACE:    /* Perl space */
3545              for (i = 1; i <= min; i++)
3546                {
3547                if (eptr >= md->end_subject)
3548                  {
3549                  SCHECK_PARTIAL();
3550                  MRRETURN(MATCH_NOMATCH);
3551                  }
3552                GETCHARINCTEST(c, eptr);
3553                prop_category = UCD_CATEGORY(c);
3554                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3555                     c == CHAR_FF || c == CHAR_CR)
3556                       == prop_fail_result)
3557                  MRRETURN(MATCH_NOMATCH);
3558              }              }
3559            break;            break;
3560    
3561              case PT_PXSPACE:  /* POSIX space */
3562              for (i = 1; i <= min; i++)
3563                {
3564                if (eptr >= md->end_subject)
3565                  {
3566                  SCHECK_PARTIAL();
3567                  MRRETURN(MATCH_NOMATCH);
3568                  }
3569                GETCHARINCTEST(c, eptr);
3570                prop_category = UCD_CATEGORY(c);
3571                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3572                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3573                       == prop_fail_result)
3574                  MRRETURN(MATCH_NOMATCH);
3575                }
3576              break;
3577    
3578              case PT_WORD:
3579              for (i = 1; i <= min; i++)
3580                {
3581                if (eptr >= md->end_subject)
3582                  {
3583                  SCHECK_PARTIAL();
3584                  MRRETURN(MATCH_NOMATCH);
3585                  }
3586                GETCHARINCTEST(c, eptr);
3587                prop_category = UCD_CATEGORY(c);
3588                if ((prop_category == ucp_L || prop_category == ucp_N ||
3589                     c == CHAR_UNDERSCORE)
3590                       == prop_fail_result)
3591                  MRRETURN(MATCH_NOMATCH);
3592                }
3593              break;
3594    
3595              /* This should not occur */
3596    
3597            default:            default:
3598            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
# Line 3429  for (;;) Line 3609  for (;;)
3609            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3610              {              {
3611              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3612              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3613              }              }
3614            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3615            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3616            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3617            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3618              {              {
3619              int len = 1;              int len = 1;
# Line 3460  for (;;) Line 3640  for (;;)
3640            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3641              {              {
3642              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3643              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3644              }              }
3645            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3646            eptr++;            eptr++;
3647            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3648            }            }
# Line 3474  for (;;) Line 3654  for (;;)
3654            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3655              {              {
3656              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3657              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3658              }              }
3659            eptr++;            eptr++;
3660            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3482  for (;;) Line 3662  for (;;)
3662          break;          break;
3663    
3664          case OP_ANYBYTE:          case OP_ANYBYTE:
3665          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3666          eptr += min;          eptr += min;
3667          break;          break;
3668    
# Line 3492  for (;;) Line 3672  for (;;)
3672            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3673              {              {
3674              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3675              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3676              }              }
3677            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3678            switch(c)            switch(c)
3679              {              {
3680              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3681              case 0x000d:              case 0x000d:
3682              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3683              break;              break;
# Line 3510  for (;;) Line 3690  for (;;)
3690              case 0x0085:              case 0x0085:
3691              case 0x2028:              case 0x2028:
3692              case 0x2029:              case 0x2029:
3693              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3694              break;              break;
3695              }              }
3696            }            }
# Line 3522  for (;;) Line 3702  for (;;)
3702            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3703              {              {
3704              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3705              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3706              }              }
3707            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3708            switch(c)            switch(c)
# Line 3547  for (;;) Line 3727  for (;;)
3727              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3728              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3729              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3730              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3731              }              }
3732            }            }
3733          break;          break;
# Line 3558  for (;;) Line 3738  for (;;)
3738            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3739              {              {
3740              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3741              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3742              }              }
3743            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3744            switch(c)            switch(c)
3745              {              {
3746              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3747              case 0x09:      /* HT */              case 0x09:      /* HT */
3748              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3749              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3594  for (;;) Line 3774  for (;;)
3774            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3775              {              {
3776              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3777              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3778              }              }
3779            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3780            switch(c)            switch(c)
# Line 3607  for (;;) Line 3787  for (;;)
3787              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3788              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3789              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3790              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3791              }              }
3792            }            }
3793          break;          break;
# Line 3618  for (;;) Line 3798  for (;;)
3798            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3799              {              {
3800              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3801              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3802              }              }
3803            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3804            switch(c)            switch(c)
3805              {              {
3806              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3807              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3808              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3809              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3642  for (;;) Line 3822  for (;;)
3822            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3823              {              {
3824              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3825              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3826              }              }
3827            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3828            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3829              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3830            }            }
3831          break;          break;
3832    
# Line 3656  for (;;) Line 3836  for (;;)
3836            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3837              {              {
3838              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3839              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3840              }              }
3841            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3842              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3843            /* 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 */
3844            }            }
3845          break;          break;
# Line 3670  for (;;) Line 3850  for (;;)
3850            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3851              {              {
3852              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3853              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3854              }              }
3855            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3856              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3857            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3858            }            }
3859          break;          break;
# Line 3684  for (;;) Line 3864  for (;;)
3864            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3865              {              {
3866              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3867              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3868              }              }
3869            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3870              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3871            /* 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 */
3872            }            }
3873          break;          break;
# Line 3695  for (;;) Line 3875  for (;;)
3875          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3876          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3877            {            {
3878            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3879               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3880              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3881                MRRETURN(MATCH_NOMATCH);
3882                }
3883              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3884                MRRETURN(MATCH_NOMATCH);
3885            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3886            }            }
3887          break;          break;
# Line 3708  for (;;) Line 3892  for (;;)
3892            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3893              {              {
3894              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3895              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3896              }              }
3897            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3898              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3899            /* 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 */
3900            }            }
3901          break;          break;
# Line 3734  for (;;) Line 3918  for (;;)
3918            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3919              {              {
3920              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3921              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3922              }              }
3923            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3924            eptr++;            eptr++;
3925            }            }
3926          break;          break;
# Line 3745  for (;;) Line 3929  for (;;)
3929          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3930            {            {
3931            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3932            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3933            }            }
3934          eptr += min;          eptr += min;
3935          break;          break;
# Line 3754  for (;;) Line 3938  for (;;)
3938          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3939            {            {
3940            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3941            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3942            }            }
3943          eptr += min;          eptr += min;
3944          break;          break;
# Line 3765  for (;;) Line 3949  for (;;)
3949            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3950              {              {
3951              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3952              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3953              }              }
3954            switch(*eptr++)            switch(*eptr++)
3955              {              {
3956              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3957              case 0x000d:              case 0x000d:
3958              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3959              break;              break;
# Line 3779  for (;;) Line 3963  for (;;)
3963              case 0x000b:              case 0x000b:
3964              case 0x000c:              case 0x000c:
3965              case 0x0085:              case 0x0085:
3966              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3967              break;              break;
3968              }              }
3969            }            }
# Line 3791  for (;;) Line 3975  for (;;)
3975            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3976              {              {
3977              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3978              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3979              }              }
3980            switch(*eptr++)            switch(*eptr++)
3981              {              {
# Line 3799  for (;;) Line 3983  for (;;)
3983              case 0x09:      /* HT */              case 0x09:      /* HT */
3984              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3985              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
3986              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3987              }              }
3988            }            }
3989          break;          break;
# Line 3810  for (;;) Line 3994  for (;;)
3994            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3995              {              {
3996              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3997              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3998              }              }
3999            switch(*eptr++)            switch(*eptr++)
4000              {              {
4001              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4002              case 0x09:      /* HT */              case 0x09:      /* HT */
4003              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4004              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3829  for (;;) Line 4013  for (;;)
4013            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4014              {              {
4015              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4016              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4017              }              }
4018            switch(*eptr++)            switch(*eptr++)
4019              {              {
# Line 3839  for (;;) Line 4023  for (;;)
4023              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4024              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4025              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4026              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4027              }              }
4028            }            }
4029          break;          break;
# Line 3850  for (;;) Line 4034  for (;;)
4034            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4035              {              {
4036              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4037              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4038              }              }
4039            switch(*eptr++)            switch(*eptr++)
4040              {              {
4041              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4042              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4043              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4044              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3871  for (;;) Line 4055  for (;;)
4055            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4056              {              {
4057              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4058              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4059              }              }
4060            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4061            }            }
4062          break;          break;
4063    
# Line 3883  for (;;) Line 4067  for (;;)
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            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4073            }            }
4074          break;          break;
4075    
# Line 3895  for (;;) Line 4079  for (;;)
4079            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4080              {              {
4081              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4082              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4083              }              }
4084            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4085            }            }
4086          break;          break;
4087    
# Line 3907  for (;;) Line 4091  for (;;)
4091            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4092              {              {
4093              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4094              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4095              }              }
4096            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4097            }            }
4098          break;          break;
4099    
# Line 3919  for (;;) Line 4103  for (;;)
4103            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4104              {              {
4105              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4106              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4107              }              }
4108            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4109              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4110            }            }
4111          break;          break;
4112    
# Line 3932  for (;;) Line 4116  for (;;)
4116            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4117              {              {
4118              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4119              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4120              }              }
4121            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4122              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4123            }            }
4124          break;          break;
4125    
# Line 3964  for (;;) Line 4148  for (;;)
4148              {              {
4149              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4150              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4151              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4152              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4153                {                {
4154                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4155                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4156                }                }
4157              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4158              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4159              }              }
4160            /* Control never gets here */            /* Control never gets here */
4161    
# Line 3980  for (;;) Line 4164  for (;;)
4164              {              {
4165              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4166              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4167              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4168              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4169                {                {
4170                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4171                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4172                }                }
4173              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4174              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4175              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4176                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4177                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4178                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4179              }              }
4180            /* Control never gets here */            /* Control never gets here */
4181    
# Line 4000  for (;;) Line 4184  for (;;)
4184              {              {
4185              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4186              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4187              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4188              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4189                {                {
4190                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4191                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4192                }                }
4193              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4194              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4195              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4196                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4197              }              }
4198            /* Control never gets here */            /* Control never gets here */
4199    
# Line 4018  for (;;) Line 4202  for (;;)
4202              {              {
4203              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4204              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4205              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4206              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4207                {                {
4208                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4209                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4210                }                }
4211              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4212              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4213              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4214                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4215              }              }
4216            /* Control never gets here */            /* Control never gets here */
4217    
# Line 4036  for (;;) Line 4220  for (;;)
4220              {              {
4221              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4222              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4223              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4224              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4225                {                {
4226                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4227                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4228                }                }
4229              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4230              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4231              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4232                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4233              }              }
4234            /* Control never gets here */            /* Control never gets here */
4235    
4236              case PT_ALNUM:
4237              for (fi = min;; fi++)
4238                {
4239                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4240                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4241                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4242                if (eptr >= md->end_subject)
4243                  {
4244                  SCHECK_PARTIAL();
4245                  MRRETURN(MATCH_NOMATCH);
4246                  }
4247                GETCHARINC(c, eptr);
4248                prop_category = UCD_CATEGORY(c);
4249                if ((prop_category == ucp_L || prop_category == ucp_N)
4250                       == prop_fail_result)
4251                  MRRETURN(MATCH_NOMATCH);
4252                }
4253              /* Control never gets here */
4254    
4255              case PT_SPACE:    /* Perl space */
4256              for (fi = min;; fi++)
4257                {
4258                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4259                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4260                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4261                if (eptr >= md->end_subject)
4262                  {
4263                  SCHECK_PARTIAL();
4264                  MRRETURN(MATCH_NOMATCH);
4265                  }
4266                GETCHARINC(c, eptr);
4267                prop_category = UCD_CATEGORY(c);
4268                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4269                     c == CHAR_FF || c == CHAR_CR)
4270                       == prop_fail_result)
4271                  MRRETURN(MATCH_NOMATCH);
4272                }
4273              /* Control never gets here */
4274    
4275              case PT_PXSPACE:  /* POSIX space */
4276              for (fi = min;; fi++)
4277                {
4278                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4279                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4280                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4281                if (eptr >= md->end_subject)
4282                  {
4283                  SCHECK_PARTIAL();
4284                  MRRETURN(MATCH_NOMATCH);
4285                  }
4286                GETCHARINC(c, eptr);
4287                prop_category = UCD_CATEGORY(c);
4288                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4289                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4290                       == prop_fail_result)
4291                  MRRETURN(MATCH_NOMATCH);
4292                }
4293              /* Control never gets here */
4294    
4295              case PT_WORD:
4296              for (fi = min;; fi++)
4297                {
4298                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4299                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4300                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4301                if (eptr >= md->end_subject)
4302                  {
4303                  SCHECK_PARTIAL();
4304                  MRRETURN(MATCH_NOMATCH);
4305                  }
4306                GETCHARINC(c, eptr);
4307                prop_category = UCD_CATEGORY(c);
4308                if ((prop_category == ucp_L ||
4309                     prop_category == ucp_N ||
4310                     c == CHAR_UNDERSCORE)
4311                       == prop_fail_result)
4312                  MRRETURN(MATCH_NOMATCH);
4313                }
4314              /* Control never gets here */
4315    
4316              /* This should never occur */
4317    
4318            default:            default:
4319            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4320            }            }
# Line 4063  for (;;) Line 4329  for (;;)
4329            {            {
4330            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4331            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4332            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4333            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4334              {              {
4335              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4336              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4337              }              }
4338            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4339            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4340            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4341            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4342              {              {
4343              int len = 1;              int len = 1;
# Line 4095  for (;;) Line 4361  for (;;)
4361            {            {
4362            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4363            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4364            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4365            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4366              {              {
4367              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4368              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4369              }              }
4370            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4371              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4372            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4373            switch(ctype)            switch(ctype)
4374              {              {
# Line 4114  for (;;) Line 4380  for (;;)
4380              case OP_ANYNL:              case OP_ANYNL:
4381              switch(c)              switch(c)
4382                {                {
4383                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4384                case 0x000d:                case 0x000d:
4385                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4386                break;                break;
# Line 4126  for (;;) Line 4392  for (;;)
4392                case 0x0085:                case 0x0085:
4393                case 0x2028:                case 0x2028:
4394                case 0x2029:                case 0x2029:
4395                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4396                break;                break;
4397                }                }
4398              break;              break;
# Line 4154  for (;;) Line 4420  for (;;)
4420                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4421                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4422                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4423                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4424                }                }
4425              break;              break;
4426    
4427              case OP_HSPACE:              case OP_HSPACE:
4428              switch(c)              switch(c)
4429                {                {
4430                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4431                case 0x09:      /* HT */                case 0x09:      /* HT */
4432                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4433                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4196  for (;;) Line 4462  for (;;)
4462                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4463                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4464                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4465                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4466                }                }
4467              break;              break;
4468    
4469              case OP_VSPACE:              case OP_VSPACE:
4470              switch(c)              switch(c)
4471                {                {
4472                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4473                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4474                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4475                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4217  for (;;) Line 4483  for (;;)
4483    
4484              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4485              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4486                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4487              break;              break;
4488    
4489              case OP_DIGIT:              case OP_DIGIT:
4490              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4491                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4492              break;              break;
4493    
4494              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4495              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4496                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4497              break;              break;
4498    
4499              case OP_WHITESPACE:              case OP_WHITESPACE:
4500              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4501                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4502              break;              break;
4503    
4504              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4505              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4506                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4507              break;              break;
4508    
4509              case OP_WORDCHAR:              case OP_WORDCHAR:
4510              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4511                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4512              break;              break;
4513    
4514              default:              default:
# Line 4258  for (;;) Line 4524  for (;;)
4524            {            {
4525            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4526            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4527            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4528            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4529              {              {
4530              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4531              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4532              }              }
4533            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4534              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4535            c = *eptr++;            c = *eptr++;
4536            switch(ctype)            switch(ctype)
4537              {              {
# Line 4277  for (;;) Line 4543  for (;;)
4543              case OP_ANYNL:              case OP_ANYNL:
4544              switch(c)              switch(c)
4545                {                {
4546                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4547                case 0x000d:                case 0x000d:
4548                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4549                break;                break;
# Line 4288  for (;;) Line 4554  for (;;)
4554                case 0x000b:                case 0x000b:
4555                case 0x000c:                case 0x000c:
4556                case 0x0085:                case 0x0085:
4557                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4558                break;                break;
4559                }                }
4560              break;              break;
# Line 4300  for (;;) Line 4566  for (;;)
4566                case 0x09:      /* HT */                case 0x09:      /* HT */
4567                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4568                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4569                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4570                }                }
4571              break;              break;
4572    
4573              case OP_HSPACE:              case OP_HSPACE:
4574              switch(c)              switch(c)
4575                {                {
4576                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4577                case 0x09:      /* HT */                case 0x09:      /* HT */
4578                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4579                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4324  for (;;) Line 4590  for (;;)
4590                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4591                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4592                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4593                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4594                }                }
4595              break;              break;
4596    
4597              case OP_VSPACE:              case OP_VSPACE:
4598              switch(c)              switch(c)
4599                {                {
4600                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4601                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4602                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4603                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4342  for (;;) Line 4608  for (;;)
4608              break;              break;
4609    
4610              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4611              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4612              break;              break;
4613    
4614              case OP_DIGIT:              case OP_DIGIT:
4615              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4616              break;              break;
4617    
4618              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4619              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4620              break;              break;
4621    
4622              case OP_WHITESPACE:              case OP_WHITESPACE:
4623              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4624              break;              break;
4625    
4626              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4627              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4628              break;              break;
4629    
4630              case OP_WORDCHAR:              case OP_WORDCHAR:
4631              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4632              break;              break;
4633    
4634              default:              default:
# Line 4470  for (;;) Line 4736  for (;;)
4736              eptr+= len;              eptr+= len;
4737              }              }
4738            break;            break;
4739    
4740              case PT_ALNUM:
4741              for (i = min; i < max; i++)
4742                {
4743                int len = 1;
4744                if (eptr >= md->end_subject)
4745                  {
4746                  SCHECK_PARTIAL();
4747                  break;
4748                  }
4749                GETCHARLEN(c, eptr, len);
4750                prop_category = UCD_CATEGORY(c);
4751                if ((prop_category == ucp_L || prop_category == ucp_N)
4752                     == prop_fail_result)
4753                  break;
4754                eptr+= len;
4755                }
4756              break;
4757    
4758              case PT_SPACE:    /* Perl space */
4759              for (i = min; i < max; i++)
4760                {
4761                int len = 1;
4762                if (eptr >= md->end_subject)
4763                  {
4764                  SCHECK_PARTIAL();
4765                  break;
4766                  }
4767                GETCHARLEN(c, eptr, len);
4768                prop_category = UCD_CATEGORY(c);
4769                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4770                     c == CHAR_FF || c == CHAR_CR)
4771                     == prop_fail_result)
4772                  break;
4773                eptr+= len;
4774                }
4775              break;
4776    
4777              case PT_PXSPACE:  /* POSIX space */
4778              for (i = min; i < max; i++)
4779                {
4780                int len = 1;
4781                if (eptr >= md->end_subject)
4782                  {
4783                  SCHECK_PARTIAL();
4784                  break;
4785                  }
4786                GETCHARLEN(c, eptr, len);
4787                prop_category = UCD_CATEGORY(c);
4788                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4789                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4790                     == prop_fail_result)
4791                  break;
4792                eptr+= len;
4793                }
4794              break;
4795    
4796              case PT_WORD:
4797              for (i = min; i < max; i++)
4798                {
4799                int len = 1;
4800                if (eptr >= md->end_subject)
4801                  {
4802                  SCHECK_PARTIAL();
4803                  break;
4804                  }
4805                GETCHARLEN(c, eptr, len);
4806                prop_category = UCD_CATEGORY(c);
4807                if ((prop_category == ucp_L || prop_category == ucp_N ||
4808                     c == CHAR_UNDERSCORE) == prop_fail_result)
4809                  break;
4810                eptr+= len;
4811                }
4812              break;
4813    
4814              default:
4815              RRETURN(PCRE_ERROR_INTERNAL);
4816            }            }
4817    
4818          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5022  for (;;) Line 5365  for (;;)
5365    
5366        /* 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 */
5367    
5368        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5369        }        }
5370      /* Control never gets here */      /* Control never gets here */
5371    
# Line 5055  switch (frame->Xwhere) Line 5398  switch (frame->Xwhere)
5398    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)
5399    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)
5400    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)
5401    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5402  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5403    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)
5404    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 5616  md->notempty_atstart = (options & PCRE_N
5616  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5617                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5618  md->hitend = FALSE;  md->hitend = FALSE;
5619    md->mark = NULL;                        /* In case never set */
5620    
5621  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5622    
# Line 5572  for(;;) Line 5916  for(;;)
5916      bytes to avoid spending too much time in this optimization. */      bytes to avoid spending too much time in this optimization. */
5917    
5918      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5919          end_subject - start_match < study->minlength)          (pcre_uint32)(end_subject - start_match) < study->minlength)
5920        {        {
5921        rc = MATCH_NOMATCH;        rc = MATCH_NOMATCH;
5922        break;        break;
# Line 5635  for(;;) Line 5979  for(;;)
5979        }        }
5980      }      }
5981    
5982  #ifdef DEBUG  /* Sigh. Some compilers never learn. */  #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
5983    printf(">>>> Match against: ");    printf(">>>> Match against: ");
5984    pchars(start_match, end_subject - start_match, TRUE, md);    pchars(start_match, end_subject - start_match, TRUE, md);
5985    printf("\n");    printf("\n");
# Line 5647  for(;;) Line 5991  for(;;)
5991    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5992    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
5993    md->match_call_count = 0;    md->match_call_count = 0;
5994    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,
5995        0, 0);
5996    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
5997    
5998    switch(rc)    switch(rc)
5999      {      {
6000      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. If MATCH_SKIP_ARG reaches
6001      exactly like PRUNE. */      this level it means that a MARK that matched the SKIP's arg was not found.
6002        We treat this as NOMATCH. THEN at this level acts exactly like PRUNE. */
6003    
6004      case MATCH_NOMATCH:      case MATCH_NOMATCH:
6005      case MATCH_PRUNE:      case MATCH_PRUNE:
6006        case MATCH_SKIP_ARG:
6007      case MATCH_THEN:      case MATCH_THEN:
6008      new_start_match = start_match + 1;      new_start_match = start_match + 1;
6009  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 5717  for(;;) Line 6064  for(;;)
6064           md->nllen == 2))           md->nllen == 2))
6065      start_match++;      start_match++;
6066    
6067    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
6068      }                  /* End of for(;;) "bumpalong" loop */
6069    
6070  /* ==========================================================================*/  /* ==========================================================================*/
6071    
# Line 5741  capturing parentheses than vector slots. Line 6089  capturing parentheses than vector slots.
6089    
6090  ENDLOOP:  ENDLOOP:
6091    
6092  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
6093    {    {
6094    if (using_temporary_offsets)    if (using_temporary_offsets)
6095      {      {
# Line 5772  if (rc == MATCH_MATCH) Line 6120  if (rc == MATCH_MATCH)
6120      }      }
6121    
6122    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6123    return rc;    goto RETURN_MARK;
6124    }    }
6125    
6126  /* 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 6132  if (using_temporary_offsets)
6132    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
6133    }    }
6134    
6135    /* For anything other than nomatch or partial match, just return the code. */
6136    
6137  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6138    {    {
6139    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6140    return rc;    return rc;
6141    }    }
6142  else if (start_partial != NULL)  
6143    /* Handle partial matches - disable any mark data */
6144    
6145    if (start_partial != NULL)
6146    {    {
6147    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
6148      md->mark = NULL;
6149    if (offsetcount > 1)    if (offsetcount > 1)
6150      {      {
6151      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = start_partial - (USPTR)subject;
6152      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = end_subject - (USPTR)subject;
6153      }      }
6154    return PCRE_ERROR_PARTIAL;    rc = PCRE_ERROR_PARTIAL;
6155    }    }
6156    
6157    /* This is the classic nomatch case */
6158    
6159  else  else
6160    {    {
6161    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
6162    return PCRE_ERROR_NOMATCH;    rc = PCRE_ERROR_NOMATCH;
6163    }    }
6164    
6165    /* Return the MARK data if it has been requested. */
6166    
6167    RETURN_MARK:
6168    
6169    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6170      *(extra_data->mark) = (unsigned char *)(md->mark);
6171    return rc;
6172  }  }
6173    
6174  /* End of pcre_exec.c */  /* End of pcre_exec.c */

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

  ViewVC Help
Powered by ViewVC 1.1.5