/[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 473 by ph10, Sat Jan 2 12:40:07 2010 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2009 University of Cambridge             Copyright (c) 1997-2010 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 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 != 0 && 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 836  for (;;) Line 839  for (;;)
839    
840      /* Now see what the actual condition is */      /* Now see what the actual condition is */
841    
842      if (condcode == OP_RREF)         /* Recursion test */      if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
843        {        {
844        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/        if (md->recursive == NULL)                /* Not recursing => FALSE */
845        condition = md->recursive != NULL &&          {
846          (offset == RREF_ANY || offset == md->recursive->group_num);          condition = FALSE;
847        ecode += condition? 3 : GET(ecode, 1);          ecode += GET(ecode, 1);
848            }
849          else
850            {
851            int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
852            condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
853    
854            /* If the test is for recursion into a specific subpattern, and it is
855            false, but the test was set up by name, scan the table to see if the
856            name refers to any other numbers, and test them. The condition is true
857            if any one is set. */
858    
859            if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
860              {
861              uschar *slotA = md->name_table;
862              for (i = 0; i < md->name_count; i++)
863                {
864                if (GET2(slotA, 0) == recno) break;
865                slotA += md->name_entry_size;
866                }
867    
868              /* Found a name for the number - there can be only one; duplicate
869              names for different numbers are allowed, but not vice versa. First
870              scan down for duplicates. */
871    
872              if (i < md->name_count)
873                {
874                uschar *slotB = slotA;
875                while (slotB > md->name_table)
876                  {
877                  slotB -= md->name_entry_size;
878                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
879                    {
880                    condition = GET2(slotB, 0) == md->recursive->group_num;
881                    if (condition) break;
882                    }
883                  else break;
884                  }
885    
886                /* Scan up for duplicates */
887    
888                if (!condition)
889                  {
890                  slotB = slotA;
891                  for (i++; i < md->name_count; i++)
892                    {
893                    slotB += md->name_entry_size;
894                    if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
895                      {
896                      condition = GET2(slotB, 0) == md->recursive->group_num;
897                      if (condition) break;
898                      }
899                    else break;
900                    }
901                  }
902                }
903              }
904    
905            /* Chose branch according to the condition */
906    
907            ecode += condition? 3 : GET(ecode, 1);
908            }
909        }        }
910    
911      else if (condcode == OP_CREF)    /* Group used test */      else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
912        {        {
913        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
914        condition = offset < offset_top && md->offset_vector[offset] >= 0;        condition = offset < offset_top && md->offset_vector[offset] >= 0;
915    
916          /* If the numbered capture is unset, but the reference was by name,
917          scan the table to see if the name refers to any other numbers, and test
918          them. The condition is true if any one is set. This is tediously similar
919          to the code above, but not close enough to try to amalgamate. */
920    
921          if (!condition && condcode == OP_NCREF)
922            {
923            int refno = offset >> 1;
924            uschar *slotA = md->name_table;
925    
926            for (i = 0; i < md->name_count; i++)
927              {
928              if (GET2(slotA, 0) == refno) break;
929              slotA += md->name_entry_size;
930              }
931    
932            /* Found a name for the number - there can be only one; duplicate names
933            for different numbers are allowed, but not vice versa. First scan down
934            for duplicates. */
935    
936            if (i < md->name_count)
937              {
938              uschar *slotB = slotA;
939              while (slotB > md->name_table)
940                {
941                slotB -= md->name_entry_size;
942                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
943                  {
944                  offset = GET2(slotB, 0) << 1;
945                  condition = offset < offset_top &&
946                    md->offset_vector[offset] >= 0;
947                  if (condition) break;
948                  }
949                else break;
950                }
951    
952              /* Scan up for duplicates */
953    
954              if (!condition)
955                {
956                slotB = slotA;
957                for (i++; i < md->name_count; i++)
958                  {
959                  slotB += md->name_entry_size;
960                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
961                    {
962                    offset = GET2(slotB, 0) << 1;
963                    condition = offset < offset_top &&
964                      md->offset_vector[offset] >= 0;
965                    if (condition) break;
966                    }
967                  else break;
968                  }
969                }
970              }
971            }
972    
973          /* Chose branch according to the condition */
974    
975        ecode += condition? 3 : GET(ecode, 1);        ecode += condition? 3 : GET(ecode, 1);
976        }        }
977    
# Line 908  for (;;) Line 1032  for (;;)
1032      break;      break;
1033    
1034    
1035        /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1036        to close any currently open capturing brackets. */
1037    
1038        case OP_CLOSE:
1039        number = GET2(ecode, 1);
1040        offset = number << 1;
1041    
1042    #ifdef DEBUG
1043          printf("end bracket %d at *ACCEPT", number);
1044          printf("\n");
1045    #endif
1046    
1047        md->capture_last = number;
1048        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1049          {
1050          md->offset_vector[offset] =
1051            md->offset_vector[md->offset_end - number];
1052          md->offset_vector[offset+1] = eptr - md->start_subject;
1053          if (offset_top <= offset) offset_top = offset + 2;
1054          }
1055        ecode += 3;
1056        break;
1057    
1058    
1059      /* 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
1060      recursion, we should restore the offsets appropriately and continue from      recursion, we should restore the offsets appropriately and continue from
1061      after the call. */      after the call. */
# Line 921  for (;;) Line 1069  for (;;)
1069        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
1070        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1071          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1072          offset_top = rec->save_offset_top;
1073        mstart = rec->save_start;        mstart = rec->save_start;
1074        ims = original_ims;        ims = original_ims;
1075        ecode = rec->after_call;        ecode = rec->after_call;
1076        break;        break;
1077        }        }
1078    
1079      /* 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
1080      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
1081        the subject. In both cases, backtracking will then try other alternatives,
1082        if any. */
1083    
1084        if (eptr == mstart &&
1085            (md->notempty ||
1086              (md->notempty_atstart &&
1087                mstart == md->start_subject + md->start_offset)))
1088          RRETURN(MATCH_NOMATCH);
1089    
1090        /* Otherwise, we have a match. */
1091    
     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);  
1092      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1093      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1094      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
# Line 975  for (;;) Line 1133  for (;;)
1133      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1134      continue;      continue;
1135    
1136      /* Negative assertion: all branches must fail to match */      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1137        PRUNE, or COMMIT means we must assume failure without checking subsequent
1138        branches. */
1139    
1140      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1141      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
# Line 984  for (;;) Line 1144  for (;;)
1144        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1145          RM5);          RM5);
1146        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
1147          if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1148            {
1149            do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1150            break;
1151            }
1152        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1153        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1154        }        }
# Line 1021  for (;;) Line 1186  for (;;)
1186        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1187        }        }
1188    
1189      /* Skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
1190    
1191        if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1192      ecode += 1 + LINK_SIZE;      ecode += 1 + LINK_SIZE;
1193      break;      break;
1194    
# Line 1102  for (;;) Line 1268  for (;;)
1268        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1269              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1270        new_recursive.save_start = mstart;        new_recursive.save_start = mstart;
1271          new_recursive.save_offset_top = offset_top;
1272        mstart = eptr;        mstart = eptr;
1273    
1274        /* 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 1326  for (;;) Line 1493  for (;;)
1493          mstart = rec->save_start;          mstart = rec->save_start;
1494          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1495            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1496            offset_top = rec->save_offset_top;
1497          ecode = rec->after_call;          ecode = rec->after_call;
1498          ims = original_ims;          ims = original_ims;
1499          break;          break;
# Line 1465  for (;;) Line 1633  for (;;)
1633    
1634        /* Find out if the previous and current characters are "word" characters.        /* Find out if the previous and current characters are "word" characters.
1635        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
1636        be "non-word" characters. */        be "non-word" characters. Remember the earliest consulted character for
1637          partial matching. */
1638    
1639  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1640        if (utf8)        if (utf8)
# Line 1474  for (;;) Line 1643  for (;;)
1643            {            {
1644            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1645            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1646              if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1647            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1648            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1649            }            }
1650          if (eptr >= md->end_subject) cur_is_word = FALSE; else          if (eptr >= md->end_subject)
1651              {
1652              SCHECK_PARTIAL();
1653              cur_is_word = FALSE;
1654              }
1655            else
1656            {            {
1657            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1658            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 1661  for (;;)
1661        else        else
1662  #endif  #endif
1663    
1664        /* More streamlined when not in UTF-8 mode */        /* Not in UTF-8 mode */
1665    
1666          {          {
1667          prev_is_word = (eptr != md->start_subject) &&          if (eptr == md->start_subject) prev_is_word = FALSE; else
1668            ((md->ctypes[eptr[-1]] & ctype_word) != 0);            {
1669          cur_is_word = (eptr < md->end_subject) &&            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1670            ((md->ctypes[*eptr] & ctype_word) != 0);            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1671              }
1672            if (eptr >= md->end_subject)
1673              {
1674              SCHECK_PARTIAL();
1675              cur_is_word = FALSE;
1676              }
1677            else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1678          }          }
1679    
1680        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
# Line 1510  for (;;) Line 1692  for (;;)
1692      /* Fall through */      /* Fall through */
1693    
1694      case OP_ALLANY:      case OP_ALLANY:
1695      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject)
1696          {
1697          SCHECK_PARTIAL();
1698          RRETURN(MATCH_NOMATCH);
1699          }
1700      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1701      ecode++;      ecode++;
1702      break;      break;
# Line 1519  for (;;) Line 1705  for (;;)
1705      any byte, even newline, independent of the setting of PCRE_DOTALL. */      any byte, even newline, independent of the setting of PCRE_DOTALL. */
1706    
1707      case OP_ANYBYTE:      case OP_ANYBYTE:
1708      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject)
1709          {
1710          SCHECK_PARTIAL();
1711          RRETURN(MATCH_NOMATCH);
1712          }
1713      ecode++;      ecode++;
1714      break;      break;
1715    
1716      case OP_NOT_DIGIT:      case OP_NOT_DIGIT:
1717      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1718          {
1719          SCHECK_PARTIAL();
1720          RRETURN(MATCH_NOMATCH);
1721          }
1722      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1723      if (      if (
1724  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1537  for (;;) Line 1731  for (;;)
1731      break;      break;
1732    
1733      case OP_DIGIT:      case OP_DIGIT:
1734      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1735          {
1736          SCHECK_PARTIAL();
1737          RRETURN(MATCH_NOMATCH);
1738          }
1739      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1740      if (      if (
1741  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1550  for (;;) Line 1748  for (;;)
1748      break;      break;
1749    
1750      case OP_NOT_WHITESPACE:      case OP_NOT_WHITESPACE:
1751      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1752          {
1753          SCHECK_PARTIAL();
1754          RRETURN(MATCH_NOMATCH);
1755          }
1756      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1757      if (      if (
1758  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1563  for (;;) Line 1765  for (;;)
1765      break;      break;
1766    
1767      case OP_WHITESPACE:      case OP_WHITESPACE:
1768      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1769          {
1770          SCHECK_PARTIAL();
1771          RRETURN(MATCH_NOMATCH);
1772          }
1773      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1774      if (      if (
1775  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1576  for (;;) Line 1782  for (;;)
1782      break;      break;
1783    
1784      case OP_NOT_WORDCHAR:      case OP_NOT_WORDCHAR:
1785      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1786          {
1787          SCHECK_PARTIAL();
1788          RRETURN(MATCH_NOMATCH);
1789          }
1790      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1791      if (      if (
1792  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1589  for (;;) Line 1799  for (;;)
1799      break;      break;
1800    
1801      case OP_WORDCHAR:      case OP_WORDCHAR:
1802      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1803          {
1804          SCHECK_PARTIAL();
1805          RRETURN(MATCH_NOMATCH);
1806          }
1807      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1808      if (      if (
1809  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1602  for (;;) Line 1816  for (;;)
1816      break;      break;
1817    
1818      case OP_ANYNL:      case OP_ANYNL:
1819      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1820          {
1821          SCHECK_PARTIAL();
1822          RRETURN(MATCH_NOMATCH);
1823          }
1824      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1825      switch(c)      switch(c)
1826        {        {
# Line 1626  for (;;) Line 1844  for (;;)
1844      break;      break;
1845    
1846      case OP_NOT_HSPACE:      case OP_NOT_HSPACE:
1847      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1848          {
1849          SCHECK_PARTIAL();
1850          RRETURN(MATCH_NOMATCH);
1851          }
1852      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1853      switch(c)      switch(c)
1854        {        {
# Line 1656  for (;;) Line 1878  for (;;)
1878      break;      break;
1879    
1880      case OP_HSPACE:      case OP_HSPACE:
1881      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1882          {
1883          SCHECK_PARTIAL();
1884          RRETURN(MATCH_NOMATCH);
1885          }
1886      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1887      switch(c)      switch(c)
1888        {        {
# Line 1686  for (;;) Line 1912  for (;;)
1912      break;      break;
1913    
1914      case OP_NOT_VSPACE:      case OP_NOT_VSPACE:
1915      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1916          {
1917          SCHECK_PARTIAL();
1918          RRETURN(MATCH_NOMATCH);
1919          }
1920      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1921      switch(c)      switch(c)
1922        {        {
# Line 1704  for (;;) Line 1934  for (;;)
1934      break;      break;
1935    
1936      case OP_VSPACE:      case OP_VSPACE:
1937      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1938          {
1939          SCHECK_PARTIAL();
1940          RRETURN(MATCH_NOMATCH);
1941          }
1942      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1943      switch(c)      switch(c)
1944        {        {
# Line 1727  for (;;) Line 1961  for (;;)
1961    
1962      case OP_PROP:      case OP_PROP:
1963      case OP_NOTPROP:      case OP_NOTPROP:
1964      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1965          {
1966          SCHECK_PARTIAL();
1967          RRETURN(MATCH_NOMATCH);
1968          }
1969      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1970        {        {
1971        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
# Line 1772  for (;;) Line 2010  for (;;)
2010      is in the binary; otherwise a compile-time error occurs. */      is in the binary; otherwise a compile-time error occurs. */
2011    
2012      case OP_EXTUNI:      case OP_EXTUNI:
2013      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2014          {
2015          SCHECK_PARTIAL();
2016          RRETURN(MATCH_NOMATCH);
2017          }
2018      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2019        {        {
2020        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
# Line 1852  for (;;) Line 2094  for (;;)
2094          break;          break;
2095    
2096          default:               /* No repeat follows */          default:               /* No repeat follows */
2097          if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);          if (!match_ref(offset, eptr, length, md, ims))
2098              {
2099              CHECK_PARTIAL();
2100              RRETURN(MATCH_NOMATCH);
2101              }
2102          eptr += length;          eptr += length;
2103          continue;              /* With the main loop */          continue;              /* With the main loop */
2104          }          }
# Line 1868  for (;;) Line 2114  for (;;)
2114    
2115        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2116          {          {
2117          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2118            {            {
2119            CHECK_PARTIAL();            CHECK_PARTIAL();
2120            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2121            }            }
2122          eptr += length;          eptr += length;
2123          }          }
2124    
# Line 1889  for (;;) Line 2135  for (;;)
2135            {            {
2136            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2137            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2138            if (fi >= max || !match_ref(offset, eptr, length, md, ims))            if (fi >= max) RRETURN(MATCH_NOMATCH);
2139              if (!match_ref(offset, eptr, length, md, ims))
2140              {              {
2141              CHECK_PARTIAL();              CHECK_PARTIAL();
2142              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2143              }              }
2144            eptr += length;            eptr += length;
2145            }            }
2146          /* Control never gets here */          /* Control never gets here */
# Line 1906  for (;;) Line 2153  for (;;)
2153          pp = eptr;          pp = eptr;
2154          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2155            {            {
2156            if (!match_ref(offset, eptr, length, md, ims)) break;            if (!match_ref(offset, eptr, length, md, ims))
2157                {
2158                CHECK_PARTIAL();
2159                break;
2160                }
2161            eptr += length;            eptr += length;
2162            }            }
         CHECK_PARTIAL();  
2163          while (eptr >= pp)          while (eptr >= pp)
2164            {            {
2165            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
# Line 1921  for (;;) Line 2171  for (;;)
2171        }        }
2172      /* Control never gets here */      /* Control never gets here */
2173    
   
   
2174      /* Match a bit-mapped character class, possibly repeatedly. This op code is      /* Match a bit-mapped character class, possibly repeatedly. This op code is
2175      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,
2176      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 2225  for (;;)
2225          {          {
2226          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2227            {            {
2228            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2229              {              {
2230              CHECK_PARTIAL();              SCHECK_PARTIAL();
2231              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2232              }              }
2233            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2234            if (c > 255)            if (c > 255)
2235              {              {
# Line 1999  for (;;) Line 2247  for (;;)
2247          {          {
2248          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2249            {            {
2250            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2251              {              {
2252              CHECK_PARTIAL();              SCHECK_PARTIAL();
2253              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2254              }              }
2255            c = *eptr++;            c = *eptr++;
2256            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2257            }            }
# Line 2027  for (;;) Line 2275  for (;;)
2275              {              {
2276              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2277              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2278              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
2279                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
2280                {                {
2281                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2282                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2283                }                }
2284              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2285              if (c > 255)              if (c > 255)
2286                {                {
# Line 2056  for (;;) Line 2300  for (;;)
2300              {              {
2301              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2302              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2303              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
2304                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
2305                {                {
2306                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2307                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2308                }                }
2309              c = *eptr++;              c = *eptr++;
2310              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2311              }              }
# Line 2086  for (;;) Line 2326  for (;;)
2326            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2327              {              {
2328              int len = 1;              int len = 1;
2329              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2330                  {
2331                  SCHECK_PARTIAL();
2332                  break;
2333                  }
2334              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
2335              if (c > 255)              if (c > 255)
2336                {                {
# Line 2098  for (;;) Line 2342  for (;;)
2342                }                }
2343              eptr += len;              eptr += len;
2344              }              }
           CHECK_PARTIAL();  
2345            for (;;)            for (;;)
2346              {              {
2347              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
# Line 2113  for (;;) Line 2356  for (;;)
2356            {            {
2357            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2358              {              {
2359              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2360                  {
2361                  SCHECK_PARTIAL();
2362                  break;
2363                  }
2364              c = *eptr;              c = *eptr;
2365              if ((data[c/8] & (1 << (c&7))) == 0) break;              if ((data[c/8] & (1 << (c&7))) == 0) break;
2366              eptr++;              eptr++;
2367              }              }
           CHECK_PARTIAL();  
2368            while (eptr >= pp)            while (eptr >= pp)
2369              {              {
2370              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
# Line 2176  for (;;) Line 2422  for (;;)
2422    
2423        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2424          {          {
2425          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2426            {            {
2427            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2428            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2429            }            }
2430          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2431          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2432          }          }
# Line 2199  for (;;) Line 2445  for (;;)
2445            {            {
2446            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2447            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2448            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
2449              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
2450              {              {
2451              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2452              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2453              }              }
2454            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2455            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2456            }            }
# Line 2223  for (;;) Line 2465  for (;;)
2465          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2466            {            {
2467            int len = 1;            int len = 1;
2468            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
2469                {
2470                SCHECK_PARTIAL();
2471                break;
2472                }
2473            GETCHARLENTEST(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2474            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2475            eptr += len;            eptr += len;
2476            }            }
         CHECK_PARTIAL();  
2477          for(;;)          for(;;)
2478            {            {
2479            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
# Line 2252  for (;;) Line 2497  for (;;)
2497        length = 1;        length = 1;
2498        ecode++;        ecode++;
2499        GETCHARLEN(fc, ecode, length);        GETCHARLEN(fc, ecode, length);
2500        if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);        if (length > md->end_subject - eptr)
2501            {
2502            CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2503            RRETURN(MATCH_NOMATCH);
2504            }
2505        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
2506        }        }
2507      else      else
# Line 2260  for (;;) Line 2509  for (;;)
2509    
2510      /* Non-UTF-8 mode */      /* Non-UTF-8 mode */
2511        {        {
2512        if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);        if (md->end_subject - eptr < 1)
2513            {
2514            SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2515            RRETURN(MATCH_NOMATCH);
2516            }
2517        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
2518        ecode += 2;        ecode += 2;
2519        }        }
# Line 2276  for (;;) Line 2529  for (;;)
2529        ecode++;        ecode++;
2530        GETCHARLEN(fc, ecode, length);        GETCHARLEN(fc, ecode, length);
2531    
2532        if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);        if (length > md->end_subject - eptr)
2533            {
2534            CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2535            RRETURN(MATCH_NOMATCH);
2536            }
2537    
2538        /* 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
2539        can use the fast lookup table. */        can use the fast lookup table. */
# Line 2311  for (;;) Line 2568  for (;;)
2568    
2569      /* Non-UTF-8 mode */      /* Non-UTF-8 mode */
2570        {        {
2571        if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);        if (md->end_subject - eptr < 1)
2572            {
2573            SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2574            RRETURN(MATCH_NOMATCH);
2575            }
2576        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
2577        ecode += 2;        ecode += 2;
2578        }        }
# Line 2365  for (;;) Line 2626  for (;;)
2626      case OP_MINQUERY:      case OP_MINQUERY:
2627      c = *ecode++ - OP_STAR;      c = *ecode++ - OP_STAR;
2628      minimize = (c & 1) != 0;      minimize = (c & 1) != 0;
2629    
2630      min = rep_min[c];                 /* Pick up values from tables; */      min = rep_min[c];                 /* Pick up values from tables; */
2631      max = rep_max[c];                 /* zero for max => infinity */      max = rep_max[c];                 /* zero for max => infinity */
2632      if (max == 0) max = INT_MAX;      if (max == 0) max = INT_MAX;
# Line 2417  for (;;) Line 2679  for (;;)
2679              {              {
2680              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2681              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2682              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2683              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2684                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2685  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2450  for (;;) Line 2708  for (;;)
2708                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
2709                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2710  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2711              else break;              else
2712                  {
2713                  CHECK_PARTIAL();
2714                  break;
2715                  }
2716              }              }
2717    
           CHECK_PARTIAL();  
2718            if (possessive) continue;            if (possessive) continue;
2719    
2720            for(;;)            for(;;)
2721              {              {
2722              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
# Line 2514  for (;;) Line 2775  for (;;)
2775            {            {
2776            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2777            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2778            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2779            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2780              {              {
2781              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2782              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2783              }              }
2784            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
# Line 2533  for (;;) Line 2790  for (;;)
2790          pp = eptr;          pp = eptr;
2791          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2792            {            {
2793            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject)
2794                {
2795                SCHECK_PARTIAL();
2796                break;
2797                }
2798              if (fc != md->lcc[*eptr]) break;
2799            eptr++;            eptr++;
2800            }            }
2801    
         CHECK_PARTIAL();  
2802          if (possessive) continue;          if (possessive) continue;
2803    
2804          while (eptr >= pp)          while (eptr >= pp)
2805            {            {
2806            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
# Line 2555  for (;;) Line 2816  for (;;)
2816    
2817      else      else
2818        {        {
2819        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2820          {          {
2821          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2822            {            {
# Line 2563  for (;;) Line 2824  for (;;)
2824            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2825            }            }
2826          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
2827          }          }
2828    
2829        if (min == max) continue;        if (min == max) continue;
2830    
2831        if (minimize)        if (minimize)
2832          {          {
2833          for (fi = min;; fi++)          for (fi = min;; fi++)
2834            {            {
2835            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2836            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2837            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2838            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2839              {              {
2840              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2841              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2842              }              }
2843            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
2844            }            }
2845          /* Control never gets here */          /* Control never gets here */
# Line 2590  for (;;) Line 2849  for (;;)
2849          pp = eptr;          pp = eptr;
2850          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2851            {            {
2852            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject)
2853                {
2854                SCHECK_PARTIAL();
2855                break;
2856                }
2857              if (fc != *eptr) break;
2858            eptr++;            eptr++;
2859            }            }
         CHECK_PARTIAL();  
2860          if (possessive) continue;          if (possessive) continue;
2861    
2862          while (eptr >= pp)          while (eptr >= pp)
2863            {            {
2864            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
# Line 2610  for (;;) Line 2874  for (;;)
2874      checking can be multibyte. */      checking can be multibyte. */
2875    
2876      case OP_NOT:      case OP_NOT:
2877      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2878          {
2879          SCHECK_PARTIAL();
2880          RRETURN(MATCH_NOMATCH);
2881          }
2882      ecode++;      ecode++;
2883      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2884      if ((ims & PCRE_CASELESS) != 0)      if ((ims & PCRE_CASELESS) != 0)
# Line 2717  for (;;) Line 2985  for (;;)
2985            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2986              {              {
2987              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2988              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2989              }              }
2990            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
2991            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
2992            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
# Line 2734  for (;;) Line 3002  for (;;)
3002            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3003              {              {
3004              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3005              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3006              }              }
3007            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3008            }            }
3009          }          }
3010    
3011        if (min == max) continue;        if (min == max) continue;
# Line 2753  for (;;) Line 3021  for (;;)
3021              {              {
3022              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3023              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3024              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3025                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3026                {                {
3027                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3028                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3029                }                }
3030              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3031              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3032              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
# Line 2776  for (;;) Line 3040  for (;;)
3040              {              {
3041              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3042              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3043              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3044              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3045                {                {
3046                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 2806  for (;;) Line 3066  for (;;)
3066            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3067              {              {
3068              int len = 1;              int len = 1;
3069              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3070              GETCHARLEN(d, eptr, len);                {
3071              if (d < 256) d = md->lcc[d];                SCHECK_PARTIAL();
3072                  break;
3073                  }
3074                GETCHARLEN(d, eptr, len);
3075                if (d < 256) d = md->lcc[d];
3076              if (fc == d) break;              if (fc == d) break;
3077              eptr += len;              eptr += len;
3078              }              }
         CHECK_PARTIAL();  
3079          if (possessive) continue;          if (possessive) continue;
3080          for(;;)          for(;;)
3081              {              {
# Line 2828  for (;;) Line 3091  for (;;)
3091            {            {
3092            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3093              {              {
3094              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject)
3095                  {
3096                  SCHECK_PARTIAL();
3097                  break;
3098                  }
3099                if (fc == md->lcc[*eptr]) break;
3100              eptr++;              eptr++;
3101              }              }
           CHECK_PARTIAL();  
3102            if (possessive) continue;            if (possessive) continue;
3103            while (eptr >= pp)            while (eptr >= pp)
3104              {              {
# Line 2860  for (;;) Line 3127  for (;;)
3127            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3128              {              {
3129              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3130              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3131              }              }
3132            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3133            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
3134            }            }
# Line 2875  for (;;) Line 3142  for (;;)
3142            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3143              {              {
3144              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3145              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3146              }              }
3147            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3148            }            }
3149          }          }
3150    
3151        if (min == max) continue;        if (min == max) continue;
# Line 2894  for (;;) Line 3161  for (;;)
3161              {              {
3162              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3163              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3164              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3165                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3166                {                {
3167                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3168                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3169                }                }
3170              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3171              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
3172              }              }
# Line 2916  for (;;) Line 3179  for (;;)
3179              {              {
3180              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3181              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3182              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3183              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3184                {                {
3185                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3186                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3187                }                }
3188              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3189              }              }
3190            }            }
# Line 2946  for (;;) Line 3205  for (;;)
3205            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3206              {              {
3207              int len = 1;              int len = 1;
3208              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3209                  {
3210                  SCHECK_PARTIAL();
3211                  break;
3212                  }
3213              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3214              if (fc == d) break;              if (fc == d) break;
3215              eptr += len;              eptr += len;
3216              }              }
           CHECK_PARTIAL();  
3217            if (possessive) continue;            if (possessive) continue;
3218            for(;;)            for(;;)
3219              {              {
# Line 2967  for (;;) Line 3229  for (;;)
3229            {            {
3230            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3231              {              {
3232              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject)
3233                  {
3234                  SCHECK_PARTIAL();
3235                  break;
3236                  }
3237                if (fc == *eptr) break;
3238              eptr++;              eptr++;
3239              }              }
           CHECK_PARTIAL();  
3240            if (possessive) continue;            if (possessive) continue;
3241            while (eptr >= pp)            while (eptr >= pp)
3242              {              {
# Line 3077  for (;;) Line 3343  for (;;)
3343            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
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              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3352              }              }
3353            break;            break;
# Line 3089  for (;;) Line 3355  for (;;)
3355            case PT_LAMP:            case PT_LAMP:
3356            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3357              {              {
3358              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3359                {                {
3360                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3361                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3362                }                }
3363              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3364              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3365              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 3106  for (;;) Line 3372  for (;;)
3372            case PT_GC:            case PT_GC:
3373            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3374              {              {
3375              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3376                {                {
3377                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3378                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3379                }                }
3380              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3381              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3382              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 3121  for (;;) Line 3387  for (;;)
3387            case PT_PC:            case PT_PC:
3388            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3389              {              {
3390              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3391                {                {
3392                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3393                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3394                }                }
3395              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3396              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3397              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 3136  for (;;) Line 3402  for (;;)
3402            case PT_SC:            case PT_SC:
3403            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3404              {              {
3405              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3406                {                {
3407                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3408                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3409                }                }
3410              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3411              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3412              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 3160  for (;;) Line 3426  for (;;)
3426          {          {
3427          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3428            {            {
3429            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3430              {              {
3431              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3432              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3433              }              }
3434            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3435            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3436            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
# Line 3193  for (;;) Line 3459  for (;;)
3459            {            {
3460            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3461              {              {
3462              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3463              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3464              }              }
3465            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3466            eptr++;            eptr++;
3467            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3205  for (;;) Line 3471  for (;;)
3471          case OP_ALLANY:          case OP_ALLANY:
3472          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3473            {            {
3474            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3475              {              {
3476              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3477              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3478              }              }
3479            eptr++;            eptr++;
3480            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3481            }            }
3482          break;          break;
3483    
3484          case OP_ANYBYTE:          case OP_ANYBYTE:
3485          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
3486          eptr += min;          eptr += min;
3487          break;          break;
3488    
3489          case OP_ANYNL:          case OP_ANYNL:
3490          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3491            {            {
3492            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3493              {              {
3494              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3495              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3496              }              }
3497            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3498            switch(c)            switch(c)
3499              {              {
# Line 3253  for (;;) Line 3519  for (;;)
3519          case OP_NOT_HSPACE:          case OP_NOT_HSPACE:
3520          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3521            {            {
3522            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3523              {              {
3524              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3525              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3526              }              }
3527            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3528            switch(c)            switch(c)
3529              {              {
# Line 3289  for (;;) Line 3555  for (;;)
3555          case OP_HSPACE:          case OP_HSPACE:
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            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3564            switch(c)            switch(c)
3565              {              {
# Line 3325  for (;;) Line 3591  for (;;)
3591          case OP_NOT_VSPACE:          case OP_NOT_VSPACE:
3592          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3593            {            {
3594            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3595              {              {
3596              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3597              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3598              }              }
3599            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3600            switch(c)            switch(c)
3601              {              {
# Line 3349  for (;;) Line 3615  for (;;)
3615          case OP_VSPACE:          case OP_VSPACE:
3616          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3617            {            {
3618            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3619              {              {
3620              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3621              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3622              }              }
3623            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3624            switch(c)            switch(c)
3625              {              {
# Line 3373  for (;;) Line 3639  for (;;)
3639          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3640          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3641            {            {
3642            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3643              {              {
3644              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3645              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3646              }              }
3647            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3648            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3649              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
# Line 3387  for (;;) Line 3653  for (;;)
3653          case OP_DIGIT:          case OP_DIGIT:
3654          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3655            {            {
3656            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3657              {              {
3658              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3659              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3660              }              }
3661            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3662              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3663            /* 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 3667  for (;;)
3667          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
3668          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3669            {            {
3670            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3671              {              {
3672              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3673              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3674              }              }
3675            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3676              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3677            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
# Line 3415  for (;;) Line 3681  for (;;)
3681          case OP_WHITESPACE:          case OP_WHITESPACE:
3682          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3683            {            {
3684            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3685              {              {
3686              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3687              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3688              }              }
3689            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3690              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3691            /* 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 3705  for (;;)
3705          case OP_WORDCHAR:          case OP_WORDCHAR:
3706          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3707            {            {
3708            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3709              {              {
3710              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3711              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3712              }              }
3713            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3714              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3715            /* 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 3731  for (;;)
3731          case OP_ANY:          case OP_ANY:
3732          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3733            {            {
3734            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3735              {              {
3736              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3737              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3738              }              }
3739            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3740            eptr++;            eptr++;
3741            }            }
3742          break;          break;
3743    
3744          case OP_ALLANY:          case OP_ALLANY:
3745          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3746              {
3747              SCHECK_PARTIAL();
3748              RRETURN(MATCH_NOMATCH);
3749              }
3750          eptr += min;          eptr += min;
3751          break;          break;
3752    
3753          case OP_ANYBYTE:          case OP_ANYBYTE:
3754          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3755              {
3756              SCHECK_PARTIAL();
3757              RRETURN(MATCH_NOMATCH);
3758              }
3759          eptr += min;          eptr += min;
3760          break;          break;
3761    
3762          case OP_ANYNL:          case OP_ANYNL:
3763          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3764            {            {
3765            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3766              {              {
3767              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3768              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3769              }              }
3770            switch(*eptr++)            switch(*eptr++)
3771              {              {
3772              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
# Line 3514  for (;;) Line 3788  for (;;)
3788          case OP_NOT_HSPACE:          case OP_NOT_HSPACE:
3789          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3790            {            {
3791            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3792              {              {
3793              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3794              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3795              }              }
3796            switch(*eptr++)            switch(*eptr++)
3797              {              {
3798              default: break;              default: break;
# Line 3533  for (;;) Line 3807  for (;;)
3807          case OP_HSPACE:          case OP_HSPACE:
3808          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3809            {            {
3810            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3811              {              {
3812              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3813              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3814              }              }
3815            switch(*eptr++)            switch(*eptr++)
3816              {              {
3817              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
# Line 3552  for (;;) Line 3826  for (;;)
3826          case OP_NOT_VSPACE:          case OP_NOT_VSPACE:
3827          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3828            {            {
3829            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3830              {              {
3831              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3832              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3833              }              }
3834            switch(*eptr++)            switch(*eptr++)
3835              {              {
3836              default: break;              default: break;
# Line 3573  for (;;) Line 3847  for (;;)
3847          case OP_VSPACE:          case OP_VSPACE:
3848          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3849            {            {
3850            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3851              {              {
3852              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3853              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3854              }              }
3855            switch(*eptr++)            switch(*eptr++)
3856              {              {
3857              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
# Line 3593  for (;;) Line 3867  for (;;)
3867    
3868          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3869          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3870            {            {
3871            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3872              {              {
3873              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3874              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3875              }              }
3876            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
3877            }            }
3878          break;          break;
3879    
3880          case OP_DIGIT:          case OP_DIGIT:
3881          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3882            {            {
3883            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3884              {              {
3885              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3886              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3887              }              }
3888            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
3889            }            }
3890          break;          break;
3891    
3892          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
3893          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3894            {            {
3895            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3896              {              {
3897              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3898              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3899              }              }
3900            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
3901            }            }
3902          break;          break;
3903    
3904          case OP_WHITESPACE:          case OP_WHITESPACE:
3905          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3906            {            {
3907            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3908              {              {
3909              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3910              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3911              }              }
3912            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
3913            }            }
3914          break;          break;
3915    
3916          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3917          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3918            {            {
3919            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3920              {              {
3921              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3922              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3923              }              }
3924            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
3925              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3926            }            }
3927          break;          break;
3928    
3929          case OP_WORDCHAR:          case OP_WORDCHAR:
3930          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3931            {            {
3932            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3933              {              {
3934              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3935              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3936              }              }
3937            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
3938              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3939            }            }
3940          break;          break;
3941    
3942          default:          default:
# Line 3690  for (;;) Line 3964  for (;;)
3964              {              {
3965              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
3966              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3967              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3968                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3969                {                {
3970                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3971                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3972                }                }
3973              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3974              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3975              }              }
# Line 3710  for (;;) Line 3980  for (;;)
3980              {              {
3981              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
3982              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3983              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
3984                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
3985                {                {
3986                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3987                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3988                }                }
3989              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3990              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3991              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 3734  for (;;) Line 4000  for (;;)
4000              {              {
4001              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4002              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4003              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
4004                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
4005                {                {
4006                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4007                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4008                }                }
4009              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4010              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4011              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 3756  for (;;) Line 4018  for (;;)
4018              {              {
4019              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4020              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4021              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
4022                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
4023                {                {
4024                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4025                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4026                }                }
4027              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4028              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4029              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 3778  for (;;) Line 4036  for (;;)
4036              {              {
4037              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4038              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4039              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
4040                {              if (eptr >= md->end_subject)
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             if (eptr >= md->end_subject)  
4041                {                {
4042                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4043                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4044                }                }
4045              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4046              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4047              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 3809  for (;;) Line 4063  for (;;)
4063            {            {
4064            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4065            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4066            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
4067              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
4068              {              {
4069              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4070              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4071              }              }
4072            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4073            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4074            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
# Line 3845  for (;;) Line 4095  for (;;)
4095            {            {
4096            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4097            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4098            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
4099              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
4100              {              {
4101              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4102              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4103              }              }
4104            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4105              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4106            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
# Line 4012  for (;;) Line 4258  for (;;)
4258            {            {
4259            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4260            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4261            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
4262              {            if (eptr >= md->end_subject)
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
           if (eptr >= md->end_subject)  
4263              {              {
4264              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4265              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4266              }              }
4267            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4268              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4269            c = *eptr++;            c = *eptr++;
# Line 4148  for (;;) Line 4390  for (;;)
4390            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4391              {              {
4392              int len = 1;              int len = 1;
4393              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4394                  {
4395                  SCHECK_PARTIAL();
4396                  break;
4397                  }
4398              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4399              if (prop_fail_result) break;              if (prop_fail_result) break;
4400              eptr+= len;              eptr+= len;
# Line 4159  for (;;) Line 4405  for (;;)
4405            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4406              {              {
4407              int len = 1;              int len = 1;
4408              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4409                  {
4410                  SCHECK_PARTIAL();
4411                  break;
4412                  }
4413              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4414              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4415              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 4174  for (;;) Line 4424  for (;;)
4424            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4425              {              {
4426              int len = 1;              int len = 1;
4427              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4428                  {
4429                  SCHECK_PARTIAL();
4430                  break;
4431                  }
4432              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4433              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4434              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 4187  for (;;) Line 4441  for (;;)
4441            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4442              {              {
4443              int len = 1;              int len = 1;
4444              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4445                  {
4446                  SCHECK_PARTIAL();
4447                  break;
4448                  }
4449              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4450              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4451              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 4200  for (;;) Line 4458  for (;;)
4458            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4459              {              {
4460              int len = 1;              int len = 1;
4461              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4462                  {
4463                  SCHECK_PARTIAL();
4464                  break;
4465                  }
4466              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4467              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4468              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 4212  for (;;) Line 4474  for (;;)
4474    
4475          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4476    
         CHECK_PARTIAL();  
4477          if (possessive) continue;          if (possessive) continue;
4478          for(;;)          for(;;)
4479            {            {
# Line 4230  for (;;) Line 4491  for (;;)
4491          {          {
4492          for (i = min; i < max; i++)          for (i = min; i < max; i++)
4493            {            {
4494            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
4495                {
4496                SCHECK_PARTIAL();
4497                break;
4498                }
4499            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4500            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4501            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
# Line 4249  for (;;) Line 4514  for (;;)
4514    
4515          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4516    
         CHECK_PARTIAL();  
4517          if (possessive) continue;          if (possessive) continue;
4518    
4519          for(;;)          for(;;)
4520            {            {
4521            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
# Line 4286  for (;;) Line 4551  for (;;)
4551              {              {
4552              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4553                {                {
4554                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4555                    {
4556                    SCHECK_PARTIAL();
4557                    break;
4558                    }
4559                  if (IS_NEWLINE(eptr)) break;
4560                eptr++;                eptr++;
4561                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4562                }                }
# Line 4298  for (;;) Line 4568  for (;;)
4568              {              {
4569              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4570                {                {
4571                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4572                    {
4573                    SCHECK_PARTIAL();
4574                    break;
4575                    }
4576                  if (IS_NEWLINE(eptr)) break;
4577                eptr++;                eptr++;
4578                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4579                }                }
# Line 4310  for (;;) Line 4585  for (;;)
4585              {              {
4586              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4587                {                {
4588                if (eptr >= md->end_subject) break;                if (eptr >= md->end_subject)
4589                    {
4590                    SCHECK_PARTIAL();
4591                    break;
4592                    }
4593                eptr++;                eptr++;
4594                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4595                }                }
# Line 4323  for (;;) Line 4602  for (;;)
4602            case OP_ANYBYTE:            case OP_ANYBYTE:
4603            c = max - min;            c = max - min;
4604            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
4605              c = md->end_subject - eptr;              {
4606            eptr += c;              eptr = md->end_subject;
4607                SCHECK_PARTIAL();
4608                }
4609              else eptr += c;
4610            break;            break;
4611    
4612            case OP_ANYNL:            case OP_ANYNL:
4613            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4614              {              {
4615              int len = 1;              int len = 1;
4616              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4617                  {
4618                  SCHECK_PARTIAL();
4619                  break;
4620                  }
4621              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4622              if (c == 0x000d)              if (c == 0x000d)
4623                {                {
# Line 4356  for (;;) Line 4642  for (;;)
4642              {              {
4643              BOOL gotspace;              BOOL gotspace;
4644              int len = 1;              int len = 1;
4645              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4646                  {
4647                  SCHECK_PARTIAL();
4648                  break;
4649                  }
4650              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4651              switch(c)              switch(c)
4652                {                {
# Line 4394  for (;;) Line 4684  for (;;)
4684              {              {
4685              BOOL gotspace;              BOOL gotspace;
4686              int len = 1;              int len = 1;
4687              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4688                  {
4689                  SCHECK_PARTIAL();
4690                  break;
4691                  }
4692              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4693              switch(c)              switch(c)
4694                {                {
# Line 4418  for (;;) Line 4712  for (;;)
4712            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4713              {              {
4714              int len = 1;              int len = 1;
4715              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4716                  {
4717                  SCHECK_PARTIAL();
4718                  break;
4719                  }
4720              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4721              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
4722              eptr+= len;              eptr+= len;
# Line 4429  for (;;) Line 4727  for (;;)
4727            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4728              {              {
4729              int len = 1;              int len = 1;
4730              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4731                  {
4732                  SCHECK_PARTIAL();
4733                  break;
4734                  }
4735              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4736              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
4737              eptr+= len;              eptr+= len;
# Line 4440  for (;;) Line 4742  for (;;)
4742            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4743              {              {
4744              int len = 1;              int len = 1;
4745              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4746                  {
4747                  SCHECK_PARTIAL();
4748                  break;
4749                  }
4750              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4751              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
4752              eptr+= len;              eptr+= len;
# Line 4451  for (;;) Line 4757  for (;;)
4757            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4758              {              {
4759              int len = 1;              int len = 1;
4760              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4761                  {
4762                  SCHECK_PARTIAL();
4763                  break;
4764                  }
4765              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4766              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
4767              eptr+= len;              eptr+= len;
# Line 4462  for (;;) Line 4772  for (;;)
4772            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4773              {              {
4774              int len = 1;              int len = 1;
4775              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4776                  {
4777                  SCHECK_PARTIAL();
4778                  break;
4779                  }
4780              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4781              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
4782              eptr+= len;              eptr+= len;
# Line 4473  for (;;) Line 4787  for (;;)
4787            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4788              {              {
4789              int len = 1;              int len = 1;
4790              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4791                  {
4792                  SCHECK_PARTIAL();
4793                  break;
4794                  }
4795              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4796              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
4797              eptr+= len;              eptr+= len;
# Line 4486  for (;;) Line 4804  for (;;)
4804    
4805          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4806    
         CHECK_PARTIAL();  
4807          if (possessive) continue;          if (possessive) continue;
4808          for(;;)          for(;;)
4809            {            {
# Line 4506  for (;;) Line 4823  for (;;)
4823            case OP_ANY:            case OP_ANY:
4824            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4825              {              {
4826              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;              if (eptr >= md->end_subject)
4827                  {
4828                  SCHECK_PARTIAL();
4829                  break;
4830                  }
4831                if (IS_NEWLINE(eptr)) break;
4832              eptr++;              eptr++;
4833              }              }
4834            break;            break;
# Line 4515  for (;;) Line 4837  for (;;)
4837            case OP_ANYBYTE:            case OP_ANYBYTE:
4838            c = max - min;            c = max - min;
4839            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
4840              c = md->end_subject - eptr;              {
4841            eptr += c;              eptr = md->end_subject;
4842                SCHECK_PARTIAL();
4843                }
4844              else eptr += c;
4845            break;            break;
4846    
4847            case OP_ANYNL:            case OP_ANYNL:
4848            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4849              {              {
4850              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4851                  {
4852                  SCHECK_PARTIAL();
4853                  break;
4854                  }
4855              c = *eptr;              c = *eptr;
4856              if (c == 0x000d)              if (c == 0x000d)
4857                {                {
# Line 4543  for (;;) Line 4872  for (;;)
4872            case OP_NOT_HSPACE:            case OP_NOT_HSPACE:
4873            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4874              {              {
4875              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4876                  {
4877                  SCHECK_PARTIAL();
4878                  break;
4879                  }
4880              c = *eptr;              c = *eptr;
4881              if (c == 0x09 || c == 0x20 || c == 0xa0) break;              if (c == 0x09 || c == 0x20 || c == 0xa0) break;
4882              eptr++;              eptr++;
# Line 4553  for (;;) Line 4886  for (;;)
4886            case OP_HSPACE:            case OP_HSPACE:
4887            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4888              {              {
4889              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4890                  {
4891                  SCHECK_PARTIAL();
4892                  break;
4893                  }
4894              c = *eptr;              c = *eptr;
4895              if (c != 0x09 && c != 0x20 && c != 0xa0) break;              if (c != 0x09 && c != 0x20 && c != 0xa0) break;
4896              eptr++;              eptr++;
# Line 4563  for (;;) Line 4900  for (;;)
4900            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
4901            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4902              {              {
4903              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4904                  {
4905                  SCHECK_PARTIAL();
4906                  break;
4907                  }
4908              c = *eptr;              c = *eptr;
4909              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
4910                break;                break;
# Line 4574  for (;;) Line 4915  for (;;)
4915            case OP_VSPACE:            case OP_VSPACE:
4916            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4917              {              {
4918              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4919                  {
4920                  SCHECK_PARTIAL();
4921                  break;
4922                  }
4923              c = *eptr;              c = *eptr;
4924              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
4925                break;                break;
# Line 4585  for (;;) Line 4930  for (;;)
4930            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4931            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4932              {              {
4933              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)              if (eptr >= md->end_subject)
4934                  {
4935                  SCHECK_PARTIAL();
4936                break;                break;
4937                  }
4938                if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
4939              eptr++;              eptr++;
4940              }              }
4941            break;            break;
# Line 4594  for (;;) Line 4943  for (;;)
4943            case OP_DIGIT:            case OP_DIGIT:
4944            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4945              {              {
4946              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)              if (eptr >= md->end_subject)
4947                  {
4948                  SCHECK_PARTIAL();
4949                break;                break;
4950                  }
4951                if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
4952              eptr++;              eptr++;
4953              }              }
4954            break;            break;
# Line 4603  for (;;) Line 4956  for (;;)
4956            case OP_NOT_WHITESPACE:            case OP_NOT_WHITESPACE:
4957            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4958              {              {
4959              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)              if (eptr >= md->end_subject)
4960                  {
4961                  SCHECK_PARTIAL();
4962                break;                break;
4963                  }
4964                if ((md->ctypes[*eptr] & ctype_space) != 0) break;
4965              eptr++;              eptr++;
4966              }              }
4967            break;            break;
# Line 4612  for (;;) Line 4969  for (;;)
4969            case OP_WHITESPACE:            case OP_WHITESPACE:
4970            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4971              {              {
4972              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)              if (eptr >= md->end_subject)
4973                  {
4974                  SCHECK_PARTIAL();
4975                break;                break;
4976                  }
4977                if ((md->ctypes[*eptr] & ctype_space) == 0) break;
4978              eptr++;              eptr++;
4979              }              }
4980            break;            break;
# Line 4621  for (;;) Line 4982  for (;;)
4982            case OP_NOT_WORDCHAR:            case OP_NOT_WORDCHAR:
4983            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4984              {              {
4985              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)              if (eptr >= md->end_subject)
4986                  {
4987                  SCHECK_PARTIAL();
4988                break;                break;
4989                  }
4990                if ((md->ctypes[*eptr] & ctype_word) != 0) break;
4991              eptr++;              eptr++;
4992              }              }
4993            break;            break;
# Line 4630  for (;;) Line 4995  for (;;)
4995            case OP_WORDCHAR:            case OP_WORDCHAR:
4996            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4997              {              {
4998              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)              if (eptr >= md->end_subject)
4999                  {
5000                  SCHECK_PARTIAL();
5001                break;                break;
5002                  }
5003                if ((md->ctypes[*eptr] & ctype_word) == 0) break;
5004              eptr++;              eptr++;
5005              }              }
5006            break;            break;
# Line 4642  for (;;) Line 5011  for (;;)
5011    
5012          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
5013    
         CHECK_PARTIAL();  
5014          if (possessive) continue;          if (possessive) continue;
5015          while (eptr >= pp)          while (eptr >= pp)
5016            {            {
# Line 4827  if (re == NULL || subject == NULL || Line 5195  if (re == NULL || subject == NULL ||
5195     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
5196  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5197    
5198    /* This information is for finding all the numbers associated with a given
5199    name, for condition testing. */
5200    
5201    md->name_table = (uschar *)re + re->name_table_offset;
5202    md->name_count = re->name_count;
5203    md->name_entry_size = re->name_entry_size;
5204    
5205  /* Fish out the optional data from the extra_data structure, first setting  /* Fish out the optional data from the extra_data structure, first setting
5206  the default values. */  the default values. */
5207    
# Line 4894  md->jscript_compat = (re->options & PCRE Line 5269  md->jscript_compat = (re->options & PCRE
5269  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
5270  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
5271  md->notempty = (options & PCRE_NOTEMPTY) != 0;  md->notempty = (options & PCRE_NOTEMPTY) != 0;
5272  md->partial = (options & PCRE_PARTIAL) != 0;  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
5273    md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5274                  ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5275  md->hitend = FALSE;  md->hitend = FALSE;
5276    
5277  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
# Line 5057  if (!anchored) Line 5434  if (!anchored)
5434      }      }
5435    else    else
5436      if (!startline && study != NULL &&      if (!startline && study != NULL &&
5437        (study->options & PCRE_STUDY_MAPPED) != 0)        (study->flags & PCRE_STUDY_MAPPED) != 0)
5438          start_bits = study->start_bits;          start_bits = study->start_bits;
5439    }    }
5440    
# Line 5184  for(;;) Line 5561  for(;;)
5561    
5562    end_subject = save_end_subject;    end_subject = save_end_subject;
5563    
5564  #ifdef DEBUG  /* Sigh. Some compilers never learn. */    /* The following two optimizations are disabled for partial matching or if
   printf(">>>> Match against: ");  
   pchars(start_match, end_subject - start_match, TRUE, md);  
   printf("\n");  
 #endif  
   
   /* If req_byte is set, we know that that character must appear in the  
   subject for the match to succeed. If the first character is set, req_byte  
   must be later in the subject; otherwise the test starts at the match point.  
   This optimization can save a huge amount of backtracking in patterns with  
   nested unlimited repeats that aren't going to match. Writing separate code  
   for cased/caseless versions makes it go faster, as does using an  
   autoincrement and backing off on a match.  
   
   HOWEVER: when the subject string is very, very long, searching to its end  
   can take a long time, and give bad performance on quite ordinary patterns.  
   This showed up when somebody was matching something like /^\d+C/ on a  
   32-megabyte string... so we don't do this when the string is sufficiently  
   long.  
   
   ALSO: this processing is disabled when partial matching is requested, or if  
5565    disabling is explicitly requested. */    disabling is explicitly requested. */
5566    
5567    if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&    if ((options & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
       req_byte >= 0 &&  
       end_subject - start_match < REQ_BYTE_MAX &&  
       !md->partial)  
5568      {      {
5569      register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);      /* If the pattern was studied, a minimum subject length may be set. This is
5570        a lower bound; no actual string of that length may actually match the
5571        pattern. Although the value is, strictly, in characters, we treat it as
5572        bytes to avoid spending too much time in this optimization. */
5573    
5574      /* We don't need to repeat the search if we haven't yet reached the      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5575      place we found it at last time. */          end_subject - start_match < study->minlength)
5576          {
5577          rc = MATCH_NOMATCH;
5578          break;
5579          }
5580    
5581      if (p > req_byte_ptr)      /* If req_byte is set, we know that that character must appear in the
5582        subject for the match to succeed. If the first character is set, req_byte
5583        must be later in the subject; otherwise the test starts at the match point.
5584        This optimization can save a huge amount of backtracking in patterns with
5585        nested unlimited repeats that aren't going to match. Writing separate code
5586        for cased/caseless versions makes it go faster, as does using an
5587        autoincrement and backing off on a match.
5588    
5589        HOWEVER: when the subject string is very, very long, searching to its end
5590        can take a long time, and give bad performance on quite ordinary patterns.
5591        This showed up when somebody was matching something like /^\d+C/ on a
5592        32-megabyte string... so we don't do this when the string is sufficiently
5593        long. */
5594    
5595        if (req_byte >= 0 && end_subject - start_match < REQ_BYTE_MAX)
5596        {        {
5597        if (req_byte_caseless)        register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);
5598    
5599          /* We don't need to repeat the search if we haven't yet reached the
5600          place we found it at last time. */
5601    
5602          if (p > req_byte_ptr)
5603          {          {
5604          while (p < end_subject)          if (req_byte_caseless)
5605            {            {
5606            register int pp = *p++;            while (p < end_subject)
5607            if (pp == req_byte || pp == req_byte2) { p--; break; }              {
5608                register int pp = *p++;
5609                if (pp == req_byte || pp == req_byte2) { p--; break; }
5610                }
5611            }            }
5612          }          else
       else  
         {  
         while (p < end_subject)  
5613            {            {
5614            if (*p++ == req_byte) { p--; break; }            while (p < end_subject)
5615                {
5616                if (*p++ == req_byte) { p--; break; }
5617                }
5618            }            }
         }  
5619    
5620        /* If we can't find the required character, break the matching loop,          /* If we can't find the required character, break the matching loop,
5621        forcing a match failure. */          forcing a match failure. */
5622    
5623        if (p >= end_subject)          if (p >= end_subject)
5624          {            {
5625          rc = MATCH_NOMATCH;            rc = MATCH_NOMATCH;
5626          break;            break;
5627          }            }
5628    
5629        /* If we have found the required character, save the point where we          /* If we have found the required character, save the point where we
5630        found it, so that we don't search again next time round the loop if          found it, so that we don't search again next time round the loop if
5631        the start hasn't passed this character yet. */          the start hasn't passed this character yet. */
5632    
5633        req_byte_ptr = p;          req_byte_ptr = p;
5634            }
5635        }        }
5636      }      }
5637    
5638    /* OK, we can now run the match. If "hitend" is set afterwards, remember the  #ifdef DEBUG  /* Sigh. Some compilers never learn. */
5639      printf(">>>> Match against: ");
5640      pchars(start_match, end_subject - start_match, TRUE, md);
5641      printf("\n");
5642    #endif
5643    
5644      /* OK, we can now run the match. If "hitend" is set afterwards, remember the
5645    first starting point for which a partial match was found. */    first starting point for which a partial match was found. */
5646    
5647    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5648      md->start_used_ptr = start_match;
5649    md->match_call_count = 0;    md->match_call_count = 0;
5650    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);
5651    if (md->hitend && start_partial == NULL) start_partial = start_match;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
5652    
5653    switch(rc)    switch(rc)
5654      {      {
# Line 5288  for(;;) Line 5678  for(;;)
5678      rc = MATCH_NOMATCH;      rc = MATCH_NOMATCH;
5679      goto ENDLOOP;      goto ENDLOOP;
5680    
5681      /* Any other return is some kind of error. */      /* Any other return is either a match, or some kind of error. */
5682    
5683      default:      default:
5684      goto ENDLOOP;      goto ENDLOOP;
# Line 5394  if (using_temporary_offsets) Line 5784  if (using_temporary_offsets)
5784    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
5785    }    }
5786    
5787  if (rc != MATCH_NOMATCH)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
5788    {    {
5789    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
5790    return rc;    return rc;
5791    }    }
5792  else if (md->partial && start_partial != NULL)  else if (start_partial != NULL)
5793    {    {
5794    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
5795    if (offsetcount > 1)    if (offsetcount > 1)
5796      {      {
5797      offsets[0] = start_partial - (USPTR)subject;      offsets[0] = start_partial - (USPTR)subject;
5798      offsets[1] = end_subject - (USPTR)subject;      offsets[1] = end_subject - (USPTR)subject;
5799      }      }
5800    return PCRE_ERROR_PARTIAL;    return PCRE_ERROR_PARTIAL;
5801    }    }
5802  else  else

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

  ViewVC Help
Powered by ViewVC 1.1.5