/[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 475 by ph10, Sat Jan 2 18:21:30 2010 UTC revision 595 by ph10, Mon May 2 10:33:29 2011 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 122  while (length-- > 0) Line 132  while (length-- > 0)
132  *          Match a back-reference                *  *          Match a back-reference                *
133  *************************************************/  *************************************************/
134    
135  /* If a back reference hasn't been set, the length that is passed is greater  /* Normally, if a back reference hasn't been set, the length that is passed is
136  than the number of characters left in the string, so the match fails.  negative, so the match always fails. However, in JavaScript compatibility mode,
137    the length passed is zero. Note that in caseless UTF-8 mode, the number of
138    subject bytes matched may be different to the number of reference bytes.
139    
140  Arguments:  Arguments:
141    offset      index into the offset vector    offset      index into the offset vector
142    eptr        points into the subject    eptr        pointer into the subject
143    length      length to be matched    length      length of reference to be matched (number of bytes)
144    md          points to match data block    md          points to match data block
145    ims         the ims flags    ims         the ims flags
146    
147  Returns:      TRUE if matched  Returns:      < 0 if not matched, otherwise the number of subject bytes matched
148  */  */
149    
150  static BOOL  static int
151  match_ref(int offset, register USPTR eptr, int length, match_data *md,  match_ref(int offset, register USPTR eptr, int length, match_data *md,
152    unsigned long int ims)    unsigned long int ims)
153  {  {
154  USPTR p = md->start_subject + md->offset_vector[offset];  USPTR eptr_start = eptr;
155    register USPTR p = md->start_subject + md->offset_vector[offset];
156    
157  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
158  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
# Line 154  pchars(p, length, FALSE, md); Line 167  pchars(p, length, FALSE, md);
167  printf("\n");  printf("\n");
168  #endif  #endif
169    
170  /* Always fail if not enough characters left */  /* Always fail if reference not set (and not JavaScript compatible). */
171    
172  if (length > md->end_subject - eptr) return FALSE;  if (length < 0) return -1;
173    
174  /* Separate the caseless case for speed. In UTF-8 mode we can only do this  /* Separate the caseless case for speed. In UTF-8 mode we can only do this
175  properly if Unicode properties are supported. Otherwise, we can check only  properly if Unicode properties are supported. Otherwise, we can check only
# Line 168  if ((ims & PCRE_CASELESS) != 0) Line 181  if ((ims & PCRE_CASELESS) != 0)
181  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
182    if (md->utf8)    if (md->utf8)
183      {      {
184      USPTR endptr = eptr + length;      /* Match characters up to the end of the reference. NOTE: the number of
185      while (eptr < endptr)      bytes matched may differ, because there are some characters whose upper and
186        lower case versions code as different numbers of bytes. For example, U+023A
187        (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);
188        a sequence of 3 of the former uses 6 bytes, as does a sequence of two of
189        the latter. It is important, therefore, to check the length along the
190        reference, not along the subject (earlier code did this wrong). */
191    
192        USPTR endptr = p + length;
193        while (p < endptr)
194        {        {
195        int c, d;        int c, d;
196        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
197        GETCHARINC(d, p);        GETCHARINC(d, p);
198        if (c != d && c != UCD_OTHERCASE(d)) return FALSE;        if (c != d && c != UCD_OTHERCASE(d)) return -1;
199        }        }
200      }      }
201    else    else
# Line 185  if ((ims & PCRE_CASELESS) != 0) Line 206  if ((ims & PCRE_CASELESS) != 0)
206    is no UCP support. */    is no UCP support. */
207    
208    while (length-- > 0)    while (length-- > 0)
209      { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }      { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
210    }    }
211    
212  /* In the caseful case, we can just compare the bytes, whether or not we  /* In the caseful case, we can just compare the bytes, whether or not we
213  are in UTF-8 mode. */  are in UTF-8 mode. */
214    
215  else  else
216    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }    { while (length-- > 0) if (*p++ != *eptr++) return -1; }
217    
218  return TRUE;  return eptr - eptr_start;
219  }  }
220    
221    
# Line 245  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 266  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
266         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
267         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
268         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
269         RM51,  RM52, RM53, RM54 };         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
270           RM61,  RM62 };
271    
272  /* 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
273  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
274  actuall used in this definition. */  actually used in this definition. */
275    
276  #ifndef NO_RECURSE  #ifndef NO_RECURSE
277  #define REGISTER register  #define REGISTER register
# Line 258  actuall used in this definition. */ Line 280  actuall used in this definition. */
280  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
281    { \    { \
282    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
283    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); \
284    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
285    }    }
286  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 268  actuall used in this definition. */ Line 290  actuall used in this definition. */
290    }    }
291  #else  #else
292  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
293    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)
294  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
295  #endif  #endif
296    
# Line 283  argument of match(), which never changes Line 305  argument of match(), which never changes
305    
306  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
307    {\    {\
308    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\    heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
309      if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
310    frame->Xwhere = rw; \    frame->Xwhere = rw; \
311    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
312    newframe->Xecode = rb;\    newframe->Xecode = rb;\
313    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
314      newframe->Xmarkptr = markptr;\
315    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
316    newframe->Xims = re;\    newframe->Xims = re;\
317    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 303  argument of match(), which never changes Line 327  argument of match(), which never changes
327    
328  #define RRETURN(ra)\  #define RRETURN(ra)\
329    {\    {\
330    heapframe *newframe = frame;\    heapframe *oldframe = frame;\
331    frame = newframe->Xprevframe;\    frame = oldframe->Xprevframe;\
332    (pcre_stack_free)(newframe);\    (pcre_stack_free)(oldframe);\
333    if (frame != NULL)\    if (frame != NULL)\
334      {\      {\
335      rrc = ra;\      rrc = ra;\
# Line 325  typedef struct heapframe { Line 349  typedef struct heapframe {
349    USPTR Xeptr;    USPTR Xeptr;
350    const uschar *Xecode;    const uschar *Xecode;
351    USPTR Xmstart;    USPTR Xmstart;
352      USPTR Xmarkptr;
353    int Xoffset_top;    int Xoffset_top;
354    long int Xims;    long int Xims;
355    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 408  immediately. The second one is used when Line 433  immediately. The second one is used when
433  the subject. */  the subject. */
434    
435  #define CHECK_PARTIAL()\  #define CHECK_PARTIAL()\
436    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && \
437      {\        eptr > md->start_used_ptr) \
438      md->hitend = TRUE;\      { \
439      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      md->hitend = TRUE; \
440        if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
441      }      }
442    
443  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
444    if (md->partial != 0 && eptr > mstart)\    if (md->partial != 0 && eptr > md->start_used_ptr) \
445      {\      { \
446      md->hitend = TRUE;\      md->hitend = TRUE; \
447      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \
448      }      }
449    
450    
# Line 432  Arguments: Line 458  Arguments:
458     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
459     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
460                   by encountering \K)                   by encountering \K)
461       markptr     pointer to the most recent MARK name, or NULL
462     offset_top  current top pointer     offset_top  current top pointer
463     md          pointer to "static" info for the match     md          pointer to "static" info for the match
464     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 445  Arguments: Line 472  Arguments:
472    
473  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
474                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
475                   a negative MATCH_xxx value for PRUNE, SKIP, etc
476                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
477                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
478  */  */
479    
480  static int  static int
481  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
482    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,
483    int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
484  {  {
485  /* 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,
486  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 472  heap storage. Set up the top-level frame Line 500  heap storage. Set up the top-level frame
500  heap whenever RMATCH() does a "recursion". See the macro definitions above. */  heap whenever RMATCH() does a "recursion". See the macro definitions above. */
501    
502  #ifdef NO_RECURSE  #ifdef NO_RECURSE
503  heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));  heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));
504    if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
505  frame->Xprevframe = NULL;            /* Marks the top level */  frame->Xprevframe = NULL;            /* Marks the top level */
506    
507  /* Copy in the original argument variables */  /* Copy in the original argument variables */
# Line 480  frame->Xprevframe = NULL;            /* Line 509  frame->Xprevframe = NULL;            /*
509  frame->Xeptr = eptr;  frame->Xeptr = eptr;
510  frame->Xecode = ecode;  frame->Xecode = ecode;
511  frame->Xmstart = mstart;  frame->Xmstart = mstart;
512    frame->Xmarkptr = markptr;
513  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
514  frame->Xims = ims;  frame->Xims = ims;
515  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 495  HEAP_RECURSE: Line 525  HEAP_RECURSE:
525  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
526  #define ecode              frame->Xecode  #define ecode              frame->Xecode
527  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
528    #define markptr            frame->Xmarkptr
529  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
530  #define ims                frame->Xims  #define ims                frame->Xims
531  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 666  for (;;) Line 697  for (;;)
697    
698    switch(op)    switch(op)
699      {      {
700        case OP_MARK:
701        markptr = ecode + 2;
702        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
703          ims, eptrb, flags, RM55);
704    
705        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
706        argument, and we must check whether that argument matches this MARK's
707        argument. It is passed back in md->start_match_ptr (an overloading of that
708        variable). If it does match, we reset that variable to the current subject
709        position and return MATCH_SKIP. Otherwise, pass back the return code
710        unaltered. */
711    
712        if (rrc == MATCH_SKIP_ARG &&
713            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
714          {
715          md->start_match_ptr = eptr;
716          RRETURN(MATCH_SKIP);
717          }
718    
719        if (md->mark == NULL) md->mark = markptr;
720        RRETURN(rrc);
721    
722      case OP_FAIL:      case OP_FAIL:
723      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
724    
725        /* COMMIT overrides PRUNE, SKIP, and THEN */
726    
727        case OP_COMMIT:
728        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
729          ims, eptrb, flags, RM52);
730        if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
731            rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
732            rrc != MATCH_THEN)
733          RRETURN(rrc);
734        MRRETURN(MATCH_COMMIT);
735    
736        /* PRUNE overrides THEN */
737    
738      case OP_PRUNE:      case OP_PRUNE:
739      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
740        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
741      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
742        MRRETURN(MATCH_PRUNE);
743    
744        case OP_PRUNE_ARG:
745        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
746          ims, eptrb, flags, RM56);
747        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
748        md->mark = ecode + 2;
749      RRETURN(MATCH_PRUNE);      RRETURN(MATCH_PRUNE);
750    
751      case OP_COMMIT:      /* SKIP overrides PRUNE and THEN */
     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,  
       ims, eptrb, flags, RM52);  
     if (rrc != MATCH_NOMATCH) RRETURN(rrc);  
     RRETURN(MATCH_COMMIT);  
752    
753      case OP_SKIP:      case OP_SKIP:
754      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
755        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
756      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
757          RRETURN(rrc);
758      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
759      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
760    
761        case OP_SKIP_ARG:
762        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
763          ims, eptrb, flags, RM57);
764        if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
765          RRETURN(rrc);
766    
767        /* Pass back the current skip name by overloading md->start_match_ptr and
768        returning the special MATCH_SKIP_ARG return code. This will either be
769        caught by a matching MARK, or get to the top, where it is treated the same
770        as PRUNE. */
771    
772        md->start_match_ptr = ecode + 2;
773        RRETURN(MATCH_SKIP_ARG);
774    
775        /* For THEN (and THEN_ARG) we pass back the address of the bracket or
776        the alt that is at the start of the current branch. This makes it possible
777        to skip back past alternatives that precede the THEN within the current
778        branch. */
779    
780      case OP_THEN:      case OP_THEN:
781      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
782        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
783      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
784        md->start_match_ptr = ecode - GET(ecode, 1);
785        MRRETURN(MATCH_THEN);
786    
787        case OP_THEN_ARG:
788        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
789          offset_top, md, ims, eptrb, flags, RM58);
790        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
791        md->start_match_ptr = ecode - GET(ecode, 1);
792        md->mark = ecode + LINK_SIZE + 2;
793      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
794    
795      /* 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 728  for (;;) Line 826  for (;;)
826        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
827    
828        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
829        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;        md->offset_vector[md->offset_end - number] =
830            (int)(eptr - md->start_subject);
831    
832        flags = (op == OP_SCBRA)? match_cbegroup : 0;        flags = (op == OP_SCBRA)? match_cbegroup : 0;
833        do        do
834          {          {
835          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
836            ims, eptrb, flags, RM1);            ims, eptrb, flags, RM1);
837          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);          if (rrc != MATCH_NOMATCH &&
838                (rrc != MATCH_THEN || md->start_match_ptr != ecode))
839              RRETURN(rrc);
840          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
841          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
842          }          }
# Line 747  for (;;) Line 848  for (;;)
848        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
849        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
850    
851          if (rrc != MATCH_THEN) md->mark = markptr;
852        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
853        }        }
854    
# Line 786  for (;;) Line 888  for (;;)
888    
889          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
890            eptrb, flags, RM48);            eptrb, flags, RM48);
891            if (rrc == MATCH_NOMATCH) md->mark = markptr;
892          RRETURN(rrc);          RRETURN(rrc);
893          }          }
894    
# Line 794  for (;;) Line 897  for (;;)
897    
898        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
899          eptrb, flags, RM2);          eptrb, flags, RM2);
900        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH &&
901              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
902            RRETURN(rrc);
903        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
904        }        }
905      /* Control never reaches here. */      /* Control never reaches here. */
# Line 821  for (;;) Line 926  for (;;)
926          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
927          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
928          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
929          cb.subject_length   = md->end_subject - md->start_subject;          cb.subject_length   = (int)(md->end_subject - md->start_subject);
930          cb.start_match      = mstart - md->start_subject;          cb.start_match      = (int)(mstart - md->start_subject);
931          cb.current_position = eptr - md->start_subject;          cb.current_position = (int)(eptr - md->start_subject);
932          cb.pattern_position = GET(ecode, LINK_SIZE + 3);          cb.pattern_position = GET(ecode, LINK_SIZE + 3);
933          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
934          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
935          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
936          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
937          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
938          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
939          }          }
940        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 995  for (;;) Line 1100  for (;;)
1100          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
1101          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1102          }          }
1103        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)        else if (rrc != MATCH_NOMATCH &&
1104                  (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1105          {          {
1106          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
1107          }          }
# Line 1049  for (;;) Line 1155  for (;;)
1155        {        {
1156        md->offset_vector[offset] =        md->offset_vector[offset] =
1157          md->offset_vector[md->offset_end - number];          md->offset_vector[md->offset_end - number];
1158        md->offset_vector[offset+1] = eptr - md->start_subject;        md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1159        if (offset_top <= offset) offset_top = offset + 2;        if (offset_top <= offset) offset_top = offset + 2;
1160        }        }
1161      ecode += 3;      ecode += 3;
# Line 1070  for (;;) Line 1176  for (;;)
1176        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1177          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1178        offset_top = rec->save_offset_top;        offset_top = rec->save_offset_top;
       mstart = rec->save_start;  
1179        ims = original_ims;        ims = original_ims;
1180        ecode = rec->after_call;        ecode = rec->after_call;
1181        break;        break;
# Line 1085  for (;;) Line 1190  for (;;)
1190          (md->notempty ||          (md->notempty ||
1191            (md->notempty_atstart &&            (md->notempty_atstart &&
1192              mstart == md->start_subject + md->start_offset)))              mstart == md->start_subject + md->start_offset)))
1193        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1194    
1195      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1196    
1197      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1198      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1199      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1200      RRETURN(MATCH_MATCH);  
1201        /* For some reason, the macros don't work properly if an expression is
1202        given as the argument to MRRETURN when the heap is in use. */
1203    
1204        rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1205        MRRETURN(rrc);
1206    
1207      /* Change option settings */      /* Change option settings */
1208    
# Line 1114  for (;;) Line 1224  for (;;)
1224        {        {
1225        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1226          RM4);          RM4);
1227        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1228        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);          {
1229            mstart = md->start_match_ptr;   /* In case \K reset it */
1230            break;
1231            }
1232          if (rrc != MATCH_NOMATCH &&
1233              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1234            RRETURN(rrc);
1235        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1236        }        }
1237      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1238      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1239    
1240      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1241    
# Line 1134  for (;;) Line 1250  for (;;)
1250      continue;      continue;
1251    
1252      /* Negative assertion: all branches must fail to match. Encountering SKIP,      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1253      PRUNE, or COMMIT means we must assume failure without checking subsequent      PRUNE, or COMMIT means we must assume failure without checking subsequent
1254      branches. */      branches. */
1255    
1256      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
# Line 1143  for (;;) Line 1259  for (;;)
1259        {        {
1260        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1261          RM5);          RM5);
1262        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1263        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1264          {          {
1265          do ecode += GET(ecode,1); while (*ecode == OP_ALT);          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1266          break;          break;
1267          }          }
1268        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH &&
1269              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1270            RRETURN(rrc);
1271        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1272        }        }
1273      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1172  for (;;) Line 1290  for (;;)
1290        while (i-- > 0)        while (i-- > 0)
1291          {          {
1292          eptr--;          eptr--;
1293          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1294          BACKCHAR(eptr);          BACKCHAR(eptr);
1295          }          }
1296        }        }
# Line 1183  for (;;) Line 1301  for (;;)
1301    
1302        {        {
1303        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1304        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1305        }        }
1306    
1307      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1204  for (;;) Line 1322  for (;;)
1322        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1323        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1324        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1325        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1326        cb.start_match      = mstart - md->start_subject;        cb.start_match      = (int)(mstart - md->start_subject);
1327        cb.current_position = eptr - md->start_subject;        cb.current_position = (int)(eptr - md->start_subject);
1328        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1329        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1330        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1331        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1332        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1333        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1334        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1335        }        }
1336      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1267  for (;;) Line 1385  for (;;)
1385    
1386        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1387              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
       new_recursive.save_start = mstart;  
1388        new_recursive.save_offset_top = offset_top;        new_recursive.save_offset_top = offset_top;
       mstart = eptr;  
1389    
1390        /* 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
1391        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1280  for (;;) Line 1396  for (;;)
1396          {          {
1397          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1398            md, ims, eptrb, flags, RM6);            md, ims, eptrb, flags, RM6);
1399          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1400            {            {
1401            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1402            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1403            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1404              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1405            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1406            }            }
1407          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH &&
1408                    (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1409            {            {
1410            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1411            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 1307  for (;;) Line 1424  for (;;)
1424        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1425        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1426          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1427        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1428        }        }
1429      /* Control never reaches here */      /* Control never reaches here */
1430    
# Line 1316  for (;;) Line 1433  for (;;)
1433      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1434      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
1435      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
1436      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1437        the start-of-match value in case it was changed by \K. */
1438    
1439      case OP_ONCE:      case OP_ONCE:
1440      prev = ecode;      prev = ecode;
# Line 1325  for (;;) Line 1443  for (;;)
1443      do      do
1444        {        {
1445        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);
1446        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1447        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);          {
1448            mstart = md->start_match_ptr;
1449            break;
1450            }
1451          if (rrc != MATCH_NOMATCH &&
1452              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1453            RRETURN(rrc);
1454        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1455        }        }
1456      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1444  for (;;) Line 1568  for (;;)
1568        }        }
1569      else saved_eptr = NULL;      else saved_eptr = NULL;
1570    
1571      /* 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
1572      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
1573      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1574        it was changed by \K. */
1575    
1576      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1577          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1454  for (;;) Line 1579  for (;;)
1579        {        {
1580        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1581        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1582        RRETURN(MATCH_MATCH);        md->start_match_ptr = mstart;
1583          MRRETURN(MATCH_MATCH);
1584        }        }
1585    
1586      /* 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 1478  for (;;) Line 1604  for (;;)
1604          {          {
1605          md->offset_vector[offset] =          md->offset_vector[offset] =
1606            md->offset_vector[md->offset_end - number];            md->offset_vector[md->offset_end - number];
1607          md->offset_vector[offset+1] = eptr - md->start_subject;          md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1608          if (offset_top <= offset) offset_top = offset + 2;          if (offset_top <= offset) offset_top = offset + 2;
1609          }          }
1610    
# Line 1490  for (;;) Line 1616  for (;;)
1616          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1617          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1618          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1619          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1620            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1621          offset_top = rec->save_offset_top;          offset_top = rec->save_offset_top;
# Line 1550  for (;;) Line 1675  for (;;)
1675      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1676    
1677      case OP_CIRC:      case OP_CIRC:
1678      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1679      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1680        {        {
1681        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1682            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1683          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1684        ecode++;        ecode++;
1685        break;        break;
1686        }        }
# Line 1564  for (;;) Line 1689  for (;;)
1689      /* Start of subject assertion */      /* Start of subject assertion */
1690    
1691      case OP_SOD:      case OP_SOD:
1692      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1693      ecode++;      ecode++;
1694      break;      break;
1695    
1696      /* Start of match assertion */      /* Start of match assertion */
1697    
1698      case OP_SOM:      case OP_SOM:
1699      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1700      ecode++;      ecode++;
1701      break;      break;
1702    
# Line 1589  for (;;) Line 1714  for (;;)
1714      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1715        {        {
1716        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1717          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1718        else        else
1719          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          {
1720            if (md->noteol) MRRETURN(MATCH_NOMATCH);
1721            SCHECK_PARTIAL();
1722            }
1723        ecode++;        ecode++;
1724        break;        break;
1725        }        }
1726      else      else  /* Not multiline */
1727        {        {
1728        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1729        if (!md->endonly)        if (!md->endonly) goto ASSERT_NL_OR_EOS;
         {  
         if (eptr != md->end_subject &&  
             (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))  
           RRETURN(MATCH_NOMATCH);  
         ecode++;  
         break;  
         }  
1730        }        }
1731    
1732      /* ... else fall through for endonly */      /* ... else fall through for endonly */
1733    
1734      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1735    
1736      case OP_EOD:      case OP_EOD:
1737      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1738        SCHECK_PARTIAL();
1739      ecode++;      ecode++;
1740      break;      break;
1741    
1742      /* End of subject or ending \n assertion (\Z) */      /* End of subject or ending \n assertion (\Z) */
1743    
1744      case OP_EODN:      case OP_EODN:
1745      if (eptr != md->end_subject &&      ASSERT_NL_OR_EOS:
1746        if (eptr < md->end_subject &&
1747          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1748        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1749    
1750        /* Either at end of string or \n before end. */
1751    
1752        SCHECK_PARTIAL();
1753      ecode++;      ecode++;
1754      break;      break;
1755    
# Line 1639  for (;;) Line 1767  for (;;)
1767  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1768        if (utf8)        if (utf8)
1769          {          {
1770            /* Get status of previous character */
1771    
1772          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1773            {            {
1774            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1775            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1776            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1777            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1778    #ifdef SUPPORT_UCP
1779              if (md->use_ucp)
1780                {
1781                if (c == '_') prev_is_word = TRUE; else
1782                  {
1783                  int cat = UCD_CATEGORY(c);
1784                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1785                  }
1786                }
1787              else
1788    #endif
1789            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1790            }            }
1791    
1792            /* Get status of next character */
1793    
1794          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1795            {            {
1796            SCHECK_PARTIAL();            SCHECK_PARTIAL();
# Line 1655  for (;;) Line 1799  for (;;)
1799          else          else
1800            {            {
1801            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1802    #ifdef SUPPORT_UCP
1803              if (md->use_ucp)
1804                {
1805                if (c == '_') cur_is_word = TRUE; else
1806                  {
1807                  int cat = UCD_CATEGORY(c);
1808                  cur_is_word = (cat == ucp_L || cat == ucp_N);
1809                  }
1810                }
1811              else
1812    #endif
1813            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1814            }            }
1815          }          }
1816        else        else
1817  #endif  #endif
1818    
1819        /* Not in UTF-8 mode */        /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
1820          consistency with the behaviour of \w we do use it in this case. */
1821    
1822          {          {
1823            /* Get status of previous character */
1824    
1825          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1826            {            {
1827            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1828    #ifdef SUPPORT_UCP
1829              if (md->use_ucp)
1830                {
1831                c = eptr[-1];
1832                if (c == '_') prev_is_word = TRUE; else
1833                  {
1834                  int cat = UCD_CATEGORY(c);
1835                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1836                  }
1837                }
1838              else
1839    #endif
1840            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1841            }            }
1842    
1843            /* Get status of next character */
1844    
1845          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1846            {            {
1847            SCHECK_PARTIAL();            SCHECK_PARTIAL();
1848            cur_is_word = FALSE;            cur_is_word = FALSE;
1849            }            }
1850          else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);          else
1851    #ifdef SUPPORT_UCP
1852            if (md->use_ucp)
1853              {
1854              c = *eptr;
1855              if (c == '_') cur_is_word = TRUE; else
1856                {
1857                int cat = UCD_CATEGORY(c);
1858                cur_is_word = (cat == ucp_L || cat == ucp_N);
1859                }
1860              }
1861            else
1862    #endif
1863            cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1864          }          }
1865    
1866        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
1867    
1868        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1869             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1870          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1871        }        }
1872      break;      break;
1873    
1874      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1875    
1876      case OP_ANY:      case OP_ANY:
1877      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1878      /* Fall through */      /* Fall through */
1879    
1880      case OP_ALLANY:      case OP_ALLANY:
1881      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1882        {        {
1883        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1884        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1885        }        }
1886      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1887      ecode++;      ecode++;
# Line 1708  for (;;) Line 1894  for (;;)
1894      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1895        {        {
1896        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1897        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1898        }        }
1899      ecode++;      ecode++;
1900      break;      break;
# Line 1717  for (;;) Line 1903  for (;;)
1903      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1904        {        {
1905        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1906        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1907        }        }
1908      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1909      if (      if (
# Line 1726  for (;;) Line 1912  for (;;)
1912  #endif  #endif
1913         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1914         )         )
1915        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1916      ecode++;      ecode++;
1917      break;      break;
1918    
# Line 1734  for (;;) Line 1920  for (;;)
1920      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1921        {        {
1922        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1923        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1924        }        }
1925      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1926      if (      if (
# Line 1743  for (;;) Line 1929  for (;;)
1929  #endif  #endif
1930         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1931         )         )
1932        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1933      ecode++;      ecode++;
1934      break;      break;
1935    
# Line 1751  for (;;) Line 1937  for (;;)
1937      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1938        {        {
1939        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1940        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1941        }        }
1942      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1943      if (      if (
# Line 1760  for (;;) Line 1946  for (;;)
1946  #endif  #endif
1947         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1948         )         )
1949        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1950      ecode++;      ecode++;
1951      break;      break;
1952    
# Line 1768  for (;;) Line 1954  for (;;)
1954      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1955        {        {
1956        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1957        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1958        }        }
1959      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1960      if (      if (
# Line 1777  for (;;) Line 1963  for (;;)
1963  #endif  #endif
1964         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1965         )         )
1966        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1967      ecode++;      ecode++;
1968      break;      break;
1969    
# Line 1785  for (;;) Line 1971  for (;;)
1971      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1972        {        {
1973        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1974        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1975        }        }
1976      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1977      if (      if (
# Line 1794  for (;;) Line 1980  for (;;)
1980  #endif  #endif
1981         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1982         )         )
1983        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1984      ecode++;      ecode++;
1985      break;      break;
1986    
# Line 1802  for (;;) Line 1988  for (;;)
1988      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1989        {        {
1990        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1991        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1992        }        }
1993      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1994      if (      if (
# Line 1811  for (;;) Line 1997  for (;;)
1997  #endif  #endif
1998         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1999         )         )
2000        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2001      ecode++;      ecode++;
2002      break;      break;
2003    
# Line 1819  for (;;) Line 2005  for (;;)
2005      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2006        {        {
2007        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2008        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2009        }        }
2010      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2011      switch(c)      switch(c)
2012        {        {
2013        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2014        case 0x000d:        case 0x000d:
2015        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2016        break;        break;
# Line 1837  for (;;) Line 2023  for (;;)
2023        case 0x0085:        case 0x0085:
2024        case 0x2028:        case 0x2028:
2025        case 0x2029:        case 0x2029:
2026        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
2027        break;        break;
2028        }        }
2029      ecode++;      ecode++;
# Line 1847  for (;;) Line 2033  for (;;)
2033      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2034        {        {
2035        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2036        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2037        }        }
2038      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2039      switch(c)      switch(c)
# Line 1872  for (;;) Line 2058  for (;;)
2058        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2059        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2060        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2061        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2062        }        }
2063      ecode++;      ecode++;
2064      break;      break;
# Line 1881  for (;;) Line 2067  for (;;)
2067      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2068        {        {
2069        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2070        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2071        }        }
2072      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2073      switch(c)      switch(c)
2074        {        {
2075        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2076        case 0x09:      /* HT */        case 0x09:      /* HT */
2077        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2078        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1915  for (;;) Line 2101  for (;;)
2101      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2102        {        {
2103        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2104        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2105        }        }
2106      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2107      switch(c)      switch(c)
# Line 1928  for (;;) Line 2114  for (;;)
2114        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2115        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2116        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2117        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2118        }        }
2119      ecode++;      ecode++;
2120      break;      break;
# Line 1937  for (;;) Line 2123  for (;;)
2123      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2124        {        {
2125        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2126        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2127        }        }
2128      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2129      switch(c)      switch(c)
2130        {        {
2131        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2132        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2133        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2134        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1964  for (;;) Line 2150  for (;;)
2150      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2151        {        {
2152        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2153        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2154        }        }
2155      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2156        {        {
# Line 1973  for (;;) Line 2159  for (;;)
2159        switch(ecode[1])        switch(ecode[1])
2160          {          {
2161          case PT_ANY:          case PT_ANY:
2162          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2163          break;          break;
2164    
2165          case PT_LAMP:          case PT_LAMP:
2166          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2167               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2168               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2169            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2170           break;          break;
2171    
2172          case PT_GC:          case PT_GC:
2173          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2174            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2175          break;          break;
2176    
2177          case PT_PC:          case PT_PC:
2178          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2179            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2180          break;          break;
2181    
2182          case PT_SC:          case PT_SC:
2183          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2184            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2185          break;          break;
2186    
2187            /* These are specials */
2188    
2189            case PT_ALNUM:
2190            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2191                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2192              MRRETURN(MATCH_NOMATCH);
2193            break;
2194    
2195            case PT_SPACE:    /* Perl space */
2196            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2197                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2198                   == (op == OP_NOTPROP))
2199              MRRETURN(MATCH_NOMATCH);
2200            break;
2201    
2202            case PT_PXSPACE:  /* POSIX space */
2203            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2204                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2205                 c == CHAR_FF || c == CHAR_CR)
2206                   == (op == OP_NOTPROP))
2207              MRRETURN(MATCH_NOMATCH);
2208            break;
2209    
2210            case PT_WORD:
2211            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2212                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2213                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2214              MRRETURN(MATCH_NOMATCH);
2215            break;
2216    
2217            /* This should never occur */
2218    
2219          default:          default:
2220          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
2221          }          }
# Line 2013  for (;;) Line 2231  for (;;)
2231      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2232        {        {
2233        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2234        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2235        }        }
2236      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2237        {        {
2238        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2239        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2240        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2241          {          {
2242          int len = 1;          int len = 1;
# Line 2045  for (;;) Line 2263  for (;;)
2263      loops). */      loops). */
2264    
2265      case OP_REF:      case OP_REF:
2266        {      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
2267        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */      ecode += 3;
       ecode += 3;  
2268    
2269        /* If the reference is unset, there are two possibilities:      /* If the reference is unset, there are two possibilities:
2270    
2271        (a) In the default, Perl-compatible state, set the length to be longer      (a) In the default, Perl-compatible state, set the length negative;
2272        than the amount of subject left; this ensures that every attempt at a      this ensures that every attempt at a match fails. We can't just fail
2273        match fails. We can't just fail here, because of the possibility of      here, because of the possibility of quantifiers with zero minima.
       quantifiers with zero minima.  
2274    
2275        (b) If the JavaScript compatibility flag is set, set the length to zero      (b) If the JavaScript compatibility flag is set, set the length to zero
2276        so that the back reference matches an empty string.      so that the back reference matches an empty string.
2277    
2278        Otherwise, set the length to the length of what was matched by the      Otherwise, set the length to the length of what was matched by the
2279        referenced subpattern. */      referenced subpattern. */
2280    
2281        if (offset >= offset_top || md->offset_vector[offset] < 0)      if (offset >= offset_top || md->offset_vector[offset] < 0)
2282          length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;        length = (md->jscript_compat)? 0 : -1;
2283        else      else
2284          length = md->offset_vector[offset+1] - md->offset_vector[offset];        length = md->offset_vector[offset+1] - md->offset_vector[offset];
2285    
2286        /* Set up for repetition, or handle the non-repeated case */      /* Set up for repetition, or handle the non-repeated case */
2287    
2288        switch (*ecode)      switch (*ecode)
2289          {        {
2290          case OP_CRSTAR:        case OP_CRSTAR:
2291          case OP_CRMINSTAR:        case OP_CRMINSTAR:
2292          case OP_CRPLUS:        case OP_CRPLUS:
2293          case OP_CRMINPLUS:        case OP_CRMINPLUS:
2294          case OP_CRQUERY:        case OP_CRQUERY:
2295          case OP_CRMINQUERY:        case OP_CRMINQUERY:
2296          c = *ecode++ - OP_CRSTAR;        c = *ecode++ - OP_CRSTAR;
2297          minimize = (c & 1) != 0;        minimize = (c & 1) != 0;
2298          min = rep_min[c];                 /* Pick up values from tables; */        min = rep_min[c];                 /* Pick up values from tables; */
2299          max = rep_max[c];                 /* zero for max => infinity */        max = rep_max[c];                 /* zero for max => infinity */
2300          if (max == 0) max = INT_MAX;        if (max == 0) max = INT_MAX;
2301          break;        break;
2302    
2303          case OP_CRRANGE:        case OP_CRRANGE:
2304          case OP_CRMINRANGE:        case OP_CRMINRANGE:
2305          minimize = (*ecode == OP_CRMINRANGE);        minimize = (*ecode == OP_CRMINRANGE);
2306          min = GET2(ecode, 1);        min = GET2(ecode, 1);
2307          max = GET2(ecode, 3);        max = GET2(ecode, 3);
2308          if (max == 0) max = INT_MAX;        if (max == 0) max = INT_MAX;
2309          ecode += 5;        ecode += 5;
2310          break;        break;
2311    
2312          default:               /* No repeat follows */        default:               /* No repeat follows */
2313          if (!match_ref(offset, eptr, length, md, ims))        if ((length = match_ref(offset, eptr, length, md, ims)) < 0)
2314            {          {
2315            CHECK_PARTIAL();          CHECK_PARTIAL();
2316            RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
           }  
         eptr += length;  
         continue;              /* With the main loop */  
2317          }          }
2318          eptr += length;
2319          continue;              /* With the main loop */
2320          }
2321    
2322        /* If the length of the reference is zero, just continue with the      /* Handle repeated back references. If the length of the reference is
2323        main loop. */      zero, just continue with the main loop. */
2324    
2325        if (length == 0) continue;      if (length == 0) continue;
2326    
2327        /* First, ensure the minimum number of matches are present. We get back      /* First, ensure the minimum number of matches are present. We get back
2328        the length of the reference string explicitly rather than passing the      the length of the reference string explicitly rather than passing the
2329        address of eptr, so that eptr can be a register variable. */      address of eptr, so that eptr can be a register variable. */
2330    
2331        for (i = 1; i <= min; i++)      for (i = 1; i <= min; i++)
2332          {
2333          int slength;
2334          if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
2335          {          {
2336          if (!match_ref(offset, eptr, length, md, ims))          CHECK_PARTIAL();
2337            {          MRRETURN(MATCH_NOMATCH);
           CHECK_PARTIAL();  
           RRETURN(MATCH_NOMATCH);  
           }  
         eptr += length;  
2338          }          }
2339          eptr += slength;
2340          }
2341    
2342        /* If min = max, continue at the same level without recursion.      /* If min = max, continue at the same level without recursion.
2343        They are not both allowed to be zero. */      They are not both allowed to be zero. */
2344    
2345        if (min == max) continue;      if (min == max) continue;
2346    
2347        /* If minimizing, keep trying and advancing the pointer */      /* If minimizing, keep trying and advancing the pointer */
2348    
2349        if (minimize)      if (minimize)
2350          {
2351          for (fi = min;; fi++)
2352          {          {
2353          for (fi = min;; fi++)          int slength;
2354            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2355            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2356            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2357            if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
2358            {            {
2359            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            CHECK_PARTIAL();
2360            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            MRRETURN(MATCH_NOMATCH);
           if (fi >= max) RRETURN(MATCH_NOMATCH);  
           if (!match_ref(offset, eptr, length, md, ims))  
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           eptr += length;  
2361            }            }
2362          /* Control never gets here */          eptr += slength;
2363          }          }
2364          /* Control never gets here */
2365          }
2366    
2367        /* If maximizing, find the longest string and work backwards */      /* If maximizing, find the longest string and work backwards */
2368    
2369        else      else
2370          {
2371          pp = eptr;
2372          for (i = min; i < max; i++)
2373          {          {
2374          pp = eptr;          int slength;
2375          for (i = min; i < max; i++)          if ((slength = match_ref(offset, eptr, length, md, ims)) < 0)
2376            {            {
2377            if (!match_ref(offset, eptr, length, md, ims))            CHECK_PARTIAL();
2378              {            break;
             CHECK_PARTIAL();  
             break;  
             }  
           eptr += length;  
           }  
         while (eptr >= pp)  
           {  
           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);  
           if (rrc != MATCH_NOMATCH) RRETURN(rrc);  
           eptr -= length;  
2379            }            }
2380          RRETURN(MATCH_NOMATCH);          eptr += slength;
2381            }
2382          while (eptr >= pp)
2383            {
2384            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
2385            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2386            eptr -= length;
2387          }          }
2388          MRRETURN(MATCH_NOMATCH);
2389        }        }
2390      /* Control never gets here */      /* Control never gets here */
2391    
# Line 2228  for (;;) Line 2446  for (;;)
2446            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2447              {              {
2448              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2449              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2450              }              }
2451            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2452            if (c > 255)            if (c > 255)
2453              {              {
2454              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2455              }              }
2456            else            else
2457              {              {
2458              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2459              }              }
2460            }            }
2461          }          }
# Line 2250  for (;;) Line 2468  for (;;)
2468            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2469              {              {
2470              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2471              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2472              }              }
2473            c = *eptr++;            c = *eptr++;
2474            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2475            }            }
2476          }          }
2477    
# Line 2275  for (;;) Line 2493  for (;;)
2493              {              {
2494              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2495              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2496              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2497              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2498                {                {
2499                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2500                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2501                }                }
2502              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2503              if (c > 255)              if (c > 255)
2504                {                {
2505                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2506                }                }
2507              else              else
2508                {                {
2509                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2510                }                }
2511              }              }
2512            }            }
# Line 2300  for (;;) Line 2518  for (;;)
2518              {              {
2519              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2520              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2521              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2522              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2523                {                {
2524                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2525                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2526                }                }
2527              c = *eptr++;              c = *eptr++;
2528              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2529              }              }
2530            }            }
2531          /* Control never gets here */          /* Control never gets here */
# Line 2373  for (;;) Line 2591  for (;;)
2591              }              }
2592            }            }
2593    
2594          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2595          }          }
2596        }        }
2597      /* Control never gets here */      /* Control never gets here */
# Line 2425  for (;;) Line 2643  for (;;)
2643          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2644            {            {
2645            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2646            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2647            }            }
2648          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2649          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2650          }          }
2651    
2652        /* 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 2663  for (;;)
2663            {            {
2664            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2665            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2666            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2667            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2668              {              {
2669              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2670              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2671              }              }
2672            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2673            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2674            }            }
2675          /* Control never gets here */          /* Control never gets here */
2676          }          }
# Line 2481  for (;;) Line 2699  for (;;)
2699            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2700            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2701            }            }
2702          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2703          }          }
2704    
2705        /* Control never gets here */        /* Control never gets here */
# Line 2500  for (;;) Line 2718  for (;;)
2718        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2719          {          {
2720          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2721          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2722          }          }
2723        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2724        }        }
2725      else      else
2726  #endif  #endif
# Line 2512  for (;;) Line 2730  for (;;)
2730        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2731          {          {
2732          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2733          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2734          }          }
2735        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2736        ecode += 2;        ecode += 2;
2737        }        }
2738      break;      break;
# Line 2532  for (;;) Line 2750  for (;;)
2750        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2751          {          {
2752          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2753          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2754          }          }
2755    
2756        /* 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 2758  for (;;)
2758    
2759        if (fc < 128)        if (fc < 128)
2760          {          {
2761          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2762          }          }
2763    
2764        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2559  for (;;) Line 2777  for (;;)
2777  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2778            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2779  #endif  #endif
2780              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2781            }            }
2782          }          }
2783        }        }
# Line 2571  for (;;) Line 2789  for (;;)
2789        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2790          {          {
2791          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2792          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2793          }          }
2794        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2795        ecode += 2;        ecode += 2;
2796        }        }
2797      break;      break;
# Line 2667  for (;;) Line 2885  for (;;)
2885            else            else
2886              {              {
2887              CHECK_PARTIAL();              CHECK_PARTIAL();
2888              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2889              }              }
2890            }            }
2891    
# Line 2679  for (;;) Line 2897  for (;;)
2897              {              {
2898              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2899              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2900              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2901              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2902                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2903  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2690  for (;;) Line 2908  for (;;)
2908              else              else
2909                {                {
2910                CHECK_PARTIAL();                CHECK_PARTIAL();
2911                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2912                }                }
2913              }              }
2914            /* Control never gets here */            /* Control never gets here */
# Line 2721  for (;;) Line 2939  for (;;)
2939              {              {
2940              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2941              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2942              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2943  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2944              eptr--;              eptr--;
2945              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2764  for (;;) Line 2982  for (;;)
2982          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2983            {            {
2984            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2985            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2986            }            }
2987          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2988          }          }
2989        if (min == max) continue;        if (min == max) continue;
2990        if (minimize)        if (minimize)
# Line 2775  for (;;) Line 2993  for (;;)
2993            {            {
2994            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2995            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2996            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2997            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2998              {              {
2999              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3000              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3001              }              }
3002            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3003            }            }
3004          /* Control never gets here */          /* Control never gets here */
3005          }          }
# Line 2807  for (;;) Line 3025  for (;;)
3025            eptr--;            eptr--;
3026            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3027            }            }
3028          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3029          }          }
3030        /* Control never gets here */        /* Control never gets here */
3031        }        }
# Line 2821  for (;;) Line 3039  for (;;)
3039          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3040            {            {
3041            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3042            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3043            }            }
3044          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3045          }          }
3046    
3047        if (min == max) continue;        if (min == max) continue;
# Line 2834  for (;;) Line 3052  for (;;)
3052            {            {
3053            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
3054            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3055            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
3056            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3057              {              {
3058              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3059              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3060              }              }
3061            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3062            }            }
3063          /* Control never gets here */          /* Control never gets here */
3064          }          }
# Line 2865  for (;;) Line 3083  for (;;)
3083            eptr--;            eptr--;
3084            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3085            }            }
3086          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3087          }          }
3088        }        }
3089      /* Control never gets here */      /* Control never gets here */
# Line 2877  for (;;) Line 3095  for (;;)
3095      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
3096        {        {
3097        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3098        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
3099        }        }
3100      ecode++;      ecode++;
3101      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2887  for (;;) Line 3105  for (;;)
3105        if (c < 256)        if (c < 256)
3106  #endif  #endif
3107        c = md->lcc[c];        c = md->lcc[c];
3108        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3109        }        }
3110      else      else
3111        {        {
3112        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3113        }        }
3114      break;      break;
3115    
# Line 2985  for (;;) Line 3203  for (;;)
3203            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3204              {              {
3205              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3206              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3207              }              }
3208            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3209            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3210            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3211            }            }
3212          }          }
3213        else        else
# Line 3002  for (;;) Line 3220  for (;;)
3220            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3221              {              {
3222              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3223              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3224              }              }
3225            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3226            }            }
3227          }          }
3228    
# Line 3021  for (;;) Line 3239  for (;;)
3239              {              {
3240              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3241              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3242              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3243              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3244                {                {
3245                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3246                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3247                }                }
3248              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3249              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3250              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3251              }              }
3252            }            }
3253          else          else
# Line 3040  for (;;) Line 3258  for (;;)
3258              {              {
3259              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3260              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3261              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3262              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3263                {                {
3264                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3265                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3266                }                }
3267              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3268              }              }
3269            }            }
3270          /* Control never gets here */          /* Control never gets here */
# Line 3108  for (;;) Line 3326  for (;;)
3326              }              }
3327            }            }
3328    
3329          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3330          }          }
3331        /* Control never gets here */        /* Control never gets here */
3332        }        }
# Line 3127  for (;;) Line 3345  for (;;)
3345            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3346              {              {
3347              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3348              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3349              }              }
3350            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3351            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3352            }            }
3353          }          }
3354        else        else
# Line 3142  for (;;) Line 3360  for (;;)
3360            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3361              {              {
3362              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3363              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3364              }              }
3365            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3366            }            }
3367          }          }
3368    
# Line 3161  for (;;) Line 3379  for (;;)
3379              {              {
3380              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3381              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3382              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3383              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3384                {                {
3385                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3386                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3387                }                }
3388              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3389              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3390              }              }
3391            }            }
3392          else          else
# Line 3179  for (;;) Line 3397  for (;;)
3397              {              {
3398              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3399              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3400              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3401              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3402                {                {
3403                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3404                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3405                }                }
3406              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3407              }              }
3408            }            }
3409          /* Control never gets here */          /* Control never gets here */
# Line 3246  for (;;) Line 3464  for (;;)
3464              }              }
3465            }            }
3466    
3467          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3468          }          }
3469        }        }
3470      /* Control never gets here */      /* Control never gets here */
# Line 3340  for (;;) Line 3558  for (;;)
3558          switch(prop_type)          switch(prop_type)
3559            {            {
3560            case PT_ANY:            case PT_ANY:
3561            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3562            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3563              {              {
3564              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3565                {                {
3566                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3567                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3568                }                }
3569              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3570              }              }
# Line 3358  for (;;) Line 3576  for (;;)
3576              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3577                {                {
3578                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3579                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3580                }                }
3581              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3582              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3583              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3584                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3585                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3586                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3587              }              }
3588            break;            break;
3589    
# Line 3375  for (;;) Line 3593  for (;;)
3593              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3594                {                {
3595                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3596                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3597                }                }
3598              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3599              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3600              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3601                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3602              }              }
3603            break;            break;
3604    
# Line 3390  for (;;) Line 3608  for (;;)
3608              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3609                {                {
3610                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3611                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3612                }                }
3613              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3614              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3615              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3616                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3617              }              }
3618            break;            break;
3619    
# Line 3405  for (;;) Line 3623  for (;;)
3623              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3624                {                {
3625                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3626                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3627                }                }
3628              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3629              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3630              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3631                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3632                }
3633              break;
3634    
3635              case PT_ALNUM:
3636              for (i = 1; i <= min; i++)
3637                {
3638                if (eptr >= md->end_subject)
3639                  {
3640                  SCHECK_PARTIAL();
3641                  MRRETURN(MATCH_NOMATCH);
3642                  }
3643                GETCHARINCTEST(c, eptr);
3644                prop_category = UCD_CATEGORY(c);
3645                if ((prop_category == ucp_L || prop_category == ucp_N)
3646                       == prop_fail_result)
3647                  MRRETURN(MATCH_NOMATCH);
3648                }
3649              break;
3650    
3651              case PT_SPACE:    /* Perl space */
3652              for (i = 1; i <= min; i++)
3653                {
3654                if (eptr >= md->end_subject)
3655                  {
3656                  SCHECK_PARTIAL();
3657                  MRRETURN(MATCH_NOMATCH);
3658                  }
3659                GETCHARINCTEST(c, eptr);
3660                prop_category = UCD_CATEGORY(c);
3661                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3662                     c == CHAR_FF || c == CHAR_CR)
3663                       == prop_fail_result)
3664                  MRRETURN(MATCH_NOMATCH);
3665              }              }
3666            break;            break;
3667    
3668              case PT_PXSPACE:  /* POSIX space */
3669              for (i = 1; i <= min; i++)
3670                {
3671                if (eptr >= md->end_subject)
3672                  {
3673                  SCHECK_PARTIAL();
3674                  MRRETURN(MATCH_NOMATCH);
3675                  }
3676                GETCHARINCTEST(c, eptr);
3677                prop_category = UCD_CATEGORY(c);
3678                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3679                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3680                       == prop_fail_result)
3681                  MRRETURN(MATCH_NOMATCH);
3682                }
3683              break;
3684    
3685              case PT_WORD:
3686              for (i = 1; i <= min; i++)
3687                {
3688                if (eptr >= md->end_subject)
3689                  {
3690                  SCHECK_PARTIAL();
3691                  MRRETURN(MATCH_NOMATCH);
3692                  }
3693                GETCHARINCTEST(c, eptr);
3694                prop_category = UCD_CATEGORY(c);
3695                if ((prop_category == ucp_L || prop_category == ucp_N ||
3696                     c == CHAR_UNDERSCORE)
3697                       == prop_fail_result)
3698                  MRRETURN(MATCH_NOMATCH);
3699                }
3700              break;
3701    
3702              /* This should not occur */
3703    
3704            default:            default:
3705            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
3706            }            }
# Line 3429  for (;;) Line 3716  for (;;)
3716            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3717              {              {
3718              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3719              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3720              }              }
3721            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3722            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3723            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3724            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3725              {              {
3726              int len = 1;              int len = 1;
# Line 3460  for (;;) Line 3747  for (;;)
3747            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3748              {              {
3749              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3750              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3751              }              }
3752            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3753            eptr++;            eptr++;
3754            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3755            }            }
# Line 3474  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            eptr++;            eptr++;
3767            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3482  for (;;) Line 3769  for (;;)
3769          break;          break;
3770    
3771          case OP_ANYBYTE:          case OP_ANYBYTE:
3772          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3773          eptr += min;          eptr += min;
3774          break;          break;
3775    
# Line 3492  for (;;) Line 3779  for (;;)
3779            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3780              {              {
3781              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3782              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3783              }              }
3784            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3785            switch(c)            switch(c)
3786              {              {
3787              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3788              case 0x000d:              case 0x000d:
3789              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3790              break;              break;
# Line 3510  for (;;) Line 3797  for (;;)
3797              case 0x0085:              case 0x0085:
3798              case 0x2028:              case 0x2028:
3799              case 0x2029:              case 0x2029:
3800              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3801              break;              break;
3802              }              }
3803            }            }
# Line 3522  for (;;) Line 3809  for (;;)
3809            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3810              {              {
3811              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3812              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3813              }              }
3814            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3815            switch(c)            switch(c)
# Line 3547  for (;;) Line 3834  for (;;)
3834              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3835              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3836              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3837              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3838              }              }
3839            }            }
3840          break;          break;
# Line 3558  for (;;) Line 3845  for (;;)
3845            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3846              {              {
3847              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3848              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3849              }              }
3850            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3851            switch(c)            switch(c)
3852              {              {
3853              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3854              case 0x09:      /* HT */              case 0x09:      /* HT */
3855              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3856              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3594  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            switch(c)            switch(c)
# Line 3607  for (;;) Line 3894  for (;;)
3894              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3895              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3896              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3897              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3898              }              }
3899            }            }
3900          break;          break;
# Line 3618  for (;;) Line 3905  for (;;)
3905            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3906              {              {
3907              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3908              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3909              }              }
3910            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3911            switch(c)            switch(c)
3912              {              {
3913              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3914              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3915              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3916              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3642  for (;;) Line 3929  for (;;)
3929            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3930              {              {
3931              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3932              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3933              }              }
3934            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3935            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3936              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3937            }            }
3938          break;          break;
3939    
# Line 3656  for (;;) Line 3943  for (;;)
3943            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3944              {              {
3945              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3946              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3947              }              }
3948            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3949              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3950            /* 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 */
3951            }            }
3952          break;          break;
# Line 3670  for (;;) Line 3957  for (;;)
3957            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3958              {              {
3959              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3960              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3961              }              }
3962            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3963              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3964            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3965            }            }
3966          break;          break;
# Line 3684  for (;;) Line 3971  for (;;)
3971            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3972              {              {
3973              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3974              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3975              }              }
3976            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3977              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3978            /* 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 */
3979            }            }
3980          break;          break;
# Line 3695  for (;;) Line 3982  for (;;)
3982          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3983          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3984            {            {
3985            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3986               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3987              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3988                MRRETURN(MATCH_NOMATCH);
3989                }
3990              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3991                MRRETURN(MATCH_NOMATCH);
3992            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3993            }            }
3994          break;          break;
# Line 3708  for (;;) Line 3999  for (;;)
3999            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4000              {              {
4001              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4002              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4003              }              }
4004            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
4005              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4006            /* 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 */
4007            }            }
4008          break;          break;
# Line 3734  for (;;) Line 4025  for (;;)
4025            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4026              {              {
4027              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4028              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4029              }              }
4030            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
4031            eptr++;            eptr++;
4032            }            }
4033          break;          break;
# Line 3745  for (;;) Line 4036  for (;;)
4036          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4037            {            {
4038            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4039            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
4040            }            }
4041          eptr += min;          eptr += min;
4042          break;          break;
# Line 3754  for (;;) Line 4045  for (;;)
4045          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4046            {            {
4047            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4048            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
4049            }            }
4050          eptr += min;          eptr += min;
4051          break;          break;
# Line 3765  for (;;) Line 4056  for (;;)
4056            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4057              {              {
4058              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4059              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4060              }              }
4061            switch(*eptr++)            switch(*eptr++)
4062              {              {
4063              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4064              case 0x000d:              case 0x000d:
4065              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4066              break;              break;
# Line 3779  for (;;) Line 4070  for (;;)
4070              case 0x000b:              case 0x000b:
4071              case 0x000c:              case 0x000c:
4072              case 0x0085:              case 0x0085:
4073              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4074              break;              break;
4075              }              }
4076            }            }
# Line 3791  for (;;) Line 4082  for (;;)
4082            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4083              {              {
4084              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4085              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4086              }              }
4087            switch(*eptr++)            switch(*eptr++)
4088              {              {
# Line 3799  for (;;) Line 4090  for (;;)
4090              case 0x09:      /* HT */              case 0x09:      /* HT */
4091              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4092              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4093              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4094              }              }
4095            }            }
4096          break;          break;
# Line 3810  for (;;) Line 4101  for (;;)
4101            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4102              {              {
4103              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4104              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4105              }              }
4106            switch(*eptr++)            switch(*eptr++)
4107              {              {
4108              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4109              case 0x09:      /* HT */              case 0x09:      /* HT */
4110              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4111              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3829  for (;;) Line 4120  for (;;)
4120            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4121              {              {
4122              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4123              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4124              }              }
4125            switch(*eptr++)            switch(*eptr++)
4126              {              {
# Line 3839  for (;;) Line 4130  for (;;)
4130              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4131              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4132              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4133              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4134              }              }
4135            }            }
4136          break;          break;
# Line 3850  for (;;) Line 4141  for (;;)
4141            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4142              {              {
4143              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4144              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4145              }              }
4146            switch(*eptr++)            switch(*eptr++)
4147              {              {
4148              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4149              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4150              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4151              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3871  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_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4168            }            }
4169          break;          break;
4170    
# Line 3883  for (;;) Line 4174  for (;;)
4174            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4175              {              {
4176              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4177              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4178              }              }
4179            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4180            }            }
4181          break;          break;
4182    
# Line 3895  for (;;) Line 4186  for (;;)
4186            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4187              {              {
4188              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4189              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4190              }              }
4191            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4192            }            }
4193          break;          break;
4194    
# Line 3907  for (;;) Line 4198  for (;;)
4198            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4199              {              {
4200              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4201              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4202              }              }
4203            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4204            }            }
4205          break;          break;
4206    
# Line 3919  for (;;) Line 4210  for (;;)
4210            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4211              {              {
4212              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4213              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4214              }              }
4215            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4216              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4217            }            }
4218          break;          break;
4219    
# Line 3932  for (;;) Line 4223  for (;;)
4223            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4224              {              {
4225              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4226              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4227              }              }
4228            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4229              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4230            }            }
4231          break;          break;
4232    
# Line 3964  for (;;) Line 4255  for (;;)
4255              {              {
4256              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4257              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4258              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4259              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4260                {                {
4261                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4262                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4263                }                }
4264              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4265              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4266              }              }
4267            /* Control never gets here */            /* Control never gets here */
4268    
# Line 3980  for (;;) Line 4271  for (;;)
4271              {              {
4272              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4273              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4274              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4275              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4276                {                {
4277                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4278                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4279                }                }
4280              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4281              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4282              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4283                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4284                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4285                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4286              }              }
4287            /* Control never gets here */            /* Control never gets here */
4288    
# Line 4000  for (;;) Line 4291  for (;;)
4291              {              {
4292              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4293              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4294              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4295              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4296                {                {
4297                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4298                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4299                }                }
4300              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4301              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4302              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4303                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4304              }              }
4305            /* Control never gets here */            /* Control never gets here */
4306    
# Line 4018  for (;;) Line 4309  for (;;)
4309              {              {
4310              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4311              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4312              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4313              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4314                {                {
4315                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4316                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4317                }                }
4318              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4319              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4320              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4321                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4322              }              }
4323            /* Control never gets here */            /* Control never gets here */
4324    
# Line 4036  for (;;) Line 4327  for (;;)
4327              {              {
4328              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4329              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4330              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4331              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4332                {                {
4333                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4334                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4335                }                }
4336              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4337              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4338              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4339                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4340                }
4341              /* Control never gets here */
4342    
4343              case PT_ALNUM:
4344              for (fi = min;; fi++)
4345                {
4346                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59);
4347                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4348                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4349                if (eptr >= md->end_subject)
4350                  {
4351                  SCHECK_PARTIAL();
4352                  MRRETURN(MATCH_NOMATCH);
4353                  }
4354                GETCHARINCTEST(c, eptr);
4355                prop_category = UCD_CATEGORY(c);
4356                if ((prop_category == ucp_L || prop_category == ucp_N)
4357                       == prop_fail_result)
4358                  MRRETURN(MATCH_NOMATCH);
4359                }
4360              /* Control never gets here */
4361    
4362              case PT_SPACE:    /* Perl space */
4363              for (fi = min;; fi++)
4364                {
4365                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
4366                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4367                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4368                if (eptr >= md->end_subject)
4369                  {
4370                  SCHECK_PARTIAL();
4371                  MRRETURN(MATCH_NOMATCH);
4372                  }
4373                GETCHARINCTEST(c, eptr);
4374                prop_category = UCD_CATEGORY(c);
4375                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4376                     c == CHAR_FF || c == CHAR_CR)
4377                       == prop_fail_result)
4378                  MRRETURN(MATCH_NOMATCH);
4379              }              }
4380            /* Control never gets here */            /* Control never gets here */
4381    
4382              case PT_PXSPACE:  /* POSIX space */
4383              for (fi = min;; fi++)
4384                {
4385                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
4386                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4387                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4388                if (eptr >= md->end_subject)
4389                  {
4390                  SCHECK_PARTIAL();
4391                  MRRETURN(MATCH_NOMATCH);
4392                  }
4393                GETCHARINCTEST(c, eptr);
4394                prop_category = UCD_CATEGORY(c);
4395                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4396                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4397                       == prop_fail_result)
4398                  MRRETURN(MATCH_NOMATCH);
4399                }
4400              /* Control never gets here */
4401    
4402              case PT_WORD:
4403              for (fi = min;; fi++)
4404                {
4405                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
4406                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4407                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4408                if (eptr >= md->end_subject)
4409                  {
4410                  SCHECK_PARTIAL();
4411                  MRRETURN(MATCH_NOMATCH);
4412                  }
4413                GETCHARINCTEST(c, eptr);
4414                prop_category = UCD_CATEGORY(c);
4415                if ((prop_category == ucp_L ||
4416                     prop_category == ucp_N ||
4417                     c == CHAR_UNDERSCORE)
4418                       == prop_fail_result)
4419                  MRRETURN(MATCH_NOMATCH);
4420                }
4421              /* Control never gets here */
4422    
4423              /* This should never occur */
4424    
4425            default:            default:
4426            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4427            }            }
# Line 4063  for (;;) Line 4436  for (;;)
4436            {            {
4437            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4438            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4439            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4440            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4441              {              {
4442              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4443              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4444              }              }
4445            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4446            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4447            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4448            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4449              {              {
4450              int len = 1;              int len = 1;
# Line 4095  for (;;) Line 4468  for (;;)
4468            {            {
4469            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4470            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4471            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4472            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4473              {              {
4474              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4475              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4476              }              }
4477            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4478              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4479            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4480            switch(ctype)            switch(ctype)
4481              {              {
# Line 4114  for (;;) Line 4487  for (;;)
4487              case OP_ANYNL:              case OP_ANYNL:
4488              switch(c)              switch(c)
4489                {                {
4490                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4491                case 0x000d:                case 0x000d:
4492                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4493                break;                break;
# Line 4126  for (;;) Line 4499  for (;;)
4499                case 0x0085:                case 0x0085:
4500                case 0x2028:                case 0x2028:
4501                case 0x2029:                case 0x2029:
4502                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4503                break;                break;
4504                }                }
4505              break;              break;
# Line 4154  for (;;) Line 4527  for (;;)
4527                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4528                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4529                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4530                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4531                }                }
4532              break;              break;
4533    
4534              case OP_HSPACE:              case OP_HSPACE:
4535              switch(c)              switch(c)
4536                {                {
4537                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4538                case 0x09:      /* HT */                case 0x09:      /* HT */
4539                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4540                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4196  for (;;) Line 4569  for (;;)
4569                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4570                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4571                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4572                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4573                }                }
4574              break;              break;
4575    
4576              case OP_VSPACE:              case OP_VSPACE:
4577              switch(c)              switch(c)
4578                {                {
4579                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4580                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4581                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4582                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4217  for (;;) Line 4590  for (;;)
4590    
4591              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4592              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4593                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4594              break;              break;
4595    
4596              case OP_DIGIT:              case OP_DIGIT:
4597              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4598                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4599              break;              break;
4600    
4601              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4602              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4603                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4604              break;              break;
4605    
4606              case OP_WHITESPACE:              case OP_WHITESPACE:
4607              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4608                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4609              break;              break;
4610    
4611              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4612              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4613                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4614              break;              break;
4615    
4616              case OP_WORDCHAR:              case OP_WORDCHAR:
4617              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4618                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4619              break;              break;
4620    
4621              default:              default:
# Line 4258  for (;;) Line 4631  for (;;)
4631            {            {
4632            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4633            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4634            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4635            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4636              {              {
4637              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4638              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4639              }              }
4640            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4641              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4642            c = *eptr++;            c = *eptr++;
4643            switch(ctype)            switch(ctype)
4644              {              {
# Line 4277  for (;;) Line 4650  for (;;)
4650              case OP_ANYNL:              case OP_ANYNL:
4651              switch(c)              switch(c)
4652                {                {
4653                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4654                case 0x000d:                case 0x000d:
4655                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4656                break;                break;
# Line 4288  for (;;) Line 4661  for (;;)
4661                case 0x000b:                case 0x000b:
4662                case 0x000c:                case 0x000c:
4663                case 0x0085:                case 0x0085:
4664                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4665                break;                break;
4666                }                }
4667              break;              break;
# Line 4300  for (;;) Line 4673  for (;;)
4673                case 0x09:      /* HT */                case 0x09:      /* HT */
4674                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4675                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4676                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4677                }                }
4678              break;              break;
4679    
4680              case OP_HSPACE:              case OP_HSPACE:
4681              switch(c)              switch(c)
4682                {                {
4683                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4684                case 0x09:      /* HT */                case 0x09:      /* HT */
4685                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4686                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4324  for (;;) Line 4697  for (;;)
4697                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4698                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4699                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4700                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4701                }                }
4702              break;              break;
4703    
4704              case OP_VSPACE:              case OP_VSPACE:
4705              switch(c)              switch(c)
4706                {                {
4707                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4708                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4709                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4710                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4342  for (;;) Line 4715  for (;;)
4715              break;              break;
4716    
4717              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4718              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4719              break;              break;
4720    
4721              case OP_DIGIT:              case OP_DIGIT:
4722              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4723              break;              break;
4724    
4725              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4726              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4727              break;              break;
4728    
4729              case OP_WHITESPACE:              case OP_WHITESPACE:
4730              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4731              break;              break;
4732    
4733              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4734              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4735              break;              break;
4736    
4737              case OP_WORDCHAR:              case OP_WORDCHAR:
4738              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4739              break;              break;
4740    
4741              default:              default:
# Line 4395  for (;;) Line 4768  for (;;)
4768                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4769                break;                break;
4770                }                }
4771              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4772              if (prop_fail_result) break;              if (prop_fail_result) break;
4773              eptr+= len;              eptr+= len;
4774              }              }
# Line 4410  for (;;) Line 4783  for (;;)
4783                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4784                break;                break;
4785                }                }
4786              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4787              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4788              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4789                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
# Line 4429  for (;;) Line 4802  for (;;)
4802                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4803                break;                break;
4804                }                }
4805              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4806              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4807              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4808                break;                break;
# Line 4446  for (;;) Line 4819  for (;;)
4819                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4820                break;                break;
4821                }                }
4822              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4823              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4824              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4825                break;                break;
# Line 4463  for (;;) Line 4836  for (;;)
4836                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4837                break;                break;
4838                }                }
4839              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4840              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4841              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4842                break;                break;
4843              eptr+= len;              eptr+= len;
4844              }              }
4845            break;            break;
4846    
4847              case PT_ALNUM:
4848              for (i = min; i < max; i++)
4849                {
4850                int len = 1;
4851                if (eptr >= md->end_subject)
4852                  {
4853                  SCHECK_PARTIAL();
4854                  break;
4855                  }
4856                GETCHARLENTEST(c, eptr, len);
4857                prop_category = UCD_CATEGORY(c);
4858                if ((prop_category == ucp_L || prop_category == ucp_N)
4859                     == prop_fail_result)
4860                  break;
4861                eptr+= len;
4862                }
4863              break;
4864    
4865              case PT_SPACE:    /* Perl space */
4866              for (i = min; i < max; i++)
4867                {
4868                int len = 1;
4869                if (eptr >= md->end_subject)
4870                  {
4871                  SCHECK_PARTIAL();
4872                  break;
4873                  }
4874                GETCHARLENTEST(c, eptr, len);
4875                prop_category = UCD_CATEGORY(c);
4876                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4877                     c == CHAR_FF || c == CHAR_CR)
4878                     == prop_fail_result)
4879                  break;
4880                eptr+= len;
4881                }
4882              break;
4883    
4884              case PT_PXSPACE:  /* POSIX space */
4885              for (i = min; i < max; i++)
4886                {
4887                int len = 1;
4888                if (eptr >= md->end_subject)
4889                  {
4890                  SCHECK_PARTIAL();
4891                  break;
4892                  }
4893                GETCHARLENTEST(c, eptr, len);
4894                prop_category = UCD_CATEGORY(c);
4895                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4896                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4897                     == prop_fail_result)
4898                  break;
4899                eptr+= len;
4900                }
4901              break;
4902    
4903              case PT_WORD:
4904              for (i = min; i < max; i++)
4905                {
4906                int len = 1;
4907                if (eptr >= md->end_subject)
4908                  {
4909                  SCHECK_PARTIAL();
4910                  break;
4911                  }
4912                GETCHARLENTEST(c, eptr, len);
4913                prop_category = UCD_CATEGORY(c);
4914                if ((prop_category == ucp_L || prop_category == ucp_N ||
4915                     c == CHAR_UNDERSCORE) == prop_fail_result)
4916                  break;
4917                eptr+= len;
4918                }
4919              break;
4920    
4921              default:
4922              RRETURN(PCRE_ERROR_INTERNAL);
4923            }            }
4924    
4925          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5022  for (;;) Line 5472  for (;;)
5472    
5473        /* 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 */
5474    
5475        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5476        }        }
5477      /* Control never gets here */      /* Control never gets here */
5478    
# Line 5055  switch (frame->Xwhere) Line 5505  switch (frame->Xwhere)
5505    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)
5506    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)
5507    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)
5508    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5509  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5510    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)
5511    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
5512  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
5513    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)
5514      LBL(59) LBL(60) LBL(61) LBL(62)
5515  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
5516  #endif  /* SUPPORT_UTF8 */  #endif  /* SUPPORT_UTF8 */
5517    default:    default:
# Line 5194  if ((options & ~PUBLIC_EXEC_OPTIONS) != Line 5645  if ((options & ~PUBLIC_EXEC_OPTIONS) !=
5645  if (re == NULL || subject == NULL ||  if (re == NULL || subject == NULL ||
5646     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
5647  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5648    if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
5649    
5650  /* This information is for finding all the numbers associated with a given  /* This information is for finding all the numbers associated with a given
5651  name, for condition testing. */  name, for condition testing. */
# Line 5264  end_subject = md->end_subject; Line 5716  end_subject = md->end_subject;
5716    
5717  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
5718  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
5719    md->use_ucp = (re->options & PCRE_UCP) != 0;
5720  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
5721    
5722  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
# Line 5273  md->notempty_atstart = (options & PCRE_N Line 5726  md->notempty_atstart = (options & PCRE_N
5726  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5727                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5728  md->hitend = FALSE;  md->hitend = FALSE;
5729    md->mark = NULL;                        /* In case never set */
5730    
5731  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5732    
# Line 5358  back the character offset. */ Line 5812  back the character offset. */
5812  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5813  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
5814    {    {
5815    if (_pcre_valid_utf8((USPTR)subject, length) >= 0)    int tb;
5816      return PCRE_ERROR_BADUTF8;    if ((tb = _pcre_valid_utf8((USPTR)subject, length)) >= 0)
5817        return (tb == length && md->partial > 1)?
5818          PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
5819    if (start_offset > 0 && start_offset < length)    if (start_offset > 0 && start_offset < length)
5820      {      {
5821      int tb = ((USPTR)subject)[start_offset];      tb = ((USPTR)subject)[start_offset] & 0xc0;
5822      if (tb > 127)      if (tb == 0x80) return PCRE_ERROR_BADUTF8_OFFSET;
       {  
       tb &= 0xc0;  
       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;  
       }  
5823      }      }
5824    }    }
5825  #endif  #endif
# Line 5495  for(;;) Line 5947  for(;;)
5947    /* There are some optimizations that avoid running the match if a known    /* There are some optimizations that avoid running the match if a known
5948    starting point is not found, or if a known later character is not present.    starting point is not found, or if a known later character is not present.
5949    However, there is an option that disables these, for testing and for ensuring    However, there is an option that disables these, for testing and for ensuring
5950    that all callouts do actually occur. */    that all callouts do actually occur. The option can be set in the regex by
5951      (*NO_START_OPT) or passed in match-time options. */
5952    
5953    if ((options & PCRE_NO_START_OPTIMIZE) == 0)    if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
5954      {      {
5955      /* Advance to a unique first byte if there is one. */      /* Advance to a unique first byte if there is one. */
5956    
# Line 5551  for(;;) Line 6004  for(;;)
6004        while (start_match < end_subject)        while (start_match < end_subject)
6005          {          {
6006          register unsigned int c = *start_match;          register unsigned int c = *start_match;
6007          if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++;          if ((start_bits[c/8] & (1 << (c&7))) == 0)
6008            else break;            {
6009              start_match++;
6010    #ifdef SUPPORT_UTF8
6011              if (utf8)
6012                while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
6013                  start_match++;
6014    #endif
6015              }
6016            else break;
6017          }          }
6018        }        }
6019      }   /* Starting optimizations */      }   /* Starting optimizations */
# Line 5572  for(;;) Line 6033  for(;;)
6033      bytes to avoid spending too much time in this optimization. */      bytes to avoid spending too much time in this optimization. */
6034    
6035      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
6036          end_subject - start_match < study->minlength)          (pcre_uint32)(end_subject - start_match) < study->minlength)
6037        {        {
6038        rc = MATCH_NOMATCH;        rc = MATCH_NOMATCH;
6039        break;        break;
# Line 5647  for(;;) Line 6108  for(;;)
6108    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
6109    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
6110    md->match_call_count = 0;    md->match_call_count = 0;
6111    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,
6112        0, 0);
6113    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
6114    
6115    switch(rc)    switch(rc)
6116      {      {
6117        /* SKIP passes back the next starting point explicitly, but if it is the
6118        same as the match we have just done, treat it as NOMATCH. */
6119    
6120        case MATCH_SKIP:
6121        if (md->start_match_ptr != start_match)
6122          {
6123          new_start_match = md->start_match_ptr;
6124          break;
6125          }
6126        /* Fall through */
6127    
6128        /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
6129        the SKIP's arg was not found. We also treat this as NOMATCH. */
6130    
6131        case MATCH_SKIP_ARG:
6132        /* Fall through */
6133    
6134      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6135      exactly like PRUNE. */      exactly like PRUNE. */
6136    
# Line 5666  for(;;) Line 6145  for(;;)
6145  #endif  #endif
6146      break;      break;
6147    
     /* SKIP passes back the next starting point explicitly. */  
   
     case MATCH_SKIP:  
     new_start_match = md->start_match_ptr;  
     break;  
   
6148      /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */      /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
6149    
6150      case MATCH_COMMIT:      case MATCH_COMMIT:
# Line 5717  for(;;) Line 6190  for(;;)
6190           md->nllen == 2))           md->nllen == 2))
6191      start_match++;      start_match++;
6192    
6193    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
6194      }                  /* End of for(;;) "bumpalong" loop */
6195    
6196  /* ==========================================================================*/  /* ==========================================================================*/
6197    
# Line 5741  capturing parentheses than vector slots. Line 6215  capturing parentheses than vector slots.
6215    
6216  ENDLOOP:  ENDLOOP:
6217    
6218  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
6219    {    {
6220    if (using_temporary_offsets)    if (using_temporary_offsets)
6221      {      {
# Line 5767  if (rc == MATCH_MATCH) Line 6241  if (rc == MATCH_MATCH)
6241    
6242    if (offsetcount < 2) rc = 0; else    if (offsetcount < 2) rc = 0; else
6243      {      {
6244      offsets[0] = md->start_match_ptr - md->start_subject;      offsets[0] = (int)(md->start_match_ptr - md->start_subject);
6245      offsets[1] = md->end_match_ptr - md->start_subject;      offsets[1] = (int)(md->end_match_ptr - md->start_subject);
6246      }      }
6247    
6248    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6249    return rc;    goto RETURN_MARK;
6250    }    }
6251    
6252  /* Control gets here if there has been an error, or if the overall match  /* Control gets here if there has been an error, or if the overall match
# Line 5784  if (using_temporary_offsets) Line 6258  if (using_temporary_offsets)
6258    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
6259    }    }
6260    
6261    /* For anything other than nomatch or partial match, just return the code. */
6262    
6263  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6264    {    {
6265    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6266    return rc;    return rc;
6267    }    }
6268  else if (start_partial != NULL)  
6269    /* Handle partial matches - disable any mark data */
6270    
6271    if (start_partial != NULL)
6272    {    {
6273    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
6274      md->mark = NULL;
6275    if (offsetcount > 1)    if (offsetcount > 1)
6276      {      {
6277      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = (int)(start_partial - (USPTR)subject);
6278      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = (int)(end_subject - (USPTR)subject);
6279      }      }
6280    return PCRE_ERROR_PARTIAL;    rc = PCRE_ERROR_PARTIAL;
6281    }    }
6282    
6283    /* This is the classic nomatch case */
6284    
6285  else  else
6286    {    {
6287    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
6288    return PCRE_ERROR_NOMATCH;    rc = PCRE_ERROR_NOMATCH;
6289    }    }
6290    
6291    /* Return the MARK data if it has been requested. */
6292    
6293    RETURN_MARK:
6294    
6295    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6296      *(extra_data->mark) = (unsigned char *)(md->mark);
6297    return rc;
6298  }  }
6299    
6300  /* End of pcre_exec.c */  /* End of pcre_exec.c */

Legend:
Removed from v.475  
changed lines
  Added in v.595

  ViewVC Help
Powered by ViewVC 1.1.5