/[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 751 by ph10, Fri Nov 18 11:13:30 2011 UTC revision 771 by ph10, Tue Nov 29 15:34:12 2011 UTC
# Line 82  negative to avoid the external error cod Line 82  negative to avoid the external error cod
82  #define MATCH_SKIP_ARG     (-993)  #define MATCH_SKIP_ARG     (-993)
83  #define MATCH_THEN         (-992)  #define MATCH_THEN         (-992)
84    
 /* This is a convenience macro for code that occurs many times. */  
   
 #define MRRETURN(ra) \  
   { \  
   md->mark = markptr; \  
   RRETURN(ra); \  
   }  
   
85  /* 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.
86  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,
87  because the offset vector is always a multiple of 3 long. */  because the offset vector is always a multiple of 3 long. */
# Line 290  actually used in this definition. */ Line 282  actually used in this definition. */
282  #define RMATCH(ra,rb,rc,rd,re,rw) \  #define RMATCH(ra,rb,rc,rd,re,rw) \
283    { \    { \
284    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
285    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1); \    rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1); \
286    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
287    }    }
288  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 300  actually used in this definition. */ Line 292  actually used in this definition. */
292    }    }
293  #else  #else
294  #define RMATCH(ra,rb,rc,rd,re,rw) \  #define RMATCH(ra,rb,rc,rd,re,rw) \
295    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1)    rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1)
296  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
297  #endif  #endif
298    
# Line 321  argument of match(), which never changes Line 313  argument of match(), which never changes
313    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
314    newframe->Xecode = rb;\    newframe->Xecode = rb;\
315    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
   newframe->Xmarkptr = markptr;\  
316    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
317    newframe->Xeptrb = re;\    newframe->Xeptrb = re;\
318    newframe->Xrdepth = frame->Xrdepth + 1;\    newframe->Xrdepth = frame->Xrdepth + 1;\
# Line 357  typedef struct heapframe { Line 348  typedef struct heapframe {
348    USPTR Xeptr;    USPTR Xeptr;
349    const uschar *Xecode;    const uschar *Xecode;
350    USPTR Xmstart;    USPTR Xmstart;
   USPTR Xmarkptr;  
351    int Xoffset_top;    int Xoffset_top;
352    eptrblock *Xeptrb;    eptrblock *Xeptrb;
353    unsigned int Xrdepth;    unsigned int Xrdepth;
# Line 438  the subject. */ Line 428  the subject. */
428        eptr > md->start_used_ptr) \        eptr > md->start_used_ptr) \
429      { \      { \
430      md->hitend = TRUE; \      md->hitend = TRUE; \
431      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
432      }      }
433    
434  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
435    if (md->partial != 0 && eptr > md->start_used_ptr) \    if (md->partial != 0 && eptr > md->start_used_ptr) \
436      { \      { \
437      md->hitend = TRUE; \      md->hitend = TRUE; \
438      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
439      }      }
440    
441    
# Line 459  Arguments: Line 449  Arguments:
449     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
450     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
451                   by encountering \K)                   by encountering \K)
    markptr     pointer to the most recent MARK name, or NULL  
452     offset_top  current top pointer     offset_top  current top pointer
453     md          pointer to "static" info for the match     md          pointer to "static" info for the match
454     eptrb       pointer to chain of blocks containing eptr at start of     eptrb       pointer to chain of blocks containing eptr at start of
# Line 475  Returns:       MATCH_MATCH if matched Line 464  Returns:       MATCH_MATCH if matched
464    
465  static int  static int
466  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
467    const uschar *markptr, int offset_top, match_data *md, eptrblock *eptrb,    int offset_top, match_data *md, eptrblock *eptrb, unsigned int rdepth)
   unsigned int rdepth)  
468  {  {
469  /* 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,
470  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 506  frame->Xprevframe = NULL;            /* Line 494  frame->Xprevframe = NULL;            /*
494  frame->Xeptr = eptr;  frame->Xeptr = eptr;
495  frame->Xecode = ecode;  frame->Xecode = ecode;
496  frame->Xmstart = mstart;  frame->Xmstart = mstart;
 frame->Xmarkptr = markptr;  
497  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
498  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
499  frame->Xrdepth = rdepth;  frame->Xrdepth = rdepth;
# Line 520  HEAP_RECURSE: Line 507  HEAP_RECURSE:
507  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
508  #define ecode              frame->Xecode  #define ecode              frame->Xecode
509  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
 #define markptr            frame->Xmarkptr  
510  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
511  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
512  #define rdepth             frame->Xrdepth  #define rdepth             frame->Xrdepth
# Line 701  for (;;) Line 687  for (;;)
687    switch(op)    switch(op)
688      {      {
689      case OP_MARK:      case OP_MARK:
690      markptr = ecode + 2;      md->nomatch_mark = ecode + 2;
691        md->mark = NULL;    /* In case previously set by assertion */
692      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
693        eptrb, RM55);        eptrb, RM55);
694        if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
695             md->mark == NULL) md->mark = ecode + 2;
696    
697      /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an      /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
698      argument, and we must check whether that argument matches this MARK's      argument, and we must check whether that argument matches this MARK's
# Line 712  for (;;) Line 701  for (;;)
701      position and return MATCH_SKIP. Otherwise, pass back the return code      position and return MATCH_SKIP. Otherwise, pass back the return code
702      unaltered. */      unaltered. */
703    
704      if (rrc == MATCH_SKIP_ARG &&      else if (rrc == MATCH_SKIP_ARG &&
705          strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)          strcmp((char *)(ecode + 2), (char *)(md->start_match_ptr)) == 0)
706        {        {
707        md->start_match_ptr = eptr;        md->start_match_ptr = eptr;
708        RRETURN(MATCH_SKIP);        RRETURN(MATCH_SKIP);
709        }        }
   
     if (md->mark == NULL) md->mark = markptr;  
710      RRETURN(rrc);      RRETURN(rrc);
711    
712      case OP_FAIL:      case OP_FAIL:
713      MRRETURN(MATCH_NOMATCH);      RRETURN(MATCH_NOMATCH);
714    
715      /* COMMIT overrides PRUNE, SKIP, and THEN */      /* COMMIT overrides PRUNE, SKIP, and THEN */
716    
# Line 734  for (;;) Line 721  for (;;)
721          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
722          rrc != MATCH_THEN)          rrc != MATCH_THEN)
723        RRETURN(rrc);        RRETURN(rrc);
724      MRRETURN(MATCH_COMMIT);      RRETURN(MATCH_COMMIT);
725    
726      /* PRUNE overrides THEN */      /* PRUNE overrides THEN */
727    
# Line 742  for (;;) Line 729  for (;;)
729      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
730        eptrb, RM51);        eptrb, RM51);
731      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
732      MRRETURN(MATCH_PRUNE);      RRETURN(MATCH_PRUNE);
733    
734      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
735        md->nomatch_mark = ecode + 2;
736        md->mark = NULL;    /* In case previously set by assertion */
737      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
738        eptrb, RM56);        eptrb, RM56);
739        if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
740             md->mark == NULL) md->mark = ecode + 2;
741      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
     md->mark = ecode + 2;  
742      RRETURN(MATCH_PRUNE);      RRETURN(MATCH_PRUNE);
743    
744      /* SKIP overrides PRUNE and THEN */      /* SKIP overrides PRUNE and THEN */
# Line 759  for (;;) Line 749  for (;;)
749      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
750        RRETURN(rrc);        RRETURN(rrc);
751      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
752      MRRETURN(MATCH_SKIP);      RRETURN(MATCH_SKIP);
753    
754        /* Note that, for Perl compatibility, SKIP with an argument does NOT set
755        nomatch_mark. There is a flag that disables this opcode when re-matching a
756        pattern that ended with a SKIP for which there was not a matching MARK. */
757    
758      case OP_SKIP_ARG:      case OP_SKIP_ARG:
759        if (md->ignore_skip_arg)
760          {
761          ecode += _pcre_OP_lengths[*ecode] + ecode[1];
762          break;
763          }
764      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
765        eptrb, RM57);        eptrb, RM57);
766      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
# Line 769  for (;;) Line 768  for (;;)
768    
769      /* Pass back the current skip name by overloading md->start_match_ptr and      /* Pass back the current skip name by overloading md->start_match_ptr and
770      returning the special MATCH_SKIP_ARG return code. This will either be      returning the special MATCH_SKIP_ARG return code. This will either be
771      caught by a matching MARK, or get to the top, where it is treated the same      caught by a matching MARK, or get to the top, where it causes a rematch
772      as PRUNE. */      with the md->ignore_skip_arg flag set. */
773    
774      md->start_match_ptr = ecode + 2;      md->start_match_ptr = ecode + 2;
775      RRETURN(MATCH_SKIP_ARG);      RRETURN(MATCH_SKIP_ARG);
# Line 784  for (;;) Line 783  for (;;)
783        eptrb, RM54);        eptrb, RM54);
784      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
785      md->start_match_ptr = ecode;      md->start_match_ptr = ecode;
786      MRRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
787    
788      case OP_THEN_ARG:      case OP_THEN_ARG:
789        md->nomatch_mark = ecode + 2;
790        md->mark = NULL;    /* In case previously set by assertion */
791      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
792        md, eptrb, RM58);        md, eptrb, RM58);
793        if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
794             md->mark == NULL) md->mark = ecode + 2;
795      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
796      md->start_match_ptr = ecode;      md->start_match_ptr = ecode;
     md->mark = ecode + 2;  
797      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
798    
799      /* Handle an atomic group that does not contain any capturing parentheses.      /* Handle an atomic group that does not contain any capturing parentheses.
# Line 816  for (;;) Line 818  for (;;)
818        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
819          {          {
820          mstart = md->start_match_ptr;          mstart = md->start_match_ptr;
         markptr = md->mark;  
821          break;          break;
822          }          }
823        if (rrc == MATCH_THEN)        if (rrc == MATCH_THEN)
# Line 954  for (;;) Line 955  for (;;)
955    
956        /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */        /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
957    
       if (md->mark == NULL) md->mark = markptr;  
958        RRETURN(rrc);        RRETURN(rrc);
959        }        }
960    
# Line 1042  for (;;) Line 1042  for (;;)
1042        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1043        }        }
1044    
     if (md->mark == NULL) md->mark = markptr;  
1045      RRETURN(MATCH_NOMATCH);      RRETURN(MATCH_NOMATCH);
1046    
1047      /* Handle possessive capturing brackets with an unlimited repeat. We come      /* Handle possessive capturing brackets with an unlimited repeat. We come
# Line 1130  for (;;) Line 1129  for (;;)
1129          md->offset_vector[md->offset_end - number] = save_offset3;          md->offset_vector[md->offset_end - number] = save_offset3;
1130          }          }
1131    
       if (md->mark == NULL) md->mark = markptr;  
1132        if (allow_zero || matched_once)        if (allow_zero || matched_once)
1133          {          {
1134          ecode += 1 + LINK_SIZE;          ecode += 1 + LINK_SIZE;
# Line 1232  for (;;) Line 1230  for (;;)
1230          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
1231          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
1232          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
1233          cb.mark             = markptr;          cb.mark             = md->nomatch_mark;
1234          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1235          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
1236          }          }
1237        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 1488  for (;;) Line 1486  for (;;)
1486           (md->notempty ||           (md->notempty ||
1487             (md->notempty_atstart &&             (md->notempty_atstart &&
1488               mstart == md->start_subject + md->start_offset)))               mstart == md->start_subject + md->start_offset)))
1489        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1490    
1491      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1492    
# Line 1497  for (;;) Line 1495  for (;;)
1495      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1496    
1497      /* For some reason, the macros don't work properly if an expression is      /* For some reason, the macros don't work properly if an expression is
1498      given as the argument to MRRETURN when the heap is in use. */      given as the argument to RRETURN when the heap is in use. */
1499    
1500      rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;      rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1501      MRRETURN(rrc);      RRETURN(rrc);
1502    
1503      /* Assertion brackets. Check the alternative branches in turn - the      /* Assertion brackets. Check the alternative branches in turn - the
1504      matching won't pass the KET for an assertion. If any one branch matches,      matching won't pass the KET for an assertion. If any one branch matches,
# Line 1528  for (;;) Line 1526  for (;;)
1526        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1527          {          {
1528          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
         markptr = md->mark;  
1529          break;          break;
1530          }          }
1531    
# Line 1540  for (;;) Line 1537  for (;;)
1537        }        }
1538      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1539    
1540      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
1541    
1542      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1543    
# Line 1570  for (;;) Line 1567  for (;;)
1567      do      do
1568        {        {
1569        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1570        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
1571        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1572          {          {
1573          do ecode += GET(ecode,1); while (*ecode == OP_ALT);          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
# Line 1603  for (;;) Line 1600  for (;;)
1600        while (i-- > 0)        while (i-- > 0)
1601          {          {
1602          eptr--;          eptr--;
1603          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1604          BACKCHAR(eptr);          BACKCHAR(eptr);
1605          }          }
1606        }        }
# Line 1614  for (;;) Line 1611  for (;;)
1611    
1612        {        {
1613        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1614        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1615        }        }
1616    
1617      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1643  for (;;) Line 1640  for (;;)
1640        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1641        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1642        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1643        cb.mark             = markptr;        cb.mark             = md->nomatch_mark;
1644        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1645        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1646        }        }
1647      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1758  for (;;) Line 1755  for (;;)
1755        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1756        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1757          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1758        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1759        }        }
1760    
1761      RECURSION_MATCHED:      RECURSION_MATCHED:
# Line 1838  for (;;) Line 1835  for (;;)
1835        md->end_match_ptr = eptr;      /* For ONCE_NC */        md->end_match_ptr = eptr;      /* For ONCE_NC */
1836        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1837        md->start_match_ptr = mstart;        md->start_match_ptr = mstart;
1838        MRRETURN(MATCH_MATCH);         /* Sets md->mark */        RRETURN(MATCH_MATCH);         /* Sets md->mark */
1839        }        }
1840    
1841      /* 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 1980  for (;;) Line 1977  for (;;)
1977      /* Not multiline mode: start of subject assertion, unless notbol. */      /* Not multiline mode: start of subject assertion, unless notbol. */
1978    
1979      case OP_CIRC:      case OP_CIRC:
1980      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
1981    
1982      /* Start of subject assertion */      /* Start of subject assertion */
1983    
1984      case OP_SOD:      case OP_SOD:
1985      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
1986      ecode++;      ecode++;
1987      break;      break;
1988    
1989      /* Multiline mode: start of subject unless notbol, or after any newline. */      /* Multiline mode: start of subject unless notbol, or after any newline. */
1990    
1991      case OP_CIRCM:      case OP_CIRCM:
1992      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
1993      if (eptr != md->start_subject &&      if (eptr != md->start_subject &&
1994          (eptr == md->end_subject || !WAS_NEWLINE(eptr)))          (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1995        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1996      ecode++;      ecode++;
1997      break;      break;
1998    
1999      /* Start of match assertion */      /* Start of match assertion */
2000    
2001      case OP_SOM:      case OP_SOM:
2002      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
2003      ecode++;      ecode++;
2004      break;      break;
2005    
# Line 2018  for (;;) Line 2015  for (;;)
2015    
2016      case OP_DOLLM:      case OP_DOLLM:
2017      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2018        { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }        { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
2019      else      else
2020        {        {
2021        if (md->noteol) MRRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
2022        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2023        }        }
2024      ecode++;      ecode++;
# Line 2031  for (;;) Line 2028  for (;;)
2028      subject unless noteol is set. */      subject unless noteol is set. */
2029    
2030      case OP_DOLL:      case OP_DOLL:
2031      if (md->noteol) MRRETURN(MATCH_NOMATCH);      if (md->noteol) RRETURN(MATCH_NOMATCH);
2032      if (!md->endonly) goto ASSERT_NL_OR_EOS;      if (!md->endonly) goto ASSERT_NL_OR_EOS;
2033    
2034      /* ... else fall through for endonly */      /* ... else fall through for endonly */
# Line 2039  for (;;) Line 2036  for (;;)
2036      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
2037    
2038      case OP_EOD:      case OP_EOD:
2039      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
2040      SCHECK_PARTIAL();      SCHECK_PARTIAL();
2041      ecode++;      ecode++;
2042      break;      break;
# Line 2050  for (;;) Line 2047  for (;;)
2047      ASSERT_NL_OR_EOS:      ASSERT_NL_OR_EOS:
2048      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2049          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2050        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2051    
2052      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2053    
# Line 2172  for (;;) Line 2169  for (;;)
2169    
2170        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
2171             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
2172          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2173        }        }
2174      break;      break;
2175    
2176      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
2177    
2178      case OP_ANY:      case OP_ANY:
2179      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2180      /* Fall through */      /* Fall through */
2181    
2182      case OP_ALLANY:      case OP_ALLANY:
2183      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2184        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
2185        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2186        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2187        }        }
2188      eptr++;      eptr++;
2189      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 2200  for (;;) Line 2197  for (;;)
2197      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2198        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
2199        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2200        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2201        }        }
2202      eptr++;      eptr++;
2203      ecode++;      ecode++;
# Line 2210  for (;;) Line 2207  for (;;)
2207      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2208        {        {
2209        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2210        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2211        }        }
2212      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2213      if (      if (
# Line 2219  for (;;) Line 2216  for (;;)
2216  #endif  #endif
2217         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
2218         )         )
2219        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2220      ecode++;      ecode++;
2221      break;      break;
2222    
# Line 2227  for (;;) Line 2224  for (;;)
2224      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2225        {        {
2226        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2227        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2228        }        }
2229      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2230      if (      if (
# Line 2236  for (;;) Line 2233  for (;;)
2233  #endif  #endif
2234         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
2235         )         )
2236        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2237      ecode++;      ecode++;
2238      break;      break;
2239    
# Line 2244  for (;;) Line 2241  for (;;)
2241      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2242        {        {
2243        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2244        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2245        }        }
2246      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2247      if (      if (
# Line 2253  for (;;) Line 2250  for (;;)
2250  #endif  #endif
2251         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
2252         )         )
2253        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2254      ecode++;      ecode++;
2255      break;      break;
2256    
# Line 2261  for (;;) Line 2258  for (;;)
2258      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2259        {        {
2260        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2261        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2262        }        }
2263      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2264      if (      if (
# Line 2270  for (;;) Line 2267  for (;;)
2267  #endif  #endif
2268         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
2269         )         )
2270        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2271      ecode++;      ecode++;
2272      break;      break;
2273    
# Line 2278  for (;;) Line 2275  for (;;)
2275      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2276        {        {
2277        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2278        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2279        }        }
2280      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2281      if (      if (
# Line 2287  for (;;) Line 2284  for (;;)
2284  #endif  #endif
2285         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
2286         )         )
2287        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2288      ecode++;      ecode++;
2289      break;      break;
2290    
# Line 2295  for (;;) Line 2292  for (;;)
2292      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2293        {        {
2294        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2295        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2296        }        }
2297      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2298      if (      if (
# Line 2304  for (;;) Line 2301  for (;;)
2301  #endif  #endif
2302         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
2303         )         )
2304        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2305      ecode++;      ecode++;
2306      break;      break;
2307    
# Line 2312  for (;;) Line 2309  for (;;)
2309      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2310        {        {
2311        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2312        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2313        }        }
2314      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2315      switch(c)      switch(c)
2316        {        {
2317        default: MRRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2318    
2319        case 0x000d:        case 0x000d:
2320        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
# Line 2331  for (;;) Line 2328  for (;;)
2328        case 0x0085:        case 0x0085:
2329        case 0x2028:        case 0x2028:
2330        case 0x2029:        case 0x2029:
2331        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2332        break;        break;
2333        }        }
2334      ecode++;      ecode++;
# Line 2341  for (;;) Line 2338  for (;;)
2338      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2339        {        {
2340        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2341        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2342        }        }
2343      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2344      switch(c)      switch(c)
# Line 2366  for (;;) Line 2363  for (;;)
2363        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2364        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2365        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2366        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2367        }        }
2368      ecode++;      ecode++;
2369      break;      break;
# Line 2375  for (;;) Line 2372  for (;;)
2372      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2373        {        {
2374        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2375        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2376        }        }
2377      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2378      switch(c)      switch(c)
2379        {        {
2380        default: MRRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2381        case 0x09:      /* HT */        case 0x09:      /* HT */
2382        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2383        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 2409  for (;;) Line 2406  for (;;)
2406      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2407        {        {
2408        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2409        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2410        }        }
2411      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2412      switch(c)      switch(c)
# Line 2422  for (;;) Line 2419  for (;;)
2419        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2420        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2421        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2422        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2423        }        }
2424      ecode++;      ecode++;
2425      break;      break;
# Line 2431  for (;;) Line 2428  for (;;)
2428      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2429        {        {
2430        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2431        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2432        }        }
2433      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2434      switch(c)      switch(c)
2435        {        {
2436        default: MRRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2437        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2438        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2439        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 2458  for (;;) Line 2455  for (;;)
2455      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2456        {        {
2457        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2458        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2459        }        }
2460      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2461        {        {
# Line 2467  for (;;) Line 2464  for (;;)
2464        switch(ecode[1])        switch(ecode[1])
2465          {          {
2466          case PT_ANY:          case PT_ANY:
2467          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2468          break;          break;
2469    
2470          case PT_LAMP:          case PT_LAMP:
2471          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2472               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2473               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2474            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2475          break;          break;
2476    
2477          case PT_GC:          case PT_GC:
2478          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2479            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2480          break;          break;
2481    
2482          case PT_PC:          case PT_PC:
2483          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2484            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2485          break;          break;
2486    
2487          case PT_SC:          case PT_SC:
2488          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2489            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2490          break;          break;
2491    
2492          /* These are specials */          /* These are specials */
# Line 2497  for (;;) Line 2494  for (;;)
2494          case PT_ALNUM:          case PT_ALNUM:
2495          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2496               _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))               _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2497            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2498          break;          break;
2499    
2500          case PT_SPACE:    /* Perl space */          case PT_SPACE:    /* Perl space */
2501          if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||          if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2502               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2503                 == (op == OP_NOTPROP))                 == (op == OP_NOTPROP))
2504            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2505          break;          break;
2506    
2507          case PT_PXSPACE:  /* POSIX space */          case PT_PXSPACE:  /* POSIX space */
# Line 2512  for (;;) Line 2509  for (;;)
2509               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2510               c == CHAR_FF || c == CHAR_CR)               c == CHAR_FF || c == CHAR_CR)
2511                 == (op == OP_NOTPROP))                 == (op == OP_NOTPROP))
2512            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2513          break;          break;
2514    
2515          case PT_WORD:          case PT_WORD:
2516          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2517               _pcre_ucp_gentype[prop->chartype] == ucp_N ||               _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2518               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2519            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2520          break;          break;
2521    
2522          /* This should never occur */          /* This should never occur */
# Line 2539  for (;;) Line 2536  for (;;)
2536      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2537        {        {
2538        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2539        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2540        }        }
2541      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2542      if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);      if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
2543      while (eptr < md->end_subject)      while (eptr < md->end_subject)
2544        {        {
2545        int len = 1;        int len = 1;
# Line 2616  for (;;) Line 2613  for (;;)
2613        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2614          {          {
2615          CHECK_PARTIAL();          CHECK_PARTIAL();
2616          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2617          }          }
2618        eptr += length;        eptr += length;
2619        continue;              /* With the main loop */        continue;              /* With the main loop */
# Line 2637  for (;;) Line 2634  for (;;)
2634        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2635          {          {
2636          CHECK_PARTIAL();          CHECK_PARTIAL();
2637          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2638          }          }
2639        eptr += slength;        eptr += slength;
2640        }        }
# Line 2656  for (;;) Line 2653  for (;;)
2653          int slength;          int slength;
2654          RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
2655          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2656          if (fi >= max) MRRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2657          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2658            {            {
2659            CHECK_PARTIAL();            CHECK_PARTIAL();
2660            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2661            }            }
2662          eptr += slength;          eptr += slength;
2663          }          }
# Line 2688  for (;;) Line 2685  for (;;)
2685          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2686          eptr -= length;          eptr -= length;
2687          }          }
2688        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2689        }        }
2690      /* Control never gets here */      /* Control never gets here */
2691    
# Line 2749  for (;;) Line 2746  for (;;)
2746            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2747              {              {
2748              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2749              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2750              }              }
2751            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2752            if (c > 255)            if (c > 255)
2753              {              {
2754              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2755              }              }
2756            else            else
2757              {              {
2758              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2759              }              }
2760            }            }
2761          }          }
# Line 2771  for (;;) Line 2768  for (;;)
2768            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2769              {              {
2770              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2771              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2772              }              }
2773            c = *eptr++;            c = *eptr++;
2774            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2775            }            }
2776          }          }
2777    
# Line 2796  for (;;) Line 2793  for (;;)
2793              {              {
2794              RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
2795              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2796              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
2797              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2798                {                {
2799                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2800                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2801                }                }
2802              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2803              if (c > 255)              if (c > 255)
2804                {                {
2805                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2806                }                }
2807              else              else
2808                {                {
2809                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2810                }                }
2811              }              }
2812            }            }
# Line 2821  for (;;) Line 2818  for (;;)
2818              {              {
2819              RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
2820              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2821              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
2822              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2823                {                {
2824                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2825                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2826                }                }
2827              c = *eptr++;              c = *eptr++;
2828              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2829              }              }
2830            }            }
2831          /* Control never gets here */          /* Control never gets here */
# Line 2894  for (;;) Line 2891  for (;;)
2891              }              }
2892            }            }
2893    
2894          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2895          }          }
2896        }        }
2897      /* Control never gets here */      /* Control never gets here */
# Line 2946  for (;;) Line 2943  for (;;)
2943          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2944            {            {
2945            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2946            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2947            }            }
2948          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2949          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2950          }          }
2951    
2952        /* 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 2966  for (;;) Line 2963  for (;;)
2963            {            {
2964            RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
2965            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2966            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
2967            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2968              {              {
2969              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2970              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2971              }              }
2972            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2973            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2974            }            }
2975          /* Control never gets here */          /* Control never gets here */
2976          }          }
# Line 3002  for (;;) Line 2999  for (;;)
2999            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3000            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3001            }            }
3002          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3003          }          }
3004    
3005        /* Control never gets here */        /* Control never gets here */
# Line 3021  for (;;) Line 3018  for (;;)
3018        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
3019          {          {
3020          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3021          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3022          }          }
3023        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
3024        }        }
3025      else      else
3026  #endif  #endif
# Line 3033  for (;;) Line 3030  for (;;)
3030        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
3031          {          {
3032          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
3033          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3034          }          }
3035        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
3036        ecode += 2;        ecode += 2;
3037        }        }
3038      break;      break;
# Line 3053  for (;;) Line 3050  for (;;)
3050        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
3051          {          {
3052          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3053          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3054          }          }
3055    
3056        /* 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 3061  for (;;) Line 3058  for (;;)
3058    
3059        if (fc < 128)        if (fc < 128)
3060          {          {
3061          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3062          }          }
3063    
3064        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 3080  for (;;) Line 3077  for (;;)
3077  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3078            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
3079  #endif  #endif
3080              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3081            }            }
3082          }          }
3083        }        }
# Line 3092  for (;;) Line 3089  for (;;)
3089        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
3090          {          {
3091          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
3092          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3093          }          }
3094        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3095        ecode += 2;        ecode += 2;
3096        }        }
3097      break;      break;
# Line 3200  for (;;) Line 3197  for (;;)
3197            else            else
3198              {              {
3199              CHECK_PARTIAL();              CHECK_PARTIAL();
3200              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3201              }              }
3202            }            }
3203    
# Line 3212  for (;;) Line 3209  for (;;)
3209              {              {
3210              RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
3211              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3212              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3213              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
3214                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
3215  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 3223  for (;;) Line 3220  for (;;)
3220              else              else
3221                {                {
3222                CHECK_PARTIAL();                CHECK_PARTIAL();
3223                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3224                }                }
3225              }              }
3226            /* Control never gets here */            /* Control never gets here */
# Line 3254  for (;;) Line 3251  for (;;)
3251              {              {
3252              RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
3253              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3254              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }
3255  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3256              eptr--;              eptr--;
3257              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 3297  for (;;) Line 3294  for (;;)
3294          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3295            {            {
3296            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3297            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3298            }            }
3299          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3300          }          }
3301        if (min == max) continue;        if (min == max) continue;
3302        if (minimize)        if (minimize)
# Line 3308  for (;;) Line 3305  for (;;)
3305            {            {
3306            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3307            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3308            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
3309            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3310              {              {
3311              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3312              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3313              }              }
3314            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3315            }            }
3316          /* Control never gets here */          /* Control never gets here */
3317          }          }
# Line 3340  for (;;) Line 3337  for (;;)
3337            eptr--;            eptr--;
3338            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3339            }            }
3340          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3341          }          }
3342        /* Control never gets here */        /* Control never gets here */
3343        }        }
# Line 3354  for (;;) Line 3351  for (;;)
3351          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3352            {            {
3353            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3354            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3355            }            }
3356          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
3357          }          }
3358    
3359        if (min == max) continue;        if (min == max) continue;
# Line 3367  for (;;) Line 3364  for (;;)
3364            {            {
3365            RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
3366            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3367            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
3368            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3369              {              {
3370              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3371              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3372              }              }
3373            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
3374            }            }
3375          /* Control never gets here */          /* Control never gets here */
3376          }          }
# Line 3398  for (;;) Line 3395  for (;;)
3395            eptr--;            eptr--;
3396            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3397            }            }
3398          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3399          }          }
3400        }        }
3401      /* Control never gets here */      /* Control never gets here */
# Line 3411  for (;;) Line 3408  for (;;)
3408      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
3409        {        {
3410        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3411        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3412        }        }
3413      ecode++;      ecode++;
3414      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 3421  for (;;) Line 3418  for (;;)
3418        if (c < 256)        if (c < 256)
3419  #endif  #endif
3420        c = md->lcc[c];        c = md->lcc[c];
3421        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);
3422        }        }
3423      else    /* Caseful */      else    /* Caseful */
3424        {        {
3425        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
3426        }        }
3427      break;      break;
3428    
# Line 3532  for (;;) Line 3529  for (;;)
3529            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3530              {              {
3531              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3532              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3533              }              }
3534            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3535            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3536            if (fc == d) MRRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
3537            }            }
3538          }          }
3539        else        else
# Line 3549  for (;;) Line 3546  for (;;)
3546            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3547              {              {
3548              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3549              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3550              }              }
3551            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3552            }            }
3553          }          }
3554    
# Line 3568  for (;;) Line 3565  for (;;)
3565              {              {
3566              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
3567              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3568              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3569              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3570                {                {
3571                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3572                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3573                }                }
3574              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3575              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3576              if (fc == d) MRRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
3577              }              }
3578            }            }
3579          else          else
# Line 3587  for (;;) Line 3584  for (;;)
3584              {              {
3585              RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
3586              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3587              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3588              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3589                {                {
3590                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3591                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3592                }                }
3593              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3594              }              }
3595            }            }
3596          /* Control never gets here */          /* Control never gets here */
# Line 3655  for (;;) Line 3652  for (;;)
3652              }              }
3653            }            }
3654    
3655          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3656          }          }
3657        /* Control never gets here */        /* Control never gets here */
3658        }        }
# Line 3674  for (;;) Line 3671  for (;;)
3671            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3672              {              {
3673              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3674              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3675              }              }
3676            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3677            if (fc == d) MRRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
3678            }            }
3679          }          }
3680        else        else
# Line 3689  for (;;) Line 3686  for (;;)
3686            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3687              {              {
3688              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3689              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3690              }              }
3691            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3692            }            }
3693          }          }
3694    
# Line 3708  for (;;) Line 3705  for (;;)
3705              {              {
3706              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
3707              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3708              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3709              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3710                {                {
3711                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3712                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3713                }                }
3714              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3715              if (fc == d) MRRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
3716              }              }
3717            }            }
3718          else          else
# Line 3726  for (;;) Line 3723  for (;;)
3723              {              {
3724              RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
3725              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3726              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3727              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3728                {                {
3729                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3730                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3731                }                }
3732              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3733              }              }
3734            }            }
3735          /* Control never gets here */          /* Control never gets here */
# Line 3793  for (;;) Line 3790  for (;;)
3790              }              }
3791            }            }
3792    
3793          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3794          }          }
3795        }        }
3796      /* Control never gets here */      /* Control never gets here */
# Line 3887  for (;;) Line 3884  for (;;)
3884          switch(prop_type)          switch(prop_type)
3885            {            {
3886            case PT_ANY:            case PT_ANY:
3887            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3888            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3889              {              {
3890              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3891                {                {
3892                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3893                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3894                }                }
3895              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3896              }              }
# Line 3906  for (;;) Line 3903  for (;;)
3903              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3904                {                {
3905                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3906                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3907                }                }
3908              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3909              chartype = UCD_CHARTYPE(c);              chartype = UCD_CHARTYPE(c);
3910              if ((chartype == ucp_Lu ||              if ((chartype == ucp_Lu ||
3911                   chartype == ucp_Ll ||                   chartype == ucp_Ll ||
3912                   chartype == ucp_Lt) == prop_fail_result)                   chartype == ucp_Lt) == prop_fail_result)
3913                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3914              }              }
3915            break;            break;
3916    
# Line 3923  for (;;) Line 3920  for (;;)
3920              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3921                {                {
3922                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3923                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3924                }                }
3925              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3926              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
3927                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3928              }              }
3929            break;            break;
3930    
# Line 3937  for (;;) Line 3934  for (;;)
3934              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3935                {                {
3936                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3937                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3938                }                }
3939              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3940              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
3941                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3942              }              }
3943            break;            break;
3944    
# Line 3951  for (;;) Line 3948  for (;;)
3948              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3949                {                {
3950                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3951                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3952                }                }
3953              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3954              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
3955                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3956              }              }
3957            break;            break;
3958    
# Line 3966  for (;;) Line 3963  for (;;)
3963              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3964                {                {
3965                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3966                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3967                }                }
3968              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3969              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
3970              if ((category == ucp_L || category == ucp_N) == prop_fail_result)              if ((category == ucp_L || category == ucp_N) == prop_fail_result)
3971                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3972              }              }
3973            break;            break;
3974    
# Line 3981  for (;;) Line 3978  for (;;)
3978              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3979                {                {
3980                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3981                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3982                }                }
3983              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3984              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3985                   c == CHAR_FF || c == CHAR_CR)                   c == CHAR_FF || c == CHAR_CR)
3986                     == prop_fail_result)                     == prop_fail_result)
3987                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3988              }              }
3989            break;            break;
3990    
# Line 3997  for (;;) Line 3994  for (;;)
3994              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3995                {                {
3996                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3997                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3998                }                }
3999              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4000              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4001                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4002                     == prop_fail_result)                     == prop_fail_result)
4003                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4004              }              }
4005            break;            break;
4006    
# Line 4014  for (;;) Line 4011  for (;;)
4011              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4012                {                {
4013                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4014                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4015                }                }
4016              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4017              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
4018              if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)              if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)
4019                     == prop_fail_result)                     == prop_fail_result)
4020                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4021              }              }
4022            break;            break;
4023    
# Line 4041  for (;;) Line 4038  for (;;)
4038            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4039              {              {
4040              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4041              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4042              }              }
4043            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4044            if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
4045            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4046              {              {
4047              int len = 1;              int len = 1;
# Line 4069  for (;;) Line 4066  for (;;)
4066            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4067              {              {
4068              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4069              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4070              }              }
4071            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4072            eptr++;            eptr++;
4073            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4074            }            }
# Line 4083  for (;;) Line 4080  for (;;)
4080            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4081              {              {
4082              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4083              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4084              }              }
4085            eptr++;            eptr++;
4086            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 4091  for (;;) Line 4088  for (;;)
4088          break;          break;
4089    
4090          case OP_ANYBYTE:          case OP_ANYBYTE:
4091          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
4092          eptr += min;          eptr += min;
4093          break;          break;
4094    
# Line 4101  for (;;) Line 4098  for (;;)
4098            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4099              {              {
4100              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4101              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4102              }              }
4103            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4104            switch(c)            switch(c)
4105              {              {
4106              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4107    
4108              case 0x000d:              case 0x000d:
4109              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
# Line 4120  for (;;) Line 4117  for (;;)
4117              case 0x0085:              case 0x0085:
4118              case 0x2028:              case 0x2028:
4119              case 0x2029:              case 0x2029:
4120              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4121              break;              break;
4122              }              }
4123            }            }
# Line 4132  for (;;) Line 4129  for (;;)
4129            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4130              {              {
4131              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4132              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4133              }              }
4134            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4135            switch(c)            switch(c)
# Line 4157  for (;;) Line 4154  for (;;)
4154              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4155              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4156              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4157              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4158              }              }
4159            }            }
4160          break;          break;
# Line 4168  for (;;) Line 4165  for (;;)
4165            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4166              {              {
4167              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4168              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4169              }              }
4170            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4171            switch(c)            switch(c)
4172              {              {
4173              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4174              case 0x09:      /* HT */              case 0x09:      /* HT */
4175              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4176              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 4204  for (;;) Line 4201  for (;;)
4201            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4202              {              {
4203              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4204              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4205              }              }
4206            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4207            switch(c)            switch(c)
# Line 4217  for (;;) Line 4214  for (;;)
4214              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4215              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4216              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
4217              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4218              }              }
4219            }            }
4220          break;          break;
# Line 4228  for (;;) Line 4225  for (;;)
4225            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4226              {              {
4227              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4228              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4229              }              }
4230            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4231            switch(c)            switch(c)
4232              {              {
4233              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4234              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4235              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4236              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 4252  for (;;) Line 4249  for (;;)
4249            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4250              {              {
4251              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4252              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4253              }              }
4254            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4255            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
4256              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4257            }            }
4258          break;          break;
4259    
# Line 4266  for (;;) Line 4263  for (;;)
4263            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4264              {              {
4265              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4266              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4267              }              }
4268            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
4269              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4270            /* 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 */
4271            }            }
4272          break;          break;
# Line 4280  for (;;) Line 4277  for (;;)
4277            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4278              {              {
4279              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4280              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4281              }              }
4282            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
4283              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4284            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
4285            }            }
4286          break;          break;
# Line 4294  for (;;) Line 4291  for (;;)
4291            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4292              {              {
4293              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4294              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4295              }              }
4296            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
4297              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4298            /* 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 */
4299            }            }
4300          break;          break;
# Line 4308  for (;;) Line 4305  for (;;)
4305            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4306              {              {
4307              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4308              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4309              }              }
4310            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
4311              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4312            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
4313            }            }
4314          break;          break;
# Line 4322  for (;;) Line 4319  for (;;)
4319            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4320              {              {
4321              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4322              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4323              }              }
4324            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
4325              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4326            /* 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 */
4327            }            }
4328          break;          break;
# Line 4348  for (;;) Line 4345  for (;;)
4345            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4346              {              {
4347              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4348              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4349              }              }
4350            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4351            eptr++;            eptr++;
4352            }            }
4353          break;          break;
# Line 4359  for (;;) Line 4356  for (;;)
4356          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4357            {            {
4358            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4359            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
4360            }            }
4361          eptr += min;          eptr += min;
4362          break;          break;
# Line 4368  for (;;) Line 4365  for (;;)
4365          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4366            {            {
4367            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4368            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
4369            }            }
4370          eptr += min;          eptr += min;
4371          break;          break;
# Line 4379  for (;;) Line 4376  for (;;)
4376            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4377              {              {
4378              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4379              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4380              }              }
4381            switch(*eptr++)            switch(*eptr++)
4382              {              {
4383              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4384    
4385              case 0x000d:              case 0x000d:
4386              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
# Line 4395  for (;;) Line 4392  for (;;)
4392              case 0x000b:              case 0x000b:
4393              case 0x000c:              case 0x000c:
4394              case 0x0085:              case 0x0085:
4395              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4396              break;              break;
4397              }              }
4398            }            }
# Line 4407  for (;;) Line 4404  for (;;)
4404            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4405              {              {
4406              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4407              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4408              }              }
4409            switch(*eptr++)            switch(*eptr++)
4410              {              {
# Line 4415  for (;;) Line 4412  for (;;)
4412              case 0x09:      /* HT */              case 0x09:      /* HT */
4413              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4414              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4415              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4416              }              }
4417            }            }
4418          break;          break;
# Line 4426  for (;;) Line 4423  for (;;)
4423            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4424              {              {
4425              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4426              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4427              }              }
4428            switch(*eptr++)            switch(*eptr++)
4429              {              {
4430              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4431              case 0x09:      /* HT */              case 0x09:      /* HT */
4432              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4433              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 4445  for (;;) Line 4442  for (;;)
4442            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4443              {              {
4444              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4445              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4446              }              }
4447            switch(*eptr++)            switch(*eptr++)
4448              {              {
# Line 4455  for (;;) Line 4452  for (;;)
4452              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4453              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4454              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4455              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4456              }              }
4457            }            }
4458          break;          break;
# Line 4466  for (;;) Line 4463  for (;;)
4463            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4464              {              {
4465              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4466              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4467              }              }
4468            switch(*eptr++)            switch(*eptr++)
4469              {              {
4470              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4471              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4472              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4473              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 4487  for (;;) Line 4484  for (;;)
4484            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4485              {              {
4486              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4487              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4488              }              }
4489            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
4490            }            }
4491          break;          break;
4492    
# Line 4499  for (;;) Line 4496  for (;;)
4496            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4497              {              {
4498              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4499              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4500              }              }
4501            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
4502            }            }
4503          break;          break;
4504    
# Line 4511  for (;;) Line 4508  for (;;)
4508            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4509              {              {
4510              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4511              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4512              }              }
4513            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
4514            }            }
4515          break;          break;
4516    
# Line 4523  for (;;) Line 4520  for (;;)
4520            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4521              {              {
4522              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4523              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4524              }              }
4525            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
4526            }            }
4527          break;          break;
4528    
# Line 4535  for (;;) Line 4532  for (;;)
4532            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4533              {              {
4534              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4535              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4536              }              }
4537            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4538              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4539            }            }
4540          break;          break;
4541    
# Line 4548  for (;;) Line 4545  for (;;)
4545            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4546              {              {
4547              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4548              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4549              }              }
4550            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4551              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4552            }            }
4553          break;          break;
4554    
# Line 4580  for (;;) Line 4577  for (;;)
4577              {              {
4578              RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);
4579              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4580              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4581              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4582                {                {
4583                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4584                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4585                }                }
4586              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4587              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4588              }              }
4589            /* Control never gets here */            /* Control never gets here */
4590    
# Line 4597  for (;;) Line 4594  for (;;)
4594              int chartype;              int chartype;
4595              RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
4596              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4597              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4598              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4599                {                {
4600                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4601                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4602                }                }
4603              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4604              chartype = UCD_CHARTYPE(c);              chartype = UCD_CHARTYPE(c);
4605              if ((chartype == ucp_Lu ||              if ((chartype == ucp_Lu ||
4606                   chartype == ucp_Ll ||                   chartype == ucp_Ll ||
4607                   chartype == ucp_Lt) == prop_fail_result)                   chartype == ucp_Lt) == prop_fail_result)
4608                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4609              }              }
4610            /* Control never gets here */            /* Control never gets here */
4611    
# Line 4617  for (;;) Line 4614  for (;;)
4614              {              {
4615              RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);
4616              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4617              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4618              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4619                {                {
4620                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4621                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4622                }                }
4623              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4624              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
4625                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4626              }              }
4627            /* Control never gets here */            /* Control never gets here */
4628    
# Line 4634  for (;;) Line 4631  for (;;)
4631              {              {
4632              RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);
4633              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4634              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4635              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4636                {                {
4637                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4638                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4639                }                }
4640              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4641              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
4642                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4643              }              }
4644            /* Control never gets here */            /* Control never gets here */
4645    
# Line 4651  for (;;) Line 4648  for (;;)
4648              {              {
4649              RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);
4650              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4651              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4652              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4653                {                {
4654                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4655                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4656                }                }
4657              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4658              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
4659                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4660              }              }
4661            /* Control never gets here */            /* Control never gets here */
4662    
# Line 4669  for (;;) Line 4666  for (;;)
4666              int category;              int category;
4667              RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
4668              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4669              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4670              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4671                {                {
4672                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4673                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4674                }                }
4675              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4676              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
4677              if ((category == ucp_L || category == ucp_N) == prop_fail_result)              if ((category == ucp_L || category == ucp_N) == prop_fail_result)
4678                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4679              }              }
4680            /* Control never gets here */            /* Control never gets here */
4681    
# Line 4687  for (;;) Line 4684  for (;;)
4684              {              {
4685              RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
4686              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4687              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4688              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4689                {                {
4690                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4691                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4692                }                }
4693              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4694              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4695                   c == CHAR_FF || c == CHAR_CR)                   c == CHAR_FF || c == CHAR_CR)
4696                     == prop_fail_result)                     == prop_fail_result)
4697                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4698              }              }
4699            /* Control never gets here */            /* Control never gets here */
4700    
# Line 4706  for (;;) Line 4703  for (;;)
4703              {              {
4704              RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);
4705              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4706              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4707              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4708                {                {
4709                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4710                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4711                }                }
4712              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4713              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4714                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4715                     == prop_fail_result)                     == prop_fail_result)
4716                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4717              }              }
4718            /* Control never gets here */            /* Control never gets here */
4719    
# Line 4726  for (;;) Line 4723  for (;;)
4723              int category;              int category;
4724              RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
4725              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4726              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4727              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4728                {                {
4729                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4730                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4731                }                }
4732              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4733              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
# Line 4738  for (;;) Line 4735  for (;;)
4735                   category == ucp_N ||                   category == ucp_N ||
4736                   c == CHAR_UNDERSCORE)                   c == CHAR_UNDERSCORE)
4737                     == prop_fail_result)                     == prop_fail_result)
4738                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4739              }              }
4740            /* Control never gets here */            /* Control never gets here */
4741    
# Line 4758  for (;;) Line 4755  for (;;)
4755            {            {
4756            RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);
4757            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4758            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
4759            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4760              {              {
4761              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4762              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4763              }              }
4764            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4765            if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
4766            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4767              {              {
4768              int len = 1;              int len = 1;
# Line 4786  for (;;) Line 4783  for (;;)
4783            {            {
4784            RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);
4785            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4786            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
4787            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4788              {              {
4789              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4790              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4791              }              }
4792            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4793              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4794            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4795            switch(ctype)            switch(ctype)
4796              {              {
# Line 4805  for (;;) Line 4802  for (;;)
4802              case OP_ANYNL:              case OP_ANYNL:
4803              switch(c)              switch(c)
4804                {                {
4805                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4806                case 0x000d:                case 0x000d:
4807                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4808                break;                break;
# Line 4817  for (;;) Line 4814  for (;;)
4814                case 0x0085:                case 0x0085:
4815                case 0x2028:                case 0x2028:
4816                case 0x2029:                case 0x2029:
4817                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4818                break;                break;
4819                }                }
4820              break;              break;
# Line 4845  for (;;) Line 4842  for (;;)
4842                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4843                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4844                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4845                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4846                }                }
4847              break;              break;
4848    
4849              case OP_HSPACE:              case OP_HSPACE:
4850              switch(c)              switch(c)
4851                {                {
4852                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4853                case 0x09:      /* HT */                case 0x09:      /* HT */
4854                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4855                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4887  for (;;) Line 4884  for (;;)
4884                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4885                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4886                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4887                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4888                }                }
4889              break;              break;
4890    
4891              case OP_VSPACE:              case OP_VSPACE:
4892              switch(c)              switch(c)
4893                {                {
4894                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4895                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4896                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4897                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4908  for (;;) Line 4905  for (;;)
4905    
4906              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4907              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4908                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4909              break;              break;
4910    
4911              case OP_DIGIT:              case OP_DIGIT:
4912              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4913                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4914              break;              break;
4915    
4916              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4917              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4918                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4919              break;              break;
4920    
4921              case OP_WHITESPACE:              case OP_WHITESPACE:
4922              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4923                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4924              break;              break;
4925    
4926              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4927              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4928                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4929              break;              break;
4930    
4931              case OP_WORDCHAR:              case OP_WORDCHAR:
4932              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4933                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4934              break;              break;
4935    
4936              default:              default:
# Line 4949  for (;;) Line 4946  for (;;)
4946            {            {
4947            RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);
4948            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4949            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
4950            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4951              {              {
4952              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4953              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4954              }              }
4955            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4956              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4957            c = *eptr++;            c = *eptr++;
4958            switch(ctype)            switch(ctype)
4959              {              {
# Line 4968  for (;;) Line 4965  for (;;)
4965              case OP_ANYNL:              case OP_ANYNL:
4966              switch(c)              switch(c)
4967                {                {
4968                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4969                case 0x000d:                case 0x000d:
4970                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4971                break;                break;
# Line 4979  for (;;) Line 4976  for (;;)
4976                case 0x000b:                case 0x000b:
4977                case 0x000c:                case 0x000c:
4978                case 0x0085:                case 0x0085:
4979                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4980                break;                break;
4981                }                }
4982              break;              break;
# Line 4991  for (;;) Line 4988  for (;;)
4988                case 0x09:      /* HT */                case 0x09:      /* HT */
4989                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4990                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4991                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4992                }                }
4993              break;              break;
4994    
4995              case OP_HSPACE:              case OP_HSPACE:
4996              switch(c)              switch(c)
4997                {                {
4998                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4999                case 0x09:      /* HT */                case 0x09:      /* HT */
5000                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
5001                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 5015  for (;;) Line 5012  for (;;)
5012                case 0x0c:      /* FF */                case 0x0c:      /* FF */
5013                case 0x0d:      /* CR */                case 0x0d:      /* CR */
5014                case 0x85:      /* NEL */                case 0x85:      /* NEL */
5015                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5016                }                }
5017              break;              break;
5018    
5019              case OP_VSPACE:              case OP_VSPACE:
5020              switch(c)              switch(c)
5021                {                {
5022                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5023                case 0x0a:      /* LF */                case 0x0a:      /* LF */
5024                case 0x0b:      /* VT */                case 0x0b:      /* VT */
5025                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 5033  for (;;) Line 5030  for (;;)
5030              break;              break;
5031    
5032              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
5033              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
5034              break;              break;
5035    
5036              case OP_DIGIT:              case OP_DIGIT:
5037              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
5038              break;              break;
5039    
5040              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
5041              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
5042              break;              break;
5043    
5044              case OP_WHITESPACE:              case OP_WHITESPACE:
5045              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
5046              break;              break;
5047    
5048              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
5049              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
5050              break;              break;
5051    
5052              case OP_WORDCHAR:              case OP_WORDCHAR:
5053              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
5054              break;              break;
5055    
5056              default:              default:
# Line 5795  for (;;) Line 5792  for (;;)
5792    
5793        /* 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 */
5794    
5795        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
5796        }        }
5797      /* Control never gets here */      /* Control never gets here */
5798    
# Line 6090  end_subject = md->end_subject; Line 6087  end_subject = md->end_subject;
6087  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
6088  md->use_ucp = (re->options & PCRE_UCP) != 0;  md->use_ucp = (re->options & PCRE_UCP) != 0;
6089  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
6090    md->ignore_skip_arg = FALSE;
6091    
6092  /* Some options are unpacked into BOOL variables in the hope that testing  /* Some options are unpacked into BOOL variables in the hope that testing
6093  them will be faster than individual option bits. */  them will be faster than individual option bits. */
# Line 6100  md->notempty = (options & PCRE_NOTEMPTY) Line 6098  md->notempty = (options & PCRE_NOTEMPTY)
6098  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
6099    
6100  md->hitend = FALSE;  md->hitend = FALSE;
6101  md->mark = NULL;                        /* In case never set */  md->mark = md->nomatch_mark = NULL;     /* In case never set */
6102    
6103  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
6104  md->hasthen = (re->flags & PCRE_HASTHEN) != 0;  md->hasthen = (re->flags & PCRE_HASTHEN) != 0;
# Line 6452  for(;;) Line 6450  for(;;)
6450    md->match_call_count = 0;    md->match_call_count = 0;
6451    md->match_function_type = 0;    md->match_function_type = 0;
6452    md->end_offset_top = 0;    md->end_offset_top = 0;
6453    rc = match(start_match, md->start_code, start_match, NULL, 2, md, NULL, 0);    rc = match(start_match, md->start_code, start_match, 2, md, NULL, 0);
6454    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
6455    
6456    switch(rc)    switch(rc)
6457      {      {
6458        /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
6459        the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP
6460        entirely. The only way we can do that is to re-do the match at the same
6461        point, with a flag to force SKIP with an argument to be ignored. Just
6462        treating this case as NOMATCH does not work because it does not check other
6463        alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */
6464    
6465        case MATCH_SKIP_ARG:
6466        new_start_match = start_match;
6467        md->ignore_skip_arg = TRUE;
6468        break;
6469    
6470      /* SKIP passes back the next starting point explicitly, but if it is the      /* SKIP passes back the next starting point explicitly, but if it is the
6471      same as the match we have just done, treat it as NOMATCH. */      same as the match we have just done, treat it as NOMATCH. */
6472    
# Line 6468  for(;;) Line 6478  for(;;)
6478        }        }
6479      /* Fall through */      /* Fall through */
6480    
     /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched  
     the SKIP's arg was not found. We also treat this as NOMATCH. */  
   
     case MATCH_SKIP_ARG:  
     /* Fall through */  
   
6481      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6482      exactly like PRUNE. */      exactly like PRUNE. Unset the ignore SKIP-with-argument flag. */
6483    
6484      case MATCH_NOMATCH:      case MATCH_NOMATCH:
6485      case MATCH_PRUNE:      case MATCH_PRUNE:
6486      case MATCH_THEN:      case MATCH_THEN:
6487        md->ignore_skip_arg = FALSE;
6488      new_start_match = start_match + 1;      new_start_match = start_match + 1;
6489  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
6490      if (utf8)      if (utf8)
# Line 6608  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6613  if (rc == MATCH_MATCH || rc == MATCH_ACC
6613      offsets[1] = (int)(md->end_match_ptr - md->start_subject);      offsets[1] = (int)(md->end_match_ptr - md->start_subject);
6614      }      }
6615    
6616      /* Return MARK data if requested */
6617    
6618      if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6619        *(extra_data->mark) = (unsigned char *)(md->mark);
6620    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6621    goto RETURN_MARK;    return rc;
6622    }    }
6623    
6624  /* 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 6653  else Line 6662  else
6662    
6663  /* Return the MARK data if it has been requested. */  /* Return the MARK data if it has been requested. */
6664    
 RETURN_MARK:  
   
6665  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6666    *(extra_data->mark) = (unsigned char *)(md->mark);    *(extra_data->mark) = (unsigned char *)(md->nomatch_mark);
6667  return rc;  return rc;
6668  }  }
6669    

Legend:
Removed from v.751  
changed lines
  Added in v.771

  ViewVC Help
Powered by ViewVC 1.1.5