061013a63b704ba993ba4466717ea20e0c9d9b04
[WebKit-https.git] / JavaScriptCore / pcre / pcre_exec.c
1 /*************************************************
2 *      Perl-Compatible Regular Expressions       *
3 *************************************************/
4
5 /* PCRE is a library of functions to support regular expressions whose syntax
6 and semantics are as close as possible to those of the Perl 5 language.
7
8                        Written by Philip Hazel
9            Copyright (c) 1997-2005 University of Cambridge
10
11 -----------------------------------------------------------------------------
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions are met:
14
15     * Redistributions of source code must retain the above copyright notice,
16       this list of conditions and the following disclaimer.
17
18     * Redistributions in binary form must reproduce the above copyright
19       notice, this list of conditions and the following disclaimer in the
20       documentation and/or other materials provided with the distribution.
21
22     * Neither the name of the University of Cambridge nor the names of its
23       contributors may be used to endorse or promote products derived from
24       this software without specific prior written permission.
25
26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 POSSIBILITY OF SUCH DAMAGE.
37 -----------------------------------------------------------------------------
38 */
39
40
41 /* This module contains pcre_exec(), the externally visible function that does
42 pattern matching using an NFA algorithm, trying to mimic Perl as closely as
43 possible. There are also some static supporting functions. */
44
45
46 #include "pcre_internal.h"
47
48
49 /* Structure for building a chain of data that actually lives on the
50 stack, for holding the values of the subject pointer at the start of each
51 subpattern, so as to detect when an empty string has been matched by a
52 subpattern - to break infinite loops. When NO_RECURSE is set, these blocks
53 are on the heap, not on the stack. */
54
55 typedef struct eptrblock {
56   struct eptrblock *epb_prev;
57   const pcre_uchar *epb_saved_eptr;
58 } eptrblock;
59
60 /* Flag bits for the match() function */
61
62 #define match_condassert   0x01    /* Called to check a condition assertion */
63 #define match_isgroup      0x02    /* Set if start of bracketed group */
64
65 /* Non-error returns from the match() function. Error returns are externally
66 defined PCRE_ERROR_xxx codes, which are all negative. */
67
68 #define MATCH_MATCH        1
69 #define MATCH_NOMATCH      0
70
71 /* Maximum number of ints of offset to save on the stack for recursive calls.
72 If the offset vector is bigger, malloc is used. This should be a multiple of 3,
73 because the offset vector is always a multiple of 3 long. */
74
75 #define REC_STACK_SAVE_MAX 30
76
77 /* Min and max values for the common repeats; for the maxima, 0 => infinity */
78
79 static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
80 static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
81
82
83
84 #ifdef DEBUG
85 /*************************************************
86 *        Debugging function to print chars       *
87 *************************************************/
88
89 /* Print a sequence of chars in printable format, stopping at the end of the
90 subject if the requested.
91
92 Arguments:
93   p           points to characters
94   length      number to print
95   is_subject  TRUE if printing from within md->start_subject
96   md          pointer to matching data block, if is_subject is TRUE
97
98 Returns:     nothing
99 */
100
101 static void
102 pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
103 {
104 int c;
105 if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
106 while (length-- > 0)
107   if (isprint(c = *(p++))) printf("%c", c);
108 #if PCRE_UTF16
109   else if (c < 256) printf("\\x%02x", c);
110   else printf("\\x{%x}", c);
111 #else
112   else printf("\\x%02x", c);
113 #endif
114 }
115 #endif
116
117
118
119 /*************************************************
120 *          Match a back-reference                *
121 *************************************************/
122
123 /* If a back reference hasn't been set, the length that is passed is greater
124 than the number of characters left in the string, so the match fails.
125
126 Arguments:
127   offset      index into the offset vector
128   eptr        points into the subject
129   length      length to be matched
130   md          points to match data block
131   ims         the ims flags
132
133 Returns:      TRUE if matched
134 */
135
136 static BOOL
137 match_ref(int offset, register const pcre_uchar *eptr, int length, match_data *md,
138   unsigned long int ims)
139 {
140 const pcre_uchar *p = md->start_subject + md->offset_vector[offset];
141
142 #ifdef DEBUG
143 if (eptr >= md->end_subject)
144   printf("matching subject <null>");
145 else
146   {
147   printf("matching subject ");
148   pchars(eptr, length, TRUE, md);
149   }
150 printf(" against backref ");
151 pchars(p, length, FALSE, md);
152 printf("\n");
153 #endif
154
155 /* Always fail if not enough characters left */
156
157 if (length > md->end_subject - eptr) return FALSE;
158
159 /* Separate the caselesss case for speed */
160
161 if ((ims & PCRE_CASELESS) != 0)
162   {
163   while (length-- > 0)
164     if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;
165   }
166 else
167   { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
168
169 return TRUE;
170 }
171
172
173
174 /***************************************************************************
175 ****************************************************************************
176                    RECURSION IN THE match() FUNCTION
177
178 The match() function is highly recursive. Some regular expressions can cause
179 it to recurse thousands of times. I was writing for Unix, so I just let it
180 call itself recursively. This uses the stack for saving everything that has
181 to be saved for a recursive call. On Unix, the stack can be large, and this
182 works fine.
183
184 It turns out that on non-Unix systems there are problems with programs that
185 use a lot of stack. (This despite the fact that every last chip has oodles
186 of memory these days, and techniques for extending the stack have been known
187 for decades.) So....
188
189 There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
190 calls by keeping local variables that need to be preserved in blocks of memory
191 obtained from malloc instead instead of on the stack. Macros are used to
192 achieve this so that the actual code doesn't look very different to what it
193 always used to.
194 ****************************************************************************
195 ***************************************************************************/
196
197
198 /* These versions of the macros use the stack, as normal */
199
200 #ifndef NO_RECURSE
201 #define REGISTER register
202 #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) rx = match(ra,rb,rc,rd,re,rf,rg)
203 #define RRETURN(ra) return ra
204 #else
205
206
207 /* These versions of the macros manage a private stack on the heap. Note
208 that the rd argument of RMATCH isn't actually used. It's the md argument of
209 match(), which never changes. */
210
211 #define REGISTER
212
213 #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\
214   {\
215   heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
216   if (setjmp(frame->Xwhere) == 0)\
217     {\
218     newframe->Xeptr = ra;\
219     newframe->Xecode = rb;\
220     newframe->Xoffset_top = rc;\
221     newframe->Xims = re;\
222     newframe->Xeptrb = rf;\
223     newframe->Xflags = rg;\
224     newframe->Xprevframe = frame;\
225     frame = newframe;\
226     DPRINTF(("restarting from line %d\n", __LINE__));\
227     goto HEAP_RECURSE;\
228     }\
229   else\
230     {\
231     DPRINTF(("longjumped back to line %d\n", __LINE__));\
232     frame = md->thisframe;\
233     rx = frame->Xresult;\
234     }\
235   }
236
237 #define RRETURN(ra)\
238   {\
239   heapframe *newframe = frame;\
240   frame = newframe->Xprevframe;\
241   (pcre_stack_free)(newframe);\
242   if (frame != NULL)\
243     {\
244     frame->Xresult = ra;\
245     md->thisframe = frame;\
246     longjmp(frame->Xwhere, 1);\
247     }\
248   return ra;\
249   }
250
251
252 /* Structure for remembering the local variables in a private frame */
253
254 typedef struct heapframe {
255   struct heapframe *Xprevframe;
256
257   /* Function arguments that may change */
258
259   const pcre_uchar *Xeptr;
260   const uschar *Xecode;
261   int Xoffset_top;
262   long int Xims;
263   eptrblock *Xeptrb;
264   int Xflags;
265
266   /* Function local variables */
267
268   const uschar *Xcallpat;
269   const uschar *Xcharptr;
270   const uschar *Xdata;
271   const uschar *Xnext;
272   const pcre_uchar *Xpp;
273   const uschar *Xprev;
274   const pcre_uchar *Xsaved_eptr;
275
276   recursion_info Xnew_recursive;
277
278   BOOL Xcur_is_word;
279   BOOL Xcondition;
280   BOOL Xminimize;
281   BOOL Xprev_is_word;
282
283   unsigned long int Xoriginal_ims;
284
285 #ifdef SUPPORT_UCP
286   int Xprop_type;
287   int Xprop_fail_result;
288   int Xprop_category;
289   int Xprop_chartype;
290   int Xprop_othercase;
291   int Xprop_test_against;
292   int *Xprop_test_variable;
293 #endif
294
295   int Xctype;
296   int Xfc;
297   int Xfi;
298   int Xlength;
299   int Xmax;
300   int Xmin;
301   int Xnumber;
302   int Xoffset;
303   int Xop;
304   int Xsave_capture_last;
305   int Xsave_offset1, Xsave_offset2, Xsave_offset3;
306   int Xstacksave[REC_STACK_SAVE_MAX];
307
308   eptrblock Xnewptrb;
309
310   /* Place to pass back result, and where to jump back to */
311
312   int  Xresult;
313   jmp_buf Xwhere;
314
315 } heapframe;
316
317 #endif
318
319
320 /***************************************************************************
321 ***************************************************************************/
322
323
324
325 /*************************************************
326 *         Match from current position            *
327 *************************************************/
328
329 /* On entry ecode points to the first opcode, and eptr to the first character
330 in the subject string, while eptrb holds the value of eptr at the start of the
331 last bracketed group - used for breaking infinite loops matching zero-length
332 strings. This function is called recursively in many circumstances. Whenever it
333 returns a negative (error) response, the outer incarnation must also return the
334 same response.
335
336 Performance note: It might be tempting to extract commonly used fields from the
337 md structure (e.g. utf8, end_subject) into individual variables to improve
338 performance. Tests using gcc on a SPARC disproved this; in the first case, it
339 made performance worse.
340
341 Arguments:
342    eptr        pointer in subject
343    ecode       position in code
344    offset_top  current top pointer
345    md          pointer to "static" info for the match
346    ims         current /i, /m, and /s options
347    eptrb       pointer to chain of blocks containing eptr at start of
348                  brackets - for testing for empty matches
349    flags       can contain
350                  match_condassert - this is an assertion condition
351                  match_isgroup - this is the start of a bracketed group
352
353 Returns:       MATCH_MATCH if matched            )  these values are >= 0
354                MATCH_NOMATCH if failed to match  )
355                a negative PCRE_ERROR_xxx value if aborted by an error condition
356                  (e.g. stopped by recursion limit)
357 */
358
359 static int
360 match(REGISTER const pcre_uchar *eptr, REGISTER const uschar *ecode,
361   int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
362   int flags)
363 {
364 /* These variables do not need to be preserved over recursion in this function,
365 so they can be ordinary variables in all cases. Mark them with "register"
366 because they are used a lot in loops. */
367
368 register int  rrc;    /* Returns from recursive calls */
369 register int  i;      /* Used for loops not involving calls to RMATCH() */
370 register int  c;      /* Character values not kept over RMATCH() calls */
371 register BOOL utf8;   /* Local copy of UTF-8 flag for speed */
372
373 /* When recursion is not being used, all "local" variables that have to be
374 preserved over calls to RMATCH() are part of a "frame" which is obtained from
375 heap storage. Set up the top-level frame here; others are obtained from the
376 heap whenever RMATCH() does a "recursion". See the macro definitions above. */
377
378 #ifdef NO_RECURSE
379 heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
380 frame->Xprevframe = NULL;            /* Marks the top level */
381
382 /* Copy in the original argument variables */
383
384 frame->Xeptr = eptr;
385 frame->Xecode = ecode;
386 frame->Xoffset_top = offset_top;
387 frame->Xims = ims;
388 frame->Xeptrb = eptrb;
389 frame->Xflags = flags;
390
391 /* This is where control jumps back to to effect "recursion" */
392
393 HEAP_RECURSE:
394
395 /* Macros make the argument variables come from the current frame */
396
397 #define eptr               frame->Xeptr
398 #define ecode              frame->Xecode
399 #define offset_top         frame->Xoffset_top
400 #define ims                frame->Xims
401 #define eptrb              frame->Xeptrb
402 #define flags              frame->Xflags
403
404 /* Ditto for the local variables */
405
406 #ifdef SUPPORT_UTF8
407 #define charptr            frame->Xcharptr
408 #endif
409 #define callpat            frame->Xcallpat
410 #define data               frame->Xdata
411 #define next               frame->Xnext
412 #define pp                 frame->Xpp
413 #define prev               frame->Xprev
414 #define saved_eptr         frame->Xsaved_eptr
415
416 #define new_recursive      frame->Xnew_recursive
417
418 #define cur_is_word        frame->Xcur_is_word
419 #define condition          frame->Xcondition
420 #define minimize           frame->Xminimize
421 #define prev_is_word       frame->Xprev_is_word
422
423 #define original_ims       frame->Xoriginal_ims
424
425 #ifdef SUPPORT_UCP
426 #define prop_type          frame->Xprop_type
427 #define prop_fail_result   frame->Xprop_fail_result
428 #define prop_category      frame->Xprop_category
429 #define prop_chartype      frame->Xprop_chartype
430 #define prop_othercase     frame->Xprop_othercase
431 #define prop_test_against  frame->Xprop_test_against
432 #define prop_test_variable frame->Xprop_test_variable
433 #endif
434
435 #define ctype              frame->Xctype
436 #define fc                 frame->Xfc
437 #define fi                 frame->Xfi
438 #define length             frame->Xlength
439 #define max                frame->Xmax
440 #define min                frame->Xmin
441 #define number             frame->Xnumber
442 #define offset             frame->Xoffset
443 #define op                 frame->Xop
444 #define save_capture_last  frame->Xsave_capture_last
445 #define save_offset1       frame->Xsave_offset1
446 #define save_offset2       frame->Xsave_offset2
447 #define save_offset3       frame->Xsave_offset3
448 #define stacksave          frame->Xstacksave
449
450 #define newptrb            frame->Xnewptrb
451
452 /* When recursion is being used, local variables are allocated on the stack and
453 get preserved during recursion in the normal way. In this environment, fi and
454 i, and fc and c, can be the same variables. */
455
456 #else
457 #define fi i
458 #define fc c
459
460
461 #if !PCRE_UTF16
462 #ifdef SUPPORT_UTF8                /* Many of these variables are used ony */
463 const uschar *charptr;             /* small blocks of the code. My normal  */
464 #endif                             /* style of coding would have declared  */
465 #endif
466 const uschar *callpat;             /* them within each of those blocks.    */
467 const uschar *data;                /* However, in order to accommodate the */
468 const uschar *next;                /* version of this code that uses an    */
469 const pcre_uchar *pp;              /* external "stack" implemented on the  */
470 const uschar *prev;                /* heap, it is easier to declare them   */
471 const pcre_uchar *saved_eptr;      /* all here, so the declarations can    */
472                                    /* be cut out in a block. The only      */
473 recursion_info new_recursive;      /* declarations within blocks below are */
474                                    /* for variables that do not have to    */
475 BOOL cur_is_word;                  /* be preserved over a recursive call   */
476 BOOL condition;                    /* to RMATCH().                         */
477 BOOL minimize;
478 BOOL prev_is_word;
479
480 unsigned long int original_ims;
481
482 #ifdef SUPPORT_UCP
483 int prop_type;
484 int prop_fail_result;
485 int prop_category;
486 int prop_chartype;
487 int prop_othercase;
488 int prop_test_against;
489 int *prop_test_variable;
490 #endif
491
492 int ctype;
493 int length;
494 int max;
495 int min;
496 int number;
497 int offset;
498 int op;
499 int save_capture_last;
500 int save_offset1, save_offset2, save_offset3;
501 int stacksave[REC_STACK_SAVE_MAX];
502
503 eptrblock newptrb;
504 #endif
505
506 /* These statements are here to stop the compiler complaining about unitialized
507 variables. */
508
509 #ifdef SUPPORT_UCP
510 prop_fail_result = 0;
511 prop_test_against = 0;
512 prop_test_variable = NULL;
513 #endif
514
515 /* OK, now we can get on with the real code of the function. Recursion is
516 specified by the macros RMATCH and RRETURN. When NO_RECURSE is *not* defined,
517 these just turn into a recursive call to match() and a "return", respectively.
518 However, RMATCH isn't like a function call because it's quite a complicated
519 macro. It has to be used in one particular way. This shouldn't, however, impact
520 performance when true recursion is being used. */
521
522 if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
523
524 original_ims = ims;    /* Save for resetting on ')' */
525 utf8 = md->utf8;       /* Local copy of the flag */
526
527 /* At the start of a bracketed group, add the current subject pointer to the
528 stack of such pointers, to be re-instated at the end of the group when we hit
529 the closing ket. When match() is called in other circumstances, we don't add to
530 this stack. */
531
532 if ((flags & match_isgroup) != 0)
533   {
534   newptrb.epb_prev = eptrb;
535   newptrb.epb_saved_eptr = eptr;
536   eptrb = &newptrb;
537   }
538
539 /* Now start processing the operations. */
540
541 for (;;)
542   {
543   op = *ecode;
544   minimize = FALSE;
545
546   /* For partial matching, remember if we ever hit the end of the subject after
547   matching at least one subject character. */
548
549   if (md->partial &&
550       eptr >= md->end_subject &&
551       eptr > md->start_match)
552     md->hitend = TRUE;
553
554   /* Opening capturing bracket. If there is space in the offset vector, save
555   the current subject position in the working slot at the top of the vector. We
556   mustn't change the current values of the data slot, because they may be set
557   from a previous iteration of this group, and be referred to by a reference
558   inside the group.
559
560   If the bracket fails to match, we need to restore this value and also the
561   values of the final offsets, in case they were set by a previous iteration of
562   the same bracket.
563
564   If there isn't enough space in the offset vector, treat this as if it were a
565   non-capturing bracket. Don't worry about setting the flag for the error case
566   here; that is handled in the code for KET. */
567
568   if (op > OP_BRA)
569     {
570     number = op - OP_BRA;
571
572     /* For extended extraction brackets (large number), we have to fish out the
573     number from a dummy opcode at the start. */
574
575     if (number > EXTRACT_BASIC_MAX)
576       number = GET2(ecode, 2+LINK_SIZE);
577     offset = number << 1;
578
579 #ifdef DEBUG
580     printf("start bracket %d subject=", number);
581     pchars(eptr, 16, TRUE, md);
582     printf("\n");
583 #endif
584
585     if (offset < md->offset_max)
586       {
587       save_offset1 = md->offset_vector[offset];
588       save_offset2 = md->offset_vector[offset+1];
589       save_offset3 = md->offset_vector[md->offset_end - number];
590       save_capture_last = md->capture_last;
591
592       DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
593       md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
594
595       do
596         {
597         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
598           match_isgroup);
599         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
600         md->capture_last = save_capture_last;
601         ecode += GET(ecode, 1);
602         }
603       while (*ecode == OP_ALT);
604
605       DPRINTF(("bracket %d failed\n", number));
606
607       md->offset_vector[offset] = save_offset1;
608       md->offset_vector[offset+1] = save_offset2;
609       md->offset_vector[md->offset_end - number] = save_offset3;
610
611       RRETURN(MATCH_NOMATCH);
612       }
613
614     /* Insufficient room for saving captured contents */
615
616     else op = OP_BRA;
617     }
618
619   /* Other types of node can be handled by a switch */
620
621   switch(op)
622     {
623     case OP_BRA:     /* Non-capturing bracket: optimized */
624     DPRINTF(("start bracket 0\n"));
625     do
626       {
627       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
628         match_isgroup);
629       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
630       ecode += GET(ecode, 1);
631       }
632     while (*ecode == OP_ALT);
633     DPRINTF(("bracket 0 failed\n"));
634     RRETURN(MATCH_NOMATCH);
635
636     /* Conditional group: compilation checked that there are no more than
637     two branches. If the condition is false, skipping the first branch takes us
638     past the end if there is only one branch, but that's OK because that is
639     exactly what going to the ket would do. */
640
641     case OP_COND:
642     if (ecode[LINK_SIZE+1] == OP_CREF) /* Condition extract or recurse test */
643       {
644       offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
645       condition = (offset == CREF_RECURSE * 2)?
646         (md->recursive != NULL) :
647         (offset < offset_top && md->offset_vector[offset] >= 0);
648       RMATCH(rrc, eptr, ecode + (condition?
649         (LINK_SIZE + 4) : (LINK_SIZE + 1 + GET(ecode, 1))),
650         offset_top, md, ims, eptrb, match_isgroup);
651       RRETURN(rrc);
652       }
653
654     /* The condition is an assertion. Call match() to evaluate it - setting
655     the final argument TRUE causes it to stop at the end of an assertion. */
656
657     else
658       {
659       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
660           match_condassert | match_isgroup);
661       if (rrc == MATCH_MATCH)
662         {
663         ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE+2);
664         while (*ecode == OP_ALT) ecode += GET(ecode, 1);
665         }
666       else if (rrc != MATCH_NOMATCH)
667         {
668         RRETURN(rrc);         /* Need braces because of following else */
669         }
670       else ecode += GET(ecode, 1);
671       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
672         match_isgroup);
673       RRETURN(rrc);
674       }
675     /* Control never reaches here */
676
677     /* Skip over conditional reference or large extraction number data if
678     encountered. */
679
680     case OP_CREF:
681     case OP_BRANUMBER:
682     ecode += 3;
683     break;
684
685     /* End of the pattern. If we are in a recursion, we should restore the
686     offsets appropriately and continue from after the call. */
687
688     case OP_END:
689     if (md->recursive != NULL && md->recursive->group_num == 0)
690       {
691       recursion_info *rec = md->recursive;
692       DPRINTF(("Hit the end in a (?0) recursion\n"));
693       md->recursive = rec->prevrec;
694       memmove(md->offset_vector, rec->offset_save,
695         rec->saved_max * sizeof(int));
696       md->start_match = rec->save_start;
697       ims = original_ims;
698       ecode = rec->after_call;
699       break;
700       }
701
702     /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
703     string - backtracking will then try other alternatives, if any. */
704
705     if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);
706     md->end_match_ptr = eptr;          /* Record where we ended */
707     md->end_offset_top = offset_top;   /* and how many extracts were taken */
708     RRETURN(MATCH_MATCH);
709
710     /* Change option settings */
711
712     case OP_OPT:
713     ims = ecode[1];
714     ecode += 2;
715     DPRINTF(("ims set to %02lx\n", ims));
716     break;
717
718     /* Assertion brackets. Check the alternative branches in turn - the
719     matching won't pass the KET for an assertion. If any one branch matches,
720     the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
721     start of each branch to move the current point backwards, so the code at
722     this level is identical to the lookahead case. */
723
724     case OP_ASSERT:
725     case OP_ASSERTBACK:
726     do
727       {
728       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
729         match_isgroup);
730       if (rrc == MATCH_MATCH) break;
731       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
732       ecode += GET(ecode, 1);
733       }
734     while (*ecode == OP_ALT);
735     if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
736
737     /* If checking an assertion for a condition, return MATCH_MATCH. */
738
739     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
740
741     /* Continue from after the assertion, updating the offsets high water
742     mark, since extracts may have been taken during the assertion. */
743
744     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
745     ecode += 1 + LINK_SIZE;
746     offset_top = md->end_offset_top;
747     continue;
748
749     /* Negative assertion: all branches must fail to match */
750
751     case OP_ASSERT_NOT:
752     case OP_ASSERTBACK_NOT:
753     do
754       {
755       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
756         match_isgroup);
757       if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
758       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
759       ecode += GET(ecode,1);
760       }
761     while (*ecode == OP_ALT);
762
763     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
764
765     ecode += 1 + LINK_SIZE;
766     continue;
767
768     /* Move the subject pointer back. This occurs only at the start of
769     each branch of a lookbehind assertion. If we are too close to the start to
770     move back, this match function fails. When working with UTF-8 we move
771     back a number of characters, not bytes. */
772
773     case OP_REVERSE:
774 #ifdef SUPPORT_UTF8
775     if (utf8)
776       {
777       c = GET(ecode,1);
778       for (i = 0; i < c; i++)
779         {
780         eptr--;
781         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
782         BACKCHAR(eptr)
783         }
784       }
785     else
786 #endif
787
788     /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
789
790       {
791       eptr -= GET(ecode,1);
792       if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
793       }
794
795     /* Skip to next op code */
796
797     ecode += 1 + LINK_SIZE;
798     break;
799
800     /* The callout item calls an external function, if one is provided, passing
801     details of the match so far. This is mainly for debugging, though the
802     function is able to force a failure. */
803
804     case OP_CALLOUT:
805     if (pcre_callout != NULL)
806       {
807       pcre_callout_block cb;
808       cb.version          = 1;   /* Version 1 of the callout block */
809       cb.callout_number   = ecode[1];
810       cb.offset_vector    = md->offset_vector;
811       cb.subject          = (const pcre_char *)md->start_subject;
812       cb.subject_length   = md->end_subject - md->start_subject;
813       cb.start_match      = md->start_match - md->start_subject;
814       cb.current_position = eptr - md->start_subject;
815       cb.pattern_position = GET(ecode, 2);
816       cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
817       cb.capture_top      = offset_top/2;
818       cb.capture_last     = md->capture_last;
819       cb.callout_data     = md->callout_data;
820       if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
821       if (rrc < 0) RRETURN(rrc);
822       }
823     ecode += 2 + 2*LINK_SIZE;
824     break;
825
826     /* Recursion either matches the current regex, or some subexpression. The
827     offset data is the offset to the starting bracket from the start of the
828     whole pattern. (This is so that it works from duplicated subpatterns.)
829
830     If there are any capturing brackets started but not finished, we have to
831     save their starting points and reinstate them after the recursion. However,
832     we don't know how many such there are (offset_top records the completed
833     total) so we just have to save all the potential data. There may be up to
834     65535 such values, which is too large to put on the stack, but using malloc
835     for small numbers seems expensive. As a compromise, the stack is used when
836     there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
837     is used. A problem is what to do if the malloc fails ... there is no way of
838     returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
839     values on the stack, and accept that the rest may be wrong.
840
841     There are also other values that have to be saved. We use a chained
842     sequence of blocks that actually live on the stack. Thanks to Robin Houston
843     for the original version of this logic. */
844
845     case OP_RECURSE:
846       {
847       callpat = md->start_code + GET(ecode, 1);
848       new_recursive.group_num = *callpat - OP_BRA;
849
850       /* For extended extraction brackets (large number), we have to fish out
851       the number from a dummy opcode at the start. */
852
853       if (new_recursive.group_num > EXTRACT_BASIC_MAX)
854         new_recursive.group_num = GET2(callpat, 2+LINK_SIZE);
855
856       /* Add to "recursing stack" */
857
858       new_recursive.prevrec = md->recursive;
859       md->recursive = &new_recursive;
860
861       /* Find where to continue from afterwards */
862
863       ecode += 1 + LINK_SIZE;
864       new_recursive.after_call = ecode;
865
866       /* Now save the offset data. */
867
868       new_recursive.saved_max = md->offset_end;
869       if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
870         new_recursive.offset_save = stacksave;
871       else
872         {
873         new_recursive.offset_save =
874           (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
875         if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
876         }
877
878       memcpy(new_recursive.offset_save, md->offset_vector,
879             new_recursive.saved_max * sizeof(int));
880       new_recursive.save_start = md->start_match;
881       md->start_match = eptr;
882
883       /* OK, now we can do the recursion. For each top-level alternative we
884       restore the offset and recursion data. */
885
886       DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
887       do
888         {
889         RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,
890             eptrb, match_isgroup);
891         if (rrc == MATCH_MATCH)
892           {
893           md->recursive = new_recursive.prevrec;
894           if (new_recursive.offset_save != stacksave)
895             (pcre_free)(new_recursive.offset_save);
896           RRETURN(MATCH_MATCH);
897           }
898         else if (rrc != MATCH_NOMATCH) RRETURN(rrc);
899
900         md->recursive = &new_recursive;
901         memcpy(md->offset_vector, new_recursive.offset_save,
902             new_recursive.saved_max * sizeof(int));
903         callpat += GET(callpat, 1);
904         }
905       while (*callpat == OP_ALT);
906
907       DPRINTF(("Recursion didn't match\n"));
908       md->recursive = new_recursive.prevrec;
909       if (new_recursive.offset_save != stacksave)
910         (pcre_free)(new_recursive.offset_save);
911       RRETURN(MATCH_NOMATCH);
912       }
913     /* Control never reaches here */
914
915     /* "Once" brackets are like assertion brackets except that after a match,
916     the point in the subject string is not moved back. Thus there can never be
917     a move back into the brackets. Friedl calls these "atomic" subpatterns.
918     Check the alternative branches in turn - the matching won't pass the KET
919     for this kind of subpattern. If any one branch matches, we carry on as at
920     the end of a normal bracket, leaving the subject pointer. */
921
922     case OP_ONCE:
923       {
924       prev = ecode;
925       saved_eptr = eptr;
926
927       do
928         {
929         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
930           eptrb, match_isgroup);
931         if (rrc == MATCH_MATCH) break;
932         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
933         ecode += GET(ecode,1);
934         }
935       while (*ecode == OP_ALT);
936
937       /* If hit the end of the group (which could be repeated), fail */
938
939       if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
940
941       /* Continue as from after the assertion, updating the offsets high water
942       mark, since extracts may have been taken. */
943
944       do ecode += GET(ecode,1); while (*ecode == OP_ALT);
945
946       offset_top = md->end_offset_top;
947       eptr = md->end_match_ptr;
948
949       /* For a non-repeating ket, just continue at this level. This also
950       happens for a repeating ket if no characters were matched in the group.
951       This is the forcible breaking of infinite loops as implemented in Perl
952       5.005. If there is an options reset, it will get obeyed in the normal
953       course of events. */
954
955       if (*ecode == OP_KET || eptr == saved_eptr)
956         {
957         ecode += 1+LINK_SIZE;
958         break;
959         }
960
961       /* The repeating kets try the rest of the pattern or restart from the
962       preceding bracket, in the appropriate order. We need to reset any options
963       that changed within the bracket before re-running it, so check the next
964       opcode. */
965
966       if (ecode[1+LINK_SIZE] == OP_OPT)
967         {
968         ims = (ims & ~PCRE_IMS) | ecode[4];
969         DPRINTF(("ims set to %02lx at group repeat\n", ims));
970         }
971
972       if (*ecode == OP_KETRMIN)
973         {
974         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0);
975         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
976         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
977         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
978         }
979       else  /* OP_KETRMAX */
980         {
981         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
982         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
983         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
984         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
985         }
986       }
987     RRETURN(MATCH_NOMATCH);
988
989     /* An alternation is the end of a branch; scan along to find the end of the
990     bracketed group and go to there. */
991
992     case OP_ALT:
993     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
994     break;
995
996     /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
997     that it may occur zero times. It may repeat infinitely, or not at all -
998     i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
999     repeat limits are compiled as a number of copies, with the optional ones
1000     preceded by BRAZERO or BRAMINZERO. */
1001
1002     case OP_BRAZERO:
1003       {
1004       next = ecode+1;
1005       RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);
1006       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1007       do next += GET(next,1); while (*next == OP_ALT);
1008       ecode = next + 1+LINK_SIZE;
1009       }
1010     break;
1011
1012     case OP_BRAMINZERO:
1013       {
1014       next = ecode+1;
1015       do next += GET(next,1); while (*next == OP_ALT);
1016       RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb,
1017         match_isgroup);
1018       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1019       ecode++;
1020       }
1021     break;
1022
1023     /* End of a group, repeated or non-repeating. If we are at the end of
1024     an assertion "group", stop matching and return MATCH_MATCH, but record the
1025     current high water mark for use by positive assertions. Do this also
1026     for the "once" (not-backup up) groups. */
1027
1028     case OP_KET:
1029     case OP_KETRMIN:
1030     case OP_KETRMAX:
1031       {
1032       prev = ecode - GET(ecode, 1);
1033       saved_eptr = eptrb->epb_saved_eptr;
1034
1035       /* Back up the stack of bracket start pointers. */
1036
1037       eptrb = eptrb->epb_prev;
1038
1039       if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1040           *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
1041           *prev == OP_ONCE)
1042         {
1043         md->end_match_ptr = eptr;      /* For ONCE */
1044         md->end_offset_top = offset_top;
1045         RRETURN(MATCH_MATCH);
1046         }
1047
1048       /* In all other cases except a conditional group we have to check the
1049       group number back at the start and if necessary complete handling an
1050       extraction by setting the offsets and bumping the high water mark. */
1051
1052       if (*prev != OP_COND)
1053         {
1054         number = *prev - OP_BRA;
1055
1056         /* For extended extraction brackets (large number), we have to fish out
1057         the number from a dummy opcode at the start. */
1058
1059         if (number > EXTRACT_BASIC_MAX) number = GET2(prev, 2+LINK_SIZE);
1060         offset = number << 1;
1061
1062 #ifdef DEBUG
1063         printf("end bracket %d", number);
1064         printf("\n");
1065 #endif
1066
1067         /* Test for a numbered group. This includes groups called as a result
1068         of recursion. Note that whole-pattern recursion is coded as a recurse
1069         into group 0, so it won't be picked up here. Instead, we catch it when
1070         the OP_END is reached. */
1071
1072         if (number > 0)
1073           {
1074           md->capture_last = number;
1075           if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1076             {
1077             md->offset_vector[offset] =
1078               md->offset_vector[md->offset_end - number];
1079             md->offset_vector[offset+1] = eptr - md->start_subject;
1080             if (offset_top <= offset) offset_top = offset + 2;
1081             }
1082
1083           /* Handle a recursively called group. Restore the offsets
1084           appropriately and continue from after the call. */
1085
1086           if (md->recursive != NULL && md->recursive->group_num == number)
1087             {
1088             recursion_info *rec = md->recursive;
1089             DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1090             md->recursive = rec->prevrec;
1091             md->start_match = rec->save_start;
1092             memcpy(md->offset_vector, rec->offset_save,
1093               rec->saved_max * sizeof(int));
1094             ecode = rec->after_call;
1095             ims = original_ims;
1096             break;
1097             }
1098           }
1099         }
1100
1101       /* Reset the value of the ims flags, in case they got changed during
1102       the group. */
1103
1104       ims = original_ims;
1105       DPRINTF(("ims reset to %02lx\n", ims));
1106
1107       /* For a non-repeating ket, just continue at this level. This also
1108       happens for a repeating ket if no characters were matched in the group.
1109       This is the forcible breaking of infinite loops as implemented in Perl
1110       5.005. If there is an options reset, it will get obeyed in the normal
1111       course of events. */
1112
1113       if (*ecode == OP_KET || eptr == saved_eptr)
1114         {
1115         ecode += 1 + LINK_SIZE;
1116         break;
1117         }
1118
1119       /* The repeating kets try the rest of the pattern or restart from the
1120       preceding bracket, in the appropriate order. */
1121
1122       if (*ecode == OP_KETRMIN)
1123         {
1124         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
1125         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1126         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
1127         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1128         }
1129       else  /* OP_KETRMAX */
1130         {
1131         RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
1132         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1133         RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
1134         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1135         }
1136       }
1137
1138     RRETURN(MATCH_NOMATCH);
1139
1140     /* Start of subject unless notbol, or after internal newline if multiline */
1141
1142     case OP_CIRC:
1143     if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
1144     if ((ims & PCRE_MULTILINE) != 0)
1145       {
1146       if (eptr != md->start_subject && eptr[-1] != NEWLINE)
1147         RRETURN(MATCH_NOMATCH);
1148       ecode++;
1149       break;
1150       }
1151     /* ... else fall through */
1152
1153     /* Start of subject assertion */
1154
1155     case OP_SOD:
1156     if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
1157     ecode++;
1158     break;
1159
1160     /* Start of match assertion */
1161
1162     case OP_SOM:
1163     if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
1164     ecode++;
1165     break;
1166
1167     /* Assert before internal newline if multiline, or before a terminating
1168     newline unless endonly is set, else end of subject unless noteol is set. */
1169
1170     case OP_DOLL:
1171     if ((ims & PCRE_MULTILINE) != 0)
1172       {
1173       if (eptr < md->end_subject)
1174         { if (*eptr != NEWLINE) RRETURN(MATCH_NOMATCH); }
1175       else
1176         { if (md->noteol) RRETURN(MATCH_NOMATCH); }
1177       ecode++;
1178       break;
1179       }
1180     else
1181       {
1182       if (md->noteol) RRETURN(MATCH_NOMATCH);
1183       if (!md->endonly)
1184         {
1185         if (eptr < md->end_subject - 1 ||
1186            (eptr == md->end_subject - 1 && *eptr != NEWLINE))
1187           RRETURN(MATCH_NOMATCH);
1188         ecode++;
1189         break;
1190         }
1191       }
1192     /* ... else fall through */
1193
1194     /* End of subject assertion (\z) */
1195
1196     case OP_EOD:
1197     if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
1198     ecode++;
1199     break;
1200
1201     /* End of subject or ending \n assertion (\Z) */
1202
1203     case OP_EODN:
1204     if (eptr < md->end_subject - 1 ||
1205        (eptr == md->end_subject - 1 && *eptr != NEWLINE)) RRETURN(MATCH_NOMATCH);
1206     ecode++;
1207     break;
1208
1209     /* Word boundary assertions */
1210
1211     case OP_NOT_WORD_BOUNDARY:
1212     case OP_WORD_BOUNDARY:
1213       {
1214
1215       /* Find out if the previous and current characters are "word" characters.
1216       It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
1217       be "non-word" characters. */
1218
1219 #ifdef SUPPORT_UTF8
1220       if (utf8)
1221         {
1222         if (eptr == md->start_subject) prev_is_word = FALSE; else
1223           {
1224           const pcre_uchar *lastptr = eptr - 1;
1225           while(ISMIDCHAR(*lastptr)) lastptr--;
1226           GETCHAR(c, lastptr);
1227           prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1228           }
1229         if (eptr >= md->end_subject) cur_is_word = FALSE; else
1230           {
1231           GETCHAR(c, eptr);
1232           cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1233           }
1234         }
1235       else
1236 #endif
1237
1238       /* More streamlined when not in UTF-8 mode */
1239
1240         {
1241         prev_is_word = (eptr != md->start_subject) &&
1242           ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1243         cur_is_word = (eptr < md->end_subject) &&
1244           ((md->ctypes[*eptr] & ctype_word) != 0);
1245         }
1246
1247       /* Now see if the situation is what we want */
1248
1249       if ((*ecode++ == OP_WORD_BOUNDARY)?
1250            cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1251         RRETURN(MATCH_NOMATCH);
1252       }
1253     break;
1254
1255     /* Match a single character type; inline for speed */
1256
1257     case OP_ANY:
1258     if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == NEWLINE)
1259       RRETURN(MATCH_NOMATCH);
1260     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
1261 #ifdef SUPPORT_UTF8
1262     if (utf8)
1263       while (eptr < md->end_subject && ISMIDCHAR(*eptr)) eptr++;
1264 #endif
1265     ecode++;
1266     break;
1267
1268     /* Match a single byte, even in UTF-8 mode. This opcode really does match
1269     any byte, even newline, independent of the setting of PCRE_DOTALL. */
1270
1271     case OP_ANYBYTE:
1272     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
1273     ecode++;
1274     break;
1275
1276     case OP_NOT_DIGIT:
1277     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1278     GETCHARINCTEST(c, eptr);
1279     if (
1280 #ifdef SUPPORT_UTF8
1281        c < 256 &&
1282 #endif
1283        (md->ctypes[c] & ctype_digit) != 0
1284        )
1285       RRETURN(MATCH_NOMATCH);
1286     ecode++;
1287     break;
1288
1289     case OP_DIGIT:
1290     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1291     GETCHARINCTEST(c, eptr);
1292     if (
1293 #ifdef SUPPORT_UTF8
1294        c >= 256 ||
1295 #endif
1296        (md->ctypes[c] & ctype_digit) == 0
1297        )
1298       RRETURN(MATCH_NOMATCH);
1299     ecode++;
1300     break;
1301
1302     case OP_NOT_WHITESPACE:
1303     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1304     GETCHARINCTEST(c, eptr);
1305     if (
1306 #ifdef SUPPORT_UTF8
1307        c < 256 &&
1308 #endif
1309        (md->ctypes[c] & ctype_space) != 0
1310        )
1311       RRETURN(MATCH_NOMATCH);
1312     ecode++;
1313     break;
1314
1315     case OP_WHITESPACE:
1316     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1317     GETCHARINCTEST(c, eptr);
1318     if (
1319 #ifdef SUPPORT_UTF8
1320        c >= 256 ||
1321 #endif
1322        (md->ctypes[c] & ctype_space) == 0
1323        )
1324       RRETURN(MATCH_NOMATCH);
1325     ecode++;
1326     break;
1327
1328     case OP_NOT_WORDCHAR:
1329     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1330     GETCHARINCTEST(c, eptr);
1331     if (
1332 #ifdef SUPPORT_UTF8
1333        c < 256 &&
1334 #endif
1335        (md->ctypes[c] & ctype_word) != 0
1336        )
1337       RRETURN(MATCH_NOMATCH);
1338     ecode++;
1339     break;
1340
1341     case OP_WORDCHAR:
1342     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1343     GETCHARINCTEST(c, eptr);
1344     if (
1345 #ifdef SUPPORT_UTF8
1346        c >= 256 ||
1347 #endif
1348        (md->ctypes[c] & ctype_word) == 0
1349        )
1350       RRETURN(MATCH_NOMATCH);
1351     ecode++;
1352     break;
1353
1354 #ifdef SUPPORT_UCP
1355     /* Check the next character by Unicode property. We will get here only
1356     if the support is in the binary; otherwise a compile-time error occurs. */
1357
1358     case OP_PROP:
1359     case OP_NOTPROP:
1360     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1361     GETCHARINCTEST(c, eptr);
1362       {
1363       int chartype, rqdtype;
1364       int othercase;
1365       int category = ucp_findchar(c, &chartype, &othercase);
1366
1367       rqdtype = *(++ecode);
1368       ecode++;
1369
1370       if (rqdtype >= 128)
1371         {
1372         if ((rqdtype - 128 != category) == (op == OP_PROP))
1373           RRETURN(MATCH_NOMATCH);
1374         }
1375       else
1376         {
1377         if ((rqdtype != chartype) == (op == OP_PROP))
1378           RRETURN(MATCH_NOMATCH);
1379         }
1380       }
1381     break;
1382
1383     /* Match an extended Unicode sequence. We will get here only if the support
1384     is in the binary; otherwise a compile-time error occurs. */
1385
1386     case OP_EXTUNI:
1387     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1388     GETCHARINCTEST(c, eptr);
1389       {
1390       int chartype;
1391       int othercase;
1392       int category = ucp_findchar(c, &chartype, &othercase);
1393       if (category == ucp_M) RRETURN(MATCH_NOMATCH);
1394       while (eptr < md->end_subject)
1395         {
1396         int len = 1;
1397         if (!utf8) c = *eptr; else
1398           {
1399           GETCHARLEN(c, eptr, len);
1400           }
1401         category = ucp_findchar(c, &chartype, &othercase);
1402         if (category != ucp_M) break;
1403         eptr += len;
1404         }
1405       }
1406     ecode++;
1407     break;
1408 #endif
1409
1410
1411     /* Match a back reference, possibly repeatedly. Look past the end of the
1412     item to see if there is repeat information following. The code is similar
1413     to that for character classes, but repeated for efficiency. Then obey
1414     similar code to character type repeats - written out again for speed.
1415     However, if the referenced string is the empty string, always treat
1416     it as matched, any number of times (otherwise there could be infinite
1417     loops). */
1418
1419     case OP_REF:
1420       {
1421       offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
1422       ecode += 3;                                 /* Advance past item */
1423
1424       /* If the reference is unset, set the length to be longer than the amount
1425       of subject left; this ensures that every attempt at a match fails. We
1426       can't just fail here, because of the possibility of quantifiers with zero
1427       minima. */
1428
1429       length = (offset >= offset_top || md->offset_vector[offset] < 0)?
1430         md->end_subject - eptr + 1 :
1431         md->offset_vector[offset+1] - md->offset_vector[offset];
1432
1433       /* Set up for repetition, or handle the non-repeated case */
1434
1435       switch (*ecode)
1436         {
1437         case OP_CRSTAR:
1438         case OP_CRMINSTAR:
1439         case OP_CRPLUS:
1440         case OP_CRMINPLUS:
1441         case OP_CRQUERY:
1442         case OP_CRMINQUERY:
1443         c = *ecode++ - OP_CRSTAR;
1444         minimize = (c & 1) != 0;
1445         min = rep_min[c];                 /* Pick up values from tables; */
1446         max = rep_max[c];                 /* zero for max => infinity */
1447         if (max == 0) max = INT_MAX;
1448         break;
1449
1450         case OP_CRRANGE:
1451         case OP_CRMINRANGE:
1452         minimize = (*ecode == OP_CRMINRANGE);
1453         min = GET2(ecode, 1);
1454         max = GET2(ecode, 3);
1455         if (max == 0) max = INT_MAX;
1456         ecode += 5;
1457         break;
1458
1459         default:               /* No repeat follows */
1460         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
1461         eptr += length;
1462         continue;              /* With the main loop */
1463         }
1464
1465       /* If the length of the reference is zero, just continue with the
1466       main loop. */
1467
1468       if (length == 0) continue;
1469
1470       /* First, ensure the minimum number of matches are present. We get back
1471       the length of the reference string explicitly rather than passing the
1472       address of eptr, so that eptr can be a register variable. */
1473
1474       for (i = 1; i <= min; i++)
1475         {
1476         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
1477         eptr += length;
1478         }
1479
1480       /* If min = max, continue at the same level without recursion.
1481       They are not both allowed to be zero. */
1482
1483       if (min == max) continue;
1484
1485       /* If minimizing, keep trying and advancing the pointer */
1486
1487       if (minimize)
1488         {
1489         for (fi = min;; fi++)
1490           {
1491           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1492           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1493           if (fi >= max || !match_ref(offset, eptr, length, md, ims))
1494             RRETURN(MATCH_NOMATCH);
1495           eptr += length;
1496           }
1497         /* Control never gets here */
1498         }
1499
1500       /* If maximizing, find the longest string and work backwards */
1501
1502       else
1503         {
1504         pp = eptr;
1505         for (i = min; i < max; i++)
1506           {
1507           if (!match_ref(offset, eptr, length, md, ims)) break;
1508           eptr += length;
1509           }
1510         while (eptr >= pp)
1511           {
1512           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1513           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1514           eptr -= length;
1515           }
1516         RRETURN(MATCH_NOMATCH);
1517         }
1518       }
1519     /* Control never gets here */
1520
1521
1522
1523     /* Match a bit-mapped character class, possibly repeatedly. This op code is
1524     used when all the characters in the class have values in the range 0-255,
1525     and either the matching is caseful, or the characters are in the range
1526     0-127 when UTF-8 processing is enabled. The only difference between
1527     OP_CLASS and OP_NCLASS occurs when a data character outside the range is
1528     encountered.
1529
1530     First, look past the end of the item to see if there is repeat information
1531     following. Then obey similar code to character type repeats - written out
1532     again for speed. */
1533
1534     case OP_NCLASS:
1535     case OP_CLASS:
1536       {
1537       data = ecode + 1;                /* Save for matching */
1538       ecode += 33;                     /* Advance past the item */
1539
1540       switch (*ecode)
1541         {
1542         case OP_CRSTAR:
1543         case OP_CRMINSTAR:
1544         case OP_CRPLUS:
1545         case OP_CRMINPLUS:
1546         case OP_CRQUERY:
1547         case OP_CRMINQUERY:
1548         c = *ecode++ - OP_CRSTAR;
1549         minimize = (c & 1) != 0;
1550         min = rep_min[c];                 /* Pick up values from tables; */
1551         max = rep_max[c];                 /* zero for max => infinity */
1552         if (max == 0) max = INT_MAX;
1553         break;
1554
1555         case OP_CRRANGE:
1556         case OP_CRMINRANGE:
1557         minimize = (*ecode == OP_CRMINRANGE);
1558         min = GET2(ecode, 1);
1559         max = GET2(ecode, 3);
1560         if (max == 0) max = INT_MAX;
1561         ecode += 5;
1562         break;
1563
1564         default:               /* No repeat follows */
1565         min = max = 1;
1566         break;
1567         }
1568
1569       /* First, ensure the minimum number of matches are present. */
1570
1571 #ifdef SUPPORT_UTF8
1572       /* UTF-8 mode */
1573       if (utf8)
1574         {
1575         for (i = 1; i <= min; i++)
1576           {
1577           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1578           GETCHARINC(c, eptr);
1579           if (c > 255)
1580             {
1581             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
1582             }
1583           else
1584             {
1585             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
1586             }
1587           }
1588         }
1589       else
1590 #endif
1591       /* Not UTF-8 mode */
1592         {
1593         for (i = 1; i <= min; i++)
1594           {
1595           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1596           c = *eptr++;
1597           if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
1598           }
1599         }
1600
1601       /* If max == min we can continue with the main loop without the
1602       need to recurse. */
1603
1604       if (min == max) continue;
1605
1606       /* If minimizing, keep testing the rest of the expression and advancing
1607       the pointer while it matches the class. */
1608
1609       if (minimize)
1610         {
1611 #ifdef SUPPORT_UTF8
1612         /* UTF-8 mode */
1613         if (utf8)
1614           {
1615           for (fi = min;; fi++)
1616             {
1617             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1618             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1619             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1620             GETCHARINC(c, eptr);
1621             if (c > 255)
1622               {
1623               if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
1624               }
1625             else
1626               {
1627               if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
1628               }
1629             }
1630           }
1631         else
1632 #endif
1633         /* Not UTF-8 mode */
1634           {
1635           for (fi = min;; fi++)
1636             {
1637             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1638             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1639             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1640             c = *eptr++;
1641             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
1642             }
1643           }
1644         /* Control never gets here */
1645         }
1646
1647       /* If maximizing, find the longest possible run, then work backwards. */
1648
1649       else
1650         {
1651         pp = eptr;
1652
1653 #ifdef SUPPORT_UTF8
1654         /* UTF-8 mode */
1655         if (utf8)
1656           {
1657           for (i = min; i < max; i++)
1658             {
1659             int len = 1;
1660             if (eptr >= md->end_subject) break;
1661             GETCHARLEN(c, eptr, len);
1662             if (c > 255)
1663               {
1664               if (op == OP_CLASS) break;
1665               }
1666             else
1667               {
1668               if ((data[c/8] & (1 << (c&7))) == 0) break;
1669               }
1670             eptr += len;
1671             }
1672           for (;;)
1673             {
1674             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1675             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1676             if (eptr-- == pp) break;        /* Stop if tried at original pos */
1677             BACKCHAR(eptr);
1678             }
1679           }
1680         else
1681 #endif
1682           /* Not UTF-8 mode */
1683           {
1684           for (i = min; i < max; i++)
1685             {
1686             if (eptr >= md->end_subject) break;
1687             c = *eptr;
1688             if ((data[c/8] & (1 << (c&7))) == 0) break;
1689             eptr++;
1690             }
1691           while (eptr >= pp)
1692             {
1693             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1694             eptr--;
1695             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1696             }
1697           }
1698
1699         RRETURN(MATCH_NOMATCH);
1700         }
1701       }
1702     /* Control never gets here */
1703
1704
1705     /* Match an extended character class. This opcode is encountered only
1706     in UTF-8 mode, because that's the only time it is compiled. */
1707
1708 #ifdef SUPPORT_UTF8
1709     case OP_XCLASS:
1710       {
1711       data = ecode + 1 + LINK_SIZE;                /* Save for matching */
1712       ecode += GET(ecode, 1);                      /* Advance past the item */
1713
1714       switch (*ecode)
1715         {
1716         case OP_CRSTAR:
1717         case OP_CRMINSTAR:
1718         case OP_CRPLUS:
1719         case OP_CRMINPLUS:
1720         case OP_CRQUERY:
1721         case OP_CRMINQUERY:
1722         c = *ecode++ - OP_CRSTAR;
1723         minimize = (c & 1) != 0;
1724         min = rep_min[c];                 /* Pick up values from tables; */
1725         max = rep_max[c];                 /* zero for max => infinity */
1726         if (max == 0) max = INT_MAX;
1727         break;
1728
1729         case OP_CRRANGE:
1730         case OP_CRMINRANGE:
1731         minimize = (*ecode == OP_CRMINRANGE);
1732         min = GET2(ecode, 1);
1733         max = GET2(ecode, 3);
1734         if (max == 0) max = INT_MAX;
1735         ecode += 5;
1736         break;
1737
1738         default:               /* No repeat follows */
1739         min = max = 1;
1740         break;
1741         }
1742
1743       /* First, ensure the minimum number of matches are present. */
1744
1745       for (i = 1; i <= min; i++)
1746         {
1747         if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1748         GETCHARINC(c, eptr);
1749         if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
1750         }
1751
1752       /* If max == min we can continue with the main loop without the
1753       need to recurse. */
1754
1755       if (min == max) continue;
1756
1757       /* If minimizing, keep testing the rest of the expression and advancing
1758       the pointer while it matches the class. */
1759
1760       if (minimize)
1761         {
1762         for (fi = min;; fi++)
1763           {
1764           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1765           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1766           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1767           GETCHARINC(c, eptr);
1768           if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
1769           }
1770         /* Control never gets here */
1771         }
1772
1773       /* If maximizing, find the longest possible run, then work backwards. */
1774
1775       else
1776         {
1777         pp = eptr;
1778         for (i = min; i < max; i++)
1779           {
1780           int len = 1;
1781           if (eptr >= md->end_subject) break;
1782           GETCHARLEN(c, eptr, len);
1783           if (!_pcre_xclass(c, data)) break;
1784           eptr += len;
1785           }
1786         for(;;)
1787           {
1788           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1789           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1790           if (eptr-- == pp) break;        /* Stop if tried at original pos */
1791           BACKCHAR(eptr)
1792           }
1793         RRETURN(MATCH_NOMATCH);
1794         }
1795
1796       /* Control never gets here */
1797       }
1798 #endif    /* End of XCLASS */
1799
1800     /* Match a single character, casefully */
1801
1802     case OP_CHAR:
1803 #ifdef SUPPORT_UTF8
1804     if (utf8)
1805       {
1806       length = 1;
1807       ecode++;
1808       GETUTF8CHARLEN(fc, ecode, length);
1809 #if PCRE_UTF16
1810       {
1811         int dc;
1812         ecode += length;
1813         switch (md->end_subject - eptr)
1814         {
1815           case 0:
1816             RRETURN(MATCH_NOMATCH);
1817           case 1:
1818             dc = *eptr++;
1819             if (IS_LEADING_SURROGATE(dc))
1820               RRETURN(MATCH_NOMATCH);
1821             break;
1822           default:
1823             GETCHARINC(dc, eptr);
1824         }
1825         if (fc != dc) RRETURN(MATCH_NOMATCH);
1826      }  
1827 #else
1828       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
1829       while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
1830 #endif
1831       }
1832     else
1833 #endif
1834
1835     /* Non-UTF-8 mode */
1836       {
1837       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
1838       if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
1839       ecode += 2;
1840       }
1841     break;
1842
1843     /* Match a single character, caselessly */
1844
1845     case OP_CHARNC:
1846 #ifdef SUPPORT_UTF8
1847     if (utf8)
1848       {
1849       length = 1;
1850       ecode++;
1851       GETUTF8CHARLEN(fc, ecode, length);
1852
1853 #if PCRE_UTF16
1854       if (md->end_subject - eptr == 0) RRETURN(MATCH_NOMATCH);
1855 #else
1856       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
1857 #endif
1858
1859       /* If the pattern character's value is < 128, we have only one byte, and
1860       can use the fast lookup table. */
1861
1862       if (fc < 128)
1863         {
1864 #if PCRE_UTF16
1865         int dc;
1866         ecode++;
1867         dc = *eptr++;
1868         if (dc >= 128 || md->lcc[fc] != md->lcc[dc]) RRETURN(MATCH_NOMATCH);
1869 #else
1870         if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
1871 #endif
1872         }
1873
1874       /* Otherwise we must pick up the subject character */
1875
1876       else
1877         {
1878         int dc;
1879 #if PCRE_UTF16
1880         if (md->end_subject - eptr == 1) {
1881           dc = *eptr++;
1882           if (IS_LEADING_SURROGATE(dc))
1883             RRETURN(MATCH_NOMATCH);
1884         } else
1885 #endif
1886           GETCHARINC(dc, eptr);
1887         ecode += length;
1888
1889         /* If we have Unicode property support, we can use it to test the other
1890         case of the character, if there is one. The result of ucp_findchar() is
1891         < 0 if the char isn't found, and othercase is returned as zero if there
1892         isn't one. */
1893
1894         if (fc != dc)
1895           {
1896 #ifdef SUPPORT_UCP
1897           int chartype;
1898           int othercase;
1899           if (ucp_findchar(fc, &chartype, &othercase) < 0 || dc != othercase)
1900 #endif
1901             RRETURN(MATCH_NOMATCH);
1902           }
1903         }
1904       }
1905     else
1906 #endif   /* SUPPORT_UTF8 */
1907
1908     /* Non-UTF-8 mode */
1909       {
1910       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
1911       if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
1912       ecode += 2;
1913       }
1914     break;
1915
1916     /* Match a single character repeatedly; different opcodes share code. */
1917
1918     case OP_EXACT:
1919     min = max = GET2(ecode, 1);
1920     ecode += 3;
1921     goto REPEATCHAR;
1922
1923     case OP_UPTO:
1924     case OP_MINUPTO:
1925     min = 0;
1926     max = GET2(ecode, 1);
1927     minimize = *ecode == OP_MINUPTO;
1928     ecode += 3;
1929     goto REPEATCHAR;
1930
1931     case OP_STAR:
1932     case OP_MINSTAR:
1933     case OP_PLUS:
1934     case OP_MINPLUS:
1935     case OP_QUERY:
1936     case OP_MINQUERY:
1937     c = *ecode++ - OP_STAR;
1938     minimize = (c & 1) != 0;
1939     min = rep_min[c];                 /* Pick up values from tables; */
1940     max = rep_max[c];                 /* zero for max => infinity */
1941     if (max == 0) max = INT_MAX;
1942
1943     /* Common code for all repeated single-character matches. We can give
1944     up quickly if there are fewer than the minimum number of characters left in
1945     the subject. */
1946
1947     REPEATCHAR:
1948 #ifdef SUPPORT_UTF8
1949 #if PCRE_UTF16
1950
1951       length = 1;
1952       GETUTF8CHARLEN(fc, ecode, length);
1953       {
1954       int utf16Length; // don't initialize on this line as workaround for Win32 compile problem
1955       utf16Length = fc > 0xFFFF ? 2 : 1;
1956       if (min * utf16Length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
1957       ecode += length;
1958
1959       if (utf16Length == 1)
1960         {
1961 #ifdef SUPPORT_UCP
1962         int othercase;
1963         int chartype;
1964         if ((ims & PCRE_CASELESS) == 0 || ucp_findchar(fc, &chartype, &othercase) < 0)
1965           othercase = -1; /* Guaranteed to not match any character */
1966 #endif  /* SUPPORT_UCP */
1967
1968         for (i = 1; i <= min; i++)
1969           {
1970           if (*eptr != fc && *eptr != othercase) RRETURN(MATCH_NOMATCH);
1971           ++eptr;
1972           }
1973
1974         if (min == max) continue;
1975
1976         if (minimize)
1977           {
1978           for (fi = min;; fi++)
1979             {
1980             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
1981             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1982             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1983             if (*eptr != fc && *eptr != othercase) RRETURN(MATCH_NOMATCH);
1984             ++eptr;
1985             }
1986           /* Control never gets here */
1987           }
1988         else
1989           {
1990           pp = eptr;
1991           for (i = min; i < max; i++)
1992             {
1993             if (eptr > md->end_subject - length) break;
1994             if (*eptr != fc && *eptr != othercase) break;
1995             ++eptr;
1996             }
1997           while (eptr >= pp)
1998            {
1999            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2000            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2001            --eptr;
2002            }
2003           RRETURN(MATCH_NOMATCH);
2004           }
2005         /* Control never gets here */
2006         }
2007       else
2008         {
2009         /* No case on surrogate pairs, so no need to bother with "othercase". */
2010
2011         for (i = 1; i <= min; i++)
2012           {
2013           int nc;
2014           GETCHAR(nc, eptr);
2015           if (nc != fc) RRETURN(MATCH_NOMATCH);
2016           eptr += 2;
2017           }
2018
2019         if (min == max) continue;
2020
2021         if (minimize)
2022           {
2023           for (fi = min;; fi++)
2024             {
2025             int nc;
2026             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2027             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2028             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2029             GETCHAR(nc, eptr);
2030             if (*eptr != fc) RRETURN(MATCH_NOMATCH);
2031             eptr += 2;
2032             }
2033           /* Control never gets here */
2034           }
2035         else
2036           {
2037           pp = eptr;
2038           for (i = min; i < max; i++)
2039             {
2040             int nc;
2041             if (eptr > md->end_subject - length) break;
2042             GETCHAR(nc, eptr);
2043             if (*eptr != fc) break;
2044             eptr += 2;
2045             }
2046           while (eptr >= pp)
2047            {
2048            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2049            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2050            eptr -= 2;
2051            }
2052           RRETURN(MATCH_NOMATCH);
2053           }
2054           /* Control never gets here */
2055         }
2056         /* Control never gets here */
2057         }
2058 #else
2059     if (utf8)
2060       {
2061       length = 1;
2062       charptr = ecode;
2063       GETCHARLEN(fc, ecode, length);
2064       if (min * length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
2065       ecode += length;
2066
2067       /* Handle multibyte character matching specially here. There is
2068       support for caseless matching if UCP support is present. */
2069
2070       if (length > 1)
2071         {
2072         int oclength = 0;
2073         uschar occhars[8];
2074
2075 #ifdef SUPPORT_UCP
2076         int othercase;
2077         int chartype;
2078         if ((ims & PCRE_CASELESS) != 0 &&
2079              ucp_findchar(fc, &chartype, &othercase) >= 0 &&
2080              othercase > 0)
2081           oclength = _pcre_ord2utf8(othercase, occhars);
2082 #endif  /* SUPPORT_UCP */
2083
2084         for (i = 1; i <= min; i++)
2085           {
2086           if (memcmp(eptr, charptr, length) == 0) eptr += length;
2087           /* Need braces because of following else */
2088           else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
2089           else
2090             {
2091             if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
2092             eptr += oclength;
2093             }
2094           }
2095
2096         if (min == max) continue;
2097
2098         if (minimize)
2099           {
2100           for (fi = min;; fi++)
2101             {
2102             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2103             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2104             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2105             if (memcmp(eptr, charptr, length) == 0) eptr += length;
2106             /* Need braces because of following else */
2107             else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
2108             else
2109               {
2110               if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
2111               eptr += oclength;
2112               }
2113             }
2114           /* Control never gets here */
2115           }
2116         else
2117           {
2118           pp = eptr;
2119           for (i = min; i < max; i++)
2120             {
2121             if (eptr > md->end_subject - length) break;
2122             if (memcmp(eptr, charptr, length) == 0) eptr += length;
2123             else if (oclength == 0) break;
2124             else
2125               {
2126               if (memcmp(eptr, occhars, oclength) != 0) break;
2127               eptr += oclength;
2128               }
2129             }
2130           while (eptr >= pp)
2131            {
2132            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2133            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2134            eptr -= length;
2135            }
2136           RRETURN(MATCH_NOMATCH);
2137           }
2138         /* Control never gets here */
2139         }
2140
2141       /* If the length of a UTF-8 character is 1, we fall through here, and
2142       obey the code as for non-UTF-8 characters below, though in this case the
2143       value of fc will always be < 128. */
2144       }
2145     else
2146 #endif
2147 #endif  /* SUPPORT_UTF8 */
2148
2149     /* When not in UTF-8 mode, load a single-byte character. */
2150       {
2151       if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
2152       fc = *ecode++;
2153       }
2154
2155     /* The value of fc at this point is always less than 256, though we may or
2156     may not be in UTF-8 mode. The code is duplicated for the caseless and
2157     caseful cases, for speed, since matching characters is likely to be quite
2158     common. First, ensure the minimum number of matches are present. If min =
2159     max, continue at the same level without recursing. Otherwise, if
2160     minimizing, keep trying the rest of the expression and advancing one
2161     matching character if failing, up to the maximum. Alternatively, if
2162     maximizing, find the maximum number of characters and work backwards. */
2163
2164     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
2165       max, eptr));
2166
2167     if ((ims & PCRE_CASELESS) != 0)
2168       {
2169       fc = md->lcc[fc];
2170       for (i = 1; i <= min; i++)
2171         if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
2172       if (min == max) continue;
2173       if (minimize)
2174         {
2175         for (fi = min;; fi++)
2176           {
2177           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2178           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2179           if (fi >= max || eptr >= md->end_subject ||
2180               fc != md->lcc[*eptr++])
2181             RRETURN(MATCH_NOMATCH);
2182           }
2183         /* Control never gets here */
2184         }
2185       else
2186         {
2187         pp = eptr;
2188         for (i = min; i < max; i++)
2189           {
2190           if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
2191           eptr++;
2192           }
2193         while (eptr >= pp)
2194           {
2195           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2196           eptr--;
2197           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2198           }
2199         RRETURN(MATCH_NOMATCH);
2200         }
2201       /* Control never gets here */
2202       }
2203
2204     /* Caseful comparisons (includes all multi-byte characters) */
2205
2206     else
2207       {
2208       for (i = 1; i <= min; i++) if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
2209       if (min == max) continue;
2210       if (minimize)
2211         {
2212         for (fi = min;; fi++)
2213           {
2214           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2215           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2216           if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
2217             RRETURN(MATCH_NOMATCH);
2218           }
2219         /* Control never gets here */
2220         }
2221       else
2222         {
2223         pp = eptr;
2224         for (i = min; i < max; i++)
2225           {
2226           if (eptr >= md->end_subject || fc != *eptr) break;
2227           eptr++;
2228           }
2229         while (eptr >= pp)
2230           {
2231           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2232           eptr--;
2233           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2234           }
2235         RRETURN(MATCH_NOMATCH);
2236         }
2237       }
2238     /* Control never gets here */
2239
2240     /* Match a negated single one-byte character. The character we are
2241     checking can be multibyte. */
2242
2243     case OP_NOT:
2244     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2245     ecode++;
2246     GETCHARINCTEST(c, eptr);
2247     if ((ims & PCRE_CASELESS) != 0)
2248       {
2249 #ifdef SUPPORT_UTF8
2250       if (c < 256)
2251 #endif
2252       c = md->lcc[c];
2253       if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);
2254       }
2255     else
2256       {
2257       if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
2258       }
2259     break;
2260
2261     /* Match a negated single one-byte character repeatedly. This is almost a
2262     repeat of the code for a repeated single character, but I haven't found a
2263     nice way of commoning these up that doesn't require a test of the
2264     positive/negative option for each character match. Maybe that wouldn't add
2265     very much to the time taken, but character matching *is* what this is all
2266     about... */
2267
2268     case OP_NOTEXACT:
2269     min = max = GET2(ecode, 1);
2270     ecode += 3;
2271     goto REPEATNOTCHAR;
2272
2273     case OP_NOTUPTO:
2274     case OP_NOTMINUPTO:
2275     min = 0;
2276     max = GET2(ecode, 1);
2277     minimize = *ecode == OP_NOTMINUPTO;
2278     ecode += 3;
2279     goto REPEATNOTCHAR;
2280
2281     case OP_NOTSTAR:
2282     case OP_NOTMINSTAR:
2283     case OP_NOTPLUS:
2284     case OP_NOTMINPLUS:
2285     case OP_NOTQUERY:
2286     case OP_NOTMINQUERY:
2287     c = *ecode++ - OP_NOTSTAR;
2288     minimize = (c & 1) != 0;
2289     min = rep_min[c];                 /* Pick up values from tables; */
2290     max = rep_max[c];                 /* zero for max => infinity */
2291     if (max == 0) max = INT_MAX;
2292
2293     /* Common code for all repeated single-byte matches. We can give up quickly
2294     if there are fewer than the minimum number of bytes left in the
2295     subject. */
2296
2297     REPEATNOTCHAR:
2298     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
2299     fc = *ecode++;
2300
2301     /* The code is duplicated for the caseless and caseful cases, for speed,
2302     since matching characters is likely to be quite common. First, ensure the
2303     minimum number of matches are present. If min = max, continue at the same
2304     level without recursing. Otherwise, if minimizing, keep trying the rest of
2305     the expression and advancing one matching character if failing, up to the
2306     maximum. Alternatively, if maximizing, find the maximum number of
2307     characters and work backwards. */
2308
2309     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
2310       max, eptr));
2311
2312     if ((ims & PCRE_CASELESS) != 0)
2313       {
2314       fc = md->lcc[fc];
2315
2316 #ifdef SUPPORT_UTF8
2317       /* UTF-8 mode */
2318       if (utf8)
2319         {
2320         register int d;
2321         for (i = 1; i <= min; i++)
2322           {
2323           GETCHARINC(d, eptr);
2324           if (d < 256) d = md->lcc[d];
2325           if (fc == d) RRETURN(MATCH_NOMATCH);
2326           }
2327         }
2328       else
2329 #endif
2330
2331       /* Not UTF-8 mode */
2332         {
2333         for (i = 1; i <= min; i++)
2334           if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
2335         }
2336
2337       if (min == max) continue;
2338
2339       if (minimize)
2340         {
2341 #ifdef SUPPORT_UTF8
2342         /* UTF-8 mode */
2343         if (utf8)
2344           {
2345           register int d;
2346           for (fi = min;; fi++)
2347             {
2348             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2349             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2350             GETCHARINC(d, eptr);
2351             if (d < 256) d = md->lcc[d];
2352             if (fi >= max || eptr >= md->end_subject || fc == d)
2353               RRETURN(MATCH_NOMATCH);
2354             }
2355           }
2356         else
2357 #endif
2358         /* Not UTF-8 mode */
2359           {
2360           for (fi = min;; fi++)
2361             {
2362             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2363             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2364             if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
2365               RRETURN(MATCH_NOMATCH);
2366             }
2367           }
2368         /* Control never gets here */
2369         }
2370
2371       /* Maximize case */
2372
2373       else
2374         {
2375         pp = eptr;
2376
2377 #ifdef SUPPORT_UTF8
2378         /* UTF-8 mode */
2379         if (utf8)
2380           {
2381           register int d;
2382           for (i = min; i < max; i++)
2383             {
2384             int len = 1;
2385             if (eptr >= md->end_subject) break;
2386             GETCHARLEN(d, eptr, len);
2387             if (d < 256) d = md->lcc[d];
2388             if (fc == d) break;
2389             eptr += len;
2390             }
2391           for(;;)
2392             {
2393             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2394             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2395             if (eptr-- == pp) break;        /* Stop if tried at original pos */
2396             BACKCHAR(eptr);
2397             }
2398           }
2399         else
2400 #endif
2401         /* Not UTF-8 mode */
2402           {
2403           for (i = min; i < max; i++)
2404             {
2405             if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
2406             eptr++;
2407             }
2408           while (eptr >= pp)
2409             {
2410             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2411             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2412             eptr--;
2413             }
2414           }
2415
2416         RRETURN(MATCH_NOMATCH);
2417         }
2418       /* Control never gets here */
2419       }
2420
2421     /* Caseful comparisons */
2422
2423     else
2424       {
2425 #ifdef SUPPORT_UTF8
2426       /* UTF-8 mode */
2427       if (utf8)
2428         {
2429         register int d;
2430         for (i = 1; i <= min; i++)
2431           {
2432           GETCHARINC(d, eptr);
2433           if (fc == d) RRETURN(MATCH_NOMATCH);
2434           }
2435         }
2436       else
2437 #endif
2438       /* Not UTF-8 mode */
2439         {
2440         for (i = 1; i <= min; i++)
2441           if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
2442         }
2443
2444       if (min == max) continue;
2445
2446       if (minimize)
2447         {
2448 #ifdef SUPPORT_UTF8
2449         /* UTF-8 mode */
2450         if (utf8)
2451           {
2452           register int d;
2453           for (fi = min;; fi++)
2454             {
2455             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2456             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2457             GETCHARINC(d, eptr);
2458             if (fi >= max || eptr >= md->end_subject || fc == d)
2459               RRETURN(MATCH_NOMATCH);
2460             }
2461           }
2462         else
2463 #endif
2464         /* Not UTF-8 mode */
2465           {
2466           for (fi = min;; fi++)
2467             {
2468             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2469             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2470             if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
2471               RRETURN(MATCH_NOMATCH);
2472             }
2473           }
2474         /* Control never gets here */
2475         }
2476
2477       /* Maximize case */
2478
2479       else
2480         {
2481         pp = eptr;
2482
2483 #ifdef SUPPORT_UTF8
2484         /* UTF-8 mode */
2485         if (utf8)
2486           {
2487           register int d;
2488           for (i = min; i < max; i++)
2489             {
2490             int len = 1;
2491             if (eptr >= md->end_subject) break;
2492             GETCHARLEN(d, eptr, len);
2493             if (fc == d) break;
2494             eptr += len;
2495             }
2496           for(;;)
2497             {
2498             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2499             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2500             if (eptr-- == pp) break;        /* Stop if tried at original pos */
2501             BACKCHAR(eptr);
2502             }
2503           }
2504         else
2505 #endif
2506         /* Not UTF-8 mode */
2507           {
2508           for (i = min; i < max; i++)
2509             {
2510             if (eptr >= md->end_subject || fc == *eptr) break;
2511             eptr++;
2512             }
2513           while (eptr >= pp)
2514             {
2515             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2516             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2517             eptr--;
2518             }
2519           }
2520
2521         RRETURN(MATCH_NOMATCH);
2522         }
2523       }
2524     /* Control never gets here */
2525
2526     /* Match a single character type repeatedly; several different opcodes
2527     share code. This is very similar to the code for single characters, but we
2528     repeat it in the interests of efficiency. */
2529
2530     case OP_TYPEEXACT:
2531     min = max = GET2(ecode, 1);
2532     minimize = TRUE;
2533     ecode += 3;
2534     goto REPEATTYPE;
2535
2536     case OP_TYPEUPTO:
2537     case OP_TYPEMINUPTO:
2538     min = 0;
2539     max = GET2(ecode, 1);
2540     minimize = *ecode == OP_TYPEMINUPTO;
2541     ecode += 3;
2542     goto REPEATTYPE;
2543
2544     case OP_TYPESTAR:
2545     case OP_TYPEMINSTAR:
2546     case OP_TYPEPLUS:
2547     case OP_TYPEMINPLUS:
2548     case OP_TYPEQUERY:
2549     case OP_TYPEMINQUERY:
2550     c = *ecode++ - OP_TYPESTAR;
2551     minimize = (c & 1) != 0;
2552     min = rep_min[c];                 /* Pick up values from tables; */
2553     max = rep_max[c];                 /* zero for max => infinity */
2554     if (max == 0) max = INT_MAX;
2555
2556     /* Common code for all repeated single character type matches. Note that
2557     in UTF-8 mode, '.' matches a character of any length, but for the other
2558     character types, the valid characters are all one-byte long. */
2559
2560     REPEATTYPE:
2561     ctype = *ecode++;      /* Code for the character type */
2562
2563 #ifdef SUPPORT_UCP
2564     if (ctype == OP_PROP || ctype == OP_NOTPROP)
2565       {
2566       prop_fail_result = ctype == OP_NOTPROP;
2567       prop_type = *ecode++;
2568       if (prop_type >= 128)
2569         {
2570         prop_test_against = prop_type - 128;
2571         prop_test_variable = &prop_category;
2572         }
2573       else
2574         {
2575         prop_test_against = prop_type;
2576         prop_test_variable = &prop_chartype;
2577         }
2578       }
2579     else prop_type = -1;
2580 #endif
2581
2582     /* First, ensure the minimum number of matches are present. Use inline
2583     code for maximizing the speed, and do the type test once at the start
2584     (i.e. keep it out of the loop). Also we can test that there are at least
2585     the minimum number of bytes before we start. This isn't as effective in
2586     UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
2587     is tidier. Also separate the UCP code, which can be the same for both UTF-8
2588     and single-bytes. */
2589
2590     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
2591     if (min > 0)
2592       {
2593 #ifdef SUPPORT_UCP
2594       if (prop_type > 0)
2595         {
2596         for (i = 1; i <= min; i++)
2597           {
2598           GETCHARINC(c, eptr);
2599           prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2600           if ((*prop_test_variable == prop_test_against) == prop_fail_result)
2601             RRETURN(MATCH_NOMATCH);
2602           }
2603         }
2604
2605       /* Match extended Unicode sequences. We will get here only if the
2606       support is in the binary; otherwise a compile-time error occurs. */
2607
2608       else if (ctype == OP_EXTUNI)
2609         {
2610         for (i = 1; i <= min; i++)
2611           {
2612           GETCHARINCTEST(c, eptr);
2613           prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2614           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
2615           while (eptr < md->end_subject)
2616             {
2617             int len = 1;
2618             if (!utf8) c = *eptr; else
2619               {
2620               GETCHARLEN(c, eptr, len);
2621               }
2622             prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2623             if (prop_category != ucp_M) break;
2624             eptr += len;
2625             }
2626           }
2627         }
2628
2629       else
2630 #endif     /* SUPPORT_UCP */
2631
2632 /* Handle all other cases when the coding is UTF-8 */
2633
2634 #ifdef SUPPORT_UTF8
2635       if (utf8) switch(ctype)
2636         {
2637         case OP_ANY:
2638         for (i = 1; i <= min; i++)
2639           {
2640           if (eptr >= md->end_subject ||
2641              (*eptr++ == NEWLINE && (ims & PCRE_DOTALL) == 0))
2642             RRETURN(MATCH_NOMATCH);
2643           while (eptr < md->end_subject && ISMIDCHAR(*eptr)) eptr++;
2644           }
2645         break;
2646
2647         case OP_ANYBYTE:
2648         eptr += min;
2649         break;
2650
2651         case OP_NOT_DIGIT:
2652         for (i = 1; i <= min; i++)
2653           {
2654           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2655           GETCHARINC(c, eptr);
2656           if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
2657             RRETURN(MATCH_NOMATCH);
2658           }
2659         break;
2660
2661         case OP_DIGIT:
2662         for (i = 1; i <= min; i++)
2663           {
2664           if (eptr >= md->end_subject ||
2665              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
2666             RRETURN(MATCH_NOMATCH);
2667           /* No need to skip more bytes - we know it's a 1-byte character */
2668           }
2669         break;
2670
2671         case OP_NOT_WHITESPACE:
2672         for (i = 1; i <= min; i++)
2673           {
2674           if (eptr >= md->end_subject ||
2675              (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))
2676             RRETURN(MATCH_NOMATCH);
2677           while (eptr < md->end_subject && ISMIDCHAR(*eptr)) eptr++;
2678           }
2679         break;
2680
2681         case OP_WHITESPACE:
2682         for (i = 1; i <= min; i++)
2683           {
2684           if (eptr >= md->end_subject ||
2685              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
2686             RRETURN(MATCH_NOMATCH);
2687           /* No need to skip more bytes - we know it's a 1-byte character */
2688           }
2689         break;
2690
2691         case OP_NOT_WORDCHAR:
2692         for (i = 1; i <= min; i++)
2693           {
2694           if (eptr >= md->end_subject ||
2695              (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))
2696             RRETURN(MATCH_NOMATCH);
2697           while (eptr < md->end_subject && ISMIDCHAR(*eptr)) eptr++;
2698           }
2699         break;
2700
2701         case OP_WORDCHAR:
2702         for (i = 1; i <= min; i++)
2703           {
2704           if (eptr >= md->end_subject ||
2705              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
2706             RRETURN(MATCH_NOMATCH);
2707           /* No need to skip more bytes - we know it's a 1-byte character */
2708           }
2709         break;
2710
2711         default:
2712         RRETURN(PCRE_ERROR_INTERNAL);
2713         }  /* End switch(ctype) */
2714
2715       else
2716 #endif     /* SUPPORT_UTF8 */
2717
2718       /* Code for the non-UTF-8 case for minimum matching of operators other
2719       than OP_PROP and OP_NOTPROP. */
2720
2721       switch(ctype)
2722         {
2723         case OP_ANY:
2724         if ((ims & PCRE_DOTALL) == 0)
2725           {
2726           for (i = 1; i <= min; i++)
2727             if (*eptr++ == NEWLINE) RRETURN(MATCH_NOMATCH);
2728           }
2729         else eptr += min;
2730         break;
2731
2732         case OP_ANYBYTE:
2733         eptr += min;
2734         break;
2735
2736         case OP_NOT_DIGIT:
2737         for (i = 1; i <= min; i++)
2738           if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
2739         break;
2740
2741         case OP_DIGIT:
2742         for (i = 1; i <= min; i++)
2743           if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
2744         break;
2745
2746         case OP_NOT_WHITESPACE:
2747         for (i = 1; i <= min; i++)
2748           if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
2749         break;
2750
2751         case OP_WHITESPACE:
2752         for (i = 1; i <= min; i++)
2753           if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
2754         break;
2755
2756         case OP_NOT_WORDCHAR:
2757         for (i = 1; i <= min; i++)
2758           if ((md->ctypes[*eptr++] & ctype_word) != 0)
2759             RRETURN(MATCH_NOMATCH);
2760         break;
2761
2762         case OP_WORDCHAR:
2763         for (i = 1; i <= min; i++)
2764           if ((md->ctypes[*eptr++] & ctype_word) == 0)
2765             RRETURN(MATCH_NOMATCH);
2766         break;
2767
2768         default:
2769         RRETURN(PCRE_ERROR_INTERNAL);
2770         }
2771       }
2772
2773     /* If min = max, continue at the same level without recursing */
2774
2775     if (min == max) continue;
2776
2777     /* If minimizing, we have to test the rest of the pattern before each
2778     subsequent match. Again, separate the UTF-8 case for speed, and also
2779     separate the UCP cases. */
2780
2781     if (minimize)
2782       {
2783 #ifdef SUPPORT_UCP
2784       if (prop_type > 0)
2785         {
2786         for (fi = min;; fi++)
2787           {
2788           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2789           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2790           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2791           GETCHARINC(c, eptr);
2792           prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2793           if ((*prop_test_variable == prop_test_against) == prop_fail_result)
2794             RRETURN(MATCH_NOMATCH);
2795           }
2796         }
2797
2798       /* Match extended Unicode sequences. We will get here only if the
2799       support is in the binary; otherwise a compile-time error occurs. */
2800
2801       else if (ctype == OP_EXTUNI)
2802         {
2803         for (fi = min;; fi++)
2804           {
2805           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2806           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2807           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2808           GETCHARINCTEST(c, eptr);
2809           prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2810           if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
2811           while (eptr < md->end_subject)
2812             {
2813             int len = 1;
2814             if (!utf8) c = *eptr; else
2815               {
2816               GETCHARLEN(c, eptr, len);
2817               }
2818             prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2819             if (prop_category != ucp_M) break;
2820             eptr += len;
2821             }
2822           }
2823         }
2824
2825       else
2826 #endif     /* SUPPORT_UCP */
2827
2828 #ifdef SUPPORT_UTF8
2829       /* UTF-8 mode */
2830       if (utf8)
2831         {
2832         for (fi = min;; fi++)
2833           {
2834           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2835           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2836           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2837
2838           GETCHARINC(c, eptr);
2839           switch(ctype)
2840             {
2841             case OP_ANY:
2842             if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);
2843             break;
2844
2845             case OP_ANYBYTE:
2846             break;
2847
2848             case OP_NOT_DIGIT:
2849             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
2850               RRETURN(MATCH_NOMATCH);
2851             break;
2852
2853             case OP_DIGIT:
2854             if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
2855               RRETURN(MATCH_NOMATCH);
2856             break;
2857
2858             case OP_NOT_WHITESPACE:
2859             if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
2860               RRETURN(MATCH_NOMATCH);
2861             break;
2862
2863             case OP_WHITESPACE:
2864             if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
2865               RRETURN(MATCH_NOMATCH);
2866             break;
2867
2868             case OP_NOT_WORDCHAR:
2869             if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
2870               RRETURN(MATCH_NOMATCH);
2871             break;
2872
2873             case OP_WORDCHAR:
2874             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
2875               RRETURN(MATCH_NOMATCH);
2876             break;
2877
2878             default:
2879             RRETURN(PCRE_ERROR_INTERNAL);
2880             }
2881           }
2882         }
2883       else
2884 #endif
2885       /* Not UTF-8 mode */
2886         {
2887         for (fi = min;; fi++)
2888           {
2889           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2890           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2891           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2892           c = *eptr++;
2893           switch(ctype)
2894             {
2895             case OP_ANY:
2896             if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);
2897             break;
2898
2899             case OP_ANYBYTE:
2900             break;
2901
2902             case OP_NOT_DIGIT:
2903             if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
2904             break;
2905
2906             case OP_DIGIT:
2907             if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
2908             break;
2909
2910             case OP_NOT_WHITESPACE:
2911             if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
2912             break;
2913
2914             case OP_WHITESPACE:
2915             if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
2916             break;
2917
2918             case OP_NOT_WORDCHAR:
2919             if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
2920             break;
2921
2922             case OP_WORDCHAR:
2923             if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
2924             break;
2925
2926             default:
2927             RRETURN(PCRE_ERROR_INTERNAL);
2928             }
2929           }
2930         }
2931       /* Control never gets here */
2932       }
2933
2934     /* If maximizing it is worth using inline code for speed, doing the type
2935     test once at the start (i.e. keep it out of the loop). Again, keep the
2936     UTF-8 and UCP stuff separate. */
2937
2938     else
2939       {
2940       pp = eptr;  /* Remember where we started */
2941
2942 #ifdef SUPPORT_UCP
2943       if (prop_type > 0)
2944         {
2945         for (i = min; i < max; i++)
2946           {
2947           int len = 1;
2948           if (eptr >= md->end_subject) break;
2949           GETCHARLEN(c, eptr, len);
2950           prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2951           if ((*prop_test_variable == prop_test_against) == prop_fail_result)
2952             break;
2953           eptr+= len;
2954           }
2955
2956         /* eptr is now past the end of the maximum run */
2957
2958         for(;;)
2959           {
2960           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2961           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2962           if (eptr-- == pp) break;        /* Stop if tried at original pos */
2963           BACKCHAR(eptr);
2964           }
2965         }
2966
2967       /* Match extended Unicode sequences. We will get here only if the
2968       support is in the binary; otherwise a compile-time error occurs. */
2969
2970       else if (ctype == OP_EXTUNI)
2971         {
2972         for (i = min; i < max; i++)
2973           {
2974           if (eptr >= md->end_subject) break;
2975           GETCHARINCTEST(c, eptr);
2976           prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2977           if (prop_category == ucp_M) break;
2978           while (eptr < md->end_subject)
2979             {
2980             int len = 1;
2981             if (!utf8) c = *eptr; else
2982               {
2983               GETCHARLEN(c, eptr, len);
2984               }
2985             prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
2986             if (prop_category != ucp_M) break;
2987             eptr += len;
2988             }
2989           }
2990
2991         /* eptr is now past the end of the maximum run */
2992
2993         for(;;)
2994           {
2995           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
2996           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2997           if (eptr-- == pp) break;        /* Stop if tried at original pos */
2998           for (;;)                        /* Move back over one extended */
2999             {
3000             int len = 1;
3001             BACKCHAR(eptr);
3002             if (!utf8) c = *eptr; else
3003               {
3004               GETCHARLEN(c, eptr, len);
3005               }
3006             prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
3007             if (prop_category != ucp_M) break;
3008             eptr--;
3009             }
3010           }
3011         }
3012
3013       else
3014 #endif   /* SUPPORT_UCP */
3015
3016 #ifdef SUPPORT_UTF8
3017       /* UTF-8 mode */
3018
3019       if (utf8)
3020         {
3021         switch(ctype)
3022           {
3023           case OP_ANY:
3024
3025           /* Special code is required for UTF8, but when the maximum is unlimited
3026           we don't need it, so we repeat the non-UTF8 code. This is probably
3027           worth it, because .* is quite a common idiom. */
3028
3029           if (max < INT_MAX)
3030             {
3031             if ((ims & PCRE_DOTALL) == 0)
3032               {
3033               for (i = min; i < max; i++)
3034                 {
3035                 if (eptr >= md->end_subject || *eptr == NEWLINE) break;
3036                 eptr++;
3037                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3038                 }
3039               }
3040             else
3041               {
3042               for (i = min; i < max; i++)
3043                 {
3044                 eptr++;
3045                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3046                 }
3047               }
3048             }
3049
3050           /* Handle unlimited UTF-8 repeat */
3051
3052           else
3053             {
3054             if ((ims & PCRE_DOTALL) == 0)
3055               {
3056               for (i = min; i < max; i++)
3057                 {
3058                 if (eptr >= md->end_subject || *eptr == NEWLINE) break;
3059                 eptr++;
3060                 }
3061               break;
3062               }
3063             else
3064               {
3065               c = max - min;
3066               if (c > md->end_subject - eptr) c = md->end_subject - eptr;
3067               eptr += c;
3068               }
3069             }
3070           break;
3071
3072           /* The byte case is the same as non-UTF8 */
3073
3074           case OP_ANYBYTE:
3075           c = max - min;
3076           if (c > md->end_subject - eptr) c = md->end_subject - eptr;
3077           eptr += c;
3078           break;
3079
3080           case OP_NOT_DIGIT:
3081           for (i = min; i < max; i++)
3082             {
3083             int len = 1;
3084             if (eptr >= md->end_subject) break;
3085             GETCHARLEN(c, eptr, len);
3086             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
3087             eptr+= len;
3088             }
3089           break;
3090
3091           case OP_DIGIT:
3092           for (i = min; i < max; i++)
3093             {
3094             int len = 1;
3095             if (eptr >= md->end_subject) break;
3096             GETCHARLEN(c, eptr, len);
3097             if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
3098             eptr+= len;
3099             }
3100           break;
3101
3102           case OP_NOT_WHITESPACE:
3103           for (i = min; i < max; i++)
3104             {
3105             int len = 1;
3106             if (eptr >= md->end_subject) break;
3107             GETCHARLEN(c, eptr, len);
3108             if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
3109             eptr+= len;
3110             }
3111           break;
3112
3113           case OP_WHITESPACE:
3114           for (i = min; i < max; i++)
3115             {
3116             int len = 1;
3117             if (eptr >= md->end_subject) break;
3118             GETCHARLEN(c, eptr, len);
3119             if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
3120             eptr+= len;
3121             }
3122           break;
3123
3124           case OP_NOT_WORDCHAR:
3125           for (i = min; i < max; i++)
3126             {
3127             int len = 1;
3128             if (eptr >= md->end_subject) break;
3129             GETCHARLEN(c, eptr, len);
3130             if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
3131             eptr+= len;
3132             }
3133           break;
3134
3135           case OP_WORDCHAR:
3136           for (i = min; i < max; i++)
3137             {
3138             int len = 1;
3139             if (eptr >= md->end_subject) break;
3140             GETCHARLEN(c, eptr, len);
3141             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
3142             eptr+= len;
3143             }
3144           break;
3145
3146           default:
3147           RRETURN(PCRE_ERROR_INTERNAL);
3148           }
3149
3150         /* eptr is now past the end of the maximum run */
3151
3152         for(;;)
3153           {
3154           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
3155           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3156           if (eptr-- == pp) break;        /* Stop if tried at original pos */
3157           BACKCHAR(eptr);
3158           }
3159         }
3160       else
3161 #endif
3162
3163       /* Not UTF-8 mode */
3164         {
3165         switch(ctype)
3166           {
3167           case OP_ANY:
3168           if ((ims & PCRE_DOTALL) == 0)
3169             {
3170             for (i = min; i < max; i++)
3171               {
3172               if (eptr >= md->end_subject || *eptr == NEWLINE) break;
3173               eptr++;
3174               }
3175             break;
3176             }
3177           /* For DOTALL case, fall through and treat as \C */
3178
3179           case OP_ANYBYTE:
3180           c = max - min;
3181           if (c > md->end_subject - eptr) c = md->end_subject - eptr;
3182           eptr += c;
3183           break;
3184
3185           case OP_NOT_DIGIT:
3186           for (i = min; i < max; i++)
3187             {
3188             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)
3189               break;
3190             eptr++;
3191             }
3192           break;
3193
3194           case OP_DIGIT:
3195           for (i = min; i < max; i++)
3196             {
3197             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)
3198               break;
3199             eptr++;
3200             }
3201           break;
3202
3203           case OP_NOT_WHITESPACE:
3204           for (i = min; i < max; i++)
3205             {
3206             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)
3207               break;
3208             eptr++;
3209             }
3210           break;
3211
3212           case OP_WHITESPACE:
3213           for (i = min; i < max; i++)
3214             {
3215             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)
3216               break;
3217             eptr++;
3218             }
3219           break;
3220
3221           case OP_NOT_WORDCHAR:
3222           for (i = min; i < max; i++)
3223             {
3224             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)
3225               break;
3226             eptr++;
3227             }
3228           break;
3229
3230           case OP_WORDCHAR:
3231           for (i = min; i < max; i++)
3232             {
3233             if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)
3234               break;
3235             eptr++;
3236             }
3237           break;
3238
3239           default:
3240           RRETURN(PCRE_ERROR_INTERNAL);
3241           }
3242
3243         /* eptr is now past the end of the maximum run */
3244
3245         while (eptr >= pp)
3246           {
3247           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
3248           eptr--;
3249           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3250           }
3251         }
3252
3253       /* Get here if we can't make it match with any permitted repetitions */
3254
3255       RRETURN(MATCH_NOMATCH);
3256       }
3257     /* Control never gets here */
3258
3259     /* There's been some horrible disaster. Since all codes > OP_BRA are
3260     for capturing brackets, and there shouldn't be any gaps between 0 and
3261     OP_BRA, arrival here can only mean there is something seriously wrong
3262     in the code above or the OP_xxx definitions. */
3263
3264     default:
3265     DPRINTF(("Unknown opcode %d\n", *ecode));
3266     RRETURN(PCRE_ERROR_UNKNOWN_NODE);
3267     }
3268
3269   /* Do not stick any code in here without much thought; it is assumed
3270   that "continue" in the code above comes out to here to repeat the main
3271   loop. */
3272
3273   }             /* End of main loop */
3274 /* Control never reaches here */
3275 }
3276
3277
3278 /***************************************************************************
3279 ****************************************************************************
3280                    RECURSION IN THE match() FUNCTION
3281
3282 Undefine all the macros that were defined above to handle this. */
3283
3284 #ifdef NO_RECURSE
3285 #undef eptr
3286 #undef ecode
3287 #undef offset_top
3288 #undef ims
3289 #undef eptrb
3290 #undef flags
3291
3292 #undef callpat
3293 #undef charptr
3294 #undef data
3295 #undef next
3296 #undef pp
3297 #undef prev
3298 #undef saved_eptr
3299
3300 #undef new_recursive
3301
3302 #undef cur_is_word
3303 #undef condition
3304 #undef minimize
3305 #undef prev_is_word
3306
3307 #undef original_ims
3308
3309 #undef ctype
3310 #undef length
3311 #undef max
3312 #undef min
3313 #undef number
3314 #undef offset
3315 #undef op
3316 #undef save_capture_last
3317 #undef save_offset1
3318 #undef save_offset2
3319 #undef save_offset3
3320 #undef stacksave
3321
3322 #undef newptrb
3323
3324 #endif
3325
3326 /* These two are defined as macros in both cases */
3327
3328 #undef fc
3329 #undef fi
3330
3331 /***************************************************************************
3332 ***************************************************************************/
3333
3334
3335
3336 /*************************************************
3337 *         Execute a Regular Expression           *
3338 *************************************************/
3339
3340 /* This function applies a compiled re to a subject string and picks out
3341 portions of the string if it matches. Two elements in the vector are set for
3342 each substring: the offsets to the start and end of the substring.
3343
3344 Arguments:
3345   argument_re     points to the compiled expression
3346   extra_data      points to extra data or is NULL
3347   subject         points to the subject string
3348   length          length of subject string (may contain binary zeros)
3349   start_offset    where to start in the subject string
3350   options         option bits
3351   offsets         points to a vector of ints to be filled in with offsets
3352   offsetcount     the number of elements in the vector
3353
3354 Returns:          > 0 => success; value is the number of elements filled in
3355                   = 0 => success, but offsets is not big enough
3356                    -1 => failed to match
3357                  < -1 => some kind of unexpected problem
3358 */
3359
3360 EXPORT int
3361 pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
3362   const pcre_char *subject, int length, int start_offset, int options, int *offsets,
3363   int offsetcount)
3364 {
3365 int rc, resetcount, ocount;
3366 int first_byte = -1;
3367 int req_byte = -1;
3368 int req_byte2 = -1;
3369 unsigned long int ims = 0;
3370 BOOL using_temporary_offsets = FALSE;
3371 BOOL anchored;
3372 BOOL startline;
3373 BOOL firstline;
3374 BOOL first_byte_caseless = FALSE;
3375 BOOL req_byte_caseless = FALSE;
3376 match_data match_block;
3377 const uschar *tables;
3378 const uschar *start_bits = NULL;
3379 const pcre_uchar *start_match = (const pcre_uchar *)subject + start_offset;
3380 const pcre_uchar *end_subject;
3381 const pcre_uchar *req_byte_ptr = start_match - 1;
3382
3383 pcre_study_data internal_study;
3384 const pcre_study_data *study;
3385
3386 real_pcre internal_re;
3387 const real_pcre *external_re = (const real_pcre *)argument_re;
3388 const real_pcre *re = external_re;
3389
3390 /* Plausibility checks */
3391
3392 if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
3393 if (re == NULL || subject == NULL ||
3394    (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
3395 if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
3396
3397 /* Fish out the optional data from the extra_data structure, first setting
3398 the default values. */
3399
3400 study = NULL;
3401 match_block.match_limit = MATCH_LIMIT;
3402 match_block.callout_data = NULL;
3403
3404 /* The table pointer is always in native byte order. */
3405
3406 tables = external_re->tables;
3407
3408 if (extra_data != NULL)
3409   {
3410   register unsigned int flags = extra_data->flags;
3411   if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
3412     study = (const pcre_study_data *)extra_data->study_data;
3413   if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
3414     match_block.match_limit = extra_data->match_limit;
3415   if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
3416     match_block.callout_data = extra_data->callout_data;
3417   if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
3418   }
3419
3420 /* If the exec call supplied NULL for tables, use the inbuilt ones. This
3421 is a feature that makes it possible to save compiled regex and re-use them
3422 in other programs later. */
3423
3424 if (tables == NULL) tables = _pcre_default_tables;
3425
3426 /* Check that the first field in the block is the magic number. If it is not,
3427 test for a regex that was compiled on a host of opposite endianness. If this is
3428 the case, flipped values are put in internal_re and internal_study if there was
3429 study data too. */
3430
3431 if (re->magic_number != MAGIC_NUMBER)
3432   {
3433   re = _pcre_try_flipped(re, &internal_re, study, &internal_study);
3434   if (re == NULL) return PCRE_ERROR_BADMAGIC;
3435   if (study != NULL) study = &internal_study;
3436   }
3437
3438 /* Set up other data */
3439
3440 anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
3441 startline = (re->options & PCRE_STARTLINE) != 0;
3442 firstline = (re->options & PCRE_FIRSTLINE) != 0;
3443
3444 /* The code starts after the real_pcre block and the capture name table. */
3445
3446 match_block.start_code = (const uschar *)external_re + re->name_table_offset +
3447   re->name_count * re->name_entry_size;
3448
3449 match_block.start_subject = (const pcre_uchar *)subject;
3450 match_block.start_offset = start_offset;
3451 match_block.end_subject = match_block.start_subject + length;
3452 end_subject = match_block.end_subject;
3453
3454 match_block.endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
3455 match_block.utf8 = (re->options & PCRE_UTF8) != 0;
3456
3457 match_block.notbol = (options & PCRE_NOTBOL) != 0;
3458 match_block.noteol = (options & PCRE_NOTEOL) != 0;
3459 match_block.notempty = (options & PCRE_NOTEMPTY) != 0;
3460 match_block.partial = (options & PCRE_PARTIAL) != 0;
3461 match_block.hitend = FALSE;
3462
3463 match_block.recursive = NULL;                   /* No recursion at top level */
3464
3465 match_block.lcc = tables + lcc_offset;
3466 match_block.ctypes = tables + ctypes_offset;
3467
3468 /* Partial matching is supported only for a restricted set of regexes at the
3469 moment. */
3470
3471 if (match_block.partial && (re->options & PCRE_NOPARTIAL) != 0)
3472   return PCRE_ERROR_BADPARTIAL;
3473
3474 /* Check a UTF-8 string if required. Unfortunately there's no way of passing
3475 back the character offset. */
3476
3477 #if !PCRE_UTF16
3478 #ifdef SUPPORT_UTF8
3479 if (match_block.utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
3480   {
3481   if (_pcre_valid_utf8((pcre_uchar *)subject, length) >= 0)
3482     return PCRE_ERROR_BADUTF8;
3483   if (start_offset > 0 && start_offset < length)
3484     {
3485     int tb = ((pcre_uchar *)subject)[start_offset];
3486     if (tb > 127)
3487       {
3488       tb &= 0xc0;
3489       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;
3490       }
3491     }
3492   }
3493 #endif
3494 #endif
3495
3496 /* The ims options can vary during the matching as a result of the presence
3497 of (?ims) items in the pattern. They are kept in a local variable so that
3498 restoring at the exit of a group is easy. */
3499
3500 ims = re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL);
3501
3502 /* If the expression has got more back references than the offsets supplied can
3503 hold, we get a temporary chunk of working store to use during the matching.
3504 Otherwise, we can use the vector supplied, rounding down its size to a multiple
3505 of 3. */
3506
3507 ocount = offsetcount - (offsetcount % 3);
3508
3509 if (re->top_backref > 0 && re->top_backref >= ocount/3)
3510   {
3511   ocount = re->top_backref * 3 + 3;
3512   match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
3513   if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
3514   using_temporary_offsets = TRUE;
3515   DPRINTF(("Got memory to hold back references\n"));
3516   }
3517 else match_block.offset_vector = offsets;
3518
3519 match_block.offset_end = ocount;
3520 match_block.offset_max = (2*ocount)/3;
3521 match_block.offset_overflow = FALSE;
3522 match_block.capture_last = -1;
3523
3524 /* Compute the minimum number of offsets that we need to reset each time. Doing
3525 this makes a huge difference to execution time when there aren't many brackets
3526 in the pattern. */
3527
3528 resetcount = 2 + re->top_bracket * 2;
3529 if (resetcount > offsetcount) resetcount = ocount;
3530
3531 /* Reset the working variable associated with each extraction. These should
3532 never be used unless previously set, but they get saved and restored, and so we
3533 initialize them to avoid reading uninitialized locations. */
3534
3535 if (match_block.offset_vector != NULL)
3536   {
3537   register int *iptr = match_block.offset_vector + ocount;
3538   register int *iend = iptr - resetcount/2 + 1;
3539   while (--iptr >= iend) *iptr = -1;
3540   }
3541
3542 /* Set up the first character to match, if available. The first_byte value is
3543 never set for an anchored regular expression, but the anchoring may be forced
3544 at run time, so we have to test for anchoring. The first char may be unset for
3545 an unanchored pattern, of course. If there's no first char and the pattern was
3546 studied, there may be a bitmap of possible first characters. */
3547
3548 if (!anchored)
3549   {
3550   if ((re->options & PCRE_FIRSTSET) != 0)
3551     {
3552     first_byte = re->first_byte & 255;
3553     if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
3554       first_byte = match_block.lcc[first_byte];
3555     }
3556   else
3557     if (!startline && study != NULL &&
3558       (study->options & PCRE_STUDY_MAPPED) != 0)
3559         start_bits = study->start_bits;
3560   }
3561
3562 /* For anchored or unanchored matches, there may be a "last known required
3563 character" set. */
3564
3565 if ((re->options & PCRE_REQCHSET) != 0)
3566   {
3567   req_byte = re->req_byte & 255;
3568   req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
3569   req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */
3570   }
3571
3572 /* Loop for handling unanchored repeated matching attempts; for anchored regexs
3573 the loop runs just once. */
3574
3575 do
3576   {
3577   const pcre_uchar *save_end_subject = end_subject;
3578
3579   /* Reset the maximum number of extractions we might see. */
3580
3581   if (match_block.offset_vector != NULL)
3582     {
3583     register int *iptr = match_block.offset_vector;
3584     register int *iend = iptr + resetcount;
3585     while (iptr < iend) *iptr++ = -1;
3586     }
3587
3588   /* Advance to a unique first char if possible. If firstline is TRUE, the
3589   start of the match is constrained to the first line of a multiline string.
3590   Implement this by temporarily adjusting end_subject so that we stop scanning
3591   at a newline. If the match fails at the newline, later code breaks this loop.
3592   */
3593
3594   if (firstline)
3595     {
3596     const pcre_uchar *t = start_match;
3597     while (t < save_end_subject && *t != '\n') t++;
3598     end_subject = t;
3599     }
3600
3601   /* Now test for a unique first byte */
3602
3603   if (first_byte >= 0)
3604     {
3605     if (first_byte_caseless)
3606       while (start_match < end_subject)
3607         {
3608         int sm = *start_match;
3609 #if PCRE_UTF16
3610         if (sm > 127)
3611           break;
3612 #endif
3613         if (match_block.lcc[sm] == first_byte)
3614           break;
3615         start_match++;
3616         }
3617     else
3618       while (start_match < end_subject && *start_match != first_byte)
3619         start_match++;
3620     }
3621
3622   /* Or to just after \n for a multiline match if possible */
3623
3624   else if (startline)
3625     {
3626     if (start_match > match_block.start_subject + start_offset)
3627       {
3628       while (start_match < end_subject && start_match[-1] != NEWLINE)
3629         start_match++;
3630       }
3631     }
3632
3633   /* Or to a non-unique first char after study */
3634
3635   else if (start_bits != NULL)
3636     {
3637     while (start_match < end_subject)
3638       {
3639       register unsigned int c = *start_match;
3640       if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;
3641       }
3642     }
3643
3644   /* Restore fudged end_subject */
3645
3646   end_subject = save_end_subject;
3647
3648 #ifdef DEBUG  /* Sigh. Some compilers never learn. */
3649   printf(">>>> Match against: ");
3650   pchars(start_match, end_subject - start_match, TRUE, &match_block);
3651   printf("\n");
3652 #endif
3653
3654   /* If req_byte is set, we know that that character must appear in the subject
3655   for the match to succeed. If the first character is set, req_byte must be
3656   later in the subject; otherwise the test starts at the match point. This
3657   optimization can save a huge amount of backtracking in patterns with nested
3658   unlimited repeats that aren't going to match. Writing separate code for
3659   cased/caseless versions makes it go faster, as does using an autoincrement
3660   and backing off on a match.
3661
3662   HOWEVER: when the subject string is very, very long, searching to its end can
3663   take a long time, and give bad performance on quite ordinary patterns. This
3664   showed up when somebody was matching /^C/ on a 32-megabyte string... so we
3665   don't do this when the string is sufficiently long.
3666
3667   ALSO: this processing is disabled when partial matching is requested.
3668   */
3669
3670   if (req_byte >= 0 &&
3671       end_subject - start_match < REQ_BYTE_MAX &&
3672       !match_block.partial)
3673     {
3674     register const pcre_uchar *p = start_match + ((first_byte >= 0)? 1 : 0);
3675
3676     /* We don't need to repeat the search if we haven't yet reached the
3677     place we found it at last time. */
3678
3679     if (p > req_byte_ptr)
3680       {
3681       if (req_byte_caseless)
3682         {
3683         while (p < end_subject)
3684           {
3685           register int pp = *p++;
3686           if (pp == req_byte || pp == req_byte2) { p--; break; }
3687           }
3688         }
3689       else
3690         {
3691         while (p < end_subject)
3692           {
3693           if (*p++ == req_byte) { p--; break; }
3694           }
3695         }
3696
3697       /* If we can't find the required character, break the matching loop */
3698
3699       if (p >= end_subject) break;
3700
3701       /* If we have found the required character, save the point where we
3702       found it, so that we don't search again next time round the loop if
3703       the start hasn't passed this character yet. */
3704
3705       req_byte_ptr = p;
3706       }
3707     }
3708
3709   /* When a match occurs, substrings will be set for all internal extractions;
3710   we just need to set up the whole thing as substring 0 before returning. If
3711   there were too many extractions, set the return code to zero. In the case
3712   where we had to get some local store to hold offsets for backreferences, copy
3713   those back references that we can. In this case there need not be overflow
3714   if certain parts of the pattern were not used. */
3715
3716   match_block.start_match = start_match;
3717   match_block.match_call_count = 0;
3718
3719   rc = match(start_match, match_block.start_code, 2, &match_block, ims, NULL,
3720     match_isgroup);
3721
3722   /* When the result is no match, if the subject's first character was a
3723   newline and the PCRE_FIRSTLINE option is set, break (which will return
3724   PCRE_ERROR_NOMATCH). The option requests that a match occur before the first
3725   newline in the subject. Otherwise, advance the pointer to the next character
3726   and continue - but the continuation will actually happen only when the
3727   pattern is not anchored. */
3728
3729   if (rc == MATCH_NOMATCH)
3730     {
3731     if (firstline && *start_match == NEWLINE) break;
3732     start_match++;
3733 #ifdef SUPPORT_UTF8
3734     if (match_block.utf8)
3735       while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
3736         start_match++;
3737 #endif
3738     continue;
3739     }
3740
3741   if (rc != MATCH_MATCH)
3742     {
3743     DPRINTF((">>>> error: returning %d\n", rc));
3744     return rc;
3745     }
3746
3747   /* We have a match! Copy the offset information from temporary store if
3748   necessary */
3749
3750   if (using_temporary_offsets)
3751     {
3752     if (offsetcount >= 4)
3753       {
3754       memcpy(offsets + 2, match_block.offset_vector + 2,
3755         (offsetcount - 2) * sizeof(int));
3756       DPRINTF(("Copied offsets from temporary memory\n"));
3757       }
3758     if (match_block.end_offset_top > offsetcount)
3759       match_block.offset_overflow = TRUE;
3760
3761     DPRINTF(("Freeing temporary memory\n"));
3762     (pcre_free)(match_block.offset_vector);
3763     }
3764
3765   rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
3766
3767   if (offsetcount < 2) rc = 0; else
3768     {
3769     offsets[0] = start_match - match_block.start_subject;
3770     offsets[1] = match_block.end_match_ptr - match_block.start_subject;
3771     }
3772
3773   DPRINTF((">>>> returning %d\n", rc));
3774   return rc;
3775   }
3776
3777 /* This "while" is the end of the "do" above */
3778
3779 while (!anchored && start_match <= end_subject);
3780
3781 if (using_temporary_offsets)
3782   {
3783   DPRINTF(("Freeing temporary memory\n"));
3784   (pcre_free)(match_block.offset_vector);
3785   }
3786
3787 if (match_block.partial && match_block.hitend)
3788   {
3789   DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
3790   return PCRE_ERROR_PARTIAL;
3791   }
3792 else
3793   {
3794   DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
3795   return PCRE_ERROR_NOMATCH;
3796   }
3797 }
3798
3799 /* End of pcre_exec.c */