/[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 498 by ph10, Wed Mar 3 19:29:38 2010 UTC revision 579 by ph10, Wed Nov 24 17:39:25 2010 UTC
# Line 106  never stored, so we push them well clear Line 106  never stored, so we push them well clear
106    
107    
108  /* This table identifies those opcodes that are followed immediately by a  /* This table identifies those opcodes that are followed immediately by a
109  character that is to be tested in some way. This makes is possible to  character that is to be tested in some way. This makes it possible to
110  centralize the loading of these characters. In the case of Type * etc, the  centralize the loading of these characters. In the case of Type * etc, the
111  "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a  "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a
112  small value. Non-zero values in the table are the offsets from the opcode where  small value. Non-zero values in the table are the offsets from the opcode where
# Line 161  static const uschar coptable[] = { Line 161  static const uschar coptable[] = {
161    0, 0,                          /* RREF, NRREF                            */    0, 0,                          /* RREF, NRREF                            */
162    0,                             /* DEF                                    */    0,                             /* DEF                                    */
163    0, 0,                          /* BRAZERO, BRAMINZERO                    */    0, 0,                          /* BRAZERO, BRAMINZERO                    */
164    0, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
165    0, 0, 0, 0                     /* FAIL, ACCEPT, CLOSE, SKIPZERO          */    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
166      0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
167  };  };
168    
169  /* This table identifies those opcodes that inspect a character. It is used to  /* This table identifies those opcodes that inspect a character. It is used to
# Line 218  static const uschar poptable[] = { Line 219  static const uschar poptable[] = {
219    0, 0,                          /* RREF, NRREF                            */    0, 0,                          /* RREF, NRREF                            */
220    0,                             /* DEF                                    */    0,                             /* DEF                                    */
221    0, 0,                          /* BRAZERO, BRAMINZERO                    */    0, 0,                          /* BRAZERO, BRAMINZERO                    */
222    0, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
223    0, 0, 0, 0                     /* FAIL, ACCEPT, CLOSE, SKIPZERO          */    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
224      0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
225  };  };
226    
227  /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,  /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,
# Line 473  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 490  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 526  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 714  for (;;) Line 716  for (;;)
716        opcode, are not the correct length. It seems to be the only way to do        opcode, are not the correct length. It seems to be the only way to do
717        such a check at compile time, as the sizeof() operator does not work        such a check at compile time, as the sizeof() operator does not work
718        in the C preprocessor. */        in the C preprocessor. */
719    
720        case OP_TABLE_LENGTH:        case OP_TABLE_LENGTH:
721        case OP_TABLE_LENGTH +        case OP_TABLE_LENGTH +
722          ((sizeof(coptable) == OP_TABLE_LENGTH) &&          ((sizeof(coptable) == OP_TABLE_LENGTH) &&
723           (sizeof(poptable) == OP_TABLE_LENGTH)):           (sizeof(poptable) == OP_TABLE_LENGTH)):
724        break;        break;
725    
726  /* ========================================================================== */  /* ========================================================================== */
727        /* Reached a closing bracket. If not at the end of the pattern, carry        /* Reached a closing bracket. If not at the end of the pattern, carry
# Line 753  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 776  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 784  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 793  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 808  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 829  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 869  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 877  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 920  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 953  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 || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
992                   prop->chartype == ucp_Lt;
993            break;            break;
994    
995            case PT_GC:            case PT_GC:
# Line 968  for (;;) Line 1004  for (;;)
1004            OK = prop->script == code[2];            OK = prop->script == code[2];
1005            break;            break;
1006    
1007              /* These are specials for combination cases. */
1008    
1009              case PT_ALNUM:
1010              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1011                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1012              break;
1013    
1014              case PT_SPACE:    /* Perl space */
1015              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1016                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1017              break;
1018    
1019              case PT_PXSPACE:  /* POSIX space */
1020              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1021                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1022                   c == CHAR_FF || c == CHAR_CR;
1023              break;
1024    
1025              case PT_WORD:
1026              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1027                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1028                   c == CHAR_UNDERSCORE;
1029              break;
1030    
1031            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1032    
1033            default:            default:
# Line 1122  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 || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1186                prop->chartype == ucp_Lt;
1187            break;            break;
1188    
1189            case PT_GC:            case PT_GC:
# Line 1137  for (;;) Line 1198  for (;;)
1198            OK = prop->script == code[3];            OK = prop->script == code[3];
1199            break;            break;
1200    
1201              /* These are specials for combination cases. */
1202    
1203              case PT_ALNUM:
1204              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1205                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1206              break;
1207    
1208              case PT_SPACE:    /* Perl space */
1209              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1210                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1211              break;
1212    
1213              case PT_PXSPACE:  /* POSIX space */
1214              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1215                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1216                   c == CHAR_FF || c == CHAR_CR;
1217              break;
1218    
1219              case PT_WORD:
1220              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1221                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1222                   c == CHAR_UNDERSCORE;
1223              break;
1224    
1225            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1226    
1227            default:            default:
# Line 1344  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 || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1433                prop->chartype == ucp_Lt;
1434            break;            break;
1435    
1436            case PT_GC:            case PT_GC:
# Line 1359  for (;;) Line 1445  for (;;)
1445            OK = prop->script == code[3];            OK = prop->script == code[3];
1446            break;            break;
1447    
1448              /* These are specials for combination cases. */
1449    
1450              case PT_ALNUM:
1451              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1452                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1453              break;
1454    
1455              case PT_SPACE:    /* Perl space */
1456              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1457                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1458              break;
1459    
1460              case PT_PXSPACE:  /* POSIX space */
1461              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1462                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1463                   c == CHAR_FF || c == CHAR_CR;
1464              break;
1465    
1466              case PT_WORD:
1467              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1468                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1469                   c == CHAR_UNDERSCORE;
1470              break;
1471    
1472            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1473    
1474            default:            default:
# Line 1591  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 || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1705                prop->chartype == ucp_Lt;
1706            break;            break;
1707    
1708            case PT_GC:            case PT_GC:
# Line 1606  for (;;) Line 1717  for (;;)
1717            OK = prop->script == code[5];            OK = prop->script == code[5];
1718            break;            break;
1719    
1720              /* These are specials for combination cases. */
1721    
1722              case PT_ALNUM:
1723              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1724                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1725              break;
1726    
1727              case PT_SPACE:    /* Perl space */
1728              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1729                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1730              break;
1731    
1732              case PT_PXSPACE:  /* POSIX space */
1733              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1734                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1735                   c == CHAR_FF || c == CHAR_CR;
1736              break;
1737    
1738              case PT_WORD:
1739              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1740                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1741                   c == CHAR_UNDERSCORE;
1742              break;
1743    
1744            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1745    
1746            default:            default:
# Line 2233  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 2304  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 2315  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 2342  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 2395  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 2407  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 2428  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 2480  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 2497  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 2505  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 2569  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 2617  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 2708  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 2826  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 2922  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 2982  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.498  
changed lines
  Added in v.579

  ViewVC Help
Powered by ViewVC 1.1.5