/[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 463 by ph10, Sun Oct 18 10:02:46 2009 UTC revision 569 by ph10, Sun Nov 7 16:14:50 2010 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-2009 University of Cambridge             Copyright (c) 1997-2010 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 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 118  static const uschar coptable[] = { Line 118  static const uschar coptable[] = {
118    0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */    0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
119    0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */    0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
120    0, 0, 0,                       /* Any, AllAny, Anybyte                   */    0, 0, 0,                       /* Any, AllAny, Anybyte                   */
121    0, 0, 0,                       /* NOTPROP, PROP, EXTUNI                  */    0, 0,                          /* \P, \p                                 */
122    0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */    0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
123      0,                             /* \X                                     */
124    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
125    1,                             /* Char                                   */    1,                             /* Char                                   */
126    1,                             /* Charnc                                 */    1,                             /* Charnc                                 */
# Line 156  static const uschar coptable[] = { Line 157  static const uschar coptable[] = {
157    0,                             /* Reverse                                */    0,                             /* Reverse                                */
158    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
159    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
160    0,                             /* CREF                                   */    0, 0,                          /* CREF, NCREF                            */
161    0,                             /* RREF                                   */    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 174  static const uschar poptable[] = { Line 176  static const uschar poptable[] = {
176    0, 0, 0, 1, 1,                 /* \A, \G, \K, \B, \b                     */    0, 0, 0, 1, 1,                 /* \A, \G, \K, \B, \b                     */
177    1, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */    1, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */
178    1, 1, 1,                       /* Any, AllAny, Anybyte                   */    1, 1, 1,                       /* Any, AllAny, Anybyte                   */
179    1, 1, 1,                       /* NOTPROP, PROP, EXTUNI                  */    1, 1,                          /* \P, \p                                 */
180    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */
181      1,                             /* \X                                     */
182    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
183    1,                             /* Char                                   */    1,                             /* Char                                   */
184    1,                             /* Charnc                                 */    1,                             /* Charnc                                 */
# Line 212  static const uschar poptable[] = { Line 215  static const uschar poptable[] = {
215    0,                             /* Reverse                                */    0,                             /* Reverse                                */
216    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
217    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
218    0,                             /* CREF                                   */    0, 0,                          /* CREF, NCREF                            */
219    0,                             /* RREF                                   */    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 255  typedef struct stateblock { Line 259  typedef struct stateblock {
259  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))
260    
261    
262  #ifdef DEBUG  #ifdef PCRE_DEBUG
263  /*************************************************  /*************************************************
264  *             Print character string             *  *             Print character string             *
265  *************************************************/  *************************************************/
# Line 471  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 488  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 524  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 559  for (;;) Line 563  for (;;)
563    workspace[0] ^= 1;              /* Remember for the restarting feature */    workspace[0] ^= 1;              /* Remember for the restarting feature */
564    workspace[1] = active_count;    workspace[1] = active_count;
565    
566  #ifdef DEBUG  #ifdef PCRE_DEBUG
567    printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);    printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);
568    pchars((uschar *)ptr, strlen((char *)ptr), stdout);    pchars((uschar *)ptr, strlen((char *)ptr), stdout);
569    printf("\"\n");    printf("\"\n");
# Line 605  for (;;) Line 609  for (;;)
609      int state_offset = current_state->offset;      int state_offset = current_state->offset;
610      int count, codevalue, rrc;      int count, codevalue, rrc;
611    
612  #ifdef DEBUG  #ifdef PCRE_DEBUG
613      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
614      if (clen == 0) printf("EOL\n");      if (clen == 0) printf("EOL\n");
615        else if (c > 32 && c < 127) printf("'%c'\n", c);        else if (c > 32 && c < 127) printf("'%c'\n", c);
# Line 706  for (;;) Line 710  for (;;)
710    
711      switch (codevalue)      switch (codevalue)
712        {        {
713    /* ========================================================================== */
714          /* These cases are never obeyed. This is a fudge that causes a compile-
715          time error if the vectors coptable or poptable, which are indexed by
716          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
718          in the C preprocessor. */
719    
720          case OP_TABLE_LENGTH:
721          case OP_TABLE_LENGTH +
722            ((sizeof(coptable) == OP_TABLE_LENGTH) &&
723             (sizeof(poptable) == OP_TABLE_LENGTH)):
724          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 739  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 762  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 770  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 779  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 794  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 815  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 855  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 863  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 906  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 939  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 954  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 1108  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 1123  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 1330  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 1345  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 1577  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 1592  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 2219  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 2290  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 2299  for (;;) Line 2448  for (;;)
2448            rlevel,                               /* function recursion level */            rlevel,                               /* function recursion level */
2449            recursing);                           /* pass on regex recursion */            recursing);                           /* pass on regex recursion */
2450    
2451            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 2327  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 2380  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 2389  for (;;) Line 2539  for (;;)
2539              rlevel,                               /* function recursion level */              rlevel,                               /* function recursion level */
2540              recursing);                           /* pass on regex recursion */              recursing);                           /* pass on regex recursion */
2541    
2542              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 2412  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 2464  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 2481  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 2489  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 2553  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 2601  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 2692  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 2810  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 2966  for (;;) Line 3117  for (;;)
3117          while (current_subject < end_subject)          while (current_subject < end_subject)
3118            {            {
3119            register unsigned int c = *current_subject;            register unsigned int c = *current_subject;
3120            if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;            if ((start_bits[c/8] & (1 << (c&7))) == 0)
3121              else break;              {
3122                current_subject++;
3123    #ifdef SUPPORT_UTF8
3124                if (utf8)
3125                  while(current_subject < end_subject &&
3126                        (*current_subject & 0xc0) == 0x80) current_subject++;
3127    #endif
3128                }
3129              else break;
3130            }            }
3131          }          }
3132        }        }
# Line 2989  for (;;) Line 3148  for (;;)
3148        bytes to avoid spending too much time in this optimization. */        bytes to avoid spending too much time in this optimization. */
3149    
3150        if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&        if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
3151            end_subject - current_subject < study->minlength)            (pcre_uint32)(end_subject - current_subject) < study->minlength)
3152          return PCRE_ERROR_NOMATCH;          return PCRE_ERROR_NOMATCH;
3153    
3154        /* If req_byte is set, we know that that character must appear in the        /* If req_byte is set, we know that that character must appear in the
Legend:
Removed from v.463  
changed lines
  Added in v.569
webmaster@exim.org
 ViewVC Help
Powered by ViewVC 1.1.12