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

Diff of /code/trunk/pcre_exec.c

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

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

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

  ViewVC Help
Powered by ViewVC 1.1.5