/[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 1046 by ph10, Tue Sep 25 16:27:58 2012 UTC revision 1320 by ph10, Wed May 1 16:39:35 2013 UTC
# Line 7  and semantics are as close as possible t Line 7  and semantics are as close as possible t
7  below for why this module is different).  below for why this module is different).
8    
9                         Written by Philip Hazel                         Written by Philip Hazel
10             Copyright (c) 1997-2012 University of Cambridge             Copyright (c) 1997-2013 University of Cambridge
11    
12  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
13  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# 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;          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 1110  for (;;)
1110                 PRIV(ucp_gentype)[prop->chartype] == ucp_N ||                 PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
1111                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1112            break;            break;
1113    
1114            case PT_CLIST:            case PT_CLIST:
1115            cp = PRIV(ucd_caseless_sets) + prop->caseset;            cp = PRIV(ucd_caseless_sets) + code[2];
1116            for (;;)            for (;;)
1117              {              {
1118              if (c < *cp) { OK = FALSE; break; }              if (c < *cp) { OK = FALSE; break; }
1119              if (c == *cp++) { OK = TRUE; break; }              if (c == *cp++) { OK = TRUE; break; }
1120              }              }
1121            break;            break;
1122    
1123              case PT_UCNC:
1124              OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
1125                   c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
1126                   c >= 0xe000;
1127              break;
1128    
1129            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1130    
# Line 1304  for (;;) Line 1312  for (;;)
1312        if (clen > 0)        if (clen > 0)
1313          {          {
1314          BOOL OK;          BOOL OK;
1315          const pcre_uint32 *cp;          const pcre_uint32 *cp;
1316          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1317          switch(code[2])          switch(code[2])
1318            {            {
# Line 1354  for (;;) Line 1362  for (;;)
1362            break;            break;
1363    
1364            case PT_CLIST:            case PT_CLIST:
1365            cp = PRIV(ucd_caseless_sets) + prop->caseset;            cp = PRIV(ucd_caseless_sets) + code[3];
1366            for (;;)            for (;;)
1367              {              {
1368              if (c < *cp) { OK = FALSE; break; }              if (c < *cp) { OK = FALSE; break; }
1369              if (c == *cp++) { OK = TRUE; break; }              if (c == *cp++) { OK = TRUE; break; }
1370              }              }
1371            break;            break;
1372    
1373              case PT_UCNC:
1374              OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
1375                   c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
1376                   c >= 0xe000;
1377              break;
1378    
1379            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1380    
# Line 1437  for (;;) Line 1451  for (;;)
1451            goto ANYNL01;            goto ANYNL01;
1452    
1453            case CHAR_CR:            case CHAR_CR:
1454            if (ptr + 1 < end_subject && ptr[1] == CHAR_LF) ncount = 1;            if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;
1455            /* Fall through */            /* Fall through */
1456    
1457            ANYNL01:            ANYNL01:
# Line 1468  for (;;) Line 1482  for (;;)
1482          BOOL OK;          BOOL OK;
1483          switch (c)          switch (c)
1484            {            {
1485            VSPACE_CASES:            VSPACE_CASES:
1486            OK = TRUE;            OK = TRUE;
1487            break;            break;
1488    
# Line 1501  for (;;) Line 1515  for (;;)
1515          BOOL OK;          BOOL OK;
1516          switch (c)          switch (c)
1517            {            {
1518            HSPACE_CASES:            HSPACE_CASES:
1519            OK = TRUE;            OK = TRUE;
1520            break;            break;
1521    
# Line 1542  for (;;) Line 1556  for (;;)
1556        if (clen > 0)        if (clen > 0)
1557          {          {
1558          BOOL OK;          BOOL OK;
1559          const pcre_uint32 *cp;          const pcre_uint32 *cp;
1560          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1561          switch(code[2])          switch(code[2])
1562            {            {
# Line 1592  for (;;) Line 1606  for (;;)
1606            break;            break;
1607    
1608            case PT_CLIST:            case PT_CLIST:
1609            cp = PRIV(ucd_caseless_sets) + prop->caseset;            cp = PRIV(ucd_caseless_sets) + code[3];
1610            for (;;)            for (;;)
1611              {              {
1612              if (c < *cp) { OK = FALSE; break; }              if (c < *cp) { OK = FALSE; break; }
1613              if (c == *cp++) { OK = TRUE; break; }              if (c == *cp++) { OK = TRUE; break; }
1614              }              }
1615            break;            break;
1616    
1617              case PT_UCNC:
1618              OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
1619                   c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
1620                   c >= 0xe000;
1621              break;
1622    
1623            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1624    
# Line 1692  for (;;) Line 1712  for (;;)
1712            goto ANYNL02;            goto ANYNL02;
1713    
1714            case CHAR_CR:            case CHAR_CR:
1715            if (ptr + 1 < end_subject && ptr[1] == CHAR_LF) ncount = 1;            if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;
1716            /* Fall through */            /* Fall through */
1717    
1718            ANYNL02:            ANYNL02:
# Line 1703  for (;;) Line 1723  for (;;)
1723              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1724              next_active_state--;              next_active_state--;
1725              }              }
1726            ADD_NEW_DATA(-(state_offset + count), 0, ncount);            ADD_NEW_DATA(-(state_offset + (int)count), 0, ncount);
1727            break;            break;
1728    
1729            default:            default:
# Line 1731  for (;;) Line 1751  for (;;)
1751          BOOL OK;          BOOL OK;
1752          switch (c)          switch (c)
1753            {            {
1754            VSPACE_CASES:            VSPACE_CASES:
1755            OK = TRUE;            OK = TRUE;
1756            break;            break;
1757    
# Line 1747  for (;;) Line 1767  for (;;)
1767              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1768              next_active_state--;              next_active_state--;
1769              }              }
1770            ADD_NEW_DATA(-(state_offset + count), 0, 0);            ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
1771            }            }
1772          }          }
1773        break;        break;
# Line 1771  for (;;) Line 1791  for (;;)
1791          BOOL OK;          BOOL OK;
1792          switch (c)          switch (c)
1793            {            {
1794            HSPACE_CASES:            HSPACE_CASES:
1795            OK = TRUE;            OK = TRUE;
1796            break;            break;
1797    
# Line 1788  for (;;) Line 1808  for (;;)
1808              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1809              next_active_state--;              next_active_state--;
1810              }              }
1811            ADD_NEW_DATA(-(state_offset + count), 0, 0);            ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
1812            }            }
1813          }          }
1814        break;        break;
# Line 1805  for (;;) Line 1825  for (;;)
1825        if (clen > 0)        if (clen > 0)
1826          {          {
1827          BOOL OK;          BOOL OK;
1828          const pcre_uint32 *cp;          const pcre_uint32 *cp;
1829          const ucd_record * prop = GET_UCD(c);          const ucd_record * prop = GET_UCD(c);
1830          switch(code[1 + IMM2_SIZE + 1])          switch(code[1 + IMM2_SIZE + 1])
1831            {            {
# Line 1855  for (;;) Line 1875  for (;;)
1875            break;            break;
1876    
1877            case PT_CLIST:            case PT_CLIST:
1878            cp = PRIV(ucd_caseless_sets) + prop->caseset;            cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2];
1879            for (;;)            for (;;)
1880              {              {
1881              if (c < *cp) { OK = FALSE; break; }              if (c < *cp) { OK = FALSE; break; }
1882              if (c == *cp++) { OK = TRUE; break; }              if (c == *cp++) { OK = TRUE; break; }
1883              }              }
1884            break;            break;
1885    
1886              case PT_UCNC:
1887              OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
1888                   c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
1889                   c >= 0xe000;
1890              break;
1891    
1892            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1893    
# Line 1948  for (;;) Line 1974  for (;;)
1974            goto ANYNL03;            goto ANYNL03;
1975    
1976            case CHAR_CR:            case CHAR_CR:
1977            if (ptr + 1 < end_subject && ptr[1] == CHAR_LF) ncount = 1;            if (ptr + 1 < end_subject && RAWUCHARTEST(ptr + 1) == CHAR_LF) ncount = 1;
1978            /* Fall through */            /* Fall through */
1979    
1980            ANYNL03:            ANYNL03:
# Line 1983  for (;;) Line 2009  for (;;)
2009          BOOL OK;          BOOL OK;
2010          switch (c)          switch (c)
2011            {            {
2012            VSPACE_CASES:            VSPACE_CASES:
2013            OK = TRUE;            OK = TRUE;
2014            break;            break;
2015    
# Line 2019  for (;;) Line 2045  for (;;)
2045          BOOL OK;          BOOL OK;
2046          switch (c)          switch (c)
2047            {            {
2048            HSPACE_CASES:            HSPACE_CASES:
2049            OK = TRUE;            OK = TRUE;
2050            break;            break;
2051    
# Line 2146  for (;;) Line 2172  for (;;)
2172            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
2173              reset_could_continue = TRUE;              reset_could_continue = TRUE;
2174            }            }
2175          else if (ptr[1] == CHAR_LF)          else if (RAWUCHARTEST(ptr + 1) == CHAR_LF)
2176            {            {
2177            ADD_NEW_DATA(-(state_offset + 1), 0, 1);            ADD_NEW_DATA(-(state_offset + 1), 0, 1);
2178            }            }
# Line 2162  for (;;) Line 2188  for (;;)
2188        case OP_NOT_VSPACE:        case OP_NOT_VSPACE:
2189        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2190          {          {
2191          VSPACE_CASES:          VSPACE_CASES:
2192          break;          break;
2193    
2194          default:          default:
# Line 2175  for (;;) Line 2201  for (;;)
2201        case OP_VSPACE:        case OP_VSPACE:
2202        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2203          {          {
2204          VSPACE_CASES:          VSPACE_CASES:
2205          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2206          break;          break;
2207    
2208          default:          default:
2209          break;          break;
2210          }          }
2211        break;        break;
# Line 2188  for (;;) Line 2214  for (;;)
2214        case OP_NOT_HSPACE:        case OP_NOT_HSPACE:
2215        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2216          {          {
2217          HSPACE_CASES:          HSPACE_CASES:
2218          break;          break;
2219    
2220          default:          default:
# Line 2201  for (;;) Line 2227  for (;;)
2227        case OP_HSPACE:        case OP_HSPACE:
2228        if (clen > 0) switch(c)        if (clen > 0) switch(c)
2229          {          {
2230          HSPACE_CASES:          HSPACE_CASES:
2231          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
2232          break;          break;
2233    
2234          default:          default:
2235          break;          break;
2236          }          }
2237        break;        break;
2238    
# Line 2260  for (;;) Line 2286  for (;;)
2286        if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }
2287        if (clen > 0)        if (clen > 0)
2288          {          {
2289          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2290          if (caseless)          if (caseless)
2291            {            {
2292  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2307  for (;;) Line 2333  for (;;)
2333        ADD_ACTIVE(state_offset + dlen + 1, 0);        ADD_ACTIVE(state_offset + dlen + 1, 0);
2334        if (clen > 0)        if (clen > 0)
2335          {          {
2336          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2337          if (caseless)          if (caseless)
2338            {            {
2339  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2352  for (;;) Line 2378  for (;;)
2378        ADD_ACTIVE(state_offset + dlen + 1, 0);        ADD_ACTIVE(state_offset + dlen + 1, 0);
2379        if (clen > 0)        if (clen > 0)
2380          {          {
2381          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2382          if (caseless)          if (caseless)
2383            {            {
2384  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2389  for (;;) Line 2415  for (;;)
2415        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
2416        if (clen > 0)        if (clen > 0)
2417          {          {
2418          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2419          if (caseless)          if (caseless)
2420            {            {
2421  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2433  for (;;) Line 2459  for (;;)
2459        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
2460        if (clen > 0)        if (clen > 0)
2461          {          {
2462          unsigned int otherd = NOTACHAR;          pcre_uint32 otherd = NOTACHAR;
2463          if (caseless)          if (caseless)
2464            {            {
2465  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
# Line 2531  for (;;) Line 2557  for (;;)
2557              { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }              { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
2558            if (isinclass)            if (isinclass)
2559              {              {
2560              int max = GET2(ecode, 1 + IMM2_SIZE);              unsigned int max = GET2(ecode, 1 + IMM2_SIZE);
2561              if (++count >= max && max != 0)   /* Max 0 => no limit */              if (++count >= max && max != 0)   /* Max 0 => no limit */
2562                { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }                { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
2563              else              else
# Line 2607  for (;;) Line 2633  for (;;)
2633              cb.version          = 1;   /* Version 1 of the callout block */              cb.version          = 1;   /* Version 1 of the callout block */
2634              cb.callout_number   = code[LINK_SIZE+2];              cb.callout_number   = code[LINK_SIZE+2];
2635              cb.offset_vector    = offsets;              cb.offset_vector    = offsets;
2636  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
2637              cb.subject          = (PCRE_SPTR)start_subject;              cb.subject          = (PCRE_SPTR)start_subject;
2638  #else  #elif defined COMPILE_PCRE16
2639              cb.subject          = (PCRE_SPTR16)start_subject;              cb.subject          = (PCRE_SPTR16)start_subject;
2640    #elif defined COMPILE_PCRE32
2641                cb.subject          = (PCRE_SPTR32)start_subject;
2642  #endif  #endif
2643              cb.subject_length   = (int)(end_subject - start_subject);              cb.subject_length   = (int)(end_subject - start_subject);
2644              cb.start_match      = (int)(current_subject - start_subject);              cb.start_match      = (int)(current_subject - start_subject);
# Line 2741  for (;;) Line 2769  for (;;)
2769            for (rc = rc*2 - 2; rc >= 0; rc -= 2)            for (rc = rc*2 - 2; rc >= 0; rc -= 2)
2770              {              {
2771              int charcount = local_offsets[rc+1] - local_offsets[rc];              int charcount = local_offsets[rc+1] - local_offsets[rc];
2772  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2773              if (utf)              if (utf)
2774                {                {
2775                const pcre_uchar *p = start_subject + local_offsets[rc];                const pcre_uchar *p = start_subject + local_offsets[rc];
# Line 2845  for (;;) Line 2873  for (;;)
2873              const pcre_uchar *p = ptr;              const pcre_uchar *p = ptr;
2874              const pcre_uchar *pp = local_ptr;              const pcre_uchar *pp = local_ptr;
2875              charcount = (int)(pp - p);              charcount = (int)(pp - p);
2876  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2877              if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;              if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
2878  #endif  #endif
2879              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));              ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
# Line 2927  for (;;) Line 2955  for (;;)
2955              }              }
2956            else            else
2957              {              {
2958  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
2959              if (utf)              if (utf)
2960                {                {
2961                const pcre_uchar *p = start_subject + local_offsets[0];                const pcre_uchar *p = start_subject + local_offsets[0];
# Line 2956  for (;;) Line 2984  for (;;)
2984          cb.version          = 1;   /* Version 1 of the callout block */          cb.version          = 1;   /* Version 1 of the callout block */
2985          cb.callout_number   = code[1];          cb.callout_number   = code[1];
2986          cb.offset_vector    = offsets;          cb.offset_vector    = offsets;
2987  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
2988          cb.subject          = (PCRE_SPTR)start_subject;          cb.subject          = (PCRE_SPTR)start_subject;
2989  #else  #elif defined COMPILE_PCRE16
2990          cb.subject          = (PCRE_SPTR16)start_subject;          cb.subject          = (PCRE_SPTR16)start_subject;
2991    #elif defined COMPILE_PCRE32
2992            cb.subject          = (PCRE_SPTR32)start_subject;
2993  #endif  #endif
2994          cb.subject_length   = (int)(end_subject - start_subject);          cb.subject_length   = (int)(end_subject - start_subject);
2995          cb.start_match      = (int)(current_subject - start_subject);          cb.start_match      = (int)(current_subject - start_subject);
# Line 3017  for (;;) Line 3047  for (;;)
3047            ptr > md->start_used_ptr)            /* Inspected non-empty string */            ptr > md->start_used_ptr)            /* Inspected non-empty string */
3048            )            )
3049          )          )
       {  
       if (offsetcount >= 2)  
         {  
         offsets[0] = (int)(md->start_used_ptr - start_subject);  
         offsets[1] = (int)(end_subject - start_subject);  
         }  
3050        match_count = PCRE_ERROR_PARTIAL;        match_count = PCRE_ERROR_PARTIAL;
       }  
   
3051      DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"      DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
3052        "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel, match_count,        "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel, match_count,
3053        rlevel*2-2, SP));        rlevel*2-2, SP));
# Line 3075  Returns:          > 0 => number of match Line 3097  Returns:          > 0 => number of match
3097                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
3098  */  */
3099    
3100  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
3101  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3102  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
3103    const char *subject, int length, int start_offset, int options, int *offsets,    const char *subject, int length, int start_offset, int options, int *offsets,
3104    int offsetcount, int *workspace, int wscount)    int offsetcount, int *workspace, int wscount)
3105  #else  #elif defined COMPILE_PCRE16
3106  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3107  pcre16_dfa_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,  pcre16_dfa_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
3108    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
3109    int offsetcount, int *workspace, int wscount)    int offsetcount, int *workspace, int wscount)
3110    #elif defined COMPILE_PCRE32
3111    PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
3112    pcre32_dfa_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
3113      PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
3114      int offsetcount, int *workspace, int wscount)
3115  #endif  #endif
3116  {  {
3117  REAL_PCRE *re = (REAL_PCRE *)argument_re;  REAL_PCRE *re = (REAL_PCRE *)argument_re;
# Line 3111  if (re == NULL || subject == NULL || wor Line 3138  if (re == NULL || subject == NULL || wor
3138     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
3139  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
3140  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
3141    if (length < 0) return PCRE_ERROR_BADLENGTH;
3142  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
3143    
3144  /* 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 3159  end_subject = (const pcre_uchar *)subjec Line 3187  end_subject = (const pcre_uchar *)subjec
3187  req_char_ptr = current_subject - 1;  req_char_ptr = current_subject - 1;
3188    
3189  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3190  /* PCRE_UTF16 has the same value as PCRE_UTF8. */  /* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
3191  utf = (re->options & PCRE_UTF8) != 0;  utf = (re->options & PCRE_UTF8) != 0;
3192  #else  #else
3193  utf = FALSE;  utf = FALSE;
# Line 3245  if (utf && (options & PCRE_NO_UTF8_CHECK Line 3273  if (utf && (options & PCRE_NO_UTF8_CHECK
3273        offsets[0] = erroroffset;        offsets[0] = erroroffset;
3274        offsets[1] = errorcode;        offsets[1] = errorcode;
3275        }        }
3276      return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0)?  #if defined COMPILE_PCRE8
3277        return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0) ?
3278        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
3279    #elif defined COMPILE_PCRE16
3280        return (errorcode <= PCRE_UTF16_ERR1 && (options & PCRE_PARTIAL_HARD) != 0) ?
3281          PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
3282    #elif defined COMPILE_PCRE32
3283        return PCRE_ERROR_BADUTF32;
3284    #endif
3285      }      }
3286    #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
3287    if (start_offset > 0 && start_offset < length &&    if (start_offset > 0 && start_offset < length &&
3288          NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))          NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
3289      return PCRE_ERROR_BADUTF8_OFFSET;      return PCRE_ERROR_BADUTF8_OFFSET;
3290    #endif
3291    }    }
3292  #endif  #endif
3293    
# Line 3360  for (;;) Line 3397  for (;;)
3397        if (has_first_char)        if (has_first_char)
3398          {          {
3399          if (first_char != first_char2)          if (first_char != first_char2)
3400              {
3401              pcre_uchar csc;
3402            while (current_subject < end_subject &&            while (current_subject < end_subject &&
3403                *current_subject != first_char && *current_subject != first_char2)                   (csc = RAWUCHARTEST(current_subject)) != first_char && csc != first_char2)
3404              current_subject++;              current_subject++;
3405              }
3406          else          else
3407            while (current_subject < end_subject &&            while (current_subject < end_subject &&
3408                   *current_subject != first_char)                   RAWUCHARTEST(current_subject) != first_char)
3409              current_subject++;              current_subject++;
3410          }          }
3411    
# Line 3395  for (;;) Line 3435  for (;;)
3435            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
3436            more character. */            more character. */
3437    
3438            if (current_subject[-1] == CHAR_CR &&            if (RAWUCHARTEST(current_subject - 1) == CHAR_CR &&
3439                 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&                 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
3440                 current_subject < end_subject &&                 current_subject < end_subject &&
3441                 *current_subject == CHAR_NL)                 RAWUCHARTEST(current_subject) == CHAR_NL)
3442              current_subject++;              current_subject++;
3443            }            }
3444          }          }
# Line 3409  for (;;) Line 3449  for (;;)
3449          {          {
3450          while (current_subject < end_subject)          while (current_subject < end_subject)
3451            {            {
3452            register unsigned int c = *current_subject;            register pcre_uint32 c = RAWUCHARTEST(current_subject);
3453  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
3454            if (c > 255) c = 255;            if (c > 255) c = 255;
3455  #endif  #endif
# Line 3475  for (;;) Line 3515  for (;;)
3515              {              {
3516              while (p < end_subject)              while (p < end_subject)
3517                {                {
3518                register int pp = *p++;                register pcre_uint32 pp = RAWUCHARINCTEST(p);
3519                if (pp == req_char || pp == req_char2) { p--; break; }                if (pp == req_char || pp == req_char2) { p--; break; }
3520                }                }
3521              }              }
# Line 3483  for (;;) Line 3523  for (;;)
3523              {              {
3524              while (p < end_subject)              while (p < end_subject)
3525                {                {
3526                if (*p++ == req_char) { p--; break; }                if (RAWUCHARINCTEST(p) == req_char) { p--; break; }
3527                }                }
3528              }              }
3529    
# Line 3521  for (;;) Line 3561  for (;;)
3561    /* Anything other than "no match" means we are done, always; otherwise, carry    /* Anything other than "no match" means we are done, always; otherwise, carry
3562    on only if not anchored. */    on only if not anchored. */
3563    
3564    if (rc != PCRE_ERROR_NOMATCH || anchored) return rc;    if (rc != PCRE_ERROR_NOMATCH || anchored)
3565        {
3566        if (rc == PCRE_ERROR_PARTIAL && offsetcount >= 2)
3567          {
3568          offsets[0] = (int)(md->start_used_ptr - (PCRE_PUCHAR)subject);
3569          offsets[1] = (int)(end_subject - (PCRE_PUCHAR)subject);
3570          if (offsetcount > 2)
3571            offsets[2] = (int)(current_subject - (PCRE_PUCHAR)subject);
3572          }
3573        return rc;
3574        }
3575    
3576    /* Advance to the next subject character unless we are at the end of a line    /* Advance to the next subject character unless we are at the end of a line
3577    and firstline is set. */    and firstline is set. */
# Line 3541  for (;;) Line 3591  for (;;)
3591    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
3592    or ANY or ANYCRLF, advance the match position by one more character. */    or ANY or ANYCRLF, advance the match position by one more character. */
3593    
3594    if (current_subject[-1] == CHAR_CR &&    if (RAWUCHARTEST(current_subject - 1) == CHAR_CR &&
3595        current_subject < end_subject &&        current_subject < end_subject &&
3596        *current_subject == CHAR_NL &&        RAWUCHARTEST(current_subject) == CHAR_NL &&
3597        (re->flags & PCRE_HASCRORLF) == 0 &&        (re->flags & PCRE_HASCRORLF) == 0 &&
3598          (md->nltype == NLTYPE_ANY ||          (md->nltype == NLTYPE_ANY ||
3599           md->nltype == NLTYPE_ANYCRLF ||           md->nltype == NLTYPE_ANYCRLF ||

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

  ViewVC Help
Powered by ViewVC 1.1.5