/[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 1015 by ph10, Sun Aug 26 16:07:14 2012 UTC revision 1233 by ph10, Sat Dec 8 12:43:37 2012 UTC
# Line 302  Returns:       nothing Line 302  Returns:       nothing
302  static void  static void
303  pchars(const pcre_uchar *p, int length, FILE *f)  pchars(const pcre_uchar *p, int length, FILE *f)
304  {  {
305  int c;  pcre_uint32 c;
306  while (length-- > 0)  while (length-- > 0)
307    {    {
308    if (isprint(c = *(p++)))    if (isprint(c = *(p++)))
309      fprintf(f, "%c", c);      fprintf(f, "%c", c);
310    else    else
311      fprintf(f, "\\x%02x", c);      fprintf(f, "\\x{%02x}", c);
312    }    }
313  }  }
314  #endif  #endif
# Line 571  for (;;) Line 571  for (;;)
571    {    {
572    int i, j;    int i, j;
573    int clen, dlen;    int clen, dlen;
574    unsigned int c, d;    pcre_uint32 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;
# Line 613  for (;;) Line 613  for (;;)
613      {      {
614      clen = 1;        /* Number of data items 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      GETCHARLENTEST(c, ptr, clen);
617  #endif  /* SUPPORT_UTF */  #else
618      c = *ptr;      c = *ptr;
619    #endif  /* SUPPORT_UTF */
620      }      }
621    else    else
622      {      {
# Line 634  for (;;) Line 635  for (;;)
635      BOOL caseless = FALSE;      BOOL caseless = FALSE;
636      const pcre_uchar *code;      const pcre_uchar *code;
637      int state_offset = current_state->offset;      int state_offset = current_state->offset;
638      int count, codevalue, rrc;      int codevalue, rrc;
639        unsigned int count;
640    
641  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
642      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
# Line 1007  for (;;) Line 1009  for (;;)
1009            {            {
1010            const pcre_uchar *temp = ptr - 1;            const pcre_uchar *temp = ptr - 1;
1011            if (temp < md->start_used_ptr) md->start_used_ptr = temp;            if (temp < md->start_used_ptr) md->start_used_ptr = temp;
1012  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
1013            if (utf) { BACKCHAR(temp); }            if (utf) { BACKCHAR(temp); }
1014  #endif  #endif
1015            GETCHARTEST(d, temp);            GETCHARTEST(d, temp);
# Line 1060  for (;;) Line 1062  for (;;)
1062        if (clen > 0)        if (clen > 0)
1063          {          {
1064          BOOL OK;          BOOL OK;
1065            const pcre_uint32 *cp;
1066          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1067          switch(code[1])          switch(code[1])
1068            {            {
# Line 1108  for (;;) Line 1111  for (;;)
1111                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1112            break;            break;
1113    
1114              case PT_CLIST:
1115              cp = PRIV(ucd_caseless_sets) + code[2];
1116              for (;;)
1117                {
1118                if (c < *cp) { OK = FALSE; break; }
1119                if (c == *cp++) { OK = TRUE; break; }
1120                }
1121              break;
1122    
1123            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1124    
1125            default:            default:
# Line 1294  for (;;) Line 1306  for (;;)
1306        if (clen > 0)        if (clen > 0)
1307          {          {
1308          BOOL OK;          BOOL OK;
1309            const pcre_uint32 *cp;
1310          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1311          switch(code[2])          switch(code[2])
1312            {            {
# Line 1342  for (;;) Line 1355  for (;;)
1355                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1356            break;            break;
1357    
1358              case PT_CLIST:
1359              cp = PRIV(ucd_caseless_sets) + code[3];
1360              for (;;)
1361                {
1362                if (c < *cp) { OK = FALSE; break; }
1363                if (c == *cp++) { OK = TRUE; break; }
1364                }
1365              break;
1366    
1367            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1368    
1369            default:            default:
# Line 1370  for (;;) Line 1392  for (;;)
1392        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1393        if (clen > 0)        if (clen > 0)
1394          {          {
1395          int lgb, rgb;          int lgb, rgb;
1396          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
1397          int ncount = 0;          int ncount = 0;
1398          if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)          if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)
# Line 1378  for (;;) Line 1400  for (;;)
1400            active_count--;           /* Remove non-match possibility */            active_count--;           /* Remove non-match possibility */
1401            next_active_state--;            next_active_state--;
1402            }            }
1403          lgb = UCD_GRAPHBREAK(c);          lgb = UCD_GRAPHBREAK(c);
1404          while (nptr < end_subject)          while (nptr < end_subject)
1405            {            {
1406            dlen = 1;            dlen = 1;
1407            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
1408            rgb = UCD_GRAPHBREAK(d);            rgb = UCD_GRAPHBREAK(d);
1409            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
1410            ncount++;            ncount++;
1411            lgb = rgb;            lgb = rgb;
1412            nptr += dlen;            nptr += dlen;
1413            }            }
1414          count++;          count++;
# Line 1406  for (;;) Line 1428  for (;;)
1428          int ncount = 0;          int ncount = 0;
1429          switch (c)          switch (c)
1430            {            {
1431            case 0x000b:            case CHAR_VT:
1432            case 0x000c:            case CHAR_FF:
1433            case 0x0085:            case CHAR_NEL:
1434    #ifndef EBCDIC
1435            case 0x2028:            case 0x2028:
1436            case 0x2029:            case 0x2029:
1437    #endif  /* Not EBCDIC */
1438            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1439            goto ANYNL01;            goto ANYNL01;
1440    
1441            case 0x000d:            case CHAR_CR:
1442            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;
1443            /* Fall through */            /* Fall through */
1444    
1445            ANYNL01:            ANYNL01:
1446            case 0x000a:            case CHAR_LF:
1447            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
1448              {              {
1449              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
# Line 1446  for (;;) Line 1470  for (;;)
1470          BOOL OK;          BOOL OK;
1471          switch (c)          switch (c)
1472            {            {
1473            case 0x000a:            VSPACE_CASES:
           case 0x000b:  
           case 0x000c:  
           case 0x000d:  
           case 0x0085:  
           case 0x2028:  
           case 0x2029:  
1474            OK = TRUE;            OK = TRUE;
1475            break;            break;
1476    
# Line 1485  for (;;) Line 1503  for (;;)
1503          BOOL OK;          BOOL OK;
1504          switch (c)          switch (c)
1505            {            {
1506            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 */  
1507            OK = TRUE;            OK = TRUE;
1508            break;            break;
1509    
# Line 1544  for (;;) Line 1544  for (;;)
1544        if (clen > 0)        if (clen > 0)
1545          {          {
1546          BOOL OK;          BOOL OK;
1547            const pcre_uint32 *cp;
1548          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1549          switch(code[2])          switch(code[2])
1550            {            {
# Line 1592  for (;;) Line 1593  for (;;)
1593                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1594            break;            break;
1595    
1596              case PT_CLIST:
1597              cp = PRIV(ucd_caseless_sets) + code[3];
1598              for (;;)
1599                {
1600                if (c < *cp) { OK = FALSE; break; }
1601                if (c == *cp++) { OK = TRUE; break; }
1602                }
1603              break;
1604    
1605            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1606    
1607            default:            default:
# Line 1629  for (;;) Line 1639  for (;;)
1639        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
1640        if (clen > 0)        if (clen > 0)
1641          {          {
1642          int lgb, rgb;          int lgb, rgb;
1643          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
1644          int ncount = 0;          int ncount = 0;
1645          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||
# Line 1638  for (;;) Line 1648  for (;;)
1648            active_count--;           /* Remove non-match possibility */            active_count--;           /* Remove non-match possibility */
1649            next_active_state--;            next_active_state--;
1650            }            }
1651          lgb = UCD_GRAPHBREAK(c);          lgb = UCD_GRAPHBREAK(c);
1652          while (nptr < end_subject)          while (nptr < end_subject)
1653            {            {
1654            dlen = 1;            dlen = 1;
1655            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
1656            rgb = UCD_GRAPHBREAK(d);            rgb = UCD_GRAPHBREAK(d);
1657            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
1658            ncount++;            ncount++;
1659            lgb = rgb;            lgb = rgb;
1660            nptr += dlen;            nptr += dlen;
1661            }            }
1662          ADD_NEW_DATA(-(state_offset + count), 0, ncount);          ADD_NEW_DATA(-(state_offset + count), 0, ncount);
# Line 1673  for (;;) Line 1683  for (;;)
1683          int ncount = 0;          int ncount = 0;
1684          switch (c)          switch (c)
1685            {            {
1686            case 0x000b:            case CHAR_VT:
1687            case 0x000c:            case CHAR_FF:
1688            case 0x0085:            case CHAR_NEL:
1689    #ifndef EBCDIC
1690            case 0x2028:            case 0x2028:
1691            case 0x2029:            case 0x2029:
1692    #endif  /* Not EBCDIC */
1693            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1694            goto ANYNL02;            goto ANYNL02;
1695    
1696            case 0x000d:            case CHAR_CR:
1697            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;
1698            /* Fall through */            /* Fall through */
1699    
1700            ANYNL02:            ANYNL02:
1701            case 0x000a:            case CHAR_LF:
1702            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
1703                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
1704              {              {
1705              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1706              next_active_state--;              next_active_state--;
1707              }              }
1708            ADD_NEW_DATA(-(state_offset + count), 0, ncount);            ADD_NEW_DATA(-(state_offset + (int)count), 0, ncount);
1709            break;            break;
1710    
1711            default:            default:
# Line 1721  for (;;) Line 1733  for (;;)
1733          BOOL OK;          BOOL OK;
1734          switch (c)          switch (c)
1735            {            {
1736            case 0x000a:            VSPACE_CASES:
           case 0x000b:  
           case 0x000c:  
           case 0x000d:  
           case 0x0085:  
           case 0x2028:  
           case 0x2029:  
1737            OK = TRUE;            OK = TRUE;
1738            break;            break;
1739    
# Line 1743  for (;;) Line 1749  for (;;)
1749              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1750              next_active_state--;              next_active_state--;
1751              }              }
1752            ADD_NEW_DATA(-(state_offset + count), 0, 0);            ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
1753            }            }
1754          }          }
1755        break;        break;
# Line 1767  for (;;) Line 1773  for (;;)
1773          BOOL OK;          BOOL OK;
1774          switch (c)          switch (c)
1775            {            {
1776            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 */  
1777            OK = TRUE;            OK = TRUE;
1778            break;            break;
1779    
# Line 1802  for (;;) Line 1790  for (;;)
1790              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1791              next_active_state--;              next_active_state--;
1792              }              }
1793            ADD_NEW_DATA(-(state_offset + count), 0, 0);            ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
1794            }            }
1795          }          }
1796        break;        break;
# Line 1819  for (;;) Line 1807  for (;;)
1807        if (clen > 0)        if (clen > 0)
1808          {          {
1809          BOOL OK;          BOOL OK;
1810            const pcre_uint32 *cp;
1811          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1812          switch(code[1 + IMM2_SIZE + 1])          switch(code[1 + IMM2_SIZE + 1])
1813            {            {
# Line 1867  for (;;) Line 1856  for (;;)
1856                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1857            break;            break;
1858    
1859              case PT_CLIST:
1860              cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2];
1861              for (;;)
1862                {
1863                if (c < *cp) { OK = FALSE; break; }
1864                if (c == *cp++) { OK = TRUE; break; }
1865                }
1866              break;
1867    
1868            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1869    
1870            default:            default:
# Line 1899  for (;;) Line 1897  for (;;)
1897        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
1898        if (clen > 0)        if (clen > 0)
1899          {          {
1900          int lgb, rgb;          int lgb, rgb;
1901          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
1902          int ncount = 0;          int ncount = 0;
1903          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)          if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)
# Line 1907  for (;;) Line 1905  for (;;)
1905            active_count--;           /* Remove non-match possibility */            active_count--;           /* Remove non-match possibility */
1906            next_active_state--;            next_active_state--;
1907            }            }
1908          lgb = UCD_GRAPHBREAK(c);          lgb = UCD_GRAPHBREAK(c);
1909          while (nptr < end_subject)          while (nptr < end_subject)
1910            {            {
1911            dlen = 1;            dlen = 1;
1912            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
1913            rgb = UCD_GRAPHBREAK(d);            rgb = UCD_GRAPHBREAK(d);
1914            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
1915            ncount++;            ncount++;
1916            lgb = rgb;            lgb = rgb;
1917            nptr += dlen;            nptr += dlen;
1918            }            }
1919          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
# Line 1941  for (;;) Line 1939  for (;;)
1939          int ncount = 0;          int ncount = 0;
1940          switch (c)          switch (c)
1941            {            {
1942            case 0x000b:            case CHAR_VT:
1943            case 0x000c:            case CHAR_FF:
1944            case 0x0085:            case CHAR_NEL:
1945    #ifndef EBCDIC
1946            case 0x2028:            case 0x2028:
1947            case 0x2029:            case 0x2029:
1948    #endif  /* Not EBCDIC */
1949            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1950            goto ANYNL03;            goto ANYNL03;
1951    
1952            case 0x000d:            case CHAR_CR:
1953            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;
1954            /* Fall through */            /* Fall through */
1955    
1956            ANYNL03:            ANYNL03:
1957            case 0x000a:            case CHAR_LF:
1958            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
1959              {              {
1960              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
# Line 1985  for (;;) Line 1985  for (;;)
1985          BOOL OK;          BOOL OK;
1986          switch (c)          switch (c)
1987            {            {
1988            case 0x000a:            VSPACE_CASES:
           case 0x000b:  
           case 0x000c:  
           case 0x000d:  
           case 0x0085:  
           case 0x2028:  
           case 0x2029:  
1989            OK = TRUE;            OK = TRUE;
1990            break;            break;
1991    
# Line 2027  for (;;) Line 2021  for (;;)
2021          BOOL OK;          BOOL OK;
2022          switch (c)          switch (c)
2023            {            {
2024            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 */  
2025            OK = TRUE;            OK = TRUE;
2026            break;            break;
2027    
# Line 2123  for (;;) Line 2099  for (;;)
2099        case OP_EXTUNI:        case OP_EXTUNI:
2100        if (clen > 0)        if (clen > 0)
2101          {          {
2102          int lgb, rgb;          int lgb, rgb;
2103          const pcre_uchar *nptr = ptr + clen;          const pcre_uchar *nptr = ptr + clen;
2104          int ncount = 0;          int ncount = 0;
2105          lgb = UCD_GRAPHBREAK(c);          lgb = UCD_GRAPHBREAK(c);
2106          while (nptr < end_subject)          while (nptr < end_subject)
2107            {            {
2108            dlen = 1;            dlen = 1;
2109            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }            if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
2110            rgb = UCD_GRAPHBREAK(d);            rgb = UCD_GRAPHBREAK(d);
2111            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2112            ncount++;            ncount++;
2113            lgb = rgb;            lgb = rgb;
2114            nptr += dlen;            nptr += dlen;
2115            }            }
2116          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)          if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
# Line 2152  for (;;) Line 2128  for (;;)
2128        case OP_ANYNL:        case OP_ANYNL:
2129        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2130          {          {
2131          case 0x000b:          case CHAR_VT:
2132          case 0x000c:          case CHAR_FF:
2133          case 0x0085:          case CHAR_NEL:
2134    #ifndef EBCDIC
2135          case 0x2028:          case 0x2028:
2136          case 0x2029:          case 0x2029:
2137    #endif  /* Not EBCDIC */
2138          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
2139    
2140          case 0x000a:          case CHAR_LF:
2141          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2142          break;          break;
2143    
2144          case 0x000d:          case CHAR_CR:
2145          if (ptr + 1 >= end_subject)          if (ptr + 1 >= end_subject)
2146            {            {
2147            ADD_NEW(state_offset + 1, 0);            ADD_NEW(state_offset + 1, 0);
2148            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
2149              reset_could_continue = TRUE;              reset_could_continue = TRUE;
2150            }            }
2151          else if (ptr[1] == 0x0a)          else if (RAWUCHARTEST(ptr + 1) == CHAR_LF)
2152            {            {
2153            ADD_NEW_DATA(-(state_offset + 1), 0, 1);            ADD_NEW_DATA(-(state_offset + 1), 0, 1);
2154            }            }
# Line 2186  for (;;) Line 2164  for (;;)
2164        case OP_NOT_VSPACE:        case OP_NOT_VSPACE:
2165        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2166          {          {
2167          case 0x000a:          VSPACE_CASES:
         case 0x000b:  
         case 0x000c:  
         case 0x000d:  
         case 0x0085:  
         case 0x2028:  
         case 0x2029:  
2168          break;          break;
2169    
2170          default:          default:
# Line 2205  for (;;) Line 2177  for (;;)
2177        case OP_VSPACE:        case OP_VSPACE:
2178        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2179          {          {
2180          case 0x000a:          VSPACE_CASES:
         case 0x000b:  
         case 0x000c:  
         case 0x000d:  
         case 0x0085:  
         case 0x2028:  
         case 0x2029:  
2181          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2182          break;          break;
2183    
2184          default: break;          default:
2185            break;
2186          }          }
2187        break;        break;
2188    
# Line 2223  for (;;) Line 2190  for (;;)
2190        case OP_NOT_HSPACE:        case OP_NOT_HSPACE:
2191        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2192          {          {
2193          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 */  
2194          break;          break;
2195    
2196          default:          default:
# Line 2254  for (;;) Line 2203  for (;;)
2203        case OP_HSPACE:        case OP_HSPACE:
2204        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2205          {          {
2206          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 */  
2207          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2208          break;          break;
2209    
2210            default:
2211            break;
2212          }          }
2213        break;        break;
2214    
# Line 2328  for (;;) Line 2262  for (;;)
2262        if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }
2263        if (clen > 0)        if (clen > 0)
2264          {          {
2265          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2266          if (caseless)          if (caseless)
2267            {            {
2268  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2375  for (;;) Line 2309  for (;;)
2309        ADD_ACTIVE(state_offset + dlen + 1, 0);        ADD_ACTIVE(state_offset + dlen + 1, 0);
2310        if (clen > 0)        if (clen > 0)
2311          {          {
2312          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2313          if (caseless)          if (caseless)
2314            {            {
2315  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2420  for (;;) Line 2354  for (;;)
2354        ADD_ACTIVE(state_offset + dlen + 1, 0);        ADD_ACTIVE(state_offset + dlen + 1, 0);
2355        if (clen > 0)        if (clen > 0)
2356          {          {
2357          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2358          if (caseless)          if (caseless)
2359            {            {
2360  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2457  for (;;) Line 2391  for (;;)
2391        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
2392        if (clen > 0)        if (clen > 0)
2393          {          {
2394          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2395          if (caseless)          if (caseless)
2396            {            {
2397  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2501  for (;;) Line 2435  for (;;)
2435        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
2436        if (clen > 0)        if (clen > 0)
2437          {          {
2438          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2439          if (caseless)          if (caseless)
2440            {            {
2441  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2599  for (;;) Line 2533  for (;;)
2533              { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }              { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
2534            if (isinclass)            if (isinclass)
2535              {              {
2536              int max = GET2(ecode, 1 + IMM2_SIZE);              unsigned int max = GET2(ecode, 1 + IMM2_SIZE);
2537              if (++count >= max && max != 0)   /* Max 0 => no limit */              if (++count >= max && max != 0)   /* Max 0 => no limit */
2538                { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }                { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
2539              else              else
# Line 2675  for (;;) Line 2609  for (;;)
2609              cb.version          = 1;   /* Version 1 of the callout block */              cb.version          = 1;   /* Version 1 of the callout block */
2610              cb.callout_number   = code[LINK_SIZE+2];              cb.callout_number   = code[LINK_SIZE+2];
2611              cb.offset_vector    = offsets;              cb.offset_vector    = offsets;
2612  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
2613              cb.subject          = (PCRE_SPTR)start_subject;              cb.subject          = (PCRE_SPTR)start_subject;
2614  #else  #elif defined COMPILE_PCRE16
2615              cb.subject          = (PCRE_SPTR16)start_subject;              cb.subject          = (PCRE_SPTR16)start_subject;
2616    #elif defined COMPILE_PCRE32
2617                cb.subject          = (PCRE_SPTR32)start_subject;
2618  #endif  #endif
2619              cb.subject_length   = (int)(end_subject - start_subject);              cb.subject_length   = (int)(end_subject - start_subject);
2620              cb.start_match      = (int)(current_subject - start_subject);              cb.start_match      = (int)(current_subject - start_subject);
# Line 2809  for (;;) Line 2745  for (;;)
2745            for (rc = rc*2 - 2; rc >= 0; rc -= 2)            for (rc = rc*2 - 2; rc >= 0; rc -= 2)
2746              {              {
2747              int charcount = local_offsets[rc+1] - local_offsets[rc];              int charcount = local_offsets[rc+1] - local_offsets[rc];
2748  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2749              if (utf)              if (utf)
2750                {                {
2751                const pcre_uchar *p = start_subject + local_offsets[rc];                const pcre_uchar *p = start_subject + local_offsets[rc];
# Line 2913  for (;;) Line 2849  for (;;)
2849              const pcre_uchar *p = ptr;              const pcre_uchar *p = ptr;
2850              const pcre_uchar *pp = local_ptr;              const pcre_uchar *pp = local_ptr;
2851              charcount = (int)(pp - p);              charcount = (int)(pp - p);
2852  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2853              if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;              if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
2854  #endif  #endif
2855              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
# Line 2995  for (;;) Line 2931  for (;;)
2931              }              }
2932            else            else
2933              {              {
2934  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2935              if (utf)              if (utf)
2936                {                {
2937                const pcre_uchar *p = start_subject + local_offsets[0];                const pcre_uchar *p = start_subject + local_offsets[0];
# Line 3024  for (;;) Line 2960  for (;;)
2960          cb.version          = 1;   /* Version 1 of the callout block */          cb.version          = 1;   /* Version 1 of the callout block */
2961          cb.callout_number   = code[1];          cb.callout_number   = code[1];
2962          cb.offset_vector    = offsets;          cb.offset_vector    = offsets;
2963  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
2964          cb.subject          = (PCRE_SPTR)start_subject;          cb.subject          = (PCRE_SPTR)start_subject;
2965  #else  #elif defined COMPILE_PCRE16
2966          cb.subject          = (PCRE_SPTR16)start_subject;          cb.subject          = (PCRE_SPTR16)start_subject;
2967    #elif defined COMPILE_PCRE32
2968            cb.subject          = (PCRE_SPTR32)start_subject;
2969  #endif  #endif
2970          cb.subject_length   = (int)(end_subject - start_subject);          cb.subject_length   = (int)(end_subject - start_subject);
2971          cb.start_match      = (int)(current_subject - start_subject);          cb.start_match      = (int)(current_subject - start_subject);
# Line 3143  Returns:          > 0 => number of match Line 3081  Returns:          > 0 => number of match
3081                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
3082  */  */
3083    
3084  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
3085  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3086  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
3087    const char *subject, int length, int start_offset, int options, int *offsets,    const char *subject, int length, int start_offset, int options, int *offsets,
3088    int offsetcount, int *workspace, int wscount)    int offsetcount, int *workspace, int wscount)
3089  #else  #elif defined COMPILE_PCRE16
3090  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3091  pcre16_dfa_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,  pcre16_dfa_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
3092    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
3093    int offsetcount, int *workspace, int wscount)    int offsetcount, int *workspace, int wscount)
3094    #elif defined COMPILE_PCRE32
3095    PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3096    pcre32_dfa_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
3097      PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
3098      int offsetcount, int *workspace, int wscount)
3099  #endif  #endif
3100  {  {
3101  REAL_PCRE *re = (REAL_PCRE *)argument_re;  REAL_PCRE *re = (REAL_PCRE *)argument_re;
# Line 3179  if (re == NULL || subject == NULL || wor Line 3122  if (re == NULL || subject == NULL || wor
3122     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
3123  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
3124  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
3125    if (length < 0) return PCRE_ERROR_BADLENGTH;
3126  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
3127    
3128  /* Check that the first field in the block is the magic number. If it is not,  /* Check that the first field in the block is the magic number. If it is not,
# Line 3227  end_subject = (const pcre_uchar *)subjec Line 3171  end_subject = (const pcre_uchar *)subjec
3171  req_char_ptr = current_subject - 1;  req_char_ptr = current_subject - 1;
3172    
3173  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3174  /* PCRE_UTF16 has the same value as PCRE_UTF8. */  /* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
3175  utf = (re->options & PCRE_UTF8) != 0;  utf = (re->options & PCRE_UTF8) != 0;
3176  #else  #else
3177  utf = FALSE;  utf = FALSE;
# Line 3313  if (utf && (options & PCRE_NO_UTF8_CHECK Line 3257  if (utf && (options & PCRE_NO_UTF8_CHECK
3257        offsets[0] = erroroffset;        offsets[0] = erroroffset;
3258        offsets[1] = errorcode;        offsets[1] = errorcode;
3259        }        }
3260      return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0)?  #if defined COMPILE_PCRE8
3261        return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0) ?
3262        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
3263    #elif defined COMPILE_PCRE16
3264        return (errorcode <= PCRE_UTF16_ERR1 && (options & PCRE_PARTIAL_HARD) != 0) ?
3265          PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
3266    #elif defined COMPILE_PCRE32
3267        return PCRE_ERROR_BADUTF32;
3268    #endif
3269      }      }
3270    #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
3271    if (start_offset > 0 && start_offset < length &&    if (start_offset > 0 && start_offset < length &&
3272          NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))          NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
3273      return PCRE_ERROR_BADUTF8_OFFSET;      return PCRE_ERROR_BADUTF8_OFFSET;
3274    #endif
3275    }    }
3276  #endif  #endif
3277    
# Line 3428  for (;;) Line 3381  for (;;)
3381        if (has_first_char)        if (has_first_char)
3382          {          {
3383          if (first_char != first_char2)          if (first_char != first_char2)
3384              {
3385              pcre_uchar csc;
3386            while (current_subject < end_subject &&            while (current_subject < end_subject &&
3387                *current_subject != first_char && *current_subject != first_char2)                   (csc = RAWUCHARTEST(current_subject)) != first_char && csc != first_char2)
3388              current_subject++;              current_subject++;
3389              }
3390          else          else
3391            while (current_subject < end_subject &&            while (current_subject < end_subject &&
3392                   *current_subject != first_char)                   RAWUCHARTEST(current_subject) != first_char)
3393              current_subject++;              current_subject++;
3394          }          }
3395    
# Line 3463  for (;;) Line 3419  for (;;)
3419            ANYCRLF, and we are now at a LF, advance the match position by one            ANYCRLF, and we are now at a LF, advance the match position by one
3420            more character. */            more character. */
3421    
3422            if (current_subject[-1] == CHAR_CR &&            if (RAWUCHARTEST(current_subject - 1) == CHAR_CR &&
3423                 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&                 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
3424                 current_subject < end_subject &&                 current_subject < end_subject &&
3425                 *current_subject == CHAR_NL)                 RAWUCHARTEST(current_subject) == CHAR_NL)
3426              current_subject++;              current_subject++;
3427            }            }
3428          }          }
# Line 3477  for (;;) Line 3433  for (;;)
3433          {          {
3434          while (current_subject < end_subject)          while (current_subject < end_subject)
3435            {            {
3436            register unsigned int c = *current_subject;            register pcre_uint32 c = RAWUCHARTEST(current_subject);
3437  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
3438            if (c > 255) c = 255;            if (c > 255) c = 255;
3439  #endif  #endif
# Line 3543  for (;;) Line 3499  for (;;)
3499              {              {
3500              while (p < end_subject)              while (p < end_subject)
3501                {                {
3502                register int pp = *p++;                register pcre_uint32 pp = RAWUCHARINCTEST(p);
3503                if (pp == req_char || pp == req_char2) { p--; break; }                if (pp == req_char || pp == req_char2) { p--; break; }
3504                }                }
3505              }              }
# Line 3551  for (;;) Line 3507  for (;;)
3507              {              {
3508              while (p < end_subject)              while (p < end_subject)
3509                {                {
3510                if (*p++ == req_char) { p--; break; }                if (RAWUCHARINCTEST(p) == req_char) { p--; break; }
3511                }                }
3512              }              }
3513    
# Line 3609  for (;;) Line 3565  for (;;)
3565    not contain any explicit matches for \r or \n, and the newline option is CRLF    not contain any explicit matches for \r or \n, and the newline option is CRLF
3566    or ANY or ANYCRLF, advance the match position by one more character. */    or ANY or ANYCRLF, advance the match position by one more character. */
3567    
3568    if (current_subject[-1] == CHAR_CR &&    if (RAWUCHARTEST(current_subject - 1) == CHAR_CR &&
3569        current_subject < end_subject &&        current_subject < end_subject &&
3570        *current_subject == CHAR_NL &&        RAWUCHARTEST(current_subject) == CHAR_NL &&
3571        (re->flags & PCRE_HASCRORLF) == 0 &&        (re->flags & PCRE_HASCRORLF) == 0 &&
3572          (md->nltype == NLTYPE_ANY ||          (md->nltype == NLTYPE_ANY ||
3573           md->nltype == NLTYPE_ANYCRLF ||           md->nltype == NLTYPE_ANYCRLF ||

Legend:
Removed from v.1015  
changed lines
  Added in v.1233

  ViewVC Help
Powered by ViewVC 1.1.5