/[pcre]/code/trunk/pcre_exec.c
ViewVC logotype

Diff of /code/trunk/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 91 by nigel, Sat Feb 24 21:41:34 2007 UTC revision 208 by ph10, Mon Aug 6 15:23:29 2007 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-2007 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 42  POSSIBILITY OF SUCH DAMAGE. Line 42  POSSIBILITY OF SUCH DAMAGE.
42  pattern matching using an NFA algorithm, trying to mimic Perl as closely as  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
43  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
44    
45  #define NLBLOCK md           /* The block containing newline information */  #ifdef HAVE_CONFIG_H
46    #include <config.h>
47    #endif
48    
49    #define NLBLOCK md             /* Block containing newline information */
50    #define PSSTART start_subject  /* Field containing processed string start */
51    #define PSEND   end_subject    /* Field containing processed string end */
52    
53  #include "pcre_internal.h"  #include "pcre_internal.h"
54    
55    /* Undefine some potentially clashing cpp symbols */
56    
57  /* Structure for building a chain of data that actually lives on the  #undef min
58  stack, for holding the values of the subject pointer at the start of each  #undef max
 subpattern, so as to detect when an empty string has been matched by a  
 subpattern - to break infinite loops. When NO_RECURSE is set, these blocks  
 are on the heap, not on the stack. */  
   
 typedef struct eptrblock {  
   struct eptrblock *epb_prev;  
   USPTR epb_saved_eptr;  
 } eptrblock;  
59    
60  /* Flag bits for the match() function */  /* Flag bits for the match() function */
61    
62  #define match_condassert   0x01    /* Called to check a condition assertion */  #define match_condassert     0x01  /* Called to check a condition assertion */
63  #define match_isgroup      0x02    /* Set if start of bracketed group */  #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
64    
65  /* Non-error returns from the match() function. Error returns are externally  /* Non-error returns from the match() function. Error returns are externally
66  defined PCRE_ERROR_xxx codes, which are all negative. */  defined PCRE_ERROR_xxx codes, which are all negative. */
# Line 101  Returns:     nothing Line 101  Returns:     nothing
101  static void  static void
102  pchars(const uschar *p, int length, BOOL is_subject, match_data *md)  pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
103  {  {
104  int c;  unsigned int c;
105  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
106  while (length-- > 0)  while (length-- > 0)
107    if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);    if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);
# Line 186  calls by keeping local variables that ne Line 186  calls by keeping local variables that ne
186  obtained from malloc() instead instead of on the stack. Macros are used to  obtained from malloc() instead instead of on the stack. Macros are used to
187  achieve this so that the actual code doesn't look very different to what it  achieve this so that the actual code doesn't look very different to what it
188  always used to.  always used to.
189    
190    The original heap-recursive code used longjmp(). However, it seems that this
191    can be very slow on some operating systems. Following a suggestion from Stan
192    Switzer, the use of longjmp() has been abolished, at the cost of having to
193    provide a unique number for each call to RMATCH. There is no way of generating
194    a sequence of numbers at compile time in C. I have given them names, to make
195    them stand out more clearly.
196    
197    Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
198    FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
199    tests. Furthermore, not using longjmp() means that local dynamic variables
200    don't have indeterminate values; this has meant that the frame size can be
201    reduced because the result can be "passed back" by straight setting of the
202    variable instead of being passed in the frame.
203  ****************************************************************************  ****************************************************************************
204  ***************************************************************************/  ***************************************************************************/
205    
206    
207    /* Numbers for RMATCH calls */
208    
209    enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
210           RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
211           RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
212           RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
213           RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50 };
214    
215    
216  /* These versions of the macros use the stack, as normal. There are debugging  /* These versions of the macros use the stack, as normal. There are debugging
217  versions and production versions. */  versions and production versions. Note that the "rw" argument of RMATCH isn't
218    actuall used in this definition. */
219    
220  #ifndef NO_RECURSE  #ifndef NO_RECURSE
221  #define REGISTER register  #define REGISTER register
222    
223  #ifdef DEBUG  #ifdef DEBUG
224  #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
225    { \    { \
226    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
227    rx = match(ra,rb,rc,rd,re,rf,rg,rdepth+1); \    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \
228    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
229    }    }
230  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 208  versions and production versions. */ Line 233  versions and production versions. */
233    return ra; \    return ra; \
234    }    }
235  #else  #else
236  #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
237    rx = match(ra,rb,rc,rd,re,rf,rg,rdepth+1)    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)
238  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
239  #endif  #endif
240    
241  #else  #else
242    
243    
244  /* These versions of the macros manage a private stack on the heap. Note  /* These versions of the macros manage a private stack on the heap. Note that
245  that the rd argument of RMATCH isn't actually used. It's the md argument of  the "rd" argument of RMATCH isn't actually used in this definition. It's the md
246  match(), which never changes. */  argument of match(), which never changes. */
247    
248  #define REGISTER  #define REGISTER
249    
250  #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
251    {\    {\
252    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
253    if (setjmp(frame->Xwhere) == 0)\    frame->Xwhere = rw; \
254      {\    newframe->Xeptr = ra;\
255      newframe->Xeptr = ra;\    newframe->Xecode = rb;\
256      newframe->Xecode = rb;\    newframe->Xmstart = mstart;\
257      newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
258      newframe->Xims = re;\    newframe->Xims = re;\
259      newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
260      newframe->Xflags = rg;\    newframe->Xflags = rg;\
261      newframe->Xrdepth = frame->Xrdepth + 1;\    newframe->Xrdepth = frame->Xrdepth + 1;\
262      newframe->Xprevframe = frame;\    newframe->Xprevframe = frame;\
263      frame = newframe;\    frame = newframe;\
264      DPRINTF(("restarting from line %d\n", __LINE__));\    DPRINTF(("restarting from line %d\n", __LINE__));\
265      goto HEAP_RECURSE;\    goto HEAP_RECURSE;\
266      }\    L_##rw:\
267    else\    DPRINTF(("jumped back to line %d\n", __LINE__));\
     {\  
     DPRINTF(("longjumped back to line %d\n", __LINE__));\  
     frame = md->thisframe;\  
     rx = frame->Xresult;\  
     }\  
268    }    }
269    
270  #define RRETURN(ra)\  #define RRETURN(ra)\
# Line 254  match(), which never changes. */ Line 274  match(), which never changes. */
274    (pcre_stack_free)(newframe);\    (pcre_stack_free)(newframe);\
275    if (frame != NULL)\    if (frame != NULL)\
276      {\      {\
277      frame->Xresult = ra;\      rrc = ra;\
278      md->thisframe = frame;\      goto HEAP_RETURN;\
     longjmp(frame->Xwhere, 1);\  
279      }\      }\
280    return ra;\    return ra;\
281    }    }
# Line 271  typedef struct heapframe { Line 290  typedef struct heapframe {
290    
291    const uschar *Xeptr;    const uschar *Xeptr;
292    const uschar *Xecode;    const uschar *Xecode;
293      const uschar *Xmstart;
294    int Xoffset_top;    int Xoffset_top;
295    long int Xims;    long int Xims;
296    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 291  typedef struct heapframe { Line 311  typedef struct heapframe {
311    
312    BOOL Xcur_is_word;    BOOL Xcur_is_word;
313    BOOL Xcondition;    BOOL Xcondition;
   BOOL Xminimize;  
314    BOOL Xprev_is_word;    BOOL Xprev_is_word;
315    
316    unsigned long int Xoriginal_ims;    unsigned long int Xoriginal_ims;
# Line 303  typedef struct heapframe { Line 322  typedef struct heapframe {
322    int Xprop_category;    int Xprop_category;
323    int Xprop_chartype;    int Xprop_chartype;
324    int Xprop_script;    int Xprop_script;
325    int *Xprop_test_variable;    int Xoclength;
326      uschar Xocchars[8];
327  #endif  #endif
328    
329    int Xctype;    int Xctype;
330    int Xfc;    unsigned int Xfc;
331    int Xfi;    int Xfi;
332    int Xlength;    int Xlength;
333    int Xmax;    int Xmax;
# Line 321  typedef struct heapframe { Line 341  typedef struct heapframe {
341    
342    eptrblock Xnewptrb;    eptrblock Xnewptrb;
343    
344    /* Place to pass back result, and where to jump back to */    /* Where to jump back to */
345    
346    int  Xresult;    int Xwhere;
   jmp_buf Xwhere;  
347    
348  } heapframe;  } heapframe;
349    
# Line 340  typedef struct heapframe { Line 359  typedef struct heapframe {
359  *         Match from current position            *  *         Match from current position            *
360  *************************************************/  *************************************************/
361    
362  /* On entry ecode points to the first opcode, and eptr to the first character  /* This function is called recursively in many circumstances. Whenever it
 in the subject string, while eptrb holds the value of eptr at the start of the  
 last bracketed group - used for breaking infinite loops matching zero-length  
 strings. This function is called recursively in many circumstances. Whenever it  
363  returns a negative (error) response, the outer incarnation must also return the  returns a negative (error) response, the outer incarnation must also return the
364  same response.  same response.
365    
# Line 353  performance. Tests using gcc on a SPARC Line 369  performance. Tests using gcc on a SPARC
369  made performance worse.  made performance worse.
370    
371  Arguments:  Arguments:
372     eptr        pointer in subject     eptr        pointer to current character in subject
373     ecode       position in code     ecode       pointer to current position in compiled code
374       mstart      pointer to the current match start position (can be modified
375                     by encountering \K)
376     offset_top  current top pointer     offset_top  current top pointer
377     md          pointer to "static" info for the match     md          pointer to "static" info for the match
378     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 362  Arguments: Line 380  Arguments:
380                   brackets - for testing for empty matches                   brackets - for testing for empty matches
381     flags       can contain     flags       can contain
382                   match_condassert - this is an assertion condition                   match_condassert - this is an assertion condition
383                   match_isgroup - this is the start of a bracketed group                   match_cbegroup - this is the start of an unlimited repeat
384                       group that can match an empty string
385     rdepth      the recursion depth     rdepth      the recursion depth
386    
387  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
# Line 372  Returns:       MATCH_MATCH if matched Line 391  Returns:       MATCH_MATCH if matched
391  */  */
392    
393  static int  static int
394  match(REGISTER USPTR eptr, REGISTER const uschar *ecode,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
395    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
396    int flags, unsigned int rdepth)    int flags, unsigned int rdepth)
397  {  {
398  /* These variables do not need to be preserved over recursion in this function,  /* These variables do not need to be preserved over recursion in this function,
399  so they can be ordinary variables in all cases. Mark them with "register"  so they can be ordinary variables in all cases. Mark some of them with
400  because they are used a lot in loops. */  "register" because they are used a lot in loops. */
401    
402  register int  rrc;         /* Returns from recursive calls */  register int  rrc;         /* Returns from recursive calls */
403  register int  i;           /* Used for loops not involving calls to RMATCH() */  register int  i;           /* Used for loops not involving calls to RMATCH() */
404  register unsigned int  c;  /* Character values not kept over RMATCH() calls */  register unsigned int c;   /* Character values not kept over RMATCH() calls */
405  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
406    
407    BOOL minimize, possessive; /* Quantifier options */
408    
409  /* When recursion is not being used, all "local" variables that have to be  /* When recursion is not being used, all "local" variables that have to be
410  preserved over calls to RMATCH() are part of a "frame" which is obtained from  preserved over calls to RMATCH() are part of a "frame" which is obtained from
411  heap storage. Set up the top-level frame here; others are obtained from the  heap storage. Set up the top-level frame here; others are obtained from the
# Line 398  frame->Xprevframe = NULL;            /* Line 419  frame->Xprevframe = NULL;            /*
419    
420  frame->Xeptr = eptr;  frame->Xeptr = eptr;
421  frame->Xecode = ecode;  frame->Xecode = ecode;
422    frame->Xmstart = mstart;
423  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
424  frame->Xims = ims;  frame->Xims = ims;
425  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 412  HEAP_RECURSE: Line 434  HEAP_RECURSE:
434    
435  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
436  #define ecode              frame->Xecode  #define ecode              frame->Xecode
437    #define mstart             frame->Xmstart
438  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
439  #define ims                frame->Xims  #define ims                frame->Xims
440  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 434  HEAP_RECURSE: Line 457  HEAP_RECURSE:
457    
458  #define cur_is_word        frame->Xcur_is_word  #define cur_is_word        frame->Xcur_is_word
459  #define condition          frame->Xcondition  #define condition          frame->Xcondition
 #define minimize           frame->Xminimize  
460  #define prev_is_word       frame->Xprev_is_word  #define prev_is_word       frame->Xprev_is_word
461    
462  #define original_ims       frame->Xoriginal_ims  #define original_ims       frame->Xoriginal_ims
# Line 446  HEAP_RECURSE: Line 468  HEAP_RECURSE:
468  #define prop_category      frame->Xprop_category  #define prop_category      frame->Xprop_category
469  #define prop_chartype      frame->Xprop_chartype  #define prop_chartype      frame->Xprop_chartype
470  #define prop_script        frame->Xprop_script  #define prop_script        frame->Xprop_script
471  #define prop_test_variable frame->Xprop_test_variable  #define oclength           frame->Xoclength
472    #define occhars            frame->Xocchars
473  #endif  #endif
474    
475  #define ctype              frame->Xctype  #define ctype              frame->Xctype
# Line 470  HEAP_RECURSE: Line 493  HEAP_RECURSE:
493  get preserved during recursion in the normal way. In this environment, fi and  get preserved during recursion in the normal way. In this environment, fi and
494  i, and fc and c, can be the same variables. */  i, and fc and c, can be the same variables. */
495    
496  #else  #else         /* NO_RECURSE not defined */
497  #define fi i  #define fi i
498  #define fc c  #define fc c
499    
# Line 489  recursion_info new_recursive;      /* wi Line 512  recursion_info new_recursive;      /* wi
512                                     /* that do not have to be preserved over  */                                     /* that do not have to be preserved over  */
513  BOOL cur_is_word;                  /* a recursive call to RMATCH().          */  BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
514  BOOL condition;  BOOL condition;
 BOOL minimize;  
515  BOOL prev_is_word;  BOOL prev_is_word;
516    
517  unsigned long int original_ims;  unsigned long int original_ims;
# Line 501  int prop_fail_result; Line 523  int prop_fail_result;
523  int prop_category;  int prop_category;
524  int prop_chartype;  int prop_chartype;
525  int prop_script;  int prop_script;
526  int *prop_test_variable;  int oclength;
527    uschar occhars[8];
528  #endif  #endif
529    
530  int ctype;  int ctype;
# Line 516  int save_offset1, save_offset2, save_off Line 539  int save_offset1, save_offset2, save_off
539  int stacksave[REC_STACK_SAVE_MAX];  int stacksave[REC_STACK_SAVE_MAX];
540    
541  eptrblock newptrb;  eptrblock newptrb;
542  #endif  #endif     /* NO_RECURSE */
543    
544  /* These statements are here to stop the compiler complaining about unitialized  /* These statements are here to stop the compiler complaining about unitialized
545  variables. */  variables. */
# Line 524  variables. */ Line 547  variables. */
547  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
548  prop_value = 0;  prop_value = 0;
549  prop_fail_result = 0;  prop_fail_result = 0;
 prop_test_variable = NULL;  
550  #endif  #endif
551    
552    
553  /* This label is used for tail recursion, which is used in a few cases even  /* This label is used for tail recursion, which is used in a few cases even
554  when NO_RECURSE is not defined, in order to reduce the amount of stack that is  when NO_RECURSE is not defined, in order to reduce the amount of stack that is
555  used. Thanks to Ian Taylor for noticing this possibility and sending the  used. Thanks to Ian Taylor for noticing this possibility and sending the
# Line 542  defined). However, RMATCH isn't like a f Line 565  defined). However, RMATCH isn't like a f
565  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
566  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
567    
568    #ifdef SUPPORT_UTF8
569    utf8 = md->utf8;       /* Local copy of the flag */
570    #else
571    utf8 = FALSE;
572    #endif
573    
574  /* First check that we haven't called match() too many times, or that we  /* First check that we haven't called match() too many times, or that we
575  haven't exceeded the recursive call limit. */  haven't exceeded the recursive call limit. */
576    
# Line 550  if (rdepth >= md->match_limit_recursion) Line 579  if (rdepth >= md->match_limit_recursion)
579    
580  original_ims = ims;    /* Save for resetting on ')' */  original_ims = ims;    /* Save for resetting on ')' */
581    
582  #ifdef SUPPORT_UTF8  /* At the start of a group with an unlimited repeat that may match an empty
583  utf8 = md->utf8;       /* Local copy of the flag */  string, the match_cbegroup flag is set. When this is the case, add the current
584  #else  subject pointer to the chain of such remembered pointers, to be checked when we
585  utf8 = FALSE;  hit the closing ket, in order to break infinite loops that match no characters.
586  #endif  When match() is called in other circumstances, don't add to the chain. The
587    match_cbegroup flag must NOT be used with tail recursion, because the memory
588  /* At the start of a bracketed group, add the current subject pointer to the  block that is used is on the stack, so a new one may be required for each
589  stack of such pointers, to be re-instated at the end of the group when we hit  match(). */
 the closing ket. When match() is called in other circumstances, we don't add to  
 this stack. */  
590    
591  if ((flags & match_isgroup) != 0)  if ((flags & match_cbegroup) != 0)
592    {    {
   newptrb.epb_prev = eptrb;  
593    newptrb.epb_saved_eptr = eptr;    newptrb.epb_saved_eptr = eptr;
594      newptrb.epb_prev = eptrb;
595    eptrb = &newptrb;    eptrb = &newptrb;
596    }    }
597    
598  /* Now start processing the operations. */  /* Now start processing the opcodes. */
599    
600  for (;;)  for (;;)
601    {    {
602      minimize = possessive = FALSE;
603    op = *ecode;    op = *ecode;
   minimize = FALSE;  
604    
605    /* For partial matching, remember if we ever hit the end of the subject after    /* For partial matching, remember if we ever hit the end of the subject after
606    matching at least one subject character. */    matching at least one subject character. */
607    
608    if (md->partial &&    if (md->partial &&
609        eptr >= md->end_subject &&        eptr >= md->end_subject &&
610        eptr > md->start_match)        eptr > mstart)
611      md->hitend = TRUE;      md->hitend = TRUE;
612    
613    /* Opening capturing bracket. If there is space in the offset vector, save    switch(op)
   the current subject position in the working slot at the top of the vector. We  
   mustn't change the current values of the data slot, because they may be set  
   from a previous iteration of this group, and be referred to by a reference  
   inside the group.  
   
   If the bracket fails to match, we need to restore this value and also the  
   values of the final offsets, in case they were set by a previous iteration of  
   the same bracket.  
   
   If there isn't enough space in the offset vector, treat this as if it were a  
   non-capturing bracket. Don't worry about setting the flag for the error case  
   here; that is handled in the code for KET. */  
   
   if (op > OP_BRA)  
614      {      {
615      number = op - OP_BRA;      /* Handle a capturing bracket. If there is space in the offset vector, save
616        the current subject position in the working slot at the top of the vector.
617      /* For extended extraction brackets (large number), we have to fish out the      We mustn't change the current values of the data slot, because they may be
618      number from a dummy opcode at the start. */      set from a previous iteration of this group, and be referred to by a
619        reference inside the group.
620      if (number > EXTRACT_BASIC_MAX)  
621        number = GET2(ecode, 2+LINK_SIZE);      If the bracket fails to match, we need to restore this value and also the
622        values of the final offsets, in case they were set by a previous iteration
623        of the same bracket.
624    
625        If there isn't enough space in the offset vector, treat this as if it were
626        a non-capturing bracket. Don't worry about setting the flag for the error
627        case here; that is handled in the code for KET. */
628    
629        case OP_CBRA:
630        case OP_SCBRA:
631        number = GET2(ecode, 1+LINK_SIZE);
632      offset = number << 1;      offset = number << 1;
633    
634  #ifdef DEBUG  #ifdef DEBUG
635      printf("start bracket %d subject=", number);      printf("start bracket %d\n", number);
636        printf("subject=");
637      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
638      printf("\n");      printf("\n");
639  #endif  #endif
# Line 624  for (;;) Line 648  for (;;)
648        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
649        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
650    
651          flags = (op == OP_SCBRA)? match_cbegroup : 0;
652        do        do
653          {          {
654          RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
655            match_isgroup);            ims, eptrb, flags, RM1);
656          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
657          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
658          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
# Line 643  for (;;) Line 668  for (;;)
668        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
669        }        }
670    
671      /* Insufficient room for saving captured contents */      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
672        as a non-capturing bracket. */
673    
674      else op = OP_BRA;      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
675      }      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
   
   /* Other types of node can be handled by a switch */  
   
   switch(op)  
     {  
     case OP_BRA:     /* Non-capturing bracket: optimized */  
     DPRINTF(("start bracket 0\n"));  
676    
677      /* Loop for all the alternatives */      DPRINTF(("insufficient capture room: treat as non-capturing\n"));
678    
679        /* VVVVVVVVVVVVVVVVVVVVVVVVV */
680        /* VVVVVVVVVVVVVVVVVVVVVVVVV */
681    
682        /* Non-capturing bracket. Loop for all the alternatives. When we get to the
683        final alternative within the brackets, we would return the result of a
684        recursive call to match() whatever happened. We can reduce stack usage by
685        turning this into a tail recursion, except in the case when match_cbegroup
686        is set.*/
687    
688        case OP_BRA:
689        case OP_SBRA:
690        DPRINTF(("start non-capturing bracket\n"));
691        flags = (op >= OP_SBRA)? match_cbegroup : 0;
692      for (;;)      for (;;)
693        {        {
694        /* When we get to the final alternative within the brackets, we would        if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
695        return the result of a recursive call to match() whatever happened. We          {
696        can reduce stack usage by turning this into a tail recursion. */          if (flags == 0)    /* Not a possibly empty group */
697              {
698        if (ecode[GET(ecode, 1)] != OP_ALT)            ecode += _pcre_OP_lengths[*ecode];
699         {            DPRINTF(("bracket 0 tail recursion\n"));
700         ecode += 1 + LINK_SIZE;            goto TAIL_RECURSE;
701         flags = match_isgroup;            }
702         DPRINTF(("bracket 0 tail recursion\n"));  
703         goto TAIL_RECURSE;          /* Possibly empty group; can't use tail recursion. */
704         }  
705            RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
706              eptrb, flags, RM48);
707            RRETURN(rrc);
708            }
709    
710        /* For non-final alternatives, continue the loop for a NOMATCH result;        /* For non-final alternatives, continue the loop for a NOMATCH result;
711        otherwise return. */        otherwise return. */
712    
713        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
714          match_isgroup);          eptrb, flags, RM2);
715        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
716        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
717        }        }
# Line 688  for (;;) Line 724  for (;;)
724      obeyed, we can use tail recursion to avoid using another stack frame. */      obeyed, we can use tail recursion to avoid using another stack frame. */
725    
726      case OP_COND:      case OP_COND:
727      if (ecode[LINK_SIZE+1] == OP_CREF) /* Condition extract or recurse test */      case OP_SCOND:
728        if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */
729          {
730          offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
731          condition = md->recursive != NULL &&
732            (offset == RREF_ANY || offset == md->recursive->group_num);
733          ecode += condition? 3 : GET(ecode, 1);
734          }
735    
736        else if (ecode[LINK_SIZE+1] == OP_CREF)    /* Group used test */
737        {        {
738        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
739        condition = (offset == CREF_RECURSE * 2)?        condition = offset < offset_top && md->offset_vector[offset] >= 0;
740          (md->recursive != NULL) :        ecode += condition? 3 : GET(ecode, 1);
741          (offset < offset_top && md->offset_vector[offset] >= 0);        }
742        ecode += condition? (LINK_SIZE + 4) : (LINK_SIZE + 1 + GET(ecode, 1));  
743        flags = match_isgroup;      else if (ecode[LINK_SIZE+1] == OP_DEF)     /* DEFINE - always false */
744        goto TAIL_RECURSE;        {
745          condition = FALSE;
746          ecode += GET(ecode, 1);
747        }        }
748    
749      /* The condition is an assertion. Call match() to evaluate it - setting      /* The condition is an assertion. Call match() to evaluate it - setting
750      the final argument TRUE causes it to stop at the end of an assertion. */      the final argument match_condassert causes it to stop at the end of an
751        assertion. */
752    
753      else      else
754        {        {
755        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
756            match_condassert | match_isgroup);            match_condassert, RM3);
757        if (rrc == MATCH_MATCH)        if (rrc == MATCH_MATCH)
758          {          {
759          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE+2);          condition = TRUE;
760            ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
761          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
762          }          }
763        else if (rrc != MATCH_NOMATCH)        else if (rrc != MATCH_NOMATCH)
764          {          {
765          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
766          }          }
767        else ecode += GET(ecode, 1);        else
768            {
769            condition = FALSE;
770            ecode += GET(ecode, 1);
771            }
772          }
773    
774        /* We are now at the branch that is to be obeyed. As there is only one,      /* We are now at the branch that is to be obeyed. As there is only one,
775        we can use tail recursion to avoid using another stack frame. */      we can use tail recursion to avoid using another stack frame, except when
776        match_cbegroup is required for an unlimited repeat of a possibly empty
777        group. If the second alternative doesn't exist, we can just plough on. */
778    
779        if (condition || *ecode == OP_ALT)
780          {
781          ecode += 1 + LINK_SIZE;
782          if (op == OP_SCOND)        /* Possibly empty group */
783            {
784            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
785            RRETURN(rrc);
786            }
787          else                       /* Group must match something */
788            {
789            flags = 0;
790            goto TAIL_RECURSE;
791            }
792          }
793        else                         /* Condition false & no 2nd alternative */
794          {
795        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
       flags = match_isgroup;  
       goto TAIL_RECURSE;  
796        }        }
     /* Control never reaches here */  
   
     /* Skip over conditional reference or large extraction number data if  
     encountered. */  
   
     case OP_CREF:  
     case OP_BRANUMBER:  
     ecode += 3;  
797      break;      break;
798    
799      /* End of the pattern. If we are in a recursion, we should restore the  
800      offsets appropriately and continue from after the call. */      /* End of the pattern. If we are in a top-level recursion, we should
801        restore the offsets appropriately and continue from after the call. */
802    
803      case OP_END:      case OP_END:
804      if (md->recursive != NULL && md->recursive->group_num == 0)      if (md->recursive != NULL && md->recursive->group_num == 0)
# Line 745  for (;;) Line 808  for (;;)
808        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
809        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
810          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
811        md->start_match = rec->save_start;        mstart = rec->save_start;
812        ims = original_ims;        ims = original_ims;
813        ecode = rec->after_call;        ecode = rec->after_call;
814        break;        break;
# Line 754  for (;;) Line 817  for (;;)
817      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
818      string - backtracking will then try other alternatives, if any. */      string - backtracking will then try other alternatives, if any. */
819    
820      if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);      if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
821      md->end_match_ptr = eptr;          /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
822      md->end_offset_top = offset_top;   /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
823        md->start_match_ptr = mstart;  /* and the start (\K can modify) */
824      RRETURN(MATCH_MATCH);      RRETURN(MATCH_MATCH);
825    
826      /* Change option settings */      /* Change option settings */
# Line 777  for (;;) Line 841  for (;;)
841      case OP_ASSERTBACK:      case OP_ASSERTBACK:
842      do      do
843        {        {
844        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
845          match_isgroup);          RM4);
846        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
847        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
848        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
# Line 804  for (;;) Line 868  for (;;)
868      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
869      do      do
870        {        {
871        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
872          match_isgroup);          RM5);
873        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
874        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
875        ecode += GET(ecode,1);        ecode += GET(ecode,1);
# Line 826  for (;;) Line 890  for (;;)
890  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
891      if (utf8)      if (utf8)
892        {        {
893        c = GET(ecode,1);        i = GET(ecode, 1);
894        for (i = 0; i < c; i++)        while (i-- > 0)
895          {          {
896          eptr--;          eptr--;
897          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
898          BACKCHAR(eptr)          BACKCHAR(eptr);
899          }          }
900        }        }
901      else      else
# Line 840  for (;;) Line 904  for (;;)
904      /* No UTF-8 support, or not in UTF-8 mode: count is byte count */      /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
905    
906        {        {
907        eptr -= GET(ecode,1);        eptr -= GET(ecode, 1);
908        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
909        }        }
910    
# Line 862  for (;;) Line 926  for (;;)
926        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
927        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
928        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = md->end_subject - md->start_subject;
929        cb.start_match      = md->start_match - md->start_subject;        cb.start_match      = mstart - md->start_subject;
930        cb.current_position = eptr - md->start_subject;        cb.current_position = eptr - md->start_subject;
931        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
932        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
# Line 897  for (;;) Line 961  for (;;)
961      case OP_RECURSE:      case OP_RECURSE:
962        {        {
963        callpat = md->start_code + GET(ecode, 1);        callpat = md->start_code + GET(ecode, 1);
964        new_recursive.group_num = *callpat - OP_BRA;        new_recursive.group_num = (callpat == md->start_code)? 0 :
965            GET2(callpat, 1 + LINK_SIZE);
       /* For extended extraction brackets (large number), we have to fish out  
       the number from a dummy opcode at the start. */  
   
       if (new_recursive.group_num > EXTRACT_BASIC_MAX)  
         new_recursive.group_num = GET2(callpat, 2+LINK_SIZE);  
966    
967        /* Add to "recursing stack" */        /* Add to "recursing stack" */
968    
# Line 929  for (;;) Line 988  for (;;)
988    
989        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
990              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
991        new_recursive.save_start = md->start_match;        new_recursive.save_start = mstart;
992        md->start_match = eptr;        mstart = eptr;
993    
994        /* OK, now we can do the recursion. For each top-level alternative we        /* OK, now we can do the recursion. For each top-level alternative we
995        restore the offset and recursion data. */        restore the offset and recursion data. */
996    
997        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
998          flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
999        do        do
1000          {          {
1001          RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1002              eptrb, match_isgroup);            md, ims, eptrb, flags, RM6);
1003          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH)
1004            {            {
1005            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
# Line 982  for (;;) Line 1042  for (;;)
1042    
1043      do      do
1044        {        {
1045        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
         eptrb, match_isgroup);  
1046        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
1047        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1048        ecode += GET(ecode,1);        ecode += GET(ecode,1);
# Line 997  for (;;) Line 1056  for (;;)
1056      /* Continue as from after the assertion, updating the offsets high water      /* Continue as from after the assertion, updating the offsets high water
1057      mark, since extracts may have been taken. */      mark, since extracts may have been taken. */
1058    
1059      do ecode += GET(ecode,1); while (*ecode == OP_ALT);      do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1060    
1061      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1062      eptr = md->end_match_ptr;      eptr = md->end_match_ptr;
# Line 1028  for (;;) Line 1087  for (;;)
1087    
1088      if (*ecode == OP_KETRMIN)      if (*ecode == OP_KETRMIN)
1089        {        {
1090        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);
1091        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1092        ecode = prev;        ecode = prev;
1093        flags = match_isgroup;        flags = 0;
1094        goto TAIL_RECURSE;        goto TAIL_RECURSE;
1095        }        }
1096      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
1097        {        {
1098        RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);        RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
1099        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1100        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1101        flags = 0;        flags = 0;
# Line 1060  for (;;) Line 1119  for (;;)
1119      case OP_BRAZERO:      case OP_BRAZERO:
1120        {        {
1121        next = ecode+1;        next = ecode+1;
1122        RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);        RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);
1123        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1124        do next += GET(next,1); while (*next == OP_ALT);        do next += GET(next,1); while (*next == OP_ALT);
1125        ecode = next + 1+LINK_SIZE;        ecode = next + 1 + LINK_SIZE;
1126        }        }
1127      break;      break;
1128    
1129      case OP_BRAMINZERO:      case OP_BRAMINZERO:
1130        {        {
1131        next = ecode+1;        next = ecode+1;
1132        do next += GET(next,1); while (*next == OP_ALT);        do next += GET(next, 1); while (*next == OP_ALT);
1133        RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb,        RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0, RM11);
         match_isgroup);  
1134        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1135        ecode++;        ecode++;
1136        }        }
1137      break;      break;
1138    
1139      /* End of a group, repeated or non-repeating. If we are at the end of      /* End of a group, repeated or non-repeating. */
     an assertion "group", stop matching and return MATCH_MATCH, but record the  
     current high water mark for use by positive assertions. Do this also  
     for the "once" (not-backup up) groups. */  
1140    
1141      case OP_KET:      case OP_KET:
1142      case OP_KETRMIN:      case OP_KETRMIN:
1143      case OP_KETRMAX:      case OP_KETRMAX:
1144      prev = ecode - GET(ecode, 1);      prev = ecode - GET(ecode, 1);
     saved_eptr = eptrb->epb_saved_eptr;  
1145    
1146      /* Back up the stack of bracket start pointers. */      /* If this was a group that remembered the subject start, in order to break
1147        infinite repeats of empty string matches, retrieve the subject start from
1148        the chain. Otherwise, set it NULL. */
1149    
1150        if (*prev >= OP_SBRA)
1151          {
1152          saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */
1153          eptrb = eptrb->epb_prev;              /* Backup to previous group */
1154          }
1155        else saved_eptr = NULL;
1156    
1157      eptrb = eptrb->epb_prev;      /* If we are at the end of an assertion group, stop matching and return
1158        MATCH_MATCH, but record the current high water mark for use by positive
1159        assertions. Do this also for the "once" (atomic) groups. */
1160    
1161      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1162          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1102  for (;;) Line 1167  for (;;)
1167        RRETURN(MATCH_MATCH);        RRETURN(MATCH_MATCH);
1168        }        }
1169    
1170      /* In all other cases except a conditional group we have to check the      /* For capturing groups we have to check the group number back at the start
1171      group number back at the start and if necessary complete handling an      and if necessary complete handling an extraction by setting the offsets and
1172      extraction by setting the offsets and bumping the high water mark. */      bumping the high water mark. Note that whole-pattern recursion is coded as
1173        a recurse into group 0, so it won't be picked up here. Instead, we catch it
1174        when the OP_END is reached. Other recursion is handled here. */
1175    
1176      if (*prev != OP_COND)      if (*prev == OP_CBRA || *prev == OP_SCBRA)
1177        {        {
1178        number = *prev - OP_BRA;        number = GET2(prev, 1+LINK_SIZE);
   
       /* For extended extraction brackets (large number), we have to fish out  
       the number from a dummy opcode at the start. */  
   
       if (number > EXTRACT_BASIC_MAX) number = GET2(prev, 2+LINK_SIZE);  
1179        offset = number << 1;        offset = number << 1;
1180    
1181  #ifdef DEBUG  #ifdef DEBUG
# Line 1121  for (;;) Line 1183  for (;;)
1183        printf("\n");        printf("\n");
1184  #endif  #endif
1185    
1186        /* Test for a numbered group. This includes groups called as a result        md->capture_last = number;
1187        of recursion. Note that whole-pattern recursion is coded as a recurse        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
       into group 0, so it won't be picked up here. Instead, we catch it when  
       the OP_END is reached. */  
   
       if (number > 0)  
1188          {          {
1189          md->capture_last = number;          md->offset_vector[offset] =
1190          if (offset >= md->offset_max) md->offset_overflow = TRUE; else            md->offset_vector[md->offset_end - number];
1191            {          md->offset_vector[offset+1] = eptr - md->start_subject;
1192            md->offset_vector[offset] =          if (offset_top <= offset) offset_top = offset + 2;
1193              md->offset_vector[md->offset_end - number];          }
1194            md->offset_vector[offset+1] = eptr - md->start_subject;  
1195            if (offset_top <= offset) offset_top = offset + 2;        /* Handle a recursively called group. Restore the offsets
1196            }        appropriately and continue from after the call. */
1197    
1198          /* Handle a recursively called group. Restore the offsets        if (md->recursive != NULL && md->recursive->group_num == number)
1199          appropriately and continue from after the call. */          {
1200            recursion_info *rec = md->recursive;
1201          if (md->recursive != NULL && md->recursive->group_num == number)          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1202            {          md->recursive = rec->prevrec;
1203            recursion_info *rec = md->recursive;          mstart = rec->save_start;
1204            DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          memcpy(md->offset_vector, rec->offset_save,
1205            md->recursive = rec->prevrec;            rec->saved_max * sizeof(int));
1206            md->start_match = rec->save_start;          ecode = rec->after_call;
1207            memcpy(md->offset_vector, rec->offset_save,          ims = original_ims;
1208              rec->saved_max * sizeof(int));          break;
           ecode = rec->after_call;  
           ims = original_ims;  
           break;  
           }  
1209          }          }
1210        }        }
1211    
1212      /* Reset the value of the ims flags, in case they got changed during      /* For both capturing and non-capturing groups, reset the value of the ims
1213      the group. */      flags, in case they got changed during the group. */
1214    
1215      ims = original_ims;      ims = original_ims;
1216      DPRINTF(("ims reset to %02lx\n", ims));      DPRINTF(("ims reset to %02lx\n", ims));
# Line 1175  for (;;) Line 1229  for (;;)
1229    
1230      /* The repeating kets try the rest of the pattern or restart from the      /* The repeating kets try the rest of the pattern or restart from the
1231      preceding bracket, in the appropriate order. In the second case, we can use      preceding bracket, in the appropriate order. In the second case, we can use
1232      tail recursion to avoid using another stack frame. */      tail recursion to avoid using another stack frame, unless we have an
1233        unlimited repeat of a group that can match an empty string. */
1234    
1235        flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
1236    
1237      if (*ecode == OP_KETRMIN)      if (*ecode == OP_KETRMIN)
1238        {        {
1239        RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
1240        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1241          if (flags != 0)    /* Could match an empty string */
1242            {
1243            RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
1244            RRETURN(rrc);
1245            }
1246        ecode = prev;        ecode = prev;
       flags = match_isgroup;  
1247        goto TAIL_RECURSE;        goto TAIL_RECURSE;
1248        }        }
1249      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
1250        {        {
1251        RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);        RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
1252        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1253        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1254        flags = 0;        flags = 0;
# Line 1202  for (;;) Line 1263  for (;;)
1263      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1264        {        {
1265        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1266            (eptr == md->end_subject ||            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
            eptr < md->start_subject + md->nllen ||  
            !IS_NEWLINE(eptr - md->nllen)))  
1267          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
1268        ecode++;        ecode++;
1269        break;        break;
# Line 1225  for (;;) Line 1284  for (;;)
1284      ecode++;      ecode++;
1285      break;      break;
1286    
1287        /* Reset the start of match point */
1288    
1289        case OP_SET_SOM:
1290        mstart = eptr;
1291        ecode++;
1292        break;
1293    
1294      /* Assert before internal newline if multiline, or before a terminating      /* Assert before internal newline if multiline, or before a terminating
1295      newline unless endonly is set, else end of subject unless noteol is set. */      newline unless endonly is set, else end of subject unless noteol is set. */
1296    
# Line 1244  for (;;) Line 1310  for (;;)
1310        if (!md->endonly)        if (!md->endonly)
1311          {          {
1312          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1313              (eptr != md->end_subject - md->nllen || !IS_NEWLINE(eptr)))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1314            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1315          ecode++;          ecode++;
1316          break;          break;
# Line 1263  for (;;) Line 1329  for (;;)
1329    
1330      case OP_EODN:      case OP_EODN:
1331      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1332          (eptr != md->end_subject - md->nllen || !IS_NEWLINE(eptr)))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1333        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1334      ecode++;      ecode++;
1335      break;      break;
# Line 1319  for (;;) Line 1385  for (;;)
1385      case OP_ANY:      case OP_ANY:
1386      if ((ims & PCRE_DOTALL) == 0)      if ((ims & PCRE_DOTALL) == 0)
1387        {        {
1388        if (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr))        if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
         RRETURN(MATCH_NOMATCH);  
1389        }        }
1390      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
1391      if (utf8)      if (utf8)
# Line 1414  for (;;) Line 1479  for (;;)
1479      ecode++;      ecode++;
1480      break;      break;
1481    
1482        case OP_ANYNL:
1483        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1484        GETCHARINCTEST(c, eptr);
1485        switch(c)
1486          {
1487          default: RRETURN(MATCH_NOMATCH);
1488          case 0x000d:
1489          if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1490          break;
1491          case 0x000a:
1492          case 0x000b:
1493          case 0x000c:
1494          case 0x0085:
1495          case 0x2028:
1496          case 0x2029:
1497          break;
1498          }
1499        ecode++;
1500        break;
1501    
1502        case OP_NOT_HSPACE:
1503        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1504        GETCHARINCTEST(c, eptr);
1505        switch(c)
1506          {
1507          default: break;
1508          case 0x09:      /* HT */
1509          case 0x20:      /* SPACE */
1510          case 0xa0:      /* NBSP */
1511          case 0x1680:    /* OGHAM SPACE MARK */
1512          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1513          case 0x2000:    /* EN QUAD */
1514          case 0x2001:    /* EM QUAD */
1515          case 0x2002:    /* EN SPACE */
1516          case 0x2003:    /* EM SPACE */
1517          case 0x2004:    /* THREE-PER-EM SPACE */
1518          case 0x2005:    /* FOUR-PER-EM SPACE */
1519          case 0x2006:    /* SIX-PER-EM SPACE */
1520          case 0x2007:    /* FIGURE SPACE */
1521          case 0x2008:    /* PUNCTUATION SPACE */
1522          case 0x2009:    /* THIN SPACE */
1523          case 0x200A:    /* HAIR SPACE */
1524          case 0x202f:    /* NARROW NO-BREAK SPACE */
1525          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1526          case 0x3000:    /* IDEOGRAPHIC SPACE */
1527          RRETURN(MATCH_NOMATCH);
1528          }
1529        ecode++;
1530        break;
1531    
1532        case OP_HSPACE:
1533        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1534        GETCHARINCTEST(c, eptr);
1535        switch(c)
1536          {
1537          default: RRETURN(MATCH_NOMATCH);
1538          case 0x09:      /* HT */
1539          case 0x20:      /* SPACE */
1540          case 0xa0:      /* NBSP */
1541          case 0x1680:    /* OGHAM SPACE MARK */
1542          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1543          case 0x2000:    /* EN QUAD */
1544          case 0x2001:    /* EM QUAD */
1545          case 0x2002:    /* EN SPACE */
1546          case 0x2003:    /* EM SPACE */
1547          case 0x2004:    /* THREE-PER-EM SPACE */
1548          case 0x2005:    /* FOUR-PER-EM SPACE */
1549          case 0x2006:    /* SIX-PER-EM SPACE */
1550          case 0x2007:    /* FIGURE SPACE */
1551          case 0x2008:    /* PUNCTUATION SPACE */
1552          case 0x2009:    /* THIN SPACE */
1553          case 0x200A:    /* HAIR SPACE */
1554          case 0x202f:    /* NARROW NO-BREAK SPACE */
1555          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1556          case 0x3000:    /* IDEOGRAPHIC SPACE */
1557          break;
1558          }
1559        ecode++;
1560        break;
1561    
1562        case OP_NOT_VSPACE:
1563        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1564        GETCHARINCTEST(c, eptr);
1565        switch(c)
1566          {
1567          default: break;
1568          case 0x0a:      /* LF */
1569          case 0x0b:      /* VT */
1570          case 0x0c:      /* FF */
1571          case 0x0d:      /* CR */
1572          case 0x85:      /* NEL */
1573          case 0x2028:    /* LINE SEPARATOR */
1574          case 0x2029:    /* PARAGRAPH SEPARATOR */
1575          RRETURN(MATCH_NOMATCH);
1576          }
1577        ecode++;
1578        break;
1579    
1580        case OP_VSPACE:
1581        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1582        GETCHARINCTEST(c, eptr);
1583        switch(c)
1584          {
1585          default: RRETURN(MATCH_NOMATCH);
1586          case 0x0a:      /* LF */
1587          case 0x0b:      /* VT */
1588          case 0x0c:      /* FF */
1589          case 0x0d:      /* CR */
1590          case 0x85:      /* NEL */
1591          case 0x2028:    /* LINE SEPARATOR */
1592          case 0x2029:    /* PARAGRAPH SEPARATOR */
1593          break;
1594          }
1595        ecode++;
1596        break;
1597    
1598  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
1599      /* Check the next character by Unicode property. We will get here only      /* Check the next character by Unicode property. We will get here only
1600      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. */
# Line 1456  for (;;) Line 1637  for (;;)
1637    
1638          default:          default:
1639          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
         break;  
1640          }          }
1641    
1642        ecode += 3;        ecode += 3;
# Line 1570  for (;;) Line 1750  for (;;)
1750          {          {
1751          for (fi = min;; fi++)          for (fi = min;; fi++)
1752            {            {
1753            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
1754            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1755            if (fi >= max || !match_ref(offset, eptr, length, md, ims))            if (fi >= max || !match_ref(offset, eptr, length, md, ims))
1756              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
# Line 1591  for (;;) Line 1771  for (;;)
1771            }            }
1772          while (eptr >= pp)          while (eptr >= pp)
1773            {            {
1774            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
1775            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1776            eptr -= length;            eptr -= length;
1777            }            }
# Line 1696  for (;;) Line 1876  for (;;)
1876            {            {
1877            for (fi = min;; fi++)            for (fi = min;; fi++)
1878              {              {
1879              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
1880              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1881              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1882              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
# Line 1716  for (;;) Line 1896  for (;;)
1896            {            {
1897            for (fi = min;; fi++)            for (fi = min;; fi++)
1898              {              {
1899              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
1900              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1901              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1902              c = *eptr++;              c = *eptr++;
# Line 1753  for (;;) Line 1933  for (;;)
1933              }              }
1934            for (;;)            for (;;)
1935              {              {
1936              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
1937              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1938              if (eptr-- == pp) break;        /* Stop if tried at original pos */              if (eptr-- == pp) break;        /* Stop if tried at original pos */
1939              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 1772  for (;;) Line 1952  for (;;)
1952              }              }
1953            while (eptr >= pp)            while (eptr >= pp)
1954              {              {
1955              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
1956              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1957              eptr--;              eptr--;
1958              }              }
# Line 1843  for (;;) Line 2023  for (;;)
2023          {          {
2024          for (fi = min;; fi++)          for (fi = min;; fi++)
2025            {            {
2026            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2027            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2028            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2029            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
# Line 1867  for (;;) Line 2047  for (;;)
2047            }            }
2048          for(;;)          for(;;)
2049            {            {
2050            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2051            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2052            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2053            BACKCHAR(eptr)            BACKCHAR(eptr);
2054            }            }
2055          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2056          }          }
# Line 1926  for (;;) Line 2106  for (;;)
2106    
2107        else        else
2108          {          {
2109          int dc;          unsigned int dc;
2110          GETCHARINC(dc, eptr);          GETCHARINC(dc, eptr);
2111          ecode += length;          ecode += length;
2112    
# Line 1953  for (;;) Line 2133  for (;;)
2133        }        }
2134      break;      break;
2135    
2136      /* Match a single character repeatedly; different opcodes share code. */      /* Match a single character repeatedly. */
2137    
2138      case OP_EXACT:      case OP_EXACT:
2139      min = max = GET2(ecode, 1);      min = max = GET2(ecode, 1);
2140      ecode += 3;      ecode += 3;
2141      goto REPEATCHAR;      goto REPEATCHAR;
2142    
2143        case OP_POSUPTO:
2144        possessive = TRUE;
2145        /* Fall through */
2146    
2147      case OP_UPTO:      case OP_UPTO:
2148      case OP_MINUPTO:      case OP_MINUPTO:
2149      min = 0;      min = 0;
# Line 1968  for (;;) Line 2152  for (;;)
2152      ecode += 3;      ecode += 3;
2153      goto REPEATCHAR;      goto REPEATCHAR;
2154    
2155        case OP_POSSTAR:
2156        possessive = TRUE;
2157        min = 0;
2158        max = INT_MAX;
2159        ecode++;
2160        goto REPEATCHAR;
2161    
2162        case OP_POSPLUS:
2163        possessive = TRUE;
2164        min = 1;
2165        max = INT_MAX;
2166        ecode++;
2167        goto REPEATCHAR;
2168    
2169        case OP_POSQUERY:
2170        possessive = TRUE;
2171        min = 0;
2172        max = 1;
2173        ecode++;
2174        goto REPEATCHAR;
2175    
2176      case OP_STAR:      case OP_STAR:
2177      case OP_MINSTAR:      case OP_MINSTAR:
2178      case OP_PLUS:      case OP_PLUS:
# Line 1999  for (;;) Line 2204  for (;;)
2204    
2205        if (length > 1)        if (length > 1)
2206          {          {
         int oclength = 0;  
         uschar occhars[8];  
   
2207  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2208          int othercase;          unsigned int othercase;
2209          if ((ims & PCRE_CASELESS) != 0 &&          if ((ims & PCRE_CASELESS) != 0 &&
2210              (othercase = _pcre_ucp_othercase(fc)) >= 0 &&              (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)
              othercase >= 0)  
2211            oclength = _pcre_ord2utf8(othercase, occhars);            oclength = _pcre_ord2utf8(othercase, occhars);
2212            else oclength = 0;
2213  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2214    
2215          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2216            {            {
2217            if (memcmp(eptr, charptr, length) == 0) eptr += length;            if (memcmp(eptr, charptr, length) == 0) eptr += length;
2218    #ifdef SUPPORT_UCP
2219            /* Need braces because of following else */            /* Need braces because of following else */
2220            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
2221            else            else
# Line 2020  for (;;) Line 2223  for (;;)
2223              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
2224              eptr += oclength;              eptr += oclength;
2225              }              }
2226    #else   /* without SUPPORT_UCP */
2227              else { RRETURN(MATCH_NOMATCH); }
2228    #endif  /* SUPPORT_UCP */
2229            }            }
2230    
2231          if (min == max) continue;          if (min == max) continue;
# Line 2028  for (;;) Line 2234  for (;;)
2234            {            {
2235            for (fi = min;; fi++)            for (fi = min;; fi++)
2236              {              {
2237              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2238              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2239              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2240              if (memcmp(eptr, charptr, length) == 0) eptr += length;              if (memcmp(eptr, charptr, length) == 0) eptr += length;
2241    #ifdef SUPPORT_UCP
2242              /* Need braces because of following else */              /* Need braces because of following else */
2243              else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }              else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
2244              else              else
# Line 2039  for (;;) Line 2246  for (;;)
2246                if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);                if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
2247                eptr += oclength;                eptr += oclength;
2248                }                }
2249    #else   /* without SUPPORT_UCP */
2250                else { RRETURN (MATCH_NOMATCH); }
2251    #endif  /* SUPPORT_UCP */
2252              }              }
2253            /* Control never gets here */            /* Control never gets here */
2254            }            }
2255          else  
2256            else  /* Maximize */
2257            {            {
2258            pp = eptr;            pp = eptr;
2259            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2260              {              {
2261              if (eptr > md->end_subject - length) break;              if (eptr > md->end_subject - length) break;
2262              if (memcmp(eptr, charptr, length) == 0) eptr += length;              if (memcmp(eptr, charptr, length) == 0) eptr += length;
2263    #ifdef SUPPORT_UCP
2264              else if (oclength == 0) break;              else if (oclength == 0) break;
2265              else              else
2266                {                {
2267                if (memcmp(eptr, occhars, oclength) != 0) break;                if (memcmp(eptr, occhars, oclength) != 0) break;
2268                eptr += oclength;                eptr += oclength;
2269                }                }
2270    #else   /* without SUPPORT_UCP */
2271                else break;
2272    #endif  /* SUPPORT_UCP */
2273              }              }
2274            while (eptr >= pp)  
2275              if (possessive) continue;
2276              for(;;)
2277             {             {
2278             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2279             if (rrc != MATCH_NOMATCH) RRETURN(rrc);             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2280               if (eptr == pp) RRETURN(MATCH_NOMATCH);
2281    #ifdef SUPPORT_UCP
2282               eptr--;
2283               BACKCHAR(eptr);
2284    #else   /* without SUPPORT_UCP */
2285             eptr -= length;             eptr -= length;
2286    #endif  /* SUPPORT_UCP */
2287             }             }
           RRETURN(MATCH_NOMATCH);  
2288            }            }
2289          /* Control never gets here */          /* Control never gets here */
2290          }          }
# Line 2102  for (;;) Line 2324  for (;;)
2324          {          {
2325          for (fi = min;; fi++)          for (fi = min;; fi++)
2326            {            {
2327            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2328            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2329            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
2330                fc != md->lcc[*eptr++])                fc != md->lcc[*eptr++])
# Line 2110  for (;;) Line 2332  for (;;)
2332            }            }
2333          /* Control never gets here */          /* Control never gets here */
2334          }          }
2335        else        else  /* Maximize */
2336          {          {
2337          pp = eptr;          pp = eptr;
2338          for (i = min; i < max; i++)          for (i = min; i < max; i++)
# Line 2118  for (;;) Line 2340  for (;;)
2340            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
2341            eptr++;            eptr++;
2342            }            }
2343            if (possessive) continue;
2344          while (eptr >= pp)          while (eptr >= pp)
2345            {            {
2346            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
2347            eptr--;            eptr--;
2348            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2349            }            }
# Line 2139  for (;;) Line 2362  for (;;)
2362          {          {
2363          for (fi = min;; fi++)          for (fi = min;; fi++)
2364            {            {
2365            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2366            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2367            if (fi >= max || eptr >= md->end_subject || fc != *eptr++)            if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
2368              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2369            }            }
2370          /* Control never gets here */          /* Control never gets here */
2371          }          }
2372        else        else  /* Maximize */
2373          {          {
2374          pp = eptr;          pp = eptr;
2375          for (i = min; i < max; i++)          for (i = min; i < max; i++)
# Line 2154  for (;;) Line 2377  for (;;)
2377            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject || fc != *eptr) break;
2378            eptr++;            eptr++;
2379            }            }
2380            if (possessive) continue;
2381          while (eptr >= pp)          while (eptr >= pp)
2382            {            {
2383            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
2384            eptr--;            eptr--;
2385            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2386            }            }
# Line 2206  for (;;) Line 2430  for (;;)
2430      ecode += 3;      ecode += 3;
2431      goto REPEATNOTCHAR;      goto REPEATNOTCHAR;
2432    
2433        case OP_NOTPOSSTAR:
2434        possessive = TRUE;
2435        min = 0;
2436        max = INT_MAX;
2437        ecode++;
2438        goto REPEATNOTCHAR;
2439    
2440        case OP_NOTPOSPLUS:
2441        possessive = TRUE;
2442        min = 1;
2443        max = INT_MAX;
2444        ecode++;
2445        goto REPEATNOTCHAR;
2446    
2447        case OP_NOTPOSQUERY:
2448        possessive = TRUE;
2449        min = 0;
2450        max = 1;
2451        ecode++;
2452        goto REPEATNOTCHAR;
2453    
2454        case OP_NOTPOSUPTO:
2455        possessive = TRUE;
2456        min = 0;
2457        max = GET2(ecode, 1);
2458        ecode += 3;
2459        goto REPEATNOTCHAR;
2460    
2461      case OP_NOTSTAR:      case OP_NOTSTAR:
2462      case OP_NOTMINSTAR:      case OP_NOTMINSTAR:
2463      case OP_NOTPLUS:      case OP_NOTPLUS:
# Line 2245  for (;;) Line 2497  for (;;)
2497        /* UTF-8 mode */        /* UTF-8 mode */
2498        if (utf8)        if (utf8)
2499          {          {
2500          register int d;          register unsigned int d;
2501          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2502            {            {
2503            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
# Line 2270  for (;;) Line 2522  for (;;)
2522          /* UTF-8 mode */          /* UTF-8 mode */
2523          if (utf8)          if (utf8)
2524            {            {
2525            register int d;            register unsigned int d;
2526            for (fi = min;; fi++)            for (fi = min;; fi++)
2527              {              {
2528              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
2529              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2530              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2531              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
# Line 2287  for (;;) Line 2539  for (;;)
2539            {            {
2540            for (fi = min;; fi++)            for (fi = min;; fi++)
2541              {              {
2542              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
2543              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2544              if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])              if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
2545                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2306  for (;;) Line 2558  for (;;)
2558          /* UTF-8 mode */          /* UTF-8 mode */
2559          if (utf8)          if (utf8)
2560            {            {
2561            register int d;            register unsigned int d;
2562            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2563              {              {
2564              int len = 1;              int len = 1;
# Line 2316  for (;;) Line 2568  for (;;)
2568              if (fc == d) break;              if (fc == d) break;
2569              eptr += len;              eptr += len;
2570              }              }
2571            for(;;)          if (possessive) continue;
2572            for(;;)
2573              {              {
2574              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
2575              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2576              if (eptr-- == pp) break;        /* Stop if tried at original pos */              if (eptr-- == pp) break;        /* Stop if tried at original pos */
2577              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2333  for (;;) Line 2586  for (;;)
2586              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
2587              eptr++;              eptr++;
2588              }              }
2589              if (possessive) continue;
2590            while (eptr >= pp)            while (eptr >= pp)
2591              {              {
2592              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);
2593              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2594              eptr--;              eptr--;
2595              }              }
# Line 2354  for (;;) Line 2608  for (;;)
2608        /* UTF-8 mode */        /* UTF-8 mode */
2609        if (utf8)        if (utf8)
2610          {          {
2611          register int d;          register unsigned int d;
2612          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2613            {            {
2614            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
# Line 2377  for (;;) Line 2631  for (;;)
2631          /* UTF-8 mode */          /* UTF-8 mode */
2632          if (utf8)          if (utf8)
2633            {            {
2634            register int d;            register unsigned int d;
2635            for (fi = min;; fi++)            for (fi = min;; fi++)
2636              {              {
2637              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
2638              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2639              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2640              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fi >= max || eptr >= md->end_subject || fc == d)
# Line 2393  for (;;) Line 2647  for (;;)
2647            {            {
2648            for (fi = min;; fi++)            for (fi = min;; fi++)
2649              {              {
2650              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
2651              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2652              if (fi >= max || eptr >= md->end_subject || fc == *eptr++)              if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
2653                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2412  for (;;) Line 2666  for (;;)
2666          /* UTF-8 mode */          /* UTF-8 mode */
2667          if (utf8)          if (utf8)
2668            {            {
2669            register int d;            register unsigned int d;
2670            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2671              {              {
2672              int len = 1;              int len = 1;
# Line 2421  for (;;) Line 2675  for (;;)
2675              if (fc == d) break;              if (fc == d) break;
2676              eptr += len;              eptr += len;
2677              }              }
2678              if (possessive) continue;
2679            for(;;)            for(;;)
2680              {              {
2681              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
2682              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2683              if (eptr-- == pp) break;        /* Stop if tried at original pos */              if (eptr-- == pp) break;        /* Stop if tried at original pos */
2684              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2438  for (;;) Line 2693  for (;;)
2693              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject || fc == *eptr) break;
2694              eptr++;              eptr++;
2695              }              }
2696              if (possessive) continue;
2697            while (eptr >= pp)            while (eptr >= pp)
2698              {              {
2699              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);
2700              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2701              eptr--;              eptr--;
2702              }              }
# Line 2469  for (;;) Line 2725  for (;;)
2725      ecode += 3;      ecode += 3;
2726      goto REPEATTYPE;      goto REPEATTYPE;
2727    
2728        case OP_TYPEPOSSTAR:
2729        possessive = TRUE;
2730        min = 0;
2731        max = INT_MAX;
2732        ecode++;
2733        goto REPEATTYPE;
2734    
2735        case OP_TYPEPOSPLUS:
2736        possessive = TRUE;
2737        min = 1;
2738        max = INT_MAX;
2739        ecode++;
2740        goto REPEATTYPE;
2741    
2742        case OP_TYPEPOSQUERY:
2743        possessive = TRUE;
2744        min = 0;
2745        max = 1;
2746        ecode++;
2747        goto REPEATTYPE;
2748    
2749        case OP_TYPEPOSUPTO:
2750        possessive = TRUE;
2751        min = 0;
2752        max = GET2(ecode, 1);
2753        ecode += 3;
2754        goto REPEATTYPE;
2755    
2756      case OP_TYPESTAR:      case OP_TYPESTAR:
2757      case OP_TYPEMINSTAR:      case OP_TYPEMINSTAR:
2758      case OP_TYPEPLUS:      case OP_TYPEPLUS:
# Line 2519  for (;;) Line 2803  for (;;)
2803            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2804              {              {
2805              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2806              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2807              }              }
2808            break;            break;
2809    
# Line 2527  for (;;) Line 2811  for (;;)
2811            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2812              {              {
2813              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2814              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2815              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
2816              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
2817                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
# Line 2540  for (;;) Line 2824  for (;;)
2824            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2825              {              {
2826              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2827              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2828              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
2829              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
2830                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2551  for (;;) Line 2835  for (;;)
2835            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2836              {              {
2837              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2838              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2839              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
2840              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
2841                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2562  for (;;) Line 2846  for (;;)
2846            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2847              {              {
2848              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2849              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2850              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
2851              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
2852                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2571  for (;;) Line 2855  for (;;)
2855    
2856            default:            default:
2857            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
           break;  
2858            }            }
2859          }          }
2860    
# Line 2611  for (;;) Line 2894  for (;;)
2894          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2895            {            {
2896            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
2897                 ((ims & PCRE_DOTALL) == 0 &&                 ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
                  eptr <= md->end_subject - md->nllen &&  
                  IS_NEWLINE(eptr)))  
2898              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2899            eptr++;            eptr++;
2900            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 2624  for (;;) Line 2905  for (;;)
2905          eptr += min;          eptr += min;
2906          break;          break;
2907    
2908          case OP_NOT_DIGIT:          case OP_ANYNL:
2909          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2910            {            {
2911            if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2912            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2913            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            switch(c)
2914              RRETURN(MATCH_NOMATCH);              {
2915                default: RRETURN(MATCH_NOMATCH);
2916                case 0x000d:
2917                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2918                break;
2919                case 0x000a:
2920                case 0x000b:
2921                case 0x000c:
2922                case 0x0085:
2923                case 0x2028:
2924                case 0x2029:
2925                break;
2926                }
2927            }            }
2928          break;          break;
2929    
2930          case OP_DIGIT:          case OP_NOT_HSPACE:
2931          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2932            {            {
2933            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2934               *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            GETCHARINC(c, eptr);
2935              switch(c)
2936                {
2937                default: break;
2938                case 0x09:      /* HT */
2939                case 0x20:      /* SPACE */
2940                case 0xa0:      /* NBSP */
2941                case 0x1680:    /* OGHAM SPACE MARK */
2942                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
2943                case 0x2000:    /* EN QUAD */
2944                case 0x2001:    /* EM QUAD */
2945                case 0x2002:    /* EN SPACE */
2946                case 0x2003:    /* EM SPACE */
2947                case 0x2004:    /* THREE-PER-EM SPACE */
2948                case 0x2005:    /* FOUR-PER-EM SPACE */
2949                case 0x2006:    /* SIX-PER-EM SPACE */
2950                case 0x2007:    /* FIGURE SPACE */
2951                case 0x2008:    /* PUNCTUATION SPACE */
2952                case 0x2009:    /* THIN SPACE */
2953                case 0x200A:    /* HAIR SPACE */
2954                case 0x202f:    /* NARROW NO-BREAK SPACE */
2955                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2956                case 0x3000:    /* IDEOGRAPHIC SPACE */
2957              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2958            /* No need to skip more bytes - we know it's a 1-byte character */              }
2959            }            }
2960          break;          break;
2961    
2962          case OP_NOT_WHITESPACE:          case OP_HSPACE:
2963          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2964            {            {
2965            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2966               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))            GETCHARINC(c, eptr);
2967              RRETURN(MATCH_NOMATCH);            switch(c)
2968            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;              {
2969                default: RRETURN(MATCH_NOMATCH);
2970                case 0x09:      /* HT */
2971                case 0x20:      /* SPACE */
2972                case 0xa0:      /* NBSP */
2973                case 0x1680:    /* OGHAM SPACE MARK */
2974                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
2975                case 0x2000:    /* EN QUAD */
2976                case 0x2001:    /* EM QUAD */
2977                case 0x2002:    /* EN SPACE */
2978                case 0x2003:    /* EM SPACE */
2979                case 0x2004:    /* THREE-PER-EM SPACE */
2980                case 0x2005:    /* FOUR-PER-EM SPACE */
2981                case 0x2006:    /* SIX-PER-EM SPACE */
2982                case 0x2007:    /* FIGURE SPACE */
2983                case 0x2008:    /* PUNCTUATION SPACE */
2984                case 0x2009:    /* THIN SPACE */
2985                case 0x200A:    /* HAIR SPACE */
2986                case 0x202f:    /* NARROW NO-BREAK SPACE */
2987                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2988                case 0x3000:    /* IDEOGRAPHIC SPACE */
2989                break;
2990                }
2991            }            }
2992          break;          break;
2993    
2994          case OP_WHITESPACE:          case OP_NOT_VSPACE:
2995          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2996            {            {
2997            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2998               *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            GETCHARINC(c, eptr);
2999              switch(c)
3000                {
3001                default: break;
3002                case 0x0a:      /* LF */
3003                case 0x0b:      /* VT */
3004                case 0x0c:      /* FF */
3005                case 0x0d:      /* CR */
3006                case 0x85:      /* NEL */
3007                case 0x2028:    /* LINE SEPARATOR */
3008                case 0x2029:    /* PARAGRAPH SEPARATOR */
3009              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3010            /* No need to skip more bytes - we know it's a 1-byte character */              }
3011            }            }
3012          break;          break;
3013    
3014          case OP_NOT_WORDCHAR:          case OP_VSPACE:
3015          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3016            {            {
3017            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3018               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))            GETCHARINC(c, eptr);
3019              RRETURN(MATCH_NOMATCH);            switch(c)
3020            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;              {
3021                default: RRETURN(MATCH_NOMATCH);
3022                case 0x0a:      /* LF */
3023                case 0x0b:      /* VT */
3024                case 0x0c:      /* FF */
3025                case 0x0d:      /* CR */
3026                case 0x85:      /* NEL */
3027                case 0x2028:    /* LINE SEPARATOR */
3028                case 0x2029:    /* PARAGRAPH SEPARATOR */
3029                break;
3030                }
3031              }
3032            break;
3033    
3034            case OP_NOT_DIGIT:
3035            for (i = 1; i <= min; i++)
3036              {
3037              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3038              GETCHARINC(c, eptr);
3039              if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3040                RRETURN(MATCH_NOMATCH);
3041              }
3042            break;
3043    
3044            case OP_DIGIT:
3045            for (i = 1; i <= min; i++)
3046              {
3047              if (eptr >= md->end_subject ||
3048                 *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3049                RRETURN(MATCH_NOMATCH);
3050              /* No need to skip more bytes - we know it's a 1-byte character */
3051              }
3052            break;
3053    
3054            case OP_NOT_WHITESPACE:
3055            for (i = 1; i <= min; i++)
3056              {
3057              if (eptr >= md->end_subject ||
3058                 (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))
3059                RRETURN(MATCH_NOMATCH);
3060              while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3061              }
3062            break;
3063    
3064            case OP_WHITESPACE:
3065            for (i = 1; i <= min; i++)
3066              {
3067              if (eptr >= md->end_subject ||
3068                 *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3069                RRETURN(MATCH_NOMATCH);
3070              /* No need to skip more bytes - we know it's a 1-byte character */
3071              }
3072            break;
3073    
3074            case OP_NOT_WORDCHAR:
3075            for (i = 1; i <= min; i++)
3076              {
3077              if (eptr >= md->end_subject ||
3078                 (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))
3079                RRETURN(MATCH_NOMATCH);
3080              while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3081            }            }
3082          break;          break;
3083    
# Line 2692  for (;;) Line 3099  for (;;)
3099  #endif     /* SUPPORT_UTF8 */  #endif     /* SUPPORT_UTF8 */
3100    
3101        /* Code for the non-UTF-8 case for minimum matching of operators other        /* Code for the non-UTF-8 case for minimum matching of operators other
3102        than OP_PROP and OP_NOTPROP. */        than OP_PROP and OP_NOTPROP. We can assume that there are the minimum
3103          number of bytes present, as this was tested above. */
3104    
3105        switch(ctype)        switch(ctype)
3106          {          {
# Line 2701  for (;;) Line 3109  for (;;)
3109            {            {
3110            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3111              {              {
3112              if (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr))              if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
               RRETURN(MATCH_NOMATCH);  
3113              eptr++;              eptr++;
3114              }              }
3115            }            }
# Line 2713  for (;;) Line 3120  for (;;)
3120          eptr += min;          eptr += min;
3121          break;          break;
3122    
3123            /* Because of the CRLF case, we can't assume the minimum number of
3124            bytes are present in this case. */
3125    
3126            case OP_ANYNL:
3127            for (i = 1; i <= min; i++)
3128              {
3129              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3130              switch(*eptr++)
3131                {
3132                default: RRETURN(MATCH_NOMATCH);
3133                case 0x000d:
3134                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3135                break;
3136                case 0x000a:
3137                case 0x000b:
3138                case 0x000c:
3139                case 0x0085:
3140                break;
3141                }
3142              }
3143            break;
3144    
3145            case OP_NOT_HSPACE:
3146            for (i = 1; i <= min; i++)
3147              {
3148              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3149              switch(*eptr++)
3150                {
3151                default: break;
3152                case 0x09:      /* HT */
3153                case 0x20:      /* SPACE */
3154                case 0xa0:      /* NBSP */
3155                RRETURN(MATCH_NOMATCH);
3156                }
3157              }
3158            break;
3159    
3160            case OP_HSPACE:
3161            for (i = 1; i <= min; i++)
3162              {
3163              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3164              switch(*eptr++)
3165                {
3166                default: RRETURN(MATCH_NOMATCH);
3167                case 0x09:      /* HT */
3168                case 0x20:      /* SPACE */
3169                case 0xa0:      /* NBSP */
3170                break;
3171                }
3172              }
3173            break;
3174    
3175            case OP_NOT_VSPACE:
3176            for (i = 1; i <= min; i++)
3177              {
3178              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3179              switch(*eptr++)
3180                {
3181                default: break;
3182                case 0x0a:      /* LF */
3183                case 0x0b:      /* VT */
3184                case 0x0c:      /* FF */
3185                case 0x0d:      /* CR */
3186                case 0x85:      /* NEL */
3187                RRETURN(MATCH_NOMATCH);
3188                }
3189              }
3190            break;
3191    
3192            case OP_VSPACE:
3193            for (i = 1; i <= min; i++)
3194              {
3195              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3196              switch(*eptr++)
3197                {
3198                default: RRETURN(MATCH_NOMATCH);
3199                case 0x0a:      /* LF */
3200                case 0x0b:      /* VT */
3201                case 0x0c:      /* FF */
3202                case 0x0d:      /* CR */
3203                case 0x85:      /* NEL */
3204                break;
3205                }
3206              }
3207            break;
3208    
3209          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3210          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3211            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
# Line 2768  for (;;) Line 3261  for (;;)
3261            case PT_ANY:            case PT_ANY:
3262            for (fi = min;; fi++)            for (fi = min;; fi++)
3263              {              {
3264              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
3265              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3266              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3267              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3268              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3269              }              }
3270            break;            /* Control never gets here */
3271    
3272            case PT_LAMP:            case PT_LAMP:
3273            for (fi = min;; fi++)            for (fi = min;; fi++)
3274              {              {
3275              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
3276              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3277              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3278              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
# Line 2789  for (;;) Line 3282  for (;;)
3282                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3283                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3284              }              }
3285            break;            /* Control never gets here */
3286    
3287            case PT_GC:            case PT_GC:
3288            for (fi = min;; fi++)            for (fi = min;; fi++)
3289              {              {
3290              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
3291              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3292              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3293              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
# Line 2802  for (;;) Line 3295  for (;;)
3295              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3296                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3297              }              }
3298            break;            /* Control never gets here */
3299    
3300            case PT_PC:            case PT_PC:
3301            for (fi = min;; fi++)            for (fi = min;; fi++)
3302              {              {
3303              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
3304              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3305              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3306              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
# Line 2815  for (;;) Line 3308  for (;;)
3308              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3309                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3310              }              }
3311            break;            /* Control never gets here */
3312    
3313            case PT_SC:            case PT_SC:
3314            for (fi = min;; fi++)            for (fi = min;; fi++)
3315              {              {
3316              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
3317              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3318              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3319              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
# Line 2828  for (;;) Line 3321  for (;;)
3321              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3322                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3323              }              }
3324            break;            /* Control never gets here */
3325    
3326            default:            default:
3327            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
           break;  
3328            }            }
3329          }          }
3330    
# Line 2843  for (;;) Line 3335  for (;;)
3335          {          {
3336          for (fi = min;; fi++)          for (fi = min;; fi++)
3337            {            {
3338            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
3339            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3340            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3341            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
# Line 2872  for (;;) Line 3364  for (;;)
3364          {          {
3365          for (fi = min;; fi++)          for (fi = min;; fi++)
3366            {            {
3367            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
3368            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3369            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3370                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&
3371                  eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))                  IS_NEWLINE(eptr)))
3372              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3373    
3374            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
# Line 2888  for (;;) Line 3380  for (;;)
3380              case OP_ANYBYTE:              case OP_ANYBYTE:
3381              break;              break;
3382    
3383                case OP_ANYNL:
3384                switch(c)
3385                  {
3386                  default: RRETURN(MATCH_NOMATCH);
3387                  case 0x000d:
3388                  if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3389                  break;
3390                  case 0x000a:
3391                  case 0x000b:
3392                  case 0x000c:
3393                  case 0x0085:
3394                  case 0x2028:
3395                  case 0x2029:
3396                  break;
3397                  }
3398                break;
3399    
3400                case OP_NOT_HSPACE:
3401                switch(c)
3402                  {
3403                  default: break;
3404                  case 0x09:      /* HT */
3405                  case 0x20:      /* SPACE */
3406                  case 0xa0:      /* NBSP */
3407                  case 0x1680:    /* OGHAM SPACE MARK */
3408                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3409                  case 0x2000:    /* EN QUAD */
3410                  case 0x2001:    /* EM QUAD */
3411                  case 0x2002:    /* EN SPACE */
3412                  case 0x2003:    /* EM SPACE */
3413                  case 0x2004:    /* THREE-PER-EM SPACE */
3414                  case 0x2005:    /* FOUR-PER-EM SPACE */
3415                  case 0x2006:    /* SIX-PER-EM SPACE */
3416                  case 0x2007:    /* FIGURE SPACE */
3417                  case 0x2008:    /* PUNCTUATION SPACE */
3418                  case 0x2009:    /* THIN SPACE */
3419                  case 0x200A:    /* HAIR SPACE */
3420                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3421                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3422                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3423                  RRETURN(MATCH_NOMATCH);
3424                  }
3425                break;
3426    
3427                case OP_HSPACE:
3428                switch(c)
3429                  {
3430                  default: RRETURN(MATCH_NOMATCH);
3431                  case 0x09:      /* HT */
3432                  case 0x20:      /* SPACE */
3433                  case 0xa0:      /* NBSP */
3434                  case 0x1680:    /* OGHAM SPACE MARK */
3435                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3436                  case 0x2000:    /* EN QUAD */
3437                  case 0x2001:    /* EM QUAD */
3438                  case 0x2002:    /* EN SPACE */
3439                  case 0x2003:    /* EM SPACE */
3440                  case 0x2004:    /* THREE-PER-EM SPACE */
3441                  case 0x2005:    /* FOUR-PER-EM SPACE */
3442                  case 0x2006:    /* SIX-PER-EM SPACE */
3443                  case 0x2007:    /* FIGURE SPACE */
3444                  case 0x2008:    /* PUNCTUATION SPACE */
3445                  case 0x2009:    /* THIN SPACE */
3446                  case 0x200A:    /* HAIR SPACE */
3447                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3448                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3449                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3450                  break;
3451                  }
3452                break;
3453    
3454                case OP_NOT_VSPACE:
3455                switch(c)
3456                  {
3457                  default: break;
3458                  case 0x0a:      /* LF */
3459                  case 0x0b:      /* VT */
3460                  case 0x0c:      /* FF */
3461                  case 0x0d:      /* CR */
3462                  case 0x85:      /* NEL */
3463                  case 0x2028:    /* LINE SEPARATOR */
3464                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3465                  RRETURN(MATCH_NOMATCH);
3466                  }
3467                break;
3468    
3469                case OP_VSPACE:
3470                switch(c)
3471                  {
3472                  default: RRETURN(MATCH_NOMATCH);
3473                  case 0x0a:      /* LF */
3474                  case 0x0b:      /* VT */
3475                  case 0x0c:      /* FF */
3476                  case 0x0d:      /* CR */
3477                  case 0x85:      /* NEL */
3478                  case 0x2028:    /* LINE SEPARATOR */
3479                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3480                  break;
3481                  }
3482                break;
3483    
3484              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
3485              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
3486                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2929  for (;;) Line 3522  for (;;)
3522          {          {
3523          for (fi = min;; fi++)          for (fi = min;; fi++)
3524            {            {
3525            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
3526            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3527            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3528                 ((ims & PCRE_DOTALL) == 0 &&                 ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
                  eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))  
3529              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3530    
3531            c = *eptr++;            c = *eptr++;
# Line 2945  for (;;) Line 3537  for (;;)
3537              case OP_ANYBYTE:              case OP_ANYBYTE:
3538              break;              break;
3539    
3540                case OP_ANYNL:
3541                switch(c)
3542                  {
3543                  default: RRETURN(MATCH_NOMATCH);
3544                  case 0x000d:
3545                  if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3546                  break;
3547                  case 0x000a:
3548                  case 0x000b:
3549                  case 0x000c:
3550                  case 0x0085:
3551                  break;
3552                  }
3553                break;
3554    
3555                case OP_NOT_HSPACE:
3556                switch(c)
3557                  {
3558                  default: break;
3559                  case 0x09:      /* HT */
3560                  case 0x20:      /* SPACE */
3561                  case 0xa0:      /* NBSP */
3562                  RRETURN(MATCH_NOMATCH);
3563                  }
3564                break;
3565    
3566                case OP_HSPACE:
3567                switch(c)
3568                  {
3569                  default: RRETURN(MATCH_NOMATCH);
3570                  case 0x09:      /* HT */
3571                  case 0x20:      /* SPACE */
3572                  case 0xa0:      /* NBSP */
3573                  break;
3574                  }
3575                break;
3576    
3577                case OP_NOT_VSPACE:
3578                switch(c)
3579                  {
3580                  default: break;
3581                  case 0x0a:      /* LF */
3582                  case 0x0b:      /* VT */
3583                  case 0x0c:      /* FF */
3584                  case 0x0d:      /* CR */
3585                  case 0x85:      /* NEL */
3586                  RRETURN(MATCH_NOMATCH);
3587                  }
3588                break;
3589    
3590                case OP_VSPACE:
3591                switch(c)
3592                  {
3593                  default: RRETURN(MATCH_NOMATCH);
3594                  case 0x0a:      /* LF */
3595                  case 0x0b:      /* VT */
3596                  case 0x0c:      /* FF */
3597                  case 0x0d:      /* CR */
3598                  case 0x85:      /* NEL */
3599                  break;
3600                  }
3601                break;
3602    
3603              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
3604              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
3605              break;              break;
# Line 2977  for (;;) Line 3632  for (;;)
3632        /* Control never gets here */        /* Control never gets here */
3633        }        }
3634    
3635      /* If maximizing it is worth using inline code for speed, doing the type      /* If maximizing, it is worth using inline code for speed, doing the type
3636      test once at the start (i.e. keep it out of the loop). Again, keep the      test once at the start (i.e. keep it out of the loop). Again, keep the
3637      UTF-8 and UCP stuff separate. */      UTF-8 and UCP stuff separate. */
3638    
# Line 3058  for (;;) Line 3713  for (;;)
3713    
3714          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
3715    
3716            if (possessive) continue;
3717          for(;;)          for(;;)
3718            {            {
3719            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
3720            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3721            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3722            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3723            }            }
3724          }          }
3725    
# Line 3093  for (;;) Line 3749  for (;;)
3749    
3750          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
3751    
3752            if (possessive) continue;
3753          for(;;)          for(;;)
3754            {            {
3755            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
3756            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3757            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3758            for (;;)                        /* Move back over one extended */            for (;;)                        /* Move back over one extended */
3759              {              {
3760              int len = 1;              int len = 1;
             BACKCHAR(eptr);  
3761              if (!utf8) c = *eptr; else              if (!utf8) c = *eptr; else
3762                {                {
3763                  BACKCHAR(eptr);
3764                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3765                }                }
3766              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
# Line 3124  for (;;) Line 3781  for (;;)
3781          switch(ctype)          switch(ctype)
3782            {            {
3783            case OP_ANY:            case OP_ANY:
   
           /* Special code is required for UTF8, but when the maximum is  
           unlimited we don't need it, so we repeat the non-UTF8 code. This is  
           probably worth it, because .* is quite a common idiom. */  
   
3784            if (max < INT_MAX)            if (max < INT_MAX)
3785              {              {
3786              if ((ims & PCRE_DOTALL) == 0)              if ((ims & PCRE_DOTALL) == 0)
3787                {                {
3788                for (i = min; i < max; i++)                for (i = min; i < max; i++)
3789                  {                  {
3790                  if (eptr >= md->end_subject ||                  if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
                     (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))  
                   break;  
3791                  eptr++;                  eptr++;
3792                  while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                  while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3793                  }                  }
# Line 3161  for (;;) Line 3811  for (;;)
3811                {                {
3812                for (i = min; i < max; i++)                for (i = min; i < max; i++)
3813                  {                  {
3814                  if (eptr >= md->end_subject ||                  if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
                     (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))  
                   break;  
3815                  eptr++;                  eptr++;
3816                    while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3817                  }                  }
               break;  
3818                }                }
3819              else              else
3820                {                {
3821                c = max - min;                eptr = md->end_subject;
               if (c > md->end_subject - eptr) c = md->end_subject - eptr;  
               eptr += c;  
3822                }                }
3823              }              }
3824            break;            break;
# Line 3181  for (;;) Line 3827  for (;;)
3827    
3828            case OP_ANYBYTE:            case OP_ANYBYTE:
3829            c = max - min;            c = max - min;
3830            if (c > md->end_subject - eptr) c = md->end_subject - eptr;            if (c > (unsigned int)(md->end_subject - eptr))
3831                c = md->end_subject - eptr;
3832            eptr += c;            eptr += c;
3833            break;            break;
3834    
3835              case OP_ANYNL:
3836              for (i = min; i < max; i++)
3837                {
3838                int len = 1;
3839                if (eptr >= md->end_subject) break;
3840                GETCHARLEN(c, eptr, len);
3841                if (c == 0x000d)
3842                  {
3843                  if (++eptr >= md->end_subject) break;
3844                  if (*eptr == 0x000a) eptr++;
3845                  }
3846                else
3847                  {
3848                  if (c != 0x000a && c != 0x000b && c != 0x000c &&
3849                      c != 0x0085 && c != 0x2028 && c != 0x2029)
3850                    break;
3851                  eptr += len;
3852                  }
3853                }
3854              break;
3855    
3856              case OP_NOT_HSPACE:
3857              case OP_HSPACE:
3858              for (i = min; i < max; i++)
3859                {
3860                BOOL gotspace;
3861                int len = 1;
3862                if (eptr >= md->end_subject) break;
3863                GETCHARLEN(c, eptr, len);
3864                switch(c)
3865                  {
3866                  default: gotspace = FALSE; break;
3867                  case 0x09:      /* HT */
3868                  case 0x20:      /* SPACE */
3869                  case 0xa0:      /* NBSP */
3870                  case 0x1680:    /* OGHAM SPACE MARK */
3871                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3872                  case 0x2000:    /* EN QUAD */
3873                  case 0x2001:    /* EM QUAD */
3874                  case 0x2002:    /* EN SPACE */
3875                  case 0x2003:    /* EM SPACE */
3876                  case 0x2004:    /* THREE-PER-EM SPACE */
3877                  case 0x2005:    /* FOUR-PER-EM SPACE */
3878                  case 0x2006:    /* SIX-PER-EM SPACE */
3879                  case 0x2007:    /* FIGURE SPACE */
3880                  case 0x2008:    /* PUNCTUATION SPACE */
3881                  case 0x2009:    /* THIN SPACE */
3882                  case 0x200A:    /* HAIR SPACE */
3883                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3884                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3885                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3886                  gotspace = TRUE;
3887                  break;
3888                  }
3889                if (gotspace == (ctype == OP_NOT_HSPACE)) break;
3890                eptr += len;
3891                }
3892              break;
3893    
3894              case OP_NOT_VSPACE:
3895              case OP_VSPACE:
3896              for (i = min; i < max; i++)
3897                {
3898                BOOL gotspace;
3899                int len = 1;
3900                if (eptr >= md->end_subject) break;
3901                GETCHARLEN(c, eptr, len);
3902                switch(c)
3903                  {
3904                  default: gotspace = FALSE; break;
3905                  case 0x0a:      /* LF */
3906                  case 0x0b:      /* VT */
3907                  case 0x0c:      /* FF */
3908                  case 0x0d:      /* CR */
3909                  case 0x85:      /* NEL */
3910                  case 0x2028:    /* LINE SEPARATOR */
3911                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3912                  gotspace = TRUE;
3913                  break;
3914                  }
3915                if (gotspace == (ctype == OP_NOT_VSPACE)) break;
3916                eptr += len;
3917                }
3918              break;
3919    
3920            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
3921            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3922              {              {
# Line 3257  for (;;) Line 3989  for (;;)
3989    
3990          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
3991    
3992            if (possessive) continue;
3993          for(;;)          for(;;)
3994            {            {
3995            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM46);
3996            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3997            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3998            BACKCHAR(eptr);            BACKCHAR(eptr);
3999            }            }
4000          }          }
4001        else        else
4002  #endif  #endif  /* SUPPORT_UTF8 */
4003    
4004        /* Not UTF-8 mode */        /* Not UTF-8 mode */
4005          {          {
# Line 3277  for (;;) Line 4010  for (;;)
4010              {              {
4011              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4012                {                {
4013                if (eptr >= md->end_subject ||                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
                   (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))  
                 break;  
4014                eptr++;                eptr++;
4015                }                }
4016              break;              break;
# Line 3288  for (;;) Line 4019  for (;;)
4019    
4020            case OP_ANYBYTE:            case OP_ANYBYTE:
4021            c = max - min;            c = max - min;
4022            if (c > md->end_subject - eptr) c = md->end_subject - eptr;            if (c > (unsigned int)(md->end_subject - eptr))
4023                c = md->end_subject - eptr;
4024            eptr += c;            eptr += c;
4025            break;            break;
4026    
4027              case OP_ANYNL:
4028              for (i = min; i < max; i++)
4029                {
4030                if (eptr >= md->end_subject) break;
4031                c = *eptr;
4032                if (c == 0x000d)
4033                  {
4034                  if (++eptr >= md->end_subject) break;
4035                  if (*eptr == 0x000a) eptr++;
4036                  }
4037                else
4038                  {
4039                  if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)
4040                    break;
4041                  eptr++;
4042                  }
4043                }
4044              break;
4045    
4046              case OP_NOT_HSPACE:
4047              for (i = min; i < max; i++)
4048                {
4049                if (eptr >= md->end_subject) break;
4050                c = *eptr;
4051                if (c == 0x09 || c == 0x20 || c == 0xa0) break;
4052                eptr++;
4053                }
4054              break;
4055    
4056              case OP_HSPACE:
4057              for (i = min; i < max; i++)
4058                {
4059                if (eptr >= md->end_subject) break;
4060                c = *eptr;
4061                if (c != 0x09 && c != 0x20 && c != 0xa0) break;
4062                eptr++;
4063                }
4064              break;
4065    
4066              case OP_NOT_VSPACE:
4067              for (i = min; i < max; i++)
4068                {
4069                if (eptr >= md->end_subject) break;
4070                c = *eptr;
4071                if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
4072                  break;
4073                eptr++;
4074                }
4075              break;
4076    
4077              case OP_VSPACE:
4078              for (i = min; i < max; i++)
4079                {
4080                if (eptr >= md->end_subject) break;
4081                c = *eptr;
4082                if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
4083                  break;
4084                eptr++;
4085                }
4086              break;
4087    
4088            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4089            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4090              {              {
# Line 3352  for (;;) Line 4145  for (;;)
4145    
4146          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4147    
4148            if (possessive) continue;
4149          while (eptr >= pp)          while (eptr >= pp)
4150            {            {
4151            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM47);
4152            eptr--;            eptr--;
4153            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4154            }            }
# Line 3366  for (;;) Line 4160  for (;;)
4160        }        }
4161      /* Control never gets here */      /* Control never gets here */
4162    
4163      /* There's been some horrible disaster. Since all codes > OP_BRA are      /* There's been some horrible disaster. Arrival here can only mean there is
4164      for capturing brackets, and there shouldn't be any gaps between 0 and      something seriously wrong in the code above or the OP_xxx definitions. */
     OP_BRA, arrival here can only mean there is something seriously wrong  
     in the code above or the OP_xxx definitions. */  
4165    
4166      default:      default:
4167      DPRINTF(("Unknown opcode %d\n", *ecode));      DPRINTF(("Unknown opcode %d\n", *ecode));
4168      RRETURN(PCRE_ERROR_UNKNOWN_NODE);      RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
4169      }      }
4170    
4171    /* Do not stick any code in here without much thought; it is assumed    /* Do not stick any code in here without much thought; it is assumed
# Line 3382  for (;;) Line 4174  for (;;)
4174    
4175    }             /* End of main loop */    }             /* End of main loop */
4176  /* Control never reaches here */  /* Control never reaches here */
4177    
4178    
4179    /* When compiling to use the heap rather than the stack for recursive calls to
4180    match(), the RRETURN() macro jumps here. The number that is saved in
4181    frame->Xwhere indicates which label we actually want to return to. */
4182    
4183    #ifdef NO_RECURSE
4184    #define LBL(val) case val: goto L_RM##val;
4185    HEAP_RETURN:
4186    switch (frame->Xwhere)
4187      {
4188      LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
4189      LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16)
4190      LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24)
4191      LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32)
4192      LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39) LBL(40)
4193      LBL(41) LBL(42) LBL(43) LBL(44) LBL(45) LBL(46) LBL(47)
4194      default:
4195      DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
4196      return PCRE_ERROR_INTERNAL;
4197      }
4198    #undef LBL
4199    #endif  /* NO_RECURSE */
4200  }  }
4201    
4202    
# Line 3394  Undefine all the macros that were define Line 4209  Undefine all the macros that were define
4209  #ifdef NO_RECURSE  #ifdef NO_RECURSE
4210  #undef eptr  #undef eptr
4211  #undef ecode  #undef ecode
4212    #undef mstart
4213  #undef offset_top  #undef offset_top
4214  #undef ims  #undef ims
4215  #undef eptrb  #undef eptrb
# Line 3411  Undefine all the macros that were define Line 4227  Undefine all the macros that were define
4227    
4228  #undef cur_is_word  #undef cur_is_word
4229  #undef condition  #undef condition
 #undef minimize  
4230  #undef prev_is_word  #undef prev_is_word
4231    
4232  #undef original_ims  #undef original_ims
# Line 3467  Returns:          > 0 => success; value Line 4282  Returns:          > 0 => success; value
4282                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
4283  */  */
4284    
4285  PCRE_DATA_SCOPE int  PCRE_EXP_DEFN int
4286  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
4287    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
4288    int offsetcount)    int offsetcount)
# Line 3484  BOOL startline; Line 4299  BOOL startline;
4299  BOOL firstline;  BOOL firstline;
4300  BOOL first_byte_caseless = FALSE;  BOOL first_byte_caseless = FALSE;
4301  BOOL req_byte_caseless = FALSE;  BOOL req_byte_caseless = FALSE;
4302    BOOL utf8;
4303  match_data match_block;  match_data match_block;
4304  match_data *md = &match_block;  match_data *md = &match_block;
4305  const uschar *tables;  const uschar *tables;
# Line 3567  md->end_subject = md->start_subject + le Line 4383  md->end_subject = md->start_subject + le
4383  end_subject = md->end_subject;  end_subject = md->end_subject;
4384    
4385  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
4386  md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
4387    
4388  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
4389  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
# Line 3580  md->recursive = NULL; Line 4396  md->recursive = NULL;
4396  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
4397  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
4398    
4399  /* Handle different types of newline. The two bits give four cases. If nothing  /* Handle different types of newline. The three bits give eight cases. If
4400  is set at run time, whatever was used at compile time applies. */  nothing is set at run time, whatever was used at compile time applies. */
4401    
4402  switch ((((options & PCRE_NEWLINE_CRLF) == 0)? re->options : options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
4403           PCRE_NEWLINE_CRLF)         PCRE_NEWLINE_BITS)
4404    {    {
4405    default:              newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
4406    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = '\r'; break;
4407    case PCRE_NEWLINE_LF: newline = '\n'; break;    case PCRE_NEWLINE_LF: newline = '\n'; break;
4408    case PCRE_NEWLINE_CR+    case PCRE_NEWLINE_CR+
4409         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
4410      case PCRE_NEWLINE_ANY: newline = -1; break;
4411      case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
4412      default: return PCRE_ERROR_BADNEWLINE;
4413    }    }
4414    
4415  if (newline > 255)  if (newline == -2)
4416    {    {
4417    md->nllen = 2;    md->nltype = NLTYPE_ANYCRLF;
4418    md->nl[0] = (newline >> 8) & 255;    }
4419    md->nl[1] = newline & 255;  else if (newline < 0)
4420      {
4421      md->nltype = NLTYPE_ANY;
4422    }    }
4423  else  else
4424    {    {
4425    md->nllen = 1;    md->nltype = NLTYPE_FIXED;
4426    md->nl[0] = newline;    if (newline > 255)
4427        {
4428        md->nllen = 2;
4429        md->nl[0] = (newline >> 8) & 255;
4430        md->nl[1] = newline & 255;
4431        }
4432      else
4433        {
4434        md->nllen = 1;
4435        md->nl[0] = newline;
4436        }
4437    }    }
4438    
4439  /* Partial matching is supported only for a restricted set of regexes at the  /* Partial matching is supported only for a restricted set of regexes at the
# Line 3615  if (md->partial && (re->options & PCRE_N Line 4446  if (md->partial && (re->options & PCRE_N
4446  back the character offset. */  back the character offset. */
4447    
4448  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
4449  if (md->utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
4450    {    {
4451    if (_pcre_valid_utf8((uschar *)subject, length) >= 0)    if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
4452      return PCRE_ERROR_BADUTF8;      return PCRE_ERROR_BADUTF8;
# Line 3707  if ((re->options & PCRE_REQCHSET) != 0) Line 4538  if ((re->options & PCRE_REQCHSET) != 0)
4538    req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */    req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */
4539    }    }
4540    
4541    
4542    /* ==========================================================================*/
4543    
4544  /* Loop for handling unanchored repeated matching attempts; for anchored regexs  /* Loop for handling unanchored repeated matching attempts; for anchored regexs
4545  the loop runs just once. */  the loop runs just once. */
4546    
4547  do  for(;;)
4548    {    {
4549    USPTR save_end_subject = end_subject;    USPTR save_end_subject = end_subject;
4550    
# Line 3725  do Line 4559  do
4559    
4560    /* Advance to a unique first char if possible. If firstline is TRUE, the    /* Advance to a unique first char if possible. If firstline is TRUE, the
4561    start of the match is constrained to the first line of a multiline string.    start of the match is constrained to the first line of a multiline string.
4562    Implement this by temporarily adjusting end_subject so that we stop scanning    That is, the match must be before or at the first newline. Implement this by
4563    at a newline. If the match fails at the newline, later code breaks this loop.    temporarily adjusting end_subject so that we stop scanning at a newline. If
4564    */    the match fails at the newline, later code breaks this loop. */
4565    
4566    if (firstline)    if (firstline)
4567      {      {
4568      USPTR t = start_match;      USPTR t = start_match;
4569      while (t <= save_end_subject - md->nllen && !IS_NEWLINE(t)) t++;      while (t < md->end_subject && !IS_NEWLINE(t)) t++;
4570      end_subject = t;      end_subject = t;
4571      }      }
4572    
# Line 3753  do Line 4587  do
4587    
4588    else if (startline)    else if (startline)
4589      {      {
4590      if (start_match >= md->start_subject + md->nllen +      if (start_match > md->start_subject + start_offset)
           start_offset)  
4591        {        {
4592        while (start_match <= end_subject &&        while (start_match <= end_subject && !WAS_NEWLINE(start_match))
4593               !IS_NEWLINE(start_match - md->nllen))          start_match++;
4594    
4595          /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
4596          and we are now at a LF, advance the match position by one more character.
4597          */
4598    
4599          if (start_match[-1] == '\r' &&
4600               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
4601               start_match < end_subject &&
4602               *start_match == '\n')
4603          start_match++;          start_match++;
4604        }        }
4605      }      }
# Line 3793  do Line 4635  do
4635    
4636    HOWEVER: when the subject string is very, very long, searching to its end can    HOWEVER: when the subject string is very, very long, searching to its end can
4637    take a long time, and give bad performance on quite ordinary patterns. This    take a long time, and give bad performance on quite ordinary patterns. This
4638    showed up when somebody was matching /^C/ on a 32-megabyte string... so we    showed up when somebody was matching something like /^\d+C/ on a 32-megabyte
4639    don't do this when the string is sufficiently long.    string... so we don't do this when the string is sufficiently long.
4640    
4641    ALSO: this processing is disabled when partial matching is requested.    ALSO: this processing is disabled when partial matching is requested.
4642    */    */
# Line 3826  do Line 4668  do
4668            }            }
4669          }          }
4670    
4671        /* If we can't find the required character, break the matching loop */        /* If we can't find the required character, break the matching loop,
4672          forcing a match failure. */
4673    
4674        if (p >= end_subject) break;        if (p >= end_subject)
4675            {
4676            rc = MATCH_NOMATCH;
4677            break;
4678            }
4679    
4680        /* If we have found the required character, save the point where we        /* If we have found the required character, save the point where we
4681        found it, so that we don't search again next time round the loop if        found it, so that we don't search again next time round the loop if
# Line 3838  do Line 4685  do
4685        }        }
4686      }      }
4687    
4688    /* When a match occurs, substrings will be set for all internal extractions;    /* OK, we can now run the match. */
   we just need to set up the whole thing as substring 0 before returning. If  
   there were too many extractions, set the return code to zero. In the case  
   where we had to get some local store to hold offsets for backreferences, copy  
   those back references that we can. In this case there need not be overflow  
   if certain parts of the pattern were not used. */  
4689    
4690    md->start_match = start_match;    md->start_match_ptr = start_match;      /* Insurance */
4691    md->match_call_count = 0;    md->match_call_count = 0;
4692      rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);
4693    
4694    rc = match(start_match, md->start_code, 2, md, ims, NULL, match_isgroup, 0);    /* Any return other than MATCH_NOMATCH breaks the loop. */
4695    
4696    /* When the result is no match, if the subject's first character was a    if (rc != MATCH_NOMATCH) break;
   newline and the PCRE_FIRSTLINE option is set, break (which will return  
   PCRE_ERROR_NOMATCH). The option requests that a match occur before the first  
   newline in the subject. Otherwise, advance the pointer to the next character  
   and continue - but the continuation will actually happen only when the  
   pattern is not anchored. */  
4697    
4698    if (rc == MATCH_NOMATCH)    /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
4699      {    newline in the subject (though it may continue over the newline). Therefore,
4700      if (firstline &&    if we have just failed to match, starting at a newline, do not continue. */
4701          start_match <= md->end_subject - md->nllen &&  
4702          IS_NEWLINE(start_match))    if (firstline && IS_NEWLINE(start_match)) break;
4703        break;  
4704      start_match++;    /* Advance the match position by one character. */
4705    
4706      start_match++;
4707  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
4708      if (md->utf8)    if (utf8)
4709        while(start_match < end_subject && (*start_match & 0xc0) == 0x80)      while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
4710          start_match++;        start_match++;
4711  #endif  #endif
4712      continue;  
4713      }    /* Break the loop if the pattern is anchored or if we have passed the end of
4714      the subject. */
4715    
4716      if (anchored || start_match > end_subject) break;
4717    
4718      /* If we have just passed a CR and the newline option is CRLF or ANY or
4719      ANYCRLF, and we are now at a LF, advance the match position by one more
4720      character. */
4721    
4722      if (start_match[-1] == '\r' &&
4723           (md->nltype == NLTYPE_ANY ||
4724            md->nltype == NLTYPE_ANYCRLF ||
4725            md->nllen == 2) &&
4726           start_match < end_subject &&
4727           *start_match == '\n')
4728        start_match++;
4729    
4730    if (rc != MATCH_MATCH)    }   /* End of for(;;) "bumpalong" loop */
4731      {  
4732      DPRINTF((">>>> error: returning %d\n", rc));  /* ==========================================================================*/
4733      return rc;  
4734      }  /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
4735    conditions is true:
4736    
4737    (1) The pattern is anchored;
4738    
4739    (2) We are past the end of the subject;
4740    
4741    /* We have a match! Copy the offset information from temporary store if  (3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
4742    necessary */      this option requests that a match occur at or before the first newline in
4743        the subject.
4744    
4745    When we have a match and the offset vector is big enough to deal with any
4746    backreferences, captured substring offsets will already be set up. In the case
4747    where we had to get some local store to hold offsets for backreference
4748    processing, copy those that we can. In this case there need not be overflow if
4749    certain parts of the pattern were not used, even though there are more
4750    capturing parentheses than vector slots. */
4751    
4752    if (rc == MATCH_MATCH)
4753      {
4754    if (using_temporary_offsets)    if (using_temporary_offsets)
4755      {      {
4756      if (offsetcount >= 4)      if (offsetcount >= 4)
# Line 3889  do Line 4759  do
4759          (offsetcount - 2) * sizeof(int));          (offsetcount - 2) * sizeof(int));
4760        DPRINTF(("Copied offsets from temporary memory\n"));        DPRINTF(("Copied offsets from temporary memory\n"));
4761        }        }
4762      if (md->end_offset_top > offsetcount)      if (md->end_offset_top > offsetcount) md->offset_overflow = TRUE;
       md->offset_overflow = TRUE;  
   
4763      DPRINTF(("Freeing temporary memory\n"));      DPRINTF(("Freeing temporary memory\n"));
4764      (pcre_free)(md->offset_vector);      (pcre_free)(md->offset_vector);
4765      }      }
4766    
4767      /* Set the return code to the number of captured strings, or 0 if there are
4768      too many to fit into the vector. */
4769    
4770    rc = md->offset_overflow? 0 : md->end_offset_top/2;    rc = md->offset_overflow? 0 : md->end_offset_top/2;
4771    
4772      /* If there is space, set up the whole thing as substring 0. The value of
4773      md->start_match_ptr might be modified if \K was encountered on the success
4774      matching path. */
4775    
4776    if (offsetcount < 2) rc = 0; else    if (offsetcount < 2) rc = 0; else
4777      {      {
4778      offsets[0] = start_match - md->start_subject;      offsets[0] = md->start_match_ptr - md->start_subject;
4779      offsets[1] = md->end_match_ptr - md->start_subject;      offsets[1] = md->end_match_ptr - md->start_subject;
4780      }      }
4781    
# Line 3908  do Line 4783  do
4783    return rc;    return rc;
4784    }    }
4785    
4786  /* This "while" is the end of the "do" above */  /* Control gets here if there has been an error, or if the overall match
4787    attempt has failed at all permitted starting positions. */
 while (!anchored && start_match <= end_subject);  
4788    
4789  if (using_temporary_offsets)  if (using_temporary_offsets)
4790    {    {
# Line 3918  if (using_temporary_offsets) Line 4792  if (using_temporary_offsets)
4792    (pcre_free)(md->offset_vector);    (pcre_free)(md->offset_vector);
4793    }    }
4794    
4795  if (md->partial && md->hitend)  if (rc != MATCH_NOMATCH)
4796      {
4797      DPRINTF((">>>> error: returning %d\n", rc));
4798      return rc;
4799      }
4800    else if (md->partial && md->hitend)
4801    {    {
4802    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
4803    return PCRE_ERROR_PARTIAL;    return PCRE_ERROR_PARTIAL;

Legend:
Removed from v.91  
changed lines
  Added in v.208

  ViewVC Help
Powered by ViewVC 1.1.5