/[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 426 by ph10, Wed Aug 26 15:38:32 2009 UTC revision 447 by ph10, Tue Sep 15 18:17:54 2009 UTC
# Line 403  same response. */ Line 403  same response. */
403  /* These macros pack up tests that are used for partial matching, and which  /* These macros pack up tests that are used for partial matching, and which
404  appears several times in the code. We set the "hit end" flag if the pointer is  appears several times in the code. We set the "hit end" flag if the pointer is
405  at the end of the subject and also past the start of the subject (i.e.  at the end of the subject and also past the start of the subject (i.e.
406  something has been matched). The second one is used when we already know we are  something has been matched). For hard partial matching, we then return
407  past the end of the subject. */  immediately. The second one is used when we already know we are past the end of
408    the subject. */
409    
410  #define CHECK_PARTIAL()\  #define CHECK_PARTIAL()\
411    if (md->partial && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
412      md->hitend = TRUE      {\
413        md->hitend = TRUE;\
414        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
415        }
416    
417  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
418    if (md->partial && eptr > mstart) md->hitend = TRUE    if (md->partial && eptr > mstart)\
419        {\
420        md->hitend = TRUE;\
421        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
422        }
423    
424    
425  /* Performance note: It might be tempting to extract commonly used fields from  /* Performance note: It might be tempting to extract commonly used fields from
426  the md structure (e.g. utf8, end_subject) into individual variables to improve  the md structure (e.g. utf8, end_subject) into individual variables to improve
# Line 655  for (;;) Line 664  for (;;)
664    minimize = possessive = FALSE;    minimize = possessive = FALSE;
665    op = *ecode;    op = *ecode;
666    
   /* For partial matching, remember if we ever hit the end of the subject after  
   matching at least one subject character. This code is now wrapped in a macro  
   because it appears several times below. */  
   
   CHECK_PARTIAL();  
   
667    switch(op)    switch(op)
668      {      {
669      case OP_FAIL:      case OP_FAIL:
# Line 906  for (;;) Line 909  for (;;)
909        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
910        }        }
911      break;      break;
912    
913    
914        /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
915        to close any currently open capturing brackets. */
916    
917        case OP_CLOSE:
918        number = GET2(ecode, 1);
919        offset = number << 1;
920    
921    #ifdef DEBUG
922          printf("end bracket %d at *ACCEPT", number);
923          printf("\n");
924    #endif
925    
926        md->capture_last = number;
927        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
928          {
929          md->offset_vector[offset] =
930            md->offset_vector[md->offset_end - number];
931          md->offset_vector[offset+1] = eptr - md->start_subject;
932          if (offset_top <= offset) offset_top = offset + 2;
933          }
934        ecode += 3;
935        break;
936    
937    
938      /* End of the pattern, either real or forced. If we are in a top-level      /* End of the pattern, either real or forced. If we are in a top-level
# Line 921  for (;;) Line 948  for (;;)
948        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
949        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
950          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
951          offset_top = rec->offset_top;
952        mstart = rec->save_start;        mstart = rec->save_start;
953        ims = original_ims;        ims = original_ims;
954        ecode = rec->after_call;        ecode = rec->after_call;
955        break;        break;
956        }        }
957    
958      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty      /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
959      string - backtracking will then try other alternatives, if any. */      set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
960        the subject. In both cases, backtracking will then try other alternatives,
961        if any. */
962    
963        if (eptr == mstart &&
964            (md->notempty ||
965              (md->notempty_atstart &&
966                mstart == md->start_subject + md->start_offset)))
967          RRETURN(MATCH_NOMATCH);
968    
969        /* Otherwise, we have a match. */
970    
     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);  
971      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
972      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
973      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
# Line 1021  for (;;) Line 1058  for (;;)
1058        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1059        }        }
1060    
1061      /* Skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
1062    
1063        if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1064      ecode += 1 + LINK_SIZE;      ecode += 1 + LINK_SIZE;
1065      break;      break;
1066    
# Line 1102  for (;;) Line 1140  for (;;)
1140        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1141              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1142        new_recursive.save_start = mstart;        new_recursive.save_start = mstart;
1143          new_recursive.offset_top = offset_top;
1144        mstart = eptr;        mstart = eptr;
1145    
1146        /* OK, now we can do the recursion. For each top-level alternative we        /* OK, now we can do the recursion. For each top-level alternative we
# Line 1300  for (;;) Line 1339  for (;;)
1339        {        {
1340        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1341        offset = number << 1;        offset = number << 1;
1342    
1343  #ifdef DEBUG  #ifdef DEBUG
1344        printf("end bracket %d", number);        printf("end bracket %d", number);
1345        printf("\n");        printf("\n");
# Line 1326  for (;;) Line 1365  for (;;)
1365          mstart = rec->save_start;          mstart = rec->save_start;
1366          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1367            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1368            offset_top = rec->offset_top;
1369          ecode = rec->after_call;          ecode = rec->after_call;
1370          ims = original_ims;          ims = original_ims;
1371          break;          break;
# Line 1465  for (;;) Line 1505  for (;;)
1505    
1506        /* Find out if the previous and current characters are "word" characters.        /* Find out if the previous and current characters are "word" characters.
1507        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
1508        be "non-word" characters. */        be "non-word" characters. Remember the earliest consulted character for
1509          partial matching. */
1510    
1511  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1512        if (utf8)        if (utf8)
# Line 1474  for (;;) Line 1515  for (;;)
1515            {            {
1516            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1517            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1518              if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1519            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1520            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1521            }            }
1522          if (eptr >= md->end_subject) cur_is_word = FALSE; else          if (eptr >= md->end_subject)
1523              {
1524              SCHECK_PARTIAL();
1525              cur_is_word = FALSE;
1526              }
1527            else
1528            {            {
1529            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1530            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
# Line 1486  for (;;) Line 1533  for (;;)
1533        else        else
1534  #endif  #endif
1535    
1536        /* More streamlined when not in UTF-8 mode */        /* Not in UTF-8 mode */
1537    
1538          {          {
1539          prev_is_word = (eptr != md->start_subject) &&          if (eptr == md->start_subject) prev_is_word = FALSE; else
1540            ((md->ctypes[eptr[-1]] & ctype_word) != 0);            {
1541          cur_is_word = (eptr < md->end_subject) &&            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1542            ((md->ctypes[*eptr] & ctype_word) != 0);            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1543              }
1544            if (eptr >= md->end_subject)
1545              {
1546              SCHECK_PARTIAL();
1547              cur_is_word = FALSE;
1548              }
1549            else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1550          }          }
1551    
1552        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
# Line 1510  for (;;) Line 1564  for (;;)
1564      /* Fall through */      /* Fall through */
1565    
1566      case OP_ALLANY:      case OP_ALLANY:
1567      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject)
1568          {
1569          SCHECK_PARTIAL();
1570          RRETURN(MATCH_NOMATCH);
1571          }
1572      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1573      ecode++;      ecode++;
1574      break;      break;
# Line 1519  for (;;) Line 1577  for (;;)
1577      any byte, even newline, independent of the setting of PCRE_DOTALL. */      any byte, even newline, independent of the setting of PCRE_DOTALL. */
1578    
1579      case OP_ANYBYTE:      case OP_ANYBYTE:
1580      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject)
1581          {
1582          SCHECK_PARTIAL();
1583          RRETURN(MATCH_NOMATCH);
1584          }
1585      ecode++;      ecode++;
1586      break;      break;
1587    
1588      case OP_NOT_DIGIT:      case OP_NOT_DIGIT:
1589      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1590          {
1591          SCHECK_PARTIAL();
1592          RRETURN(MATCH_NOMATCH);
1593          }
1594      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1595      if (      if (
1596  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1537  for (;;) Line 1603  for (;;)
1603      break;      break;
1604    
1605      case OP_DIGIT:      case OP_DIGIT:
1606      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1607          {
1608          SCHECK_PARTIAL();
1609          RRETURN(MATCH_NOMATCH);
1610          }
1611      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1612      if (      if (
1613  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1550  for (;;) Line 1620  for (;;)
1620      break;      break;
1621    
1622      case OP_NOT_WHITESPACE:      case OP_NOT_WHITESPACE:
1623      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1624          {
1625          SCHECK_PARTIAL();
1626          RRETURN(MATCH_NOMATCH);
1627          }
1628      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1629      if (      if (
1630  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1563  for (;;) Line 1637  for (;;)
1637      break;      break;
1638    
1639      case OP_WHITESPACE:      case OP_WHITESPACE:
1640      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1641          {
1642          SCHECK_PARTIAL();
1643          RRETURN(MATCH_NOMATCH);
1644          }
1645      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1646      if (      if (
1647  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1576  for (;;) Line 1654  for (;;)
1654      break;      break;
1655    
1656      case OP_NOT_WORDCHAR:      case OP_NOT_WORDCHAR:
1657      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1658          {
1659          SCHECK_PARTIAL();
1660          RRETURN(MATCH_NOMATCH);
1661          }
1662      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1663      if (      if (
1664  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1589  for (;;) Line 1671  for (;;)
1671      break;      break;
1672    
1673      case OP_WORDCHAR:      case OP_WORDCHAR:
1674      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1675          {
1676          SCHECK_PARTIAL();
1677          RRETURN(MATCH_NOMATCH);
1678          }
1679      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1680      if (      if (
1681  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1602  for (;;) Line 1688  for (;;)
1688      break;      break;
1689    
1690      case OP_ANYNL:      case OP_ANYNL:
1691      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1692          {
1693          SCHECK_PARTIAL();
1694          RRETURN(MATCH_NOMATCH);
1695          }
1696      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1697      switch(c)      switch(c)
1698        {        {
# Line 1626  for (;;) Line 1716  for (;;)
1716      break;      break;
1717    
1718      case OP_NOT_HSPACE:      case OP_NOT_HSPACE:
1719      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1720          {
1721          SCHECK_PARTIAL();
1722          RRETURN(MATCH_NOMATCH);
1723          }
1724      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1725      switch(c)      switch(c)
1726        {        {
# Line 1656  for (;;) Line 1750  for (;;)
1750      break;      break;
1751    
1752      case OP_HSPACE:      case OP_HSPACE:
1753      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1754          {
1755          SCHECK_PARTIAL();
1756          RRETURN(MATCH_NOMATCH);
1757          }
1758      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1759      switch(c)      switch(c)
1760        {        {
# Line 1686  for (;;) Line 1784  for (;;)
1784      break;      break;
1785    
1786      case OP_NOT_VSPACE:      case OP_NOT_VSPACE:
1787      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1788          {
1789          SCHECK_PARTIAL();
1790          RRETURN(MATCH_NOMATCH);
1791          }
1792      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1793      switch(c)      switch(c)
1794        {        {
# Line 1704  for (;;) Line 1806  for (;;)
1806      break;      break;
1807    
1808      case OP_VSPACE:      case OP_VSPACE:
1809      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1810          {
1811          SCHECK_PARTIAL();
1812          RRETURN(MATCH_NOMATCH);
1813          }
1814      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1815      switch(c)      switch(c)
1816        {        {
# Line 1727  for (;;) Line 1833  for (;;)
1833    
1834      case OP_PROP:      case OP_PROP:
1835      case OP_NOTPROP:      case OP_NOTPROP:
1836      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1837          {
1838          SCHECK_PARTIAL();
1839          RRETURN(MATCH_NOMATCH);
1840          }
1841      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1842        {        {
1843        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
# Line 1772  for (;;) Line 1882  for (;;)
1882      is in the binary; otherwise a compile-time error occurs. */      is in the binary; otherwise a compile-time error occurs. */
1883    
1884      case OP_EXTUNI:      case OP_EXTUNI:
1885      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1886          {
1887          SCHECK_PARTIAL();
1888          RRETURN(MATCH_NOMATCH);
1889          }
1890      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1891        {        {
1892        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
# Line 1852  for (;;) Line 1966  for (;;)
1966          break;          break;
1967    
1968          default:               /* No repeat follows */          default:               /* No repeat follows */
1969          if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);          if (!match_ref(offset, eptr, length, md, ims))
1970              {
1971              CHECK_PARTIAL();
1972              RRETURN(MATCH_NOMATCH);
1973              }
1974          eptr += length;          eptr += length;
1975          continue;              /* With the main loop */          continue;              /* With the main loop */
1976          }          }
# Line 1868  for (;;) Line 1986  for (;;)
1986    
1987        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
1988          {          {
1989          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
1990            {            {
1991            CHECK_PARTIAL();            CHECK_PARTIAL();
1992            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1993            }            }
1994          eptr += length;          eptr += length;
1995          }          }
1996    
# Line 1889  for (;;) Line 2007  for (;;)
2007            {            {
2008            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2009            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2010            if (fi >= max || !match_ref(offset, eptr, length, md, ims))            if (fi >= max) RRETURN(MATCH_NOMATCH);
2011              if (!match_ref(offset, eptr, length, md, ims))
2012              {              {
2013              CHECK_PARTIAL();              CHECK_PARTIAL();
2014              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2015              }              }
2016            eptr += length;            eptr += length;
2017            }            }
2018          /* Control never gets here */          /* Control never gets here */
# Line 1909  for (;;) Line 2028  for (;;)
2028            if (!match_ref(offset, eptr, length, md, ims)) break;            if (!match_ref(offset, eptr, length, md, ims)) break;
2029            eptr += length;            eptr += length;
2030            }            }
         CHECK_PARTIAL();  
2031          while (eptr >= pp)          while (eptr >= pp)
2032            {            {
2033            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
# Line 1921  for (;;) Line 2039  for (;;)
2039        }        }
2040      /* Control never gets here */      /* Control never gets here */
2041    
   
   
2042      /* Match a bit-mapped character class, possibly repeatedly. This op code is      /* Match a bit-mapped character class, possibly repeatedly. This op code is
2043      used when all the characters in the class have values in the range 0-255,      used when all the characters in the class have values in the range 0-255,
2044      and either the matching is caseful, or the characters are in the range      and either the matching is caseful, or the characters are in the range
# Line 1977  for (;;) Line 2093  for (;;)
2093          {          {
2094          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2095            {            {
2096            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2097              {              {
2098              CHECK_PARTIAL();              SCHECK_PARTIAL();
2099              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2100              }              }
2101            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2102            if (c > 255)            if (c > 255)
2103              {              {
# Line 1999  for (;;) Line 2115  for (;;)
2115          {          {
2116          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2117            {            {
2118            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2119              {              {
2120              CHECK_PARTIAL();              SCHECK_PARTIAL();
2121              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2122              }              }
2123            c = *eptr++;            c = *eptr++;
2124            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2125            }            }
# Line 2027  for (;;) Line 2143  for (;;)
2143              {              {
2144              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2145              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2146              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
2147                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
2148                {                {
2149                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2150                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2151                }                }
2152              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2153              if (c > 255)              if (c > 255)
2154                {                {
# Line 2056  for (;;) Line 2168  for (;;)
2168              {              {
2169              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2170              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2171              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
2172                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
2173                {                {
2174                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2175                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2176                }                }
2177              c = *eptr++;              c = *eptr++;
2178              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2179              }              }
# Line 2098  for (;;) Line 2206  for (;;)
2206                }                }
2207              eptr += len;              eptr += len;
2208              }              }
           CHECK_PARTIAL();  
2209            for (;;)            for (;;)
2210              {              {
2211              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
# Line 2118  for (;;) Line 2225  for (;;)
2225              if ((data[c/8] & (1 << (c&7))) == 0) break;              if ((data[c/8] & (1 << (c&7))) == 0) break;
2226              eptr++;              eptr++;
2227              }              }
           CHECK_PARTIAL();  
2228            while (eptr >= pp)            while (eptr >= pp)
2229              {              {
2230              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
# Line 2176  for (;;) Line 2282  for (;;)
2282    
2283        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2284          {          {
2285          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2286            {            {
2287            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2288            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2289            }            }
2290          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2291          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2292          }          }
# Line 2199  for (;;) Line 2305  for (;;)
2305            {            {
2306            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2307            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2308            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
2309              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
2310              {              {
2311              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2312              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2313              }              }
2314            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2315            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2316            }            }
# Line 2228  for (;;) Line 2330  for (;;)
2330            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2331            eptr += len;            eptr += len;
2332            }            }
         CHECK_PARTIAL();  
2333          for(;;)          for(;;)
2334            {            {
2335            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
# Line 2252  for (;;) Line 2353  for (;;)
2353        length = 1;        length = 1;
2354        ecode++;        ecode++;
2355        GETCHARLEN(fc, ecode, length);        GETCHARLEN(fc, ecode, length);
2356        if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);        if (length > md->end_subject - eptr)
2357            {
2358            CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2359            RRETURN(MATCH_NOMATCH);
2360            }
2361        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
2362        }        }
2363      else      else
# Line 2260  for (;;) Line 2365  for (;;)
2365    
2366      /* Non-UTF-8 mode */      /* Non-UTF-8 mode */
2367        {        {
2368        if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);        if (md->end_subject - eptr < 1)
2369            {
2370            SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2371            RRETURN(MATCH_NOMATCH);
2372            }
2373        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
2374        ecode += 2;        ecode += 2;
2375        }        }
# Line 2276  for (;;) Line 2385  for (;;)
2385        ecode++;        ecode++;
2386        GETCHARLEN(fc, ecode, length);        GETCHARLEN(fc, ecode, length);
2387    
2388        if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);        if (length > md->end_subject - eptr)
2389            {
2390            CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2391            RRETURN(MATCH_NOMATCH);
2392            }
2393    
2394        /* 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
2395        can use the fast lookup table. */        can use the fast lookup table. */
# Line 2311  for (;;) Line 2424  for (;;)
2424    
2425      /* Non-UTF-8 mode */      /* Non-UTF-8 mode */
2426        {        {
2427        if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);        if (md->end_subject - eptr < 1)
2428            {
2429            SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2430            RRETURN(MATCH_NOMATCH);
2431            }
2432        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
2433        ecode += 2;        ecode += 2;
2434        }        }
# Line 2365  for (;;) Line 2482  for (;;)
2482      case OP_MINQUERY:      case OP_MINQUERY:
2483      c = *ecode++ - OP_STAR;      c = *ecode++ - OP_STAR;
2484      minimize = (c & 1) != 0;      minimize = (c & 1) != 0;
2485    
2486      min = rep_min[c];                 /* Pick up values from tables; */      min = rep_min[c];                 /* Pick up values from tables; */
2487      max = rep_max[c];                 /* zero for max => infinity */      max = rep_max[c];                 /* zero for max => infinity */
2488      if (max == 0) max = INT_MAX;      if (max == 0) max = INT_MAX;
# Line 2417  for (;;) Line 2535  for (;;)
2535              {              {
2536              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2537              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2538              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2539              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2540                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2541  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2453  for (;;) Line 2567  for (;;)
2567              else break;              else break;
2568              }              }
2569    
           CHECK_PARTIAL();  
2570            if (possessive) continue;            if (possessive) continue;
2571    
2572            for(;;)            for(;;)
2573              {              {
2574              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
# Line 2514  for (;;) Line 2627  for (;;)
2627            {            {
2628            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2629            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2630            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2631            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2632              {              {
2633              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2634              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2635              }              }
2636            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
# Line 2536  for (;;) Line 2645  for (;;)
2645            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
2646            eptr++;            eptr++;
2647            }            }
2648    
         CHECK_PARTIAL();  
2649          if (possessive) continue;          if (possessive) continue;
2650    
2651          while (eptr >= pp)          while (eptr >= pp)
2652            {            {
2653            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
# Line 2555  for (;;) Line 2663  for (;;)
2663    
2664      else      else
2665        {        {
2666        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2667          {          {
2668          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2669            {            {
# Line 2563  for (;;) Line 2671  for (;;)
2671            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2672            }            }
2673          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
2674          }          }
2675    
2676        if (min == max) continue;        if (min == max) continue;
2677    
2678        if (minimize)        if (minimize)
2679          {          {
2680          for (fi = min;; fi++)          for (fi = min;; fi++)
2681            {            {
2682            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2683            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2684            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2685            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2686              {              {
2687              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2688              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2689              }              }
2690            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
2691            }            }
2692          /* Control never gets here */          /* Control never gets here */
# Line 2593  for (;;) Line 2699  for (;;)
2699            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject || fc != *eptr) break;
2700            eptr++;            eptr++;
2701            }            }
         CHECK_PARTIAL();  
2702          if (possessive) continue;          if (possessive) continue;
2703    
2704          while (eptr >= pp)          while (eptr >= pp)
2705            {            {
2706            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
# Line 2610  for (;;) Line 2716  for (;;)
2716      checking can be multibyte. */      checking can be multibyte. */
2717    
2718      case OP_NOT:      case OP_NOT:
2719      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2720          {
2721          SCHECK_PARTIAL();
2722          RRETURN(MATCH_NOMATCH);
2723          }
2724      ecode++;      ecode++;
2725      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2726      if ((ims & PCRE_CASELESS) != 0)      if ((ims & PCRE_CASELESS) != 0)
# Line 2717  for (;;) Line 2827  for (;;)
2827            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2828              {              {
2829              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2830              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2831              }              }
2832            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
2833            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
2834            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
# Line 2734  for (;;) Line 2844  for (;;)
2844            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2845              {              {
2846              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2847              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2848              }              }
2849            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
2850            }            }
2851          }          }
2852    
2853        if (min == max) continue;        if (min == max) continue;
# Line 2753  for (;;) Line 2863  for (;;)
2863              {              {
2864              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
2865              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2866              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
2867                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
2868                {                {
2869                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2870                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2871                }                }
2872              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2873              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
2874              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
# Line 2776  for (;;) Line 2882  for (;;)
2882              {              {
2883              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
2884              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2885              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2886              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2887                {                {
2888                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 2812  for (;;) Line 2914  for (;;)
2914              if (fc == d) break;              if (fc == d) break;
2915              eptr += len;              eptr += len;
2916              }              }
         CHECK_PARTIAL();  
2917          if (possessive) continue;          if (possessive) continue;
2918          for(;;)          for(;;)
2919              {              {
# Line 2831  for (;;) Line 2932  for (;;)
2932              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
2933              eptr++;              eptr++;
2934              }              }
           CHECK_PARTIAL();  
2935            if (possessive) continue;            if (possessive) continue;
2936            while (eptr >= pp)            while (eptr >= pp)
2937              {              {
# Line 2860  for (;;) Line 2960  for (;;)
2960            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2961              {              {
2962              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2963              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2964              }              }
2965            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
2966            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
2967            }            }
# Line 2875  for (;;) Line 2975  for (;;)
2975            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2976              {              {
2977              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2978              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2979              }              }
2980            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
2981            }            }
2982          }          }
2983    
2984        if (min == max) continue;        if (min == max) continue;
# Line 2894  for (;;) Line 2994  for (;;)
2994              {              {
2995              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
2996              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2997              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
2998                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
2999                {                {
3000                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3001                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3002                }                }
3003              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3004              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
3005              }              }
# Line 2916  for (;;) Line 3012  for (;;)
3012              {              {
3013              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3014              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3015              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3016              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3017                {                {
3018                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3019                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3020                }                }
3021              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3022              }              }
3023            }            }
# Line 2951  for (;;) Line 3043  for (;;)
3043              if (fc == d) break;              if (fc == d) break;
3044              eptr += len;              eptr += len;
3045              }              }
           CHECK_PARTIAL();  
3046            if (possessive) continue;            if (possessive) continue;
3047            for(;;)            for(;;)
3048              {              {
# Line 2970  for (;;) Line 3061  for (;;)
3061              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject || fc == *eptr) break;
3062              eptr++;              eptr++;
3063              }              }
           CHECK_PARTIAL();  
3064            if (possessive) continue;            if (possessive) continue;
3065            while (eptr >= pp)            while (eptr >= pp)
3066              {              {
# Line 3077  for (;;) Line 3167  for (;;)
3167            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3168            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3169              {              {
3170              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3171                {                {
3172                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3173                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3174                }                }
3175              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3176              }              }
3177            break;            break;
# Line 3089  for (;;) Line 3179  for (;;)
3179            case PT_LAMP:            case PT_LAMP:
3180            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3181              {              {
3182              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3183                {                {
3184                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3185                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3186                }                }
3187              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3188              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3189              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 3106  for (;;) Line 3196  for (;;)
3196            case PT_GC:            case PT_GC:
3197            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3198              {              {
3199              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3200                {                {
3201                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3202                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3203                }                }
3204              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3205              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3206              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 3121  for (;;) Line 3211  for (;;)
3211            case PT_PC:            case PT_PC:
3212            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3213              {              {
3214              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3215                {                {
3216                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3217                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3218                }                }
3219              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3220              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3221              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 3136  for (;;) Line 3226  for (;;)
3226            case PT_SC:            case PT_SC:
3227            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3228              {              {
3229              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3230                {                {
3231                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3232                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3233                }                }
3234              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3235              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3236              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 3160  for (;;) Line 3250  for (;;)
3250          {          {
3251          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3252            {            {
3253            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3254              {              {
3255              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3256              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3257              }              }
3258            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3259            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3260            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
# Line 3193  for (;;) Line 3283  for (;;)
3283            {            {
3284            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3285              {              {
3286              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3287              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3288              }              }
3289            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3290            eptr++;            eptr++;
3291            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3205  for (;;) Line 3295  for (;;)
3295          case OP_ALLANY:          case OP_ALLANY:
3296          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3297            {            {
3298            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3299              {              {
3300              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3301              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3302              }              }
3303            eptr++;            eptr++;
3304            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3305            }            }
3306          break;          break;
3307    
3308          case OP_ANYBYTE:          case OP_ANYBYTE:
3309          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
3310          eptr += min;          eptr += min;
3311          break;          break;
3312    
3313          case OP_ANYNL:          case OP_ANYNL:
3314          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3315            {            {
3316            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3317              {              {
3318              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3319              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3320              }              }
3321            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3322            switch(c)            switch(c)
3323              {              {
# Line 3253  for (;;) Line 3343  for (;;)
3343          case OP_NOT_HSPACE:          case OP_NOT_HSPACE:
3344          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3345            {            {
3346            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3347              {              {
3348              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3349              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3350              }              }
3351            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3352            switch(c)            switch(c)
3353              {              {
# Line 3289  for (;;) Line 3379  for (;;)
3379          case OP_HSPACE:          case OP_HSPACE:
3380          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3381            {            {
3382            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3383              {              {
3384              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3385              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3386              }              }
3387            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3388            switch(c)            switch(c)
3389              {              {
# Line 3325  for (;;) Line 3415  for (;;)
3415          case OP_NOT_VSPACE:          case OP_NOT_VSPACE:
3416          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3417            {            {
3418            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3419              {              {
3420              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3421              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3422              }              }
3423            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3424            switch(c)            switch(c)
3425              {              {
# Line 3349  for (;;) Line 3439  for (;;)
3439          case OP_VSPACE:          case OP_VSPACE:
3440          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3441            {            {
3442            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3443              {              {
3444              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3445              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3446              }              }
3447            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3448            switch(c)            switch(c)
3449              {              {
# Line 3373  for (;;) Line 3463  for (;;)
3463          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3464          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3465            {            {
3466            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3467              {              {
3468              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3469              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3470              }              }
3471            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3472            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3473              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
# Line 3387  for (;;) Line 3477  for (;;)
3477          case OP_DIGIT:          case OP_DIGIT:
3478          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3479            {            {
3480            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3481              {              {
3482              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3483              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3484              }              }
3485            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3486              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3487            /* 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 */
# Line 3401  for (;;) Line 3491  for (;;)
3491          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
3492          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3493            {            {
3494            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3495              {              {
3496              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3497              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3498              }              }
3499            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3500              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3501            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
# Line 3415  for (;;) Line 3505  for (;;)
3505          case OP_WHITESPACE:          case OP_WHITESPACE:
3506          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3507            {            {
3508            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3509              {              {
3510              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3511              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3512              }              }
3513            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3514              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3515            /* 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 */
# Line 3439  for (;;) Line 3529  for (;;)
3529          case OP_WORDCHAR:          case OP_WORDCHAR:
3530          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3531            {            {
3532            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3533              {              {
3534              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3535              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3536              }              }
3537            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3538              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3539            /* 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 */
# Line 3465  for (;;) Line 3555  for (;;)
3555          case OP_ANY:          case OP_ANY:
3556          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3557            {            {
3558            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3559              {              {
3560              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3561              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3562              }              }
3563            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3564            eptr++;            eptr++;
3565            }            }
3566          break;          break;
3567    
3568          case OP_ALLANY:          case OP_ALLANY:
3569          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3570              {
3571              SCHECK_PARTIAL();
3572              RRETURN(MATCH_NOMATCH);
3573              }
3574          eptr += min;          eptr += min;
3575          break;          break;
3576    
3577          case OP_ANYBYTE:          case OP_ANYBYTE:
3578          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3579              {
3580              SCHECK_PARTIAL();
3581              RRETURN(MATCH_NOMATCH);
3582              }
3583          eptr += min;          eptr += min;
3584          break;          break;
3585    
3586          case OP_ANYNL:          case OP_ANYNL:
3587          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3588            {            {
3589            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3590              {              {
3591              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3592              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3593              }              }
3594            switch(*eptr++)            switch(*eptr++)
3595              {              {
3596              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
# Line 3514  for (;;) Line 3612  for (;;)
3612          case OP_NOT_HSPACE:          case OP_NOT_HSPACE:
3613          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3614            {            {
3615            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3616              {              {
3617              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3618              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3619              }              }
3620            switch(*eptr++)            switch(*eptr++)
3621              {              {
3622              default: break;              default: break;
# Line 3533  for (;;) Line 3631  for (;;)
3631          case OP_HSPACE:          case OP_HSPACE:
3632          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3633            {            {
3634            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3635              {              {
3636              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3637              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3638              }              }
3639            switch(*eptr++)            switch(*eptr++)
3640              {              {
3641              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
# Line 3552  for (;;) Line 3650  for (;;)
3650          case OP_NOT_VSPACE:          case OP_NOT_VSPACE:
3651          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3652            {            {
3653            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3654              {              {
3655              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3656              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3657              }              }
3658            switch(*eptr++)            switch(*eptr++)
3659              {              {
3660              default: break;              default: break;
# Line 3573  for (;;) Line 3671  for (;;)
3671          case OP_VSPACE:          case OP_VSPACE:
3672          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3673            {            {
3674            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3675              {              {
3676              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3677              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3678              }              }
3679            switch(*eptr++)            switch(*eptr++)
3680              {              {
3681              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
# Line 3593  for (;;) Line 3691  for (;;)
3691    
3692          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3693          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3694            {            {
3695            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3696              {              {
3697              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3698              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3699              }              }
3700            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
3701            }            }
3702          break;          break;
3703    
3704          case OP_DIGIT:          case OP_DIGIT:
3705          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3706            {            {
3707            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3708              {              {
3709              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3710              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3711              }              }
3712            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
3713            }            }
3714          break;          break;
3715    
3716          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
3717          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3718            {            {
3719            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3720              {              {
3721              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3722              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3723              }              }
3724            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
3725            }            }
3726          break;          break;
3727    
3728          case OP_WHITESPACE:          case OP_WHITESPACE:
3729          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3730            {            {
3731            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3732              {              {
3733              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3734              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3735              }              }
3736            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
3737            }            }
3738          break;          break;
3739    
3740          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3741          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3742            {            {
3743            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3744              {              {
3745              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3746              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3747              }              }
3748            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
3749              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3750            }            }
3751          break;          break;
3752    
3753          case OP_WORDCHAR:          case OP_WORDCHAR:
3754          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3755            {            {
3756            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3757              {              {
3758              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3759              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3760              }              }
3761            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
3762              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3763            }            }
3764          break;          break;
3765    
3766          default:          default:
# Line 3690  for (;;) Line 3788  for (;;)
3788              {              {
3789              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
3790              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3791              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3792                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3793                {                {
3794                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3795                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3796                }                }
3797              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3798              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3799              }              }
# Line 3710  for (;;) Line 3804  for (;;)
3804              {              {
3805              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
3806              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3807              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3808                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3809                {                {
3810                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3811                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3812                }                }
3813              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3814              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3815              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 3734  for (;;) Line 3824  for (;;)
3824              {              {
3825              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
3826              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3827              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3828                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3829                {                {
3830                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3831                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3832                }                }
3833              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3834              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3835              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 3756  for (;;) Line 3842  for (;;)
3842              {              {
3843              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
3844              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3845              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3846                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3847                {                {
3848                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3849                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3850                }                }
3851              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3852              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3853              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 3778  for (;;) Line 3860  for (;;)
3860              {              {
3861              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
3862              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3863              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3864                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3865                {                {
3866                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3867                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3868                }                }
3869              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3870              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3871              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 3809  for (;;) Line 3887  for (;;)
3887            {            {
3888            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
3889            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3890            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
3891              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
3892              {              {
3893              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3894              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3895              }              }
3896            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3897            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3898            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
# Line 3845  for (;;) Line 3919  for (;;)
3919            {            {
3920            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
3921            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3922            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
3923              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
3924              {              {
3925              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3926              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3927              }              }
3928            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
3929              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3930            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
# Line 4012  for (;;) Line 4082  for (;;)
4082            {            {
4083            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4084            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4085            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
4086              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
4087              {              {
4088              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4089              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4090              }              }
4091            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4092              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4093            c = *eptr++;            c = *eptr++;
# Line 4212  for (;;) Line 4278  for (;;)
4278    
4279          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4280    
         CHECK_PARTIAL();  
4281          if (possessive) continue;          if (possessive) continue;
4282          for(;;)          for(;;)
4283            {            {
# Line 4249  for (;;) Line 4314  for (;;)
4314    
4315          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4316    
         CHECK_PARTIAL();  
4317          if (possessive) continue;          if (possessive) continue;
4318          for(;;)          for(;;)
4319            {            {
# Line 4486  for (;;) Line 4550  for (;;)
4550    
4551          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4552    
         CHECK_PARTIAL();  
4553          if (possessive) continue;          if (possessive) continue;
4554          for(;;)          for(;;)
4555            {            {
# Line 4642  for (;;) Line 4705  for (;;)
4705    
4706          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4707    
         CHECK_PARTIAL();  
4708          if (possessive) continue;          if (possessive) continue;
4709          while (eptr >= pp)          while (eptr >= pp)
4710            {            {
# Line 4894  md->jscript_compat = (re->options & PCRE Line 4956  md->jscript_compat = (re->options & PCRE
4956  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
4957  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
4958  md->notempty = (options & PCRE_NOTEMPTY) != 0;  md->notempty = (options & PCRE_NOTEMPTY) != 0;
4959  md->partial = (options & PCRE_PARTIAL) != 0;  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
4960    md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
4961                  ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
4962  md->hitend = FALSE;  md->hitend = FALSE;
4963    
4964  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
# Line 5252  for(;;) Line 5316  for(;;)
5316        }        }
5317      }      }
5318    
5319    /* 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
5320    first starting point for which a partial match was found. */    first starting point for which a partial match was found. */
5321    
5322    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5323      md->start_used_ptr = start_match;
5324    md->match_call_count = 0;    md->match_call_count = 0;
5325    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);
5326    if (md->hitend && start_partial == NULL) start_partial = start_match;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
5327    
5328    switch(rc)    switch(rc)
5329      {      {
# Line 5288  for(;;) Line 5353  for(;;)
5353      rc = MATCH_NOMATCH;      rc = MATCH_NOMATCH;
5354      goto ENDLOOP;      goto ENDLOOP;
5355    
5356      /* Any other return is some kind of error. */      /* Any other return is either a match, or some kind of error. */
5357    
5358      default:      default:
5359      goto ENDLOOP;      goto ENDLOOP;
# Line 5370  if (rc == MATCH_MATCH) Line 5435  if (rc == MATCH_MATCH)
5435    too many to fit into the vector. */    too many to fit into the vector. */
5436    
5437    rc = md->offset_overflow? 0 : md->end_offset_top/2;    rc = md->offset_overflow? 0 : md->end_offset_top/2;
5438    
5439    /* If there is space, set up the whole thing as substring 0. The value of    /* If there is space, set up the whole thing as substring 0. The value of
5440    md->start_match_ptr might be modified if \K was encountered on the success    md->start_match_ptr might be modified if \K was encountered on the success
5441    matching path. */    matching path. */
# Line 5394  if (using_temporary_offsets) Line 5459  if (using_temporary_offsets)
5459    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
5460    }    }
5461    
5462  if (rc != MATCH_NOMATCH)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
5463    {    {
5464    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
5465    return rc;    return rc;
5466    }    }
5467  else if (md->partial && start_partial != NULL)  else if (start_partial != NULL)
5468    {    {
5469    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
5470    if (offsetcount > 1)    if (offsetcount > 1)
5471      {      {
5472      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = start_partial - (USPTR)subject;
5473      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = end_subject - (USPTR)subject;
5474      }      }
5475    return PCRE_ERROR_PARTIAL;    return PCRE_ERROR_PARTIAL;
5476    }    }
5477  else  else

Legend:
Removed from v.426  
changed lines
  Added in v.447

  ViewVC Help
Powered by ViewVC 1.1.5