/[pcre]/code/branches/pcre16/pcre_exec.c
ViewVC logotype

Diff of /code/branches/pcre16/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 427 by ph10, Fri Aug 28 09:55:54 2009 UTC revision 482 by ph10, Mon Jan 4 15:55:46 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 89  static const char rep_max[] = { 0, 0, 0, Line 89  static const char rep_max[] = { 0, 0, 0,
89    
90    
91    
92  #ifdef DEBUG  #ifdef PCRE_DEBUG
93  /*************************************************  /*************************************************
94  *        Debugging function to print chars       *  *        Debugging function to print chars       *
95  *************************************************/  *************************************************/
# Line 141  match_ref(int offset, register USPTR ept Line 141  match_ref(int offset, register USPTR ept
141  {  {
142  USPTR p = md->start_subject + md->offset_vector[offset];  USPTR p = md->start_subject + md->offset_vector[offset];
143    
144  #ifdef DEBUG  #ifdef PCRE_DEBUG
145  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
146    printf("matching subject <null>");    printf("matching subject <null>");
147  else  else
# Line 254  actuall used in this definition. */ Line 254  actuall used in this definition. */
254  #ifndef NO_RECURSE  #ifndef NO_RECURSE
255  #define REGISTER register  #define REGISTER register
256    
257  #ifdef DEBUG  #ifdef PCRE_DEBUG
258  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
259    { \    { \
260    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
# Line 408  immediately. The second one is used when Line 408  immediately. The second one is used when
408  the subject. */  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      {\      {\
413      md->hitend = TRUE;\      md->hitend = TRUE;\
414      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
415      }      }
416    
417  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
418    if (md->partial && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
419      {\      {\
420      md->hitend = TRUE;\      md->hitend = TRUE;\
     md->hitend = TRUE;\  
421      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
422      }      }
423    
# Line 623  TAIL_RECURSE: Line 622  TAIL_RECURSE:
622  /* OK, now we can get on with the real code of the function. Recursive calls  /* OK, now we can get on with the real code of the function. Recursive calls
623  are specified by the macro RMATCH and RRETURN is used to return. When  are specified by the macro RMATCH and RRETURN is used to return. When
624  NO_RECURSE is *not* defined, these just turn into a recursive call to match()  NO_RECURSE is *not* defined, these just turn into a recursive call to match()
625  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
626  defined). However, RMATCH isn't like a function call because it's quite a  defined). However, RMATCH isn't like a function call because it's quite a
627  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
628  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# Line 665  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 720  for (;;) Line 713  for (;;)
713      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
714      offset = number << 1;      offset = number << 1;
715    
716  #ifdef DEBUG  #ifdef PCRE_DEBUG
717      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
718      printf("subject=");      printf("subject=");
719      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# Line 846  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 918  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 PCRE_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 931  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 985  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 994  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 1031  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 1112  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 1311  for (;;) Line 1468  for (;;)
1468        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1469        offset = number << 1;        offset = number << 1;
1470    
1471  #ifdef DEBUG  #ifdef PCRE_DEBUG
1472        printf("end bracket %d", number);        printf("end bracket %d", number);
1473        printf("\n");        printf("\n");
1474  #endif  #endif
# Line 1336  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 1475  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 1484  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 1496  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 1520  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 1529  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 1547  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 1560  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 1573  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 1586  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 1599  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 1612  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 1636  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 1666  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 1696  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 1714  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 1737  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 1782  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 1862  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 1899  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);
# Line 1916  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 1931  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 1989  for (;;) Line 2227  for (;;)
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);
# Line 2011  for (;;) Line 2249  for (;;)
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++;
# Line 2037  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);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2279              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2280                {                {
2281                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 2066  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);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2304              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2305                {                {
2306                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 2096  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 2108  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 2123  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 2209  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);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2449            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2450              {              {
2451              SCHECK_PARTIAL();              SCHECK_PARTIAL();
# Line 2233  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 2262  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 2270  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 2286  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 2321  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 2375  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 2427  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 2460  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(;;)
# Line 2524  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();
# Line 2543  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)
# Line 2574  for (;;) Line 2825  for (;;)
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();
# Line 2600  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 2620  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 2763  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);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3025              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3026                {                {
3027                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 2786  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 2816  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                  {
3071                  SCHECK_PARTIAL();
3072                  break;
3073                  }
3074              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3075              if (d < 256) d = md->lcc[d];              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 2838  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 2904  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);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3165              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3166                {                {
3167                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 2926  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();
# Line 2956  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 2977  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 3439  for (;;) Line 3695  for (;;)
3695          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3696          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3697            {            {
3698            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3699               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3700                SCHECK_PARTIAL();
3701                RRETURN(MATCH_NOMATCH);
3702                }
3703              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3704              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3705            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3706            }            }
# Line 3486  for (;;) Line 3746  for (;;)
3746          break;          break;
3747    
3748          case OP_ALLANY:          case OP_ALLANY:
3749          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3750              {
3751              SCHECK_PARTIAL();
3752              RRETURN(MATCH_NOMATCH);
3753              }
3754          eptr += min;          eptr += min;
3755          break;          break;
3756    
3757          case OP_ANYBYTE:          case OP_ANYBYTE:
3758          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3759              {
3760              SCHECK_PARTIAL();
3761              RRETURN(MATCH_NOMATCH);
3762              }
3763          eptr += min;          eptr += min;
3764          break;          break;
3765    
# Line 3700  for (;;) Line 3968  for (;;)
3968              {              {
3969              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
3970              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3971              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3972              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3973                {                {
3974                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 3720  for (;;) Line 3984  for (;;)
3984              {              {
3985              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
3986              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3987              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3988              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3989                {                {
3990                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 3744  for (;;) Line 4004  for (;;)
4004              {              {
4005              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4006              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4007              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4008              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4009                {                {
4010                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 3766  for (;;) Line 4022  for (;;)
4022              {              {
4023              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4024              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4025              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4026              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4027                {                {
4028                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 3788  for (;;) Line 4040  for (;;)
4040              {              {
4041              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4042              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4043              if (fi >= max)              if (fi >= max) RRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4044              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4045                {                {
4046                SCHECK_PARTIAL();                SCHECK_PARTIAL();
# Line 3819  for (;;) Line 4067  for (;;)
4067            {            {
4068            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4069            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4070            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
4071            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4072              {              {
4073              SCHECK_PARTIAL();              SCHECK_PARTIAL();
# Line 3855  for (;;) Line 4099  for (;;)
4099            {            {
4100            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4101            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4102            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
4103            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4104              {              {
4105              SCHECK_PARTIAL();              SCHECK_PARTIAL();
# Line 4022  for (;;) Line 4262  for (;;)
4262            {            {
4263            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4264            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4265            if (fi >= max)            if (fi >= max) RRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
4266            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4267              {              {
4268              SCHECK_PARTIAL();              SCHECK_PARTIAL();
# Line 4158  for (;;) Line 4394  for (;;)
4394            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4395              {              {
4396              int len = 1;              int len = 1;
4397              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4398                  {
4399                  SCHECK_PARTIAL();
4400                  break;
4401                  }
4402              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4403              if (prop_fail_result) break;              if (prop_fail_result) break;
4404              eptr+= len;              eptr+= len;
# Line 4169  for (;;) Line 4409  for (;;)
4409            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4410              {              {
4411              int len = 1;              int len = 1;
4412              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4413                  {
4414                  SCHECK_PARTIAL();
4415                  break;
4416                  }
4417              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4418              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4419              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 4184  for (;;) Line 4428  for (;;)
4428            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4429              {              {
4430              int len = 1;              int len = 1;
4431              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4432                  {
4433                  SCHECK_PARTIAL();
4434                  break;
4435                  }
4436              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4437              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4438              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 4197  for (;;) Line 4445  for (;;)
4445            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4446              {              {
4447              int len = 1;              int len = 1;
4448              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4449                  {
4450                  SCHECK_PARTIAL();
4451                  break;
4452                  }
4453              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4454              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4455              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 4210  for (;;) Line 4462  for (;;)
4462            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4463              {              {
4464              int len = 1;              int len = 1;
4465              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4466                  {
4467                  SCHECK_PARTIAL();
4468                  break;
4469                  }
4470              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4471              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4472              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 4222  for (;;) Line 4478  for (;;)
4478    
4479          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4480    
         CHECK_PARTIAL();  
4481          if (possessive) continue;          if (possessive) continue;
4482          for(;;)          for(;;)
4483            {            {
# Line 4240  for (;;) Line 4495  for (;;)
4495          {          {
4496          for (i = min; i < max; i++)          for (i = min; i < max; i++)
4497            {            {
4498            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
4499                {
4500                SCHECK_PARTIAL();
4501                break;
4502                }
4503            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4504            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4505            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
# Line 4259  for (;;) Line 4518  for (;;)
4518    
4519          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4520    
         CHECK_PARTIAL();  
4521          if (possessive) continue;          if (possessive) continue;
4522    
4523          for(;;)          for(;;)
4524            {            {
4525            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
# Line 4296  for (;;) Line 4555  for (;;)
4555              {              {
4556              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4557                {                {
4558                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4559                    {
4560                    SCHECK_PARTIAL();
4561                    break;
4562                    }
4563                  if (IS_NEWLINE(eptr)) break;
4564                eptr++;                eptr++;
4565                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4566                }                }
# Line 4308  for (;;) Line 4572  for (;;)
4572              {              {
4573              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4574                {                {
4575                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4576                    {
4577                    SCHECK_PARTIAL();
4578                    break;
4579                    }
4580                  if (IS_NEWLINE(eptr)) break;
4581                eptr++;                eptr++;
4582                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4583                }                }
# Line 4320  for (;;) Line 4589  for (;;)
4589              {              {
4590              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4591                {                {
4592                if (eptr >= md->end_subject) break;                if (eptr >= md->end_subject)
4593                    {
4594                    SCHECK_PARTIAL();
4595                    break;
4596                    }
4597                eptr++;                eptr++;
4598                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4599                }                }
# Line 4333  for (;;) Line 4606  for (;;)
4606            case OP_ANYBYTE:            case OP_ANYBYTE:
4607            c = max - min;            c = max - min;
4608            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
4609              c = md->end_subject - eptr;              {
4610            eptr += c;              eptr = md->end_subject;
4611                SCHECK_PARTIAL();
4612                }
4613              else eptr += c;
4614            break;            break;
4615    
4616            case OP_ANYNL:            case OP_ANYNL:
4617            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4618              {              {
4619              int len = 1;              int len = 1;
4620              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4621                  {
4622                  SCHECK_PARTIAL();
4623                  break;
4624                  }
4625              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4626              if (c == 0x000d)              if (c == 0x000d)
4627                {                {
# Line 4366  for (;;) Line 4646  for (;;)
4646              {              {
4647              BOOL gotspace;              BOOL gotspace;
4648              int len = 1;              int len = 1;
4649              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4650                  {
4651                  SCHECK_PARTIAL();
4652                  break;
4653                  }
4654              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4655              switch(c)              switch(c)
4656                {                {
# Line 4404  for (;;) Line 4688  for (;;)
4688              {              {
4689              BOOL gotspace;              BOOL gotspace;
4690              int len = 1;              int len = 1;
4691              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4692                  {
4693                  SCHECK_PARTIAL();
4694                  break;
4695                  }
4696              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4697              switch(c)              switch(c)
4698                {                {
# Line 4428  for (;;) Line 4716  for (;;)
4716            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4717              {              {
4718              int len = 1;              int len = 1;
4719              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4720                  {
4721                  SCHECK_PARTIAL();
4722                  break;
4723                  }
4724              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4725              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
4726              eptr+= len;              eptr+= len;
# Line 4439  for (;;) Line 4731  for (;;)
4731            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4732              {              {
4733              int len = 1;              int len = 1;
4734              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4735                  {
4736                  SCHECK_PARTIAL();
4737                  break;
4738                  }
4739              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4740              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
4741              eptr+= len;              eptr+= len;
# Line 4450  for (;;) Line 4746  for (;;)
4746            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4747              {              {
4748              int len = 1;              int len = 1;
4749              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4750                  {
4751                  SCHECK_PARTIAL();
4752                  break;
4753                  }
4754              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4755              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
4756              eptr+= len;              eptr+= len;
# Line 4461  for (;;) Line 4761  for (;;)
4761            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4762              {              {
4763              int len = 1;              int len = 1;
4764              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4765                  {
4766                  SCHECK_PARTIAL();
4767                  break;
4768                  }
4769              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4770              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
4771              eptr+= len;              eptr+= len;
# Line 4472  for (;;) Line 4776  for (;;)
4776            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4777              {              {
4778              int len = 1;              int len = 1;
4779              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4780                  {
4781                  SCHECK_PARTIAL();
4782                  break;
4783                  }
4784              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4785              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
4786              eptr+= len;              eptr+= len;
# Line 4483  for (;;) Line 4791  for (;;)
4791            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4792              {              {
4793              int len = 1;              int len = 1;
4794              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4795                  {
4796                  SCHECK_PARTIAL();
4797                  break;
4798                  }
4799              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4800              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
4801              eptr+= len;              eptr+= len;
# Line 4496  for (;;) Line 4808  for (;;)
4808    
4809          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4810    
         CHECK_PARTIAL();  
4811          if (possessive) continue;          if (possessive) continue;
4812          for(;;)          for(;;)
4813            {            {
# Line 4516  for (;;) Line 4827  for (;;)
4827            case OP_ANY:            case OP_ANY:
4828            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4829              {              {
4830              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;              if (eptr >= md->end_subject)
4831                  {
4832                  SCHECK_PARTIAL();
4833                  break;
4834                  }
4835                if (IS_NEWLINE(eptr)) break;
4836              eptr++;              eptr++;
4837              }              }
4838            break;            break;
# Line 4525  for (;;) Line 4841  for (;;)
4841            case OP_ANYBYTE:            case OP_ANYBYTE:
4842            c = max - min;            c = max - min;
4843            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
4844              c = md->end_subject - eptr;              {
4845            eptr += c;              eptr = md->end_subject;
4846                SCHECK_PARTIAL();
4847                }
4848              else eptr += c;
4849            break;            break;
4850    
4851            case OP_ANYNL:            case OP_ANYNL:
4852            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4853              {              {
4854              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4855                  {
4856                  SCHECK_PARTIAL();
4857                  break;
4858                  }
4859              c = *eptr;              c = *eptr;
4860              if (c == 0x000d)              if (c == 0x000d)
4861                {                {
# Line 4553  for (;;) Line 4876  for (;;)
4876            case OP_NOT_HSPACE:            case OP_NOT_HSPACE:
4877            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4878              {              {
4879              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4880                  {
4881                  SCHECK_PARTIAL();
4882                  break;
4883                  }
4884              c = *eptr;              c = *eptr;
4885              if (c == 0x09 || c == 0x20 || c == 0xa0) break;              if (c == 0x09 || c == 0x20 || c == 0xa0) break;
4886              eptr++;              eptr++;
# Line 4563  for (;;) Line 4890  for (;;)
4890            case OP_HSPACE:            case OP_HSPACE:
4891            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4892              {              {
4893              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4894                  {
4895                  SCHECK_PARTIAL();
4896                  break;
4897                  }
4898              c = *eptr;              c = *eptr;
4899              if (c != 0x09 && c != 0x20 && c != 0xa0) break;              if (c != 0x09 && c != 0x20 && c != 0xa0) break;
4900              eptr++;              eptr++;
# Line 4573  for (;;) Line 4904  for (;;)
4904            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
4905            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4906              {              {
4907              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4908                  {
4909                  SCHECK_PARTIAL();
4910                  break;
4911                  }
4912              c = *eptr;              c = *eptr;
4913              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
4914                break;                break;
# Line 4584  for (;;) Line 4919  for (;;)
4919            case OP_VSPACE:            case OP_VSPACE:
4920            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4921              {              {
4922              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4923                  {
4924                  SCHECK_PARTIAL();
4925                  break;
4926                  }
4927              c = *eptr;              c = *eptr;
4928              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
4929                break;                break;
# Line 4595  for (;;) Line 4934  for (;;)
4934            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4935            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4936              {              {
4937              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)              if (eptr >= md->end_subject)
4938                  {
4939                  SCHECK_PARTIAL();
4940                break;                break;
4941                  }
4942                if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
4943              eptr++;              eptr++;
4944              }              }
4945            break;            break;
# Line 4604  for (;;) Line 4947  for (;;)
4947            case OP_DIGIT:            case OP_DIGIT:
4948            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4949              {              {
4950              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)              if (eptr >= md->end_subject)
4951                  {
4952                  SCHECK_PARTIAL();
4953                break;                break;
4954                  }
4955                if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
4956              eptr++;              eptr++;
4957              }              }
4958            break;            break;
# Line 4613  for (;;) Line 4960  for (;;)
4960            case OP_NOT_WHITESPACE:            case OP_NOT_WHITESPACE:
4961            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4962              {              {
4963              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)              if (eptr >= md->end_subject)
4964                  {
4965                  SCHECK_PARTIAL();
4966                break;                break;
4967                  }
4968                if ((md->ctypes[*eptr] & ctype_space) != 0) break;
4969              eptr++;              eptr++;
4970              }              }
4971            break;            break;
# Line 4622  for (;;) Line 4973  for (;;)
4973            case OP_WHITESPACE:            case OP_WHITESPACE:
4974            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4975              {              {
4976              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)              if (eptr >= md->end_subject)
4977                  {
4978                  SCHECK_PARTIAL();
4979                break;                break;
4980                  }
4981                if ((md->ctypes[*eptr] & ctype_space) == 0) break;
4982              eptr++;              eptr++;
4983              }              }
4984            break;            break;
# Line 4631  for (;;) Line 4986  for (;;)
4986            case OP_NOT_WORDCHAR:            case OP_NOT_WORDCHAR:
4987            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4988              {              {
4989              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)              if (eptr >= md->end_subject)
4990                  {
4991                  SCHECK_PARTIAL();
4992                break;                break;
4993                  }
4994                if ((md->ctypes[*eptr] & ctype_word) != 0) break;
4995              eptr++;              eptr++;
4996              }              }
4997            break;            break;
# Line 4640  for (;;) Line 4999  for (;;)
4999            case OP_WORDCHAR:            case OP_WORDCHAR:
5000            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5001              {              {
5002              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)              if (eptr >= md->end_subject)
5003                  {
5004                  SCHECK_PARTIAL();
5005                break;                break;
5006                  }
5007                if ((md->ctypes[*eptr] & ctype_word) == 0) break;
5008              eptr++;              eptr++;
5009              }              }
5010            break;            break;
# Line 4652  for (;;) Line 5015  for (;;)
5015    
5016          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
5017    
         CHECK_PARTIAL();  
5018          if (possessive) continue;          if (possessive) continue;
5019          while (eptr >= pp)          while (eptr >= pp)
5020            {            {
# Line 4837  if (re == NULL || subject == NULL || Line 5199  if (re == NULL || subject == NULL ||
5199     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
5200  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5201    
5202    /* This information is for finding all the numbers associated with a given
5203    name, for condition testing. */
5204    
5205    md->name_table = (uschar *)re + re->name_table_offset;
5206    md->name_count = re->name_count;
5207    md->name_entry_size = re->name_entry_size;
5208    
5209  /* Fish out the optional data from the extra_data structure, first setting  /* Fish out the optional data from the extra_data structure, first setting
5210  the default values. */  the default values. */
5211    
# Line 4904  md->jscript_compat = (re->options & PCRE Line 5273  md->jscript_compat = (re->options & PCRE
5273  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
5274  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
5275  md->notempty = (options & PCRE_NOTEMPTY) != 0;  md->notempty = (options & PCRE_NOTEMPTY) != 0;
5276    md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
5277  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5278                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5279  md->hitend = FALSE;  md->hitend = FALSE;
# Line 5068  if (!anchored) Line 5438  if (!anchored)
5438      }      }
5439    else    else
5440      if (!startline && study != NULL &&      if (!startline && study != NULL &&
5441        (study->options & PCRE_STUDY_MAPPED) != 0)        (study->flags & PCRE_STUDY_MAPPED) != 0)
5442          start_bits = study->start_bits;          start_bits = study->start_bits;
5443    }    }
5444    
# Line 5195  for(;;) Line 5565  for(;;)
5565    
5566    end_subject = save_end_subject;    end_subject = save_end_subject;
5567    
5568  #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  
5569    disabling is explicitly requested. */    disabling is explicitly requested. */
5570    
5571    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)  
5572      {      {
5573      register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);      /* If the pattern was studied, a minimum subject length may be set. This is
5574        a lower bound; no actual string of that length may actually match the
5575        pattern. Although the value is, strictly, in characters, we treat it as
5576        bytes to avoid spending too much time in this optimization. */
5577    
5578        if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5579            (pcre_uint32)(end_subject - start_match) < study->minlength)
5580          {
5581          rc = MATCH_NOMATCH;
5582          break;
5583          }
5584    
5585      /* We don't need to repeat the search if we haven't yet reached the      /* If req_byte is set, we know that that character must appear in the
5586      place we found it at last time. */      subject for the match to succeed. If the first character is set, req_byte
5587        must be later in the subject; otherwise the test starts at the match point.
5588        This optimization can save a huge amount of backtracking in patterns with
5589        nested unlimited repeats that aren't going to match. Writing separate code
5590        for cased/caseless versions makes it go faster, as does using an
5591        autoincrement and backing off on a match.
5592    
5593      if (p > req_byte_ptr)      HOWEVER: when the subject string is very, very long, searching to its end
5594        can take a long time, and give bad performance on quite ordinary patterns.
5595        This showed up when somebody was matching something like /^\d+C/ on a
5596        32-megabyte string... so we don't do this when the string is sufficiently
5597        long. */
5598    
5599        if (req_byte >= 0 && end_subject - start_match < REQ_BYTE_MAX)
5600        {        {
5601        if (req_byte_caseless)        register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);
5602    
5603          /* We don't need to repeat the search if we haven't yet reached the
5604          place we found it at last time. */
5605    
5606          if (p > req_byte_ptr)
5607          {          {
5608          while (p < end_subject)          if (req_byte_caseless)
5609            {            {
5610            register int pp = *p++;            while (p < end_subject)
5611            if (pp == req_byte || pp == req_byte2) { p--; break; }              {
5612                register int pp = *p++;
5613                if (pp == req_byte || pp == req_byte2) { p--; break; }
5614                }
5615            }            }
5616          }          else
       else  
         {  
         while (p < end_subject)  
5617            {            {
5618            if (*p++ == req_byte) { p--; break; }            while (p < end_subject)
5619                {
5620                if (*p++ == req_byte) { p--; break; }
5621                }
5622            }            }
         }  
5623    
5624        /* If we can't find the required character, break the matching loop,          /* If we can't find the required character, break the matching loop,
5625        forcing a match failure. */          forcing a match failure. */
5626    
5627        if (p >= end_subject)          if (p >= end_subject)
5628          {            {
5629          rc = MATCH_NOMATCH;            rc = MATCH_NOMATCH;
5630          break;            break;
5631          }            }
5632    
5633        /* If we have found the required character, save the point where we          /* If we have found the required character, save the point where we
5634        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
5635        the start hasn't passed this character yet. */          the start hasn't passed this character yet. */
5636    
5637        req_byte_ptr = p;          req_byte_ptr = p;
5638            }
5639        }        }
5640      }      }
5641    
5642    #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
5643      printf(">>>> Match against: ");
5644      pchars(start_match, end_subject - start_match, TRUE, md);
5645      printf("\n");
5646    #endif
5647    
5648    /* OK, we can now run the match. If "hitend" is set afterwards, remember the    /* OK, we can now run the match. If "hitend" is set afterwards, remember the
5649    first starting point for which a partial match was found. */    first starting point for which a partial match was found. */
5650    
5651    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5652      md->start_used_ptr = start_match;
5653    md->match_call_count = 0;    md->match_call_count = 0;
5654    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);
5655    if (md->hitend && start_partial == NULL) start_partial = start_match;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
5656    
5657    switch(rc)    switch(rc)
5658      {      {
# Line 5299  for(;;) Line 5682  for(;;)
5682      rc = MATCH_NOMATCH;      rc = MATCH_NOMATCH;
5683      goto ENDLOOP;      goto ENDLOOP;
5684    
5685      /* Any other return is some kind of error. */      /* Any other return is either a match, or some kind of error. */
5686    
5687      default:      default:
5688      goto ENDLOOP;      goto ENDLOOP;

Legend:
Removed from v.427  
changed lines
  Added in v.482

  ViewVC Help
Powered by ViewVC 1.1.5