/[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 93 by nigel, Sat Feb 24 21:41:42 2007 UTC revision 345 by ph10, Mon Apr 28 15:10:02 2008 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2006 University of Cambridge             Copyright (c) 1997-2008 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 44  FSM). This is NOT Perl- compatible, but Line 44  FSM). This is NOT Perl- compatible, but
44  applications. */  applications. */
45    
46    
47    #ifdef HAVE_CONFIG_H
48    #include "config.h"
49    #endif
50    
51  #define NLBLOCK md             /* Block containing newline information */  #define NLBLOCK md             /* Block containing newline information */
52  #define PSSTART start_subject  /* Field containing processed string start */  #define PSSTART start_subject  /* Field containing processed string start */
53  #define PSEND   end_subject    /* Field containing processed string end */  #define PSEND   end_subject    /* Field containing processed string end */
# Line 63  applications. */ Line 67  applications. */
67    
68  /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes  /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes
69  into others, under special conditions. A gap of 20 between the blocks should be  into others, under special conditions. A gap of 20 between the blocks should be
70  enough. */  enough. The resulting opcodes don't have to be less than 256 because they are
71    never stored, so we push them well clear of the normal opcodes. */
72    
73  #define OP_PROP_EXTRA 100  #define OP_PROP_EXTRA       300
74  #define OP_EXTUNI_EXTRA 120  #define OP_EXTUNI_EXTRA     320
75  #define OP_ANYNL_EXTRA 140  #define OP_ANYNL_EXTRA      340
76    #define OP_HSPACE_EXTRA     360
77    #define OP_VSPACE_EXTRA     380
78    
79    
80  /* This table identifies those opcodes that are followed immediately by a  /* This table identifies those opcodes that are followed immediately by a
81  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 is possible to
82  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
83  "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
84  small value. */  small value. ***NOTE*** If the start of this table is modified, the two tables
85    that follow must also be modified. */
86    
87  static uschar coptable[] = {  static const uschar coptable[] = {
88    0,                             /* End                                    */    0,                             /* End                                    */
89    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* \A, \G, \B, \b, \D, \d, \S, \s, \W, \w */    0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
90    0, 0,                          /* Any, Anybyte                           */    0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
91    0, 0, 0, 0,                    /* NOTPROP, PROP, EXTUNI, ANYNL           */    0, 0, 0,                       /* Any, AllAny, Anybyte                   */
92      0, 0, 0,                       /* NOTPROP, PROP, EXTUNI                  */
93      0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
94    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
95    1,                             /* Char                                   */    1,                             /* Char                                   */
96    1,                             /* Charnc                                 */    1,                             /* Charnc                                 */
# Line 120  static uschar coptable[] = { Line 130  static uschar coptable[] = {
130    0,                             /* CREF                                   */    0,                             /* CREF                                   */
131    0,                             /* RREF                                   */    0,                             /* RREF                                   */
132    0,                             /* DEF                                    */    0,                             /* DEF                                    */
133    0, 0                           /* BRAZERO, BRAMINZERO                    */    0, 0,                          /* BRAZERO, BRAMINZERO                    */
134      0, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */
135      0, 0, 0                        /* FAIL, ACCEPT, SKIPZERO                 */
136  };  };
137    
138  /* 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,
139  and \w */  and \w */
140    
141  static uschar toptable1[] = {  static const uschar toptable1[] = {
142    0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0,
143    ctype_digit, ctype_digit,    ctype_digit, ctype_digit,
144    ctype_space, ctype_space,    ctype_space, ctype_space,
145    ctype_word,  ctype_word,    ctype_word,  ctype_word,
146    0                               /* OP_ANY */    0, 0                            /* OP_ANY, OP_ALLANY */
147  };  };
148    
149  static uschar toptable2[] = {  static const uschar toptable2[] = {
150    0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0,
151    ctype_digit, 0,    ctype_digit, 0,
152    ctype_space, 0,    ctype_space, 0,
153    ctype_word,  0,    ctype_word,  0,
154    1                               /* OP_ANY */    1, 1                            /* OP_ANY, OP_ALLANY */
155  };  };
156    
157    
# Line 211  Arguments: Line 223  Arguments:
223    rlevel            function call recursion level    rlevel            function call recursion level
224    recursing         regex recursive call level    recursing         regex recursive call level
225    
226  Returns:            > 0 =>  Returns:            > 0 => number of match offset pairs placed in offsets
227                      = 0 =>                      = 0 => offsets overflowed; longest matches are present
228                       -1 => failed to match                       -1 => failed to match
229                     < -1 => some kind of unexpected problem                     < -1 => some kind of unexpected problem
230    
# Line 500  for (;;) Line 512  for (;;)
512      const uschar *code;      const uschar *code;
513      int state_offset = current_state->offset;      int state_offset = current_state->offset;
514      int count, codevalue;      int count, codevalue;
515    #ifdef SUPPORT_UCP
516      int chartype, script;      int chartype, script;
517    #endif
518    
519  #ifdef DEBUG  #ifdef DEBUG
520      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
# Line 555  for (;;) Line 569  for (;;)
569      permitted.      permitted.
570    
571      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
572      argument that is not a data character - but is always one byte long.      argument that is not a data character - but is always one byte long. We
573      Unfortunately, we have to take special action to deal with  \P, \p, and      have to take special action to deal with  \P, \p, \H, \h, \V, \v and \X in
574      \X in this case. To keep the other cases fast, convert these ones to new      this case. To keep the other cases fast, convert these ones to new opcodes.
575      opcodes. */      */
576    
577      if (coptable[codevalue] > 0)      if (coptable[codevalue] > 0)
578        {        {
# Line 576  for (;;) Line 590  for (;;)
590            case OP_PROP: codevalue += OP_PROP_EXTRA; break;            case OP_PROP: codevalue += OP_PROP_EXTRA; break;
591            case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;            case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;
592            case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;            case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;
593              case OP_NOT_HSPACE:
594              case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break;
595              case OP_NOT_VSPACE:
596              case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break;
597            default: break;            default: break;
598            }            }
599          }          }
# Line 676  for (;;) Line 694  for (;;)
694        break;        break;
695    
696        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
697          case OP_SKIPZERO:
698          code += 1 + GET(code, 2);
699          while (*code == OP_ALT) code += GET(code, 1);
700          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);
701          break;
702    
703          /*-----------------------------------------------------------------*/
704        case OP_CIRC:        case OP_CIRC:
705        if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||        if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
706            ((ims & PCRE_MULTILINE) != 0 &&            ((ims & PCRE_MULTILINE) != 0 &&
# Line 714  for (;;) Line 739  for (;;)
739    
740        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
741        case OP_ANY:        case OP_ANY:
742        if (clen > 0 && ((ims & PCRE_DOTALL) != 0 || !IS_NEWLINE(ptr)))        if (clen > 0 && !IS_NEWLINE(ptr))
743            { ADD_NEW(state_offset + 1, 0); }
744          break;
745    
746          /*-----------------------------------------------------------------*/
747          case OP_ALLANY:
748          if (clen > 0)
749          { ADD_NEW(state_offset + 1, 0); }          { ADD_NEW(state_offset + 1, 0); }
750        break;        break;
751    
# Line 783  for (;;) Line 814  for (;;)
814        break;        break;
815    
816    
 #ifdef SUPPORT_UCP  
   
817        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
818        /* Check the next character by Unicode property. We will get here only        /* Check the next character by Unicode property. We will get here only
819        if the support is in the binary; otherwise a compile-time error occurs.        if the support is in the binary; otherwise a compile-time error occurs.
820        */        */
821    
822    #ifdef SUPPORT_UCP
823        case OP_PROP:        case OP_PROP:
824        case OP_NOTPROP:        case OP_NOTPROP:
825        if (clen > 0)        if (clen > 0)
# Line 835  for (;;) Line 865  for (;;)
865  /* ========================================================================== */  /* ========================================================================== */
866        /* These opcodes likewise inspect the subject character, but have an        /* These opcodes likewise inspect the subject character, but have an
867        argument that is not a data character. It is one of these opcodes:        argument that is not a data character. It is one of these opcodes:
868        OP_ANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE, OP_WORDCHAR,        OP_ANY, OP_ALLANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE,
869        OP_NOT_WORDCHAR. The value is loaded into d. */        OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */
870    
871        case OP_TYPEPLUS:        case OP_TYPEPLUS:
872        case OP_TYPEMINPLUS:        case OP_TYPEMINPLUS:
# Line 847  for (;;) Line 877  for (;;)
877          {          {
878          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
879              (c < 256 &&              (c < 256 &&
880                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
881                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
882            {            {
883            if (count > 0 && codevalue == OP_TYPEPOSPLUS)            if (count > 0 && codevalue == OP_TYPEPOSPLUS)
# Line 873  for (;;) Line 900  for (;;)
900          {          {
901          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
902              (c < 256 &&              (c < 256 &&
903                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
904                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
905            {            {
906            if (codevalue == OP_TYPEPOSQUERY)            if (codevalue == OP_TYPEPOSQUERY)
# Line 898  for (;;) Line 922  for (;;)
922          {          {
923          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
924              (c < 256 &&              (c < 256 &&
925                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
926                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
927            {            {
928            if (codevalue == OP_TYPEPOSSTAR)            if (codevalue == OP_TYPEPOSSTAR)
# Line 921  for (;;) Line 942  for (;;)
942          {          {
943          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
944              (c < 256 &&              (c < 256 &&
945                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
946                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
947            {            {
948            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
# Line 945  for (;;) Line 963  for (;;)
963          {          {
964          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
965              (c < 256 &&              (c < 256 &&
966                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
967                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
968            {            {
969            if (codevalue == OP_TYPEPOSUPTO)            if (codevalue == OP_TYPEPOSUPTO)
# Line 970  for (;;) Line 985  for (;;)
985        argument. It keeps the code above fast for the other cases. The argument        argument. It keeps the code above fast for the other cases. The argument
986        is in the d variable. */        is in the d variable. */
987    
988    #ifdef SUPPORT_UCP
989        case OP_PROP_EXTRA + OP_TYPEPLUS:        case OP_PROP_EXTRA + OP_TYPEPLUS:
990        case OP_PROP_EXTRA + OP_TYPEMINPLUS:        case OP_PROP_EXTRA + OP_TYPEMINPLUS:
991        case OP_PROP_EXTRA + OP_TYPEPOSPLUS:        case OP_PROP_EXTRA + OP_TYPEPOSPLUS:
# Line 1049  for (;;) Line 1065  for (;;)
1065          ADD_NEW_DATA(-state_offset, count, ncount);          ADD_NEW_DATA(-state_offset, count, ncount);
1066          }          }
1067        break;        break;
1068    #endif
1069    
1070        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1071        case OP_ANYNL_EXTRA + OP_TYPEPLUS:        case OP_ANYNL_EXTRA + OP_TYPEPLUS:
# Line 1061  for (;;) Line 1078  for (;;)
1078          int ncount = 0;          int ncount = 0;
1079          switch (c)          switch (c)
1080            {            {
1081              case 0x000b:
1082              case 0x000c:
1083              case 0x0085:
1084              case 0x2028:
1085              case 0x2029:
1086              if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1087              goto ANYNL01;
1088    
1089            case 0x000d:            case 0x000d:
1090            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1091            /* Fall through */            /* Fall through */
1092    
1093              ANYNL01:
1094              case 0x000a:
1095              if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
1096                {
1097                active_count--;           /* Remove non-match possibility */
1098                next_active_state--;
1099                }
1100              count++;
1101              ADD_NEW_DATA(-state_offset, count, ncount);
1102              break;
1103    
1104              default:
1105              break;
1106              }
1107            }
1108          break;
1109    
1110          /*-----------------------------------------------------------------*/
1111          case OP_VSPACE_EXTRA + OP_TYPEPLUS:
1112          case OP_VSPACE_EXTRA + OP_TYPEMINPLUS:
1113          case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS:
1114          count = current_state->count;  /* Already matched */
1115          if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1116          if (clen > 0)
1117            {
1118            BOOL OK;
1119            switch (c)
1120              {
1121            case 0x000a:            case 0x000a:
1122            case 0x000b:            case 0x000b:
1123            case 0x000c:            case 0x000c:
1124              case 0x000d:
1125            case 0x0085:            case 0x0085:
1126            case 0x2028:            case 0x2028:
1127            case 0x2029:            case 0x2029:
1128            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)            OK = TRUE;
1129              break;
1130    
1131              default:
1132              OK = FALSE;
1133              break;
1134              }
1135    
1136            if (OK == (d == OP_VSPACE))
1137              {
1138              if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS)
1139              {              {
1140              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1141              next_active_state--;              next_active_state--;
1142              }              }
1143            count++;            count++;
1144            ADD_NEW_DATA(-state_offset, count, ncount);            ADD_NEW_DATA(-state_offset, count, 0);
1145              }
1146            }
1147          break;
1148    
1149          /*-----------------------------------------------------------------*/
1150          case OP_HSPACE_EXTRA + OP_TYPEPLUS:
1151          case OP_HSPACE_EXTRA + OP_TYPEMINPLUS:
1152          case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS:
1153          count = current_state->count;  /* Already matched */
1154          if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1155          if (clen > 0)
1156            {
1157            BOOL OK;
1158            switch (c)
1159              {
1160              case 0x09:      /* HT */
1161              case 0x20:      /* SPACE */
1162              case 0xa0:      /* NBSP */
1163              case 0x1680:    /* OGHAM SPACE MARK */
1164              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1165              case 0x2000:    /* EN QUAD */
1166              case 0x2001:    /* EM QUAD */
1167              case 0x2002:    /* EN SPACE */
1168              case 0x2003:    /* EM SPACE */
1169              case 0x2004:    /* THREE-PER-EM SPACE */
1170              case 0x2005:    /* FOUR-PER-EM SPACE */
1171              case 0x2006:    /* SIX-PER-EM SPACE */
1172              case 0x2007:    /* FIGURE SPACE */
1173              case 0x2008:    /* PUNCTUATION SPACE */
1174              case 0x2009:    /* THIN SPACE */
1175              case 0x200A:    /* HAIR SPACE */
1176              case 0x202f:    /* NARROW NO-BREAK SPACE */
1177              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1178              case 0x3000:    /* IDEOGRAPHIC SPACE */
1179              OK = TRUE;
1180            break;            break;
1181    
1182            default:            default:
1183              OK = FALSE;
1184            break;            break;
1185            }            }
1186    
1187            if (OK == (d == OP_HSPACE))
1188              {
1189              if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS)
1190                {
1191                active_count--;           /* Remove non-match possibility */
1192                next_active_state--;
1193                }
1194              count++;
1195              ADD_NEW_DATA(-state_offset, count, 0);
1196              }
1197          }          }
1198        break;        break;
1199    
1200        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1201    #ifdef SUPPORT_UCP
1202        case OP_PROP_EXTRA + OP_TYPEQUERY:        case OP_PROP_EXTRA + OP_TYPEQUERY:
1203        case OP_PROP_EXTRA + OP_TYPEMINQUERY:        case OP_PROP_EXTRA + OP_TYPEMINQUERY:
1204        case OP_PROP_EXTRA + OP_TYPEPOSQUERY:        case OP_PROP_EXTRA + OP_TYPEPOSQUERY:
# Line 1182  for (;;) Line 1296  for (;;)
1296          ADD_NEW_DATA(-(state_offset + count), 0, ncount);          ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1297          }          }
1298        break;        break;
1299    #endif
1300    
1301        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1302        case OP_ANYNL_EXTRA + OP_TYPEQUERY:        case OP_ANYNL_EXTRA + OP_TYPEQUERY:
# Line 1202  for (;;) Line 1317  for (;;)
1317          int ncount = 0;          int ncount = 0;
1318          switch (c)          switch (c)
1319            {            {
1320              case 0x000b:
1321              case 0x000c:
1322              case 0x0085:
1323              case 0x2028:
1324              case 0x2029:
1325              if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1326              goto ANYNL02;
1327    
1328            case 0x000d:            case 0x000d:
1329            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1330            /* Fall through */            /* Fall through */
1331    
1332              ANYNL02:
1333              case 0x000a:
1334              if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
1335                  codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
1336                {
1337                active_count--;           /* Remove non-match possibility */
1338                next_active_state--;
1339                }
1340              ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1341              break;
1342    
1343              default:
1344              break;
1345              }
1346            }
1347          break;
1348    
1349          /*-----------------------------------------------------------------*/
1350          case OP_VSPACE_EXTRA + OP_TYPEQUERY:
1351          case OP_VSPACE_EXTRA + OP_TYPEMINQUERY:
1352          case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY:
1353          count = 2;
1354          goto QS4;
1355    
1356          case OP_VSPACE_EXTRA + OP_TYPESTAR:
1357          case OP_VSPACE_EXTRA + OP_TYPEMINSTAR:
1358          case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR:
1359          count = 0;
1360    
1361          QS4:
1362          ADD_ACTIVE(state_offset + 2, 0);
1363          if (clen > 0)
1364            {
1365            BOOL OK;
1366            switch (c)
1367              {
1368            case 0x000a:            case 0x000a:
1369            case 0x000b:            case 0x000b:
1370            case 0x000c:            case 0x000c:
1371              case 0x000d:
1372            case 0x0085:            case 0x0085:
1373            case 0x2028:            case 0x2028:
1374            case 0x2029:            case 0x2029:
1375            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||            OK = TRUE;
1376                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)            break;
1377    
1378              default:
1379              OK = FALSE;
1380              break;
1381              }
1382            if (OK == (d == OP_VSPACE))
1383              {
1384              if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR ||
1385                  codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY)
1386              {              {
1387              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1388              next_active_state--;              next_active_state--;
1389              }              }
1390            ADD_NEW_DATA(-(state_offset + count), 0, ncount);            ADD_NEW_DATA(-(state_offset + count), 0, 0);
1391              }
1392            }
1393          break;
1394    
1395          /*-----------------------------------------------------------------*/
1396          case OP_HSPACE_EXTRA + OP_TYPEQUERY:
1397          case OP_HSPACE_EXTRA + OP_TYPEMINQUERY:
1398          case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY:
1399          count = 2;
1400          goto QS5;
1401    
1402          case OP_HSPACE_EXTRA + OP_TYPESTAR:
1403          case OP_HSPACE_EXTRA + OP_TYPEMINSTAR:
1404          case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR:
1405          count = 0;
1406    
1407          QS5:
1408          ADD_ACTIVE(state_offset + 2, 0);
1409          if (clen > 0)
1410            {
1411            BOOL OK;
1412            switch (c)
1413              {
1414              case 0x09:      /* HT */
1415              case 0x20:      /* SPACE */
1416              case 0xa0:      /* NBSP */
1417              case 0x1680:    /* OGHAM SPACE MARK */
1418              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1419              case 0x2000:    /* EN QUAD */
1420              case 0x2001:    /* EM QUAD */
1421              case 0x2002:    /* EN SPACE */
1422              case 0x2003:    /* EM SPACE */
1423              case 0x2004:    /* THREE-PER-EM SPACE */
1424              case 0x2005:    /* FOUR-PER-EM SPACE */
1425              case 0x2006:    /* SIX-PER-EM SPACE */
1426              case 0x2007:    /* FIGURE SPACE */
1427              case 0x2008:    /* PUNCTUATION SPACE */
1428              case 0x2009:    /* THIN SPACE */
1429              case 0x200A:    /* HAIR SPACE */
1430              case 0x202f:    /* NARROW NO-BREAK SPACE */
1431              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1432              case 0x3000:    /* IDEOGRAPHIC SPACE */
1433              OK = TRUE;
1434            break;            break;
1435    
1436            default:            default:
1437              OK = FALSE;
1438            break;            break;
1439            }            }
1440    
1441            if (OK == (d == OP_HSPACE))
1442              {
1443              if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR ||
1444                  codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY)
1445                {
1446                active_count--;           /* Remove non-match possibility */
1447                next_active_state--;
1448                }
1449              ADD_NEW_DATA(-(state_offset + count), 0, 0);
1450              }
1451          }          }
1452        break;        break;
1453    
1454        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1455    #ifdef SUPPORT_UCP
1456        case OP_PROP_EXTRA + OP_TYPEEXACT:        case OP_PROP_EXTRA + OP_TYPEEXACT:
1457        case OP_PROP_EXTRA + OP_TYPEUPTO:        case OP_PROP_EXTRA + OP_TYPEUPTO:
1458        case OP_PROP_EXTRA + OP_TYPEMINUPTO:        case OP_PROP_EXTRA + OP_TYPEMINUPTO:
# Line 1313  for (;;) Line 1540  for (;;)
1540            { ADD_NEW_DATA(-state_offset, count, ncount); }            { ADD_NEW_DATA(-state_offset, count, ncount); }
1541          }          }
1542        break;        break;
1543    #endif
1544    
1545        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1546        case OP_ANYNL_EXTRA + OP_TYPEEXACT:        case OP_ANYNL_EXTRA + OP_TYPEEXACT:
# Line 1327  for (;;) Line 1555  for (;;)
1555          int ncount = 0;          int ncount = 0;
1556          switch (c)          switch (c)
1557            {            {
1558              case 0x000b:
1559              case 0x000c:
1560              case 0x0085:
1561              case 0x2028:
1562              case 0x2029:
1563              if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1564              goto ANYNL03;
1565    
1566            case 0x000d:            case 0x000d:
1567            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1568            /* Fall through */            /* Fall through */
1569    
1570              ANYNL03:
1571              case 0x000a:
1572              if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
1573                {
1574                active_count--;           /* Remove non-match possibility */
1575                next_active_state--;
1576                }
1577              if (++count >= GET2(code, 1))
1578                { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }
1579              else
1580                { ADD_NEW_DATA(-state_offset, count, ncount); }
1581              break;
1582    
1583              default:
1584              break;
1585              }
1586            }
1587          break;
1588    
1589          /*-----------------------------------------------------------------*/
1590          case OP_VSPACE_EXTRA + OP_TYPEEXACT:
1591          case OP_VSPACE_EXTRA + OP_TYPEUPTO:
1592          case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:
1593          case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:
1594          if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)
1595            { ADD_ACTIVE(state_offset + 4, 0); }
1596          count = current_state->count;  /* Number already matched */
1597          if (clen > 0)
1598            {
1599            BOOL OK;
1600            switch (c)
1601              {
1602            case 0x000a:            case 0x000a:
1603            case 0x000b:            case 0x000b:
1604            case 0x000c:            case 0x000c:
1605              case 0x000d:
1606            case 0x0085:            case 0x0085:
1607            case 0x2028:            case 0x2028:
1608            case 0x2029:            case 0x2029:
1609            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)            OK = TRUE;
1610              break;
1611    
1612              default:
1613              OK = FALSE;
1614              }
1615    
1616            if (OK == (d == OP_VSPACE))
1617              {
1618              if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO)
1619              {              {
1620              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1621              next_active_state--;              next_active_state--;
1622              }              }
1623            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
1624              { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }              { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1625            else            else
1626              { ADD_NEW_DATA(-state_offset, count, ncount); }              { ADD_NEW_DATA(-state_offset, count, 0); }
1627              }
1628            }
1629          break;
1630    
1631          /*-----------------------------------------------------------------*/
1632          case OP_HSPACE_EXTRA + OP_TYPEEXACT:
1633          case OP_HSPACE_EXTRA + OP_TYPEUPTO:
1634          case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:
1635          case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:
1636          if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)
1637            { ADD_ACTIVE(state_offset + 4, 0); }
1638          count = current_state->count;  /* Number already matched */
1639          if (clen > 0)
1640            {
1641            BOOL OK;
1642            switch (c)
1643              {
1644              case 0x09:      /* HT */
1645              case 0x20:      /* SPACE */
1646              case 0xa0:      /* NBSP */
1647              case 0x1680:    /* OGHAM SPACE MARK */
1648              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1649              case 0x2000:    /* EN QUAD */
1650              case 0x2001:    /* EM QUAD */
1651              case 0x2002:    /* EN SPACE */
1652              case 0x2003:    /* EM SPACE */
1653              case 0x2004:    /* THREE-PER-EM SPACE */
1654              case 0x2005:    /* FOUR-PER-EM SPACE */
1655              case 0x2006:    /* SIX-PER-EM SPACE */
1656              case 0x2007:    /* FIGURE SPACE */
1657              case 0x2008:    /* PUNCTUATION SPACE */
1658              case 0x2009:    /* THIN SPACE */
1659              case 0x200A:    /* HAIR SPACE */
1660              case 0x202f:    /* NARROW NO-BREAK SPACE */
1661              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1662              case 0x3000:    /* IDEOGRAPHIC SPACE */
1663              OK = TRUE;
1664            break;            break;
1665    
1666            default:            default:
1667              OK = FALSE;
1668            break;            break;
1669            }            }
1670    
1671            if (OK == (d == OP_HSPACE))
1672              {
1673              if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO)
1674                {
1675                active_count--;           /* Remove non-match possibility */
1676                next_active_state--;
1677                }
1678              if (++count >= GET2(code, 1))
1679                { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1680              else
1681                { ADD_NEW_DATA(-state_offset, count, 0); }
1682              }
1683          }          }
1684        break;        break;
1685    
# Line 1429  for (;;) Line 1760  for (;;)
1760        case OP_ANYNL:        case OP_ANYNL:
1761        if (clen > 0) switch(c)        if (clen > 0) switch(c)
1762          {          {
         case 0x000a:  
1763          case 0x000b:          case 0x000b:
1764          case 0x000c:          case 0x000c:
1765          case 0x0085:          case 0x0085:
1766          case 0x2028:          case 0x2028:
1767          case 0x2029:          case 0x2029:
1768            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1769    
1770            case 0x000a:
1771          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
1772          break;          break;
1773    
1774          case 0x000d:          case 0x000d:
1775          if (ptr + 1 < end_subject && ptr[1] == 0x0a)          if (ptr + 1 < end_subject && ptr[1] == 0x0a)
1776            {            {
# Line 1451  for (;;) Line 1785  for (;;)
1785        break;        break;
1786    
1787        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1788          case OP_NOT_VSPACE:
1789          if (clen > 0) switch(c)
1790            {
1791            case 0x000a:
1792            case 0x000b:
1793            case 0x000c:
1794            case 0x000d:
1795            case 0x0085:
1796            case 0x2028:
1797            case 0x2029:
1798            break;
1799    
1800            default:
1801            ADD_NEW(state_offset + 1, 0);
1802            break;
1803            }
1804          break;
1805    
1806          /*-----------------------------------------------------------------*/
1807          case OP_VSPACE:
1808          if (clen > 0) switch(c)
1809            {
1810            case 0x000a:
1811            case 0x000b:
1812            case 0x000c:
1813            case 0x000d:
1814            case 0x0085:
1815            case 0x2028:
1816            case 0x2029:
1817            ADD_NEW(state_offset + 1, 0);
1818            break;
1819    
1820            default: break;
1821            }
1822          break;
1823    
1824          /*-----------------------------------------------------------------*/
1825          case OP_NOT_HSPACE:
1826          if (clen > 0) switch(c)
1827            {
1828            case 0x09:      /* HT */
1829            case 0x20:      /* SPACE */
1830            case 0xa0:      /* NBSP */
1831            case 0x1680:    /* OGHAM SPACE MARK */
1832            case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1833            case 0x2000:    /* EN QUAD */
1834            case 0x2001:    /* EM QUAD */
1835            case 0x2002:    /* EN SPACE */
1836            case 0x2003:    /* EM SPACE */
1837            case 0x2004:    /* THREE-PER-EM SPACE */
1838            case 0x2005:    /* FOUR-PER-EM SPACE */
1839            case 0x2006:    /* SIX-PER-EM SPACE */
1840            case 0x2007:    /* FIGURE SPACE */
1841            case 0x2008:    /* PUNCTUATION SPACE */
1842            case 0x2009:    /* THIN SPACE */
1843            case 0x200A:    /* HAIR SPACE */
1844            case 0x202f:    /* NARROW NO-BREAK SPACE */
1845            case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1846            case 0x3000:    /* IDEOGRAPHIC SPACE */
1847            break;
1848    
1849            default:
1850            ADD_NEW(state_offset + 1, 0);
1851            break;
1852            }
1853          break;
1854    
1855          /*-----------------------------------------------------------------*/
1856          case OP_HSPACE:
1857          if (clen > 0) switch(c)
1858            {
1859            case 0x09:      /* HT */
1860            case 0x20:      /* SPACE */
1861            case 0xa0:      /* NBSP */
1862            case 0x1680:    /* OGHAM SPACE MARK */
1863            case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1864            case 0x2000:    /* EN QUAD */
1865            case 0x2001:    /* EM QUAD */
1866            case 0x2002:    /* EN SPACE */
1867            case 0x2003:    /* EM SPACE */
1868            case 0x2004:    /* THREE-PER-EM SPACE */
1869            case 0x2005:    /* FOUR-PER-EM SPACE */
1870            case 0x2006:    /* SIX-PER-EM SPACE */
1871            case 0x2007:    /* FIGURE SPACE */
1872            case 0x2008:    /* PUNCTUATION SPACE */
1873            case 0x2009:    /* THIN SPACE */
1874            case 0x200A:    /* HAIR SPACE */
1875            case 0x202f:    /* NARROW NO-BREAK SPACE */
1876            case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1877            case 0x3000:    /* IDEOGRAPHIC SPACE */
1878            ADD_NEW(state_offset + 1, 0);
1879            break;
1880            }
1881          break;
1882    
1883          /*-----------------------------------------------------------------*/
1884        /* Match a negated single character. This is only used for one-byte        /* Match a negated single character. This is only used for one-byte
1885        characters, that is, we know that d < 256. The character we are        characters, that is, we know that d < 256. The character we are
1886        checking (c) can be multibyte. */        checking (c) can be multibyte. */
# Line 1730  for (;;) Line 2160  for (;;)
2160    
2161  /* ========================================================================== */  /* ========================================================================== */
2162        /* These are the opcodes for fancy brackets of various kinds. We have        /* These are the opcodes for fancy brackets of various kinds. We have
2163        to use recursion in order to handle them. */        to use recursion in order to handle them. The "always failing" assersion
2164          (?!) is optimised when compiling to OP_FAIL, so we have to support that,
2165          though the other "backtracking verbs" are not supported. */
2166    
2167          case OP_FAIL:
2168          break;
2169    
2170        case OP_ASSERT:        case OP_ASSERT:
2171        case OP_ASSERT_NOT:        case OP_ASSERT_NOT:
# Line 2057  is not anchored. Line 2492  is not anchored.
2492    
2493  Arguments:  Arguments:
2494    argument_re     points to the compiled expression    argument_re     points to the compiled expression
2495    extra_data      points to extra data or is NULL (not currently used)    extra_data      points to extra data or is NULL
2496    subject         points to the subject string    subject         points to the subject string
2497    length          length of subject string (may contain binary zeros)    length          length of subject string (may contain binary zeros)
2498    start_offset    where to start in the subject string    start_offset    where to start in the subject string
# Line 2073  Returns: > 0 => number of match Line 2508  Returns: > 0 => number of match
2508                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
2509  */  */
2510    
2511  PCRE_DATA_SCOPE int  PCRE_EXP_DEFN int
2512  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
2513    const char *subject, int length, int start_offset, int options, int *offsets,    const char *subject, int length, int start_offset, int options, int *offsets,
2514    int offsetcount, int *workspace, int wscount)    int offsetcount, int *workspace, int wscount)
# Line 2163  md->end_subject = end_subject; Line 2598  md->end_subject = end_subject;
2598  md->moptions = options;  md->moptions = options;
2599  md->poptions = re->options;  md->poptions = re->options;
2600    
2601  /* Handle different types of newline. The two bits give four cases. If nothing  /* If the BSR option is not set at match time, copy what was set
2602  is set at run time, whatever was used at compile time applies. */  at compile time. */
2603    
2604  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : options) &  if ((md->moptions & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) == 0)
2605      {
2606      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
2607        md->moptions |= re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE);
2608    #ifdef BSR_ANYCRLF
2609      else md->moptions |= PCRE_BSR_ANYCRLF;
2610    #endif
2611      }
2612    
2613    /* Handle different types of newline. The three bits give eight cases. If
2614    nothing is set at run time, whatever was used at compile time applies. */
2615    
2616    switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
2617           PCRE_NEWLINE_BITS)           PCRE_NEWLINE_BITS)
2618    {    {
2619    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
# Line 2175  switch ((((options & PCRE_NEWLINE_BITS) Line 2622  switch ((((options & PCRE_NEWLINE_BITS)
2622    case PCRE_NEWLINE_CR+    case PCRE_NEWLINE_CR+
2623         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
2624    case PCRE_NEWLINE_ANY: newline = -1; break;    case PCRE_NEWLINE_ANY: newline = -1; break;
2625      case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
2626    default: return PCRE_ERROR_BADNEWLINE;    default: return PCRE_ERROR_BADNEWLINE;
2627    }    }
2628    
2629  if (newline < 0)  if (newline == -2)
2630      {
2631      md->nltype = NLTYPE_ANYCRLF;
2632      }
2633    else if (newline < 0)
2634    {    {
2635    md->nltype = NLTYPE_ANY;    md->nltype = NLTYPE_ANY;
2636    }    }
# Line 2228  if (md->tables == NULL) md->tables = _pc Line 2680  if (md->tables == NULL) md->tables = _pc
2680  used in a loop when finding where to start. */  used in a loop when finding where to start. */
2681    
2682  lcc = md->tables + lcc_offset;  lcc = md->tables + lcc_offset;
2683  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
2684  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
2685    
2686  /* Set up the first character to match, if available. The first_byte value is  /* Set up the first character to match, if available. The first_byte value is
# Line 2239  studied, there may be a bitmap of possib Line 2691  studied, there may be a bitmap of possib
2691    
2692  if (!anchored)  if (!anchored)
2693    {    {
2694    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
2695      {      {
2696      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
2697      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
# Line 2256  if (!anchored) Line 2708  if (!anchored)
2708  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
2709  character" set. */  character" set. */
2710    
2711  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
2712    {    {
2713    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
2714    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
# Line 2308  for (;;) Line 2760  for (;;)
2760          {          {
2761          while (current_subject <= end_subject && !WAS_NEWLINE(current_subject))          while (current_subject <= end_subject && !WAS_NEWLINE(current_subject))
2762            current_subject++;            current_subject++;
2763    
2764            /* If we have just passed a CR and the newline option is ANY or
2765            ANYCRLF, and we are now at a LF, advance the match position by one more
2766            character. */
2767    
2768            if (current_subject[-1] == '\r' &&
2769                 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
2770                 current_subject < end_subject &&
2771                 *current_subject == '\n')
2772              current_subject++;
2773          }          }
2774        }        }
2775    
# Line 2416  for (;;) Line 2878  for (;;)
2878      }      }
2879    if (current_subject > end_subject) break;    if (current_subject > end_subject) break;
2880    
2881    /* If we have just passed a CR and the newline option is CRLF or ANY, and we    /* If we have just passed a CR and we are now at a LF, and the pattern does
2882    are now at a LF, advance the match position by one more character. */    not contain any explicit matches for \r or \n, and the newline option is CRLF
2883      or ANY or ANYCRLF, advance the match position by one more character. */
2884    
2885    if (current_subject[-1] == '\r' &&    if (current_subject[-1] == '\r' &&
2886         (md->nltype == NLTYPE_ANY || md->nllen == 2) &&        current_subject < end_subject &&
2887         current_subject < end_subject &&        *current_subject == '\n' &&
2888         *current_subject == '\n')        (re->flags & PCRE_HASCRORLF) == 0 &&
2889            (md->nltype == NLTYPE_ANY ||
2890             md->nltype == NLTYPE_ANYCRLF ||
2891             md->nllen == 2))
2892      current_subject++;      current_subject++;
2893    
2894    }   /* "Bumpalong" loop */    }   /* "Bumpalong" loop */

Legend:
Removed from v.93  
changed lines
  Added in v.345

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12