/[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 463 by ph10, Sun Oct 18 10:02:46 2009 UTC revision 534 by ph10, Thu Jun 3 18:26:05 2010 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2009 University of Cambridge             Copyright (c) 1997-2010 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 71  defined PCRE_ERROR_xxx codes, which are Line 71  defined PCRE_ERROR_xxx codes, which are
71  /* Special internal returns from the match() function. Make them sufficiently  /* Special internal returns from the match() function. Make them sufficiently
72  negative to avoid the external error codes. */  negative to avoid the external error codes. */
73    
74  #define MATCH_COMMIT       (-999)  #define MATCH_ACCEPT       (-999)
75  #define MATCH_PRUNE        (-998)  #define MATCH_COMMIT       (-998)
76  #define MATCH_SKIP         (-997)  #define MATCH_PRUNE        (-997)
77  #define MATCH_THEN         (-996)  #define MATCH_SKIP         (-996)
78    #define MATCH_SKIP_ARG     (-995)
79    #define MATCH_THEN         (-994)
80    
81    /* This is a convenience macro for code that occurs many times. */
82    
83    #define MRRETURN(ra) \
84      { \
85      md->mark = markptr; \
86      RRETURN(ra); \
87      }
88    
89  /* Maximum number of ints of offset to save on the stack for recursive calls.  /* Maximum number of ints of offset to save on the stack for recursive calls.
90  If the offset vector is bigger, malloc is used. This should be a multiple of 3,  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
# Line 89  static const char rep_max[] = { 0, 0, 0, Line 99  static const char rep_max[] = { 0, 0, 0,
99    
100    
101    
102  #ifdef DEBUG  #ifdef PCRE_DEBUG
103  /*************************************************  /*************************************************
104  *        Debugging function to print chars       *  *        Debugging function to print chars       *
105  *************************************************/  *************************************************/
# Line 141  match_ref(int offset, register USPTR ept Line 151  match_ref(int offset, register USPTR ept
151  {  {
152  USPTR p = md->start_subject + md->offset_vector[offset];  USPTR p = md->start_subject + md->offset_vector[offset];
153    
154  #ifdef DEBUG  #ifdef PCRE_DEBUG
155  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
156    printf("matching subject <null>");    printf("matching subject <null>");
157  else  else
# Line 245  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 255  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
255         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
256         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
257         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
258         RM51,  RM52, RM53, RM54 };         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
259           RM61,  RM62 };
260    
261  /* These versions of the macros use the stack, as normal. There are debugging  /* These versions of the macros use the stack, as normal. There are debugging
262  versions and production versions. Note that the "rw" argument of RMATCH isn't  versions and production versions. Note that the "rw" argument of RMATCH isn't
263  actuall used in this definition. */  actually used in this definition. */
264    
265  #ifndef NO_RECURSE  #ifndef NO_RECURSE
266  #define REGISTER register  #define REGISTER register
267    
268  #ifdef DEBUG  #ifdef PCRE_DEBUG
269  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
270    { \    { \
271    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
272    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
273    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
274    }    }
275  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 268  actuall used in this definition. */ Line 279  actuall used in this definition. */
279    }    }
280  #else  #else
281  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
282    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
283  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
284  #endif  #endif
285    
# Line 284  argument of match(), which never changes Line 295  argument of match(), which never changes
295  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
296    {\    {\
297    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
298      if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
299    frame->Xwhere = rw; \    frame->Xwhere = rw; \
300    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
301    newframe->Xecode = rb;\    newframe->Xecode = rb;\
302    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
303      newframe->Xmarkptr = markptr;\
304    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
305    newframe->Xims = re;\    newframe->Xims = re;\
306    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 303  argument of match(), which never changes Line 316  argument of match(), which never changes
316    
317  #define RRETURN(ra)\  #define RRETURN(ra)\
318    {\    {\
319    heapframe *newframe = frame;\    heapframe *oldframe = frame;\
320    frame = newframe->Xprevframe;\    frame = oldframe->Xprevframe;\
321    (pcre_stack_free)(newframe);\    (pcre_stack_free)(oldframe);\
322    if (frame != NULL)\    if (frame != NULL)\
323      {\      {\
324      rrc = ra;\      rrc = ra;\
# Line 325  typedef struct heapframe { Line 338  typedef struct heapframe {
338    USPTR Xeptr;    USPTR Xeptr;
339    const uschar *Xecode;    const uschar *Xecode;
340    USPTR Xmstart;    USPTR Xmstart;
341      USPTR Xmarkptr;
342    int Xoffset_top;    int Xoffset_top;
343    long int Xims;    long int Xims;
344    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 411  the subject. */ Line 425  the subject. */
425    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
426      {\      {\
427      md->hitend = TRUE;\      md->hitend = TRUE;\
428      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
429      }      }
430    
431  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
432    if (md->partial != 0 && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
433      {\      {\
434      md->hitend = TRUE;\      md->hitend = TRUE;\
435      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
436      }      }
437    
438    
# Line 432  Arguments: Line 446  Arguments:
446     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
447     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
448                   by encountering \K)                   by encountering \K)
449       markptr     pointer to the most recent MARK name, or NULL
450     offset_top  current top pointer     offset_top  current top pointer
451     md          pointer to "static" info for the match     md          pointer to "static" info for the match
452     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 445  Arguments: Line 460  Arguments:
460    
461  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
462                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
463                   a negative MATCH_xxx value for PRUNE, SKIP, etc
464                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
465                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
466  */  */
467    
468  static int  static int
469  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
470    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,
471    int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
472  {  {
473  /* 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,
474  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 473  heap whenever RMATCH() does a "recursion Line 489  heap whenever RMATCH() does a "recursion
489    
490  #ifdef NO_RECURSE  #ifdef NO_RECURSE
491  heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));  heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
492    if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
493  frame->Xprevframe = NULL;            /* Marks the top level */  frame->Xprevframe = NULL;            /* Marks the top level */
494    
495  /* Copy in the original argument variables */  /* Copy in the original argument variables */
# Line 480  frame->Xprevframe = NULL;            /* Line 497  frame->Xprevframe = NULL;            /*
497  frame->Xeptr = eptr;  frame->Xeptr = eptr;
498  frame->Xecode = ecode;  frame->Xecode = ecode;
499  frame->Xmstart = mstart;  frame->Xmstart = mstart;
500    frame->Xmarkptr = markptr;
501  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
502  frame->Xims = ims;  frame->Xims = ims;
503  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 495  HEAP_RECURSE: Line 513  HEAP_RECURSE:
513  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
514  #define ecode              frame->Xecode  #define ecode              frame->Xecode
515  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
516    #define markptr            frame->Xmarkptr
517  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
518  #define ims                frame->Xims  #define ims                frame->Xims
519  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 622  TAIL_RECURSE: Line 641  TAIL_RECURSE:
641  /* OK, now we can get on with the real code of the function. Recursive calls  /* OK, now we can get on with the real code of the function. Recursive calls
642  are specified by the macro RMATCH and RRETURN is used to return. When  are specified by the macro RMATCH and RRETURN is used to return. When
643  NO_RECURSE is *not* defined, these just turn into a recursive call to match()  NO_RECURSE is *not* defined, these just turn into a recursive call to match()
644  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
645  defined). However, RMATCH isn't like a function call because it's quite a  defined). However, RMATCH isn't like a function call because it's quite a
646  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
647  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# Line 666  for (;;) Line 685  for (;;)
685    
686    switch(op)    switch(op)
687      {      {
688        case OP_MARK:
689        markptr = ecode + 2;
690        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
691          ims, eptrb, flags, RM55);
692    
693        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
694        argument, and we must check whether that argument matches this MARK's
695        argument. It is passed back in md->start_match_ptr (an overloading of that
696        variable). If it does match, we reset that variable to the current subject
697        position and return MATCH_SKIP. Otherwise, pass back the return code
698        unaltered. */
699    
700        if (rrc == MATCH_SKIP_ARG &&
701            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
702          {
703          md->start_match_ptr = eptr;
704          RRETURN(MATCH_SKIP);
705          }
706    
707        if (md->mark == NULL) md->mark = markptr;
708        RRETURN(rrc);
709    
710      case OP_FAIL:      case OP_FAIL:
711      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
712    
713        case OP_COMMIT:
714        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
715          ims, eptrb, flags, RM52);
716        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
717        MRRETURN(MATCH_COMMIT);
718    
719      case OP_PRUNE:      case OP_PRUNE:
720      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
721        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
722      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
723      RRETURN(MATCH_PRUNE);      MRRETURN(MATCH_PRUNE);
724    
725      case OP_COMMIT:      case OP_PRUNE_ARG:
726      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
727        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM56);
728      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
729      RRETURN(MATCH_COMMIT);      md->mark = ecode + 2;
730        RRETURN(MATCH_PRUNE);
731    
732      case OP_SKIP:      case OP_SKIP:
733      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
734        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
735      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
736      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
737      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
738    
739        case OP_SKIP_ARG:
740        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
741          ims, eptrb, flags, RM57);
742        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
743    
744        /* Pass back the current skip name by overloading md->start_match_ptr and
745        returning the special MATCH_SKIP_ARG return code. This will either be
746        caught by a matching MARK, or get to the top, where it is treated the same
747        as PRUNE. */
748    
749        md->start_match_ptr = ecode + 2;
750        RRETURN(MATCH_SKIP_ARG);
751    
752      case OP_THEN:      case OP_THEN:
753      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
754        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
755      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
756        MRRETURN(MATCH_THEN);
757    
758        case OP_THEN_ARG:
759        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
760          ims, eptrb, flags, RM58);
761        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
762        md->mark = ecode + 2;
763      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
764    
765      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
# Line 713  for (;;) Line 781  for (;;)
781      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
782      offset = number << 1;      offset = number << 1;
783    
784  #ifdef DEBUG  #ifdef PCRE_DEBUG
785      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
786      printf("subject=");      printf("subject=");
787      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# Line 728  for (;;) Line 796  for (;;)
796        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
797    
798        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
799        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;        md->offset_vector[md->offset_end - number] =
800            (int)(eptr - md->start_subject);
801    
802        flags = (op == OP_SCBRA)? match_cbegroup : 0;        flags = (op == OP_SCBRA)? match_cbegroup : 0;
803        do        do
# Line 747  for (;;) Line 816  for (;;)
816        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
817        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
818    
819          if (rrc != MATCH_THEN) md->mark = markptr;
820        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
821        }        }
822    
# Line 786  for (;;) Line 856  for (;;)
856    
857          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
858            eptrb, flags, RM48);            eptrb, flags, RM48);
859            if (rrc == MATCH_NOMATCH) md->mark = markptr;
860          RRETURN(rrc);          RRETURN(rrc);
861          }          }
862    
# Line 821  for (;;) Line 892  for (;;)
892          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
893          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
894          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
895          cb.subject_length   = md->end_subject - md->start_subject;          cb.subject_length   = (int)(md->end_subject - md->start_subject);
896          cb.start_match      = mstart - md->start_subject;          cb.start_match      = (int)(mstart - md->start_subject);
897          cb.current_position = eptr - md->start_subject;          cb.current_position = (int)(eptr - md->start_subject);
898          cb.pattern_position = GET(ecode, LINK_SIZE + 3);          cb.pattern_position = GET(ecode, LINK_SIZE + 3);
899          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
900          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
901          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
902          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
903          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
904          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
905          }          }
906        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 1039  for (;;) Line 1110  for (;;)
1110      number = GET2(ecode, 1);      number = GET2(ecode, 1);
1111      offset = number << 1;      offset = number << 1;
1112    
1113  #ifdef DEBUG  #ifdef PCRE_DEBUG
1114        printf("end bracket %d at *ACCEPT", number);        printf("end bracket %d at *ACCEPT", number);
1115        printf("\n");        printf("\n");
1116  #endif  #endif
# Line 1049  for (;;) Line 1120  for (;;)
1120        {        {
1121        md->offset_vector[offset] =        md->offset_vector[offset] =
1122          md->offset_vector[md->offset_end - number];          md->offset_vector[md->offset_end - number];
1123        md->offset_vector[offset+1] = eptr - md->start_subject;        md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1124        if (offset_top <= offset) offset_top = offset + 2;        if (offset_top <= offset) offset_top = offset + 2;
1125        }        }
1126      ecode += 3;      ecode += 3;
# Line 1070  for (;;) Line 1141  for (;;)
1141        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1142          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1143        offset_top = rec->save_offset_top;        offset_top = rec->save_offset_top;
       mstart = rec->save_start;  
1144        ims = original_ims;        ims = original_ims;
1145        ecode = rec->after_call;        ecode = rec->after_call;
1146        break;        break;
# Line 1085  for (;;) Line 1155  for (;;)
1155          (md->notempty ||          (md->notempty ||
1156            (md->notempty_atstart &&            (md->notempty_atstart &&
1157              mstart == md->start_subject + md->start_offset)))              mstart == md->start_subject + md->start_offset)))
1158        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1159    
1160      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1161    
1162      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1163      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1164      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1165      RRETURN(MATCH_MATCH);  
1166        /* For some reason, the macros don't work properly if an expression is
1167        given as the argument to MRRETURN when the heap is in use. */
1168    
1169        rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1170        MRRETURN(rrc);
1171    
1172      /* Change option settings */      /* Change option settings */
1173    
# Line 1114  for (;;) Line 1189  for (;;)
1189        {        {
1190        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1191          RM4);          RM4);
1192        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1193            {
1194            mstart = md->start_match_ptr;   /* In case \K reset it */
1195            break;
1196            }
1197        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1198        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1199        }        }
1200      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1201      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1202    
1203      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1204    
# Line 1133  for (;;) Line 1212  for (;;)
1212      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1213      continue;      continue;
1214    
1215      /* Negative assertion: all branches must fail to match */      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1216        PRUNE, or COMMIT means we must assume failure without checking subsequent
1217        branches. */
1218    
1219      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1220      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
# Line 1141  for (;;) Line 1222  for (;;)
1222        {        {
1223        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1224          RM5);          RM5);
1225        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1226          if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1227            {
1228            do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1229            break;
1230            }
1231        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1232        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1233        }        }
# Line 1165  for (;;) Line 1251  for (;;)
1251        while (i-- > 0)        while (i-- > 0)
1252          {          {
1253          eptr--;          eptr--;
1254          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1255          BACKCHAR(eptr);          BACKCHAR(eptr);
1256          }          }
1257        }        }
# Line 1176  for (;;) Line 1262  for (;;)
1262    
1263        {        {
1264        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1265        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1266        }        }
1267    
1268      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1197  for (;;) Line 1283  for (;;)
1283        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1284        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1285        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1286        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1287        cb.start_match      = mstart - md->start_subject;        cb.start_match      = (int)(mstart - md->start_subject);
1288        cb.current_position = eptr - md->start_subject;        cb.current_position = (int)(eptr - md->start_subject);
1289        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1290        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1291        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1292        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1293        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1294        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1295        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1296        }        }
1297      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1260  for (;;) Line 1346  for (;;)
1346    
1347        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1348              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
       new_recursive.save_start = mstart;  
1349        new_recursive.save_offset_top = offset_top;        new_recursive.save_offset_top = offset_top;
       mstart = eptr;  
1350    
1351        /* 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
1352        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1273  for (;;) Line 1357  for (;;)
1357          {          {
1358          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1359            md, ims, eptrb, flags, RM6);            md, ims, eptrb, flags, RM6);
1360          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1361            {            {
1362            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1363            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1364            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1365              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1366            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1367            }            }
1368          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1369            {            {
# Line 1300  for (;;) Line 1384  for (;;)
1384        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1385        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1386          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1387        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1388        }        }
1389      /* Control never reaches here */      /* Control never reaches here */
1390    
# Line 1309  for (;;) Line 1393  for (;;)
1393      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1394      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
1395      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
1396      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1397        the start-of-match value in case it was changed by \K. */
1398    
1399      case OP_ONCE:      case OP_ONCE:
1400      prev = ecode;      prev = ecode;
# Line 1318  for (;;) Line 1403  for (;;)
1403      do      do
1404        {        {
1405        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);
1406        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1407            {
1408            mstart = md->start_match_ptr;
1409            break;
1410            }
1411        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1412        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1413        }        }
# Line 1437  for (;;) Line 1526  for (;;)
1526        }        }
1527      else saved_eptr = NULL;      else saved_eptr = NULL;
1528    
1529      /* 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
1530      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
1531      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1532        it was changed by \K. */
1533    
1534      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1535          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1447  for (;;) Line 1537  for (;;)
1537        {        {
1538        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1539        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1540        RRETURN(MATCH_MATCH);        md->start_match_ptr = mstart;
1541          MRRETURN(MATCH_MATCH);
1542        }        }
1543    
1544      /* 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 1461  for (;;) Line 1552  for (;;)
1552        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1553        offset = number << 1;        offset = number << 1;
1554    
1555  #ifdef DEBUG  #ifdef PCRE_DEBUG
1556        printf("end bracket %d", number);        printf("end bracket %d", number);
1557        printf("\n");        printf("\n");
1558  #endif  #endif
# Line 1471  for (;;) Line 1562  for (;;)
1562          {          {
1563          md->offset_vector[offset] =          md->offset_vector[offset] =
1564            md->offset_vector[md->offset_end - number];            md->offset_vector[md->offset_end - number];
1565          md->offset_vector[offset+1] = eptr - md->start_subject;          md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1566          if (offset_top <= offset) offset_top = offset + 2;          if (offset_top <= offset) offset_top = offset + 2;
1567          }          }
1568    
# Line 1483  for (;;) Line 1574  for (;;)
1574          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1575          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1576          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1577          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1578            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1579          offset_top = rec->save_offset_top;          offset_top = rec->save_offset_top;
# Line 1543  for (;;) Line 1633  for (;;)
1633      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1634    
1635      case OP_CIRC:      case OP_CIRC:
1636      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1637      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1638        {        {
1639        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1640            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1641          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1642        ecode++;        ecode++;
1643        break;        break;
1644        }        }
# Line 1557  for (;;) Line 1647  for (;;)
1647      /* Start of subject assertion */      /* Start of subject assertion */
1648    
1649      case OP_SOD:      case OP_SOD:
1650      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1651      ecode++;      ecode++;
1652      break;      break;
1653    
1654      /* Start of match assertion */      /* Start of match assertion */
1655    
1656      case OP_SOM:      case OP_SOM:
1657      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1658      ecode++;      ecode++;
1659      break;      break;
1660    
# Line 1582  for (;;) Line 1672  for (;;)
1672      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1673        {        {
1674        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1675          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1676        else        else
1677          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
1678        ecode++;        ecode++;
1679        break;        break;
1680        }        }
1681      else      else
1682        {        {
1683        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1684        if (!md->endonly)        if (!md->endonly)
1685          {          {
1686          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1687              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1688            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
1689          ecode++;          ecode++;
1690          break;          break;
1691          }          }
# Line 1605  for (;;) Line 1695  for (;;)
1695      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1696    
1697      case OP_EOD:      case OP_EOD:
1698      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1699      ecode++;      ecode++;
1700      break;      break;
1701    
# Line 1614  for (;;) Line 1704  for (;;)
1704      case OP_EODN:      case OP_EODN:
1705      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1706          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1707        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1708      ecode++;      ecode++;
1709      break;      break;
1710    
# Line 1632  for (;;) Line 1722  for (;;)
1722  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1723        if (utf8)        if (utf8)
1724          {          {
1725            /* Get status of previous character */
1726    
1727          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1728            {            {
1729            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1730            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1731            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1732            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1733    #ifdef SUPPORT_UCP
1734              if (md->use_ucp)
1735                {
1736                if (c == '_') prev_is_word = TRUE; else
1737                  {
1738                  int cat = UCD_CATEGORY(c);
1739                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1740                  }
1741                }
1742              else
1743    #endif
1744            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1745            }            }
1746    
1747            /* Get status of next character */
1748    
1749          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1750            {            {
1751            SCHECK_PARTIAL();            SCHECK_PARTIAL();
# Line 1648  for (;;) Line 1754  for (;;)
1754          else          else
1755            {            {
1756            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1757    #ifdef SUPPORT_UCP
1758              if (md->use_ucp)
1759                {
1760                if (c == '_') cur_is_word = TRUE; else
1761                  {
1762                  int cat = UCD_CATEGORY(c);
1763                  cur_is_word = (cat == ucp_L || cat == ucp_N);
1764                  }
1765                }
1766              else
1767    #endif
1768            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1769            }            }
1770          }          }
1771        else        else
1772  #endif  #endif
1773    
1774        /* Not in UTF-8 mode */        /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
1775          consistency with the behaviour of \w we do use it in this case. */
1776    
1777          {          {
1778            /* Get status of previous character */
1779    
1780          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1781            {            {
1782            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1783    #ifdef SUPPORT_UCP
1784              if (md->use_ucp)
1785                {
1786                c = eptr[-1];
1787                if (c == '_') prev_is_word = TRUE; else
1788                  {
1789                  int cat = UCD_CATEGORY(c);
1790                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1791                  }
1792                }
1793              else
1794    #endif
1795            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1796            }            }
1797    
1798            /* Get status of next character */
1799    
1800          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1801            {            {
1802            SCHECK_PARTIAL();            SCHECK_PARTIAL();
1803            cur_is_word = FALSE;            cur_is_word = FALSE;
1804            }            }
1805          else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);          else
1806    #ifdef SUPPORT_UCP
1807            if (md->use_ucp)
1808              {
1809              c = *eptr;
1810              if (c == '_') cur_is_word = TRUE; else
1811                {
1812                int cat = UCD_CATEGORY(c);
1813                cur_is_word = (cat == ucp_L || cat == ucp_N);
1814                }
1815              }
1816            else
1817    #endif
1818            cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1819          }          }
1820    
1821        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
1822    
1823        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1824             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1825          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1826        }        }
1827      break;      break;
1828    
1829      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1830    
1831      case OP_ANY:      case OP_ANY:
1832      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1833      /* Fall through */      /* Fall through */
1834    
1835      case OP_ALLANY:      case OP_ALLANY:
1836      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1837        {        {
1838        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1839        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1840        }        }
1841      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1842      ecode++;      ecode++;
# Line 1701  for (;;) Line 1849  for (;;)
1849      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1850        {        {
1851        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1852        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1853        }        }
1854      ecode++;      ecode++;
1855      break;      break;
# Line 1710  for (;;) Line 1858  for (;;)
1858      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1859        {        {
1860        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1861        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1862        }        }
1863      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1864      if (      if (
# Line 1719  for (;;) Line 1867  for (;;)
1867  #endif  #endif
1868         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1869         )         )
1870        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1871      ecode++;      ecode++;
1872      break;      break;
1873    
# Line 1727  for (;;) Line 1875  for (;;)
1875      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1876        {        {
1877        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1878        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1879        }        }
1880      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1881      if (      if (
# Line 1736  for (;;) Line 1884  for (;;)
1884  #endif  #endif
1885         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1886         )         )
1887        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1888      ecode++;      ecode++;
1889      break;      break;
1890    
# Line 1744  for (;;) Line 1892  for (;;)
1892      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1893        {        {
1894        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1895        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1896        }        }
1897      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1898      if (      if (
# Line 1753  for (;;) Line 1901  for (;;)
1901  #endif  #endif
1902         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1903         )         )
1904        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1905      ecode++;      ecode++;
1906      break;      break;
1907    
# Line 1761  for (;;) Line 1909  for (;;)
1909      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1910        {        {
1911        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1912        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1913        }        }
1914      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1915      if (      if (
# Line 1770  for (;;) Line 1918  for (;;)
1918  #endif  #endif
1919         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1920         )         )
1921        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1922      ecode++;      ecode++;
1923      break;      break;
1924    
# Line 1778  for (;;) Line 1926  for (;;)
1926      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1927        {        {
1928        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1929        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1930        }        }
1931      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1932      if (      if (
# Line 1787  for (;;) Line 1935  for (;;)
1935  #endif  #endif
1936         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1937         )         )
1938        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1939      ecode++;      ecode++;
1940      break;      break;
1941    
# Line 1795  for (;;) Line 1943  for (;;)
1943      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1944        {        {
1945        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1946        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1947        }        }
1948      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1949      if (      if (
# Line 1804  for (;;) Line 1952  for (;;)
1952  #endif  #endif
1953         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1954         )         )
1955        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1956      ecode++;      ecode++;
1957      break;      break;
1958    
# Line 1812  for (;;) Line 1960  for (;;)
1960      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1961        {        {
1962        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1963        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1964        }        }
1965      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1966      switch(c)      switch(c)
1967        {        {
1968        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1969        case 0x000d:        case 0x000d:
1970        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1971        break;        break;
# Line 1830  for (;;) Line 1978  for (;;)
1978        case 0x0085:        case 0x0085:
1979        case 0x2028:        case 0x2028:
1980        case 0x2029:        case 0x2029:
1981        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
1982        break;        break;
1983        }        }
1984      ecode++;      ecode++;
# Line 1840  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      switch(c)      switch(c)
# Line 1865  for (;;) Line 2013  for (;;)
2013        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2014        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2015        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2016        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2017        }        }
2018      ecode++;      ecode++;
2019      break;      break;
# Line 1874  for (;;) Line 2022  for (;;)
2022      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2023        {        {
2024        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2025        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2026        }        }
2027      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2028      switch(c)      switch(c)
2029        {        {
2030        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2031        case 0x09:      /* HT */        case 0x09:      /* HT */
2032        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2033        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1908  for (;;) Line 2056  for (;;)
2056      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2057        {        {
2058        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2059        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2060        }        }
2061      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2062      switch(c)      switch(c)
# Line 1921  for (;;) Line 2069  for (;;)
2069        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2070        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2071        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2072        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2073        }        }
2074      ecode++;      ecode++;
2075      break;      break;
# Line 1930  for (;;) Line 2078  for (;;)
2078      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2079        {        {
2080        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2081        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2082        }        }
2083      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2084      switch(c)      switch(c)
2085        {        {
2086        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2087        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2088        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2089        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1957  for (;;) Line 2105  for (;;)
2105      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2106        {        {
2107        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2108        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2109        }        }
2110      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2111        {        {
# Line 1966  for (;;) Line 2114  for (;;)
2114        switch(ecode[1])        switch(ecode[1])
2115          {          {
2116          case PT_ANY:          case PT_ANY:
2117          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2118          break;          break;
2119    
2120          case PT_LAMP:          case PT_LAMP:
2121          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2122               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2123               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2124            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2125           break;          break;
2126    
2127          case PT_GC:          case PT_GC:
2128          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2129            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2130          break;          break;
2131    
2132          case PT_PC:          case PT_PC:
2133          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2134            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2135          break;          break;
2136    
2137          case PT_SC:          case PT_SC:
2138          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2139            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2140            break;
2141    
2142            /* These are specials */
2143    
2144            case PT_ALNUM:
2145            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2146                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2147              MRRETURN(MATCH_NOMATCH);
2148            break;
2149    
2150            case PT_SPACE:    /* Perl space */
2151            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2152                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2153                   == (op == OP_NOTPROP))
2154              MRRETURN(MATCH_NOMATCH);
2155            break;
2156    
2157            case PT_PXSPACE:  /* POSIX space */
2158            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2159                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2160                 c == CHAR_FF || c == CHAR_CR)
2161                   == (op == OP_NOTPROP))
2162              MRRETURN(MATCH_NOMATCH);
2163            break;
2164    
2165            case PT_WORD:
2166            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2167                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2168                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2169              MRRETURN(MATCH_NOMATCH);
2170          break;          break;
2171    
2172            /* This should never occur */
2173    
2174          default:          default:
2175          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
2176          }          }
# Line 2006  for (;;) Line 2186  for (;;)
2186      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2187        {        {
2188        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2189        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2190        }        }
2191      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2192        {        {
2193        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2194        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2195        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2196          {          {
2197          int len = 1;          int len = 1;
# Line 2056  for (;;) Line 2236  for (;;)
2236        referenced subpattern. */        referenced subpattern. */
2237    
2238        if (offset >= offset_top || md->offset_vector[offset] < 0)        if (offset >= offset_top || md->offset_vector[offset] < 0)
2239          length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;          length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1);
2240        else        else
2241          length = md->offset_vector[offset+1] - md->offset_vector[offset];          length = md->offset_vector[offset+1] - md->offset_vector[offset];
2242    
# Line 2090  for (;;) Line 2270  for (;;)
2270          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2271            {            {
2272            CHECK_PARTIAL();            CHECK_PARTIAL();
2273            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2274            }            }
2275          eptr += length;          eptr += length;
2276          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 2110  for (;;) Line 2290  for (;;)
2290          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2291            {            {
2292            CHECK_PARTIAL();            CHECK_PARTIAL();
2293            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2294            }            }
2295          eptr += length;          eptr += length;
2296          }          }
# Line 2128  for (;;) Line 2308  for (;;)
2308            {            {
2309            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2310            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2311            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2312            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2313              {              {
2314              CHECK_PARTIAL();              CHECK_PARTIAL();
2315              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2316              }              }
2317            eptr += length;            eptr += length;
2318            }            }
# Line 2159  for (;;) Line 2339  for (;;)
2339            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2340            eptr -= length;            eptr -= length;
2341            }            }
2342          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2343          }          }
2344        }        }
2345      /* Control never gets here */      /* Control never gets here */
# Line 2221  for (;;) Line 2401  for (;;)
2401            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2402              {              {
2403              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2404              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2405              }              }
2406            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2407            if (c > 255)            if (c > 255)
2408              {              {
2409              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2410              }              }
2411            else            else
2412              {              {
2413              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2414              }              }
2415            }            }
2416          }          }
# Line 2243  for (;;) Line 2423  for (;;)
2423            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2424              {              {
2425              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2426              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2427              }              }
2428            c = *eptr++;            c = *eptr++;
2429            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2430            }            }
2431          }          }
2432    
# Line 2268  for (;;) Line 2448  for (;;)
2448              {              {
2449              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2450              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2451              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2452              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2453                {                {
2454                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2455                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2456                }                }
2457              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2458              if (c > 255)              if (c > 255)
2459                {                {
2460                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2461                }                }
2462              else              else
2463                {                {
2464                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2465                }                }
2466              }              }
2467            }            }
# Line 2293  for (;;) Line 2473  for (;;)
2473              {              {
2474              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2475              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2476              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2477              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2478                {                {
2479                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2480                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2481                }                }
2482              c = *eptr++;              c = *eptr++;
2483              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2484              }              }
2485            }            }
2486          /* Control never gets here */          /* Control never gets here */
# Line 2366  for (;;) Line 2546  for (;;)
2546              }              }
2547            }            }
2548    
2549          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2550          }          }
2551        }        }
2552      /* Control never gets here */      /* Control never gets here */
# Line 2418  for (;;) Line 2598  for (;;)
2598          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2599            {            {
2600            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2601            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2602            }            }
2603          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2604          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2605          }          }
2606    
2607        /* 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 2438  for (;;) Line 2618  for (;;)
2618            {            {
2619            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2620            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2621            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2622            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2623              {              {
2624              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2625              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2626              }              }
2627            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2628            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2629            }            }
2630          /* Control never gets here */          /* Control never gets here */
2631          }          }
# Line 2474  for (;;) Line 2654  for (;;)
2654            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2655            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2656            }            }
2657          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2658          }          }
2659    
2660        /* Control never gets here */        /* Control never gets here */
# Line 2493  for (;;) Line 2673  for (;;)
2673        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2674          {          {
2675          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2676          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2677          }          }
2678        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2679        }        }
2680      else      else
2681  #endif  #endif
# Line 2505  for (;;) Line 2685  for (;;)
2685        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2686          {          {
2687          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2688          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2689          }          }
2690        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2691        ecode += 2;        ecode += 2;
2692        }        }
2693      break;      break;
# Line 2525  for (;;) Line 2705  for (;;)
2705        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2706          {          {
2707          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2708          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2709          }          }
2710    
2711        /* 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 2533  for (;;) Line 2713  for (;;)
2713    
2714        if (fc < 128)        if (fc < 128)
2715          {          {
2716          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2717          }          }
2718    
2719        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2552  for (;;) Line 2732  for (;;)
2732  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2733            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2734  #endif  #endif
2735              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2736            }            }
2737          }          }
2738        }        }
# Line 2564  for (;;) Line 2744  for (;;)
2744        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2745          {          {
2746          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2747          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2748          }          }
2749        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2750        ecode += 2;        ecode += 2;
2751        }        }
2752      break;      break;
# Line 2660  for (;;) Line 2840  for (;;)
2840            else            else
2841              {              {
2842              CHECK_PARTIAL();              CHECK_PARTIAL();
2843              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2844              }              }
2845            }            }
2846    
# Line 2672  for (;;) Line 2852  for (;;)
2852              {              {
2853              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2854              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2855              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2856              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2857                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2858  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2683  for (;;) Line 2863  for (;;)
2863              else              else
2864                {                {
2865                CHECK_PARTIAL();                CHECK_PARTIAL();
2866                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2867                }                }
2868              }              }
2869            /* Control never gets here */            /* Control never gets here */
# Line 2714  for (;;) Line 2894  for (;;)
2894              {              {
2895              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2896              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2897              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2898  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2899              eptr--;              eptr--;
2900              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2757  for (;;) Line 2937  for (;;)
2937          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2938            {            {
2939            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2940            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2941            }            }
2942          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2943          }          }
2944        if (min == max) continue;        if (min == max) continue;
2945        if (minimize)        if (minimize)
# Line 2768  for (;;) Line 2948  for (;;)
2948            {            {
2949            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2950            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2951            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2952            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2953              {              {
2954              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2955              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2956              }              }
2957            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2958            }            }
2959          /* Control never gets here */          /* Control never gets here */
2960          }          }
# Line 2800  for (;;) Line 2980  for (;;)
2980            eptr--;            eptr--;
2981            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2982            }            }
2983          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2984          }          }
2985        /* Control never gets here */        /* Control never gets here */
2986        }        }
# Line 2814  for (;;) Line 2994  for (;;)
2994          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2995            {            {
2996            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2997            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2998            }            }
2999          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3000          }          }
3001    
3002        if (min == max) continue;        if (min == max) continue;
# Line 2827  for (;;) Line 3007  for (;;)
3007            {            {
3008            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
3009            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3010            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
3011            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3012              {              {
3013              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3014              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3015              }              }
3016            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3017            }            }
3018          /* Control never gets here */          /* Control never gets here */
3019          }          }
# Line 2858  for (;;) Line 3038  for (;;)
3038            eptr--;            eptr--;
3039            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3040            }            }
3041          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3042          }          }
3043        }        }
3044      /* Control never gets here */      /* Control never gets here */
# Line 2870  for (;;) Line 3050  for (;;)
3050      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
3051        {        {
3052        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3053        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
3054        }        }
3055      ecode++;      ecode++;
3056      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2880  for (;;) Line 3060  for (;;)
3060        if (c < 256)        if (c < 256)
3061  #endif  #endif
3062        c = md->lcc[c];        c = md->lcc[c];
3063        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3064        }        }
3065      else      else
3066        {        {
3067        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3068        }        }
3069      break;      break;
3070    
# Line 2978  for (;;) Line 3158  for (;;)
3158            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3159              {              {
3160              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3161              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3162              }              }
3163            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3164            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3165            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3166            }            }
3167          }          }
3168        else        else
# Line 2995  for (;;) Line 3175  for (;;)
3175            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3176              {              {
3177              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3178              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3179              }              }
3180            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3181            }            }
3182          }          }
3183    
# Line 3014  for (;;) Line 3194  for (;;)
3194              {              {
3195              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3196              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3197              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3198              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3199                {                {
3200                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3201                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3202                }                }
3203              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3204              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3205              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3206              }              }
3207            }            }
3208          else          else
# Line 3033  for (;;) Line 3213  for (;;)
3213              {              {
3214              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3215              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3216              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3217              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3218                {                {
3219                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3220                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3221                }                }
3222              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3223              }              }
3224            }            }
3225          /* Control never gets here */          /* Control never gets here */
# Line 3101  for (;;) Line 3281  for (;;)
3281              }              }
3282            }            }
3283    
3284          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3285          }          }
3286        /* Control never gets here */        /* Control never gets here */
3287        }        }
# Line 3120  for (;;) Line 3300  for (;;)
3300            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3301              {              {
3302              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3303              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3304              }              }
3305            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3306            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3307            }            }
3308          }          }
3309        else        else
# Line 3135  for (;;) Line 3315  for (;;)
3315            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3316              {              {
3317              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3318              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3319              }              }
3320            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3321            }            }
3322          }          }
3323    
# Line 3154  for (;;) Line 3334  for (;;)
3334              {              {
3335              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3336              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3337              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3338              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3339                {                {
3340                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3341                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3342                }                }
3343              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3344              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3345              }              }
3346            }            }
3347          else          else
# Line 3172  for (;;) Line 3352  for (;;)
3352              {              {
3353              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3354              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3355              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3356              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3357                {                {
3358                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3359                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3360                }                }
3361              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3362              }              }
3363            }            }
3364          /* Control never gets here */          /* Control never gets here */
# Line 3239  for (;;) Line 3419  for (;;)
3419              }              }
3420            }            }
3421    
3422          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3423          }          }
3424        }        }
3425      /* Control never gets here */      /* Control never gets here */
# Line 3333  for (;;) Line 3513  for (;;)
3513          switch(prop_type)          switch(prop_type)
3514            {            {
3515            case PT_ANY:            case PT_ANY:
3516            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3517            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3518              {              {
3519              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3520                {                {
3521                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3522                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3523                }                }
3524              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3525              }              }
# Line 3351  for (;;) Line 3531  for (;;)
3531              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3532                {                {
3533                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3534                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3535                }                }
3536              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3537              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3538              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3539                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3540                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3541                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3542              }              }
3543            break;            break;
3544    
# Line 3368  for (;;) Line 3548  for (;;)
3548              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3549                {                {
3550                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3551                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3552                }                }
3553              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3554              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3555              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3556                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3557              }              }
3558            break;            break;
3559    
# Line 3383  for (;;) Line 3563  for (;;)
3563              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3564                {                {
3565                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3566                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3567                }                }
3568              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3569              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3570              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3571                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3572              }              }
3573            break;            break;
3574    
# Line 3398  for (;;) Line 3578  for (;;)
3578              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3579                {                {
3580                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3581                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3582                }                }
3583              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3584              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3585              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3586                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3587                }
3588              break;
3589    
3590              case PT_ALNUM:
3591              for (i = 1; i <= min; i++)
3592                {
3593                if (eptr >= md->end_subject)
3594                  {
3595                  SCHECK_PARTIAL();
3596                  MRRETURN(MATCH_NOMATCH);
3597                  }
3598                GETCHARINCTEST(c, eptr);
3599                prop_category = UCD_CATEGORY(c);
3600                if ((prop_category == ucp_L || prop_category == ucp_N)
3601                       == prop_fail_result)
3602                  MRRETURN(MATCH_NOMATCH);
3603                }
3604              break;
3605    
3606              case PT_SPACE:    /* Perl space */
3607              for (i = 1; i <= min; i++)
3608                {
3609                if (eptr >= md->end_subject)
3610                  {
3611                  SCHECK_PARTIAL();
3612                  MRRETURN(MATCH_NOMATCH);
3613                  }
3614                GETCHARINCTEST(c, eptr);
3615                prop_category = UCD_CATEGORY(c);
3616                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3617                     c == CHAR_FF || c == CHAR_CR)
3618                       == prop_fail_result)
3619                  MRRETURN(MATCH_NOMATCH);
3620                }
3621              break;
3622    
3623              case PT_PXSPACE:  /* POSIX space */
3624              for (i = 1; i <= min; i++)
3625                {
3626                if (eptr >= md->end_subject)
3627                  {
3628                  SCHECK_PARTIAL();
3629                  MRRETURN(MATCH_NOMATCH);
3630                  }
3631                GETCHARINCTEST(c, eptr);
3632                prop_category = UCD_CATEGORY(c);
3633                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3634                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3635                       == prop_fail_result)
3636                  MRRETURN(MATCH_NOMATCH);
3637                }
3638              break;
3639    
3640              case PT_WORD:
3641              for (i = 1; i <= min; i++)
3642                {
3643                if (eptr >= md->end_subject)
3644                  {
3645                  SCHECK_PARTIAL();
3646                  MRRETURN(MATCH_NOMATCH);
3647                  }
3648                GETCHARINCTEST(c, eptr);
3649                prop_category = UCD_CATEGORY(c);
3650                if ((prop_category == ucp_L || prop_category == ucp_N ||
3651                     c == CHAR_UNDERSCORE)
3652                       == prop_fail_result)
3653                  MRRETURN(MATCH_NOMATCH);
3654              }              }
3655            break;            break;
3656    
3657              /* This should not occur */
3658    
3659            default:            default:
3660            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
3661            }            }
# Line 3422  for (;;) Line 3671  for (;;)
3671            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3672              {              {
3673              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3674              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3675              }              }
3676            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3677            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3678            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3679            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3680              {              {
3681              int len = 1;              int len = 1;
# Line 3453  for (;;) Line 3702  for (;;)
3702            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3703              {              {
3704              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3705              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3706              }              }
3707            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3708            eptr++;            eptr++;
3709            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3710            }            }
# Line 3467  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            eptr++;            eptr++;
3722            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3475  for (;;) Line 3724  for (;;)
3724          break;          break;
3725    
3726          case OP_ANYBYTE:          case OP_ANYBYTE:
3727          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3728          eptr += min;          eptr += min;
3729          break;          break;
3730    
# Line 3485  for (;;) Line 3734  for (;;)
3734            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3735              {              {
3736              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3737              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3738              }              }
3739            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3740            switch(c)            switch(c)
3741              {              {
3742              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3743              case 0x000d:              case 0x000d:
3744              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3745              break;              break;
# Line 3503  for (;;) Line 3752  for (;;)
3752              case 0x0085:              case 0x0085:
3753              case 0x2028:              case 0x2028:
3754              case 0x2029:              case 0x2029:
3755              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3756              break;              break;
3757              }              }
3758            }            }
# Line 3515  for (;;) Line 3764  for (;;)
3764            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3765              {              {
3766              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3767              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3768              }              }
3769            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3770            switch(c)            switch(c)
# Line 3540  for (;;) Line 3789  for (;;)
3789              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3790              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3791              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3792              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3793              }              }
3794            }            }
3795          break;          break;
# Line 3551  for (;;) Line 3800  for (;;)
3800            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3801              {              {
3802              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3803              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3804              }              }
3805            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3806            switch(c)            switch(c)
3807              {              {
3808              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3809              case 0x09:      /* HT */              case 0x09:      /* HT */
3810              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3811              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3587  for (;;) Line 3836  for (;;)
3836            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3837              {              {
3838              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3839              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3840              }              }
3841            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3842            switch(c)            switch(c)
# Line 3600  for (;;) Line 3849  for (;;)
3849              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3850              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3851              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3852              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3853              }              }
3854            }            }
3855          break;          break;
# Line 3611  for (;;) Line 3860  for (;;)
3860            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3861              {              {
3862              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3863              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3864              }              }
3865            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3866            switch(c)            switch(c)
3867              {              {
3868              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3869              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3870              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3871              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3635  for (;;) Line 3884  for (;;)
3884            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3885              {              {
3886              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3887              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3888              }              }
3889            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3890            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3891              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3892            }            }
3893          break;          break;
3894    
# Line 3649  for (;;) Line 3898  for (;;)
3898            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3899              {              {
3900              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3901              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3902              }              }
3903            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3904              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3905            /* 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 */
3906            }            }
3907          break;          break;
# Line 3663  for (;;) Line 3912  for (;;)
3912            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3913              {              {
3914              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3915              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3916              }              }
3917            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3918              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3919            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3920            }            }
3921          break;          break;
# Line 3677  for (;;) Line 3926  for (;;)
3926            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3927              {              {
3928              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3929              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3930              }              }
3931            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3932              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3933            /* 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 */
3934            }            }
3935          break;          break;
# Line 3688  for (;;) Line 3937  for (;;)
3937          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3938          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3939            {            {
3940            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3941               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3942              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3943                MRRETURN(MATCH_NOMATCH);
3944                }
3945              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3946                MRRETURN(MATCH_NOMATCH);
3947            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3948            }            }
3949          break;          break;
# Line 3701  for (;;) Line 3954  for (;;)
3954            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3955              {              {
3956              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3957              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3958              }              }
3959            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3960              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3961            /* 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 */
3962            }            }
3963          break;          break;
# Line 3727  for (;;) Line 3980  for (;;)
3980            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3981              {              {
3982              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3983              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3984              }              }
3985            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3986            eptr++;            eptr++;
3987            }            }
3988          break;          break;
# Line 3738  for (;;) Line 3991  for (;;)
3991          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3992            {            {
3993            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3994            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3995            }            }
3996          eptr += min;          eptr += min;
3997          break;          break;
# Line 3747  for (;;) Line 4000  for (;;)
4000          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4001            {            {
4002            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4003            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
4004            }            }
4005          eptr += min;          eptr += min;
4006          break;          break;
# Line 3758  for (;;) Line 4011  for (;;)
4011            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4012              {              {
4013              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4014              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4015              }              }
4016            switch(*eptr++)            switch(*eptr++)
4017              {              {
4018              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4019              case 0x000d:              case 0x000d:
4020              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4021              break;              break;
# Line 3772  for (;;) Line 4025  for (;;)
4025              case 0x000b:              case 0x000b:
4026              case 0x000c:              case 0x000c:
4027              case 0x0085:              case 0x0085:
4028              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4029              break;              break;
4030              }              }
4031            }            }
# Line 3784  for (;;) Line 4037  for (;;)
4037            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4038              {              {
4039              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4040              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4041              }              }
4042            switch(*eptr++)            switch(*eptr++)
4043              {              {
# Line 3792  for (;;) Line 4045  for (;;)
4045              case 0x09:      /* HT */              case 0x09:      /* HT */
4046              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4047              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4048              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4049              }              }
4050            }            }
4051          break;          break;
# Line 3803  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 0x09:      /* HT */              case 0x09:      /* HT */
4065              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4066              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3822  for (;;) Line 4075  for (;;)
4075            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4076              {              {
4077              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4078              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4079              }              }
4080            switch(*eptr++)            switch(*eptr++)
4081              {              {
# Line 3832  for (;;) Line 4085  for (;;)
4085              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4086              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4087              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4088              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4089              }              }
4090            }            }
4091          break;          break;
# Line 3843  for (;;) Line 4096  for (;;)
4096            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4097              {              {
4098              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4099              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4100              }              }
4101            switch(*eptr++)            switch(*eptr++)
4102              {              {
4103              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4104              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4105              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4106              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3864  for (;;) Line 4117  for (;;)
4117            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4118              {              {
4119              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4120              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4121              }              }
4122            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4123            }            }
4124          break;          break;
4125    
# Line 3876  for (;;) Line 4129  for (;;)
4129            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4130              {              {
4131              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4132              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4133              }              }
4134            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4135            }            }
4136          break;          break;
4137    
# Line 3888  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            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4147            }            }
4148          break;          break;
4149    
# Line 3900  for (;;) Line 4153  for (;;)
4153            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4154              {              {
4155              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4156              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4157              }              }
4158            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4159            }            }
4160          break;          break;
4161    
# Line 3912  for (;;) Line 4165  for (;;)
4165            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4166              {              {
4167              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4168              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4169              }              }
4170            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4171              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4172            }            }
4173          break;          break;
4174    
# Line 3925  for (;;) Line 4178  for (;;)
4178            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4179              {              {
4180              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4181              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4182              }              }
4183            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4184              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4185            }            }
4186          break;          break;
4187    
# Line 3957  for (;;) Line 4210  for (;;)
4210              {              {
4211              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4212              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4213              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4214              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4215                {                {
4216                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4217                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4218                }                }
4219              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4220              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4221              }              }
4222            /* Control never gets here */            /* Control never gets here */
4223    
# Line 3973  for (;;) Line 4226  for (;;)
4226              {              {
4227              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4228              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4229              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4230              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4231                {                {
4232                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4233                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4234                }                }
4235              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4236              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4237              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4238                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4239                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4240                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4241              }              }
4242            /* Control never gets here */            /* Control never gets here */
4243    
# Line 3993  for (;;) Line 4246  for (;;)
4246              {              {
4247              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4248              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4249              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4250              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4251                {                {
4252                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4253                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4254                }                }
4255              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4256              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4257              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4258                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4259              }              }
4260            /* Control never gets here */            /* Control never gets here */
4261    
# Line 4011  for (;;) Line 4264  for (;;)
4264              {              {
4265              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4266              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4267              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4268              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4269                {                {
4270                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4271                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4272                }                }
4273              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4274              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4275              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4276                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4277              }              }
4278            /* Control never gets here */            /* Control never gets here */
4279    
# Line 4029  for (;;) Line 4282  for (;;)
4282              {              {
4283              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4284              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4285              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4286              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4287                {                {
4288                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4289                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4290                }                }
4291              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4292              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4293              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4294                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4295                }
4296              /* Control never gets here */
4297    
4298              case PT_ALNUM:
4299              for (fi = min;; fi++)
4300                {
4301                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59);
4302                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4303                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4304                if (eptr >= md->end_subject)
4305                  {
4306                  SCHECK_PARTIAL();
4307                  MRRETURN(MATCH_NOMATCH);
4308                  }
4309                GETCHARINCTEST(c, eptr);
4310                prop_category = UCD_CATEGORY(c);
4311                if ((prop_category == ucp_L || prop_category == ucp_N)
4312                       == prop_fail_result)
4313                  MRRETURN(MATCH_NOMATCH);
4314              }              }
4315            /* Control never gets here */            /* Control never gets here */
4316    
4317              case PT_SPACE:    /* Perl space */
4318              for (fi = min;; fi++)
4319                {
4320                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
4321                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4322                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4323                if (eptr >= md->end_subject)
4324                  {
4325                  SCHECK_PARTIAL();
4326                  MRRETURN(MATCH_NOMATCH);
4327                  }
4328                GETCHARINCTEST(c, eptr);
4329                prop_category = UCD_CATEGORY(c);
4330                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4331                     c == CHAR_FF || c == CHAR_CR)
4332                       == prop_fail_result)
4333                  MRRETURN(MATCH_NOMATCH);
4334                }
4335              /* Control never gets here */
4336    
4337              case PT_PXSPACE:  /* POSIX space */
4338              for (fi = min;; fi++)
4339                {
4340                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
4341                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4342                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4343                if (eptr >= md->end_subject)
4344                  {
4345                  SCHECK_PARTIAL();
4346                  MRRETURN(MATCH_NOMATCH);
4347                  }
4348                GETCHARINCTEST(c, eptr);
4349                prop_category = UCD_CATEGORY(c);
4350                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4351                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4352                       == prop_fail_result)
4353                  MRRETURN(MATCH_NOMATCH);
4354                }
4355              /* Control never gets here */
4356    
4357              case PT_WORD:
4358              for (fi = min;; fi++)
4359                {
4360                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
4361                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4362                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4363                if (eptr >= md->end_subject)
4364                  {
4365                  SCHECK_PARTIAL();
4366                  MRRETURN(MATCH_NOMATCH);
4367                  }
4368                GETCHARINCTEST(c, eptr);
4369                prop_category = UCD_CATEGORY(c);
4370                if ((prop_category == ucp_L ||
4371                     prop_category == ucp_N ||
4372                     c == CHAR_UNDERSCORE)
4373                       == prop_fail_result)
4374                  MRRETURN(MATCH_NOMATCH);
4375                }
4376              /* Control never gets here */
4377    
4378              /* This should never occur */
4379    
4380            default:            default:
4381            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4382            }            }
# Line 4056  for (;;) Line 4391  for (;;)
4391            {            {
4392            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4393            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4394            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4395            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4396              {              {
4397              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4398              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4399              }              }
4400            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4401            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4402            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4403            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4404              {              {
4405              int len = 1;              int len = 1;
# Line 4088  for (;;) Line 4423  for (;;)
4423            {            {
4424            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4425            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4426            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4427            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4428              {              {
4429              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4430              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4431              }              }
4432            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4433              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4434            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4435            switch(ctype)            switch(ctype)
4436              {              {
# Line 4107  for (;;) Line 4442  for (;;)
4442              case OP_ANYNL:              case OP_ANYNL:
4443              switch(c)              switch(c)
4444                {                {
4445                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4446                case 0x000d:                case 0x000d:
4447                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4448                break;                break;
# Line 4119  for (;;) Line 4454  for (;;)
4454                case 0x0085:                case 0x0085:
4455                case 0x2028:                case 0x2028:
4456                case 0x2029:                case 0x2029:
4457                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4458                break;                break;
4459                }                }
4460              break;              break;
# Line 4147  for (;;) Line 4482  for (;;)
4482                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4483                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4484                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4485                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4486                }                }
4487              break;              break;
4488    
4489              case OP_HSPACE:              case OP_HSPACE:
4490              switch(c)              switch(c)
4491                {                {
4492                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4493                case 0x09:      /* HT */                case 0x09:      /* HT */
4494                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4495                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4189  for (;;) Line 4524  for (;;)
4524                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4525                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4526                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4527                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4528                }                }
4529              break;              break;
4530    
4531              case OP_VSPACE:              case OP_VSPACE:
4532              switch(c)              switch(c)
4533                {                {
4534                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4535                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4536                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4537                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4210  for (;;) Line 4545  for (;;)
4545    
4546              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4547              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4548                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4549              break;              break;
4550    
4551              case OP_DIGIT:              case OP_DIGIT:
4552              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4553                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4554              break;              break;
4555    
4556              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4557              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4558                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4559              break;              break;
4560    
4561              case OP_WHITESPACE:              case OP_WHITESPACE:
4562              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4563                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4564              break;              break;
4565    
4566              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4567              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4568                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4569              break;              break;
4570    
4571              case OP_WORDCHAR:              case OP_WORDCHAR:
4572              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4573                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4574              break;              break;
4575    
4576              default:              default:
# Line 4251  for (;;) Line 4586  for (;;)
4586            {            {
4587            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4588            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4589            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4590            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4591              {              {
4592              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4593              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4594              }              }
4595            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4596              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4597            c = *eptr++;            c = *eptr++;
4598            switch(ctype)            switch(ctype)
4599              {              {
# Line 4270  for (;;) Line 4605  for (;;)
4605              case OP_ANYNL:              case OP_ANYNL:
4606              switch(c)              switch(c)
4607                {                {
4608                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4609                case 0x000d:                case 0x000d:
4610                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4611                break;                break;
# Line 4281  for (;;) Line 4616  for (;;)
4616                case 0x000b:                case 0x000b:
4617                case 0x000c:                case 0x000c:
4618                case 0x0085:                case 0x0085:
4619                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4620                break;                break;
4621                }                }
4622              break;              break;
# Line 4293  for (;;) Line 4628  for (;;)
4628                case 0x09:      /* HT */                case 0x09:      /* HT */
4629                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4630                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4631                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4632                }                }
4633              break;              break;
4634    
4635              case OP_HSPACE:              case OP_HSPACE:
4636              switch(c)              switch(c)
4637                {                {
4638                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4639                case 0x09:      /* HT */                case 0x09:      /* HT */
4640                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4641                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4317  for (;;) Line 4652  for (;;)
4652                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4653                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4654                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4655                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4656                }                }
4657              break;              break;
4658    
4659              case OP_VSPACE:              case OP_VSPACE:
4660              switch(c)              switch(c)
4661                {                {
4662                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4663                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4664                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4665                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4335  for (;;) Line 4670  for (;;)
4670              break;              break;
4671    
4672              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4673              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4674              break;              break;
4675    
4676              case OP_DIGIT:              case OP_DIGIT:
4677              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4678              break;              break;
4679    
4680              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4681              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4682              break;              break;
4683    
4684              case OP_WHITESPACE:              case OP_WHITESPACE:
4685              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4686              break;              break;
4687    
4688              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4689              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4690              break;              break;
4691    
4692              case OP_WORDCHAR:              case OP_WORDCHAR:
4693              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4694              break;              break;
4695    
4696              default:              default:
# Line 4388  for (;;) Line 4723  for (;;)
4723                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4724                break;                break;
4725                }                }
4726              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4727              if (prop_fail_result) break;              if (prop_fail_result) break;
4728              eptr+= len;              eptr+= len;
4729              }              }
# Line 4403  for (;;) Line 4738  for (;;)
4738                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4739                break;                break;
4740                }                }
4741              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4742              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4743              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4744                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
# Line 4422  for (;;) Line 4757  for (;;)
4757                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4758                break;                break;
4759                }                }
4760              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4761              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4762              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4763                break;                break;
# Line 4439  for (;;) Line 4774  for (;;)
4774                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4775                break;                break;
4776                }                }
4777              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4778              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4779              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4780                break;                break;
# Line 4456  for (;;) Line 4791  for (;;)
4791                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4792                break;                break;
4793                }                }
4794              GETCHARLEN(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
4795              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4796              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4797                break;                break;
4798              eptr+= len;              eptr+= len;
4799              }              }
4800            break;            break;
4801    
4802              case PT_ALNUM:
4803              for (i = min; i < max; i++)
4804                {
4805                int len = 1;
4806                if (eptr >= md->end_subject)
4807                  {
4808                  SCHECK_PARTIAL();
4809                  break;
4810                  }
4811                GETCHARLENTEST(c, eptr, len);
4812                prop_category = UCD_CATEGORY(c);
4813                if ((prop_category == ucp_L || prop_category == ucp_N)
4814                     == prop_fail_result)
4815                  break;
4816                eptr+= len;
4817                }
4818              break;
4819    
4820              case PT_SPACE:    /* Perl space */
4821              for (i = min; i < max; i++)
4822                {
4823                int len = 1;
4824                if (eptr >= md->end_subject)
4825                  {
4826                  SCHECK_PARTIAL();
4827                  break;
4828                  }
4829                GETCHARLENTEST(c, eptr, len);
4830                prop_category = UCD_CATEGORY(c);
4831                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4832                     c == CHAR_FF || c == CHAR_CR)
4833                     == prop_fail_result)
4834                  break;
4835                eptr+= len;
4836                }
4837              break;
4838    
4839              case PT_PXSPACE:  /* POSIX space */
4840              for (i = min; i < max; i++)
4841                {
4842                int len = 1;
4843                if (eptr >= md->end_subject)
4844                  {
4845                  SCHECK_PARTIAL();
4846                  break;
4847                  }
4848                GETCHARLENTEST(c, eptr, len);
4849                prop_category = UCD_CATEGORY(c);
4850                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4851                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4852                     == prop_fail_result)
4853                  break;
4854                eptr+= len;
4855                }
4856              break;
4857    
4858              case PT_WORD:
4859              for (i = min; i < max; i++)
4860                {
4861                int len = 1;
4862                if (eptr >= md->end_subject)
4863                  {
4864                  SCHECK_PARTIAL();
4865                  break;
4866                  }
4867                GETCHARLENTEST(c, eptr, len);
4868                prop_category = UCD_CATEGORY(c);
4869                if ((prop_category == ucp_L || prop_category == ucp_N ||
4870                     c == CHAR_UNDERSCORE) == prop_fail_result)
4871                  break;
4872                eptr+= len;
4873                }
4874              break;
4875    
4876              default:
4877              RRETURN(PCRE_ERROR_INTERNAL);
4878            }            }
4879    
4880          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5015  for (;;) Line 5427  for (;;)
5427    
5428        /* 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 */
5429    
5430        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5431        }        }
5432      /* Control never gets here */      /* Control never gets here */
5433    
# Line 5048  switch (frame->Xwhere) Line 5460  switch (frame->Xwhere)
5460    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)
5461    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)
5462    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)
5463    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5464  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5465    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)
5466    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
5467  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
5468    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)
5469      LBL(59) LBL(60) LBL(61) LBL(62)
5470  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
5471  #endif  /* SUPPORT_UTF8 */  #endif  /* SUPPORT_UTF8 */
5472    default:    default:
# Line 5257  end_subject = md->end_subject; Line 5670  end_subject = md->end_subject;
5670    
5671  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
5672  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
5673    md->use_ucp = (re->options & PCRE_UCP) != 0;
5674  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
5675    
5676  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
# Line 5266  md->notempty_atstart = (options & PCRE_N Line 5680  md->notempty_atstart = (options & PCRE_N
5680  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5681                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5682  md->hitend = FALSE;  md->hitend = FALSE;
5683    md->mark = NULL;                        /* In case never set */
5684    
5685  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5686    
# Line 5565  for(;;) Line 5980  for(;;)
5980      bytes to avoid spending too much time in this optimization. */      bytes to avoid spending too much time in this optimization. */
5981    
5982      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5983          end_subject - start_match < study->minlength)          (pcre_uint32)(end_subject - start_match) < study->minlength)
5984        {        {
5985        rc = MATCH_NOMATCH;        rc = MATCH_NOMATCH;
5986        break;        break;
# Line 5628  for(;;) Line 6043  for(;;)
6043        }        }
6044      }      }
6045    
6046  #ifdef DEBUG  /* Sigh. Some compilers never learn. */  #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
6047    printf(">>>> Match against: ");    printf(">>>> Match against: ");
6048    pchars(start_match, end_subject - start_match, TRUE, md);    pchars(start_match, end_subject - start_match, TRUE, md);
6049    printf("\n");    printf("\n");
# Line 5640  for(;;) Line 6055  for(;;)
6055    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
6056    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
6057    md->match_call_count = 0;    md->match_call_count = 0;
6058    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,
6059        0, 0);
6060    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
6061    
6062    switch(rc)    switch(rc)
6063      {      {
6064      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. If MATCH_SKIP_ARG reaches
6065      exactly like PRUNE. */      this level it means that a MARK that matched the SKIP's arg was not found.
6066        We treat this as NOMATCH. THEN at this level acts exactly like PRUNE. */
6067    
6068      case MATCH_NOMATCH:      case MATCH_NOMATCH:
6069      case MATCH_PRUNE:      case MATCH_PRUNE:
6070        case MATCH_SKIP_ARG:
6071      case MATCH_THEN:      case MATCH_THEN:
6072      new_start_match = start_match + 1;      new_start_match = start_match + 1;
6073  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 5710  for(;;) Line 6128  for(;;)
6128           md->nllen == 2))           md->nllen == 2))
6129      start_match++;      start_match++;
6130    
6131    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
6132      }                  /* End of for(;;) "bumpalong" loop */
6133    
6134  /* ==========================================================================*/  /* ==========================================================================*/
6135    
# Line 5734  capturing parentheses than vector slots. Line 6153  capturing parentheses than vector slots.
6153    
6154  ENDLOOP:  ENDLOOP:
6155    
6156  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
6157    {    {
6158    if (using_temporary_offsets)    if (using_temporary_offsets)
6159      {      {
# Line 5760  if (rc == MATCH_MATCH) Line 6179  if (rc == MATCH_MATCH)
6179    
6180    if (offsetcount < 2) rc = 0; else    if (offsetcount < 2) rc = 0; else
6181      {      {
6182      offsets[0] = md->start_match_ptr - md->start_subject;      offsets[0] = (int)(md->start_match_ptr - md->start_subject);
6183      offsets[1] = md->end_match_ptr - md->start_subject;      offsets[1] = (int)(md->end_match_ptr - md->start_subject);
6184      }      }
6185    
6186    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6187    return rc;    goto RETURN_MARK;
6188    }    }
6189    
6190  /* 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 5777  if (using_temporary_offsets) Line 6196  if (using_temporary_offsets)
6196    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
6197    }    }
6198    
6199    /* For anything other than nomatch or partial match, just return the code. */
6200    
6201  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6202    {    {
6203    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6204    return rc;    return rc;
6205    }    }
6206  else if (start_partial != NULL)  
6207    /* Handle partial matches - disable any mark data */
6208    
6209    if (start_partial != NULL)
6210    {    {
6211    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
6212      md->mark = NULL;
6213    if (offsetcount > 1)    if (offsetcount > 1)
6214      {      {
6215      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = (int)(start_partial - (USPTR)subject);
6216      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = (int)(end_subject - (USPTR)subject);
6217      }      }
6218    return PCRE_ERROR_PARTIAL;    rc = PCRE_ERROR_PARTIAL;
6219    }    }
6220    
6221    /* This is the classic nomatch case */
6222    
6223  else  else
6224    {    {
6225    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
6226    return PCRE_ERROR_NOMATCH;    rc = PCRE_ERROR_NOMATCH;
6227    }    }
6228    
6229    /* Return the MARK data if it has been requested. */
6230    
6231    RETURN_MARK:
6232    
6233    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6234      *(extra_data->mark) = (unsigned char *)(md->mark);
6235    return rc;
6236  }  }
6237    
6238  /* End of pcre_exec.c */  /* End of pcre_exec.c */

Legend:
Removed from v.463  
changed lines
  Added in v.534

  ViewVC Help
Powered by ViewVC 1.1.5