/[pcre]/code/trunk/pcre_dfa_exec.c
ViewVC logotype

Diff of /code/trunk/pcre_dfa_exec.c

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

revision 904 by ph10, Mon Jan 23 17:30:49 2012 UTC revision 1046 by ph10, Tue Sep 25 16:27:58 2012 UTC
# Line 38  POSSIBILITY OF SUCH DAMAGE. Line 38  POSSIBILITY OF SUCH DAMAGE.
38  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
39  */  */
40    
   
41  /* This module contains the external function pcre_dfa_exec(), which is an  /* This module contains the external function pcre_dfa_exec(), which is an
42  alternative matching function that uses a sort of DFA algorithm (not a true  alternative matching function that uses a sort of DFA algorithm (not a true
43  FSM). This is NOT Perl- compatible, but it has advantages in certain  FSM). This is NOT Perl-compatible, but it has advantages in certain
44  applications. */  applications. */
45    
46    
# Line 282  typedef struct stateblock { Line 281  typedef struct stateblock {
281    int data;                       /* Some use extra data */    int data;                       /* Some use extra data */
282  } stateblock;  } stateblock;
283    
284  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))  #define INTS_PER_STATEBLOCK  (int)(sizeof(stateblock)/sizeof(int))
285    
286    
287  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
# Line 382  for the current character, one for the f Line 381  for the current character, one for the f
381      next_new_state->count  = (y); \      next_new_state->count  = (y); \
382      next_new_state->data   = (z); \      next_new_state->data   = (z); \
383      next_new_state++; \      next_new_state++; \
384      DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \      DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d) line %d\n", rlevel*2-2, SP, \
385          (x), (y), (z), __LINE__)); \
386      } \      } \
387    else return PCRE_ERROR_DFA_WSSIZE    else return PCRE_ERROR_DFA_WSSIZE
388    
# Line 424  BOOL utf = (md->poptions & PCRE_UTF8) != Line 424  BOOL utf = (md->poptions & PCRE_UTF8) !=
424  BOOL utf = FALSE;  BOOL utf = FALSE;
425  #endif  #endif
426    
427    BOOL reset_could_continue = FALSE;
428    
429  rlevel++;  rlevel++;
430  offsetcount &= (-2);  offsetcount &= (-2);
431    
# Line 571  for (;;) Line 573  for (;;)
573    int clen, dlen;    int clen, dlen;
574    unsigned int c, d;    unsigned int c, d;
575    int forced_fail = 0;    int forced_fail = 0;
576    BOOL could_continue = FALSE;    BOOL partial_newline = FALSE;
577      BOOL could_continue = reset_could_continue;
578      reset_could_continue = FALSE;
579    
580    /* Make the new state list into the active state list and empty the    /* Make the new state list into the active state list and empty the
581    new state list. */    new state list. */
# Line 607  for (;;) Line 611  for (;;)
611    
612    if (ptr < end_subject)    if (ptr < end_subject)
613      {      {
614      clen = 1;        /* Number of bytes in the character */      clen = 1;        /* Number of data items in the character */
615  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
616      if (utf) { GETCHARLEN(c, ptr, clen); } else      if (utf) { GETCHARLEN(c, ptr, clen); } else
617  #endif  /* SUPPORT_UTF */  #endif  /* SUPPORT_UTF */
# Line 641  for (;;) Line 645  for (;;)
645    
646      /* A negative offset is a special case meaning "hold off going to this      /* A negative offset is a special case meaning "hold off going to this
647      (negated) state until the number of characters in the data field have      (negated) state until the number of characters in the data field have
648      been skipped". */      been skipped". If the could_continue flag was passed over from a previous
649        state, arrange for it to passed on. */
650    
651      if (state_offset < 0)      if (state_offset < 0)
652        {        {
# Line 650  for (;;) Line 655  for (;;)
655          DPRINTF(("%.*sSkipping this character\n", rlevel*2-2, SP));          DPRINTF(("%.*sSkipping this character\n", rlevel*2-2, SP));
656          ADD_NEW_DATA(state_offset, current_state->count,          ADD_NEW_DATA(state_offset, current_state->count,
657            current_state->data - 1);            current_state->data - 1);
658            if (could_continue) reset_could_continue = TRUE;
659          continue;          continue;
660          }          }
661        else        else
# Line 689  for (;;) Line 695  for (;;)
695      permitted.      permitted.
696    
697      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
698      argument that is not a data character - but is always one byte long. We      argument that is not a data character - but is always one byte long because
699      have to take special action to deal with  \P, \p, \H, \h, \V, \v and \X in      the values are small. We have to take special action to deal with  \P, \p,
700      this case. To keep the other cases fast, convert these ones to new opcodes.      \H, \h, \V, \v and \X in this case. To keep the other cases fast, convert
701      */      these ones to new opcodes. */
702    
703      if (coptable[codevalue] > 0)      if (coptable[codevalue] > 0)
704        {        {
# Line 783  for (;;) Line 789  for (;;)
789              offsets[0] = (int)(current_subject - start_subject);              offsets[0] = (int)(current_subject - start_subject);
790              offsets[1] = (int)(ptr - start_subject);              offsets[1] = (int)(ptr - start_subject);
791              DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,              DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
792                offsets[1] - offsets[0], current_subject));                offsets[1] - offsets[0], (char *)current_subject));
793              }              }
794            if ((md->moptions & PCRE_DFA_SHORTEST) != 0)            if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
795              {              {
# Line 888  for (;;) Line 894  for (;;)
894        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
895        case OP_ANY:        case OP_ANY:
896        if (clen > 0 && !IS_NEWLINE(ptr))        if (clen > 0 && !IS_NEWLINE(ptr))
897          { ADD_NEW(state_offset + 1, 0); }          {
898            if (ptr + 1 >= md->end_subject &&
899                (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
900                NLBLOCK->nltype == NLTYPE_FIXED &&
901                NLBLOCK->nllen == 2 &&
902                c == NLBLOCK->nl[0])
903              {
904              could_continue = partial_newline = TRUE;
905              }
906            else
907              {
908              ADD_NEW(state_offset + 1, 0);
909              }
910            }
911        break;        break;
912    
913        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 916  for (;;) Line 935  for (;;)
935                 (ptr == end_subject - md->nllen)                 (ptr == end_subject - md->nllen)
936              ))              ))
937            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
938            else if (ptr + 1 >= md->end_subject &&
939                     (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&
940                     NLBLOCK->nltype == NLTYPE_FIXED &&
941                     NLBLOCK->nllen == 2 &&
942                     c == NLBLOCK->nl[0])
943              {
944              if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
945                {
946                reset_could_continue = TRUE;
947                ADD_NEW_DATA(-(state_offset + 1), 0, 1);
948                }
949              else could_continue = partial_newline = TRUE;
950              }
951          }          }
952        break;        break;
953    
# Line 928  for (;;) Line 960  for (;;)
960          else if (clen == 0 ||          else if (clen == 0 ||
961              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))
962            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
963            else if (ptr + 1 >= md->end_subject &&
964                     (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&
965                     NLBLOCK->nltype == NLTYPE_FIXED &&
966                     NLBLOCK->nllen == 2 &&
967                     c == NLBLOCK->nl[0])
968              {
969              if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
970                {
971                reset_could_continue = TRUE;
972                ADD_NEW_DATA(-(state_offset + 1), 0, 1);
973                }
974              else could_continue = partial_newline = TRUE;
975              }
976          }          }
977        else if (IS_NEWLINE(ptr))        else if (IS_NEWLINE(ptr))
978          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
# Line 1015  for (;;) Line 1060  for (;;)
1060        if (clen > 0)        if (clen > 0)
1061          {          {
1062          BOOL OK;          BOOL OK;
1063            const pcre_uint32 *cp;
1064          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1065          switch(code[1])          switch(code[1])
1066            {            {
# Line 1062  for (;;) Line 1108  for (;;)
1108                 PRIV(ucp_gentype)[prop->chartype] == ucp_N ||                 PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
1109                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1110            break;            break;
1111    
1112              case PT_CLIST:
1113              cp = PRIV(ucd_caseless_sets) + prop->caseset;
1114              for (;;)
1115                {
1116                if (c < *cp) { OK = FALSE; break; }
1117                if (c == *cp++) { OK = TRUE; break; }
1118                }
1119              break;
1120    
1121            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1122    
# Line 1090  for (;;) Line 1145  for (;;)
1145        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1146        if (clen > 0)        if (clen > 0)
1147          {          {
1148          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1149                (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1150                NLBLOCK->nltype == NLTYPE_FIXED &&
1151                NLBLOCK->nllen == 2 &&
1152                c == NLBLOCK->nl[0])
1153              {
1154              could_continue = partial_newline = TRUE;
1155              }
1156            else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1157              (c < 256 &&              (c < 256 &&
1158                (d != OP_ANY || !IS_NEWLINE(ptr)) &&                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1159                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
# Line 1113  for (;;) Line 1176  for (;;)
1176        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
1177        if (clen > 0)        if (clen > 0)
1178          {          {
1179          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1180                (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1181                NLBLOCK->nltype == NLTYPE_FIXED &&
1182                NLBLOCK->nllen == 2 &&
1183                c == NLBLOCK->nl[0])
1184              {
1185              could_continue = partial_newline = TRUE;
1186              }
1187            else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1188              (c < 256 &&              (c < 256 &&
1189                (d != OP_ANY || !IS_NEWLINE(ptr)) &&                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1190                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
# Line 1135  for (;;) Line 1206  for (;;)
1206        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
1207        if (clen > 0)        if (clen > 0)
1208          {          {
1209          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1210                (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1211                NLBLOCK->nltype == NLTYPE_FIXED &&
1212                NLBLOCK->nllen == 2 &&
1213                c == NLBLOCK->nl[0])
1214              {
1215              could_continue = partial_newline = TRUE;
1216              }
1217            else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1218              (c < 256 &&              (c < 256 &&
1219                (d != OP_ANY || !IS_NEWLINE(ptr)) &&                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1220                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
# Line 1155  for (;;) Line 1234  for (;;)
1234        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
1235        if (clen > 0)        if (clen > 0)
1236          {          {
1237          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1238                (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1239                NLBLOCK->nltype == NLTYPE_FIXED &&
1240                NLBLOCK->nllen == 2 &&
1241                c == NLBLOCK->nl[0])
1242              {
1243              could_continue = partial_newline = TRUE;
1244              }
1245            else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1246              (c < 256 &&              (c < 256 &&
1247                (d != OP_ANY || !IS_NEWLINE(ptr)) &&                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1248                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
# Line 1176  for (;;) Line 1263  for (;;)
1263        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
1264        if (clen > 0)        if (clen > 0)
1265          {          {
1266          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1267                (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1268                NLBLOCK->nltype == NLTYPE_FIXED &&
1269                NLBLOCK->nllen == 2 &&
1270                c == NLBLOCK->nl[0])
1271              {
1272              could_continue = partial_newline = TRUE;
1273              }
1274            else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1275              (c < 256 &&              (c < 256 &&
1276                (d != OP_ANY || !IS_NEWLINE(ptr)) &&                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
1277                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
# Line 1209  for (;;) Line 1304  for (;;)
1304        if (clen > 0)        if (clen > 0)
1305          {          {
1306          BOOL OK;          BOOL OK;
1307            const pcre_uint32 *cp;
1308          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1309          switch(code[2])          switch(code[2])
1310            {            {
# Line 1257  for (;;) Line 1353  for (;;)
1353                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1354            break;            break;
1355    
1356              case PT_CLIST:
1357              cp = PRIV(ucd_caseless_sets) + prop->caseset;
1358              for (;;)
1359                {
1360                if (c < *cp) { OK = FALSE; break; }
1361                if (c == *cp++) { OK = TRUE; break; }
1362                }
1363              break;
1364    
1365            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1366    
1367            default:            default:
# Line 1283  for (;;) Line 1388  for (;;)
1388        case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:        case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:
1389        count = current_state->count;  /* Already matched */        count = current_state->count;  /* Already matched */
1390        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1391        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)        if (clen > 0)
1392          {          {
1393            int lgb, rgb;
1394          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
1395          int ncount = 0;          int ncount = 0;
1396          if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)          if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)
# Line 1292  for (;;) Line 1398  for (;;)
1398            active_count--;           /* Remove non-match possibility */            active_count--;           /* Remove non-match possibility */
1399            next_active_state--;            next_active_state--;
1400            }            }
1401            lgb = UCD_GRAPHBREAK(c);
1402          while (nptr < end_subject)          while (nptr < end_subject)
1403            {            {
1404            int nd;            dlen = 1;
1405            int ndlen = 1;            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
1406            GETCHARLEN(nd, nptr, ndlen);            rgb = UCD_GRAPHBREAK(d);
1407            if (UCD_CATEGORY(nd) != ucp_M) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
1408            ncount++;            ncount++;
1409            nptr += ndlen;            lgb = rgb;
1410              nptr += dlen;
1411            }            }
1412          count++;          count++;
1413          ADD_NEW_DATA(-state_offset, count, ncount);          ADD_NEW_DATA(-state_offset, count, ncount);
# Line 1318  for (;;) Line 1426  for (;;)
1426          int ncount = 0;          int ncount = 0;
1427          switch (c)          switch (c)
1428            {            {
1429            case 0x000b:            case CHAR_VT:
1430            case 0x000c:            case CHAR_FF:
1431            case 0x0085:            case CHAR_NEL:
1432    #ifndef EBCDIC
1433            case 0x2028:            case 0x2028:
1434            case 0x2029:            case 0x2029:
1435    #endif  /* Not EBCDIC */
1436            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1437            goto ANYNL01;            goto ANYNL01;
1438    
1439            case 0x000d:            case CHAR_CR:
1440            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == CHAR_LF) ncount = 1;
1441            /* Fall through */            /* Fall through */
1442    
1443            ANYNL01:            ANYNL01:
1444            case 0x000a:            case CHAR_LF:
1445            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
1446              {              {
1447              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
# Line 1358  for (;;) Line 1468  for (;;)
1468          BOOL OK;          BOOL OK;
1469          switch (c)          switch (c)
1470            {            {
1471            case 0x000a:            VSPACE_CASES:
           case 0x000b:  
           case 0x000c:  
           case 0x000d:  
           case 0x0085:  
           case 0x2028:  
           case 0x2029:  
1472            OK = TRUE;            OK = TRUE;
1473            break;            break;
1474    
# Line 1397  for (;;) Line 1501  for (;;)
1501          BOOL OK;          BOOL OK;
1502          switch (c)          switch (c)
1503            {            {
1504            case 0x09:      /* HT */            HSPACE_CASES:
           case 0x20:      /* SPACE */  
           case 0xa0:      /* NBSP */  
           case 0x1680:    /* OGHAM SPACE MARK */  
           case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
           case 0x2000:    /* EN QUAD */  
           case 0x2001:    /* EM QUAD */  
           case 0x2002:    /* EN SPACE */  
           case 0x2003:    /* EM SPACE */  
           case 0x2004:    /* THREE-PER-EM SPACE */  
           case 0x2005:    /* FOUR-PER-EM SPACE */  
           case 0x2006:    /* SIX-PER-EM SPACE */  
           case 0x2007:    /* FIGURE SPACE */  
           case 0x2008:    /* PUNCTUATION SPACE */  
           case 0x2009:    /* THIN SPACE */  
           case 0x200A:    /* HAIR SPACE */  
           case 0x202f:    /* NARROW NO-BREAK SPACE */  
           case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
           case 0x3000:    /* IDEOGRAPHIC SPACE */  
1505            OK = TRUE;            OK = TRUE;
1506            break;            break;
1507    
# Line 1456  for (;;) Line 1542  for (;;)
1542        if (clen > 0)        if (clen > 0)
1543          {          {
1544          BOOL OK;          BOOL OK;
1545            const pcre_uint32 *cp;
1546          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1547          switch(code[2])          switch(code[2])
1548            {            {
# Line 1504  for (;;) Line 1591  for (;;)
1591                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1592            break;            break;
1593    
1594              case PT_CLIST:
1595              cp = PRIV(ucd_caseless_sets) + prop->caseset;
1596              for (;;)
1597                {
1598                if (c < *cp) { OK = FALSE; break; }
1599                if (c == *cp++) { OK = TRUE; break; }
1600                }
1601              break;
1602    
1603            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1604    
1605            default:            default:
# Line 1539  for (;;) Line 1635  for (;;)
1635        QS2:        QS2:
1636    
1637        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
1638        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)        if (clen > 0)
1639          {          {
1640            int lgb, rgb;
1641          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
1642          int ncount = 0;          int ncount = 0;
1643          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||
# Line 1549  for (;;) Line 1646  for (;;)
1646            active_count--;           /* Remove non-match possibility */            active_count--;           /* Remove non-match possibility */
1647            next_active_state--;            next_active_state--;
1648            }            }
1649            lgb = UCD_GRAPHBREAK(c);
1650          while (nptr < end_subject)          while (nptr < end_subject)
1651            {            {
1652            int nd;            dlen = 1;
1653            int ndlen = 1;            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
1654            GETCHARLEN(nd, nptr, ndlen);            rgb = UCD_GRAPHBREAK(d);
1655            if (UCD_CATEGORY(nd) != ucp_M) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
1656            ncount++;            ncount++;
1657            nptr += ndlen;            lgb = rgb;
1658              nptr += dlen;
1659            }            }
1660          ADD_NEW_DATA(-(state_offset + count), 0, ncount);          ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1661          }          }
# Line 1582  for (;;) Line 1681  for (;;)
1681          int ncount = 0;          int ncount = 0;
1682          switch (c)          switch (c)
1683            {            {
1684            case 0x000b:            case CHAR_VT:
1685            case 0x000c:            case CHAR_FF:
1686            case 0x0085:            case CHAR_NEL:
1687    #ifndef EBCDIC
1688            case 0x2028:            case 0x2028:
1689            case 0x2029:            case 0x2029:
1690    #endif  /* Not EBCDIC */
1691            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1692            goto ANYNL02;            goto ANYNL02;
1693    
1694            case 0x000d:            case CHAR_CR:
1695            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == CHAR_LF) ncount = 1;
1696            /* Fall through */            /* Fall through */
1697    
1698            ANYNL02:            ANYNL02:
1699            case 0x000a:            case CHAR_LF:
1700            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
1701                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
1702              {              {
# Line 1630  for (;;) Line 1731  for (;;)
1731          BOOL OK;          BOOL OK;
1732          switch (c)          switch (c)
1733            {            {
1734            case 0x000a:            VSPACE_CASES:
           case 0x000b:  
           case 0x000c:  
           case 0x000d:  
           case 0x0085:  
           case 0x2028:  
           case 0x2029:  
1735            OK = TRUE;            OK = TRUE;
1736            break;            break;
1737    
# Line 1676  for (;;) Line 1771  for (;;)
1771          BOOL OK;          BOOL OK;
1772          switch (c)          switch (c)
1773            {            {
1774            case 0x09:      /* HT */            HSPACE_CASES:
           case 0x20:      /* SPACE */  
           case 0xa0:      /* NBSP */  
           case 0x1680:    /* OGHAM SPACE MARK */  
           case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
           case 0x2000:    /* EN QUAD */  
           case 0x2001:    /* EM QUAD */  
           case 0x2002:    /* EN SPACE */  
           case 0x2003:    /* EM SPACE */  
           case 0x2004:    /* THREE-PER-EM SPACE */  
           case 0x2005:    /* FOUR-PER-EM SPACE */  
           case 0x2006:    /* SIX-PER-EM SPACE */  
           case 0x2007:    /* FIGURE SPACE */  
           case 0x2008:    /* PUNCTUATION SPACE */  
           case 0x2009:    /* THIN SPACE */  
           case 0x200A:    /* HAIR SPACE */  
           case 0x202f:    /* NARROW NO-BREAK SPACE */  
           case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
           case 0x3000:    /* IDEOGRAPHIC SPACE */  
1775            OK = TRUE;            OK = TRUE;
1776            break;            break;
1777    
# Line 1728  for (;;) Line 1805  for (;;)
1805        if (clen > 0)        if (clen > 0)
1806          {          {
1807          BOOL OK;          BOOL OK;
1808            const pcre_uint32 *cp;
1809          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1810          switch(code[1 + IMM2_SIZE + 1])          switch(code[1 + IMM2_SIZE + 1])
1811            {            {
# Line 1776  for (;;) Line 1854  for (;;)
1854                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1855            break;            break;
1856    
1857              case PT_CLIST:
1858              cp = PRIV(ucd_caseless_sets) + prop->caseset;
1859              for (;;)
1860                {
1861                if (c < *cp) { OK = FALSE; break; }
1862                if (c == *cp++) { OK = TRUE; break; }
1863                }
1864              break;
1865    
1866            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1867    
1868            default:            default:
# Line 1806  for (;;) Line 1893  for (;;)
1893        if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)        if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)
1894          { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }          { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
1895        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
1896        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)        if (clen > 0)
1897          {          {
1898            int lgb, rgb;
1899          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
1900          int ncount = 0;          int ncount = 0;
1901          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)
# Line 1815  for (;;) Line 1903  for (;;)
1903            active_count--;           /* Remove non-match possibility */            active_count--;           /* Remove non-match possibility */
1904            next_active_state--;            next_active_state--;
1905            }            }
1906            lgb = UCD_GRAPHBREAK(c);
1907          while (nptr < end_subject)          while (nptr < end_subject)
1908            {            {
1909            int nd;            dlen = 1;
1910            int ndlen = 1;            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
1911            GETCHARLEN(nd, nptr, ndlen);            rgb = UCD_GRAPHBREAK(d);
1912            if (UCD_CATEGORY(nd) != ucp_M) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
1913            ncount++;            ncount++;
1914            nptr += ndlen;            lgb = rgb;
1915              nptr += dlen;
1916            }            }
1917            if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
1918                reset_could_continue = TRUE;
1919          if (++count >= GET2(code, 1))          if (++count >= GET2(code, 1))
1920            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
1921          else          else
# Line 1845  for (;;) Line 1937  for (;;)
1937          int ncount = 0;          int ncount = 0;
1938          switch (c)          switch (c)
1939            {            {
1940            case 0x000b:            case CHAR_VT:
1941            case 0x000c:            case CHAR_FF:
1942            case 0x0085:            case CHAR_NEL:
1943    #ifndef EBCDIC
1944            case 0x2028:            case 0x2028:
1945            case 0x2029:            case 0x2029:
1946    #endif  /* Not EBCDIC */
1947            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1948            goto ANYNL03;            goto ANYNL03;
1949    
1950            case 0x000d:            case CHAR_CR:
1951            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == CHAR_LF) ncount = 1;
1952            /* Fall through */            /* Fall through */
1953    
1954            ANYNL03:            ANYNL03:
1955            case 0x000a:            case CHAR_LF:
1956            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
1957              {              {
1958              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
# Line 1889  for (;;) Line 1983  for (;;)
1983          BOOL OK;          BOOL OK;
1984          switch (c)          switch (c)
1985            {            {
1986            case 0x000a:            VSPACE_CASES:
           case 0x000b:  
           case 0x000c:  
           case 0x000d:  
           case 0x0085:  
           case 0x2028:  
           case 0x2029:  
1987            OK = TRUE;            OK = TRUE;
1988            break;            break;
1989    
# Line 1931  for (;;) Line 2019  for (;;)
2019          BOOL OK;          BOOL OK;
2020          switch (c)          switch (c)
2021            {            {
2022            case 0x09:      /* HT */            HSPACE_CASES:
           case 0x20:      /* SPACE */  
           case 0xa0:      /* NBSP */  
           case 0x1680:    /* OGHAM SPACE MARK */  
           case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
           case 0x2000:    /* EN QUAD */  
           case 0x2001:    /* EM QUAD */  
           case 0x2002:    /* EN SPACE */  
           case 0x2003:    /* EM SPACE */  
           case 0x2004:    /* THREE-PER-EM SPACE */  
           case 0x2005:    /* FOUR-PER-EM SPACE */  
           case 0x2006:    /* SIX-PER-EM SPACE */  
           case 0x2007:    /* FIGURE SPACE */  
           case 0x2008:    /* PUNCTUATION SPACE */  
           case 0x2009:    /* THIN SPACE */  
           case 0x200A:    /* HAIR SPACE */  
           case 0x202f:    /* NARROW NO-BREAK SPACE */  
           case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
           case 0x3000:    /* IDEOGRAPHIC SPACE */  
2023            OK = TRUE;            OK = TRUE;
2024            break;            break;
2025    
# Line 2025  for (;;) Line 2095  for (;;)
2095        to wait for them to pass before continuing. */        to wait for them to pass before continuing. */
2096    
2097        case OP_EXTUNI:        case OP_EXTUNI:
2098        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)        if (clen > 0)
2099          {          {
2100            int lgb, rgb;
2101          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
2102          int ncount = 0;          int ncount = 0;
2103            lgb = UCD_GRAPHBREAK(c);
2104          while (nptr < end_subject)          while (nptr < end_subject)
2105            {            {
2106            int nclen = 1;            dlen = 1;
2107            GETCHARLEN(c, nptr, nclen);            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
2108            if (UCD_CATEGORY(c) != ucp_M) break;            rgb = UCD_GRAPHBREAK(d);
2109              if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2110            ncount++;            ncount++;
2111            nptr += nclen;            lgb = rgb;
2112              nptr += dlen;
2113            }            }
2114            if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
2115                reset_could_continue = TRUE;
2116          ADD_NEW_DATA(-(state_offset + 1), 0, ncount);          ADD_NEW_DATA(-(state_offset + 1), 0, ncount);
2117          }          }
2118        break;        break;
# Line 2050  for (;;) Line 2126  for (;;)
2126        case OP_ANYNL:        case OP_ANYNL:
2127        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2128          {          {
2129          case 0x000b:          case CHAR_VT:
2130          case 0x000c:          case CHAR_FF:
2131          case 0x0085:          case CHAR_NEL:
2132    #ifndef EBCDIC
2133          case 0x2028:          case 0x2028:
2134          case 0x2029:          case 0x2029:
2135    #endif  /* Not EBCDIC */
2136          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
2137    
2138          case 0x000a:          case CHAR_LF:
2139          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2140          break;          break;
2141    
2142          case 0x000d:          case CHAR_CR:
2143          if (ptr + 1 < end_subject && ptr[1] == 0x0a)          if (ptr + 1 >= end_subject)
2144              {
2145              ADD_NEW(state_offset + 1, 0);
2146              if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
2147                reset_could_continue = TRUE;
2148              }
2149            else if (ptr[1] == CHAR_LF)
2150            {            {
2151            ADD_NEW_DATA(-(state_offset + 1), 0, 1);            ADD_NEW_DATA(-(state_offset + 1), 0, 1);
2152            }            }
# Line 2078  for (;;) Line 2162  for (;;)
2162        case OP_NOT_VSPACE:        case OP_NOT_VSPACE:
2163        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2164          {          {
2165          case 0x000a:          VSPACE_CASES:
         case 0x000b:  
         case 0x000c:  
         case 0x000d:  
         case 0x0085:  
         case 0x2028:  
         case 0x2029:  
2166          break;          break;
2167    
2168          default:          default:
# Line 2097  for (;;) Line 2175  for (;;)
2175        case OP_VSPACE:        case OP_VSPACE:
2176        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2177          {          {
2178          case 0x000a:          VSPACE_CASES:
         case 0x000b:  
         case 0x000c:  
         case 0x000d:  
         case 0x0085:  
         case 0x2028:  
         case 0x2029:  
2179          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2180          break;          break;
2181    
2182          default: break;          default:
2183            break;
2184          }          }
2185        break;        break;
2186    
# Line 2115  for (;;) Line 2188  for (;;)
2188        case OP_NOT_HSPACE:        case OP_NOT_HSPACE:
2189        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2190          {          {
2191          case 0x09:      /* HT */          HSPACE_CASES:
         case 0x20:      /* SPACE */  
         case 0xa0:      /* NBSP */  
         case 0x1680:    /* OGHAM SPACE MARK */  
         case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
         case 0x2000:    /* EN QUAD */  
         case 0x2001:    /* EM QUAD */  
         case 0x2002:    /* EN SPACE */  
         case 0x2003:    /* EM SPACE */  
         case 0x2004:    /* THREE-PER-EM SPACE */  
         case 0x2005:    /* FOUR-PER-EM SPACE */  
         case 0x2006:    /* SIX-PER-EM SPACE */  
         case 0x2007:    /* FIGURE SPACE */  
         case 0x2008:    /* PUNCTUATION SPACE */  
         case 0x2009:    /* THIN SPACE */  
         case 0x200A:    /* HAIR SPACE */  
         case 0x202f:    /* NARROW NO-BREAK SPACE */  
         case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
         case 0x3000:    /* IDEOGRAPHIC SPACE */  
2192          break;          break;
2193    
2194          default:          default:
# Line 2146  for (;;) Line 2201  for (;;)
2201        case OP_HSPACE:        case OP_HSPACE:
2202        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2203          {          {
2204          case 0x09:      /* HT */          HSPACE_CASES:
         case 0x20:      /* SPACE */  
         case 0xa0:      /* NBSP */  
         case 0x1680:    /* OGHAM SPACE MARK */  
         case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
         case 0x2000:    /* EN QUAD */  
         case 0x2001:    /* EM QUAD */  
         case 0x2002:    /* EN SPACE */  
         case 0x2003:    /* EM SPACE */  
         case 0x2004:    /* THREE-PER-EM SPACE */  
         case 0x2005:    /* FOUR-PER-EM SPACE */  
         case 0x2006:    /* SIX-PER-EM SPACE */  
         case 0x2007:    /* FIGURE SPACE */  
         case 0x2008:    /* PUNCTUATION SPACE */  
         case 0x2009:    /* THIN SPACE */  
         case 0x200A:    /* HAIR SPACE */  
         case 0x202f:    /* NARROW NO-BREAK SPACE */  
         case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
         case 0x3000:    /* IDEOGRAPHIC SPACE */  
2205          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2206          break;          break;
2207    
2208            default:
2209            break;
2210          }          }
2211        break;        break;
2212    
2213        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2214        /* Match a negated single character casefully. This is only used for        /* Match a negated single character casefully. */
       one-byte characters, that is, we know that d < 256. The character we are  
       checking (c) can be multibyte. */  
2215    
2216        case OP_NOT:        case OP_NOT:
2217        if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }        if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }
2218        break;        break;
2219    
2220        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2221        /* Match a negated single character caselessly. This is only used for        /* Match a negated single character caselessly. */
       one-byte characters, that is, we know that d < 256. The character we are  
       checking (c) can be multibyte. */  
2222    
2223        case OP_NOTI:        case OP_NOTI:
2224        if (clen > 0 && c != d && c != fcc[d])        if (clen > 0)
2225          { ADD_NEW(state_offset + dlen + 1, 0); }          {
2226            unsigned int otherd;
2227    #ifdef SUPPORT_UTF
2228            if (utf && d >= 128)
2229              {
2230    #ifdef SUPPORT_UCP
2231              otherd = UCD_OTHERCASE(d);
2232    #endif  /* SUPPORT_UCP */
2233              }
2234            else
2235    #endif  /* SUPPORT_UTF */
2236            otherd = TABLE_GET(d, fcc, d);
2237            if (c != d && c != otherd)
2238              { ADD_NEW(state_offset + dlen + 1, 0); }
2239            }
2240        break;        break;
2241    
2242        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 2692  for (;;) Line 2742  for (;;)
2742              {              {
2743              int charcount = local_offsets[rc+1] - local_offsets[rc];              int charcount = local_offsets[rc+1] - local_offsets[rc];
2744  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
2745              const pcre_uchar *p = start_subject + local_offsets[rc];              if (utf)
2746              const pcre_uchar *pp = start_subject + local_offsets[rc+1];                {
2747              while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;                const pcre_uchar *p = start_subject + local_offsets[rc];
2748                  const pcre_uchar *pp = start_subject + local_offsets[rc+1];
2749                  while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
2750                  }
2751  #endif  #endif
2752              if (charcount > 0)              if (charcount > 0)
2753                {                {
# Line 2793  for (;;) Line 2846  for (;;)
2846              const pcre_uchar *pp = local_ptr;              const pcre_uchar *pp = local_ptr;
2847              charcount = (int)(pp - p);              charcount = (int)(pp - p);
2848  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
2849              while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;              if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
2850  #endif  #endif
2851              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
2852              }              }
# Line 2875  for (;;) Line 2928  for (;;)
2928            else            else
2929              {              {
2930  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
2931              const pcre_uchar *p = start_subject + local_offsets[0];              if (utf)
2932              const pcre_uchar *pp = start_subject + local_offsets[1];                {
2933              while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;                const pcre_uchar *p = start_subject + local_offsets[0];
2934                  const pcre_uchar *pp = start_subject + local_offsets[1];
2935                  while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
2936                  }
2937  #endif  #endif
2938              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
2939              if (repeat_state_offset >= 0)              if (repeat_state_offset >= 0)
# Line 2946  for (;;) Line 3002  for (;;)
3002    if (new_count <= 0)    if (new_count <= 0)
3003      {      {
3004      if (rlevel == 1 &&                               /* Top level, and */      if (rlevel == 1 &&                               /* Top level, and */
3005          could_continue &&                            /* Some could go on */          could_continue &&                            /* Some could go on, and */
3006          forced_fail != workspace[1] &&               /* Not all forced fail & */          forced_fail != workspace[1] &&               /* Not all forced fail & */
3007          (                                            /* either... */          (                                            /* either... */
3008          (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */          (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */
# Line 2954  for (;;) Line 3010  for (;;)
3010          ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */          ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
3011           match_count < 0)                            /* no matches */           match_count < 0)                            /* no matches */
3012          ) &&                                         /* And... */          ) &&                                         /* And... */
3013          ptr >= end_subject &&                  /* Reached end of subject */          (
3014          ptr > md->start_used_ptr)              /* Inspected non-empty string */          partial_newline ||                           /* Either partial NL */
3015              (                                          /* or ... */
3016              ptr >= end_subject &&                /* End of subject and */
3017              ptr > md->start_used_ptr)            /* Inspected non-empty string */
3018              )
3019            )
3020        {        {
3021        if (offsetcount >= 2)        if (offsetcount >= 2)
3022          {          {
# Line 3052  if (offsetcount < 0) return PCRE_ERROR_B Line 3113  if (offsetcount < 0) return PCRE_ERROR_B
3113  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
3114  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
3115    
3116  /* We need to find the pointer to any study data before we test for byte  /* Check that the first field in the block is the magic number. If it is not,
3117  flipping, so we scan the extra_data block first. This may set two fields in the  return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
3118  match block, so we must initialize them beforehand. However, the other fields  REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
3119  in the match block must not be set until after the byte flipping. */  means that the pattern is likely compiled with different endianness. */
3120    
3121    if (re->magic_number != MAGIC_NUMBER)
3122      return re->magic_number == REVERSED_MAGIC_NUMBER?
3123        PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
3124    if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
3125    
3126    /* If restarting after a partial match, do some sanity checks on the contents
3127    of the workspace. */
3128    
3129    if ((options & PCRE_DFA_RESTART) != 0)
3130      {
3131      if ((workspace[0] & (-2)) != 0 || workspace[1] < 1 ||
3132        workspace[1] > (wscount - 2)/INTS_PER_STATEBLOCK)
3133          return PCRE_ERROR_DFA_BADRESTART;
3134      }
3135    
3136    /* Set up study, callout, and table data */
3137    
3138  md->tables = re->tables;  md->tables = re->tables;
3139  md->callout_data = NULL;  md->callout_data = NULL;
# Line 3074  if (extra_data != NULL) Line 3152  if (extra_data != NULL)
3152      md->tables = extra_data->tables;      md->tables = extra_data->tables;
3153    }    }
3154    
 /* Check that the first field in the block is the magic number. If it is not,  
 return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to  
 REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which  
 means that the pattern is likely compiled with different endianness. */  
   
 if (re->magic_number != MAGIC_NUMBER)  
   return re->magic_number == REVERSED_MAGIC_NUMBER?  
     PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;  
 if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;  
   
3155  /* Set some local values */  /* Set some local values */
3156    
3157  current_subject = (const pcre_uchar *)subject + start_offset;  current_subject = (const pcre_uchar *)subject + start_offset;

Legend:
Removed from v.904  
changed lines
  Added in v.1046

  ViewVC Help
Powered by ViewVC 1.1.5