/[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 517 by ph10, Wed May 5 10:44:20 2010 UTC revision 579 by ph10, Wed Nov 24 17:39:25 2010 UTC
# Line 475  if (*first_op == OP_REVERSE) Line 475  if (*first_op == OP_REVERSE)
475    
476      {      {
477      gone_back = (current_subject - max_back < start_subject)?      gone_back = (current_subject - max_back < start_subject)?
478        current_subject - start_subject : max_back;        (int)(current_subject - start_subject) : max_back;
479      current_subject -= gone_back;      current_subject -= gone_back;
480      }      }
481    
# Line 492  if (*first_op == OP_REVERSE) Line 492  if (*first_op == OP_REVERSE)
492      int back = GET(end_code, 2+LINK_SIZE);      int back = GET(end_code, 2+LINK_SIZE);
493      if (back <= gone_back)      if (back <= gone_back)
494        {        {
495        int bstate = end_code - start_code + 2 + 2*LINK_SIZE;        int bstate = (int)(end_code - start_code + 2 + 2*LINK_SIZE);
496        ADD_NEW_DATA(-bstate, 0, gone_back - back);        ADD_NEW_DATA(-bstate, 0, gone_back - back);
497        }        }
498      end_code += GET(end_code, 1);      end_code += GET(end_code, 1);
# Line 528  else Line 528  else
528        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
529      do      do
530        {        {
531        ADD_NEW(end_code - start_code + length, 0);        ADD_NEW((int)(end_code - start_code + length), 0);
532        end_code += GET(end_code, 1);        end_code += GET(end_code, 1);
533        length = 1 + LINK_SIZE;        length = 1 + LINK_SIZE;
534        }        }
# Line 755  for (;;) Line 755  for (;;)
755            if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));            if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
756            if (offsetcount >= 2)            if (offsetcount >= 2)
757              {              {
758              offsets[0] = current_subject - start_subject;              offsets[0] = (int)(current_subject - start_subject);
759              offsets[1] = ptr - start_subject;              offsets[1] = (int)(ptr - start_subject);
760              DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,              DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
761                offsets[1] - offsets[0], current_subject));                offsets[1] - offsets[0], current_subject));
762              }              }
# Line 778  for (;;) Line 778  for (;;)
778        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
779        case OP_ALT:        case OP_ALT:
780        do { code += GET(code, 1); } while (*code == OP_ALT);        do { code += GET(code, 1); } while (*code == OP_ALT);
781        ADD_ACTIVE(code - start_code, 0);        ADD_ACTIVE((int)(code - start_code), 0);
782        break;        break;
783    
784        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 786  for (;;) Line 786  for (;;)
786        case OP_SBRA:        case OP_SBRA:
787        do        do
788          {          {
789          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);          ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
790          code += GET(code, 1);          code += GET(code, 1);
791          }          }
792        while (*code == OP_ALT);        while (*code == OP_ALT);
# Line 795  for (;;) Line 795  for (;;)
795        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
796        case OP_CBRA:        case OP_CBRA:
797        case OP_SCBRA:        case OP_SCBRA:
798        ADD_ACTIVE(code - start_code + 3 + LINK_SIZE,  0);        ADD_ACTIVE((int)(code - start_code + 3 + LINK_SIZE),  0);
799        code += GET(code, 1);        code += GET(code, 1);
800        while (*code == OP_ALT)        while (*code == OP_ALT)
801          {          {
802          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE,  0);          ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE),  0);
803          code += GET(code, 1);          code += GET(code, 1);
804          }          }
805        break;        break;
# Line 810  for (;;) Line 810  for (;;)
810        ADD_ACTIVE(state_offset + 1, 0);        ADD_ACTIVE(state_offset + 1, 0);
811        code += 1 + GET(code, 2);        code += 1 + GET(code, 2);
812        while (*code == OP_ALT) code += GET(code, 1);        while (*code == OP_ALT) code += GET(code, 1);
813        ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);        ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
814        break;        break;
815    
816        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
817        case OP_SKIPZERO:        case OP_SKIPZERO:
818        code += 1 + GET(code, 2);        code += 1 + GET(code, 2);
819        while (*code == OP_ALT) code += GET(code, 1);        while (*code == OP_ALT) code += GET(code, 1);
820        ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);        ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
821        break;        break;
822    
823        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 831  for (;;) Line 831  for (;;)
831    
832        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
833        case OP_EOD:        case OP_EOD:
834        if (ptr >= end_subject) { ADD_ACTIVE(state_offset + 1, 0); }        if (ptr >= end_subject)
835            {
836            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
837              could_continue = TRUE;
838            else { ADD_ACTIVE(state_offset + 1, 0); }
839            }
840        break;        break;
841    
842        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 871  for (;;) Line 876  for (;;)
876    
877        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
878        case OP_EODN:        case OP_EODN:
879        if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))        if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
880            could_continue = TRUE;
881          else if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
882          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
883        break;        break;
884    
# Line 879  for (;;) Line 886  for (;;)
886        case OP_DOLL:        case OP_DOLL:
887        if ((md->moptions & PCRE_NOTEOL) == 0)        if ((md->moptions & PCRE_NOTEOL) == 0)
888          {          {
889          if (clen == 0 ||          if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
890              could_continue = TRUE;
891            else if (clen == 0 ||
892              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
893                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)
894              ))              ))
# Line 922  for (;;) Line 931  for (;;)
931            if (utf8) BACKCHAR(temp);            if (utf8) BACKCHAR(temp);
932  #endif  #endif
933            GETCHARTEST(d, temp);            GETCHARTEST(d, temp);
934    #ifdef SUPPORT_UCP
935              if ((md->poptions & PCRE_UCP) != 0)
936                {
937                if (d == '_') left_word = TRUE; else
938                  {
939                  int cat = UCD_CATEGORY(d);
940                  left_word = (cat == ucp_L || cat == ucp_N);
941                  }
942                }
943              else
944    #endif
945            left_word = d < 256 && (ctypes[d] & ctype_word) != 0;            left_word = d < 256 && (ctypes[d] & ctype_word) != 0;
946            }            }
947          else left_word = 0;          else left_word = FALSE;
948    
949          if (clen > 0)          if (clen > 0)
950              {
951    #ifdef SUPPORT_UCP
952              if ((md->poptions & PCRE_UCP) != 0)
953                {
954                if (c == '_') right_word = TRUE; else
955                  {
956                  int cat = UCD_CATEGORY(c);
957                  right_word = (cat == ucp_L || cat == ucp_N);
958                  }
959                }
960              else
961    #endif
962            right_word = c < 256 && (ctypes[c] & ctype_word) != 0;            right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
963          else right_word = 0;            }
964            else right_word = FALSE;
965    
966          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))
967            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
# Line 955  for (;;) Line 988  for (;;)
988            break;            break;
989    
990            case PT_LAMP:            case PT_LAMP:
991            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
992                 prop->chartype == ucp_Lt;                 prop->chartype == ucp_Lt;
993            break;            break;
994    
# Line 970  for (;;) Line 1003  for (;;)
1003            case PT_SC:            case PT_SC:
1004            OK = prop->script == code[2];            OK = prop->script == code[2];
1005            break;            break;
1006    
1007            /* These are specials for combination cases. */            /* These are specials for combination cases. */
1008    
1009            case PT_ALNUM:            case PT_ALNUM:
1010            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1011                 _pcre_ucp_gentype[prop->chartype] == ucp_N;                 _pcre_ucp_gentype[prop->chartype] == ucp_N;
1012            break;            break;
1013    
1014            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
1015            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1016                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1017            break;            break;
1018    
1019            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1020            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1021                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1022                 c == CHAR_FF || c == CHAR_CR;                 c == CHAR_FF || c == CHAR_CR;
1023            break;            break;
1024    
1025            case PT_WORD:            case PT_WORD:
1026            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1027                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1028                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1029            break;            break;
1030    
1031            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1032    
# Line 1149  for (;;) Line 1182  for (;;)
1182            break;            break;
1183    
1184            case PT_LAMP:            case PT_LAMP:
1185            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1186              prop->chartype == ucp_Lt;              prop->chartype == ucp_Lt;
1187            break;            break;
1188    
# Line 1166  for (;;) Line 1199  for (;;)
1199            break;            break;
1200    
1201            /* These are specials for combination cases. */            /* These are specials for combination cases. */
1202    
1203            case PT_ALNUM:            case PT_ALNUM:
1204            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1205                 _pcre_ucp_gentype[prop->chartype] == ucp_N;                 _pcre_ucp_gentype[prop->chartype] == ucp_N;
1206            break;            break;
1207    
1208            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
1209            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1210                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1211            break;            break;
1212    
1213            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1214            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1215                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1216                 c == CHAR_FF || c == CHAR_CR;                 c == CHAR_FF || c == CHAR_CR;
1217            break;            break;
1218    
1219            case PT_WORD:            case PT_WORD:
1220            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1221                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1222                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1223            break;            break;
1224    
1225            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1226    
# Line 1396  for (;;) Line 1429  for (;;)
1429            break;            break;
1430    
1431            case PT_LAMP:            case PT_LAMP:
1432            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1433              prop->chartype == ucp_Lt;              prop->chartype == ucp_Lt;
1434            break;            break;
1435    
# Line 1411  for (;;) Line 1444  for (;;)
1444            case PT_SC:            case PT_SC:
1445            OK = prop->script == code[3];            OK = prop->script == code[3];
1446            break;            break;
1447    
1448            /* These are specials for combination cases. */            /* These are specials for combination cases. */
1449    
1450            case PT_ALNUM:            case PT_ALNUM:
1451            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1452                 _pcre_ucp_gentype[prop->chartype] == ucp_N;                 _pcre_ucp_gentype[prop->chartype] == ucp_N;
1453            break;            break;
1454    
1455            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
1456            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1457                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1458            break;            break;
1459    
1460            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1461            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1462                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1463                 c == CHAR_FF || c == CHAR_CR;                 c == CHAR_FF || c == CHAR_CR;
1464            break;            break;
1465    
1466            case PT_WORD:            case PT_WORD:
1467            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1468                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1469                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1470            break;            break;
1471    
1472            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1473    
# Line 1668  for (;;) Line 1701  for (;;)
1701            break;            break;
1702    
1703            case PT_LAMP:            case PT_LAMP:
1704            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1705              prop->chartype == ucp_Lt;              prop->chartype == ucp_Lt;
1706            break;            break;
1707    
# Line 1683  for (;;) Line 1716  for (;;)
1716            case PT_SC:            case PT_SC:
1717            OK = prop->script == code[5];            OK = prop->script == code[5];
1718            break;            break;
1719    
1720            /* These are specials for combination cases. */            /* These are specials for combination cases. */
1721    
1722            case PT_ALNUM:            case PT_ALNUM:
1723            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1724                 _pcre_ucp_gentype[prop->chartype] == ucp_N;                 _pcre_ucp_gentype[prop->chartype] == ucp_N;
1725            break;            break;
1726    
1727            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
1728            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1729                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1730            break;            break;
1731    
1732            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
1733            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1734                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1735                 c == CHAR_FF || c == CHAR_CR;                 c == CHAR_FF || c == CHAR_CR;
1736            break;            break;
1737    
1738            case PT_WORD:            case PT_WORD:
1739            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||            OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1740                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1741                 c == CHAR_UNDERSCORE;                 c == CHAR_UNDERSCORE;
1742            break;            break;
1743    
1744            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1745    
# Line 2335  for (;;) Line 2368  for (;;)
2368          points to the byte after the end of the class. If there is a          points to the byte after the end of the class. If there is a
2369          quantifier, this is where it will be. */          quantifier, this is where it will be. */
2370    
2371          next_state_offset = ecode - start_code;          next_state_offset = (int)(ecode - start_code);
2372    
2373          switch (*ecode)          switch (*ecode)
2374            {            {
# Line 2406  for (;;) Line 2439  for (;;)
2439            md,                                   /* static match data */            md,                                   /* static match data */
2440            code,                                 /* this subexpression's code */            code,                                 /* this subexpression's code */
2441            ptr,                                  /* where we currently are */            ptr,                                  /* where we currently are */
2442            ptr - start_subject,                  /* start offset */            (int)(ptr - start_subject),           /* start offset */
2443            local_offsets,                        /* offset vector */            local_offsets,                        /* offset vector */
2444            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2445            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
# Line 2417  for (;;) Line 2450  for (;;)
2450    
2451          if (rc == PCRE_ERROR_DFA_UITEM) return rc;          if (rc == PCRE_ERROR_DFA_UITEM) return rc;
2452          if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))          if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))
2453              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }              { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
2454          }          }
2455        break;        break;
2456    
# Line 2444  for (;;) Line 2477  for (;;)
2477              cb.callout_number   = code[LINK_SIZE+2];              cb.callout_number   = code[LINK_SIZE+2];
2478              cb.offset_vector    = offsets;              cb.offset_vector    = offsets;
2479              cb.subject          = (PCRE_SPTR)start_subject;              cb.subject          = (PCRE_SPTR)start_subject;
2480              cb.subject_length   = end_subject - start_subject;              cb.subject_length   = (int)(end_subject - start_subject);
2481              cb.start_match      = current_subject - start_subject;              cb.start_match      = (int)(current_subject - start_subject);
2482              cb.current_position = ptr - start_subject;              cb.current_position = (int)(ptr - start_subject);
2483              cb.pattern_position = GET(code, LINK_SIZE + 3);              cb.pattern_position = GET(code, LINK_SIZE + 3);
2484              cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);              cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
2485              cb.capture_top      = 1;              cb.capture_top      = 1;
# Line 2497  for (;;) Line 2530  for (;;)
2530              md,                                   /* fixed match data */              md,                                   /* fixed match data */
2531              asscode,                              /* this subexpression's code */              asscode,                              /* this subexpression's code */
2532              ptr,                                  /* where we currently are */              ptr,                                  /* where we currently are */
2533              ptr - start_subject,                  /* start offset */              (int)(ptr - start_subject),           /* start offset */
2534              local_offsets,                        /* offset vector */              local_offsets,                        /* offset vector */
2535              sizeof(local_offsets)/sizeof(int),    /* size of same */              sizeof(local_offsets)/sizeof(int),    /* size of same */
2536              local_workspace,                      /* workspace vector */              local_workspace,                      /* workspace vector */
# Line 2509  for (;;) Line 2542  for (;;)
2542            if (rc == PCRE_ERROR_DFA_UITEM) return rc;            if (rc == PCRE_ERROR_DFA_UITEM) return rc;
2543            if ((rc >= 0) ==            if ((rc >= 0) ==
2544                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
2545              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }              { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
2546            else            else
2547              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2548            }            }
# Line 2530  for (;;) Line 2563  for (;;)
2563            md,                                   /* fixed match data */            md,                                   /* fixed match data */
2564            start_code + GET(code, 1),            /* this subexpression's code */            start_code + GET(code, 1),            /* this subexpression's code */
2565            ptr,                                  /* where we currently are */            ptr,                                  /* where we currently are */
2566            ptr - start_subject,                  /* start offset */            (int)(ptr - start_subject),           /* start offset */
2567            local_offsets,                        /* offset vector */            local_offsets,                        /* offset vector */
2568            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2569            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
# Line 2582  for (;;) Line 2615  for (;;)
2615            md,                                   /* fixed match data */            md,                                   /* fixed match data */
2616            code,                                 /* this subexpression's code */            code,                                 /* this subexpression's code */
2617            ptr,                                  /* where we currently are */            ptr,                                  /* where we currently are */
2618            ptr - start_subject,                  /* start offset */            (int)(ptr - start_subject),           /* start offset */
2619            local_offsets,                        /* offset vector */            local_offsets,                        /* offset vector */
2620            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2621            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
# Line 2599  for (;;) Line 2632  for (;;)
2632    
2633            do { end_subpattern += GET(end_subpattern, 1); }            do { end_subpattern += GET(end_subpattern, 1); }
2634              while (*end_subpattern == OP_ALT);              while (*end_subpattern == OP_ALT);
2635            next_state_offset = end_subpattern - start_code + LINK_SIZE + 1;            next_state_offset =
2636                (int)(end_subpattern - start_code + LINK_SIZE + 1);
2637    
2638            /* If the end of this subpattern is KETRMAX or KETRMIN, we must            /* If the end of this subpattern is KETRMAX or KETRMIN, we must
2639            arrange for the repeat state also to be added to the relevant list.            arrange for the repeat state also to be added to the relevant list.
# Line 2607  for (;;) Line 2641  for (;;)
2641    
2642            repeat_state_offset = (*end_subpattern == OP_KETRMAX ||            repeat_state_offset = (*end_subpattern == OP_KETRMAX ||
2643                                   *end_subpattern == OP_KETRMIN)?                                   *end_subpattern == OP_KETRMIN)?
2644              end_subpattern - start_code - GET(end_subpattern, 1) : -1;              (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1;
2645    
2646            /* If we have matched an empty string, add the next state at the            /* If we have matched an empty string, add the next state at the
2647            current character pointer. This is important so that the duplicate            current character pointer. This is important so that the duplicate
# Line 2671  for (;;) Line 2705  for (;;)
2705          cb.callout_number   = code[1];          cb.callout_number   = code[1];
2706          cb.offset_vector    = offsets;          cb.offset_vector    = offsets;
2707          cb.subject          = (PCRE_SPTR)start_subject;          cb.subject          = (PCRE_SPTR)start_subject;
2708          cb.subject_length   = end_subject - start_subject;          cb.subject_length   = (int)(end_subject - start_subject);
2709          cb.start_match      = current_subject - start_subject;          cb.start_match      = (int)(current_subject - start_subject);
2710          cb.current_position = ptr - start_subject;          cb.current_position = (int)(ptr - start_subject);
2711          cb.pattern_position = GET(code, 2);          cb.pattern_position = GET(code, 2);
2712          cb.next_item_length = GET(code, 2 + LINK_SIZE);          cb.next_item_length = GET(code, 2 + LINK_SIZE);
2713          cb.capture_top      = 1;          cb.capture_top      = 1;
# Line 2719  for (;;) Line 2753  for (;;)
2753          ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */          ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
2754           match_count < 0)                            /* no matches */           match_count < 0)                            /* no matches */
2755          ) &&                                         /* And... */          ) &&                                         /* And... */
2756          ptr >= end_subject &&                     /* Reached end of subject */          ptr >= end_subject &&                  /* Reached end of subject */
2757          ptr > current_subject)                    /* Matched non-empty string */          ptr > md->start_used_ptr)              /* Inspected non-empty string */
2758        {        {
2759        if (offsetcount >= 2)        if (offsetcount >= 2)
2760          {          {
2761          offsets[0] = md->start_used_ptr - start_subject;          offsets[0] = (int)(md->start_used_ptr - start_subject);
2762          offsets[1] = end_subject - start_subject;          offsets[1] = (int)(end_subject - start_subject);
2763          }          }
2764        match_count = PCRE_ERROR_PARTIAL;        match_count = PCRE_ERROR_PARTIAL;
2765        }        }
# Line 2810  if (re == NULL || subject == NULL || wor Line 2844  if (re == NULL || subject == NULL || wor
2844     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
2845  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
2846  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
2847    if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
2848    
2849  /* We need to find the pointer to any study data before we test for byte  /* We need to find the pointer to any study data before we test for byte
2850  flipping, so we scan the extra_data block first. This may set two fields in the  flipping, so we scan the extra_data block first. This may set two fields in the
# Line 2928  back the character offset. */ Line 2963  back the character offset. */
2963  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2964  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
2965    {    {
2966    if (_pcre_valid_utf8((uschar *)subject, length) >= 0)    int tb;
2967      return PCRE_ERROR_BADUTF8;    if ((tb = _pcre_valid_utf8((uschar *)subject, length)) >= 0)
2968        return (tb == length && (options & PCRE_PARTIAL_HARD) != 0)?
2969          PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
2970    if (start_offset > 0 && start_offset < length)    if (start_offset > 0 && start_offset < length)
2971      {      {
2972      int tb = ((uschar *)subject)[start_offset];      tb = ((USPTR)subject)[start_offset] & 0xc0;
2973      if (tb > 127)      if (tb == 0x80) return PCRE_ERROR_BADUTF8_OFFSET;
       {  
       tb &= 0xc0;  
       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;  
       }  
2974      }      }
2975    }    }
2976  #endif  #endif
# Line 3024  for (;;) Line 3057  for (;;)
3057    
3058      /* There are some optimizations that avoid running the match if a known      /* There are some optimizations that avoid running the match if a known
3059      starting point is not found. However, there is an option that disables      starting point is not found. However, there is an option that disables
3060      these, for testing and for ensuring that all callouts do actually occur. */      these, for testing and for ensuring that all callouts do actually occur.
3061        The option can be set in the regex by (*NO_START_OPT) or passed in
3062        match-time options. */
3063    
3064      if ((options & PCRE_NO_START_OPTIMIZE) == 0)      if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
3065        {        {
3066        /* Advance to a known first byte. */        /* Advance to a known first byte. */
3067    
# Line 3084  for (;;) Line 3119  for (;;)
3119          while (current_subject < end_subject)          while (current_subject < end_subject)
3120            {            {
3121            register unsigned int c = *current_subject;            register unsigned int c = *current_subject;
3122            if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;            if ((start_bits[c/8] & (1 << (c&7))) == 0)
3123              else break;              {
3124                current_subject++;
3125    #ifdef SUPPORT_UTF8
3126                if (utf8)
3127                  while(current_subject < end_subject &&
3128                        (*current_subject & 0xc0) == 0x80) current_subject++;
3129    #endif
3130                }
3131              else break;
3132            }            }
3133          }          }
3134        }        }
Legend:
Removed from v.517  
changed lines
  Added in v.579
webmaster@exim.org
 ViewVC Help
Powered by ViewVC 1.1.12