/[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 925 by ph10, Wed Feb 22 14:24:56 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 573  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 partial_newline = FALSE;    BOOL partial_newline = FALSE;
577    BOOL could_continue = reset_could_continue;    BOOL could_continue = reset_could_continue;
578    reset_could_continue = FALSE;    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. */
582    
# Line 611  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 645  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". If the could_continue flag was passed over from a previous      been skipped". If the could_continue flag was passed over from a previous
649      state, arrange for it to passed on. */      state, arrange for it to passed on. */
650    
651      if (state_offset < 0)      if (state_offset < 0)
# Line 695  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 because      argument that is not a data character - but is always one byte long because
699      the values are small. We have to take special action to deal with  \P, \p,      the values are small. We have to take special action to deal with  \P, \p,
700      \H, \h, \V, \v and \X in this case. To keep the other cases fast, convert      \H, \h, \V, \v and \X in this case. To keep the other cases fast, convert
701      these ones to new opcodes. */      these ones to new opcodes. */
# Line 789  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 894  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          {          {
898          if (ptr + 1 >= md->end_subject &&          if (ptr + 1 >= md->end_subject &&
899              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
900              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
901              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
902              c == NLBLOCK->nl[0])              c == NLBLOCK->nl[0])
903            {            {
904            could_continue = partial_newline = TRUE;            could_continue = partial_newline = TRUE;
905            }            }
906          else          else
907            {            {
908            ADD_NEW(state_offset + 1, 0);            ADD_NEW(state_offset + 1, 0);
909            }            }
910          }          }
911        break;        break;
912    
# Line 938  for (;;) Line 938  for (;;)
938          else if (ptr + 1 >= md->end_subject &&          else if (ptr + 1 >= md->end_subject &&
939                   (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&                   (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&
940                   NLBLOCK->nltype == NLTYPE_FIXED &&                   NLBLOCK->nltype == NLTYPE_FIXED &&
941                   NLBLOCK->nllen == 2 &&                   NLBLOCK->nllen == 2 &&
942                   c == NLBLOCK->nl[0])                   c == NLBLOCK->nl[0])
943            {            {
944            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
945              {              {
946              reset_could_continue = TRUE;              reset_could_continue = TRUE;
947              ADD_NEW_DATA(-(state_offset + 1), 0, 1);              ADD_NEW_DATA(-(state_offset + 1), 0, 1);
948              }              }
949            else could_continue = partial_newline = TRUE;            else could_continue = partial_newline = TRUE;
950            }            }
951          }          }
952        break;        break;
953    
# Line 963  for (;;) Line 963  for (;;)
963          else if (ptr + 1 >= md->end_subject &&          else if (ptr + 1 >= md->end_subject &&
964                   (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&                   (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&
965                   NLBLOCK->nltype == NLTYPE_FIXED &&                   NLBLOCK->nltype == NLTYPE_FIXED &&
966                   NLBLOCK->nllen == 2 &&                   NLBLOCK->nllen == 2 &&
967                   c == NLBLOCK->nl[0])                   c == NLBLOCK->nl[0])
968            {            {
969            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
970              {              {
971              reset_could_continue = TRUE;              reset_could_continue = TRUE;
972              ADD_NEW_DATA(-(state_offset + 1), 0, 1);              ADD_NEW_DATA(-(state_offset + 1), 0, 1);
973              }              }
974            else could_continue = partial_newline = TRUE;            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 1060  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 1107  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 1138  for (;;) Line 1148  for (;;)
1148          if (d == OP_ANY && ptr + 1 >= md->end_subject &&          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1149              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1150              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
1151              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
1152              c == NLBLOCK->nl[0])              c == NLBLOCK->nl[0])
1153            {            {
1154            could_continue = partial_newline = TRUE;            could_continue = partial_newline = TRUE;
1155            }            }
1156          else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          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)) &&
# Line 1169  for (;;) Line 1179  for (;;)
1179          if (d == OP_ANY && ptr + 1 >= md->end_subject &&          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1180              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1181              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
1182              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
1183              c == NLBLOCK->nl[0])              c == NLBLOCK->nl[0])
1184            {            {
1185            could_continue = partial_newline = TRUE;            could_continue = partial_newline = TRUE;
1186            }            }
1187          else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          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)) &&
# Line 1199  for (;;) Line 1209  for (;;)
1209          if (d == OP_ANY && ptr + 1 >= md->end_subject &&          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1210              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1211              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
1212              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
1213              c == NLBLOCK->nl[0])              c == NLBLOCK->nl[0])
1214            {            {
1215            could_continue = partial_newline = TRUE;            could_continue = partial_newline = TRUE;
1216            }            }
1217          else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          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)) &&
# Line 1227  for (;;) Line 1237  for (;;)
1237          if (d == OP_ANY && ptr + 1 >= md->end_subject &&          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1238              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1239              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
1240              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
1241              c == NLBLOCK->nl[0])              c == NLBLOCK->nl[0])
1242            {            {
1243            could_continue = partial_newline = TRUE;            could_continue = partial_newline = TRUE;
1244            }            }
1245          else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          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)) &&
# Line 1256  for (;;) Line 1266  for (;;)
1266          if (d == OP_ANY && ptr + 1 >= md->end_subject &&          if (d == OP_ANY && ptr + 1 >= md->end_subject &&
1267              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&              (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
1268              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
1269              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
1270              c == NLBLOCK->nl[0])              c == NLBLOCK->nl[0])
1271            {            {
1272            could_continue = partial_newline = TRUE;            could_continue = partial_newline = TRUE;
1273            }            }
1274          else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          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)) &&
# Line 1294  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 1342  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 1368  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 1377  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 1403  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 1443  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 1482  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 1541  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 1589  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 1624  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 1634  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 1667  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 1715  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 1761  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 1813  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 1861  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 1891  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 1900  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)          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
1918              reset_could_continue = TRUE;              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 1932  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 1976  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 2018  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 2112  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)          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
2115              reset_could_continue = TRUE;              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 2139  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)          if (ptr + 1 >= end_subject)
2144            {            {
2145            ADD_NEW(state_offset + 1, 0);            ADD_NEW(state_offset + 1, 0);
2146            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
2147              reset_could_continue = TRUE;              reset_could_continue = TRUE;
2148            }            }
2149          else if (ptr[1] == 0x0a)          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            }            }
2153          else          else
2154            {            {
2155            ADD_NEW(state_offset + 1, 0);            ADD_NEW(state_offset + 1, 0);
2156            }            }
2157          break;          break;
2158          }          }
2159        break;        break;
# Line 2173  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 2192  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 2210  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 2241  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    
# Line 2277  for (;;) Line 2222  for (;;)
2222    
2223        case OP_NOTI:        case OP_NOTI:
2224        if (clen > 0)        if (clen > 0)
2225          {          {
2226          unsigned int otherd;          unsigned int otherd;
2227  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
2228          if (utf && d >= 128)          if (utf && d >= 128)
# Line 2291  for (;;) Line 2236  for (;;)
2236          otherd = TABLE_GET(d, fcc, d);          otherd = TABLE_GET(d, fcc, d);
2237          if (c != d && c != otherd)          if (c != d && c != otherd)
2238            { ADD_NEW(state_offset + dlen + 1, 0); }            { ADD_NEW(state_offset + dlen + 1, 0); }
2239          }          }
2240        break;        break;
2241    
2242        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 2797  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 2898  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 2980  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 3047  for (;;) Line 2998  for (;;)
2998    
2999    The "could_continue" variable is true if a state could have continued but    The "could_continue" variable is true if a state could have continued but
3000    for the fact that the end of the subject was reached. */    for the fact that the end of the subject was reached. */
3001    
3002    if (new_count <= 0)    if (new_count <= 0)
3003      {      {
3004      if (rlevel == 1 &&                               /* Top level, and */      if (rlevel == 1 &&                               /* Top level, and */
# Line 3064  for (;;) Line 3015  for (;;)
3015            (                                          /* or ... */            (                                          /* or ... */
3016            ptr >= end_subject &&                /* End of subject and */            ptr >= end_subject &&                /* End of subject and */
3017            ptr > md->start_used_ptr)            /* Inspected non-empty string */            ptr > md->start_used_ptr)            /* Inspected non-empty string */
3018            )            )
3019          )          )
3020        {        {
3021        if (offsetcount >= 2)        if (offsetcount >= 2)
3022          {          {
# Line 3162  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 3182  if (extra_data != NULL) Line 3150  if (extra_data != NULL)
3150      md->callout_data = extra_data->callout_data;      md->callout_data = extra_data->callout_data;
3151    if ((flags & PCRE_EXTRA_TABLES) != 0)    if ((flags & PCRE_EXTRA_TABLES) != 0)
3152      md->tables = extra_data->tables;      md->tables = extra_data->tables;
   ((pcre_extra *)extra_data)->flags &= ~PCRE_EXTRA_USED_JIT;  /* No JIT support here */  
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.925  
changed lines
  Added in v.1046

  ViewVC Help
Powered by ViewVC 1.1.5