/[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 501 by ph10, Sun Mar 7 11:49:54 2010 UTC revision 510 by ph10, Sat Mar 27 17:45:29 2010 UTC
# Line 74  negative to avoid the external error cod Line 74  negative to avoid the external error cod
74  #define MATCH_COMMIT       (-999)  #define MATCH_COMMIT       (-999)
75  #define MATCH_PRUNE        (-998)  #define MATCH_PRUNE        (-998)
76  #define MATCH_SKIP         (-997)  #define MATCH_SKIP         (-997)
77  #define MATCH_THEN         (-996)  #define MATCH_SKIP_ARG     (-996)
78    #define MATCH_THEN         (-995)
79    
80    /* This is a convenience macro for code that occurs many times. */
81    
82    #define MRRETURN(ra) \
83      { \
84      md->mark = markptr; \
85      RRETURN(ra); \
86      }
87    
88  /* 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.
89  If the offset vector is bigger, malloc is used. This should be a multiple of 3,  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
# Line 413  the subject. */ Line 422  the subject. */
422    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
423      {\      {\
424      md->hitend = TRUE;\      md->hitend = TRUE;\
425      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
426      }      }
427    
428  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
429    if (md->partial != 0 && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
430      {\      {\
431      md->hitend = TRUE;\      md->hitend = TRUE;\
432      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
433      }      }
434    
435    
# Line 448  Arguments: Line 457  Arguments:
457    
458  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
459                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
460                   a negative MATCH_xxx value for PRUNE, SKIP, etc
461                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
462                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
463  */  */
464    
465  static int  static int
466  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart, USPTR  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
467    markptr, int offset_top, match_data *md, unsigned long int ims,    const uschar *markptr, int offset_top, match_data *md, unsigned long int ims,
468    eptrblock *eptrb, int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
469  {  {
470  /* 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,
# Line 671  for (;;) Line 681  for (;;)
681    
682    switch(op)    switch(op)
683      {      {
684        case OP_MARK:
685        markptr = ecode + 2;
686        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
687          ims, eptrb, flags, RM51);
688    
689        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
690        argument, and we must check whether that argument matches this MARK's
691        argument. It is passed back in md->start_match_ptr (an overloading of that
692        variable). If it does match, we reset that variable to the current subject
693        position and return MATCH_SKIP. Otherwise, pass back the return code
694        unaltered. */
695    
696        if (rrc == MATCH_SKIP_ARG &&
697            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
698          {
699          md->start_match_ptr = eptr;
700          RRETURN(MATCH_SKIP);
701          }
702    
703        if (md->mark == NULL) md->mark = markptr;
704        RRETURN(rrc);
705    
706      case OP_FAIL:      case OP_FAIL:
707      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
708    
709        case OP_COMMIT:
710        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
711          ims, eptrb, flags, RM52);
712        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
713        MRRETURN(MATCH_COMMIT);
714    
715      case OP_PRUNE:      case OP_PRUNE:
716      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
717        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
718      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
719      RRETURN(MATCH_PRUNE);      MRRETURN(MATCH_PRUNE);
720    
721      case OP_COMMIT:      case OP_PRUNE_ARG:
722      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
723        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM51);
724      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
725      RRETURN(MATCH_COMMIT);      md->mark = ecode + 2;
726        RRETURN(MATCH_PRUNE);
727    
728      case OP_SKIP:      case OP_SKIP:
729      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
730        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
731      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
732      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
733      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
734    
735        case OP_SKIP_ARG:
736        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
737          ims, eptrb, flags, RM53);
738        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
739    
740        /* Pass back the current skip name by overloading md->start_match_ptr and
741        returning the special MATCH_SKIP_ARG return code. This will either be
742        caught by a matching MARK, or get to the top, where it is treated the same
743        as PRUNE. */
744    
745        md->start_match_ptr = ecode + 2;
746        RRETURN(MATCH_SKIP_ARG);
747    
748      case OP_THEN:      case OP_THEN:
749      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
750        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
751      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
752        MRRETURN(MATCH_THEN);
753    
754        case OP_THEN_ARG:
755        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
756          ims, eptrb, flags, RM54);
757        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
758        md->mark = ecode + 2;
759      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
760    
761      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
# Line 752  for (;;) Line 811  for (;;)
811        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
812        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
813    
814          if (rrc != MATCH_THEN) md->mark = markptr;
815        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
816        }        }
817    
# Line 791  for (;;) Line 851  for (;;)
851    
852          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
853            eptrb, flags, RM48);            eptrb, flags, RM48);
854          RRETURN(rrc);          if (rrc == MATCH_NOMATCH) md->mark = markptr;
855            RRETURN(rrc);
856          }          }
857    
858        /* For non-final alternatives, continue the loop for a NOMATCH result;        /* For non-final alternatives, continue the loop for a NOMATCH result;
# Line 834  for (;;) Line 895  for (;;)
895          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
896          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
897          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
898          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
899          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
900          }          }
901        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 1089  for (;;) Line 1150  for (;;)
1150          (md->notempty ||          (md->notempty ||
1151            (md->notempty_atstart &&            (md->notempty_atstart &&
1152              mstart == md->start_subject + md->start_offset)))              mstart == md->start_subject + md->start_offset)))
1153        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1154    
1155      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1156    
1157      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1158      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1159      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1160      RRETURN(MATCH_MATCH);      MRRETURN(MATCH_MATCH);
1161    
1162      /* Change option settings */      /* Change option settings */
1163    
# Line 1127  for (;;) Line 1188  for (;;)
1188        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1189        }        }
1190      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1191      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1192    
1193      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1194    
# Line 1151  for (;;) Line 1212  for (;;)
1212        {        {
1213        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1214          RM5);          RM5);
1215        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) MRRETURN(MATCH_NOMATCH);
1216        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1217          {          {
1218          do ecode += GET(ecode,1); while (*ecode == OP_ALT);          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
# Line 1180  for (;;) Line 1241  for (;;)
1241        while (i-- > 0)        while (i-- > 0)
1242          {          {
1243          eptr--;          eptr--;
1244          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1245          BACKCHAR(eptr);          BACKCHAR(eptr);
1246          }          }
1247        }        }
# Line 1191  for (;;) Line 1252  for (;;)
1252    
1253        {        {
1254        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1255        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1256        }        }
1257    
1258      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1220  for (;;) Line 1281  for (;;)
1281        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1282        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1283        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1284        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1285        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1286        }        }
1287      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1292  for (;;) Line 1353  for (;;)
1353            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1354            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1355              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1356            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1357            }            }
1358          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1359            {            {
# Line 1313  for (;;) Line 1374  for (;;)
1374        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1375        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1376          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1377        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1378        }        }
1379      /* Control never reaches here */      /* Control never reaches here */
1380    
# Line 1467  for (;;) Line 1528  for (;;)
1528        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1529        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1530        md->start_match_ptr = mstart;        md->start_match_ptr = mstart;
1531        RRETURN(MATCH_MATCH);        MRRETURN(MATCH_MATCH);
1532        }        }
1533    
1534      /* 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 1562  for (;;) Line 1623  for (;;)
1623      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1624    
1625      case OP_CIRC:      case OP_CIRC:
1626      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1627      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1628        {        {
1629        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1630            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1631          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1632        ecode++;        ecode++;
1633        break;        break;
1634        }        }
# Line 1576  for (;;) Line 1637  for (;;)
1637      /* Start of subject assertion */      /* Start of subject assertion */
1638    
1639      case OP_SOD:      case OP_SOD:
1640      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1641      ecode++;      ecode++;
1642      break;      break;
1643    
1644      /* Start of match assertion */      /* Start of match assertion */
1645    
1646      case OP_SOM:      case OP_SOM:
1647      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1648      ecode++;      ecode++;
1649      break;      break;
1650    
# Line 1601  for (;;) Line 1662  for (;;)
1662      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1663        {        {
1664        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1665          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1666        else        else
1667          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
1668        ecode++;        ecode++;
1669        break;        break;
1670        }        }
1671      else      else
1672        {        {
1673        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1674        if (!md->endonly)        if (!md->endonly)
1675          {          {
1676          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1677              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1678            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
1679          ecode++;          ecode++;
1680          break;          break;
1681          }          }
# Line 1624  for (;;) Line 1685  for (;;)
1685      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1686    
1687      case OP_EOD:      case OP_EOD:
1688      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1689      ecode++;      ecode++;
1690      break;      break;
1691    
# Line 1633  for (;;) Line 1694  for (;;)
1694      case OP_EODN:      case OP_EODN:
1695      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1696          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1697        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1698      ecode++;      ecode++;
1699      break;      break;
1700    
# Line 1693  for (;;) Line 1754  for (;;)
1754    
1755        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1756             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1757          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1758        }        }
1759      break;      break;
1760    
1761      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1762    
1763      case OP_ANY:      case OP_ANY:
1764      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1765      /* Fall through */      /* Fall through */
1766    
1767      case OP_ALLANY:      case OP_ALLANY:
1768      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1769        {        {
1770        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1771        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1772        }        }
1773      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1774      ecode++;      ecode++;
# Line 1720  for (;;) Line 1781  for (;;)
1781      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1782        {        {
1783        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1784        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1785        }        }
1786      ecode++;      ecode++;
1787      break;      break;
# Line 1729  for (;;) Line 1790  for (;;)
1790      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1791        {        {
1792        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1793        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1794        }        }
1795      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1796      if (      if (
# Line 1738  for (;;) Line 1799  for (;;)
1799  #endif  #endif
1800         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1801         )         )
1802        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1803      ecode++;      ecode++;
1804      break;      break;
1805    
# Line 1746  for (;;) Line 1807  for (;;)
1807      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1808        {        {
1809        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1810        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1811        }        }
1812      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1813      if (      if (
# Line 1755  for (;;) Line 1816  for (;;)
1816  #endif  #endif
1817         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1818         )         )
1819        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1820      ecode++;      ecode++;
1821      break;      break;
1822    
# Line 1763  for (;;) Line 1824  for (;;)
1824      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1825        {        {
1826        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1827        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1828        }        }
1829      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1830      if (      if (
# Line 1772  for (;;) Line 1833  for (;;)
1833  #endif  #endif
1834         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1835         )         )
1836        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1837      ecode++;      ecode++;
1838      break;      break;
1839    
# Line 1780  for (;;) Line 1841  for (;;)
1841      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1842        {        {
1843        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1844        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1845        }        }
1846      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1847      if (      if (
# Line 1789  for (;;) Line 1850  for (;;)
1850  #endif  #endif
1851         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1852         )         )
1853        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1854      ecode++;      ecode++;
1855      break;      break;
1856    
# Line 1797  for (;;) Line 1858  for (;;)
1858      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1859        {        {
1860        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1861        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1862        }        }
1863      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1864      if (      if (
# Line 1806  for (;;) Line 1867  for (;;)
1867  #endif  #endif
1868         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1869         )         )
1870        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1871      ecode++;      ecode++;
1872      break;      break;
1873    
# Line 1814  for (;;) Line 1875  for (;;)
1875      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1876        {        {
1877        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1878        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1879        }        }
1880      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1881      if (      if (
# Line 1823  for (;;) Line 1884  for (;;)
1884  #endif  #endif
1885         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1886         )         )
1887        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1888      ecode++;      ecode++;
1889      break;      break;
1890    
# Line 1831  for (;;) Line 1892  for (;;)
1892      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1893        {        {
1894        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1895        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1896        }        }
1897      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1898      switch(c)      switch(c)
1899        {        {
1900        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1901        case 0x000d:        case 0x000d:
1902        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1903        break;        break;
# Line 1849  for (;;) Line 1910  for (;;)
1910        case 0x0085:        case 0x0085:
1911        case 0x2028:        case 0x2028:
1912        case 0x2029:        case 0x2029:
1913        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
1914        break;        break;
1915        }        }
1916      ecode++;      ecode++;
# Line 1859  for (;;) Line 1920  for (;;)
1920      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1921        {        {
1922        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1923        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1924        }        }
1925      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1926      switch(c)      switch(c)
# Line 1884  for (;;) Line 1945  for (;;)
1945        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
1946        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1947        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
1948        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1949        }        }
1950      ecode++;      ecode++;
1951      break;      break;
# Line 1893  for (;;) Line 1954  for (;;)
1954      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1955        {        {
1956        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1957        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1958        }        }
1959      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1960      switch(c)      switch(c)
1961        {        {
1962        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1963        case 0x09:      /* HT */        case 0x09:      /* HT */
1964        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
1965        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1927  for (;;) Line 1988  for (;;)
1988      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1989        {        {
1990        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1991        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1992        }        }
1993      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1994      switch(c)      switch(c)
# Line 1940  for (;;) Line 2001  for (;;)
2001        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2002        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2003        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2004        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2005        }        }
2006      ecode++;      ecode++;
2007      break;      break;
# Line 1949  for (;;) Line 2010  for (;;)
2010      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2011        {        {
2012        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2013        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2014        }        }
2015      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2016      switch(c)      switch(c)
2017        {        {
2018        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2019        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2020        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2021        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1976  for (;;) Line 2037  for (;;)
2037      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2038        {        {
2039        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2040        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2041        }        }
2042      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2043        {        {
# Line 1985  for (;;) Line 2046  for (;;)
2046        switch(ecode[1])        switch(ecode[1])
2047          {          {
2048          case PT_ANY:          case PT_ANY:
2049          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2050          break;          break;
2051    
2052          case PT_LAMP:          case PT_LAMP:
2053          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2054               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2055               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2056            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2057           break;           break;
2058    
2059          case PT_GC:          case PT_GC:
2060          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2061            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2062          break;          break;
2063    
2064          case PT_PC:          case PT_PC:
2065          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2066            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2067          break;          break;
2068    
2069          case PT_SC:          case PT_SC:
2070          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2071            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2072          break;          break;
2073    
2074          default:          default:
# Line 2025  for (;;) Line 2086  for (;;)
2086      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2087        {        {
2088        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2089        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2090        }        }
2091      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2092        {        {
2093        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2094        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2095        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2096          {          {
2097          int len = 1;          int len = 1;
# Line 2109  for (;;) Line 2170  for (;;)
2170          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2171            {            {
2172            CHECK_PARTIAL();            CHECK_PARTIAL();
2173            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2174            }            }
2175          eptr += length;          eptr += length;
2176          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 2129  for (;;) Line 2190  for (;;)
2190          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2191            {            {
2192            CHECK_PARTIAL();            CHECK_PARTIAL();
2193            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2194            }            }
2195          eptr += length;          eptr += length;
2196          }          }
# Line 2147  for (;;) Line 2208  for (;;)
2208            {            {
2209            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2210            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2211            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2212            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2213              {              {
2214              CHECK_PARTIAL();              CHECK_PARTIAL();
2215              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2216              }              }
2217            eptr += length;            eptr += length;
2218            }            }
# Line 2178  for (;;) Line 2239  for (;;)
2239            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2240            eptr -= length;            eptr -= length;
2241            }            }
2242          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2243          }          }
2244        }        }
2245      /* Control never gets here */      /* Control never gets here */
# Line 2240  for (;;) Line 2301  for (;;)
2301            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2302              {              {
2303              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2304              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2305              }              }
2306            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2307            if (c > 255)            if (c > 255)
2308              {              {
2309              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2310              }              }
2311            else            else
2312              {              {
2313              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2314              }              }
2315            }            }
2316          }          }
# Line 2262  for (;;) Line 2323  for (;;)
2323            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2324              {              {
2325              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2326              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2327              }              }
2328            c = *eptr++;            c = *eptr++;
2329            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2330            }            }
2331          }          }
2332    
# Line 2287  for (;;) Line 2348  for (;;)
2348              {              {
2349              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2350              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2351              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2352              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2353                {                {
2354                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2355                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2356                }                }
2357              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2358              if (c > 255)              if (c > 255)
2359                {                {
2360                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2361                }                }
2362              else              else
2363                {                {
2364                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2365                }                }
2366              }              }
2367            }            }
# Line 2312  for (;;) Line 2373  for (;;)
2373              {              {
2374              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2375              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2376              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2377              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2378                {                {
2379                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2380                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2381                }                }
2382              c = *eptr++;              c = *eptr++;
2383              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2384              }              }
2385            }            }
2386          /* Control never gets here */          /* Control never gets here */
# Line 2385  for (;;) Line 2446  for (;;)
2446              }              }
2447            }            }
2448    
2449          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2450          }          }
2451        }        }
2452      /* Control never gets here */      /* Control never gets here */
# Line 2437  for (;;) Line 2498  for (;;)
2498          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2499            {            {
2500            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2501            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2502            }            }
2503          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2504          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2505          }          }
2506    
2507        /* 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 2457  for (;;) Line 2518  for (;;)
2518            {            {
2519            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2520            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2521            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2522            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2523              {              {
2524              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2525              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2526              }              }
2527            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2528            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2529            }            }
2530          /* Control never gets here */          /* Control never gets here */
2531          }          }
# Line 2493  for (;;) Line 2554  for (;;)
2554            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2555            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2556            }            }
2557          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2558          }          }
2559    
2560        /* Control never gets here */        /* Control never gets here */
# Line 2512  for (;;) Line 2573  for (;;)
2573        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2574          {          {
2575          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2576          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2577          }          }
2578        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2579        }        }
2580      else      else
2581  #endif  #endif
# Line 2524  for (;;) Line 2585  for (;;)
2585        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2586          {          {
2587          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2588          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2589          }          }
2590        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2591        ecode += 2;        ecode += 2;
2592        }        }
2593      break;      break;
# Line 2544  for (;;) Line 2605  for (;;)
2605        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2606          {          {
2607          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2608          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2609          }          }
2610    
2611        /* 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 2552  for (;;) Line 2613  for (;;)
2613    
2614        if (fc < 128)        if (fc < 128)
2615          {          {
2616          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2617          }          }
2618    
2619        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2571  for (;;) Line 2632  for (;;)
2632  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2633            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2634  #endif  #endif
2635              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2636            }            }
2637          }          }
2638        }        }
# Line 2583  for (;;) Line 2644  for (;;)
2644        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2645          {          {
2646          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2647          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2648          }          }
2649        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2650        ecode += 2;        ecode += 2;
2651        }        }
2652      break;      break;
# Line 2679  for (;;) Line 2740  for (;;)
2740            else            else
2741              {              {
2742              CHECK_PARTIAL();              CHECK_PARTIAL();
2743              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2744              }              }
2745            }            }
2746    
# Line 2691  for (;;) Line 2752  for (;;)
2752              {              {
2753              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2754              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2755              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2756              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2757                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2758  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2702  for (;;) Line 2763  for (;;)
2763              else              else
2764                {                {
2765                CHECK_PARTIAL();                CHECK_PARTIAL();
2766                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2767                }                }
2768              }              }
2769            /* Control never gets here */            /* Control never gets here */
# Line 2733  for (;;) Line 2794  for (;;)
2794              {              {
2795              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2796              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2797              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2798  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2799              eptr--;              eptr--;
2800              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2776  for (;;) Line 2837  for (;;)
2837          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2838            {            {
2839            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2840            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2841            }            }
2842          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2843          }          }
2844        if (min == max) continue;        if (min == max) continue;
2845        if (minimize)        if (minimize)
# Line 2787  for (;;) Line 2848  for (;;)
2848            {            {
2849            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2850            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2851            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2852            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2853              {              {
2854              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2855              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2856              }              }
2857            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2858            }            }
2859          /* Control never gets here */          /* Control never gets here */
2860          }          }
# Line 2819  for (;;) Line 2880  for (;;)
2880            eptr--;            eptr--;
2881            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2882            }            }
2883          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2884          }          }
2885        /* Control never gets here */        /* Control never gets here */
2886        }        }
# Line 2833  for (;;) Line 2894  for (;;)
2894          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2895            {            {
2896            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2897            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2898            }            }
2899          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2900          }          }
2901    
2902        if (min == max) continue;        if (min == max) continue;
# Line 2846  for (;;) Line 2907  for (;;)
2907            {            {
2908            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2909            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2910            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2911            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2912              {              {
2913              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2914              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2915              }              }
2916            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2917            }            }
2918          /* Control never gets here */          /* Control never gets here */
2919          }          }
# Line 2877  for (;;) Line 2938  for (;;)
2938            eptr--;            eptr--;
2939            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2940            }            }
2941          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2942          }          }
2943        }        }
2944      /* Control never gets here */      /* Control never gets here */
# Line 2889  for (;;) Line 2950  for (;;)
2950      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2951        {        {
2952        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2953        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2954        }        }
2955      ecode++;      ecode++;
2956      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2899  for (;;) Line 2960  for (;;)
2960        if (c < 256)        if (c < 256)
2961  #endif  #endif
2962        c = md->lcc[c];        c = md->lcc[c];
2963        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
2964        }        }
2965      else      else
2966        {        {
2967        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
2968        }        }
2969      break;      break;
2970    
# Line 2997  for (;;) Line 3058  for (;;)
3058            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3059              {              {
3060              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3061              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3062              }              }
3063            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3064            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3065            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3066            }            }
3067          }          }
3068        else        else
# Line 3014  for (;;) Line 3075  for (;;)
3075            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3076              {              {
3077              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3078              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3079              }              }
3080            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3081            }            }
3082          }          }
3083    
# Line 3033  for (;;) Line 3094  for (;;)
3094              {              {
3095              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3096              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3097              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3098              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3099                {                {
3100                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3101                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3102                }                }
3103              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3104              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3105              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3106              }              }
3107            }            }
3108          else          else
# Line 3052  for (;;) Line 3113  for (;;)
3113              {              {
3114              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3115              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3116              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3117              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3118                {                {
3119                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3120                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3121                }                }
3122              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3123              }              }
3124            }            }
3125          /* Control never gets here */          /* Control never gets here */
# Line 3120  for (;;) Line 3181  for (;;)
3181              }              }
3182            }            }
3183    
3184          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3185          }          }
3186        /* Control never gets here */        /* Control never gets here */
3187        }        }
# Line 3139  for (;;) Line 3200  for (;;)
3200            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3201              {              {
3202              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3203              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3204              }              }
3205            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3206            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3207            }            }
3208          }          }
3209        else        else
# Line 3154  for (;;) Line 3215  for (;;)
3215            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3216              {              {
3217              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3218              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3219              }              }
3220            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3221            }            }
3222          }          }
3223    
# Line 3173  for (;;) Line 3234  for (;;)
3234              {              {
3235              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3236              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3237              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3238              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3239                {                {
3240                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3241                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3242                }                }
3243              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3244              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3245              }              }
3246            }            }
3247          else          else
# Line 3191  for (;;) Line 3252  for (;;)
3252              {              {
3253              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3254              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3255              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3256              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3257                {                {
3258                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3259                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3260                }                }
3261              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3262              }              }
3263            }            }
3264          /* Control never gets here */          /* Control never gets here */
# Line 3258  for (;;) Line 3319  for (;;)
3319              }              }
3320            }            }
3321    
3322          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3323          }          }
3324        }        }
3325      /* Control never gets here */      /* Control never gets here */
# Line 3352  for (;;) Line 3413  for (;;)
3413          switch(prop_type)          switch(prop_type)
3414            {            {
3415            case PT_ANY:            case PT_ANY:
3416            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3417            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3418              {              {
3419              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3420                {                {
3421                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3422                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3423                }                }
3424              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3425              }              }
# Line 3370  for (;;) Line 3431  for (;;)
3431              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3432                {                {
3433                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3434                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3435                }                }
3436              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3437              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3438              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3439                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3440                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3441                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3442              }              }
3443            break;            break;
3444    
# Line 3387  for (;;) Line 3448  for (;;)
3448              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3449                {                {
3450                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3451                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3452                }                }
3453              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3454              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3455              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3456                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3457              }              }
3458            break;            break;
3459    
# Line 3402  for (;;) Line 3463  for (;;)
3463              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3464                {                {
3465                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3466                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3467                }                }
3468              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3469              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3470              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3471                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3472              }              }
3473            break;            break;
3474    
# Line 3417  for (;;) Line 3478  for (;;)
3478              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3479                {                {
3480                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3481                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3482                }                }
3483              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3484              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3485              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3486                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3487              }              }
3488            break;            break;
3489    
# Line 3441  for (;;) Line 3502  for (;;)
3502            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3503              {              {
3504              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3505              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3506              }              }
3507            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3508            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3509            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3510            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3511              {              {
3512              int len = 1;              int len = 1;
# Line 3472  for (;;) Line 3533  for (;;)
3533            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3534              {              {
3535              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3536              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3537              }              }
3538            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3539            eptr++;            eptr++;
3540            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3541            }            }
# Line 3486  for (;;) Line 3547  for (;;)
3547            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3548              {              {
3549              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3550              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3551              }              }
3552            eptr++;            eptr++;
3553            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3494  for (;;) Line 3555  for (;;)
3555          break;          break;
3556    
3557          case OP_ANYBYTE:          case OP_ANYBYTE:
3558          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3559          eptr += min;          eptr += min;
3560          break;          break;
3561    
# Line 3504  for (;;) Line 3565  for (;;)
3565            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3566              {              {
3567              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3568              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3569              }              }
3570            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3571            switch(c)            switch(c)
3572              {              {
3573              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3574              case 0x000d:              case 0x000d:
3575              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3576              break;              break;
# Line 3522  for (;;) Line 3583  for (;;)
3583              case 0x0085:              case 0x0085:
3584              case 0x2028:              case 0x2028:
3585              case 0x2029:              case 0x2029:
3586              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3587              break;              break;
3588              }              }
3589            }            }
# Line 3534  for (;;) Line 3595  for (;;)
3595            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3596              {              {
3597              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3598              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3599              }              }
3600            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3601            switch(c)            switch(c)
# Line 3559  for (;;) Line 3620  for (;;)
3620              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3621              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3622              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3623              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3624              }              }
3625            }            }
3626          break;          break;
# Line 3570  for (;;) Line 3631  for (;;)
3631            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3632              {              {
3633              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3634              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3635              }              }
3636            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3637            switch(c)            switch(c)
3638              {              {
3639              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3640              case 0x09:      /* HT */              case 0x09:      /* HT */
3641              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3642              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3606  for (;;) Line 3667  for (;;)
3667            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3668              {              {
3669              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3670              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3671              }              }
3672            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3673            switch(c)            switch(c)
# Line 3619  for (;;) Line 3680  for (;;)
3680              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3681              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3682              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3683              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3684              }              }
3685            }            }
3686          break;          break;
# Line 3630  for (;;) Line 3691  for (;;)
3691            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3692              {              {
3693              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3694              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3695              }              }
3696            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3697            switch(c)            switch(c)
3698              {              {
3699              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3700              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3701              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3702              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3654  for (;;) Line 3715  for (;;)
3715            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3716              {              {
3717              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3718              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3719              }              }
3720            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3721            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3722              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3723            }            }
3724          break;          break;
3725    
# Line 3668  for (;;) Line 3729  for (;;)
3729            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3730              {              {
3731              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3732              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3733              }              }
3734            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3735              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3736            /* 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 */
3737            }            }
3738          break;          break;
# Line 3682  for (;;) Line 3743  for (;;)
3743            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3744              {              {
3745              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3746              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3747              }              }
3748            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3749              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3750            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3751            }            }
3752          break;          break;
# Line 3696  for (;;) Line 3757  for (;;)
3757            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3758              {              {
3759              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3760              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3761              }              }
3762            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3763              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3764            /* 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 */
3765            }            }
3766          break;          break;
# Line 3710  for (;;) Line 3771  for (;;)
3771            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3772              {              {
3773              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3774              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3775              }              }
3776            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3777              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3778            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3779            }            }
3780          break;          break;
# Line 3724  for (;;) Line 3785  for (;;)
3785            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3786              {              {
3787              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3788              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3789              }              }
3790            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3791              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3792            /* 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 */
3793            }            }
3794          break;          break;
# Line 3750  for (;;) Line 3811  for (;;)
3811            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3812              {              {
3813              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3814              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3815              }              }
3816            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3817            eptr++;            eptr++;
3818            }            }
3819          break;          break;
# Line 3761  for (;;) Line 3822  for (;;)
3822          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3823            {            {
3824            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3825            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3826            }            }
3827          eptr += min;          eptr += min;
3828          break;          break;
# Line 3770  for (;;) Line 3831  for (;;)
3831          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3832            {            {
3833            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3834            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3835            }            }
3836          eptr += min;          eptr += min;
3837          break;          break;
# Line 3781  for (;;) Line 3842  for (;;)
3842            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3843              {              {
3844              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3845              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3846              }              }
3847            switch(*eptr++)            switch(*eptr++)
3848              {              {
3849              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3850              case 0x000d:              case 0x000d:
3851              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3852              break;              break;
# Line 3795  for (;;) Line 3856  for (;;)
3856              case 0x000b:              case 0x000b:
3857              case 0x000c:              case 0x000c:
3858              case 0x0085:              case 0x0085:
3859              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3860              break;              break;
3861              }              }
3862            }            }
# Line 3807  for (;;) Line 3868  for (;;)
3868            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3869              {              {
3870              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3871              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3872              }              }
3873            switch(*eptr++)            switch(*eptr++)
3874              {              {
# Line 3815  for (;;) Line 3876  for (;;)
3876              case 0x09:      /* HT */              case 0x09:      /* HT */
3877              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3878              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
3879              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3880              }              }
3881            }            }
3882          break;          break;
# Line 3826  for (;;) Line 3887  for (;;)
3887            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3888              {              {
3889              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3890              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3891              }              }
3892            switch(*eptr++)            switch(*eptr++)
3893              {              {
3894              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3895              case 0x09:      /* HT */              case 0x09:      /* HT */
3896              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3897              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3845  for (;;) Line 3906  for (;;)
3906            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3907              {              {
3908              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3909              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3910              }              }
3911            switch(*eptr++)            switch(*eptr++)
3912              {              {
# Line 3855  for (;;) Line 3916  for (;;)
3916              case 0x0c:      /* FF */              case 0x0c:      /* FF */
3917              case 0x0d:      /* CR */              case 0x0d:      /* CR */
3918              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3919              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3920              }              }
3921            }            }
3922          break;          break;
# Line 3866  for (;;) Line 3927  for (;;)
3927            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3928              {              {
3929              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3930              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3931              }              }
3932            switch(*eptr++)            switch(*eptr++)
3933              {              {
3934              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3935              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3936              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3937              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3887  for (;;) Line 3948  for (;;)
3948            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3949              {              {
3950              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3951              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3952              }              }
3953            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
3954            }            }
3955          break;          break;
3956    
# Line 3899  for (;;) Line 3960  for (;;)
3960            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3961              {              {
3962              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3963              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3964              }              }
3965            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
3966            }            }
3967          break;          break;
3968    
# Line 3911  for (;;) Line 3972  for (;;)
3972            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3973              {              {
3974              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3975              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3976              }              }
3977            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
3978            }            }
3979          break;          break;
3980    
# Line 3923  for (;;) Line 3984  for (;;)
3984            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3985              {              {
3986              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3987              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3988              }              }
3989            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
3990            }            }
3991          break;          break;
3992    
# Line 3935  for (;;) Line 3996  for (;;)
3996            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3997              {              {
3998              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3999              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4000              }              }
4001            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4002              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4003            }            }
4004          break;          break;
4005    
# Line 3948  for (;;) Line 4009  for (;;)
4009            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4010              {              {
4011              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4012              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4013              }              }
4014            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4015              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4016            }            }
4017          break;          break;
4018    
# Line 3980  for (;;) Line 4041  for (;;)
4041              {              {
4042              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4043              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4044              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4045              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4046                {                {
4047                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4048                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4049                }                }
4050              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4051              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4052              }              }
4053            /* Control never gets here */            /* Control never gets here */
4054    
# Line 3996  for (;;) Line 4057  for (;;)
4057              {              {
4058              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4059              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4060              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4061              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4062                {                {
4063                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4064                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4065                }                }
4066              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4067              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4068              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4069                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4070                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4071                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4072              }              }
4073            /* Control never gets here */            /* Control never gets here */
4074    
# Line 4016  for (;;) Line 4077  for (;;)
4077              {              {
4078              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4079              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4080              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4081              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4082                {                {
4083                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4084                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4085                }                }
4086              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4087              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4088              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4089                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4090              }              }
4091            /* Control never gets here */            /* Control never gets here */
4092    
# Line 4034  for (;;) Line 4095  for (;;)
4095              {              {
4096              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4097              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4098              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4099              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4100                {                {
4101                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4102                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4103                }                }
4104              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4105              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4106              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4107                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4108              }              }
4109            /* Control never gets here */            /* Control never gets here */
4110    
# Line 4052  for (;;) Line 4113  for (;;)
4113              {              {
4114              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4115              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4116              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4117              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4118                {                {
4119                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4120                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4121                }                }
4122              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4123              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4124              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4125                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4126              }              }
4127            /* Control never gets here */            /* Control never gets here */
4128    
# Line 4079  for (;;) Line 4140  for (;;)
4140            {            {
4141            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4142            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4143            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4144            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4145              {              {
4146              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4147              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4148              }              }
4149            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4150            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4151            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4152            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4153              {              {
4154              int len = 1;              int len = 1;
# Line 4111  for (;;) Line 4172  for (;;)
4172            {            {
4173            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4174            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4175            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4176            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4177              {              {
4178              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4179              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4180              }              }
4181            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4182              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4183            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4184            switch(ctype)            switch(ctype)
4185              {              {
# Line 4130  for (;;) Line 4191  for (;;)
4191              case OP_ANYNL:              case OP_ANYNL:
4192              switch(c)              switch(c)
4193                {                {
4194                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4195                case 0x000d:                case 0x000d:
4196                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4197                break;                break;
# Line 4142  for (;;) Line 4203  for (;;)
4203                case 0x0085:                case 0x0085:
4204                case 0x2028:                case 0x2028:
4205                case 0x2029:                case 0x2029:
4206                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4207                break;                break;
4208                }                }
4209              break;              break;
# Line 4170  for (;;) Line 4231  for (;;)
4231                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4232                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4233                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4234                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4235                }                }
4236              break;              break;
4237    
4238              case OP_HSPACE:              case OP_HSPACE:
4239              switch(c)              switch(c)
4240                {                {
4241                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4242                case 0x09:      /* HT */                case 0x09:      /* HT */
4243                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4244                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4212  for (;;) Line 4273  for (;;)
4273                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4274                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4275                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4276                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4277                }                }
4278              break;              break;
4279    
4280              case OP_VSPACE:              case OP_VSPACE:
4281              switch(c)              switch(c)
4282                {                {
4283                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4284                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4285                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4286                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4233  for (;;) Line 4294  for (;;)
4294    
4295              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4296              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4297                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4298              break;              break;
4299    
4300              case OP_DIGIT:              case OP_DIGIT:
4301              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4302                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4303              break;              break;
4304    
4305              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4306              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4307                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4308              break;              break;
4309    
4310              case OP_WHITESPACE:              case OP_WHITESPACE:
4311              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4312                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4313              break;              break;
4314    
4315              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4316              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4317                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4318              break;              break;
4319    
4320              case OP_WORDCHAR:              case OP_WORDCHAR:
4321              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4322                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4323              break;              break;
4324    
4325              default:              default:
# Line 4274  for (;;) Line 4335  for (;;)
4335            {            {
4336            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4337            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4338            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4339            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4340              {              {
4341              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4342              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4343              }              }
4344            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4345              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4346            c = *eptr++;            c = *eptr++;
4347            switch(ctype)            switch(ctype)
4348              {              {
# Line 4293  for (;;) Line 4354  for (;;)
4354              case OP_ANYNL:              case OP_ANYNL:
4355              switch(c)              switch(c)
4356                {                {
4357                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4358                case 0x000d:                case 0x000d:
4359                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4360                break;                break;
# Line 4304  for (;;) Line 4365  for (;;)
4365                case 0x000b:                case 0x000b:
4366                case 0x000c:                case 0x000c:
4367                case 0x0085:                case 0x0085:
4368                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4369                break;                break;
4370                }                }
4371              break;              break;
# Line 4316  for (;;) Line 4377  for (;;)
4377                case 0x09:      /* HT */                case 0x09:      /* HT */
4378                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4379                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4380                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4381                }                }
4382              break;              break;
4383    
4384              case OP_HSPACE:              case OP_HSPACE:
4385              switch(c)              switch(c)
4386                {                {
4387                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4388                case 0x09:      /* HT */                case 0x09:      /* HT */
4389                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4390                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4340  for (;;) Line 4401  for (;;)
4401                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4402                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4403                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4404                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4405                }                }
4406              break;              break;
4407    
4408              case OP_VSPACE:              case OP_VSPACE:
4409              switch(c)              switch(c)
4410                {                {
4411                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4412                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4413                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4414                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4358  for (;;) Line 4419  for (;;)
4419              break;              break;
4420    
4421              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4422              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4423              break;              break;
4424    
4425              case OP_DIGIT:              case OP_DIGIT:
4426              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4427              break;              break;
4428    
4429              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4430              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4431              break;              break;
4432    
4433              case OP_WHITESPACE:              case OP_WHITESPACE:
4434              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4435              break;              break;
4436    
4437              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4438              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4439              break;              break;
4440    
4441              case OP_WORDCHAR:              case OP_WORDCHAR:
4442              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4443              break;              break;
4444    
4445              default:              default:
# Line 5038  for (;;) Line 5099  for (;;)
5099    
5100        /* 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 */
5101    
5102        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5103        }        }
5104      /* Control never gets here */      /* Control never gets here */
5105    
# Line 5289  md->notempty_atstart = (options & PCRE_N Line 5350  md->notempty_atstart = (options & PCRE_N
5350  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5351                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5352  md->hitend = FALSE;  md->hitend = FALSE;
5353    md->mark = NULL;                        /* In case never set */
5354    
5355  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5356    
# Line 5659  for(;;) Line 5721  for(;;)
5721    
5722    /* OK, we can now run the match. If "hitend" is set afterwards, remember the    /* OK, we can now run the match. If "hitend" is set afterwards, remember the
5723    first starting point for which a partial match was found. */    first starting point for which a partial match was found. */
5724    
5725    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5726    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
5727    md->match_call_count = 0;    md->match_call_count = 0;
# Line 5669  for(;;) Line 5731  for(;;)
5731    
5732    switch(rc)    switch(rc)
5733      {      {
5734      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. If MATCH_SKIP_ARG reaches
5735      exactly like PRUNE. */      this level it means that a MARK that matched the SKIP's arg was not found.
5736        We treat this as NOMATCH. THEN at this level acts exactly like PRUNE. */
5737    
5738      case MATCH_NOMATCH:      case MATCH_NOMATCH:
5739      case MATCH_PRUNE:      case MATCH_PRUNE:
5740        case MATCH_SKIP_ARG:
5741      case MATCH_THEN:      case MATCH_THEN:
5742      new_start_match = start_match + 1;      new_start_match = start_match + 1;
5743  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 5734  for(;;) Line 5798  for(;;)
5798           md->nllen == 2))           md->nllen == 2))
5799      start_match++;      start_match++;
5800    
5801    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
5802      }                  /* End of for(;;) "bumpalong" loop */
5803    
5804  /* ==========================================================================*/  /* ==========================================================================*/
5805    
# Line 5789  if (rc == MATCH_MATCH) Line 5854  if (rc == MATCH_MATCH)
5854      }      }
5855    
5856    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
5857    return rc;    goto RETURN_MARK;
5858    }    }
5859    
5860  /* 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 5800  if (using_temporary_offsets) Line 5865  if (using_temporary_offsets)
5865    DPRINTF(("Freeing temporary memory\n"));    DPRINTF(("Freeing temporary memory\n"));
5866    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
5867    }    }
5868    
5869    /* For anything other than nomatch or partial match, just return the code. */
5870    
5871  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
5872    {    {
5873    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
5874    return rc;    return rc;
5875    }    }
5876  else if (start_partial != NULL)  
5877    /* Handle partial matches - disable any mark data */
5878    
5879    if (start_partial != NULL)
5880    {    {
5881    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
5882      md->mark = NULL;
5883    if (offsetcount > 1)    if (offsetcount > 1)
5884      {      {
5885      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = start_partial - (USPTR)subject;
5886      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = end_subject - (USPTR)subject;
5887      }      }
5888    return PCRE_ERROR_PARTIAL;    rc = PCRE_ERROR_PARTIAL;
5889    }    }
5890    
5891    /* This is the classic nomatch case */
5892    
5893  else  else
5894    {    {
5895    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));    DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
5896    return PCRE_ERROR_NOMATCH;    rc = PCRE_ERROR_NOMATCH;
5897    }    }
5898    
5899    /* Return the MARK data if it has been requested. */
5900    
5901    RETURN_MARK:
5902    
5903    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
5904      *(extra_data->mark) = (unsigned char *)(md->mark);
5905    return rc;
5906  }  }
5907    
5908  /* End of pcre_exec.c */  /* End of pcre_exec.c */

Legend:
Removed from v.501  
changed lines
  Added in v.510

  ViewVC Help
Powered by ViewVC 1.1.5