/[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 598 by ph10, Sat May 7 15:37:31 2011 UTC revision 602 by ph10, Wed May 25 08:29:03 2011 UTC
# Line 121  static const uschar coptable[] = { Line 121  static const uschar coptable[] = {
121    0, 0,                          /* \P, \p                                 */    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                                     */    0,                             /* \X                                     */
124    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0, 0,              /* \Z, \z, ^, ^M, $, $M                   */
125    1,                             /* Char                                   */    1,                             /* Char                                   */
126    1,                             /* Charnc                                 */    1,                             /* Chari                                  */
127    1,                             /* not                                    */    1,                             /* not                                    */
128      1,                             /* noti                                   */
129    /* Positive single-char repeats                                          */    /* Positive single-char repeats                                          */
130    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
131    3, 3, 3,                       /* upto, minupto, exact                   */    3, 3, 3,                       /* upto, minupto, exact                   */
132    1, 1, 1, 3,                    /* *+, ++, ?+, upto+                      */    1, 1, 1, 3,                    /* *+, ++, ?+, upto+                      */
133      1, 1, 1, 1, 1, 1,              /* *I, *?I, +I, +?I, ?I, ??I              */
134      3, 3, 3,                       /* upto I, minupto I, exact I             */
135      1, 1, 1, 3,                    /* *+I, ++I, ?+I, upto+I                  */
136    /* Negative single-char repeats - only for chars < 256                   */    /* Negative single-char repeats - only for chars < 256                   */
137    1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */    1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
138    3, 3, 3,                       /* NOT upto, minupto, exact               */    3, 3, 3,                       /* NOT upto, minupto, exact               */
139    1, 1, 1, 3,                    /* NOT *+, ++, ?+, updo+                  */    1, 1, 1, 3,                    /* NOT *+, ++, ?+, upto+                  */
140      1, 1, 1, 1, 1, 1,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */
141      3, 3, 3,                       /* NOT upto I, minupto I, exact I         */
142      1, 1, 1, 3,                    /* NOT *+I, ++I, ?+I, upto+I              */
143    /* Positive type repeats                                                 */    /* Positive type repeats                                                 */
144    1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */    1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
145    3, 3, 3,                       /* Type upto, minupto, exact              */    3, 3, 3,                       /* Type upto, minupto, exact              */
# Line 144  static const uschar coptable[] = { Line 151  static const uschar coptable[] = {
151    0,                             /* NCLASS                                 */    0,                             /* NCLASS                                 */
152    0,                             /* XCLASS - variable length               */    0,                             /* XCLASS - variable length               */
153    0,                             /* REF                                    */    0,                             /* REF                                    */
154      0,                             /* REFI                                   */
155    0,                             /* RECURSE                                */    0,                             /* RECURSE                                */
156    0,                             /* CALLOUT                                */    0,                             /* CALLOUT                                */
157    0,                             /* Alt                                    */    0,                             /* Alt                                    */
# Line 179  static const uschar poptable[] = { Line 187  static const uschar poptable[] = {
187    1, 1,                          /* \P, \p                                 */    1, 1,                          /* \P, \p                                 */
188    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */
189    1,                             /* \X                                     */    1,                             /* \X                                     */
190    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0, 0,              /* \Z, \z, ^, ^M, $, $M                   */
191    1,                             /* Char                                   */    1,                             /* Char                                   */
192    1,                             /* Charnc                                 */    1,                             /* Chari                                  */
193    1,                             /* not                                    */    1,                             /* not                                    */
194      1,                             /* noti                                   */
195    /* Positive single-char repeats                                          */    /* Positive single-char repeats                                          */
196    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
197    1, 1, 1,                       /* upto, minupto, exact                   */    1, 1, 1,                       /* upto, minupto, exact                   */
198    1, 1, 1, 1,                    /* *+, ++, ?+, upto+                      */    1, 1, 1, 1,                    /* *+, ++, ?+, upto+                      */
199      1, 1, 1, 1, 1, 1,              /* *I, *?I, +I, +?I, ?I, ??I              */
200      1, 1, 1,                       /* upto I, minupto I, exact I             */
201      1, 1, 1, 1,                    /* *+I, ++I, ?+I, upto+I                  */
202    /* Negative single-char repeats - only for chars < 256                   */    /* Negative single-char repeats - only for chars < 256                   */
203    1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */    1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
204    1, 1, 1,                       /* NOT upto, minupto, exact               */    1, 1, 1,                       /* NOT upto, minupto, exact               */
205    1, 1, 1, 1,                    /* NOT *+, ++, ?+, upto+                  */    1, 1, 1, 1,                    /* NOT *+, ++, ?+, upto+                  */
206      1, 1, 1, 1, 1, 1,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */
207      1, 1, 1,                       /* NOT upto I, minupto I, exact I         */
208      1, 1, 1, 1,                    /* NOT *+I, ++I, ?+I, upto+I              */
209    /* Positive type repeats                                                 */    /* Positive type repeats                                                 */
210    1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */    1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
211    1, 1, 1,                       /* Type upto, minupto, exact              */    1, 1, 1,                       /* Type upto, minupto, exact              */
# Line 202  static const uschar poptable[] = { Line 217  static const uschar poptable[] = {
217    1,                             /* NCLASS                                 */    1,                             /* NCLASS                                 */
218    1,                             /* XCLASS - variable length               */    1,                             /* XCLASS - variable length               */
219    0,                             /* REF                                    */    0,                             /* REF                                    */
220      0,                             /* REFI                                   */
221    0,                             /* RECURSE                                */    0,                             /* RECURSE                                */
222    0,                             /* CALLOUT                                */    0,                             /* CALLOUT                                */
223    0,                             /* Alt                                    */    0,                             /* Alt                                    */
# Line 252  these structures in, is a vector of ints Line 268  these structures in, is a vector of ints
268  typedef struct stateblock {  typedef struct stateblock {
269    int offset;                     /* Offset to opcode */    int offset;                     /* Offset to opcode */
270    int count;                      /* Count for repeats */    int count;                      /* Count for repeats */
   int ims;                        /* ims flag bits */  
271    int data;                       /* Some use extra data */    int data;                       /* Some use extra data */
272  } stateblock;  } stateblock;
273    
# Line 308  Arguments: Line 323  Arguments:
323    offsetcount       size of same    offsetcount       size of same
324    workspace         vector of workspace    workspace         vector of workspace
325    wscount           size of same    wscount           size of same
   ims               the current ims flags  
326    rlevel            function call recursion level    rlevel            function call recursion level
327    recursing         regex recursive call level    recursing         regex recursive call level
328    
# Line 325  for the current character, one for the f Line 339  for the current character, one for the f
339      { \      { \
340      next_active_state->offset = (x); \      next_active_state->offset = (x); \
341      next_active_state->count  = (y); \      next_active_state->count  = (y); \
     next_active_state->ims    = ims; \  
342      next_active_state++; \      next_active_state++; \
343      DPRINTF(("%.*sADD_ACTIVE(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \      DPRINTF(("%.*sADD_ACTIVE(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
344      } \      } \
# Line 336  for the current character, one for the f Line 349  for the current character, one for the f
349      { \      { \
350      next_active_state->offset = (x); \      next_active_state->offset = (x); \
351      next_active_state->count  = (y); \      next_active_state->count  = (y); \
     next_active_state->ims    = ims; \  
352      next_active_state->data   = (z); \      next_active_state->data   = (z); \
353      next_active_state++; \      next_active_state++; \
354      DPRINTF(("%.*sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \      DPRINTF(("%.*sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
# Line 348  for the current character, one for the f Line 360  for the current character, one for the f
360      { \      { \
361      next_new_state->offset = (x); \      next_new_state->offset = (x); \
362      next_new_state->count  = (y); \      next_new_state->count  = (y); \
     next_new_state->ims    = ims; \  
363      next_new_state++; \      next_new_state++; \
364      DPRINTF(("%.*sADD_NEW(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \      DPRINTF(("%.*sADD_NEW(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
365      } \      } \
# Line 359  for the current character, one for the f Line 370  for the current character, one for the f
370      { \      { \
371      next_new_state->offset = (x); \      next_new_state->offset = (x); \
372      next_new_state->count  = (y); \      next_new_state->count  = (y); \
     next_new_state->ims    = ims; \  
373      next_new_state->data   = (z); \      next_new_state->data   = (z); \
374      next_new_state++; \      next_new_state++; \
375      DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \      DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
# Line 378  internal_dfa_exec( Line 388  internal_dfa_exec(
388    int offsetcount,    int offsetcount,
389    int *workspace,    int *workspace,
390    int wscount,    int wscount,
   int ims,  
391    int  rlevel,    int  rlevel,
392    int  recursing)    int  recursing)
393  {  {
# Line 605  for (;;) Line 614  for (;;)
614    for (i = 0; i < active_count; i++)    for (i = 0; i < active_count; i++)
615      {      {
616      stateblock *current_state = active_states + i;      stateblock *current_state = active_states + i;
617        BOOL caseless = FALSE;
618      const uschar *code;      const uschar *code;
619      int state_offset = current_state->offset;      int state_offset = current_state->offset;
620      int count, codevalue, rrc;      int count, codevalue, rrc;
# Line 616  for (;;) Line 626  for (;;)
626          else printf("0x%02x\n", c);          else printf("0x%02x\n", c);
627  #endif  #endif
628    
     /* This variable is referred to implicity in the ADD_xxx macros. */  
   
     ims = current_state->ims;  
   
629      /* A negative offset is a special case meaning "hold off going to this      /* A negative offset is a special case meaning "hold off going to this
630      (negated) state until the number of characters in the data field have      (negated) state until the number of characters in the data field have
631      been skipped". */      been skipped". */
# Line 822  for (;;) Line 828  for (;;)
828    
829        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
830        case OP_CIRC:        case OP_CIRC:
831          if (ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0)
832            { ADD_ACTIVE(state_offset + 1, 0); }
833          break;
834    
835          /*-----------------------------------------------------------------*/
836          case OP_CIRCM:
837        if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||        if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
838            ((ims & PCRE_MULTILINE) != 0 &&            (ptr != end_subject && WAS_NEWLINE(ptr)))
             ptr != end_subject &&  
             WAS_NEWLINE(ptr)))  
839          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
840        break;        break;
841    
# Line 840  for (;;) Line 850  for (;;)
850        break;        break;
851    
852        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
       case OP_OPT:  
       ims = code[1];  
       ADD_ACTIVE(state_offset + 2, 0);  
       break;  
   
       /*-----------------------------------------------------------------*/  
853        case OP_SOD:        case OP_SOD:
854        if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }        if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }
855        break;        break;
# Line 890  for (;;) Line 894  for (;;)
894            could_continue = TRUE;            could_continue = TRUE;
895          else if (clen == 0 ||          else if (clen == 0 ||
896              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
897                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)                 (ptr == end_subject - md->nllen)
898              ))              ))
899            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
900          }          }
901        else if ((ims & PCRE_MULTILINE) != 0 && IS_NEWLINE(ptr))        break;
902    
903          /*-----------------------------------------------------------------*/
904          case OP_DOLLM:
905          if ((md->moptions & PCRE_NOTEOL) == 0)
906            {
907            if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
908              could_continue = TRUE;
909            else if (clen == 0 ||
910                ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))
911              { ADD_ACTIVE(state_offset + 1, 0); }
912            }
913          else if (IS_NEWLINE(ptr))
914          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
915        break;        break;
916    
# Line 1950  for (;;) Line 1966  for (;;)
1966        break;        break;
1967    
1968        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1969        case OP_CHARNC:        case OP_CHARI:
1970        if (clen == 0) break;        if (clen == 0) break;
1971    
1972  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 2136  for (;;) Line 2152  for (;;)
2152        break;        break;
2153    
2154        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2155        /* Match a negated single character. This is only used for one-byte        /* Match a negated single character casefully. This is only used for
2156        characters, that is, we know that d < 256. The character we are        one-byte characters, that is, we know that d < 256. The character we are
2157        checking (c) can be multibyte. */        checking (c) can be multibyte. */
2158    
2159        case OP_NOT:        case OP_NOT:
2160        if (clen > 0)        if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }
2161          {        break;
2162          unsigned int otherd = ((ims & PCRE_CASELESS) != 0)? fcc[d] : d;  
2163          if (c != d && c != otherd) { ADD_NEW(state_offset + dlen + 1, 0); }        /*-----------------------------------------------------------------*/
2164          }        /* Match a negated single character caselessly. This is only used for
2165          one-byte characters, that is, we know that d < 256. The character we are
2166          checking (c) can be multibyte. */
2167    
2168          case OP_NOTI:
2169          if (clen > 0 && c != d && c != fcc[d])
2170            { ADD_NEW(state_offset + dlen + 1, 0); }
2171        break;        break;
2172    
2173        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2174          case OP_PLUSI:
2175          case OP_MINPLUSI:
2176          case OP_POSPLUSI:
2177          case OP_NOTPLUSI:
2178          case OP_NOTMINPLUSI:
2179          case OP_NOTPOSPLUSI:
2180          caseless = TRUE;
2181          codevalue -= OP_STARI - OP_STAR;
2182    
2183          /* Fall through */
2184        case OP_PLUS:        case OP_PLUS:
2185        case OP_MINPLUS:        case OP_MINPLUS:
2186        case OP_POSPLUS:        case OP_POSPLUS:
# Line 2160  for (;;) Line 2192  for (;;)
2192        if (clen > 0)        if (clen > 0)
2193          {          {
2194          unsigned int otherd = NOTACHAR;          unsigned int otherd = NOTACHAR;
2195          if ((ims & PCRE_CASELESS) != 0)          if (caseless)
2196            {            {
2197  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2198            if (utf8 && d >= 128)            if (utf8 && d >= 128)
# Line 2188  for (;;) Line 2220  for (;;)
2220        break;        break;
2221    
2222        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2223          case OP_QUERYI:
2224          case OP_MINQUERYI:
2225          case OP_POSQUERYI:
2226          case OP_NOTQUERYI:
2227          case OP_NOTMINQUERYI:
2228          case OP_NOTPOSQUERYI:
2229          caseless = TRUE;
2230          codevalue -= OP_STARI - OP_STAR;
2231          /* Fall through */
2232        case OP_QUERY:        case OP_QUERY:
2233        case OP_MINQUERY:        case OP_MINQUERY:
2234        case OP_POSQUERY:        case OP_POSQUERY:
# Line 2198  for (;;) Line 2239  for (;;)
2239        if (clen > 0)        if (clen > 0)
2240          {          {
2241          unsigned int otherd = NOTACHAR;          unsigned int otherd = NOTACHAR;
2242          if ((ims & PCRE_CASELESS) != 0)          if (caseless)
2243            {            {
2244  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2245            if (utf8 && d >= 128)            if (utf8 && d >= 128)
# Line 2224  for (;;) Line 2265  for (;;)
2265        break;        break;
2266    
2267        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2268          case OP_STARI:
2269          case OP_MINSTARI:
2270          case OP_POSSTARI:
2271          case OP_NOTSTARI:
2272          case OP_NOTMINSTARI:
2273          case OP_NOTPOSSTARI:
2274          caseless = TRUE;
2275          codevalue -= OP_STARI - OP_STAR;
2276          /* Fall through */
2277        case OP_STAR:        case OP_STAR:
2278        case OP_MINSTAR:        case OP_MINSTAR:
2279        case OP_POSSTAR:        case OP_POSSTAR:
# Line 2234  for (;;) Line 2284  for (;;)
2284        if (clen > 0)        if (clen > 0)
2285          {          {
2286          unsigned int otherd = NOTACHAR;          unsigned int otherd = NOTACHAR;
2287          if ((ims & PCRE_CASELESS) != 0)          if (caseless)
2288            {            {
2289  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2290            if (utf8 && d >= 128)            if (utf8 && d >= 128)
# Line 2260  for (;;) Line 2310  for (;;)
2310        break;        break;
2311    
2312        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2313          case OP_EXACTI:
2314          case OP_NOTEXACTI:
2315          caseless = TRUE;
2316          codevalue -= OP_STARI - OP_STAR;
2317          /* Fall through */
2318        case OP_EXACT:        case OP_EXACT:
2319        case OP_NOTEXACT:        case OP_NOTEXACT:
2320        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
2321        if (clen > 0)        if (clen > 0)
2322          {          {
2323          unsigned int otherd = NOTACHAR;          unsigned int otherd = NOTACHAR;
2324          if ((ims & PCRE_CASELESS) != 0)          if (caseless)
2325            {            {
2326  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2327            if (utf8 && d >= 128)            if (utf8 && d >= 128)
# Line 2290  for (;;) Line 2345  for (;;)
2345        break;        break;
2346    
2347        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2348          case OP_UPTOI:
2349          case OP_MINUPTOI:
2350          case OP_POSUPTOI:
2351          case OP_NOTUPTOI:
2352          case OP_NOTMINUPTOI:
2353          case OP_NOTPOSUPTOI:
2354          caseless = TRUE;
2355          codevalue -= OP_STARI - OP_STAR;
2356          /* Fall through */
2357        case OP_UPTO:        case OP_UPTO:
2358        case OP_MINUPTO:        case OP_MINUPTO:
2359        case OP_POSUPTO:        case OP_POSUPTO:
# Line 2301  for (;;) Line 2365  for (;;)
2365        if (clen > 0)        if (clen > 0)
2366          {          {
2367          unsigned int otherd = NOTACHAR;          unsigned int otherd = NOTACHAR;
2368          if ((ims & PCRE_CASELESS) != 0)          if (caseless)
2369            {            {
2370  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2371            if (utf8 && d >= 128)            if (utf8 && d >= 128)
# Line 2444  for (;;) Line 2508  for (;;)
2508            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2509            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
2510            sizeof(local_workspace)/sizeof(int),  /* size of same */            sizeof(local_workspace)/sizeof(int),  /* size of same */
           ims,                                  /* the current ims flags */  
2511            rlevel,                               /* function recursion level */            rlevel,                               /* function recursion level */
2512            recursing);                           /* pass on regex recursion */            recursing);                           /* pass on regex recursion */
2513    
# Line 2535  for (;;) Line 2598  for (;;)
2598              sizeof(local_offsets)/sizeof(int),    /* size of same */              sizeof(local_offsets)/sizeof(int),    /* size of same */
2599              local_workspace,                      /* workspace vector */              local_workspace,                      /* workspace vector */
2600              sizeof(local_workspace)/sizeof(int),  /* size of same */              sizeof(local_workspace)/sizeof(int),  /* size of same */
             ims,                                  /* the current ims flags */  
2601              rlevel,                               /* function recursion level */              rlevel,                               /* function recursion level */
2602              recursing);                           /* pass on regex recursion */              recursing);                           /* pass on regex recursion */
2603    
# Line 2568  for (;;) Line 2630  for (;;)
2630            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2631            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
2632            sizeof(local_workspace)/sizeof(int),  /* size of same */            sizeof(local_workspace)/sizeof(int),  /* size of same */
           ims,                                  /* the current ims flags */  
2633            rlevel,                               /* function recursion level */            rlevel,                               /* function recursion level */
2634            recursing + 1);                       /* regex recurse level */            recursing + 1);                       /* regex recurse level */
2635    
# Line 2620  for (;;) Line 2681  for (;;)
2681            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2682            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
2683            sizeof(local_workspace)/sizeof(int),  /* size of same */            sizeof(local_workspace)/sizeof(int),  /* size of same */
           ims,                                  /* the current ims flags */  
2684            rlevel,                               /* function recursion level */            rlevel,                               /* function recursion level */
2685            recursing);                           /* pass on regex recursion */            recursing);                           /* pass on regex recursion */
2686    
# Line 3227  for (;;) Line 3287  for (;;)
3287      offsetcount,                       /* size of same */      offsetcount,                       /* size of same */
3288      workspace,                         /* workspace vector */      workspace,                         /* workspace vector */
3289      wscount,                           /* size of same */      wscount,                           /* size of same */
     re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL), /* ims flags */  
3290      0,                                 /* function recurse level */      0,                                 /* function recurse level */
3291      0);                                /* regex recurse level */      0);                                /* regex recurse level */
3292    

Legend:
Removed from v.598  
changed lines
  Added in v.602

  ViewVC Help
Powered by ViewVC 1.1.5