/[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 77 by nigel, Sat Feb 24 21:40:45 2007 UTC revision 399 by ph10, Sat Mar 21 12:34:15 2009 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-2005 University of Cambridge             Copyright (c) 1997-2009 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    #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;  
   const uschar *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 68  defined PCRE_ERROR_xxx codes, which are Line 68  defined PCRE_ERROR_xxx codes, which are
68  #define MATCH_MATCH        1  #define MATCH_MATCH        1
69  #define MATCH_NOMATCH      0  #define MATCH_NOMATCH      0
70    
71    /* Special internal returns from the match() function. Make them sufficiently
72    negative to avoid the external error codes. */
73    
74    #define MATCH_COMMIT       (-999)
75    #define MATCH_PRUNE        (-998)
76    #define MATCH_SKIP         (-997)
77    #define MATCH_THEN         (-996)
78    
79  /* Maximum number of ints of offset to save on the stack for recursive calls.  /* Maximum number of ints of offset to save on the stack for recursive calls.
80  If the offset vector is bigger, malloc is used. This should be a multiple of 3,  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
81  because the offset vector is always a multiple of 3 long. */  because the offset vector is always a multiple of 3 long. */
# Line 101  Returns:     nothing Line 109  Returns:     nothing
109  static void  static void
110  pchars(const uschar *p, int length, BOOL is_subject, match_data *md)  pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
111  {  {
112  int c;  unsigned int c;
113  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;
114  while (length-- > 0)  while (length-- > 0)
115    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 128  Returns:      TRUE if matched Line 136  Returns:      TRUE if matched
136  */  */
137    
138  static BOOL  static BOOL
139  match_ref(int offset, register const uschar *eptr, int length, match_data *md,  match_ref(int offset, register USPTR eptr, int length, match_data *md,
140    unsigned long int ims)    unsigned long int ims)
141  {  {
142  const uschar *p = md->start_subject + md->offset_vector[offset];  USPTR p = md->start_subject + md->offset_vector[offset];
143    
144  #ifdef DEBUG  #ifdef DEBUG
145  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
# Line 150  printf("\n"); Line 158  printf("\n");
158    
159  if (length > md->end_subject - eptr) return FALSE;  if (length > md->end_subject - eptr) return FALSE;
160    
161  /* Separate the caselesss case for speed */  /* Separate the caseless case for speed. In UTF-8 mode we can only do this
162    properly if Unicode properties are supported. Otherwise, we can check only
163    ASCII characters. */
164    
165  if ((ims & PCRE_CASELESS) != 0)  if ((ims & PCRE_CASELESS) != 0)
166    {    {
167    #ifdef SUPPORT_UTF8
168    #ifdef SUPPORT_UCP
169      if (md->utf8)
170        {
171        USPTR endptr = eptr + length;
172        while (eptr < endptr)
173          {
174          int c, d;
175          GETCHARINC(c, eptr);
176          GETCHARINC(d, p);
177          if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
178          }
179        }
180      else
181    #endif
182    #endif
183    
184      /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
185      is no UCP support. */
186    
187    while (length-- > 0)    while (length-- > 0)
188      if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;      { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
189    }    }
190    
191    /* In the caseful case, we can just compare the bytes, whether or not we
192    are in UTF-8 mode. */
193    
194  else  else
195    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
196    
# Line 169  return TRUE; Line 203  return TRUE;
203  ****************************************************************************  ****************************************************************************
204                     RECURSION IN THE match() FUNCTION                     RECURSION IN THE match() FUNCTION
205    
206  The match() function is highly recursive. Some regular expressions can cause  The match() function is highly recursive, though not every recursive call
207  it to recurse thousands of times. I was writing for Unix, so I just let it  increases the recursive depth. Nevertheless, some regular expressions can cause
208  call itself recursively. This uses the stack for saving everything that has  it to recurse to a great depth. I was writing for Unix, so I just let it call
209  to be saved for a recursive call. On Unix, the stack can be large, and this  itself recursively. This uses the stack for saving everything that has to be
210  works fine.  saved for a recursive call. On Unix, the stack can be large, and this works
211    fine.
212  It turns out that on non-Unix systems there are problems with programs that  
213  use a lot of stack. (This despite the fact that every last chip has oodles  It turns out that on some non-Unix-like systems there are problems with
214  of memory these days, and techniques for extending the stack have been known  programs that use a lot of stack. (This despite the fact that every last chip
215  for decades.) So....  has oodles of memory these days, and techniques for extending the stack have
216    been known for decades.) So....
217    
218  There is a fudge, triggered by defining NO_RECURSE, which avoids recursive  There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
219  calls by keeping local variables that need to be preserved in blocks of memory  calls by keeping local variables that need to be preserved in blocks of memory
220  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
221  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
222  always used to.  always used to.
223    
224    The original heap-recursive code used longjmp(). However, it seems that this
225    can be very slow on some operating systems. Following a suggestion from Stan
226    Switzer, the use of longjmp() has been abolished, at the cost of having to
227    provide a unique number for each call to RMATCH. There is no way of generating
228    a sequence of numbers at compile time in C. I have given them names, to make
229    them stand out more clearly.
230    
231    Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
232    FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
233    tests. Furthermore, not using longjmp() means that local dynamic variables
234    don't have indeterminate values; this has meant that the frame size can be
235    reduced because the result can be "passed back" by straight setting of the
236    variable instead of being passed in the frame.
237  ****************************************************************************  ****************************************************************************
238  ***************************************************************************/  ***************************************************************************/
239    
240    /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
241    below must be updated in sync.  */
242    
243  /* These versions of the macros use the stack, as normal */  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
244           RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
245           RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
246           RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
247           RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
248           RM51,  RM52, RM53, RM54 };
249    
250    /* These versions of the macros use the stack, as normal. There are debugging
251    versions and production versions. Note that the "rw" argument of RMATCH isn't
252    actuall used in this definition. */
253    
254  #ifndef NO_RECURSE  #ifndef NO_RECURSE
255  #define REGISTER register  #define REGISTER register
256  #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) rx = match(ra,rb,rc,rd,re,rf,rg)  
257    #ifdef DEBUG
258    #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
259      { \
260      printf("match() called in line %d\n", __LINE__); \
261      rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \
262      printf("to line %d\n", __LINE__); \
263      }
264    #define RRETURN(ra) \
265      { \
266      printf("match() returned %d from line %d ", ra, __LINE__); \
267      return ra; \
268      }
269    #else
270    #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
271      rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)
272  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
273    #endif
274    
275  #else  #else
276    
277    
278  /* 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
279  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
280  match(), which never changes. */  argument of match(), which never changes. */
281    
282  #define REGISTER  #define REGISTER
283    
284  #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
285    {\    {\
286    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
287    if (setjmp(frame->Xwhere) == 0)\    frame->Xwhere = rw; \
288      {\    newframe->Xeptr = ra;\
289      newframe->Xeptr = ra;\    newframe->Xecode = rb;\
290      newframe->Xecode = rb;\    newframe->Xmstart = mstart;\
291      newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
292      newframe->Xims = re;\    newframe->Xims = re;\
293      newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
294      newframe->Xflags = rg;\    newframe->Xflags = rg;\
295      newframe->Xprevframe = frame;\    newframe->Xrdepth = frame->Xrdepth + 1;\
296      frame = newframe;\    newframe->Xprevframe = frame;\
297      DPRINTF(("restarting from line %d\n", __LINE__));\    frame = newframe;\
298      goto HEAP_RECURSE;\    DPRINTF(("restarting from line %d\n", __LINE__));\
299      }\    goto HEAP_RECURSE;\
300    else\    L_##rw:\
301      {\    DPRINTF(("jumped back to line %d\n", __LINE__));\
     DPRINTF(("longjumped back to line %d\n", __LINE__));\  
     frame = md->thisframe;\  
     rx = frame->Xresult;\  
     }\  
302    }    }
303    
304  #define RRETURN(ra)\  #define RRETURN(ra)\
# Line 235  match(), which never changes. */ Line 308  match(), which never changes. */
308    (pcre_stack_free)(newframe);\    (pcre_stack_free)(newframe);\
309    if (frame != NULL)\    if (frame != NULL)\
310      {\      {\
311      frame->Xresult = ra;\      rrc = ra;\
312      md->thisframe = frame;\      goto HEAP_RETURN;\
     longjmp(frame->Xwhere, 1);\  
313      }\      }\
314    return ra;\    return ra;\
315    }    }
# Line 252  typedef struct heapframe { Line 324  typedef struct heapframe {
324    
325    const uschar *Xeptr;    const uschar *Xeptr;
326    const uschar *Xecode;    const uschar *Xecode;
327      const uschar *Xmstart;
328    int Xoffset_top;    int Xoffset_top;
329    long int Xims;    long int Xims;
330    eptrblock *Xeptrb;    eptrblock *Xeptrb;
331    int Xflags;    int Xflags;
332      unsigned int Xrdepth;
333    
334    /* Function local variables */    /* Function local variables */
335    
# Line 271  typedef struct heapframe { Line 345  typedef struct heapframe {
345    
346    BOOL Xcur_is_word;    BOOL Xcur_is_word;
347    BOOL Xcondition;    BOOL Xcondition;
   BOOL Xminimize;  
348    BOOL Xprev_is_word;    BOOL Xprev_is_word;
349    
350    unsigned long int Xoriginal_ims;    unsigned long int Xoriginal_ims;
351    
352  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
353    int Xprop_type;    int Xprop_type;
354      int Xprop_value;
355    int Xprop_fail_result;    int Xprop_fail_result;
356    int Xprop_category;    int Xprop_category;
357    int Xprop_chartype;    int Xprop_chartype;
358    int Xprop_othercase;    int Xprop_script;
359    int Xprop_test_against;    int Xoclength;
360    int *Xprop_test_variable;    uschar Xocchars[8];
361  #endif  #endif
362    
363    int Xctype;    int Xctype;
364    int Xfc;    unsigned int Xfc;
365    int Xfi;    int Xfi;
366    int Xlength;    int Xlength;
367    int Xmax;    int Xmax;
# Line 301  typedef struct heapframe { Line 375  typedef struct heapframe {
375    
376    eptrblock Xnewptrb;    eptrblock Xnewptrb;
377    
378    /* Place to pass back result, and where to jump back to */    /* Where to jump back to */
379    
380    int  Xresult;    int Xwhere;
   jmp_buf Xwhere;  
381    
382  } heapframe;  } heapframe;
383    
# Line 320  typedef struct heapframe { Line 393  typedef struct heapframe {
393  *         Match from current position            *  *         Match from current position            *
394  *************************************************/  *************************************************/
395    
396  /* 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  
397  returns a negative (error) response, the outer incarnation must also return the  returns a negative (error) response, the outer incarnation must also return the
398  same response.  same response.
399    
# Line 333  performance. Tests using gcc on a SPARC Line 403  performance. Tests using gcc on a SPARC
403  made performance worse.  made performance worse.
404    
405  Arguments:  Arguments:
406     eptr        pointer in subject     eptr        pointer to current character in subject
407     ecode       position in code     ecode       pointer to current position in compiled code
408       mstart      pointer to the current match start position (can be modified
409                     by encountering \K)
410     offset_top  current top pointer     offset_top  current top pointer
411     md          pointer to "static" info for the match     md          pointer to "static" info for the match
412     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 342  Arguments: Line 414  Arguments:
414                   brackets - for testing for empty matches                   brackets - for testing for empty matches
415     flags       can contain     flags       can contain
416                   match_condassert - this is an assertion condition                   match_condassert - this is an assertion condition
417                   match_isgroup - this is the start of a bracketed group                   match_cbegroup - this is the start of an unlimited repeat
418                       group that can match an empty string
419       rdepth      the recursion depth
420    
421  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
422                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
423                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
424                   (e.g. stopped by recursion limit)                   (e.g. stopped by repeated call or recursion limit)
425  */  */
426    
427  static int  static int
428  match(REGISTER const uschar *eptr, REGISTER const uschar *ecode,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
429    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
430    int flags)    int flags, unsigned int rdepth)
431  {  {
432  /* 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,
433  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
434  because they are used a lot in loops. */  "register" because they are used a lot in loops. */
435    
436    register int  rrc;         /* Returns from recursive calls */
437    register int  i;           /* Used for loops not involving calls to RMATCH() */
438    register unsigned int c;   /* Character values not kept over RMATCH() calls */
439    register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
440    
441  register int  rrc;    /* Returns from recursive calls */  BOOL minimize, possessive; /* Quantifier options */
 register int  i;      /* Used for loops not involving calls to RMATCH() */  
 register int  c;      /* Character values not kept over RMATCH() calls */  
 register BOOL utf8;   /* Local copy of UTF-8 flag for speed */  
442    
443  /* 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
444  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
# Line 377  frame->Xprevframe = NULL;            /* Line 453  frame->Xprevframe = NULL;            /*
453    
454  frame->Xeptr = eptr;  frame->Xeptr = eptr;
455  frame->Xecode = ecode;  frame->Xecode = ecode;
456    frame->Xmstart = mstart;
457  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
458  frame->Xims = ims;  frame->Xims = ims;
459  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
460  frame->Xflags = flags;  frame->Xflags = flags;
461    frame->Xrdepth = rdepth;
462    
463  /* This is where control jumps back to to effect "recursion" */  /* This is where control jumps back to to effect "recursion" */
464    
# Line 390  HEAP_RECURSE: Line 468  HEAP_RECURSE:
468    
469  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
470  #define ecode              frame->Xecode  #define ecode              frame->Xecode
471    #define mstart             frame->Xmstart
472  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
473  #define ims                frame->Xims  #define ims                frame->Xims
474  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
475  #define flags              frame->Xflags  #define flags              frame->Xflags
476    #define rdepth             frame->Xrdepth
477    
478  /* Ditto for the local variables */  /* Ditto for the local variables */
479    
# Line 411  HEAP_RECURSE: Line 491  HEAP_RECURSE:
491    
492  #define cur_is_word        frame->Xcur_is_word  #define cur_is_word        frame->Xcur_is_word
493  #define condition          frame->Xcondition  #define condition          frame->Xcondition
 #define minimize           frame->Xminimize  
494  #define prev_is_word       frame->Xprev_is_word  #define prev_is_word       frame->Xprev_is_word
495    
496  #define original_ims       frame->Xoriginal_ims  #define original_ims       frame->Xoriginal_ims
497    
498  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
499  #define prop_type          frame->Xprop_type  #define prop_type          frame->Xprop_type
500    #define prop_value         frame->Xprop_value
501  #define prop_fail_result   frame->Xprop_fail_result  #define prop_fail_result   frame->Xprop_fail_result
502  #define prop_category      frame->Xprop_category  #define prop_category      frame->Xprop_category
503  #define prop_chartype      frame->Xprop_chartype  #define prop_chartype      frame->Xprop_chartype
504  #define prop_othercase     frame->Xprop_othercase  #define prop_script        frame->Xprop_script
505  #define prop_test_against  frame->Xprop_test_against  #define oclength           frame->Xoclength
506  #define prop_test_variable frame->Xprop_test_variable  #define occhars            frame->Xocchars
507  #endif  #endif
508    
509  #define ctype              frame->Xctype  #define ctype              frame->Xctype
# Line 447  HEAP_RECURSE: Line 527  HEAP_RECURSE:
527  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
528  i, and fc and c, can be the same variables. */  i, and fc and c, can be the same variables. */
529    
530  #else  #else         /* NO_RECURSE not defined */
531  #define fi i  #define fi i
532  #define fc c  #define fc c
533    
534    
535  #ifdef SUPPORT_UTF8                /* Many of these variables are used ony */  #ifdef SUPPORT_UTF8                /* Many of these variables are used only  */
536  const uschar *charptr;             /* small blocks of the code. My normal  */  const uschar *charptr;             /* in small blocks of the code. My normal */
537  #endif                             /* style of coding would have declared  */  #endif                             /* style of coding would have declared    */
538  const uschar *callpat;             /* them within each of those blocks.    */  const uschar *callpat;             /* them within each of those blocks.      */
539  const uschar *data;                /* However, in order to accommodate the */  const uschar *data;                /* However, in order to accommodate the   */
540  const uschar *next;                /* version of this code that uses an    */  const uschar *next;                /* version of this code that uses an      */
541  const uschar *pp;                  /* external "stack" implemented on the  */  USPTR         pp;                  /* external "stack" implemented on the    */
542  const uschar *prev;                /* heap, it is easier to declare them   */  const uschar *prev;                /* heap, it is easier to declare them all */
543  const uschar *saved_eptr;          /* all here, so the declarations can    */  USPTR         saved_eptr;          /* here, so the declarations can be cut   */
544                                     /* be cut out in a block. The only      */                                     /* out in a block. The only declarations  */
545  recursion_info new_recursive;      /* declarations within blocks below are */  recursion_info new_recursive;      /* within blocks below are for variables  */
546                                     /* for variables that do not have to    */                                     /* that do not have to be preserved over  */
547  BOOL cur_is_word;                  /* be preserved over a recursive call   */  BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
548  BOOL condition;                    /* to RMATCH().                         */  BOOL condition;
 BOOL minimize;  
549  BOOL prev_is_word;  BOOL prev_is_word;
550    
551  unsigned long int original_ims;  unsigned long int original_ims;
552    
553  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
554  int prop_type;  int prop_type;
555    int prop_value;
556  int prop_fail_result;  int prop_fail_result;
557  int prop_category;  int prop_category;
558  int prop_chartype;  int prop_chartype;
559  int prop_othercase;  int prop_script;
560  int prop_test_against;  int oclength;
561  int *prop_test_variable;  uschar occhars[8];
562  #endif  #endif
563    
564    int codelink;
565    int condcode;
566  int ctype;  int ctype;
567  int length;  int length;
568  int max;  int max;
# Line 493  int save_offset1, save_offset2, save_off Line 575  int save_offset1, save_offset2, save_off
575  int stacksave[REC_STACK_SAVE_MAX];  int stacksave[REC_STACK_SAVE_MAX];
576    
577  eptrblock newptrb;  eptrblock newptrb;
578  #endif  #endif     /* NO_RECURSE */
579    
580  /* These statements are here to stop the compiler complaining about unitialized  /* These statements are here to stop the compiler complaining about unitialized
581  variables. */  variables. */
582    
583  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
584    prop_value = 0;
585  prop_fail_result = 0;  prop_fail_result = 0;
 prop_test_against = 0;  
 prop_test_variable = NULL;  
586  #endif  #endif
587    
588  /* OK, now we can get on with the real code of the function. Recursion is  
589  specified by the macros RMATCH and RRETURN. When NO_RECURSE is *not* defined,  /* This label is used for tail recursion, which is used in a few cases even
590  these just turn into a recursive call to match() and a "return", respectively.  when NO_RECURSE is not defined, in order to reduce the amount of stack that is
591  However, RMATCH isn't like a function call because it's quite a complicated  used. Thanks to Ian Taylor for noticing this possibility and sending the
592  macro. It has to be used in one particular way. This shouldn't, however, impact  original patch. */
593  performance when true recursion is being used. */  
594    TAIL_RECURSE:
595    
596    /* OK, now we can get on with the real code of the function. Recursive calls
597    are specified by the macro RMATCH and RRETURN is used to return. When
598    NO_RECURSE is *not* defined, these just turn into a recursive call to match()
599    and a "return", respectively (possibly with some debugging if DEBUG is
600    defined). However, RMATCH isn't like a function call because it's quite a
601    complicated macro. It has to be used in one particular way. This shouldn't,
602    however, impact performance when true recursion is being used. */
603    
604    #ifdef SUPPORT_UTF8
605    utf8 = md->utf8;       /* Local copy of the flag */
606    #else
607    utf8 = FALSE;
608    #endif
609    
610    /* First check that we haven't called match() too many times, or that we
611    haven't exceeded the recursive call limit. */
612    
613  if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);  if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
614    if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
615    
616  original_ims = ims;    /* Save for resetting on ')' */  original_ims = ims;    /* Save for resetting on ')' */
 utf8 = md->utf8;       /* Local copy of the flag */  
617    
618  /* At the start of a bracketed group, add the current subject pointer to the  /* At the start of a group with an unlimited repeat that may match an empty
619  stack of such pointers, to be re-instated at the end of the group when we hit  string, the match_cbegroup flag is set. When this is the case, add the current
620  the closing ket. When match() is called in other circumstances, we don't add to  subject pointer to the chain of such remembered pointers, to be checked when we
621  this stack. */  hit the closing ket, in order to break infinite loops that match no characters.
622    When match() is called in other circumstances, don't add to the chain. The
623    match_cbegroup flag must NOT be used with tail recursion, because the memory
624    block that is used is on the stack, so a new one may be required for each
625    match(). */
626    
627  if ((flags & match_isgroup) != 0)  if ((flags & match_cbegroup) != 0)
628    {    {
   newptrb.epb_prev = eptrb;  
629    newptrb.epb_saved_eptr = eptr;    newptrb.epb_saved_eptr = eptr;
630      newptrb.epb_prev = eptrb;
631    eptrb = &newptrb;    eptrb = &newptrb;
632    }    }
633    
634  /* Now start processing the operations. */  /* Now start processing the opcodes. */
635    
636  for (;;)  for (;;)
637    {    {
638      minimize = possessive = FALSE;
639    op = *ecode;    op = *ecode;
640    minimize = FALSE;  
   
641    /* 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
642    matching at least one subject character. */    matching at least one subject character. */
643    
644    if (md->partial &&    if (md->partial &&
645        eptr >= md->end_subject &&        eptr >= md->end_subject &&
646        eptr > md->start_match)        eptr > mstart)
647      md->hitend = TRUE;      md->hitend = TRUE;
648    
649    /* 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)  
650      {      {
651      number = op - OP_BRA;      case OP_FAIL:
652        RRETURN(MATCH_NOMATCH);
     /* For extended extraction brackets (large number), we have to fish out the  
     number from a dummy opcode at the start. */  
653    
654      if (number > EXTRACT_BASIC_MAX)      case OP_PRUNE:
655        number = GET2(ecode, 2+LINK_SIZE);      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
656          ims, eptrb, flags, RM51);
657        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
658        RRETURN(MATCH_PRUNE);
659    
660        case OP_COMMIT:
661        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
662          ims, eptrb, flags, RM52);
663        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
664        RRETURN(MATCH_COMMIT);
665    
666        case OP_SKIP:
667        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
668          ims, eptrb, flags, RM53);
669        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
670        md->start_match_ptr = eptr;   /* Pass back current position */
671        RRETURN(MATCH_SKIP);
672    
673        case OP_THEN:
674        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
675          ims, eptrb, flags, RM54);
676        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
677        RRETURN(MATCH_THEN);
678    
679        /* Handle a capturing bracket. If there is space in the offset vector, save
680        the current subject position in the working slot at the top of the vector.
681        We mustn't change the current values of the data slot, because they may be
682        set from a previous iteration of this group, and be referred to by a
683        reference inside the group.
684    
685        If the bracket fails to match, we need to restore this value and also the
686        values of the final offsets, in case they were set by a previous iteration
687        of the same bracket.
688    
689        If there isn't enough space in the offset vector, treat this as if it were
690        a non-capturing bracket. Don't worry about setting the flag for the error
691        case here; that is handled in the code for KET. */
692    
693        case OP_CBRA:
694        case OP_SCBRA:
695        number = GET2(ecode, 1+LINK_SIZE);
696      offset = number << 1;      offset = number << 1;
697    
698  #ifdef DEBUG  #ifdef DEBUG
699      printf("start bracket %d subject=", number);      printf("start bracket %d\n", number);
700        printf("subject=");
701      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
702      printf("\n");      printf("\n");
703  #endif  #endif
# Line 584  for (;;) Line 712  for (;;)
712        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
713        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
714    
715          flags = (op == OP_SCBRA)? match_cbegroup : 0;
716        do        do
717          {          {
718          RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
719            match_isgroup);            ims, eptrb, flags, RM1);
720          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
721          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
722          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
723          }          }
# Line 603  for (;;) Line 732  for (;;)
732        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
733        }        }
734    
735      /* Insufficient room for saving captured contents */      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
736        as a non-capturing bracket. */
737    
738      else op = OP_BRA;      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
739      }      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
740    
741    /* Other types of node can be handled by a switch */      DPRINTF(("insufficient capture room: treat as non-capturing\n"));
742    
743    switch(op)      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
744      {      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
745      case OP_BRA:     /* Non-capturing bracket: optimized */  
746      DPRINTF(("start bracket 0\n"));      /* Non-capturing bracket. Loop for all the alternatives. When we get to the
747      do      final alternative within the brackets, we would return the result of a
748        recursive call to match() whatever happened. We can reduce stack usage by
749        turning this into a tail recursion, except in the case when match_cbegroup
750        is set.*/
751    
752        case OP_BRA:
753        case OP_SBRA:
754        DPRINTF(("start non-capturing bracket\n"));
755        flags = (op >= OP_SBRA)? match_cbegroup : 0;
756        for (;;)
757        {        {
758        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,        if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
759          match_isgroup);          {
760        if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (flags == 0)    /* Not a possibly empty group */
761              {
762              ecode += _pcre_OP_lengths[*ecode];
763              DPRINTF(("bracket 0 tail recursion\n"));
764              goto TAIL_RECURSE;
765              }
766    
767            /* Possibly empty group; can't use tail recursion. */
768    
769            RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
770              eptrb, flags, RM48);
771            RRETURN(rrc);
772            }
773    
774          /* For non-final alternatives, continue the loop for a NOMATCH result;
775          otherwise return. */
776    
777          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
778            eptrb, flags, RM2);
779          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
780        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
781        }        }
782      while (*ecode == OP_ALT);      /* Control never reaches here. */
     DPRINTF(("bracket 0 failed\n"));  
     RRETURN(MATCH_NOMATCH);  
783    
784      /* Conditional group: compilation checked that there are no more than      /* Conditional group: compilation checked that there are no more than
785      two branches. If the condition is false, skipping the first branch takes us      two branches. If the condition is false, skipping the first branch takes us
786      past the end if there is only one branch, but that's OK because that is      past the end if there is only one branch, but that's OK because that is
787      exactly what going to the ket would do. */      exactly what going to the ket would do. As there is only one branch to be
788        obeyed, we can use tail recursion to avoid using another stack frame. */
789    
790      case OP_COND:      case OP_COND:
791      if (ecode[LINK_SIZE+1] == OP_CREF) /* Condition extract or recurse test */      case OP_SCOND:
792        codelink= GET(ecode, 1);
793    
794        /* Because of the way auto-callout works during compile, a callout item is
795        inserted between OP_COND and an assertion condition. */
796    
797        if (ecode[LINK_SIZE+1] == OP_CALLOUT)
798          {
799          if (pcre_callout != NULL)
800            {
801            pcre_callout_block cb;
802            cb.version          = 1;   /* Version 1 of the callout block */
803            cb.callout_number   = ecode[LINK_SIZE+2];
804            cb.offset_vector    = md->offset_vector;
805            cb.subject          = (PCRE_SPTR)md->start_subject;
806            cb.subject_length   = md->end_subject - md->start_subject;
807            cb.start_match      = mstart - md->start_subject;
808            cb.current_position = eptr - md->start_subject;
809            cb.pattern_position = GET(ecode, LINK_SIZE + 3);
810            cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
811            cb.capture_top      = offset_top/2;
812            cb.capture_last     = md->capture_last;
813            cb.callout_data     = md->callout_data;
814            if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
815            if (rrc < 0) RRETURN(rrc);
816            }
817          ecode += _pcre_OP_lengths[OP_CALLOUT];
818          }
819    
820        condcode = ecode[LINK_SIZE+1];
821    
822        /* Now see what the actual condition is */
823    
824        if (condcode == OP_RREF)         /* Recursion test */
825          {
826          offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
827          condition = md->recursive != NULL &&
828            (offset == RREF_ANY || offset == md->recursive->group_num);
829          ecode += condition? 3 : GET(ecode, 1);
830          }
831    
832        else if (condcode == OP_CREF)    /* Group used test */
833        {        {
834        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
835        condition = (offset == CREF_RECURSE * 2)?        condition = offset < offset_top && md->offset_vector[offset] >= 0;
836          (md->recursive != NULL) :        ecode += condition? 3 : GET(ecode, 1);
837          (offset < offset_top && md->offset_vector[offset] >= 0);        }
838        RMATCH(rrc, eptr, ecode + (condition?  
839          (LINK_SIZE + 4) : (LINK_SIZE + 1 + GET(ecode, 1))),      else if (condcode == OP_DEF)     /* DEFINE - always false */
840          offset_top, md, ims, eptrb, match_isgroup);        {
841        RRETURN(rrc);        condition = FALSE;
842          ecode += GET(ecode, 1);
843        }        }
844    
845      /* The condition is an assertion. Call match() to evaluate it - setting      /* The condition is an assertion. Call match() to evaluate it - setting
846      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
847        assertion. */
848    
849      else      else
850        {        {
851        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
852            match_condassert | match_isgroup);            match_condassert, RM3);
853        if (rrc == MATCH_MATCH)        if (rrc == MATCH_MATCH)
854          {          {
855          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE+2);          condition = TRUE;
856            ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
857          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
858          }          }
859        else if (rrc != MATCH_NOMATCH)        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
860          {          {
861          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
862          }          }
863        else ecode += GET(ecode, 1);        else
864        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,          {
865          match_isgroup);          condition = FALSE;
866        RRETURN(rrc);          ecode += codelink;
867            }
868        }        }
     /* Control never reaches here */  
869    
870      /* Skip over conditional reference or large extraction number data if      /* We are now at the branch that is to be obeyed. As there is only one,
871      encountered. */      we can use tail recursion to avoid using another stack frame, except when
872        match_cbegroup is required for an unlimited repeat of a possibly empty
873        group. If the second alternative doesn't exist, we can just plough on. */
874    
875      case OP_CREF:      if (condition || *ecode == OP_ALT)
876      case OP_BRANUMBER:        {
877      ecode += 3;        ecode += 1 + LINK_SIZE;
878          if (op == OP_SCOND)        /* Possibly empty group */
879            {
880            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
881            RRETURN(rrc);
882            }
883          else                       /* Group must match something */
884            {
885            flags = 0;
886            goto TAIL_RECURSE;
887            }
888          }
889        else                         /* Condition false & no alternative */
890          {
891          ecode += 1 + LINK_SIZE;
892          }
893      break;      break;
894    
     /* End of the pattern. If we are in a recursion, we should restore the  
     offsets appropriately and continue from after the call. */  
895    
896        /* End of the pattern, either real or forced. If we are in a top-level
897        recursion, we should restore the offsets appropriately and continue from
898        after the call. */
899    
900        case OP_ACCEPT:
901      case OP_END:      case OP_END:
902      if (md->recursive != NULL && md->recursive->group_num == 0)      if (md->recursive != NULL && md->recursive->group_num == 0)
903        {        {
904        recursion_info *rec = md->recursive;        recursion_info *rec = md->recursive;
905        DPRINTF(("Hit the end in a (?0) recursion\n"));        DPRINTF(("End of pattern in a (?0) recursion\n"));
906        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
907        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
908          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
909        md->start_match = rec->save_start;        mstart = rec->save_start;
910        ims = original_ims;        ims = original_ims;
911        ecode = rec->after_call;        ecode = rec->after_call;
912        break;        break;
# Line 694  for (;;) Line 915  for (;;)
915      /* 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
916      string - backtracking will then try other alternatives, if any. */      string - backtracking will then try other alternatives, if any. */
917    
918      if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);      if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
919      md->end_match_ptr = eptr;          /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
920      md->end_offset_top = offset_top;   /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
921        md->start_match_ptr = mstart;       /* and the start (\K can modify) */
922      RRETURN(MATCH_MATCH);      RRETURN(MATCH_MATCH);
923    
924      /* Change option settings */      /* Change option settings */
# Line 717  for (;;) Line 939  for (;;)
939      case OP_ASSERTBACK:      case OP_ASSERTBACK:
940      do      do
941        {        {
942        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
943          match_isgroup);          RM4);
944        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
945        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
946        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
947        }        }
948      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 744  for (;;) Line 966  for (;;)
966      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
967      do      do
968        {        {
969        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
970          match_isgroup);          RM5);
971        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
972        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
973        ecode += GET(ecode,1);        ecode += GET(ecode,1);
974        }        }
975      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 766  for (;;) Line 988  for (;;)
988  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
989      if (utf8)      if (utf8)
990        {        {
991        c = GET(ecode,1);        i = GET(ecode, 1);
992        for (i = 0; i < c; i++)        while (i-- > 0)
993          {          {
994          eptr--;          eptr--;
995          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
996          BACKCHAR(eptr)          BACKCHAR(eptr);
997          }          }
998        }        }
999      else      else
# Line 780  for (;;) Line 1002  for (;;)
1002      /* 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 */
1003    
1004        {        {
1005        eptr -= GET(ecode,1);        eptr -= GET(ecode, 1);
1006        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1007        }        }
1008    
# Line 800  for (;;) Line 1022  for (;;)
1022        cb.version          = 1;   /* Version 1 of the callout block */        cb.version          = 1;   /* Version 1 of the callout block */
1023        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1024        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1025        cb.subject          = (const char *)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1026        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = md->end_subject - md->start_subject;
1027        cb.start_match      = md->start_match - md->start_subject;        cb.start_match      = mstart - md->start_subject;
1028        cb.current_position = eptr - md->start_subject;        cb.current_position = eptr - md->start_subject;
1029        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1030        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
# Line 837  for (;;) Line 1059  for (;;)
1059      case OP_RECURSE:      case OP_RECURSE:
1060        {        {
1061        callpat = md->start_code + GET(ecode, 1);        callpat = md->start_code + GET(ecode, 1);
1062        new_recursive.group_num = *callpat - OP_BRA;        new_recursive.group_num = (callpat == md->start_code)? 0 :
1063            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);  
1064    
1065        /* Add to "recursing stack" */        /* Add to "recursing stack" */
1066    
# Line 869  for (;;) Line 1086  for (;;)
1086    
1087        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1088              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1089        new_recursive.save_start = md->start_match;        new_recursive.save_start = mstart;
1090        md->start_match = eptr;        mstart = eptr;
1091    
1092        /* 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
1093        restore the offset and recursion data. */        restore the offset and recursion data. */
1094    
1095        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1096          flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
1097        do        do
1098          {          {
1099          RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1100              eptrb, match_isgroup);            md, ims, eptrb, flags, RM6);
1101          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH)
1102            {            {
1103              DPRINTF(("Recursion matched\n"));
1104            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1105            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1106              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1107            RRETURN(MATCH_MATCH);            RRETURN(MATCH_MATCH);
1108            }            }
1109          else if (rrc != MATCH_NOMATCH) RRETURN(rrc);          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1110              {
1111              DPRINTF(("Recursion gave error %d\n", rrc));
1112              RRETURN(rrc);
1113              }
1114    
1115          md->recursive = &new_recursive;          md->recursive = &new_recursive;
1116          memcpy(md->offset_vector, new_recursive.offset_save,          memcpy(md->offset_vector, new_recursive.offset_save,
# Line 912  for (;;) Line 1135  for (;;)
1135      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer. */
1136    
1137      case OP_ONCE:      case OP_ONCE:
1138        {      prev = ecode;
1139        prev = ecode;      saved_eptr = eptr;
       saved_eptr = eptr;  
1140    
1141        do      do
1142          {        {
1143          RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
1144            eptrb, match_isgroup);        if (rrc == MATCH_MATCH) break;
1145          if (rrc == MATCH_MATCH) break;        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1146          if (rrc != MATCH_NOMATCH) RRETURN(rrc);        ecode += GET(ecode,1);
1147          ecode += GET(ecode,1);        }
1148          }      while (*ecode == OP_ALT);
       while (*ecode == OP_ALT);  
1149    
1150        /* If hit the end of the group (which could be repeated), fail */      /* If hit the end of the group (which could be repeated), fail */
1151    
1152        if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);      if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
1153    
1154        /* Continue as from after the assertion, updating the offsets high water      /* Continue as from after the assertion, updating the offsets high water
1155        mark, since extracts may have been taken. */      mark, since extracts may have been taken. */
1156    
1157        do ecode += GET(ecode,1); while (*ecode == OP_ALT);      do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1158    
1159        offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1160        eptr = md->end_match_ptr;      eptr = md->end_match_ptr;
1161    
1162        /* For a non-repeating ket, just continue at this level. This also      /* For a non-repeating ket, just continue at this level. This also
1163        happens for a repeating ket if no characters were matched in the group.      happens for a repeating ket if no characters were matched in the group.
1164        This is the forcible breaking of infinite loops as implemented in Perl      This is the forcible breaking of infinite loops as implemented in Perl
1165        5.005. If there is an options reset, it will get obeyed in the normal      5.005. If there is an options reset, it will get obeyed in the normal
1166        course of events. */      course of events. */
1167    
1168        if (*ecode == OP_KET || eptr == saved_eptr)      if (*ecode == OP_KET || eptr == saved_eptr)
1169          {        {
1170          ecode += 1+LINK_SIZE;        ecode += 1+LINK_SIZE;
1171          break;        break;
1172          }        }
1173    
1174        /* 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
1175        preceding bracket, in the appropriate order. We need to reset any options      preceding bracket, in the appropriate order. The second "call" of match()
1176        that changed within the bracket before re-running it, so check the next      uses tail recursion, to avoid using another stack frame. We need to reset
1177        opcode. */      any options that changed within the bracket before re-running it, so
1178        check the next opcode. */
1179    
1180        if (ecode[1+LINK_SIZE] == OP_OPT)      if (ecode[1+LINK_SIZE] == OP_OPT)
1181          {        {
1182          ims = (ims & ~PCRE_IMS) | ecode[4];        ims = (ims & ~PCRE_IMS) | ecode[4];
1183          DPRINTF(("ims set to %02lx at group repeat\n", ims));        DPRINTF(("ims set to %02lx at group repeat\n", ims));
1184          }        }
1185    
1186        if (*ecode == OP_KETRMIN)      if (*ecode == OP_KETRMIN)
1187          {        {
1188          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);
1189          if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1190          RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);        ecode = prev;
1191          if (rrc != MATCH_NOMATCH) RRETURN(rrc);        flags = 0;
1192          }        goto TAIL_RECURSE;
       else  /* OP_KETRMAX */  
         {  
         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);  
         if (rrc != MATCH_NOMATCH) RRETURN(rrc);  
         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);  
         if (rrc != MATCH_NOMATCH) RRETURN(rrc);  
         }  
1193        }        }
1194      RRETURN(MATCH_NOMATCH);      else  /* OP_KETRMAX */
1195          {
1196          RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
1197          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1198          ecode += 1 + LINK_SIZE;
1199          flags = 0;
1200          goto TAIL_RECURSE;
1201          }
1202        /* Control never gets here */
1203    
1204      /* An alternation is the end of a branch; scan along to find the end of the      /* An alternation is the end of a branch; scan along to find the end of the
1205      bracketed group and go to there. */      bracketed group and go to there. */
# Line 985  for (;;) Line 1208  for (;;)
1208      do ecode += GET(ecode,1); while (*ecode == OP_ALT);      do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1209      break;      break;
1210    
1211      /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating      /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1212      that it may occur zero times. It may repeat infinitely, or not at all -      indicating that it may occur zero times. It may repeat infinitely, or not
1213      i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper      at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1214      repeat limits are compiled as a number of copies, with the optional ones      with fixed upper repeat limits are compiled as a number of copies, with the
1215      preceded by BRAZERO or BRAMINZERO. */      optional ones preceded by BRAZERO or BRAMINZERO. */
1216    
1217      case OP_BRAZERO:      case OP_BRAZERO:
1218        {        {
1219        next = ecode+1;        next = ecode+1;
1220        RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);        RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);
1221        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1222        do next += GET(next,1); while (*next == OP_ALT);        do next += GET(next,1); while (*next == OP_ALT);
1223        ecode = next + 1+LINK_SIZE;        ecode = next + 1 + LINK_SIZE;
1224        }        }
1225      break;      break;
1226    
1227      case OP_BRAMINZERO:      case OP_BRAMINZERO:
1228        {        {
1229        next = ecode+1;        next = ecode+1;
1230        do next += GET(next,1); while (*next == OP_ALT);        do next += GET(next, 1); while (*next == OP_ALT);
1231        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);  
1232        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1233        ecode++;        ecode++;
1234        }        }
1235      break;      break;
1236    
1237      /* End of a group, repeated or non-repeating. If we are at the end of      case OP_SKIPZERO:
1238      an assertion "group", stop matching and return MATCH_MATCH, but record the        {
1239      current high water mark for use by positive assertions. Do this also        next = ecode+1;
1240      for the "once" (not-backup up) groups. */        do next += GET(next,1); while (*next == OP_ALT);
1241          ecode = next + 1 + LINK_SIZE;
1242          }
1243        break;
1244    
1245        /* End of a group, repeated or non-repeating. */
1246    
1247      case OP_KET:      case OP_KET:
1248      case OP_KETRMIN:      case OP_KETRMIN:
1249      case OP_KETRMAX:      case OP_KETRMAX:
1250        {      prev = ecode - GET(ecode, 1);
       prev = ecode - GET(ecode, 1);  
       saved_eptr = eptrb->epb_saved_eptr;  
1251    
1252        /* Back up the stack of bracket start pointers. */      /* If this was a group that remembered the subject start, in order to break
1253        infinite repeats of empty string matches, retrieve the subject start from
1254        the chain. Otherwise, set it NULL. */
1255    
1256        eptrb = eptrb->epb_prev;      if (*prev >= OP_SBRA)
1257          {
1258        if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||        saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */
1259            *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||        eptrb = eptrb->epb_prev;              /* Backup to previous group */
1260            *prev == OP_ONCE)        }
1261          {      else saved_eptr = NULL;
         md->end_match_ptr = eptr;      /* For ONCE */  
         md->end_offset_top = offset_top;  
         RRETURN(MATCH_MATCH);  
         }  
1262    
1263        /* In all other cases except a conditional group we have to check the      /* If we are at the end of an assertion group, stop matching and return
1264        group number back at the start and if necessary complete handling an      MATCH_MATCH, but record the current high water mark for use by positive
1265        extraction by setting the offsets and bumping the high water mark. */      assertions. Do this also for the "once" (atomic) groups. */
1266    
1267        if (*prev != OP_COND)      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1268          {          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
1269          number = *prev - OP_BRA;          *prev == OP_ONCE)
1270          {
1271          md->end_match_ptr = eptr;      /* For ONCE */
1272          md->end_offset_top = offset_top;
1273          RRETURN(MATCH_MATCH);
1274          }
1275    
1276          /* For extended extraction brackets (large number), we have to fish out      /* For capturing groups we have to check the group number back at the start
1277          the number from a dummy opcode at the start. */      and if necessary complete handling an extraction by setting the offsets and
1278        bumping the high water mark. Note that whole-pattern recursion is coded as
1279        a recurse into group 0, so it won't be picked up here. Instead, we catch it
1280        when the OP_END is reached. Other recursion is handled here. */
1281    
1282          if (number > EXTRACT_BASIC_MAX) number = GET2(prev, 2+LINK_SIZE);      if (*prev == OP_CBRA || *prev == OP_SCBRA)
1283          offset = number << 1;        {
1284          number = GET2(prev, 1+LINK_SIZE);
1285          offset = number << 1;
1286    
1287  #ifdef DEBUG  #ifdef DEBUG
1288          printf("end bracket %d", number);        printf("end bracket %d", number);
1289          printf("\n");        printf("\n");
1290  #endif  #endif
1291    
1292          /* Test for a numbered group. This includes groups called as a result        md->capture_last = number;
1293          of recursion. Note that whole-pattern recursion is coded as a recurse        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1294          into group 0, so it won't be picked up here. Instead, we catch it when          {
1295          the OP_END is reached. */          md->offset_vector[offset] =
1296              md->offset_vector[md->offset_end - number];
1297          if (number > 0)          md->offset_vector[offset+1] = eptr - md->start_subject;
1298            {          if (offset_top <= offset) offset_top = offset + 2;
1299            md->capture_last = number;          }
1300            if (offset >= md->offset_max) md->offset_overflow = TRUE; else  
1301              {        /* Handle a recursively called group. Restore the offsets
1302              md->offset_vector[offset] =        appropriately and continue from after the call. */
1303                md->offset_vector[md->offset_end - number];  
1304              md->offset_vector[offset+1] = eptr - md->start_subject;        if (md->recursive != NULL && md->recursive->group_num == number)
1305              if (offset_top <= offset) offset_top = offset + 2;          {
1306              }          recursion_info *rec = md->recursive;
1307            DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1308            /* Handle a recursively called group. Restore the offsets          md->recursive = rec->prevrec;
1309            appropriately and continue from after the call. */          mstart = rec->save_start;
1310            memcpy(md->offset_vector, rec->offset_save,
1311            if (md->recursive != NULL && md->recursive->group_num == number)            rec->saved_max * sizeof(int));
1312              {          ecode = rec->after_call;
1313              recursion_info *rec = md->recursive;          ims = original_ims;
1314              DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          break;
             md->recursive = rec->prevrec;  
             md->start_match = rec->save_start;  
             memcpy(md->offset_vector, rec->offset_save,  
               rec->saved_max * sizeof(int));  
             ecode = rec->after_call;  
             ims = original_ims;  
             break;  
             }  
           }  
1315          }          }
1316          }
1317    
1318        /* 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
1319        the group. */      flags, in case they got changed during the group. */
1320    
1321        ims = original_ims;      ims = original_ims;
1322        DPRINTF(("ims reset to %02lx\n", ims));      DPRINTF(("ims reset to %02lx\n", ims));
1323    
1324        /* For a non-repeating ket, just continue at this level. This also      /* For a non-repeating ket, just continue at this level. This also
1325        happens for a repeating ket if no characters were matched in the group.      happens for a repeating ket if no characters were matched in the group.
1326        This is the forcible breaking of infinite loops as implemented in Perl      This is the forcible breaking of infinite loops as implemented in Perl
1327        5.005. If there is an options reset, it will get obeyed in the normal      5.005. If there is an options reset, it will get obeyed in the normal
1328        course of events. */      course of events. */
1329    
1330        if (*ecode == OP_KET || eptr == saved_eptr)      if (*ecode == OP_KET || eptr == saved_eptr)
1331          {        {
1332          ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1333          break;        break;
1334          }        }
1335    
1336        /* 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
1337        preceding bracket, in the appropriate order. */      preceding bracket, in the appropriate order. In the second case, we can use
1338        tail recursion to avoid using another stack frame, unless we have an
1339        unlimited repeat of a group that can match an empty string. */
1340    
1341        if (*ecode == OP_KETRMIN)      flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
1342          {  
1343          RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);      if (*ecode == OP_KETRMIN)
1344          if (rrc != MATCH_NOMATCH) RRETURN(rrc);        {
1345          RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
1346          if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1347          }        if (flags != 0)    /* Could match an empty string */
       else  /* OP_KETRMAX */  
1348          {          {
1349          RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);          RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
1350          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          RRETURN(rrc);
         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);  
         if (rrc != MATCH_NOMATCH) RRETURN(rrc);  
1351          }          }
1352          ecode = prev;
1353          goto TAIL_RECURSE;
1354        }        }
1355        else  /* OP_KETRMAX */
1356      RRETURN(MATCH_NOMATCH);        {
1357          RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
1358          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1359          ecode += 1 + LINK_SIZE;
1360          flags = 0;
1361          goto TAIL_RECURSE;
1362          }
1363        /* Control never gets here */
1364    
1365      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1366    
# Line 1135  for (;;) Line 1368  for (;;)
1368      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
1369      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1370        {        {
1371        if (eptr != md->start_subject && eptr[-1] != NEWLINE)        if (eptr != md->start_subject &&
1372              (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1373          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
1374        ecode++;        ecode++;
1375        break;        break;
# Line 1156  for (;;) Line 1390  for (;;)
1390      ecode++;      ecode++;
1391      break;      break;
1392    
1393        /* Reset the start of match point */
1394    
1395        case OP_SET_SOM:
1396        mstart = eptr;
1397        ecode++;
1398        break;
1399    
1400      /* Assert before internal newline if multiline, or before a terminating      /* Assert before internal newline if multiline, or before a terminating
1401      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. */
1402    
# Line 1163  for (;;) Line 1404  for (;;)
1404      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1405        {        {
1406        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1407          { if (*eptr != NEWLINE) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
1408        else        else
1409          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) RRETURN(MATCH_NOMATCH); }
1410        ecode++;        ecode++;
# Line 1174  for (;;) Line 1415  for (;;)
1415        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
1416        if (!md->endonly)        if (!md->endonly)
1417          {          {
1418          if (eptr < md->end_subject - 1 ||          if (eptr != md->end_subject &&
1419             (eptr == md->end_subject - 1 && *eptr != NEWLINE))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1420            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1421          ecode++;          ecode++;
1422          break;          break;
1423          }          }
1424        }        }
1425      /* ... else fall through */      /* ... else fall through for endonly */
1426    
1427      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1428    
# Line 1193  for (;;) Line 1434  for (;;)
1434      /* End of subject or ending \n assertion (\Z) */      /* End of subject or ending \n assertion (\Z) */
1435    
1436      case OP_EODN:      case OP_EODN:
1437      if (eptr < md->end_subject - 1 ||      if (eptr != md->end_subject &&
1438         (eptr == md->end_subject - 1 && *eptr != NEWLINE)) RRETURN(MATCH_NOMATCH);          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1439          RRETURN(MATCH_NOMATCH);
1440      ecode++;      ecode++;
1441      break;      break;
1442    
# Line 1247  for (;;) Line 1489  for (;;)
1489      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1490    
1491      case OP_ANY:      case OP_ANY:
1492      if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == NEWLINE)      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
1493        RRETURN(MATCH_NOMATCH);      /* Fall through */
1494    
1495        case OP_ALLANY:
1496      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
1497  #ifdef SUPPORT_UTF8      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
     if (utf8)  
       while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
 #endif  
1498      ecode++;      ecode++;
1499      break;      break;
1500    
# Line 1343  for (;;) Line 1584  for (;;)
1584      ecode++;      ecode++;
1585      break;      break;
1586    
1587        case OP_ANYNL:
1588        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1589        GETCHARINCTEST(c, eptr);
1590        switch(c)
1591          {
1592          default: RRETURN(MATCH_NOMATCH);
1593          case 0x000d:
1594          if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1595          break;
1596    
1597          case 0x000a:
1598          break;
1599    
1600          case 0x000b:
1601          case 0x000c:
1602          case 0x0085:
1603          case 0x2028:
1604          case 0x2029:
1605          if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
1606          break;
1607          }
1608        ecode++;
1609        break;
1610    
1611        case OP_NOT_HSPACE:
1612        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1613        GETCHARINCTEST(c, eptr);
1614        switch(c)
1615          {
1616          default: break;
1617          case 0x09:      /* HT */
1618          case 0x20:      /* SPACE */
1619          case 0xa0:      /* NBSP */
1620          case 0x1680:    /* OGHAM SPACE MARK */
1621          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1622          case 0x2000:    /* EN QUAD */
1623          case 0x2001:    /* EM QUAD */
1624          case 0x2002:    /* EN SPACE */
1625          case 0x2003:    /* EM SPACE */
1626          case 0x2004:    /* THREE-PER-EM SPACE */
1627          case 0x2005:    /* FOUR-PER-EM SPACE */
1628          case 0x2006:    /* SIX-PER-EM SPACE */
1629          case 0x2007:    /* FIGURE SPACE */
1630          case 0x2008:    /* PUNCTUATION SPACE */
1631          case 0x2009:    /* THIN SPACE */
1632          case 0x200A:    /* HAIR SPACE */
1633          case 0x202f:    /* NARROW NO-BREAK SPACE */
1634          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1635          case 0x3000:    /* IDEOGRAPHIC SPACE */
1636          RRETURN(MATCH_NOMATCH);
1637          }
1638        ecode++;
1639        break;
1640    
1641        case OP_HSPACE:
1642        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1643        GETCHARINCTEST(c, eptr);
1644        switch(c)
1645          {
1646          default: RRETURN(MATCH_NOMATCH);
1647          case 0x09:      /* HT */
1648          case 0x20:      /* SPACE */
1649          case 0xa0:      /* NBSP */
1650          case 0x1680:    /* OGHAM SPACE MARK */
1651          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1652          case 0x2000:    /* EN QUAD */
1653          case 0x2001:    /* EM QUAD */
1654          case 0x2002:    /* EN SPACE */
1655          case 0x2003:    /* EM SPACE */
1656          case 0x2004:    /* THREE-PER-EM SPACE */
1657          case 0x2005:    /* FOUR-PER-EM SPACE */
1658          case 0x2006:    /* SIX-PER-EM SPACE */
1659          case 0x2007:    /* FIGURE SPACE */
1660          case 0x2008:    /* PUNCTUATION SPACE */
1661          case 0x2009:    /* THIN SPACE */
1662          case 0x200A:    /* HAIR SPACE */
1663          case 0x202f:    /* NARROW NO-BREAK SPACE */
1664          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1665          case 0x3000:    /* IDEOGRAPHIC SPACE */
1666          break;
1667          }
1668        ecode++;
1669        break;
1670    
1671        case OP_NOT_VSPACE:
1672        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1673        GETCHARINCTEST(c, eptr);
1674        switch(c)
1675          {
1676          default: break;
1677          case 0x0a:      /* LF */
1678          case 0x0b:      /* VT */
1679          case 0x0c:      /* FF */
1680          case 0x0d:      /* CR */
1681          case 0x85:      /* NEL */
1682          case 0x2028:    /* LINE SEPARATOR */
1683          case 0x2029:    /* PARAGRAPH SEPARATOR */
1684          RRETURN(MATCH_NOMATCH);
1685          }
1686        ecode++;
1687        break;
1688    
1689        case OP_VSPACE:
1690        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1691        GETCHARINCTEST(c, eptr);
1692        switch(c)
1693          {
1694          default: RRETURN(MATCH_NOMATCH);
1695          case 0x0a:      /* LF */
1696          case 0x0b:      /* VT */
1697          case 0x0c:      /* FF */
1698          case 0x0d:      /* CR */
1699          case 0x85:      /* NEL */
1700          case 0x2028:    /* LINE SEPARATOR */
1701          case 0x2029:    /* PARAGRAPH SEPARATOR */
1702          break;
1703          }
1704        ecode++;
1705        break;
1706    
1707  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
1708      /* Check the next character by Unicode property. We will get here only      /* Check the next character by Unicode property. We will get here only
1709      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 1352  for (;;) Line 1713  for (;;)
1713      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1714      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1715        {        {
1716        int chartype, rqdtype;        const ucd_record *prop = GET_UCD(c);
       int othercase;  
       int category = ucp_findchar(c, &chartype, &othercase);  
   
       rqdtype = *(++ecode);  
       ecode++;  
1717    
1718        if (rqdtype >= 128)        switch(ecode[1])
1719          {          {
1720          if ((rqdtype - 128 != category) == (op == OP_PROP))          case PT_ANY:
1721            if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
1722            break;
1723    
1724            case PT_LAMP:
1725            if ((prop->chartype == ucp_Lu ||
1726                 prop->chartype == ucp_Ll ||
1727                 prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
1728            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1729          }           break;
1730        else  
1731          {          case PT_GC:
1732          if ((rqdtype != chartype) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
1733              RRETURN(MATCH_NOMATCH);
1734            break;
1735    
1736            case PT_PC:
1737            if ((ecode[2] != prop->chartype) == (op == OP_PROP))
1738            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1739            break;
1740    
1741            case PT_SC:
1742            if ((ecode[2] != prop->script) == (op == OP_PROP))
1743              RRETURN(MATCH_NOMATCH);
1744            break;
1745    
1746            default:
1747            RRETURN(PCRE_ERROR_INTERNAL);
1748          }          }
1749    
1750          ecode += 3;
1751        }        }
1752      break;      break;
1753    
# Line 1379  for (;;) Line 1758  for (;;)
1758      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1759      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1760        {        {
1761        int chartype;        int category = UCD_CATEGORY(c);
       int othercase;  
       int category = ucp_findchar(c, &chartype, &othercase);  
1762        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) RRETURN(MATCH_NOMATCH);
1763        while (eptr < md->end_subject)        while (eptr < md->end_subject)
1764          {          {
# Line 1390  for (;;) Line 1767  for (;;)
1767            {            {
1768            GETCHARLEN(c, eptr, len);            GETCHARLEN(c, eptr, len);
1769            }            }
1770          category = ucp_findchar(c, &chartype, &othercase);          category = UCD_CATEGORY(c);
1771          if (category != ucp_M) break;          if (category != ucp_M) break;
1772          eptr += len;          eptr += len;
1773          }          }
# Line 1411  for (;;) Line 1788  for (;;)
1788      case OP_REF:      case OP_REF:
1789        {        {
1790        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
1791        ecode += 3;                                 /* Advance past item */        ecode += 3;
1792    
1793        /* If the reference is unset, set the length to be longer than the amount        /* If the reference is unset, there are two possibilities:
       of subject left; this ensures that every attempt at a match fails. We  
       can't just fail here, because of the possibility of quantifiers with zero  
       minima. */  
   
       length = (offset >= offset_top || md->offset_vector[offset] < 0)?  
         md->end_subject - eptr + 1 :  
         md->offset_vector[offset+1] - md->offset_vector[offset];  
1794    
1795        /* Set up for repetition, or handle the non-repeated case */        (a) In the default, Perl-compatible state, set the length to be longer
1796          than the amount of subject left; this ensures that every attempt at a
1797          match fails. We can't just fail here, because of the possibility of
1798          quantifiers with zero minima.
1799    
1800        switch (*ecode)        (b) If the JavaScript compatibility flag is set, set the length to zero
1801          {        so that the back reference matches an empty string.
1802          case OP_CRSTAR:  
1803          Otherwise, set the length to the length of what was matched by the
1804          referenced subpattern. */
1805    
1806          if (offset >= offset_top || md->offset_vector[offset] < 0)
1807            length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;
1808          else
1809            length = md->offset_vector[offset+1] - md->offset_vector[offset];
1810    
1811          /* Set up for repetition, or handle the non-repeated case */
1812    
1813          switch (*ecode)
1814            {
1815            case OP_CRSTAR:
1816          case OP_CRMINSTAR:          case OP_CRMINSTAR:
1817          case OP_CRPLUS:          case OP_CRPLUS:
1818          case OP_CRMINPLUS:          case OP_CRMINPLUS:
# Line 1480  for (;;) Line 1866  for (;;)
1866          {          {
1867          for (fi = min;; fi++)          for (fi = min;; fi++)
1868            {            {
1869            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
1870            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1871            if (fi >= max || !match_ref(offset, eptr, length, md, ims))            if (fi >= max || !match_ref(offset, eptr, length, md, ims))
1872              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
# Line 1501  for (;;) Line 1887  for (;;)
1887            }            }
1888          while (eptr >= pp)          while (eptr >= pp)
1889            {            {
1890            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
1891            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1892            eptr -= length;            eptr -= length;
1893            }            }
# Line 1606  for (;;) Line 1992  for (;;)
1992            {            {
1993            for (fi = min;; fi++)            for (fi = min;; fi++)
1994              {              {
1995              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
1996              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1997              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1998              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
# Line 1626  for (;;) Line 2012  for (;;)
2012            {            {
2013            for (fi = min;; fi++)            for (fi = min;; fi++)
2014              {              {
2015              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2016              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2017              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2018              c = *eptr++;              c = *eptr++;
# Line 1663  for (;;) Line 2049  for (;;)
2049              }              }
2050            for (;;)            for (;;)
2051              {              {
2052              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
2053              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2054              if (eptr-- == pp) break;        /* Stop if tried at original pos */              if (eptr-- == pp) break;        /* Stop if tried at original pos */
2055              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 1682  for (;;) Line 2068  for (;;)
2068              }              }
2069            while (eptr >= pp)            while (eptr >= pp)
2070              {              {
2071              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
             eptr--;  
2072              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2073                eptr--;
2074              }              }
2075            }            }
2076    
# Line 1695  for (;;) Line 2081  for (;;)
2081    
2082    
2083      /* Match an extended character class. This opcode is encountered only      /* Match an extended character class. This opcode is encountered only
2084      in UTF-8 mode, because that's the only time it is compiled. */      when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
2085        mode, because Unicode properties are supported in non-UTF-8 mode. */
2086    
2087  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2088      case OP_XCLASS:      case OP_XCLASS:
# Line 1737  for (;;) Line 2124  for (;;)
2124        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2125          {          {
2126          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2127          GETCHARINC(c, eptr);          GETCHARINCTEST(c, eptr);
2128          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2129          }          }
2130    
# Line 1753  for (;;) Line 2140  for (;;)
2140          {          {
2141          for (fi = min;; fi++)          for (fi = min;; fi++)
2142            {            {
2143            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2144            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2145            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2146            GETCHARINC(c, eptr);            GETCHARINCTEST(c, eptr);
2147            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2148            }            }
2149          /* Control never gets here */          /* Control never gets here */
# Line 1771  for (;;) Line 2158  for (;;)
2158            {            {
2159            int len = 1;            int len = 1;
2160            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject) break;
2161            GETCHARLEN(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2162            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2163            eptr += len;            eptr += len;
2164            }            }
2165          for(;;)          for(;;)
2166            {            {
2167            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2168            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2169            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2170            BACKCHAR(eptr)            if (utf8) BACKCHAR(eptr);
2171            }            }
2172          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2173          }          }
# Line 1836  for (;;) Line 2223  for (;;)
2223    
2224        else        else
2225          {          {
2226          int dc;          unsigned int dc;
2227          GETCHARINC(dc, eptr);          GETCHARINC(dc, eptr);
2228          ecode += length;          ecode += length;
2229    
2230          /* If we have Unicode property support, we can use it to test the other          /* If we have Unicode property support, we can use it to test the other
2231          case of the character, if there is one. The result of ucp_findchar() is          case of the character, if there is one. */
         < 0 if the char isn't found, and othercase is returned as zero if there  
         isn't one. */  
2232    
2233          if (fc != dc)          if (fc != dc)
2234            {            {
2235  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2236            int chartype;            if (dc != UCD_OTHERCASE(fc))
           int othercase;  
           if (ucp_findchar(fc, &chartype, &othercase) < 0 || dc != othercase)  
2237  #endif  #endif
2238              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2239            }            }
# Line 1867  for (;;) Line 2250  for (;;)
2250        }        }
2251      break;      break;
2252    
2253      /* Match a single character repeatedly; different opcodes share code. */      /* Match a single character repeatedly. */
2254    
2255      case OP_EXACT:      case OP_EXACT:
2256      min = max = GET2(ecode, 1);      min = max = GET2(ecode, 1);
2257      ecode += 3;      ecode += 3;
2258      goto REPEATCHAR;      goto REPEATCHAR;
2259    
2260        case OP_POSUPTO:
2261        possessive = TRUE;
2262        /* Fall through */
2263    
2264      case OP_UPTO:      case OP_UPTO:
2265      case OP_MINUPTO:      case OP_MINUPTO:
2266      min = 0;      min = 0;
# Line 1882  for (;;) Line 2269  for (;;)
2269      ecode += 3;      ecode += 3;
2270      goto REPEATCHAR;      goto REPEATCHAR;
2271    
2272        case OP_POSSTAR:
2273        possessive = TRUE;
2274        min = 0;
2275        max = INT_MAX;
2276        ecode++;
2277        goto REPEATCHAR;
2278    
2279        case OP_POSPLUS:
2280        possessive = TRUE;
2281        min = 1;
2282        max = INT_MAX;
2283        ecode++;
2284        goto REPEATCHAR;
2285    
2286        case OP_POSQUERY:
2287        possessive = TRUE;
2288        min = 0;
2289        max = 1;
2290        ecode++;
2291        goto REPEATCHAR;
2292    
2293      case OP_STAR:      case OP_STAR:
2294      case OP_MINSTAR:      case OP_MINSTAR:
2295      case OP_PLUS:      case OP_PLUS:
# Line 1913  for (;;) Line 2321  for (;;)
2321    
2322        if (length > 1)        if (length > 1)
2323          {          {
         int oclength = 0;  
         uschar occhars[8];  
   
2324  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2325          int othercase;          unsigned int othercase;
         int chartype;  
2326          if ((ims & PCRE_CASELESS) != 0 &&          if ((ims & PCRE_CASELESS) != 0 &&
2327               ucp_findchar(fc, &chartype, &othercase) >= 0 &&              (othercase = UCD_OTHERCASE(fc)) != fc)
              othercase > 0)  
2328            oclength = _pcre_ord2utf8(othercase, occhars);            oclength = _pcre_ord2utf8(othercase, occhars);
2329            else oclength = 0;
2330  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2331    
2332          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2333            {            {
2334            if (memcmp(eptr, charptr, length) == 0) eptr += length;            if (memcmp(eptr, charptr, length) == 0) eptr += length;
2335    #ifdef SUPPORT_UCP
2336            /* Need braces because of following else */            /* Need braces because of following else */
2337            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
2338            else            else
# Line 1935  for (;;) Line 2340  for (;;)
2340              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
2341              eptr += oclength;              eptr += oclength;
2342              }              }
2343    #else   /* without SUPPORT_UCP */
2344              else { RRETURN(MATCH_NOMATCH); }
2345    #endif  /* SUPPORT_UCP */
2346            }            }
2347    
2348          if (min == max) continue;          if (min == max) continue;
# Line 1943  for (;;) Line 2351  for (;;)
2351            {            {
2352            for (fi = min;; fi++)            for (fi = min;; fi++)
2353              {              {
2354              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2355              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2356              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2357              if (memcmp(eptr, charptr, length) == 0) eptr += length;              if (memcmp(eptr, charptr, length) == 0) eptr += length;
2358    #ifdef SUPPORT_UCP
2359              /* Need braces because of following else */              /* Need braces because of following else */
2360              else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }              else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
2361              else              else
# Line 1954  for (;;) Line 2363  for (;;)
2363                if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);                if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
2364                eptr += oclength;                eptr += oclength;
2365                }                }
2366    #else   /* without SUPPORT_UCP */
2367                else { RRETURN (MATCH_NOMATCH); }
2368    #endif  /* SUPPORT_UCP */
2369              }              }
2370            /* Control never gets here */            /* Control never gets here */
2371            }            }
2372          else  
2373            else  /* Maximize */
2374            {            {
2375            pp = eptr;            pp = eptr;
2376            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2377              {              {
2378              if (eptr > md->end_subject - length) break;              if (eptr > md->end_subject - length) break;
2379              if (memcmp(eptr, charptr, length) == 0) eptr += length;              if (memcmp(eptr, charptr, length) == 0) eptr += length;
2380    #ifdef SUPPORT_UCP
2381              else if (oclength == 0) break;              else if (oclength == 0) break;
2382              else              else
2383                {                {
2384                if (memcmp(eptr, occhars, oclength) != 0) break;                if (memcmp(eptr, occhars, oclength) != 0) break;
2385                eptr += oclength;                eptr += oclength;
2386                }                }
2387    #else   /* without SUPPORT_UCP */
2388                else break;
2389    #endif  /* SUPPORT_UCP */
2390              }              }
2391            while (eptr >= pp)  
2392              if (possessive) continue;
2393              for(;;)
2394             {             {
2395             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2396             if (rrc != MATCH_NOMATCH) RRETURN(rrc);             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2397               if (eptr == pp) RRETURN(MATCH_NOMATCH);
2398    #ifdef SUPPORT_UCP
2399               eptr--;
2400               BACKCHAR(eptr);
2401    #else   /* without SUPPORT_UCP */
2402             eptr -= length;             eptr -= length;
2403    #endif  /* SUPPORT_UCP */
2404             }             }
           RRETURN(MATCH_NOMATCH);  
2405            }            }
2406          /* Control never gets here */          /* Control never gets here */
2407          }          }
# Line 2017  for (;;) Line 2441  for (;;)
2441          {          {
2442          for (fi = min;; fi++)          for (fi = min;; fi++)
2443            {            {
2444            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2445            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2446            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
2447                fc != md->lcc[*eptr++])                fc != md->lcc[*eptr++])
# Line 2025  for (;;) Line 2449  for (;;)
2449            }            }
2450          /* Control never gets here */          /* Control never gets here */
2451          }          }
2452        else        else  /* Maximize */
2453          {          {
2454          pp = eptr;          pp = eptr;
2455          for (i = min; i < max; i++)          for (i = min; i < max; i++)
# Line 2033  for (;;) Line 2457  for (;;)
2457            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
2458            eptr++;            eptr++;
2459            }            }
2460            if (possessive) continue;
2461          while (eptr >= pp)          while (eptr >= pp)
2462            {            {
2463            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
2464            eptr--;            eptr--;
2465            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2466            }            }
# Line 2054  for (;;) Line 2479  for (;;)
2479          {          {
2480          for (fi = min;; fi++)          for (fi = min;; fi++)
2481            {            {
2482            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2483            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2484            if (fi >= max || eptr >= md->end_subject || fc != *eptr++)            if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
2485              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2486            }            }
2487          /* Control never gets here */          /* Control never gets here */
2488          }          }
2489        else        else  /* Maximize */
2490          {          {
2491          pp = eptr;          pp = eptr;
2492          for (i = min; i < max; i++)          for (i = min; i < max; i++)
# Line 2069  for (;;) Line 2494  for (;;)
2494            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject || fc != *eptr) break;
2495            eptr++;            eptr++;
2496            }            }
2497            if (possessive) continue;
2498          while (eptr >= pp)          while (eptr >= pp)
2499            {            {
2500            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
2501            eptr--;            eptr--;
2502            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2503            }            }
# Line 2121  for (;;) Line 2547  for (;;)
2547      ecode += 3;      ecode += 3;
2548      goto REPEATNOTCHAR;      goto REPEATNOTCHAR;
2549    
2550        case OP_NOTPOSSTAR:
2551        possessive = TRUE;
2552        min = 0;
2553        max = INT_MAX;
2554        ecode++;
2555        goto REPEATNOTCHAR;
2556    
2557        case OP_NOTPOSPLUS:
2558        possessive = TRUE;
2559        min = 1;
2560        max = INT_MAX;
2561        ecode++;
2562        goto REPEATNOTCHAR;
2563    
2564        case OP_NOTPOSQUERY:
2565        possessive = TRUE;
2566        min = 0;
2567        max = 1;
2568        ecode++;
2569        goto REPEATNOTCHAR;
2570    
2571        case OP_NOTPOSUPTO:
2572        possessive = TRUE;
2573        min = 0;
2574        max = GET2(ecode, 1);
2575        ecode += 3;
2576        goto REPEATNOTCHAR;
2577    
2578      case OP_NOTSTAR:      case OP_NOTSTAR:
2579      case OP_NOTMINSTAR:      case OP_NOTMINSTAR:
2580      case OP_NOTPLUS:      case OP_NOTPLUS:
# Line 2160  for (;;) Line 2614  for (;;)
2614        /* UTF-8 mode */        /* UTF-8 mode */
2615        if (utf8)        if (utf8)
2616          {          {
2617          register int d;          register unsigned int d;
2618          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2619            {            {
2620            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
# Line 2185  for (;;) Line 2639  for (;;)
2639          /* UTF-8 mode */          /* UTF-8 mode */
2640          if (utf8)          if (utf8)
2641            {            {
2642            register int d;            register unsigned int d;
2643            for (fi = min;; fi++)            for (fi = min;; fi++)
2644              {              {
2645              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
2646              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2647                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2648              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2649              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
2650              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fc == d) RRETURN(MATCH_NOMATCH);
2651                RRETURN(MATCH_NOMATCH);  
2652              }              }
2653            }            }
2654          else          else
# Line 2202  for (;;) Line 2657  for (;;)
2657            {            {
2658            for (fi = min;; fi++)            for (fi = min;; fi++)
2659              {              {
2660              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
2661              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2662              if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])              if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
2663                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2221  for (;;) Line 2676  for (;;)
2676          /* UTF-8 mode */          /* UTF-8 mode */
2677          if (utf8)          if (utf8)
2678            {            {
2679            register int d;            register unsigned int d;
2680            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2681              {              {
2682              int len = 1;              int len = 1;
# Line 2231  for (;;) Line 2686  for (;;)
2686              if (fc == d) break;              if (fc == d) break;
2687              eptr += len;              eptr += len;
2688              }              }
2689            for(;;)          if (possessive) continue;
2690            for(;;)
2691              {              {
2692              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
2693              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2694              if (eptr-- == pp) break;        /* Stop if tried at original pos */              if (eptr-- == pp) break;        /* Stop if tried at original pos */
2695              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2248  for (;;) Line 2704  for (;;)
2704              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
2705              eptr++;              eptr++;
2706              }              }
2707              if (possessive) continue;
2708            while (eptr >= pp)            while (eptr >= pp)
2709              {              {
2710              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);
2711              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2712              eptr--;              eptr--;
2713              }              }
# Line 2269  for (;;) Line 2726  for (;;)
2726        /* UTF-8 mode */        /* UTF-8 mode */
2727        if (utf8)        if (utf8)
2728          {          {
2729          register int d;          register unsigned int d;
2730          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2731            {            {
2732            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
# Line 2292  for (;;) Line 2749  for (;;)
2749          /* UTF-8 mode */          /* UTF-8 mode */
2750          if (utf8)          if (utf8)
2751            {            {
2752            register int d;            register unsigned int d;
2753            for (fi = min;; fi++)            for (fi = min;; fi++)
2754              {              {
2755              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
2756              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2757                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2758              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2759              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fc == d) RRETURN(MATCH_NOMATCH);
               RRETURN(MATCH_NOMATCH);  
2760              }              }
2761            }            }
2762          else          else
# Line 2308  for (;;) Line 2765  for (;;)
2765            {            {
2766            for (fi = min;; fi++)            for (fi = min;; fi++)
2767              {              {
2768              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
2769              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2770              if (fi >= max || eptr >= md->end_subject || fc == *eptr++)              if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
2771                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 2327  for (;;) Line 2784  for (;;)
2784          /* UTF-8 mode */          /* UTF-8 mode */
2785          if (utf8)          if (utf8)
2786            {            {
2787            register int d;            register unsigned int d;
2788            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2789              {              {
2790              int len = 1;              int len = 1;
# Line 2336  for (;;) Line 2793  for (;;)
2793              if (fc == d) break;              if (fc == d) break;
2794              eptr += len;              eptr += len;
2795              }              }
2796              if (possessive) continue;
2797            for(;;)            for(;;)
2798              {              {
2799              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
2800              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2801              if (eptr-- == pp) break;        /* Stop if tried at original pos */              if (eptr-- == pp) break;        /* Stop if tried at original pos */
2802              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2353  for (;;) Line 2811  for (;;)
2811              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject || fc == *eptr) break;
2812              eptr++;              eptr++;
2813              }              }
2814              if (possessive) continue;
2815            while (eptr >= pp)            while (eptr >= pp)
2816              {              {
2817              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);
2818              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2819              eptr--;              eptr--;
2820              }              }
# Line 2384  for (;;) Line 2843  for (;;)
2843      ecode += 3;      ecode += 3;
2844      goto REPEATTYPE;      goto REPEATTYPE;
2845    
2846        case OP_TYPEPOSSTAR:
2847        possessive = TRUE;
2848        min = 0;
2849        max = INT_MAX;
2850        ecode++;
2851        goto REPEATTYPE;
2852    
2853        case OP_TYPEPOSPLUS:
2854        possessive = TRUE;
2855        min = 1;
2856        max = INT_MAX;
2857        ecode++;
2858        goto REPEATTYPE;
2859    
2860        case OP_TYPEPOSQUERY:
2861        possessive = TRUE;
2862        min = 0;
2863        max = 1;
2864        ecode++;
2865        goto REPEATTYPE;
2866    
2867        case OP_TYPEPOSUPTO:
2868        possessive = TRUE;
2869        min = 0;
2870        max = GET2(ecode, 1);
2871        ecode += 3;
2872        goto REPEATTYPE;
2873    
2874      case OP_TYPESTAR:      case OP_TYPESTAR:
2875      case OP_TYPEMINSTAR:      case OP_TYPEMINSTAR:
2876      case OP_TYPEPLUS:      case OP_TYPEPLUS:
# Line 2408  for (;;) Line 2895  for (;;)
2895        {        {
2896        prop_fail_result = ctype == OP_NOTPROP;        prop_fail_result = ctype == OP_NOTPROP;
2897        prop_type = *ecode++;        prop_type = *ecode++;
2898        if (prop_type >= 128)        prop_value = *ecode++;
         {  
         prop_test_against = prop_type - 128;  
         prop_test_variable = &prop_category;  
         }  
       else  
         {  
         prop_test_against = prop_type;  
         prop_test_variable = &prop_chartype;  
         }  
2899        }        }
2900      else prop_type = -1;      else prop_type = -1;
2901  #endif  #endif
# Line 2434  for (;;) Line 2912  for (;;)
2912      if (min > 0)      if (min > 0)
2913        {        {
2914  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2915        if (prop_type > 0)        if (prop_type >= 0)
2916          {          {
2917          for (i = 1; i <= min; i++)          switch(prop_type)
2918            {            {
2919            GETCHARINC(c, eptr);            case PT_ANY:
2920            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
2921            if ((*prop_test_variable == prop_test_against) == prop_fail_result)            for (i = 1; i <= min; i++)
2922              RRETURN(MATCH_NOMATCH);              {
2923                if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2924                GETCHARINCTEST(c, eptr);
2925                }
2926              break;
2927    
2928              case PT_LAMP:
2929              for (i = 1; i <= min; i++)
2930                {
2931                if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2932                GETCHARINCTEST(c, eptr);
2933                prop_chartype = UCD_CHARTYPE(c);
2934                if ((prop_chartype == ucp_Lu ||
2935                     prop_chartype == ucp_Ll ||
2936                     prop_chartype == ucp_Lt) == prop_fail_result)
2937                  RRETURN(MATCH_NOMATCH);
2938                }
2939              break;
2940    
2941              case PT_GC:
2942              for (i = 1; i <= min; i++)
2943                {
2944                if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2945                GETCHARINCTEST(c, eptr);
2946                prop_category = UCD_CATEGORY(c);
2947                if ((prop_category == prop_value) == prop_fail_result)
2948                  RRETURN(MATCH_NOMATCH);
2949                }
2950              break;
2951    
2952              case PT_PC:
2953              for (i = 1; i <= min; i++)
2954                {
2955                if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2956                GETCHARINCTEST(c, eptr);
2957                prop_chartype = UCD_CHARTYPE(c);
2958                if ((prop_chartype == prop_value) == prop_fail_result)
2959                  RRETURN(MATCH_NOMATCH);
2960                }
2961              break;
2962    
2963              case PT_SC:
2964              for (i = 1; i <= min; i++)
2965                {
2966                if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2967                GETCHARINCTEST(c, eptr);
2968                prop_script = UCD_SCRIPT(c);
2969                if ((prop_script == prop_value) == prop_fail_result)
2970                  RRETURN(MATCH_NOMATCH);
2971                }
2972              break;
2973    
2974              default:
2975              RRETURN(PCRE_ERROR_INTERNAL);
2976            }            }
2977          }          }
2978    
# Line 2453  for (;;) Line 2984  for (;;)
2984          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2985            {            {
2986            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2987            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);            prop_category = UCD_CATEGORY(c);
2988            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
2989            while (eptr < md->end_subject)            while (eptr < md->end_subject)
2990              {              {
# Line 2462  for (;;) Line 2993  for (;;)
2993                {                {
2994                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
2995                }                }
2996              prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);              prop_category = UCD_CATEGORY(c);
2997              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
2998              eptr += len;              eptr += len;
2999              }              }
# Line 2480  for (;;) Line 3011  for (;;)
3011          case OP_ANY:          case OP_ANY:
3012          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3013            {            {
3014            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject || IS_NEWLINE(eptr))
              (*eptr++ == NEWLINE && (ims & PCRE_DOTALL) == 0))  
3015              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3016              eptr++;
3017              while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3018              }
3019            break;
3020    
3021            case OP_ALLANY:
3022            for (i = 1; i <= min; i++)
3023              {
3024              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3025              eptr++;
3026            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3027            }            }
3028          break;          break;
# Line 2491  for (;;) Line 3031  for (;;)
3031          eptr += min;          eptr += min;
3032          break;          break;
3033    
3034            case OP_ANYNL:
3035            for (i = 1; i <= min; i++)
3036              {
3037              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3038              GETCHARINC(c, eptr);
3039              switch(c)
3040                {
3041                default: RRETURN(MATCH_NOMATCH);
3042                case 0x000d:
3043                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3044                break;
3045    
3046                case 0x000a:
3047                break;
3048    
3049                case 0x000b:
3050                case 0x000c:
3051                case 0x0085:
3052                case 0x2028:
3053                case 0x2029:
3054                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3055                break;
3056                }
3057              }
3058            break;
3059    
3060            case OP_NOT_HSPACE:
3061            for (i = 1; i <= min; i++)
3062              {
3063              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3064              GETCHARINC(c, eptr);
3065              switch(c)
3066                {
3067                default: break;
3068                case 0x09:      /* HT */
3069                case 0x20:      /* SPACE */
3070                case 0xa0:      /* NBSP */
3071                case 0x1680:    /* OGHAM SPACE MARK */
3072                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3073                case 0x2000:    /* EN QUAD */
3074                case 0x2001:    /* EM QUAD */
3075                case 0x2002:    /* EN SPACE */
3076                case 0x2003:    /* EM SPACE */
3077                case 0x2004:    /* THREE-PER-EM SPACE */
3078                case 0x2005:    /* FOUR-PER-EM SPACE */
3079                case 0x2006:    /* SIX-PER-EM SPACE */
3080                case 0x2007:    /* FIGURE SPACE */
3081                case 0x2008:    /* PUNCTUATION SPACE */
3082                case 0x2009:    /* THIN SPACE */
3083                case 0x200A:    /* HAIR SPACE */
3084                case 0x202f:    /* NARROW NO-BREAK SPACE */
3085                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3086                case 0x3000:    /* IDEOGRAPHIC SPACE */
3087                RRETURN(MATCH_NOMATCH);
3088                }
3089              }
3090            break;
3091    
3092            case OP_HSPACE:
3093            for (i = 1; i <= min; i++)
3094              {
3095              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3096              GETCHARINC(c, eptr);
3097              switch(c)
3098                {
3099                default: RRETURN(MATCH_NOMATCH);
3100                case 0x09:      /* HT */
3101                case 0x20:      /* SPACE */
3102                case 0xa0:      /* NBSP */
3103                case 0x1680:    /* OGHAM SPACE MARK */
3104                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3105                case 0x2000:    /* EN QUAD */
3106                case 0x2001:    /* EM QUAD */
3107                case 0x2002:    /* EN SPACE */
3108                case 0x2003:    /* EM SPACE */
3109                case 0x2004:    /* THREE-PER-EM SPACE */
3110                case 0x2005:    /* FOUR-PER-EM SPACE */
3111                case 0x2006:    /* SIX-PER-EM SPACE */
3112                case 0x2007:    /* FIGURE SPACE */
3113                case 0x2008:    /* PUNCTUATION SPACE */
3114                case 0x2009:    /* THIN SPACE */
3115                case 0x200A:    /* HAIR SPACE */
3116                case 0x202f:    /* NARROW NO-BREAK SPACE */
3117                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3118                case 0x3000:    /* IDEOGRAPHIC SPACE */
3119                break;
3120                }
3121              }
3122            break;
3123    
3124            case OP_NOT_VSPACE:
3125            for (i = 1; i <= min; i++)
3126              {
3127              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3128              GETCHARINC(c, eptr);
3129              switch(c)
3130                {
3131                default: break;
3132                case 0x0a:      /* LF */
3133                case 0x0b:      /* VT */
3134                case 0x0c:      /* FF */
3135                case 0x0d:      /* CR */
3136                case 0x85:      /* NEL */
3137                case 0x2028:    /* LINE SEPARATOR */
3138                case 0x2029:    /* PARAGRAPH SEPARATOR */
3139                RRETURN(MATCH_NOMATCH);
3140                }
3141              }
3142            break;
3143    
3144            case OP_VSPACE:
3145            for (i = 1; i <= min; i++)
3146              {
3147              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3148              GETCHARINC(c, eptr);
3149              switch(c)
3150                {
3151                default: RRETURN(MATCH_NOMATCH);
3152                case 0x0a:      /* LF */
3153                case 0x0b:      /* VT */
3154                case 0x0c:      /* FF */
3155                case 0x0d:      /* CR */
3156                case 0x85:      /* NEL */
3157                case 0x2028:    /* LINE SEPARATOR */
3158                case 0x2029:    /* PARAGRAPH SEPARATOR */
3159                break;
3160                }
3161              }
3162            break;
3163    
3164          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3165          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3166            {            {
# Line 2515  for (;;) Line 3185  for (;;)
3185          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3186            {            {
3187            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3188               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
3189              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3190            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3191            }            }
3192          break;          break;
3193    
# Line 2535  for (;;) Line 3205  for (;;)
3205          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3206            {            {
3207            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3208               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
3209              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3210            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3211            }            }
3212          break;          break;
3213    
# Line 2559  for (;;) Line 3229  for (;;)
3229  #endif     /* SUPPORT_UTF8 */  #endif     /* SUPPORT_UTF8 */
3230    
3231        /* 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
3232        than OP_PROP and OP_NOTPROP. */        than OP_PROP and OP_NOTPROP. We can assume that there are the minimum
3233          number of bytes present, as this was tested above. */
3234    
3235        switch(ctype)        switch(ctype)
3236          {          {
3237          case OP_ANY:          case OP_ANY:
3238          if ((ims & PCRE_DOTALL) == 0)          for (i = 1; i <= min; i++)
3239            {            {
3240            for (i = 1; i <= min; i++)            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3241              if (*eptr++ == NEWLINE) RRETURN(MATCH_NOMATCH);            eptr++;
3242            }            }
3243          else eptr += min;          break;
3244    
3245            case OP_ALLANY:
3246            eptr += min;
3247          break;          break;
3248    
3249          case OP_ANYBYTE:          case OP_ANYBYTE:
3250          eptr += min;          eptr += min;
3251          break;          break;
3252    
3253            /* Because of the CRLF case, we can't assume the minimum number of
3254            bytes are present in this case. */
3255    
3256            case OP_ANYNL:
3257            for (i = 1; i <= min; i++)
3258              {
3259              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3260              switch(*eptr++)
3261                {
3262                default: RRETURN(MATCH_NOMATCH);
3263                case 0x000d:
3264                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3265                break;
3266                case 0x000a:
3267                break;
3268    
3269                case 0x000b:
3270                case 0x000c:
3271                case 0x0085:
3272                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3273                break;
3274                }
3275              }
3276            break;
3277    
3278            case OP_NOT_HSPACE:
3279            for (i = 1; i <= min; i++)
3280              {
3281              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3282              switch(*eptr++)
3283                {
3284                default: break;
3285                case 0x09:      /* HT */
3286                case 0x20:      /* SPACE */
3287                case 0xa0:      /* NBSP */
3288                RRETURN(MATCH_NOMATCH);
3289                }
3290              }
3291            break;
3292    
3293            case OP_HSPACE:
3294            for (i = 1; i <= min; i++)
3295              {
3296              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3297              switch(*eptr++)
3298                {
3299                default: RRETURN(MATCH_NOMATCH);
3300                case 0x09:      /* HT */
3301                case 0x20:      /* SPACE */
3302                case 0xa0:      /* NBSP */
3303                break;
3304                }
3305              }
3306            break;
3307    
3308            case OP_NOT_VSPACE:
3309            for (i = 1; i <= min; i++)
3310              {
3311              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3312              switch(*eptr++)
3313                {
3314                default: break;
3315                case 0x0a:      /* LF */
3316                case 0x0b:      /* VT */
3317                case 0x0c:      /* FF */
3318                case 0x0d:      /* CR */
3319                case 0x85:      /* NEL */
3320                RRETURN(MATCH_NOMATCH);
3321                }
3322              }
3323            break;
3324    
3325            case OP_VSPACE:
3326            for (i = 1; i <= min; i++)
3327              {
3328              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3329              switch(*eptr++)
3330                {
3331                default: RRETURN(MATCH_NOMATCH);
3332                case 0x0a:      /* LF */
3333                case 0x0b:      /* VT */
3334                case 0x0c:      /* FF */
3335                case 0x0d:      /* CR */
3336                case 0x85:      /* NEL */
3337                break;
3338                }
3339              }
3340            break;
3341    
3342          case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
3343          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3344            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
# Line 2624  for (;;) Line 3387  for (;;)
3387      if (minimize)      if (minimize)
3388        {        {
3389  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3390        if (prop_type > 0)        if (prop_type >= 0)
3391          {          {
3392          for (fi = min;; fi++)          switch(prop_type)
3393            {            {
3394            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            case PT_ANY:
3395            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            for (fi = min;; fi++)
3396            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              {
3397            GETCHARINC(c, eptr);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
3398            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3399            if ((*prop_test_variable == prop_test_against) == prop_fail_result)              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3400              RRETURN(MATCH_NOMATCH);              GETCHARINC(c, eptr);
3401            }              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3402          }              }
3403              /* Control never gets here */
3404    
3405              case PT_LAMP:
3406              for (fi = min;; fi++)
3407                {
3408                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
3409                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3410                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3411                GETCHARINC(c, eptr);
3412                prop_chartype = UCD_CHARTYPE(c);
3413                if ((prop_chartype == ucp_Lu ||
3414                     prop_chartype == ucp_Ll ||
3415                     prop_chartype == ucp_Lt) == prop_fail_result)
3416                  RRETURN(MATCH_NOMATCH);
3417                }
3418              /* Control never gets here */
3419    
3420              case PT_GC:
3421              for (fi = min;; fi++)
3422                {
3423                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
3424                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3425                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3426                GETCHARINC(c, eptr);
3427                prop_category = UCD_CATEGORY(c);
3428                if ((prop_category == prop_value) == prop_fail_result)
3429                  RRETURN(MATCH_NOMATCH);
3430                }
3431              /* Control never gets here */
3432    
3433              case PT_PC:
3434              for (fi = min;; fi++)
3435                {
3436                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
3437                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3438                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3439                GETCHARINC(c, eptr);
3440                prop_chartype = UCD_CHARTYPE(c);
3441                if ((prop_chartype == prop_value) == prop_fail_result)
3442                  RRETURN(MATCH_NOMATCH);
3443                }
3444              /* Control never gets here */
3445    
3446              case PT_SC:
3447              for (fi = min;; fi++)
3448                {
3449                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
3450                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3451                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3452                GETCHARINC(c, eptr);
3453                prop_script = UCD_SCRIPT(c);
3454                if ((prop_script == prop_value) == prop_fail_result)
3455                  RRETURN(MATCH_NOMATCH);
3456                }
3457              /* Control never gets here */
3458    
3459              default:
3460              RRETURN(PCRE_ERROR_INTERNAL);
3461              }
3462            }
3463    
3464        /* Match extended Unicode sequences. We will get here only if the        /* Match extended Unicode sequences. We will get here only if the
3465        support is in the binary; otherwise a compile-time error occurs. */        support is in the binary; otherwise a compile-time error occurs. */
# Line 2645  for (;;) Line 3468  for (;;)
3468          {          {
3469          for (fi = min;; fi++)          for (fi = min;; fi++)
3470            {            {
3471            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
3472            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3473            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3474            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3475            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);            prop_category = UCD_CATEGORY(c);
3476            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
3477            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3478              {              {
# Line 2658  for (;;) Line 3481  for (;;)
3481                {                {
3482                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3483                }                }
3484              prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);              prop_category = UCD_CATEGORY(c);
3485              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3486              eptr += len;              eptr += len;
3487              }              }
# Line 2674  for (;;) Line 3497  for (;;)
3497          {          {
3498          for (fi = min;; fi++)          for (fi = min;; fi++)
3499            {            {
3500            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
3501            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3502            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject ||
3503                   (ctype == OP_ANY && IS_NEWLINE(eptr)))
3504                RRETURN(MATCH_NOMATCH);
3505    
3506            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3507            switch(ctype)            switch(ctype)
3508              {              {
3509              case OP_ANY:              case OP_ANY:        /* This is the non-NL case */
3510              if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);              case OP_ALLANY:
3511                case OP_ANYBYTE:
3512              break;              break;
3513    
3514              case OP_ANYBYTE:              case OP_ANYNL:
3515                switch(c)
3516                  {
3517                  default: RRETURN(MATCH_NOMATCH);
3518                  case 0x000d:
3519                  if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3520                  break;
3521                  case 0x000a:
3522                  break;
3523    
3524                  case 0x000b:
3525                  case 0x000c:
3526                  case 0x0085:
3527                  case 0x2028:
3528                  case 0x2029:
3529                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3530                  break;
3531                  }
3532                break;
3533    
3534                case OP_NOT_HSPACE:
3535                switch(c)
3536                  {
3537                  default: break;
3538                  case 0x09:      /* HT */
3539                  case 0x20:      /* SPACE */
3540                  case 0xa0:      /* NBSP */
3541                  case 0x1680:    /* OGHAM SPACE MARK */
3542                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3543                  case 0x2000:    /* EN QUAD */
3544                  case 0x2001:    /* EM QUAD */
3545                  case 0x2002:    /* EN SPACE */
3546                  case 0x2003:    /* EM SPACE */
3547                  case 0x2004:    /* THREE-PER-EM SPACE */
3548                  case 0x2005:    /* FOUR-PER-EM SPACE */
3549                  case 0x2006:    /* SIX-PER-EM SPACE */
3550                  case 0x2007:    /* FIGURE SPACE */
3551                  case 0x2008:    /* PUNCTUATION SPACE */
3552                  case 0x2009:    /* THIN SPACE */
3553                  case 0x200A:    /* HAIR SPACE */
3554                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3555                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3556                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3557                  RRETURN(MATCH_NOMATCH);
3558                  }
3559                break;
3560    
3561                case OP_HSPACE:
3562                switch(c)
3563                  {
3564                  default: RRETURN(MATCH_NOMATCH);
3565                  case 0x09:      /* HT */
3566                  case 0x20:      /* SPACE */
3567                  case 0xa0:      /* NBSP */
3568                  case 0x1680:    /* OGHAM SPACE MARK */
3569                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3570                  case 0x2000:    /* EN QUAD */
3571                  case 0x2001:    /* EM QUAD */
3572                  case 0x2002:    /* EN SPACE */
3573                  case 0x2003:    /* EM SPACE */
3574                  case 0x2004:    /* THREE-PER-EM SPACE */
3575                  case 0x2005:    /* FOUR-PER-EM SPACE */
3576                  case 0x2006:    /* SIX-PER-EM SPACE */
3577                  case 0x2007:    /* FIGURE SPACE */
3578                  case 0x2008:    /* PUNCTUATION SPACE */
3579                  case 0x2009:    /* THIN SPACE */
3580                  case 0x200A:    /* HAIR SPACE */
3581                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3582                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3583                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3584                  break;
3585                  }
3586                break;
3587    
3588                case OP_NOT_VSPACE:
3589                switch(c)
3590                  {
3591                  default: break;
3592                  case 0x0a:      /* LF */
3593                  case 0x0b:      /* VT */
3594                  case 0x0c:      /* FF */
3595                  case 0x0d:      /* CR */
3596                  case 0x85:      /* NEL */
3597                  case 0x2028:    /* LINE SEPARATOR */
3598                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3599                  RRETURN(MATCH_NOMATCH);
3600                  }
3601                break;
3602    
3603                case OP_VSPACE:
3604                switch(c)
3605                  {
3606                  default: RRETURN(MATCH_NOMATCH);
3607                  case 0x0a:      /* LF */
3608                  case 0x0b:      /* VT */
3609                  case 0x0c:      /* FF */
3610                  case 0x0d:      /* CR */
3611                  case 0x85:      /* NEL */
3612                  case 0x2028:    /* LINE SEPARATOR */
3613                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3614                  break;
3615                  }
3616              break;              break;
3617    
3618              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
# Line 2729  for (;;) Line 3656  for (;;)
3656          {          {
3657          for (fi = min;; fi++)          for (fi = min;; fi++)
3658            {            {
3659            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
3660            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3661            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject ||
3662                   (ctype == OP_ANY && IS_NEWLINE(eptr)))
3663                RRETURN(MATCH_NOMATCH);
3664    
3665            c = *eptr++;            c = *eptr++;
3666            switch(ctype)            switch(ctype)
3667              {              {
3668              case OP_ANY:              case OP_ANY:     /* This is the non-NL case */
3669              if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);              case OP_ALLANY:
3670                case OP_ANYBYTE:
3671              break;              break;
3672    
3673              case OP_ANYBYTE:              case OP_ANYNL:
3674                switch(c)
3675                  {
3676                  default: RRETURN(MATCH_NOMATCH);
3677                  case 0x000d:
3678                  if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3679                  break;
3680    
3681                  case 0x000a:
3682                  break;
3683    
3684                  case 0x000b:
3685                  case 0x000c:
3686                  case 0x0085:
3687                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3688                  break;
3689                  }
3690                break;
3691    
3692                case OP_NOT_HSPACE:
3693                switch(c)
3694                  {
3695                  default: break;
3696                  case 0x09:      /* HT */
3697                  case 0x20:      /* SPACE */
3698                  case 0xa0:      /* NBSP */
3699                  RRETURN(MATCH_NOMATCH);
3700                  }
3701                break;
3702    
3703                case OP_HSPACE:
3704                switch(c)
3705                  {
3706                  default: RRETURN(MATCH_NOMATCH);
3707                  case 0x09:      /* HT */
3708                  case 0x20:      /* SPACE */
3709                  case 0xa0:      /* NBSP */
3710                  break;
3711                  }
3712                break;
3713    
3714                case OP_NOT_VSPACE:
3715                switch(c)
3716                  {
3717                  default: break;
3718                  case 0x0a:      /* LF */
3719                  case 0x0b:      /* VT */
3720                  case 0x0c:      /* FF */
3721                  case 0x0d:      /* CR */
3722                  case 0x85:      /* NEL */
3723                  RRETURN(MATCH_NOMATCH);
3724                  }
3725                break;
3726    
3727                case OP_VSPACE:
3728                switch(c)
3729                  {
3730                  default: RRETURN(MATCH_NOMATCH);
3731                  case 0x0a:      /* LF */
3732                  case 0x0b:      /* VT */
3733                  case 0x0c:      /* FF */
3734                  case 0x0d:      /* CR */
3735                  case 0x85:      /* NEL */
3736                  break;
3737                  }
3738              break;              break;
3739    
3740              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
# Line 2774  for (;;) Line 3769  for (;;)
3769        /* Control never gets here */        /* Control never gets here */
3770        }        }
3771    
3772      /* 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
3773      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
3774      UTF-8 and UCP stuff separate. */      UTF-8 and UCP stuff separate. */
3775    
# Line 2783  for (;;) Line 3778  for (;;)
3778        pp = eptr;  /* Remember where we started */        pp = eptr;  /* Remember where we started */
3779    
3780  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3781        if (prop_type > 0)        if (prop_type >= 0)
3782          {          {
3783          for (i = min; i < max; i++)          switch(prop_type)
3784            {            {
3785            int len = 1;            case PT_ANY:
3786            if (eptr >= md->end_subject) break;            for (i = min; i < max; i++)
3787            GETCHARLEN(c, eptr, len);              {
3788            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);              int len = 1;
3789            if ((*prop_test_variable == prop_test_against) == prop_fail_result)              if (eptr >= md->end_subject) break;
3790              break;              GETCHARLEN(c, eptr, len);
3791            eptr+= len;              if (prop_fail_result) break;
3792                eptr+= len;
3793                }
3794              break;
3795    
3796              case PT_LAMP:
3797              for (i = min; i < max; i++)
3798                {
3799                int len = 1;
3800                if (eptr >= md->end_subject) break;
3801                GETCHARLEN(c, eptr, len);
3802                prop_chartype = UCD_CHARTYPE(c);
3803                if ((prop_chartype == ucp_Lu ||
3804                     prop_chartype == ucp_Ll ||
3805                     prop_chartype == ucp_Lt) == prop_fail_result)
3806                  break;
3807                eptr+= len;
3808                }
3809              break;
3810    
3811              case PT_GC:
3812              for (i = min; i < max; i++)
3813                {
3814                int len = 1;
3815                if (eptr >= md->end_subject) break;
3816                GETCHARLEN(c, eptr, len);
3817                prop_category = UCD_CATEGORY(c);
3818                if ((prop_category == prop_value) == prop_fail_result)
3819                  break;
3820                eptr+= len;
3821                }
3822              break;
3823    
3824              case PT_PC:
3825              for (i = min; i < max; i++)
3826                {
3827                int len = 1;
3828                if (eptr >= md->end_subject) break;
3829                GETCHARLEN(c, eptr, len);
3830                prop_chartype = UCD_CHARTYPE(c);
3831                if ((prop_chartype == prop_value) == prop_fail_result)
3832                  break;
3833                eptr+= len;
3834                }
3835              break;
3836    
3837              case PT_SC:
3838              for (i = min; i < max; i++)
3839                {
3840                int len = 1;
3841                if (eptr >= md->end_subject) break;
3842                GETCHARLEN(c, eptr, len);
3843                prop_script = UCD_SCRIPT(c);
3844                if ((prop_script == prop_value) == prop_fail_result)
3845                  break;
3846                eptr+= len;
3847                }
3848              break;
3849            }            }
3850    
3851          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
3852    
3853            if (possessive) continue;
3854          for(;;)          for(;;)
3855            {            {
3856            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
3857            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3858            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3859            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3860            }            }
3861          }          }
3862    
# Line 2816  for (;;) Line 3869  for (;;)
3869            {            {
3870            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject) break;
3871            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3872            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);            prop_category = UCD_CATEGORY(c);
3873            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
3874            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3875              {              {
# Line 2825  for (;;) Line 3878  for (;;)
3878                {                {
3879                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3880                }                }
3881              prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);              prop_category = UCD_CATEGORY(c);
3882              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3883              eptr += len;              eptr += len;
3884              }              }
# Line 2833  for (;;) Line 3886  for (;;)
3886    
3887          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
3888    
3889            if (possessive) continue;
3890          for(;;)          for(;;)
3891            {            {
3892            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
3893            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3894            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3895            for (;;)                        /* Move back over one extended */            for (;;)                        /* Move back over one extended */
3896              {              {
3897              int len = 1;              int len = 1;
             BACKCHAR(eptr);  
3898              if (!utf8) c = *eptr; else              if (!utf8) c = *eptr; else
3899                {                {
3900                  BACKCHAR(eptr);
3901                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3902                }                }
3903              prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);              prop_category = UCD_CATEGORY(c);
3904              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3905              eptr--;              eptr--;
3906              }              }
# Line 2864  for (;;) Line 3918  for (;;)
3918          switch(ctype)          switch(ctype)
3919            {            {
3920            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. */  
   
3921            if (max < INT_MAX)            if (max < INT_MAX)
3922              {              {
3923              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
               {  
               for (i = min; i < max; i++)  
                 {  
                 if (eptr >= md->end_subject || *eptr == NEWLINE) break;  
                 eptr++;  
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
               }  
             else  
3924                {                {
3925                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3926                  {                eptr++;
3927                  eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
3928                }                }
3929              }              }
3930    
# Line 2894  for (;;) Line 3932  for (;;)
3932    
3933            else            else
3934              {              {
3935              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
3936                {                {
3937                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3938                  {                eptr++;
3939                  if (eptr >= md->end_subject || *eptr == NEWLINE) break;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                 eptr++;  
                 }  
               break;  
3940                }                }
3941              else              }
3942              break;
3943    
3944              case OP_ALLANY:
3945              if (max < INT_MAX)
3946                {
3947                for (i = min; i < max; i++)
3948                {                {
3949                c = max - min;                if (eptr >= md->end_subject) break;
3950                if (c > md->end_subject - eptr) c = md->end_subject - eptr;                eptr++;
3951                eptr += c;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3952                }                }
3953              }              }
3954              else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
3955            break;            break;
3956    
3957            /* The byte case is the same as non-UTF8 */            /* The byte case is the same as non-UTF8 */
3958    
3959            case OP_ANYBYTE:            case OP_ANYBYTE:
3960            c = max - min;            c = max - min;
3961            if (c > md->end_subject - eptr) c = md->end_subject - eptr;            if (c > (unsigned int)(md->end_subject - eptr))
3962                c = md->end_subject - eptr;
3963            eptr += c;            eptr += c;
3964            break;            break;
3965    
3966              case OP_ANYNL:
3967              for (i = min; i < max; i++)
3968                {
3969                int len = 1;
3970                if (eptr >= md->end_subject) break;
3971                GETCHARLEN(c, eptr, len);
3972                if (c == 0x000d)
3973                  {
3974                  if (++eptr >= md->end_subject) break;
3975                  if (*eptr == 0x000a) eptr++;
3976                  }
3977                else
3978                  {
3979                  if (c != 0x000a &&
3980                      (md->bsr_anycrlf ||
3981                       (c != 0x000b && c != 0x000c &&
3982                        c != 0x0085 && c != 0x2028 && c != 0x2029)))
3983                    break;
3984                  eptr += len;
3985                  }
3986                }
3987              break;
3988    
3989              case OP_NOT_HSPACE:
3990              case OP_HSPACE:
3991              for (i = min; i < max; i++)
3992                {
3993                BOOL gotspace;
3994                int len = 1;
3995                if (eptr >= md->end_subject) break;
3996                GETCHARLEN(c, eptr, len);
3997                switch(c)
3998                  {
3999                  default: gotspace = FALSE; break;
4000                  case 0x09:      /* HT */
4001                  case 0x20:      /* SPACE */
4002                  case 0xa0:      /* NBSP */
4003                  case 0x1680:    /* OGHAM SPACE MARK */
4004                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
4005                  case 0x2000:    /* EN QUAD */
4006                  case 0x2001:    /* EM QUAD */
4007                  case 0x2002:    /* EN SPACE */
4008                  case 0x2003:    /* EM SPACE */
4009                  case 0x2004:    /* THREE-PER-EM SPACE */
4010                  case 0x2005:    /* FOUR-PER-EM SPACE */
4011                  case 0x2006:    /* SIX-PER-EM SPACE */
4012                  case 0x2007:    /* FIGURE SPACE */
4013                  case 0x2008:    /* PUNCTUATION SPACE */
4014                  case 0x2009:    /* THIN SPACE */
4015                  case 0x200A:    /* HAIR SPACE */
4016                  case 0x202f:    /* NARROW NO-BREAK SPACE */
4017                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4018                  case 0x3000:    /* IDEOGRAPHIC SPACE */
4019                  gotspace = TRUE;
4020                  break;
4021                  }
4022                if (gotspace == (ctype == OP_NOT_HSPACE)) break;
4023                eptr += len;
4024                }
4025              break;
4026    
4027              case OP_NOT_VSPACE:
4028              case OP_VSPACE:
4029              for (i = min; i < max; i++)
4030                {
4031                BOOL gotspace;
4032                int len = 1;
4033                if (eptr >= md->end_subject) break;
4034                GETCHARLEN(c, eptr, len);
4035                switch(c)
4036                  {
4037                  default: gotspace = FALSE; break;
4038                  case 0x0a:      /* LF */
4039                  case 0x0b:      /* VT */
4040                  case 0x0c:      /* FF */
4041                  case 0x0d:      /* CR */
4042                  case 0x85:      /* NEL */
4043                  case 0x2028:    /* LINE SEPARATOR */
4044                  case 0x2029:    /* PARAGRAPH SEPARATOR */
4045                  gotspace = TRUE;
4046                  break;
4047                  }
4048                if (gotspace == (ctype == OP_NOT_VSPACE)) break;
4049                eptr += len;
4050                }
4051              break;
4052    
4053            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4054            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4055              {              {
# Line 2992  for (;;) Line 4122  for (;;)
4122    
4123          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4124    
4125            if (possessive) continue;
4126          for(;;)          for(;;)
4127            {            {
4128            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM46);
4129            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4130            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
4131            BACKCHAR(eptr);            BACKCHAR(eptr);
4132            }            }
4133          }          }
4134        else        else
4135  #endif  #endif  /* SUPPORT_UTF8 */
4136    
4137        /* Not UTF-8 mode */        /* Not UTF-8 mode */
4138          {          {
4139          switch(ctype)          switch(ctype)
4140            {            {
4141            case OP_ANY:            case OP_ANY:
4142            if ((ims & PCRE_DOTALL) == 0)            for (i = min; i < max; i++)
4143              {              {
4144              for (i = min; i < max; i++)              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
4145                {              eptr++;
               if (eptr >= md->end_subject || *eptr == NEWLINE) break;  
               eptr++;  
               }  
             break;  
4146              }              }
4147            /* For DOTALL case, fall through and treat as \C */            break;
4148    
4149              case OP_ALLANY:
4150            case OP_ANYBYTE:            case OP_ANYBYTE:
4151            c = max - min;            c = max - min;
4152            if (c > md->end_subject - eptr) c = md->end_subject - eptr;            if (c > (unsigned int)(md->end_subject - eptr))
4153                c = md->end_subject - eptr;
4154            eptr += c;            eptr += c;
4155            break;            break;
4156    
4157              case OP_ANYNL:
4158              for (i = min; i < max; i++)
4159                {
4160                if (eptr >= md->end_subject) break;
4161                c = *eptr;
4162                if (c == 0x000d)
4163                  {
4164                  if (++eptr >= md->end_subject) break;
4165                  if (*eptr == 0x000a) eptr++;
4166                  }
4167                else
4168                  {
4169                  if (c != 0x000a &&
4170                      (md->bsr_anycrlf ||
4171                        (c != 0x000b && c != 0x000c && c != 0x0085)))
4172                    break;
4173                  eptr++;
4174                  }
4175                }
4176              break;
4177    
4178              case OP_NOT_HSPACE:
4179              for (i = min; i < max; i++)
4180                {
4181                if (eptr >= md->end_subject) break;
4182                c = *eptr;
4183                if (c == 0x09 || c == 0x20 || c == 0xa0) break;
4184                eptr++;
4185                }
4186              break;
4187    
4188              case OP_HSPACE:
4189              for (i = min; i < max; i++)
4190                {
4191                if (eptr >= md->end_subject) break;
4192                c = *eptr;
4193                if (c != 0x09 && c != 0x20 && c != 0xa0) break;
4194                eptr++;
4195                }
4196              break;
4197    
4198              case OP_NOT_VSPACE:
4199              for (i = min; i < max; i++)
4200                {
4201                if (eptr >= md->end_subject) break;
4202                c = *eptr;
4203                if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
4204                  break;
4205                eptr++;
4206                }
4207              break;
4208    
4209              case OP_VSPACE:
4210              for (i = min; i < max; i++)
4211                {
4212                if (eptr >= md->end_subject) break;
4213                c = *eptr;
4214                if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
4215                  break;
4216                eptr++;
4217                }
4218              break;
4219    
4220            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4221            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4222              {              {
# Line 3085  for (;;) Line 4277  for (;;)
4277    
4278          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4279    
4280            if (possessive) continue;
4281          while (eptr >= pp)          while (eptr >= pp)
4282            {            {
4283            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM47);
4284            eptr--;            eptr--;
4285            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4286            }            }
# Line 3099  for (;;) Line 4292  for (;;)
4292        }        }
4293      /* Control never gets here */      /* Control never gets here */
4294    
4295      /* 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
4296      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. */  
4297    
4298      default:      default:
4299      DPRINTF(("Unknown opcode %d\n", *ecode));      DPRINTF(("Unknown opcode %d\n", *ecode));
4300      RRETURN(PCRE_ERROR_UNKNOWN_NODE);      RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
4301      }      }
4302    
4303    /* 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 3115  for (;;) Line 4306  for (;;)
4306    
4307    }             /* End of main loop */    }             /* End of main loop */
4308  /* Control never reaches here */  /* Control never reaches here */
4309    
4310    
4311    /* When compiling to use the heap rather than the stack for recursive calls to
4312    match(), the RRETURN() macro jumps here. The number that is saved in
4313    frame->Xwhere indicates which label we actually want to return to. */
4314    
4315    #ifdef NO_RECURSE
4316    #define LBL(val) case val: goto L_RM##val;
4317    HEAP_RETURN:
4318    switch (frame->Xwhere)
4319      {
4320      LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
4321      LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
4322      LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
4323      LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
4324      LBL(53) LBL(54)
4325    #ifdef SUPPORT_UTF8
4326      LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
4327      LBL(32) LBL(34) LBL(42) LBL(46)
4328    #ifdef SUPPORT_UCP
4329      LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
4330    #endif  /* SUPPORT_UCP */
4331    #endif  /* SUPPORT_UTF8 */
4332      default:
4333      DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
4334      return PCRE_ERROR_INTERNAL;
4335      }
4336    #undef LBL
4337    #endif  /* NO_RECURSE */
4338  }  }
4339    
4340    
# Line 3127  Undefine all the macros that were define Line 4347  Undefine all the macros that were define
4347  #ifdef NO_RECURSE  #ifdef NO_RECURSE
4348  #undef eptr  #undef eptr
4349  #undef ecode  #undef ecode
4350    #undef mstart
4351  #undef offset_top  #undef offset_top
4352  #undef ims  #undef ims
4353  #undef eptrb  #undef eptrb
# Line 3144  Undefine all the macros that were define Line 4365  Undefine all the macros that were define
4365    
4366  #undef cur_is_word  #undef cur_is_word
4367  #undef condition  #undef condition
 #undef minimize  
4368  #undef prev_is_word  #undef prev_is_word
4369    
4370  #undef original_ims  #undef original_ims
# Line 3200  Returns:          > 0 => success; value Line 4420  Returns:          > 0 => success; value
4420                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
4421  */  */
4422    
4423  EXPORT int  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
4424  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
4425    const char *subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
4426    int offsetcount)    int offsetcount)
4427  {  {
4428  int rc, resetcount, ocount;  int rc, resetcount, ocount;
4429  int first_byte = -1;  int first_byte = -1;
4430  int req_byte = -1;  int req_byte = -1;
4431  int req_byte2 = -1;  int req_byte2 = -1;
4432  unsigned long int ims = 0;  int newline;
4433    unsigned long int ims;
4434  BOOL using_temporary_offsets = FALSE;  BOOL using_temporary_offsets = FALSE;
4435  BOOL anchored;  BOOL anchored;
4436  BOOL startline;  BOOL startline;
4437  BOOL firstline;  BOOL firstline;
4438  BOOL first_byte_caseless = FALSE;  BOOL first_byte_caseless = FALSE;
4439  BOOL req_byte_caseless = FALSE;  BOOL req_byte_caseless = FALSE;
4440    BOOL utf8;
4441  match_data match_block;  match_data match_block;
4442    match_data *md = &match_block;
4443  const uschar *tables;  const uschar *tables;
4444  const uschar *start_bits = NULL;  const uschar *start_bits = NULL;
4445  const uschar *start_match = (const uschar *)subject + start_offset;  USPTR start_match = (USPTR)subject + start_offset;
4446  const uschar *end_subject;  USPTR end_subject;
4447  const uschar *req_byte_ptr = start_match - 1;  USPTR req_byte_ptr = start_match - 1;
4448    
4449  pcre_study_data internal_study;  pcre_study_data internal_study;
4450  const pcre_study_data *study;  const pcre_study_data *study;
# Line 3241  if (offsetcount < 0) return PCRE_ERROR_B Line 4464  if (offsetcount < 0) return PCRE_ERROR_B
4464  the default values. */  the default values. */
4465    
4466  study = NULL;  study = NULL;
4467  match_block.match_limit = MATCH_LIMIT;  md->match_limit = MATCH_LIMIT;
4468  match_block.callout_data = NULL;  md->match_limit_recursion = MATCH_LIMIT_RECURSION;
4469    md->callout_data = NULL;
4470    
4471  /* The table pointer is always in native byte order. */  /* The table pointer is always in native byte order. */
4472    
# Line 3254  if (extra_data != NULL) Line 4478  if (extra_data != NULL)
4478    if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)    if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
4479      study = (const pcre_study_data *)extra_data->study_data;      study = (const pcre_study_data *)extra_data->study_data;
4480    if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)    if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
4481      match_block.match_limit = extra_data->match_limit;      md->match_limit = extra_data->match_limit;
4482      if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
4483        md->match_limit_recursion = extra_data->match_limit_recursion;
4484    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
4485      match_block.callout_data = extra_data->callout_data;      md->callout_data = extra_data->callout_data;
4486    if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;    if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
4487    }    }
4488    
# Line 3281  if (re->magic_number != MAGIC_NUMBER) Line 4507  if (re->magic_number != MAGIC_NUMBER)
4507  /* Set up other data */  /* Set up other data */
4508    
4509  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
4510  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
4511  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
4512    
4513  /* The code starts after the real_pcre block and the capture name table. */  /* The code starts after the real_pcre block and the capture name table. */
4514    
4515  match_block.start_code = (const uschar *)external_re + re->name_table_offset +  md->start_code = (const uschar *)external_re + re->name_table_offset +
4516    re->name_count * re->name_entry_size;    re->name_count * re->name_entry_size;
4517    
4518  match_block.start_subject = (const uschar *)subject;  md->start_subject = (USPTR)subject;
4519  match_block.start_offset = start_offset;  md->start_offset = start_offset;
4520  match_block.end_subject = match_block.start_subject + length;  md->end_subject = md->start_subject + length;
4521  end_subject = match_block.end_subject;  end_subject = md->end_subject;
4522    
4523  match_block.endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
4524  match_block.utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
4525    md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
4526  match_block.notbol = (options & PCRE_NOTBOL) != 0;  
4527  match_block.noteol = (options & PCRE_NOTEOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
4528  match_block.notempty = (options & PCRE_NOTEMPTY) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
4529  match_block.partial = (options & PCRE_PARTIAL) != 0;  md->notempty = (options & PCRE_NOTEMPTY) != 0;
4530  match_block.hitend = FALSE;  md->partial = (options & PCRE_PARTIAL) != 0;
4531    md->hitend = FALSE;
4532    
4533    md->recursive = NULL;                   /* No recursion at top level */
4534    
4535    md->lcc = tables + lcc_offset;
4536    md->ctypes = tables + ctypes_offset;
4537    
4538    /* Handle different \R options. */
4539    
4540    switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
4541      {
4542      case 0:
4543      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
4544        md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
4545      else
4546    #ifdef BSR_ANYCRLF
4547      md->bsr_anycrlf = TRUE;
4548    #else
4549      md->bsr_anycrlf = FALSE;
4550    #endif
4551      break;
4552    
4553      case PCRE_BSR_ANYCRLF:
4554      md->bsr_anycrlf = TRUE;
4555      break;
4556    
4557      case PCRE_BSR_UNICODE:
4558      md->bsr_anycrlf = FALSE;
4559      break;
4560    
4561  match_block.recursive = NULL;                   /* No recursion at top level */    default: return PCRE_ERROR_BADNEWLINE;
4562      }
4563    
4564  match_block.lcc = tables + lcc_offset;  /* Handle different types of newline. The three bits give eight cases. If
4565  match_block.ctypes = tables + ctypes_offset;  nothing is set at run time, whatever was used at compile time applies. */
4566    
4567    switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
4568            (pcre_uint32)options) & PCRE_NEWLINE_BITS)
4569      {
4570      case 0: newline = NEWLINE; break;   /* Compile-time default */
4571      case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
4572      case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
4573      case PCRE_NEWLINE_CR+
4574           PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
4575      case PCRE_NEWLINE_ANY: newline = -1; break;
4576      case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
4577      default: return PCRE_ERROR_BADNEWLINE;
4578      }
4579    
4580    if (newline == -2)
4581      {
4582      md->nltype = NLTYPE_ANYCRLF;
4583      }
4584    else if (newline < 0)
4585      {
4586      md->nltype = NLTYPE_ANY;
4587      }
4588    else
4589      {
4590      md->nltype = NLTYPE_FIXED;
4591      if (newline > 255)
4592        {
4593        md->nllen = 2;
4594        md->nl[0] = (newline >> 8) & 255;
4595        md->nl[1] = newline & 255;
4596        }
4597      else
4598        {
4599        md->nllen = 1;
4600        md->nl[0] = newline;
4601        }
4602      }
4603    
4604  /* 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
4605  moment. */  moment. */
4606    
4607  if (match_block.partial && (re->options & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
4608    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
4609    
4610  /* Check a UTF-8 string if required. Unfortunately there's no way of passing  /* Check a UTF-8 string if required. Unfortunately there's no way of passing
4611  back the character offset. */  back the character offset. */
4612    
4613  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
4614  if (match_block.utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
4615    {    {
4616    if (_pcre_valid_utf8((uschar *)subject, length) >= 0)    if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
4617      return PCRE_ERROR_BADUTF8;      return PCRE_ERROR_BADUTF8;
# Line 3350  ocount = offset