File Coverage

deps/libgit2/deps/pcre/pcre_exec.c
Criterion Covered Total %
statement 250 1664 15.0
branch 154 1902 8.1
condition n/a
subroutine n/a
pod n/a
total 404 3566 11.3


line stmt bran cond sub pod time code
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-2018 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             /* This module contains pcre_exec(), the externally visible function that does
41             pattern matching using an NFA algorithm, trying to mimic Perl as closely as
42             possible. There are also some static supporting functions. */
43              
44             #ifdef HAVE_CONFIG_H
45             #include "config.h"
46             #endif
47              
48             #define NLBLOCK md /* Block containing newline information */
49             #define PSSTART start_subject /* Field containing processed string start */
50             #define PSEND end_subject /* Field containing processed string end */
51              
52             #include "pcre_internal.h"
53              
54             /* Undefine some potentially clashing cpp symbols */
55              
56             #undef min
57             #undef max
58              
59             /* The md->capture_last field uses the lower 16 bits for the last captured
60             substring (which can never be greater than 65535) and a bit in the top half
61             to mean "capture vector overflowed". This odd way of doing things was
62             implemented when it was realized that preserving and restoring the overflow bit
63             whenever the last capture number was saved/restored made for a neater
64             interface, and doing it this way saved on (a) another variable, which would
65             have increased the stack frame size (a big NO-NO in PCRE) and (b) another
66             separate set of save/restore instructions. The following defines are used in
67             implementing this. */
68              
69             #define CAPLMASK 0x0000ffff /* The bits used for last_capture */
70             #define OVFLMASK 0xffff0000 /* The bits used for the overflow flag */
71             #define OVFLBIT 0x00010000 /* The bit that is set for overflow */
72              
73             /* Values for setting in md->match_function_type to indicate two special types
74             of call to match(). We do it this way to save on using another stack variable,
75             as stack usage is to be discouraged. */
76              
77             #define MATCH_CONDASSERT 1 /* Called to check a condition assertion */
78             #define MATCH_CBEGROUP 2 /* Could-be-empty unlimited repeat group */
79              
80             /* Non-error returns from the match() function. Error returns are externally
81             defined PCRE_ERROR_xxx codes, which are all negative. */
82              
83             #define MATCH_MATCH 1
84             #define MATCH_NOMATCH 0
85              
86             /* Special internal returns from the match() function. Make them sufficiently
87             negative to avoid the external error codes. */
88              
89             #define MATCH_ACCEPT (-999)
90             #define MATCH_KETRPOS (-998)
91             #define MATCH_ONCE (-997)
92             /* The next 5 must be kept together and in sequence so that a test that checks
93             for any one of them can use a range. */
94             #define MATCH_COMMIT (-996)
95             #define MATCH_PRUNE (-995)
96             #define MATCH_SKIP (-994)
97             #define MATCH_SKIP_ARG (-993)
98             #define MATCH_THEN (-992)
99             #define MATCH_BACKTRACK_MAX MATCH_THEN
100             #define MATCH_BACKTRACK_MIN MATCH_COMMIT
101              
102             /* Maximum number of ints of offset to save on the stack for recursive calls.
103             If the offset vector is bigger, malloc is used. This should be a multiple of 3,
104             because the offset vector is always a multiple of 3 long. */
105              
106             #define REC_STACK_SAVE_MAX 30
107              
108             /* Min and max values for the common repeats; for the maxima, 0 => infinity */
109              
110             static const char rep_min[] = { 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, };
111             static const char rep_max[] = { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, };
112              
113             #ifdef PCRE_DEBUG
114             /*************************************************
115             * Debugging function to print chars *
116             *************************************************/
117              
118             /* Print a sequence of chars in printable format, stopping at the end of the
119             subject if the requested.
120              
121             Arguments:
122             p points to characters
123             length number to print
124             is_subject TRUE if printing from within md->start_subject
125             md pointer to matching data block, if is_subject is TRUE
126              
127             Returns: nothing
128             */
129              
130             static void
131             pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
132             {
133             pcre_uint32 c;
134             BOOL utf = md->utf;
135             if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
136             while (length-- > 0)
137             if (isprint(c = UCHAR21INCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c);
138             }
139             #endif
140              
141              
142              
143             /*************************************************
144             * Match a back-reference *
145             *************************************************/
146              
147             /* Normally, if a back reference hasn't been set, the length that is passed is
148             negative, so the match always fails. However, in JavaScript compatibility mode,
149             the length passed is zero. Note that in caseless UTF-8 mode, the number of
150             subject bytes matched may be different to the number of reference bytes.
151              
152             Arguments:
153             offset index into the offset vector
154             eptr pointer into the subject
155             length length of reference to be matched (number of bytes)
156             md points to match data block
157             caseless TRUE if caseless
158              
159             Returns: >= 0 the number of subject bytes matched
160             -1 no match
161             -2 partial match; always given if at end subject
162             */
163              
164             static int
165 0           match_ref(int offset, register PCRE_PUCHAR eptr, int length, match_data *md,
166             BOOL caseless)
167             {
168 0           PCRE_PUCHAR eptr_start = eptr;
169 0           register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
170             #if defined SUPPORT_UTF && defined SUPPORT_UCP
171             BOOL utf = md->utf;
172             #endif
173              
174             #ifdef PCRE_DEBUG
175             if (eptr >= md->end_subject)
176             printf("matching subject ");
177             else
178             {
179             printf("matching subject ");
180             pchars(eptr, length, TRUE, md);
181             }
182             printf(" against backref ");
183             pchars(p, length, FALSE, md);
184             printf("\n");
185             #endif
186              
187             /* Always fail if reference not set (and not JavaScript compatible - in that
188             case the length is passed as zero). */
189              
190 0 0         if (length < 0) return -1;
191              
192             /* Separate the caseless case for speed. In UTF-8 mode we can only do this
193             properly if Unicode properties are supported. Otherwise, we can check only
194             ASCII characters. */
195              
196 0 0         if (caseless)
197             {
198             #if defined SUPPORT_UTF && defined SUPPORT_UCP
199             if (utf)
200             {
201             /* Match characters up to the end of the reference. NOTE: the number of
202             data units matched may differ, because in UTF-8 there are some characters
203             whose upper and lower case versions code have different numbers of bytes.
204             For example, U+023A (2 bytes in UTF-8) is the upper case version of U+2C65
205             (3 bytes in UTF-8); a sequence of 3 of the former uses 6 bytes, as does a
206             sequence of two of the latter. It is important, therefore, to check the
207             length along the reference, not along the subject (earlier code did this
208             wrong). */
209              
210             PCRE_PUCHAR endptr = p + length;
211             while (p < endptr)
212             {
213             pcre_uint32 c, d;
214             const ucd_record *ur;
215             if (eptr >= md->end_subject) return -2; /* Partial match */
216             GETCHARINC(c, eptr);
217             GETCHARINC(d, p);
218             ur = GET_UCD(d);
219             if (c != d && c != d + ur->other_case)
220             {
221             const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
222             for (;;)
223             {
224             if (c < *pp) return -1;
225             if (c == *pp++) break;
226             }
227             }
228             }
229             }
230             else
231             #endif
232              
233             /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
234             is no UCP support. */
235             {
236 0 0         while (length-- > 0)
237             {
238             pcre_uint32 cc, cp;
239 0 0         if (eptr >= md->end_subject) return -2; /* Partial match */
240 0           cc = UCHAR21TEST(eptr);
241 0           cp = UCHAR21TEST(p);
242 0 0         if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1;
243 0           p++;
244 0           eptr++;
245             }
246             }
247             }
248              
249             /* In the caseful case, we can just compare the bytes, whether or not we
250             are in UTF-8 mode. */
251              
252             else
253             {
254 0 0         while (length-- > 0)
255             {
256 0 0         if (eptr >= md->end_subject) return -2; /* Partial match */
257 0 0         if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1;
258             }
259             }
260              
261 0           return (int)(eptr - eptr_start);
262             }
263              
264              
265              
266             /***************************************************************************
267             ****************************************************************************
268             RECURSION IN THE match() FUNCTION
269              
270             The match() function is highly recursive, though not every recursive call
271             increases the recursive depth. Nevertheless, some regular expressions can cause
272             it to recurse to a great depth. I was writing for Unix, so I just let it call
273             itself recursively. This uses the stack for saving everything that has to be
274             saved for a recursive call. On Unix, the stack can be large, and this works
275             fine.
276              
277             It turns out that on some non-Unix-like systems there are problems with
278             programs that use a lot of stack. (This despite the fact that every last chip
279             has oodles of memory these days, and techniques for extending the stack have
280             been known for decades.) So....
281              
282             There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
283             calls by keeping local variables that need to be preserved in blocks of memory
284             obtained from malloc() instead instead of on the stack. Macros are used to
285             achieve this so that the actual code doesn't look very different to what it
286             always used to.
287              
288             The original heap-recursive code used longjmp(). However, it seems that this
289             can be very slow on some operating systems. Following a suggestion from Stan
290             Switzer, the use of longjmp() has been abolished, at the cost of having to
291             provide a unique number for each call to RMATCH. There is no way of generating
292             a sequence of numbers at compile time in C. I have given them names, to make
293             them stand out more clearly.
294              
295             Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
296             FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
297             tests. Furthermore, not using longjmp() means that local dynamic variables
298             don't have indeterminate values; this has meant that the frame size can be
299             reduced because the result can be "passed back" by straight setting of the
300             variable instead of being passed in the frame.
301             ****************************************************************************
302             ***************************************************************************/
303              
304             /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
305             below must be updated in sync. */
306              
307             enum { RM1=1, RM2, RM3, RM4, RM5, RM6, RM7, RM8, RM9, RM10,
308             RM11, RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
309             RM21, RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
310             RM31, RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
311             RM41, RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
312             RM51, RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
313             RM61, RM62, RM63, RM64, RM65, RM66, RM67 };
314              
315             /* These versions of the macros use the stack, as normal. There are debugging
316             versions and production versions. Note that the "rw" argument of RMATCH isn't
317             actually used in this definition. */
318              
319             #ifndef NO_RECURSE
320             #define REGISTER register
321              
322             #ifdef PCRE_DEBUG
323             #define RMATCH(ra,rb,rc,rd,re,rw) \
324             { \
325             printf("match() called in line %d\n", __LINE__); \
326             rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1); \
327             printf("to line %d\n", __LINE__); \
328             }
329             #define RRETURN(ra) \
330             { \
331             printf("match() returned %d from line %d\n", ra, __LINE__); \
332             return ra; \
333             }
334             #else
335             #define RMATCH(ra,rb,rc,rd,re,rw) \
336             rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1)
337             #define RRETURN(ra) return ra
338             #endif
339              
340             #else
341              
342              
343             /* These versions of the macros manage a private stack on the heap. Note that
344             the "rd" argument of RMATCH isn't actually used in this definition. It's the md
345             argument of match(), which never changes. */
346              
347             #define REGISTER
348              
349             #define RMATCH(ra,rb,rc,rd,re,rw)\
350             {\
351             heapframe *newframe = frame->Xnextframe;\
352             if (newframe == NULL)\
353             {\
354             newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
355             if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
356             newframe->Xnextframe = NULL;\
357             frame->Xnextframe = newframe;\
358             }\
359             frame->Xwhere = rw;\
360             newframe->Xeptr = ra;\
361             newframe->Xecode = rb;\
362             newframe->Xmstart = mstart;\
363             newframe->Xoffset_top = rc;\
364             newframe->Xeptrb = re;\
365             newframe->Xrdepth = frame->Xrdepth + 1;\
366             newframe->Xprevframe = frame;\
367             frame = newframe;\
368             DPRINTF(("restarting from line %d\n", __LINE__));\
369             goto HEAP_RECURSE;\
370             L_##rw:\
371             DPRINTF(("jumped back to line %d\n", __LINE__));\
372             }
373              
374             #define RRETURN(ra)\
375             {\
376             heapframe *oldframe = frame;\
377             frame = oldframe->Xprevframe;\
378             if (frame != NULL)\
379             {\
380             rrc = ra;\
381             goto HEAP_RETURN;\
382             }\
383             return ra;\
384             }
385              
386              
387             /* Structure for remembering the local variables in a private frame */
388              
389             typedef struct heapframe {
390             struct heapframe *Xprevframe;
391             struct heapframe *Xnextframe;
392              
393             /* Function arguments that may change */
394              
395             PCRE_PUCHAR Xeptr;
396             const pcre_uchar *Xecode;
397             PCRE_PUCHAR Xmstart;
398             int Xoffset_top;
399             eptrblock *Xeptrb;
400             unsigned int Xrdepth;
401              
402             /* Function local variables */
403              
404             PCRE_PUCHAR Xcallpat;
405             #ifdef SUPPORT_UTF
406             PCRE_PUCHAR Xcharptr;
407             #endif
408             PCRE_PUCHAR Xdata;
409             PCRE_PUCHAR Xnext;
410             PCRE_PUCHAR Xpp;
411             PCRE_PUCHAR Xprev;
412             PCRE_PUCHAR Xsaved_eptr;
413              
414             recursion_info Xnew_recursive;
415              
416             BOOL Xcur_is_word;
417             BOOL Xcondition;
418             BOOL Xprev_is_word;
419              
420             #ifdef SUPPORT_UCP
421             int Xprop_type;
422             unsigned int Xprop_value;
423             int Xprop_fail_result;
424             int Xoclength;
425             pcre_uchar Xocchars[6];
426             #endif
427              
428             int Xcodelink;
429             int Xctype;
430             unsigned int Xfc;
431             int Xfi;
432             int Xlength;
433             int Xmax;
434             int Xmin;
435             unsigned int Xnumber;
436             int Xoffset;
437             unsigned int Xop;
438             pcre_int32 Xsave_capture_last;
439             int Xsave_offset1, Xsave_offset2, Xsave_offset3;
440             int Xstacksave[REC_STACK_SAVE_MAX];
441              
442             eptrblock Xnewptrb;
443              
444             /* Where to jump back to */
445              
446             int Xwhere;
447              
448             } heapframe;
449              
450             #endif
451              
452              
453             /***************************************************************************
454             ***************************************************************************/
455              
456              
457              
458             /*************************************************
459             * Match from current position *
460             *************************************************/
461              
462             /* This function is called recursively in many circumstances. Whenever it
463             returns a negative (error) response, the outer incarnation must also return the
464             same response. */
465              
466             /* These macros pack up tests that are used for partial matching, and which
467             appear several times in the code. We set the "hit end" flag if the pointer is
468             at the end of the subject and also past the start of the subject (i.e.
469             something has been matched). For hard partial matching, we then return
470             immediately. The second one is used when we already know we are past the end of
471             the subject. */
472              
473             #define CHECK_PARTIAL()\
474             if (md->partial != 0 && eptr >= md->end_subject && \
475             eptr > md->start_used_ptr) \
476             { \
477             md->hitend = TRUE; \
478             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
479             }
480              
481             #define SCHECK_PARTIAL()\
482             if (md->partial != 0 && eptr > md->start_used_ptr) \
483             { \
484             md->hitend = TRUE; \
485             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
486             }
487              
488              
489             /* Performance note: It might be tempting to extract commonly used fields from
490             the md structure (e.g. utf, end_subject) into individual variables to improve
491             performance. Tests using gcc on a SPARC disproved this; in the first case, it
492             made performance worse.
493              
494             Arguments:
495             eptr pointer to current character in subject
496             ecode pointer to current position in compiled code
497             mstart pointer to the current match start position (can be modified
498             by encountering \K)
499             offset_top current top pointer
500             md pointer to "static" info for the match
501             eptrb pointer to chain of blocks containing eptr at start of
502             brackets - for testing for empty matches
503             rdepth the recursion depth
504              
505             Returns: MATCH_MATCH if matched ) these values are >= 0
506             MATCH_NOMATCH if failed to match )
507             a negative MATCH_xxx value for PRUNE, SKIP, etc
508             a negative PCRE_ERROR_xxx value if aborted by an error condition
509             (e.g. stopped by repeated call or recursion limit)
510             */
511              
512             static int
513 153           match(REGISTER PCRE_PUCHAR eptr, REGISTER const pcre_uchar *ecode,
514             PCRE_PUCHAR mstart, int offset_top, match_data *md, eptrblock *eptrb,
515             unsigned int rdepth)
516             {
517             /* These variables do not need to be preserved over recursion in this function,
518             so they can be ordinary variables in all cases. Mark some of them with
519             "register" because they are used a lot in loops. */
520              
521             register int rrc; /* Returns from recursive calls */
522             register int i; /* Used for loops not involving calls to RMATCH() */
523             register pcre_uint32 c; /* Character values not kept over RMATCH() calls */
524             register BOOL utf; /* Local copy of UTF flag for speed */
525              
526             BOOL minimize, possessive; /* Quantifier options */
527             BOOL caseless;
528             int condcode;
529              
530             /* When recursion is not being used, all "local" variables that have to be
531             preserved over calls to RMATCH() are part of a "frame". We set up the top-level
532             frame on the stack here; subsequent instantiations are obtained from the heap
533             whenever RMATCH() does a "recursion". See the macro definitions above. Putting
534             the top-level on the stack rather than malloc-ing them all gives a performance
535             boost in many cases where there is not much "recursion". */
536              
537             #ifdef NO_RECURSE
538             heapframe *frame = (heapframe *)md->match_frames_base;
539              
540             /* Copy in the original argument variables */
541              
542             frame->Xeptr = eptr;
543             frame->Xecode = ecode;
544             frame->Xmstart = mstart;
545             frame->Xoffset_top = offset_top;
546             frame->Xeptrb = eptrb;
547             frame->Xrdepth = rdepth;
548              
549             /* This is where control jumps back to to effect "recursion" */
550              
551             HEAP_RECURSE:
552              
553             /* Macros make the argument variables come from the current frame */
554              
555             #define eptr frame->Xeptr
556             #define ecode frame->Xecode
557             #define mstart frame->Xmstart
558             #define offset_top frame->Xoffset_top
559             #define eptrb frame->Xeptrb
560             #define rdepth frame->Xrdepth
561              
562             /* Ditto for the local variables */
563              
564             #ifdef SUPPORT_UTF
565             #define charptr frame->Xcharptr
566             #endif
567             #define callpat frame->Xcallpat
568             #define codelink frame->Xcodelink
569             #define data frame->Xdata
570             #define next frame->Xnext
571             #define pp frame->Xpp
572             #define prev frame->Xprev
573             #define saved_eptr frame->Xsaved_eptr
574              
575             #define new_recursive frame->Xnew_recursive
576              
577             #define cur_is_word frame->Xcur_is_word
578             #define condition frame->Xcondition
579             #define prev_is_word frame->Xprev_is_word
580              
581             #ifdef SUPPORT_UCP
582             #define prop_type frame->Xprop_type
583             #define prop_value frame->Xprop_value
584             #define prop_fail_result frame->Xprop_fail_result
585             #define oclength frame->Xoclength
586             #define occhars frame->Xocchars
587             #endif
588              
589             #define ctype frame->Xctype
590             #define fc frame->Xfc
591             #define fi frame->Xfi
592             #define length frame->Xlength
593             #define max frame->Xmax
594             #define min frame->Xmin
595             #define number frame->Xnumber
596             #define offset frame->Xoffset
597             #define op frame->Xop
598             #define save_capture_last frame->Xsave_capture_last
599             #define save_offset1 frame->Xsave_offset1
600             #define save_offset2 frame->Xsave_offset2
601             #define save_offset3 frame->Xsave_offset3
602             #define stacksave frame->Xstacksave
603              
604             #define newptrb frame->Xnewptrb
605              
606             /* When recursion is being used, local variables are allocated on the stack and
607             get preserved during recursion in the normal way. In this environment, fi and
608             i, and fc and c, can be the same variables. */
609              
610             #else /* NO_RECURSE not defined */
611             #define fi i
612             #define fc c
613              
614             /* Many of the following variables are used only in small blocks of the code.
615             My normal style of coding would have declared them within each of those blocks.
616             However, in order to accommodate the version of this code that uses an external
617             "stack" implemented on the heap, it is easier to declare them all here, so the
618             declarations can be cut out in a block. The only declarations within blocks
619             below are for variables that do not have to be preserved over a recursive call
620             to RMATCH(). */
621              
622             #ifdef SUPPORT_UTF
623             const pcre_uchar *charptr;
624             #endif
625             const pcre_uchar *callpat;
626             const pcre_uchar *data;
627             const pcre_uchar *next;
628             PCRE_PUCHAR pp;
629             const pcre_uchar *prev;
630             PCRE_PUCHAR saved_eptr;
631              
632             recursion_info new_recursive;
633              
634             BOOL cur_is_word;
635             BOOL condition;
636             BOOL prev_is_word;
637              
638             #ifdef SUPPORT_UCP
639             int prop_type;
640             unsigned int prop_value;
641             int prop_fail_result;
642             int oclength;
643             pcre_uchar occhars[6];
644             #endif
645              
646             int codelink;
647             int ctype;
648             int length;
649             int max;
650             int min;
651             unsigned int number;
652             int offset;
653             unsigned int op;
654             pcre_int32 save_capture_last;
655             int save_offset1, save_offset2, save_offset3;
656             int stacksave[REC_STACK_SAVE_MAX];
657              
658             eptrblock newptrb;
659              
660             /* There is a special fudge for calling match() in a way that causes it to
661             measure the size of its basic stack frame when the stack is being used for
662             recursion. The second argument (ecode) being NULL triggers this behaviour. It
663             cannot normally ever be NULL. The return is the negated value of the frame
664             size. */
665              
666 153 50         if (ecode == NULL)
667             {
668 0 0         if (rdepth == 0)
669 0           return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
670             else
671             {
672 0           int len = (int)((char *)&rdepth - (char *)eptr);
673 0           return (len > 0)? -len : len;
674             }
675             }
676             #endif /* NO_RECURSE */
677              
678             /* To save space on the stack and in the heap frame, I have doubled up on some
679             of the local variables that are used only in localised parts of the code, but
680             still need to be preserved over recursive calls of match(). These macros define
681             the alternative names that are used. */
682              
683             #define allow_zero cur_is_word
684             #define cbegroup condition
685             #define code_offset codelink
686             #define condassert condition
687             #define matched_once prev_is_word
688             #define foc number
689             #define save_mark data
690              
691             /* These statements are here to stop the compiler complaining about unitialized
692             variables. */
693              
694             #ifdef SUPPORT_UCP
695             prop_value = 0;
696             prop_fail_result = 0;
697             #endif
698              
699              
700             /* This label is used for tail recursion, which is used in a few cases even
701             when NO_RECURSE is not defined, in order to reduce the amount of stack that is
702             used. Thanks to Ian Taylor for noticing this possibility and sending the
703             original patch. */
704              
705             TAIL_RECURSE:
706              
707             /* OK, now we can get on with the real code of the function. Recursive calls
708             are specified by the macro RMATCH and RRETURN is used to return. When
709             NO_RECURSE is *not* defined, these just turn into a recursive call to match()
710             and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
711             defined). However, RMATCH isn't like a function call because it's quite a
712             complicated macro. It has to be used in one particular way. This shouldn't,
713             however, impact performance when true recursion is being used. */
714              
715             #ifdef SUPPORT_UTF
716             utf = md->utf; /* Local copy of the flag */
717             #else
718 244           utf = FALSE;
719             #endif
720              
721             /* First check that we haven't called match() too many times, or that we
722             haven't exceeded the recursive call limit. */
723              
724 244 50         if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
725 244 50         if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
726              
727             /* At the start of a group with an unlimited repeat that may match an empty
728             string, the variable md->match_function_type is set to MATCH_CBEGROUP. It is
729             done this way to save having to use another function argument, which would take
730             up space on the stack. See also MATCH_CONDASSERT below.
731              
732             When MATCH_CBEGROUP is set, add the current subject pointer to the chain of
733             such remembered pointers, to be checked when we hit the closing ket, in order
734             to break infinite loops that match no characters. When match() is called in
735             other circumstances, don't add to the chain. The MATCH_CBEGROUP feature must
736             NOT be used with tail recursion, because the memory block that is used is on
737             the stack, so a new one may be required for each match(). */
738              
739 244 50         if (md->match_function_type == MATCH_CBEGROUP)
740             {
741 0           newptrb.epb_saved_eptr = eptr;
742 0           newptrb.epb_prev = eptrb;
743 0           eptrb = &newptrb;
744 0           md->match_function_type = 0;
745             }
746              
747             /* Now start processing the opcodes. */
748              
749             for (;;)
750             {
751 607           minimize = possessive = FALSE;
752 607           op = *ecode;
753              
754 607           switch(op)
755             {
756             case OP_MARK:
757 0           md->nomatch_mark = ecode + 2;
758 0           md->mark = NULL; /* In case previously set by assertion */
759 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
760             eptrb, RM55);
761 0 0         if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
    0          
    0          
762 0           md->mark == NULL) md->mark = ecode + 2;
763              
764             /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
765             argument, and we must check whether that argument matches this MARK's
766             argument. It is passed back in md->start_match_ptr (an overloading of that
767             variable). If it does match, we reset that variable to the current subject
768             position and return MATCH_SKIP. Otherwise, pass back the return code
769             unaltered. */
770              
771 0 0         else if (rrc == MATCH_SKIP_ARG &&
    0          
772 0           STRCMP_UC_UC_TEST(ecode + 2, md->start_match_ptr) == 0)
773             {
774 0           md->start_match_ptr = eptr;
775 0           RRETURN(MATCH_SKIP);
776             }
777 0           RRETURN(rrc);
778              
779             case OP_FAIL:
780 0           RRETURN(MATCH_NOMATCH);
781              
782             case OP_COMMIT:
783 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
784             eptrb, RM52);
785 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
786 0           RRETURN(MATCH_COMMIT);
787              
788             case OP_PRUNE:
789 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
790             eptrb, RM51);
791 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
792 0           RRETURN(MATCH_PRUNE);
793              
794             case OP_PRUNE_ARG:
795 0           md->nomatch_mark = ecode + 2;
796 0           md->mark = NULL; /* In case previously set by assertion */
797 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
798             eptrb, RM56);
799 0 0         if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
    0          
    0          
800 0           md->mark == NULL) md->mark = ecode + 2;
801 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
802 0           RRETURN(MATCH_PRUNE);
803              
804             case OP_SKIP:
805 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
806             eptrb, RM53);
807 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
808 0           md->start_match_ptr = eptr; /* Pass back current position */
809 0           RRETURN(MATCH_SKIP);
810              
811             /* Note that, for Perl compatibility, SKIP with an argument does NOT set
812             nomatch_mark. When a pattern match ends with a SKIP_ARG for which there was
813             not a matching mark, we have to re-run the match, ignoring the SKIP_ARG
814             that failed and any that precede it (either they also failed, or were not
815             triggered). To do this, we maintain a count of executed SKIP_ARGs. If a
816             SKIP_ARG gets to top level, the match is re-run with md->ignore_skip_arg
817             set to the count of the one that failed. */
818              
819             case OP_SKIP_ARG:
820 0           md->skip_arg_count++;
821 0 0         if (md->skip_arg_count <= md->ignore_skip_arg)
822             {
823 0           ecode += PRIV(OP_lengths)[*ecode] + ecode[1];
824 0           break;
825             }
826 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
827             eptrb, RM57);
828 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
829              
830             /* Pass back the current skip name by overloading md->start_match_ptr and
831             returning the special MATCH_SKIP_ARG return code. This will either be
832             caught by a matching MARK, or get to the top, where it causes a rematch
833             with md->ignore_skip_arg set to the value of md->skip_arg_count. */
834              
835 0           md->start_match_ptr = ecode + 2;
836 0           RRETURN(MATCH_SKIP_ARG);
837              
838             /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
839             the branch in which it occurs can be determined. Overload the start of
840             match pointer to do this. */
841              
842             case OP_THEN:
843 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
844             eptrb, RM54);
845 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
846 0           md->start_match_ptr = ecode;
847 0           RRETURN(MATCH_THEN);
848              
849             case OP_THEN_ARG:
850 0           md->nomatch_mark = ecode + 2;
851 0           md->mark = NULL; /* In case previously set by assertion */
852 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top,
853             md, eptrb, RM58);
854 0 0         if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
    0          
    0          
855 0           md->mark == NULL) md->mark = ecode + 2;
856 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
857 0           md->start_match_ptr = ecode;
858 0           RRETURN(MATCH_THEN);
859              
860             /* Handle an atomic group that does not contain any capturing parentheses.
861             This can be handled like an assertion. Prior to 8.13, all atomic groups
862             were handled this way. In 8.13, the code was changed as below for ONCE, so
863             that backups pass through the group and thereby reset captured values.
864             However, this uses a lot more stack, so in 8.20, atomic groups that do not
865             contain any captures generate OP_ONCE_NC, which can be handled in the old,
866             less stack intensive way.
867              
868             Check the alternative branches in turn - the matching won't pass the KET
869             for this kind of subpattern. If any one branch matches, we carry on as at
870             the end of a normal bracket, leaving the subject pointer, but resetting
871             the start-of-match value in case it was changed by \K. */
872              
873             case OP_ONCE_NC:
874 0           prev = ecode;
875 0           saved_eptr = eptr;
876 0           save_mark = md->mark;
877             do
878             {
879 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
880 0 0         if (rrc == MATCH_MATCH) /* Note: _not_ MATCH_ACCEPT */
881             {
882 0           mstart = md->start_match_ptr;
883 0           break;
884             }
885 0 0         if (rrc == MATCH_THEN)
886             {
887 0           next = ecode + GET(ecode,1);
888 0 0         if (md->start_match_ptr < next &&
    0          
889 0 0         (*ecode == OP_ALT || *next == OP_ALT))
890 0           rrc = MATCH_NOMATCH;
891             }
892              
893 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
894 0           ecode += GET(ecode,1);
895 0           md->mark = save_mark;
896             }
897 0 0         while (*ecode == OP_ALT);
898              
899             /* If hit the end of the group (which could be repeated), fail */
900              
901 0 0         if (*ecode != OP_ONCE_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
    0          
902              
903             /* Continue as from after the group, updating the offsets high water
904             mark, since extracts may have been taken. */
905              
906 0 0         do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
907              
908 0           offset_top = md->end_offset_top;
909 0           eptr = md->end_match_ptr;
910              
911             /* For a non-repeating ket, just continue at this level. This also
912             happens for a repeating ket if no characters were matched in the group.
913             This is the forcible breaking of infinite loops as implemented in Perl
914             5.005. */
915              
916 0 0         if (*ecode == OP_KET || eptr == saved_eptr)
    0          
917             {
918 0           ecode += 1+LINK_SIZE;
919 0           break;
920             }
921              
922             /* The repeating kets try the rest of the pattern or restart from the
923             preceding bracket, in the appropriate order. The second "call" of match()
924             uses tail recursion, to avoid using another stack frame. */
925              
926 0 0         if (*ecode == OP_KETRMIN)
927             {
928 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
929 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
930 0           ecode = prev;
931 0           goto TAIL_RECURSE;
932             }
933             else /* OP_KETRMAX */
934             {
935 0           RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
936 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
937 0           ecode += 1 + LINK_SIZE;
938 0           goto TAIL_RECURSE;
939             }
940             /* Control never gets here */
941              
942             /* Handle a capturing bracket, other than those that are possessive with an
943             unlimited repeat. If there is space in the offset vector, save the current
944             subject position in the working slot at the top of the vector. We mustn't
945             change the current values of the data slot, because they may be set from a
946             previous iteration of this group, and be referred to by a reference inside
947             the group. A failure to match might occur after the group has succeeded,
948             if something later on doesn't match. For this reason, we need to restore
949             the working value and also the values of the final offsets, in case they
950             were set by a previous iteration of the same bracket.
951              
952             If there isn't enough space in the offset vector, treat this as if it were
953             a non-capturing bracket. Don't worry about setting the flag for the error
954             case here; that is handled in the code for KET. */
955              
956             case OP_CBRA:
957             case OP_SCBRA:
958 10           number = GET2(ecode, 1+LINK_SIZE);
959 10           offset = number << 1;
960              
961             #ifdef PCRE_DEBUG
962             printf("start bracket %d\n", number);
963             printf("subject=");
964             pchars(eptr, 16, TRUE, md);
965             printf("\n");
966             #endif
967              
968 10 50         if (offset < md->offset_max)
969             {
970 0           save_offset1 = md->offset_vector[offset];
971 0           save_offset2 = md->offset_vector[offset+1];
972 0           save_offset3 = md->offset_vector[md->offset_end - number];
973 0           save_capture_last = md->capture_last;
974 0           save_mark = md->mark;
975              
976             DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
977 0           md->offset_vector[md->offset_end - number] =
978 0           (int)(eptr - md->start_subject);
979              
980             for (;;)
981             {
982 0 0         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
983 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
984             eptrb, RM1);
985 0 0         if (rrc == MATCH_ONCE) break; /* Backing up through an atomic group */
986              
987             /* If we backed up to a THEN, check whether it is within the current
988             branch by comparing the address of the THEN that is passed back with
989             the end of the branch. If it is within the current branch, and the
990             branch is one of two or more alternatives (it either starts or ends
991             with OP_ALT), we have reached the limit of THEN's action, so convert
992             the return code to NOMATCH, which will cause normal backtracking to
993             happen from now on. Otherwise, THEN is passed back to an outer
994             alternative. This implements Perl's treatment of parenthesized groups,
995             where a group not containing | does not affect the current alternative,
996             that is, (X) is NOT the same as (X|(*F)). */
997              
998 0 0         if (rrc == MATCH_THEN)
999             {
1000 0           next = ecode + GET(ecode,1);
1001 0 0         if (md->start_match_ptr < next &&
    0          
1002 0 0         (*ecode == OP_ALT || *next == OP_ALT))
1003 0           rrc = MATCH_NOMATCH;
1004             }
1005              
1006             /* Anything other than NOMATCH is passed back. */
1007              
1008 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1009 0           md->capture_last = save_capture_last;
1010 0           ecode += GET(ecode, 1);
1011 0           md->mark = save_mark;
1012 0 0         if (*ecode != OP_ALT) break;
1013 0           }
1014              
1015             DPRINTF(("bracket %d failed\n", number));
1016 0           md->offset_vector[offset] = save_offset1;
1017 0           md->offset_vector[offset+1] = save_offset2;
1018 0           md->offset_vector[md->offset_end - number] = save_offset3;
1019              
1020             /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
1021              
1022 0           RRETURN(rrc);
1023             }
1024              
1025             /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
1026             as a non-capturing bracket. */
1027              
1028             /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1029             /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1030              
1031             DPRINTF(("insufficient capture room: treat as non-capturing\n"));
1032              
1033             /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1034             /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1035              
1036             /* Non-capturing or atomic group, except for possessive with unlimited
1037             repeat and ONCE group with no captures. Loop for all the alternatives.
1038              
1039             When we get to the final alternative within the brackets, we used to return
1040             the result of a recursive call to match() whatever happened so it was
1041             possible to reduce stack usage by turning this into a tail recursion,
1042             except in the case of a possibly empty group. However, now that there is
1043             the possiblity of (*THEN) occurring in the final alternative, this
1044             optimization is no longer always possible.
1045              
1046             We can optimize if we know there are no (*THEN)s in the pattern; at present
1047             this is the best that can be done.
1048              
1049             MATCH_ONCE is returned when the end of an atomic group is successfully
1050             reached, but subsequent matching fails. It passes back up the tree (causing
1051             captured values to be reset) until the original atomic group level is
1052             reached. This is tested by comparing md->once_target with the start of the
1053             group. At this point, the return is converted into MATCH_NOMATCH so that
1054             previous backup points can be taken. */
1055              
1056             case OP_ONCE:
1057             case OP_BRA:
1058             case OP_SBRA:
1059             DPRINTF(("start non-capturing bracket\n"));
1060              
1061             for (;;)
1062             {
1063 91 50         if (op >= OP_SBRA || op == OP_ONCE)
    50          
1064 0           md->match_function_type = MATCH_CBEGROUP;
1065              
1066             /* If this is not a possibly empty group, and there are no (*THEN)s in
1067             the pattern, and this is the final alternative, optimize as described
1068             above. */
1069              
1070 91 50         else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
    50          
1071             {
1072 91           ecode += PRIV(OP_lengths)[*ecode];
1073 91           goto TAIL_RECURSE;
1074             }
1075              
1076             /* In all other cases, we have to make another call to match(). */
1077              
1078 0           save_mark = md->mark;
1079 0           save_capture_last = md->capture_last;
1080 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
1081             RM2);
1082              
1083             /* See comment in the code for capturing groups above about handling
1084             THEN. */
1085              
1086 0 0         if (rrc == MATCH_THEN)
1087             {
1088 0           next = ecode + GET(ecode,1);
1089 0 0         if (md->start_match_ptr < next &&
    0          
1090 0 0         (*ecode == OP_ALT || *next == OP_ALT))
1091 0           rrc = MATCH_NOMATCH;
1092             }
1093              
1094 0 0         if (rrc != MATCH_NOMATCH)
1095             {
1096 0 0         if (rrc == MATCH_ONCE)
1097             {
1098 0           const pcre_uchar *scode = ecode;
1099 0 0         if (*scode != OP_ONCE) /* If not at start, find it */
1100             {
1101 0 0         while (*scode == OP_ALT) scode += GET(scode, 1);
1102 0           scode -= GET(scode, 1);
1103             }
1104 0 0         if (md->once_target == scode) rrc = MATCH_NOMATCH;
1105             }
1106 0           RRETURN(rrc);
1107             }
1108 0           ecode += GET(ecode, 1);
1109 0           md->mark = save_mark;
1110 0 0         if (*ecode != OP_ALT) break;
1111 0           md->capture_last = save_capture_last;
1112 0           }
1113              
1114 0           RRETURN(MATCH_NOMATCH);
1115              
1116             /* Handle possessive capturing brackets with an unlimited repeat. We come
1117             here from BRAZERO with allow_zero set TRUE. The offset_vector values are
1118             handled similarly to the normal case above. However, the matching is
1119             different. The end of these brackets will always be OP_KETRPOS, which
1120             returns MATCH_KETRPOS without going further in the pattern. By this means
1121             we can handle the group by iteration rather than recursion, thereby
1122             reducing the amount of stack needed. */
1123              
1124             case OP_CBRAPOS:
1125             case OP_SCBRAPOS:
1126 0           allow_zero = FALSE;
1127              
1128             POSSESSIVE_CAPTURE:
1129 0           number = GET2(ecode, 1+LINK_SIZE);
1130 0           offset = number << 1;
1131              
1132             #ifdef PCRE_DEBUG
1133             printf("start possessive bracket %d\n", number);
1134             printf("subject=");
1135             pchars(eptr, 16, TRUE, md);
1136             printf("\n");
1137             #endif
1138              
1139 0 0         if (offset >= md->offset_max) goto POSSESSIVE_NON_CAPTURE;
1140              
1141 0           matched_once = FALSE;
1142 0           code_offset = (int)(ecode - md->start_code);
1143              
1144 0           save_offset1 = md->offset_vector[offset];
1145 0           save_offset2 = md->offset_vector[offset+1];
1146 0           save_offset3 = md->offset_vector[md->offset_end - number];
1147 0           save_capture_last = md->capture_last;
1148              
1149             DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
1150              
1151             /* Each time round the loop, save the current subject position for use
1152             when the group matches. For MATCH_MATCH, the group has matched, so we
1153             restart it with a new subject starting position, remembering that we had
1154             at least one match. For MATCH_NOMATCH, carry on with the alternatives, as
1155             usual. If we haven't matched any alternatives in any iteration, check to
1156             see if a previous iteration matched. If so, the group has matched;
1157             continue from afterwards. Otherwise it has failed; restore the previous
1158             capture values before returning NOMATCH. */
1159              
1160             for (;;)
1161             {
1162 0           md->offset_vector[md->offset_end - number] =
1163 0           (int)(eptr - md->start_subject);
1164 0 0         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1165 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
1166             eptrb, RM63);
1167 0 0         if (rrc == MATCH_KETRPOS)
1168             {
1169 0           offset_top = md->end_offset_top;
1170 0           ecode = md->start_code + code_offset;
1171 0           save_capture_last = md->capture_last;
1172 0           matched_once = TRUE;
1173 0           mstart = md->start_match_ptr; /* In case \K changed it */
1174 0 0         if (eptr == md->end_match_ptr) /* Matched an empty string */
1175             {
1176 0 0         do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1177 0           break;
1178             }
1179 0           eptr = md->end_match_ptr;
1180 0           continue;
1181             }
1182              
1183             /* See comment in the code for capturing groups above about handling
1184             THEN. */
1185              
1186 0 0         if (rrc == MATCH_THEN)
1187             {
1188 0           next = ecode + GET(ecode,1);
1189 0 0         if (md->start_match_ptr < next &&
    0          
1190 0 0         (*ecode == OP_ALT || *next == OP_ALT))
1191 0           rrc = MATCH_NOMATCH;
1192             }
1193              
1194 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1195 0           md->capture_last = save_capture_last;
1196 0           ecode += GET(ecode, 1);
1197 0 0         if (*ecode != OP_ALT) break;
1198 0           }
1199              
1200 0 0         if (!matched_once)
1201             {
1202 0           md->offset_vector[offset] = save_offset1;
1203 0           md->offset_vector[offset+1] = save_offset2;
1204 0           md->offset_vector[md->offset_end - number] = save_offset3;
1205             }
1206              
1207 0 0         if (allow_zero || matched_once)
    0          
1208             {
1209 0           ecode += 1 + LINK_SIZE;
1210 0           break;
1211             }
1212              
1213 0           RRETURN(MATCH_NOMATCH);
1214              
1215             /* Non-capturing possessive bracket with unlimited repeat. We come here
1216             from BRAZERO with allow_zero = TRUE. The code is similar to the above,
1217             without the capturing complication. It is written out separately for speed
1218             and cleanliness. */
1219              
1220             case OP_BRAPOS:
1221             case OP_SBRAPOS:
1222 0           allow_zero = FALSE;
1223              
1224             POSSESSIVE_NON_CAPTURE:
1225 0           matched_once = FALSE;
1226 0           code_offset = (int)(ecode - md->start_code);
1227 0           save_capture_last = md->capture_last;
1228              
1229             for (;;)
1230             {
1231 0 0         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1232 0           RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
1233             eptrb, RM48);
1234 0 0         if (rrc == MATCH_KETRPOS)
1235             {
1236 0           offset_top = md->end_offset_top;
1237 0           ecode = md->start_code + code_offset;
1238 0           matched_once = TRUE;
1239 0           mstart = md->start_match_ptr; /* In case \K reset it */
1240 0 0         if (eptr == md->end_match_ptr) /* Matched an empty string */
1241             {
1242 0 0         do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1243 0           break;
1244             }
1245 0           eptr = md->end_match_ptr;
1246 0           continue;
1247             }
1248              
1249             /* See comment in the code for capturing groups above about handling
1250             THEN. */
1251              
1252 0 0         if (rrc == MATCH_THEN)
1253             {
1254 0           next = ecode + GET(ecode,1);
1255 0 0         if (md->start_match_ptr < next &&
    0          
1256 0 0         (*ecode == OP_ALT || *next == OP_ALT))
1257 0           rrc = MATCH_NOMATCH;
1258             }
1259              
1260 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1261 0           ecode += GET(ecode, 1);
1262 0 0         if (*ecode != OP_ALT) break;
1263 0           md->capture_last = save_capture_last;
1264 0           }
1265              
1266 0 0         if (matched_once || allow_zero)
    0          
1267             {
1268 0           ecode += 1 + LINK_SIZE;
1269 0           break;
1270             }
1271 0           RRETURN(MATCH_NOMATCH);
1272              
1273             /* Control never reaches here. */
1274              
1275             /* Conditional group: compilation checked that there are no more than two
1276             branches. If the condition is false, skipping the first branch takes us
1277             past the end of the item if there is only one branch, but that's exactly
1278             what we want. */
1279              
1280             case OP_COND:
1281             case OP_SCOND:
1282              
1283             /* The variable codelink will be added to ecode when the condition is
1284             false, to get to the second branch. Setting it to the offset to the ALT
1285             or KET, then incrementing ecode achieves this effect. We now have ecode
1286             pointing to the condition or callout. */
1287              
1288 0           codelink = GET(ecode, 1); /* Offset to the second branch */
1289 0           ecode += 1 + LINK_SIZE; /* From this opcode */
1290              
1291             /* Because of the way auto-callout works during compile, a callout item is
1292             inserted between OP_COND and an assertion condition. */
1293              
1294 0 0         if (*ecode == OP_CALLOUT)
1295             {
1296 0 0         if (PUBL(callout) != NULL)
1297             {
1298             PUBL(callout_block) cb;
1299 0           cb.version = 2; /* Version 1 of the callout block */
1300 0           cb.callout_number = ecode[1];
1301 0           cb.offset_vector = md->offset_vector;
1302             #if defined COMPILE_PCRE8
1303 0           cb.subject = (PCRE_SPTR)md->start_subject;
1304             #elif defined COMPILE_PCRE16
1305             cb.subject = (PCRE_SPTR16)md->start_subject;
1306             #elif defined COMPILE_PCRE32
1307             cb.subject = (PCRE_SPTR32)md->start_subject;
1308             #endif
1309 0           cb.subject_length = (int)(md->end_subject - md->start_subject);
1310 0           cb.start_match = (int)(mstart - md->start_subject);
1311 0           cb.current_position = (int)(eptr - md->start_subject);
1312 0           cb.pattern_position = GET(ecode, 2);
1313 0           cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1314 0           cb.capture_top = offset_top/2;
1315 0           cb.capture_last = md->capture_last & CAPLMASK;
1316             /* Internal change requires this for API compatibility. */
1317 0 0         if (cb.capture_last == 0) cb.capture_last = -1;
1318 0           cb.callout_data = md->callout_data;
1319 0           cb.mark = md->nomatch_mark;
1320 0 0         if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1321 0 0         if (rrc < 0) RRETURN(rrc);
1322             }
1323              
1324             /* Advance ecode past the callout, so it now points to the condition. We
1325             must adjust codelink so that the value of ecode+codelink is unchanged. */
1326              
1327 0           ecode += PRIV(OP_lengths)[OP_CALLOUT];
1328 0           codelink -= PRIV(OP_lengths)[OP_CALLOUT];
1329             }
1330              
1331             /* Test the various possible conditions */
1332              
1333 0           condition = FALSE;
1334 0           switch(condcode = *ecode)
1335             {
1336             case OP_RREF: /* Numbered group recursion test */
1337 0 0         if (md->recursive != NULL) /* Not recursing => FALSE */
1338             {
1339 0           unsigned int recno = GET2(ecode, 1); /* Recursion group number*/
1340 0 0         condition = (recno == RREF_ANY || recno == md->recursive->group_num);
    0          
1341             }
1342 0           break;
1343              
1344             case OP_DNRREF: /* Duplicate named group recursion test */
1345 0 0         if (md->recursive != NULL)
1346             {
1347 0           int count = GET2(ecode, 1 + IMM2_SIZE);
1348 0           pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1349 0 0         while (count-- > 0)
1350             {
1351 0           unsigned int recno = GET2(slot, 0);
1352 0           condition = recno == md->recursive->group_num;
1353 0 0         if (condition) break;
1354 0           slot += md->name_entry_size;
1355             }
1356             }
1357 0           break;
1358              
1359             case OP_CREF: /* Numbered group used test */
1360 0           offset = GET2(ecode, 1) << 1; /* Doubled ref number */
1361 0 0         condition = offset < offset_top && md->offset_vector[offset] >= 0;
    0          
1362 0           break;
1363              
1364             case OP_DNCREF: /* Duplicate named group used test */
1365             {
1366 0           int count = GET2(ecode, 1 + IMM2_SIZE);
1367 0           pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1368 0 0         while (count-- > 0)
1369             {
1370 0           offset = GET2(slot, 0) << 1;
1371 0 0         condition = offset < offset_top && md->offset_vector[offset] >= 0;
    0          
1372 0 0         if (condition) break;
1373 0           slot += md->name_entry_size;
1374             }
1375             }
1376 0           break;
1377              
1378             case OP_DEF: /* DEFINE - always false */
1379             case OP_FAIL: /* From optimized (?!) condition */
1380 0           break;
1381              
1382             /* The condition is an assertion. Call match() to evaluate it - setting
1383             md->match_function_type to MATCH_CONDASSERT causes it to stop at the end
1384             of an assertion. */
1385              
1386             default:
1387 0           md->match_function_type = MATCH_CONDASSERT;
1388 0           RMATCH(eptr, ecode, offset_top, md, NULL, RM3);
1389 0 0         if (rrc == MATCH_MATCH)
1390             {
1391 0 0         if (md->end_offset_top > offset_top)
1392 0           offset_top = md->end_offset_top; /* Captures may have happened */
1393 0           condition = TRUE;
1394              
1395             /* Advance ecode past the assertion to the start of the first branch,
1396             but adjust it so that the general choosing code below works. If the
1397             assertion has a quantifier that allows zero repeats we must skip over
1398             the BRAZERO. This is a lunatic thing to do, but somebody did! */
1399              
1400 0 0         if (*ecode == OP_BRAZERO) ecode++;
1401 0           ecode += GET(ecode, 1);
1402 0 0         while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1403 0           ecode += 1 + LINK_SIZE - PRIV(OP_lengths)[condcode];
1404             }
1405              
1406             /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
1407             assertion; it is therefore treated as NOMATCH. Any other return is an
1408             error. */
1409              
1410 0 0         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
    0          
1411             {
1412 0           RRETURN(rrc); /* Need braces because of following else */
1413             }
1414 0           break;
1415             }
1416              
1417             /* Choose branch according to the condition */
1418              
1419 0 0         ecode += condition? PRIV(OP_lengths)[condcode] : codelink;
1420              
1421             /* We are now at the branch that is to be obeyed. As there is only one, we
1422             can use tail recursion to avoid using another stack frame, except when
1423             there is unlimited repeat of a possibly empty group. In the latter case, a
1424             recursive call to match() is always required, unless the second alternative
1425             doesn't exist, in which case we can just plough on. Note that, for
1426             compatibility with Perl, the | in a conditional group is NOT treated as
1427             creating two alternatives. If a THEN is encountered in the branch, it
1428             propagates out to the enclosing alternative (unless nested in a deeper set
1429             of alternatives, of course). */
1430              
1431 0 0         if (condition || ecode[-(1+LINK_SIZE)] == OP_ALT)
    0          
1432             {
1433 0 0         if (op != OP_SCOND)
1434             {
1435 0           goto TAIL_RECURSE;
1436             }
1437              
1438 0           md->match_function_type = MATCH_CBEGROUP;
1439 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM49);
1440 0           RRETURN(rrc);
1441             }
1442              
1443             /* Condition false & no alternative; continue after the group. */
1444              
1445             else
1446             {
1447             }
1448 0           break;
1449              
1450              
1451             /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1452             to close any currently open capturing brackets. */
1453              
1454             case OP_CLOSE:
1455 0           number = GET2(ecode, 1); /* Must be less than 65536 */
1456 0           offset = number << 1;
1457              
1458             #ifdef PCRE_DEBUG
1459             printf("end bracket %d at *ACCEPT", number);
1460             printf("\n");
1461             #endif
1462              
1463 0           md->capture_last = (md->capture_last & OVFLMASK) | number;
1464 0 0         if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
1465             {
1466 0           md->offset_vector[offset] =
1467 0           md->offset_vector[md->offset_end - number];
1468 0           md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1469              
1470             /* If this group is at or above the current highwater mark, ensure that
1471             any groups between the current high water mark and this group are marked
1472             unset and then update the high water mark. */
1473              
1474 0 0         if (offset >= offset_top)
1475             {
1476 0           register int *iptr = md->offset_vector + offset_top;
1477 0           register int *iend = md->offset_vector + offset;
1478 0 0         while (iptr < iend) *iptr++ = -1;
1479 0           offset_top = offset + 2;
1480             }
1481             }
1482 0           ecode += 1 + IMM2_SIZE;
1483 0           break;
1484              
1485              
1486             /* End of the pattern, either real or forced. */
1487              
1488             case OP_END:
1489             case OP_ACCEPT:
1490             case OP_ASSERT_ACCEPT:
1491              
1492             /* If we have matched an empty string, fail if not in an assertion and not
1493             in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
1494             is set and we have matched at the start of the subject. In both cases,
1495             backtracking will then try other alternatives, if any. */
1496              
1497 14 50         if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
    0          
    0          
1498 0 0         md->recursive == NULL &&
1499 0 0         (md->notempty ||
1500 0 0         (md->notempty_atstart &&
1501 0           mstart == md->start_subject + md->start_offset)))
1502 0           RRETURN(MATCH_NOMATCH);
1503              
1504             /* Otherwise, we have a match. */
1505              
1506 14           md->end_match_ptr = eptr; /* Record where we ended */
1507 14           md->end_offset_top = offset_top; /* and how many extracts were taken */
1508 14           md->start_match_ptr = mstart; /* and the start (\K can modify) */
1509              
1510             /* For some reason, the macros don't work properly if an expression is
1511             given as the argument to RRETURN when the heap is in use. */
1512              
1513 14 50         rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1514 14           RRETURN(rrc);
1515              
1516             /* Assertion brackets. Check the alternative branches in turn - the
1517             matching won't pass the KET for an assertion. If any one branch matches,
1518             the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
1519             start of each branch to move the current point backwards, so the code at
1520             this level is identical to the lookahead case. When the assertion is part
1521             of a condition, we want to return immediately afterwards. The caller of
1522             this incarnation of the match() function will have set MATCH_CONDASSERT in
1523             md->match_function type, and one of these opcodes will be the first opcode
1524             that is processed. We use a local variable that is preserved over calls to
1525             match() to remember this case. */
1526              
1527             case OP_ASSERT:
1528             case OP_ASSERTBACK:
1529 0           save_mark = md->mark;
1530 0 0         if (md->match_function_type == MATCH_CONDASSERT)
1531             {
1532 0           condassert = TRUE;
1533 0           md->match_function_type = 0;
1534             }
1535 0           else condassert = FALSE;
1536              
1537             /* Loop for each branch */
1538              
1539             do
1540             {
1541 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
1542              
1543             /* A match means that the assertion is true; break out of the loop
1544             that matches its alternatives. */
1545              
1546 0 0         if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
    0          
1547             {
1548 0           mstart = md->start_match_ptr; /* In case \K reset it */
1549 0           break;
1550             }
1551              
1552             /* If not matched, restore the previous mark setting. */
1553              
1554 0           md->mark = save_mark;
1555              
1556             /* See comment in the code for capturing groups above about handling
1557             THEN. */
1558              
1559 0 0         if (rrc == MATCH_THEN)
1560             {
1561 0           next = ecode + GET(ecode,1);
1562 0 0         if (md->start_match_ptr < next &&
    0          
1563 0 0         (*ecode == OP_ALT || *next == OP_ALT))
1564 0           rrc = MATCH_NOMATCH;
1565             }
1566              
1567             /* Anything other than NOMATCH causes the entire assertion to fail,
1568             passing back the return code. This includes COMMIT, SKIP, PRUNE and an
1569             uncaptured THEN, which means they take their normal effect. This
1570             consistent approach does not always have exactly the same effect as in
1571             Perl. */
1572              
1573 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1574 0           ecode += GET(ecode, 1);
1575             }
1576 0 0         while (*ecode == OP_ALT); /* Continue for next alternative */
1577              
1578             /* If we have tried all the alternative branches, the assertion has
1579             failed. If not, we broke out after a match. */
1580              
1581 0 0         if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
1582              
1583             /* If checking an assertion for a condition, return MATCH_MATCH. */
1584              
1585 0 0         if (condassert) RRETURN(MATCH_MATCH);
1586              
1587             /* Continue from after a successful assertion, updating the offsets high
1588             water mark, since extracts may have been taken during the assertion. */
1589              
1590 0 0         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1591 0           ecode += 1 + LINK_SIZE;
1592 0           offset_top = md->end_offset_top;
1593 0           continue;
1594              
1595             /* Negative assertion: all branches must fail to match for the assertion to
1596             succeed. */
1597              
1598             case OP_ASSERT_NOT:
1599             case OP_ASSERTBACK_NOT:
1600 0           save_mark = md->mark;
1601 0 0         if (md->match_function_type == MATCH_CONDASSERT)
1602             {
1603 0           condassert = TRUE;
1604 0           md->match_function_type = 0;
1605             }
1606 0           else condassert = FALSE;
1607              
1608             /* Loop for each alternative branch. */
1609              
1610             do
1611             {
1612 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1613 0           md->mark = save_mark; /* Always restore the mark setting */
1614              
1615 0           switch(rrc)
1616             {
1617             case MATCH_MATCH: /* A successful match means */
1618             case MATCH_ACCEPT: /* the assertion has failed. */
1619 0           RRETURN(MATCH_NOMATCH);
1620              
1621             case MATCH_NOMATCH: /* Carry on with next branch */
1622 0           break;
1623              
1624             /* See comment in the code for capturing groups above about handling
1625             THEN. */
1626              
1627             case MATCH_THEN:
1628 0           next = ecode + GET(ecode,1);
1629 0 0         if (md->start_match_ptr < next &&
    0          
1630 0 0         (*ecode == OP_ALT || *next == OP_ALT))
1631             {
1632 0           rrc = MATCH_NOMATCH;
1633 0           break;
1634             }
1635             /* Otherwise fall through. */
1636              
1637             /* COMMIT, SKIP, PRUNE, and an uncaptured THEN cause the whole
1638             assertion to fail to match, without considering any more alternatives.
1639             Failing to match means the assertion is true. This is a consistent
1640             approach, but does not always have the same effect as in Perl. */
1641              
1642             case MATCH_COMMIT:
1643             case MATCH_SKIP:
1644             case MATCH_SKIP_ARG:
1645             case MATCH_PRUNE:
1646 0 0         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1647 0           goto NEG_ASSERT_TRUE; /* Break out of alternation loop */
1648              
1649             /* Anything else is an error */
1650              
1651             default:
1652 0           RRETURN(rrc);
1653             }
1654              
1655             /* Continue with next branch */
1656              
1657 0           ecode += GET(ecode,1);
1658             }
1659 0 0         while (*ecode == OP_ALT);
1660              
1661             /* All branches in the assertion failed to match. */
1662              
1663             NEG_ASSERT_TRUE:
1664 0 0         if (condassert) RRETURN(MATCH_MATCH); /* Condition assertion */
1665 0           ecode += 1 + LINK_SIZE; /* Continue with current branch */
1666 0           continue;
1667              
1668             /* Move the subject pointer back. This occurs only at the start of
1669             each branch of a lookbehind assertion. If we are too close to the start to
1670             move back, this match function fails. When working with UTF-8 we move
1671             back a number of characters, not bytes. */
1672              
1673             case OP_REVERSE:
1674             #ifdef SUPPORT_UTF
1675             if (utf)
1676             {
1677             i = GET(ecode, 1);
1678             while (i-- > 0)
1679             {
1680             eptr--;
1681             if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1682             BACKCHAR(eptr);
1683             }
1684             }
1685             else
1686             #endif
1687              
1688             /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
1689              
1690             {
1691 0           eptr -= GET(ecode, 1);
1692 0 0         if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1693             }
1694              
1695             /* Save the earliest consulted character, then skip to next op code */
1696              
1697 0 0         if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1698 0           ecode += 1 + LINK_SIZE;
1699 0           break;
1700              
1701             /* The callout item calls an external function, if one is provided, passing
1702             details of the match so far. This is mainly for debugging, though the
1703             function is able to force a failure. */
1704              
1705             case OP_CALLOUT:
1706 0 0         if (PUBL(callout) != NULL)
1707             {
1708             PUBL(callout_block) cb;
1709 0           cb.version = 2; /* Version 1 of the callout block */
1710 0           cb.callout_number = ecode[1];
1711 0           cb.offset_vector = md->offset_vector;
1712             #if defined COMPILE_PCRE8
1713 0           cb.subject = (PCRE_SPTR)md->start_subject;
1714             #elif defined COMPILE_PCRE16
1715             cb.subject = (PCRE_SPTR16)md->start_subject;
1716             #elif defined COMPILE_PCRE32
1717             cb.subject = (PCRE_SPTR32)md->start_subject;
1718             #endif
1719 0           cb.subject_length = (int)(md->end_subject - md->start_subject);
1720 0           cb.start_match = (int)(mstart - md->start_subject);
1721 0           cb.current_position = (int)(eptr - md->start_subject);
1722 0           cb.pattern_position = GET(ecode, 2);
1723 0           cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1724 0           cb.capture_top = offset_top/2;
1725 0           cb.capture_last = md->capture_last & CAPLMASK;
1726             /* Internal change requires this for API compatibility. */
1727 0 0         if (cb.capture_last == 0) cb.capture_last = -1;
1728 0           cb.callout_data = md->callout_data;
1729 0           cb.mark = md->nomatch_mark;
1730 0 0         if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1731 0 0         if (rrc < 0) RRETURN(rrc);
1732             }
1733 0           ecode += 2 + 2*LINK_SIZE;
1734 0           break;
1735              
1736             /* Recursion either matches the current regex, or some subexpression. The
1737             offset data is the offset to the starting bracket from the start of the
1738             whole pattern. (This is so that it works from duplicated subpatterns.)
1739              
1740             The state of the capturing groups is preserved over recursion, and
1741             re-instated afterwards. We don't know how many are started and not yet
1742             finished (offset_top records the completed total) so we just have to save
1743             all the potential data. There may be up to 65535 such values, which is too
1744             large to put on the stack, but using malloc for small numbers seems
1745             expensive. As a compromise, the stack is used when there are no more than
1746             REC_STACK_SAVE_MAX values to store; otherwise malloc is used.
1747              
1748             There are also other values that have to be saved. We use a chained
1749             sequence of blocks that actually live on the stack. Thanks to Robin Houston
1750             for the original version of this logic. It has, however, been hacked around
1751             a lot, so he is not to blame for the current way it works. */
1752              
1753             case OP_RECURSE:
1754             {
1755             recursion_info *ri;
1756             unsigned int recno;
1757              
1758 0           callpat = md->start_code + GET(ecode, 1);
1759 0 0         recno = (callpat == md->start_code)? 0 :
1760 0           GET2(callpat, 1 + LINK_SIZE);
1761              
1762             /* Check for repeating a recursion without advancing the subject pointer.
1763             This should catch convoluted mutual recursions. (Some simple cases are
1764             caught at compile time.) */
1765              
1766 0 0         for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
1767 0 0         if (recno == ri->group_num && eptr == ri->subject_position)
    0          
1768 0           RRETURN(PCRE_ERROR_RECURSELOOP);
1769              
1770             /* Add to "recursing stack" */
1771              
1772 0           new_recursive.group_num = recno;
1773 0           new_recursive.saved_capture_last = md->capture_last;
1774 0           new_recursive.subject_position = eptr;
1775 0           new_recursive.prevrec = md->recursive;
1776 0           md->recursive = &new_recursive;
1777              
1778             /* Where to continue from afterwards */
1779              
1780 0           ecode += 1 + LINK_SIZE;
1781              
1782             /* Now save the offset data */
1783              
1784 0           new_recursive.saved_max = md->offset_end;
1785 0 0         if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
1786 0           new_recursive.offset_save = stacksave;
1787             else
1788             {
1789 0           new_recursive.offset_save =
1790 0           (int *)(PUBL(malloc))(new_recursive.saved_max * sizeof(int));
1791 0 0         if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
1792             }
1793 0           memcpy(new_recursive.offset_save, md->offset_vector,
1794 0           new_recursive.saved_max * sizeof(int));
1795              
1796             /* OK, now we can do the recursion. After processing each alternative,
1797             restore the offset data and the last captured value. If there were nested
1798             recursions, md->recursive might be changed, so reset it before looping.
1799             */
1800              
1801             DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1802 0           cbegroup = (*callpat >= OP_SBRA);
1803             do
1804             {
1805 0 0         if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
1806 0           RMATCH(eptr, callpat + PRIV(OP_lengths)[*callpat], offset_top,
1807             md, eptrb, RM6);
1808 0           memcpy(md->offset_vector, new_recursive.offset_save,
1809 0           new_recursive.saved_max * sizeof(int));
1810 0           md->capture_last = new_recursive.saved_capture_last;
1811 0           md->recursive = new_recursive.prevrec;
1812 0 0         if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
    0          
1813             {
1814             DPRINTF(("Recursion matched\n"));
1815 0 0         if (new_recursive.offset_save != stacksave)
1816 0           (PUBL(free))(new_recursive.offset_save);
1817              
1818             /* Set where we got to in the subject, and reset the start in case
1819             it was changed by \K. This *is* propagated back out of a recursion,
1820             for Perl compatibility. */
1821              
1822 0           eptr = md->end_match_ptr;
1823 0           mstart = md->start_match_ptr;
1824 0           goto RECURSION_MATCHED; /* Exit loop; end processing */
1825             }
1826              
1827             /* PCRE does not allow THEN, SKIP, PRUNE or COMMIT to escape beyond a
1828             recursion; they cause a NOMATCH for the entire recursion. These codes
1829             are defined in a range that can be tested for. */
1830              
1831 0 0         if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX)
    0          
1832             {
1833 0 0         if (new_recursive.offset_save != stacksave)
1834 0           (PUBL(free))(new_recursive.offset_save);
1835 0           RRETURN(MATCH_NOMATCH);
1836             }
1837              
1838             /* Any return code other than NOMATCH is an error. */
1839              
1840 0 0         if (rrc != MATCH_NOMATCH)
1841             {
1842             DPRINTF(("Recursion gave error %d\n", rrc));
1843 0 0         if (new_recursive.offset_save != stacksave)
1844 0           (PUBL(free))(new_recursive.offset_save);
1845 0           RRETURN(rrc);
1846             }
1847              
1848 0           md->recursive = &new_recursive;
1849 0           callpat += GET(callpat, 1);
1850             }
1851 0 0         while (*callpat == OP_ALT);
1852              
1853             DPRINTF(("Recursion didn't match\n"));
1854 0           md->recursive = new_recursive.prevrec;
1855 0 0         if (new_recursive.offset_save != stacksave)
1856 0           (PUBL(free))(new_recursive.offset_save);
1857 0           RRETURN(MATCH_NOMATCH);
1858             }
1859              
1860             RECURSION_MATCHED:
1861 0           break;
1862              
1863             /* An alternation is the end of a branch; scan along to find the end of the
1864             bracketed group and go to there. */
1865              
1866             case OP_ALT:
1867 0 0         do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1868 0           break;
1869              
1870             /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1871             indicating that it may occur zero times. It may repeat infinitely, or not
1872             at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1873             with fixed upper repeat limits are compiled as a number of copies, with the
1874             optional ones preceded by BRAZERO or BRAMINZERO. */
1875              
1876             case OP_BRAZERO:
1877 10           next = ecode + 1;
1878 10           RMATCH(eptr, next, offset_top, md, eptrb, RM10);
1879 10 100         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1880 7 50         do next += GET(next, 1); while (*next == OP_ALT);
1881 7           ecode = next + 1 + LINK_SIZE;
1882 7           break;
1883              
1884             case OP_BRAMINZERO:
1885 0           next = ecode + 1;
1886 0 0         do next += GET(next, 1); while (*next == OP_ALT);
1887 0           RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
1888 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1889 0           ecode++;
1890 0           break;
1891              
1892             case OP_SKIPZERO:
1893 0           next = ecode+1;
1894 0 0         do next += GET(next,1); while (*next == OP_ALT);
1895 0           ecode = next + 1 + LINK_SIZE;
1896 0           break;
1897              
1898             /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
1899             here; just jump to the group, with allow_zero set TRUE. */
1900              
1901             case OP_BRAPOSZERO:
1902 0           op = *(++ecode);
1903 0           allow_zero = TRUE;
1904 0 0         if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
    0          
1905 0           goto POSSESSIVE_NON_CAPTURE;
1906              
1907             /* End of a group, repeated or non-repeating. */
1908              
1909             case OP_KET:
1910             case OP_KETRMIN:
1911             case OP_KETRMAX:
1912             case OP_KETRPOS:
1913 17           prev = ecode - GET(ecode, 1);
1914              
1915             /* If this was a group that remembered the subject start, in order to break
1916             infinite repeats of empty string matches, retrieve the subject start from
1917             the chain. Otherwise, set it NULL. */
1918              
1919 17 50         if (*prev >= OP_SBRA || *prev == OP_ONCE)
    50          
1920             {
1921 0           saved_eptr = eptrb->epb_saved_eptr; /* Value at start of group */
1922 0           eptrb = eptrb->epb_prev; /* Backup to previous group */
1923             }
1924 17           else saved_eptr = NULL;
1925              
1926             /* If we are at the end of an assertion group or a non-capturing atomic
1927             group, stop matching and return MATCH_MATCH, but record the current high
1928             water mark for use by positive assertions. We also need to record the match
1929             start in case it was changed by \K. */
1930              
1931 17 50         if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
    50          
    50          
1932 17           *prev == OP_ONCE_NC)
1933             {
1934 0           md->end_match_ptr = eptr; /* For ONCE_NC */
1935 0           md->end_offset_top = offset_top;
1936 0           md->start_match_ptr = mstart;
1937 0           RRETURN(MATCH_MATCH); /* Sets md->mark */
1938             }
1939              
1940             /* For capturing groups we have to check the group number back at the start
1941             and if necessary complete handling an extraction by setting the offsets and
1942             bumping the high water mark. Whole-pattern recursion is coded as a recurse
1943             into group 0, so it won't be picked up here. Instead, we catch it when the
1944             OP_END is reached. Other recursion is handled here. We just have to record
1945             the current subject position and start match pointer and give a MATCH
1946             return. */
1947              
1948 17 100         if (*prev == OP_CBRA || *prev == OP_SCBRA ||
    50          
    50          
1949 14 50         *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
1950             {
1951 3           number = GET2(prev, 1+LINK_SIZE);
1952 3           offset = number << 1;
1953              
1954             #ifdef PCRE_DEBUG
1955             printf("end bracket %d", number);
1956             printf("\n");
1957             #endif
1958              
1959             /* Handle a recursively called group. */
1960              
1961 3 50         if (md->recursive != NULL && md->recursive->group_num == number)
    0          
1962             {
1963 0           md->end_match_ptr = eptr;
1964 0           md->start_match_ptr = mstart;
1965 0           RRETURN(MATCH_MATCH);
1966             }
1967              
1968             /* Deal with capturing */
1969              
1970 3           md->capture_last = (md->capture_last & OVFLMASK) | number;
1971 3 50         if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
1972             {
1973             /* If offset is greater than offset_top, it means that we are
1974             "skipping" a capturing group, and that group's offsets must be marked
1975             unset. In earlier versions of PCRE, all the offsets were unset at the
1976             start of matching, but this doesn't work because atomic groups and
1977             assertions can cause a value to be set that should later be unset.
1978             Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
1979             part of the atomic group, but this is not on the final matching path,
1980             so must be unset when 2 is set. (If there is no group 2, there is no
1981             problem, because offset_top will then be 2, indicating no capture.) */
1982              
1983 0 0         if (offset > offset_top)
1984             {
1985 0           register int *iptr = md->offset_vector + offset_top;
1986 0           register int *iend = md->offset_vector + offset;
1987 0 0         while (iptr < iend) *iptr++ = -1;
1988             }
1989              
1990             /* Now make the extraction */
1991              
1992 0           md->offset_vector[offset] =
1993 0           md->offset_vector[md->offset_end - number];
1994 0           md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1995 0 0         if (offset_top <= offset) offset_top = offset + 2;
1996             }
1997             }
1998              
1999             /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
2000             and return the MATCH_KETRPOS. This makes it possible to do the repeats one
2001             at a time from the outer level, thus saving stack. This must precede the
2002             empty string test - in this case that test is done at the outer level. */
2003              
2004 17 50         if (*ecode == OP_KETRPOS)
2005             {
2006 0           md->start_match_ptr = mstart; /* In case \K reset it */
2007 0           md->end_match_ptr = eptr;
2008 0           md->end_offset_top = offset_top;
2009 0           RRETURN(MATCH_KETRPOS);
2010             }
2011              
2012             /* For an ordinary non-repeating ket, just continue at this level. This
2013             also happens for a repeating ket if no characters were matched in the
2014             group. This is the forcible breaking of infinite loops as implemented in
2015             Perl 5.005. For a non-repeating atomic group that includes captures,
2016             establish a backup point by processing the rest of the pattern at a lower
2017             level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
2018             original OP_ONCE level, thereby bypassing intermediate backup points, but
2019             resetting any captures that happened along the way. */
2020              
2021 17 50         if (*ecode == OP_KET || eptr == saved_eptr)
    0          
2022             {
2023 17 50         if (*prev == OP_ONCE)
2024             {
2025 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
2026 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2027 0           md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
2028 0           RRETURN(MATCH_ONCE);
2029             }
2030 17           ecode += 1 + LINK_SIZE; /* Carry on at this level */
2031 17           break;
2032             }
2033              
2034             /* The normal repeating kets try the rest of the pattern or restart from
2035             the preceding bracket, in the appropriate order. In the second case, we can
2036             use tail recursion to avoid using another stack frame, unless we have an
2037             an atomic group or an unlimited repeat of a group that can match an empty
2038             string. */
2039              
2040 0 0         if (*ecode == OP_KETRMIN)
2041             {
2042 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM7);
2043 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2044 0 0         if (*prev == OP_ONCE)
2045             {
2046 0           RMATCH(eptr, prev, offset_top, md, eptrb, RM8);
2047 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2048 0           md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
2049 0           RRETURN(MATCH_ONCE);
2050             }
2051 0 0         if (*prev >= OP_SBRA) /* Could match an empty string */
2052             {
2053 0           RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2054 0           RRETURN(rrc);
2055             }
2056 0           ecode = prev;
2057 0           goto TAIL_RECURSE;
2058             }
2059             else /* OP_KETRMAX */
2060             {
2061 0           RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2062 0 0         if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
    0          
2063 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2064 0 0         if (*prev == OP_ONCE)
2065             {
2066 0           RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM9);
2067 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2068 0           md->once_target = prev;
2069 0           RRETURN(MATCH_ONCE);
2070             }
2071 0           ecode += 1 + LINK_SIZE;
2072 0           goto TAIL_RECURSE;
2073             }
2074             /* Control never gets here */
2075              
2076             /* Not multiline mode: start of subject assertion, unless notbol. */
2077              
2078             case OP_CIRC:
2079 29 50         if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
    0          
2080              
2081             /* Start of subject assertion */
2082              
2083             case OP_SOD:
2084 29 50         if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
2085 29           ecode++;
2086 29           break;
2087              
2088             /* Multiline mode: start of subject unless notbol, or after any newline. */
2089              
2090             case OP_CIRCM:
2091 0 0         if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
    0          
2092 0 0         if (eptr != md->start_subject &&
    0          
    0          
2093 0 0         (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
    0          
    0          
    0          
    0          
    0          
    0          
    0          
2094 0           RRETURN(MATCH_NOMATCH);
2095 0           ecode++;
2096 0           break;
2097              
2098             /* Start of match assertion */
2099              
2100             case OP_SOM:
2101 0 0         if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
2102 0           ecode++;
2103 0           break;
2104              
2105             /* Reset the start of match point */
2106              
2107             case OP_SET_SOM:
2108 0           mstart = eptr;
2109 0           ecode++;
2110 0           break;
2111              
2112             /* Multiline mode: assert before any newline, or before end of subject
2113             unless noteol is set. */
2114              
2115             case OP_DOLLM:
2116 0 0         if (eptr < md->end_subject)
2117             {
2118 0 0         if (!IS_NEWLINE(eptr))
    0          
    0          
    0          
    0          
    0          
    0          
    0          
2119             {
2120 0 0         if (md->partial != 0 &&
    0          
2121 0 0         eptr + 1 >= md->end_subject &&
2122 0 0         NLBLOCK->nltype == NLTYPE_FIXED &&
2123 0 0         NLBLOCK->nllen == 2 &&
2124 0           UCHAR21TEST(eptr) == NLBLOCK->nl[0])
2125             {
2126 0           md->hitend = TRUE;
2127 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2128             }
2129 0           RRETURN(MATCH_NOMATCH);
2130             }
2131             }
2132             else
2133             {
2134 0 0         if (md->noteol) RRETURN(MATCH_NOMATCH);
2135 0 0         SCHECK_PARTIAL();
    0          
    0          
2136             }
2137 0           ecode++;
2138 0           break;
2139              
2140             /* Not multiline mode: assert before a terminating newline or before end of
2141             subject unless noteol is set. */
2142              
2143             case OP_DOLL:
2144 11 50         if (md->noteol) RRETURN(MATCH_NOMATCH);
2145 11 50         if (!md->endonly) goto ASSERT_NL_OR_EOS;
2146              
2147             /* ... else fall through for endonly */
2148              
2149             /* End of subject assertion (\z) */
2150              
2151             case OP_EOD:
2152 0 0         if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
2153 0 0         SCHECK_PARTIAL();
    0          
    0          
2154 0           ecode++;
2155 0           break;
2156              
2157             /* End of subject or ending \n assertion (\Z) */
2158              
2159             case OP_EODN:
2160             ASSERT_NL_OR_EOS:
2161 12 100         if (eptr < md->end_subject &&
    50          
    50          
2162 1 50         (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
    50          
    0          
    0          
    0          
    0          
    0          
    0          
2163             {
2164 1 50         if (md->partial != 0 &&
    0          
2165 0 0         eptr + 1 >= md->end_subject &&
2166 0 0         NLBLOCK->nltype == NLTYPE_FIXED &&
2167 0 0         NLBLOCK->nllen == 2 &&
2168 0           UCHAR21TEST(eptr) == NLBLOCK->nl[0])
2169             {
2170 0           md->hitend = TRUE;
2171 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2172             }
2173 1           RRETURN(MATCH_NOMATCH);
2174             }
2175              
2176             /* Either at end of string or \n before end. */
2177              
2178 10 50         SCHECK_PARTIAL();
    0          
    0          
2179 10           ecode++;
2180 10           break;
2181              
2182             /* Word boundary assertions */
2183              
2184             case OP_NOT_WORD_BOUNDARY:
2185             case OP_WORD_BOUNDARY:
2186             {
2187              
2188             /* Find out if the previous and current characters are "word" characters.
2189             It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
2190             be "non-word" characters. Remember the earliest consulted character for
2191             partial matching. */
2192              
2193             #ifdef SUPPORT_UTF
2194             if (utf)
2195             {
2196             /* Get status of previous character */
2197              
2198             if (eptr == md->start_subject) prev_is_word = FALSE; else
2199             {
2200             PCRE_PUCHAR lastptr = eptr - 1;
2201             BACKCHAR(lastptr);
2202             if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
2203             GETCHAR(c, lastptr);
2204             #ifdef SUPPORT_UCP
2205             if (md->use_ucp)
2206             {
2207             if (c == '_') prev_is_word = TRUE; else
2208             {
2209             int cat = UCD_CATEGORY(c);
2210             prev_is_word = (cat == ucp_L || cat == ucp_N);
2211             }
2212             }
2213             else
2214             #endif
2215             prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2216             }
2217              
2218             /* Get status of next character */
2219              
2220             if (eptr >= md->end_subject)
2221             {
2222             SCHECK_PARTIAL();
2223             cur_is_word = FALSE;
2224             }
2225             else
2226             {
2227             GETCHAR(c, eptr);
2228             #ifdef SUPPORT_UCP
2229             if (md->use_ucp)
2230             {
2231             if (c == '_') cur_is_word = TRUE; else
2232             {
2233             int cat = UCD_CATEGORY(c);
2234             cur_is_word = (cat == ucp_L || cat == ucp_N);
2235             }
2236             }
2237             else
2238             #endif
2239             cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2240             }
2241             }
2242             else
2243             #endif
2244              
2245             /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
2246             consistency with the behaviour of \w we do use it in this case. */
2247              
2248             {
2249             /* Get status of previous character */
2250              
2251 0 0         if (eptr == md->start_subject) prev_is_word = FALSE; else
2252             {
2253 0 0         if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
2254             #ifdef SUPPORT_UCP
2255             if (md->use_ucp)
2256             {
2257             c = eptr[-1];
2258             if (c == '_') prev_is_word = TRUE; else
2259             {
2260             int cat = UCD_CATEGORY(c);
2261             prev_is_word = (cat == ucp_L || cat == ucp_N);
2262             }
2263             }
2264             else
2265             #endif
2266 0           prev_is_word = MAX_255(eptr[-1])
2267 0           && ((md->ctypes[eptr[-1]] & ctype_word) != 0);
2268             }
2269              
2270             /* Get status of next character */
2271              
2272 0 0         if (eptr >= md->end_subject)
2273             {
2274 0 0         SCHECK_PARTIAL();
    0          
    0          
2275 0           cur_is_word = FALSE;
2276             }
2277             else
2278             #ifdef SUPPORT_UCP
2279             if (md->use_ucp)
2280             {
2281             c = *eptr;
2282             if (c == '_') cur_is_word = TRUE; else
2283             {
2284             int cat = UCD_CATEGORY(c);
2285             cur_is_word = (cat == ucp_L || cat == ucp_N);
2286             }
2287             }
2288             else
2289             #endif
2290 0           cur_is_word = MAX_255(*eptr)
2291 0           && ((md->ctypes[*eptr] & ctype_word) != 0);
2292             }
2293              
2294             /* Now see if the situation is what we want */
2295              
2296 0 0         if ((*ecode++ == OP_WORD_BOUNDARY)?
    0          
2297             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
2298 0           RRETURN(MATCH_NOMATCH);
2299             }
2300 0           break;
2301              
2302             /* Match any single character type except newline; have to take care with
2303             CRLF newlines and partial matching. */
2304              
2305             case OP_ANY:
2306 0 0         if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
    0          
    0          
    0          
    0          
    0          
    0          
    0          
2307 0 0         if (md->partial != 0 &&
    0          
2308 0 0         eptr == md->end_subject - 1 &&
2309 0 0         NLBLOCK->nltype == NLTYPE_FIXED &&
2310 0 0         NLBLOCK->nllen == 2 &&
2311 0           UCHAR21TEST(eptr) == NLBLOCK->nl[0])
2312             {
2313 0           md->hitend = TRUE;
2314 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2315             }
2316              
2317             /* Fall through */
2318              
2319             /* Match any single character whatsoever. */
2320              
2321             case OP_ALLANY:
2322 0 0         if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2323             { /* not be updated before SCHECK_PARTIAL. */
2324 0 0         SCHECK_PARTIAL();
    0          
    0          
2325 0           RRETURN(MATCH_NOMATCH);
2326             }
2327 0           eptr++;
2328             #ifdef SUPPORT_UTF
2329             if (utf) ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
2330             #endif
2331 0           ecode++;
2332 0           break;
2333              
2334             /* Match a single byte, even in UTF-8 mode. This opcode really does match
2335             any byte, even newline, independent of the setting of PCRE_DOTALL. */
2336              
2337             case OP_ANYBYTE:
2338 0 0         if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2339             { /* not be updated before SCHECK_PARTIAL. */
2340 0 0         SCHECK_PARTIAL();
    0          
    0          
2341 0           RRETURN(MATCH_NOMATCH);
2342             }
2343 0           eptr++;
2344 0           ecode++;
2345 0           break;
2346              
2347             case OP_NOT_DIGIT:
2348 0 0         if (eptr >= md->end_subject)
2349             {
2350 0 0         SCHECK_PARTIAL();
    0          
    0          
2351 0           RRETURN(MATCH_NOMATCH);
2352             }
2353 0           GETCHARINCTEST(c, eptr);
2354 0 0         if (
2355             #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2356             c < 256 &&
2357             #endif
2358 0           (md->ctypes[c] & ctype_digit) != 0
2359             )
2360 0           RRETURN(MATCH_NOMATCH);
2361 0           ecode++;
2362 0           break;
2363              
2364             case OP_DIGIT:
2365 0 0         if (eptr >= md->end_subject)
2366             {
2367 0 0         SCHECK_PARTIAL();
    0          
    0          
2368 0           RRETURN(MATCH_NOMATCH);
2369             }
2370 0           GETCHARINCTEST(c, eptr);
2371 0 0         if (
2372             #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2373             c > 255 ||
2374             #endif
2375 0           (md->ctypes[c] & ctype_digit) == 0
2376             )
2377 0           RRETURN(MATCH_NOMATCH);
2378 0           ecode++;
2379 0           break;
2380              
2381             case OP_NOT_WHITESPACE:
2382 0 0         if (eptr >= md->end_subject)
2383             {
2384 0 0         SCHECK_PARTIAL();
    0          
    0          
2385 0           RRETURN(MATCH_NOMATCH);
2386             }
2387 0           GETCHARINCTEST(c, eptr);
2388 0 0         if (
2389             #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2390             c < 256 &&
2391             #endif
2392 0           (md->ctypes[c] & ctype_space) != 0
2393             )
2394 0           RRETURN(MATCH_NOMATCH);
2395 0           ecode++;
2396 0           break;
2397              
2398             case OP_WHITESPACE:
2399 0 0         if (eptr >= md->end_subject)
2400             {
2401 0 0         SCHECK_PARTIAL();
    0          
    0          
2402 0           RRETURN(MATCH_NOMATCH);
2403             }
2404 0           GETCHARINCTEST(c, eptr);
2405 0 0         if (
2406             #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2407             c > 255 ||
2408             #endif
2409 0           (md->ctypes[c] & ctype_space) == 0
2410             )
2411 0           RRETURN(MATCH_NOMATCH);
2412 0           ecode++;
2413 0           break;
2414              
2415             case OP_NOT_WORDCHAR:
2416 0 0         if (eptr >= md->end_subject)
2417             {
2418 0 0         SCHECK_PARTIAL();
    0          
    0          
2419 0           RRETURN(MATCH_NOMATCH);
2420             }
2421 0           GETCHARINCTEST(c, eptr);
2422 0 0         if (
2423             #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2424             c < 256 &&
2425             #endif
2426 0           (md->ctypes[c] & ctype_word) != 0
2427             )
2428 0           RRETURN(MATCH_NOMATCH);
2429 0           ecode++;
2430 0           break;
2431              
2432             case OP_WORDCHAR:
2433 0 0         if (eptr >= md->end_subject)
2434             {
2435 0 0         SCHECK_PARTIAL();
    0          
    0          
2436 0           RRETURN(MATCH_NOMATCH);
2437             }
2438 0           GETCHARINCTEST(c, eptr);
2439 0 0         if (
2440             #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2441             c > 255 ||
2442             #endif
2443 0           (md->ctypes[c] & ctype_word) == 0
2444             )
2445 0           RRETURN(MATCH_NOMATCH);
2446 0           ecode++;
2447 0           break;
2448              
2449             case OP_ANYNL:
2450 0 0         if (eptr >= md->end_subject)
2451             {
2452 0 0         SCHECK_PARTIAL();
    0          
    0          
2453 0           RRETURN(MATCH_NOMATCH);
2454             }
2455 0           GETCHARINCTEST(c, eptr);
2456 0           switch(c)
2457             {
2458 0           default: RRETURN(MATCH_NOMATCH);
2459              
2460             case CHAR_CR:
2461 0 0         if (eptr >= md->end_subject)
2462             {
2463 0 0         SCHECK_PARTIAL();
    0          
    0          
2464             }
2465 0 0         else if (UCHAR21TEST(eptr) == CHAR_LF) eptr++;
2466 0           break;
2467              
2468             case CHAR_LF:
2469 0           break;
2470              
2471             case CHAR_VT:
2472             case CHAR_FF:
2473             case CHAR_NEL:
2474             #ifndef EBCDIC
2475             case 0x2028:
2476             case 0x2029:
2477             #endif /* Not EBCDIC */
2478 0 0         if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2479 0           break;
2480             }
2481 0           ecode++;
2482 0           break;
2483              
2484             case OP_NOT_HSPACE:
2485 0 0         if (eptr >= md->end_subject)
2486             {
2487 0 0         SCHECK_PARTIAL();
    0          
    0          
2488 0           RRETURN(MATCH_NOMATCH);
2489             }
2490 0           GETCHARINCTEST(c, eptr);
2491 0 0         switch(c)
2492             {
2493 0           HSPACE_CASES: RRETURN(MATCH_NOMATCH); /* Byte and multibyte cases */
2494 0           default: break;
2495             }
2496 0           ecode++;
2497 0           break;
2498              
2499             case OP_HSPACE:
2500 0 0         if (eptr >= md->end_subject)
2501             {
2502 0 0         SCHECK_PARTIAL();
    0          
    0          
2503 0           RRETURN(MATCH_NOMATCH);
2504             }
2505 0           GETCHARINCTEST(c, eptr);
2506 0 0         switch(c)
2507             {
2508 0           HSPACE_CASES: break; /* Byte and multibyte cases */
2509 0           default: RRETURN(MATCH_NOMATCH);
2510             }
2511 0           ecode++;
2512 0           break;
2513              
2514             case OP_NOT_VSPACE:
2515 0 0         if (eptr >= md->end_subject)
2516             {
2517 0 0         SCHECK_PARTIAL();
    0          
    0          
2518 0           RRETURN(MATCH_NOMATCH);
2519             }
2520 0           GETCHARINCTEST(c, eptr);
2521 0 0         switch(c)
2522             {
2523 0           VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2524 0           default: break;
2525             }
2526 0           ecode++;
2527 0           break;
2528              
2529             case OP_VSPACE:
2530 0 0         if (eptr >= md->end_subject)
2531             {
2532 0 0         SCHECK_PARTIAL();
    0          
    0          
2533 0           RRETURN(MATCH_NOMATCH);
2534             }
2535 0           GETCHARINCTEST(c, eptr);
2536 0 0         switch(c)
2537             {
2538 0           VSPACE_CASES: break;
2539 0           default: RRETURN(MATCH_NOMATCH);
2540             }
2541 0           ecode++;
2542 0           break;
2543              
2544             #ifdef SUPPORT_UCP
2545             /* Check the next character by Unicode property. We will get here only
2546             if the support is in the binary; otherwise a compile-time error occurs. */
2547              
2548             case OP_PROP:
2549             case OP_NOTPROP:
2550             if (eptr >= md->end_subject)
2551             {
2552             SCHECK_PARTIAL();
2553             RRETURN(MATCH_NOMATCH);
2554             }
2555             GETCHARINCTEST(c, eptr);
2556             {
2557             const pcre_uint32 *cp;
2558             const ucd_record *prop = GET_UCD(c);
2559              
2560             switch(ecode[1])
2561             {
2562             case PT_ANY:
2563             if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2564             break;
2565              
2566             case PT_LAMP:
2567             if ((prop->chartype == ucp_Lu ||
2568             prop->chartype == ucp_Ll ||
2569             prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2570             RRETURN(MATCH_NOMATCH);
2571             break;
2572              
2573             case PT_GC:
2574             if ((ecode[2] != PRIV(ucp_gentype)[prop->chartype]) == (op == OP_PROP))
2575             RRETURN(MATCH_NOMATCH);
2576             break;
2577              
2578             case PT_PC:
2579             if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2580             RRETURN(MATCH_NOMATCH);
2581             break;
2582              
2583             case PT_SC:
2584             if ((ecode[2] != prop->script) == (op == OP_PROP))
2585             RRETURN(MATCH_NOMATCH);
2586             break;
2587              
2588             /* These are specials */
2589              
2590             case PT_ALNUM:
2591             if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2592             PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2593             RRETURN(MATCH_NOMATCH);
2594             break;
2595              
2596             /* Perl space used to exclude VT, but from Perl 5.18 it is included,
2597             which means that Perl space and POSIX space are now identical. PCRE
2598             was changed at release 8.34. */
2599              
2600             case PT_SPACE: /* Perl space */
2601             case PT_PXSPACE: /* POSIX space */
2602             switch(c)
2603             {
2604             HSPACE_CASES:
2605             VSPACE_CASES:
2606             if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2607             break;
2608              
2609             default:
2610             if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) ==
2611             (op == OP_NOTPROP)) RRETURN(MATCH_NOMATCH);
2612             break;
2613             }
2614             break;
2615              
2616             case PT_WORD:
2617             if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2618             PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
2619             c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2620             RRETURN(MATCH_NOMATCH);
2621             break;
2622              
2623             case PT_CLIST:
2624             cp = PRIV(ucd_caseless_sets) + ecode[2];
2625             for (;;)
2626             {
2627             if (c < *cp)
2628             { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2629             if (c == *cp++)
2630             { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
2631             }
2632             break;
2633              
2634             case PT_UCNC:
2635             if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
2636             c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
2637             c >= 0xe000) == (op == OP_NOTPROP))
2638             RRETURN(MATCH_NOMATCH);
2639             break;
2640              
2641             /* This should never occur */
2642              
2643             default:
2644             RRETURN(PCRE_ERROR_INTERNAL);
2645             }
2646              
2647             ecode += 3;
2648             }
2649             break;
2650              
2651             /* Match an extended Unicode sequence. We will get here only if the support
2652             is in the binary; otherwise a compile-time error occurs. */
2653              
2654             case OP_EXTUNI:
2655             if (eptr >= md->end_subject)
2656             {
2657             SCHECK_PARTIAL();
2658             RRETURN(MATCH_NOMATCH);
2659             }
2660             else
2661             {
2662             int lgb, rgb;
2663             GETCHARINCTEST(c, eptr);
2664             lgb = UCD_GRAPHBREAK(c);
2665             while (eptr < md->end_subject)
2666             {
2667             int len = 1;
2668             if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2669             rgb = UCD_GRAPHBREAK(c);
2670             if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2671             lgb = rgb;
2672             eptr += len;
2673             }
2674             }
2675             CHECK_PARTIAL();
2676             ecode++;
2677             break;
2678             #endif /* SUPPORT_UCP */
2679              
2680              
2681             /* Match a back reference, possibly repeatedly. Look past the end of the
2682             item to see if there is repeat information following. The code is similar
2683             to that for character classes, but repeated for efficiency. Then obey
2684             similar code to character type repeats - written out again for speed.
2685             However, if the referenced string is the empty string, always treat
2686             it as matched, any number of times (otherwise there could be infinite
2687             loops). If the reference is unset, there are two possibilities:
2688              
2689             (a) In the default, Perl-compatible state, set the length negative;
2690             this ensures that every attempt at a match fails. We can't just fail
2691             here, because of the possibility of quantifiers with zero minima.
2692              
2693             (b) If the JavaScript compatibility flag is set, set the length to zero
2694             so that the back reference matches an empty string.
2695              
2696             Otherwise, set the length to the length of what was matched by the
2697             referenced subpattern.
2698              
2699             The OP_REF and OP_REFI opcodes are used for a reference to a numbered group
2700             or to a non-duplicated named group. For a duplicated named group, OP_DNREF
2701             and OP_DNREFI are used. In this case we must scan the list of groups to
2702             which the name refers, and use the first one that is set. */
2703              
2704             case OP_DNREF:
2705             case OP_DNREFI:
2706 0           caseless = op == OP_DNREFI;
2707             {
2708 0           int count = GET2(ecode, 1+IMM2_SIZE);
2709 0           pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
2710 0           ecode += 1 + 2*IMM2_SIZE;
2711              
2712             /* Setting the default length first and initializing 'offset' avoids
2713             compiler warnings in the REF_REPEAT code. */
2714              
2715 0 0         length = (md->jscript_compat)? 0 : -1;
2716 0           offset = 0;
2717              
2718 0 0         while (count-- > 0)
2719             {
2720 0           offset = GET2(slot, 0) << 1;
2721 0 0         if (offset < offset_top && md->offset_vector[offset] >= 0)
    0          
2722             {
2723 0           length = md->offset_vector[offset+1] - md->offset_vector[offset];
2724 0           break;
2725             }
2726 0           slot += md->name_entry_size;
2727             }
2728             }
2729 0           goto REF_REPEAT;
2730              
2731             case OP_REF:
2732             case OP_REFI:
2733 0           caseless = op == OP_REFI;
2734 0           offset = GET2(ecode, 1) << 1; /* Doubled ref number */
2735 0           ecode += 1 + IMM2_SIZE;
2736 0 0         if (offset >= offset_top || md->offset_vector[offset] < 0)
    0          
2737 0 0         length = (md->jscript_compat)? 0 : -1;
2738             else
2739 0           length = md->offset_vector[offset+1] - md->offset_vector[offset];
2740              
2741             /* Set up for repetition, or handle the non-repeated case */
2742              
2743             REF_REPEAT:
2744 0           switch (*ecode)
2745             {
2746             case OP_CRSTAR:
2747             case OP_CRMINSTAR:
2748             case OP_CRPLUS:
2749             case OP_CRMINPLUS:
2750             case OP_CRQUERY:
2751             case OP_CRMINQUERY:
2752 0           c = *ecode++ - OP_CRSTAR;
2753 0           minimize = (c & 1) != 0;
2754 0           min = rep_min[c]; /* Pick up values from tables; */
2755 0           max = rep_max[c]; /* zero for max => infinity */
2756 0 0         if (max == 0) max = INT_MAX;
2757 0           break;
2758              
2759             case OP_CRRANGE:
2760             case OP_CRMINRANGE:
2761 0           minimize = (*ecode == OP_CRMINRANGE);
2762 0           min = GET2(ecode, 1);
2763 0           max = GET2(ecode, 1 + IMM2_SIZE);
2764 0 0         if (max == 0) max = INT_MAX;
2765 0           ecode += 1 + 2 * IMM2_SIZE;
2766 0           break;
2767              
2768             default: /* No repeat follows */
2769 0 0         if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2770             {
2771 0 0         if (length == -2) eptr = md->end_subject; /* Partial match */
2772 0 0         CHECK_PARTIAL();
    0          
    0          
    0          
2773 0           RRETURN(MATCH_NOMATCH);
2774             }
2775 0           eptr += length;
2776 0           continue; /* With the main loop */
2777             }
2778              
2779             /* Handle repeated back references. If the length of the reference is
2780             zero, just continue with the main loop. If the length is negative, it
2781             means the reference is unset in non-Java-compatible mode. If the minimum is
2782             zero, we can continue at the same level without recursion. For any other
2783             minimum, carrying on will result in NOMATCH. */
2784              
2785 0 0         if (length == 0) continue;
2786 0 0         if (length < 0 && min == 0) continue;
    0          
2787              
2788             /* First, ensure the minimum number of matches are present. We get back
2789             the length of the reference string explicitly rather than passing the
2790             address of eptr, so that eptr can be a register variable. */
2791              
2792 0 0         for (i = 1; i <= min; i++)
2793             {
2794             int slength;
2795 0 0         if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2796             {
2797 0 0         if (slength == -2) eptr = md->end_subject; /* Partial match */
2798 0 0         CHECK_PARTIAL();
    0          
    0          
    0          
2799 0           RRETURN(MATCH_NOMATCH);
2800             }
2801 0           eptr += slength;
2802             }
2803              
2804             /* If min = max, continue at the same level without recursion.
2805             They are not both allowed to be zero. */
2806              
2807 0 0         if (min == max) continue;
2808              
2809             /* If minimizing, keep trying and advancing the pointer */
2810              
2811 0 0         if (minimize)
2812             {
2813 0           for (fi = min;; fi++)
2814             {
2815             int slength;
2816 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
2817 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2818 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
2819 0 0         if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2820             {
2821 0 0         if (slength == -2) eptr = md->end_subject; /* Partial match */
2822 0 0         CHECK_PARTIAL();
    0          
    0          
    0          
2823 0           RRETURN(MATCH_NOMATCH);
2824             }
2825 0           eptr += slength;
2826 0           }
2827             /* Control never gets here */
2828             }
2829              
2830             /* If maximizing, find the longest string and work backwards */
2831              
2832             else
2833             {
2834 0           pp = eptr;
2835 0 0         for (i = min; i < max; i++)
2836             {
2837             int slength;
2838 0 0         if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2839             {
2840             /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2841             the soft partial matching case. */
2842              
2843 0 0         if (slength == -2 && md->partial != 0 &&
    0          
    0          
2844 0           md->end_subject > md->start_used_ptr)
2845             {
2846 0           md->hitend = TRUE;
2847 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2848             }
2849 0           break;
2850             }
2851 0           eptr += slength;
2852             }
2853              
2854 0 0         while (eptr >= pp)
2855             {
2856 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
2857 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2858 0           eptr -= length;
2859             }
2860 0           RRETURN(MATCH_NOMATCH);
2861             }
2862             /* Control never gets here */
2863              
2864             /* Match a bit-mapped character class, possibly repeatedly. This op code is
2865             used when all the characters in the class have values in the range 0-255,
2866             and either the matching is caseful, or the characters are in the range
2867             0-127 when UTF-8 processing is enabled. The only difference between
2868             OP_CLASS and OP_NCLASS occurs when a data character outside the range is
2869             encountered.
2870              
2871             First, look past the end of the item to see if there is repeat information
2872             following. Then obey similar code to character type repeats - written out
2873             again for speed. */
2874              
2875             case OP_NCLASS:
2876             case OP_CLASS:
2877             {
2878             /* The data variable is saved across frames, so the byte map needs to
2879             be stored there. */
2880             #define BYTE_MAP ((pcre_uint8 *)data)
2881 0           data = ecode + 1; /* Save for matching */
2882 0           ecode += 1 + (32 / sizeof(pcre_uchar)); /* Advance past the item */
2883              
2884 0           switch (*ecode)
2885             {
2886             case OP_CRSTAR:
2887             case OP_CRMINSTAR:
2888             case OP_CRPLUS:
2889             case OP_CRMINPLUS:
2890             case OP_CRQUERY:
2891             case OP_CRMINQUERY:
2892             case OP_CRPOSSTAR:
2893             case OP_CRPOSPLUS:
2894             case OP_CRPOSQUERY:
2895 0           c = *ecode++ - OP_CRSTAR;
2896 0 0         if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
2897 0           else possessive = TRUE;
2898 0           min = rep_min[c]; /* Pick up values from tables; */
2899 0           max = rep_max[c]; /* zero for max => infinity */
2900 0 0         if (max == 0) max = INT_MAX;
2901 0           break;
2902              
2903             case OP_CRRANGE:
2904             case OP_CRMINRANGE:
2905             case OP_CRPOSRANGE:
2906 0           minimize = (*ecode == OP_CRMINRANGE);
2907 0           possessive = (*ecode == OP_CRPOSRANGE);
2908 0           min = GET2(ecode, 1);
2909 0           max = GET2(ecode, 1 + IMM2_SIZE);
2910 0 0         if (max == 0) max = INT_MAX;
2911 0           ecode += 1 + 2 * IMM2_SIZE;
2912 0           break;
2913              
2914             default: /* No repeat follows */
2915 0           min = max = 1;
2916 0           break;
2917             }
2918              
2919             /* First, ensure the minimum number of matches are present. */
2920              
2921             #ifdef SUPPORT_UTF
2922             if (utf)
2923             {
2924             for (i = 1; i <= min; i++)
2925             {
2926             if (eptr >= md->end_subject)
2927             {
2928             SCHECK_PARTIAL();
2929             RRETURN(MATCH_NOMATCH);
2930             }
2931             GETCHARINC(c, eptr);
2932             if (c > 255)
2933             {
2934             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2935             }
2936             else
2937             if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2938             }
2939             }
2940             else
2941             #endif
2942             /* Not UTF mode */
2943             {
2944 0 0         for (i = 1; i <= min; i++)
2945             {
2946 0 0         if (eptr >= md->end_subject)
2947             {
2948 0 0         SCHECK_PARTIAL();
    0          
    0          
2949 0           RRETURN(MATCH_NOMATCH);
2950             }
2951 0           c = *eptr++;
2952             #ifndef COMPILE_PCRE8
2953             if (c > 255)
2954             {
2955             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2956             }
2957             else
2958             #endif
2959 0 0         if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2960             }
2961             }
2962              
2963             /* If max == min we can continue with the main loop without the
2964             need to recurse. */
2965              
2966 0 0         if (min == max) continue;
2967              
2968             /* If minimizing, keep testing the rest of the expression and advancing
2969             the pointer while it matches the class. */
2970              
2971 0 0         if (minimize)
2972             {
2973             #ifdef SUPPORT_UTF
2974             if (utf)
2975             {
2976             for (fi = min;; fi++)
2977             {
2978             RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
2979             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2980             if (fi >= max) RRETURN(MATCH_NOMATCH);
2981             if (eptr >= md->end_subject)
2982             {
2983             SCHECK_PARTIAL();
2984             RRETURN(MATCH_NOMATCH);
2985             }
2986             GETCHARINC(c, eptr);
2987             if (c > 255)
2988             {
2989             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2990             }
2991             else
2992             if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2993             }
2994             }
2995             else
2996             #endif
2997             /* Not UTF mode */
2998             {
2999 0           for (fi = min;; fi++)
3000             {
3001 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
3002 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3003 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
3004 0 0         if (eptr >= md->end_subject)
3005             {
3006 0 0         SCHECK_PARTIAL();
    0          
    0          
3007 0           RRETURN(MATCH_NOMATCH);
3008             }
3009 0           c = *eptr++;
3010             #ifndef COMPILE_PCRE8
3011             if (c > 255)
3012             {
3013             if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
3014             }
3015             else
3016             #endif
3017 0 0         if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
3018 0           }
3019             }
3020             /* Control never gets here */
3021             }
3022              
3023             /* If maximizing, find the longest possible run, then work backwards. */
3024              
3025             else
3026             {
3027 0           pp = eptr;
3028              
3029             #ifdef SUPPORT_UTF
3030             if (utf)
3031             {
3032             for (i = min; i < max; i++)
3033             {
3034             int len = 1;
3035             if (eptr >= md->end_subject)
3036             {
3037             SCHECK_PARTIAL();
3038             break;
3039             }
3040             GETCHARLEN(c, eptr, len);
3041             if (c > 255)
3042             {
3043             if (op == OP_CLASS) break;
3044             }
3045             else
3046             if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3047             eptr += len;
3048             }
3049              
3050             if (possessive) continue; /* No backtracking */
3051              
3052             for (;;)
3053             {
3054             RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
3055             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3056             if (eptr-- <= pp) break; /* Stop if tried at original pos */
3057             BACKCHAR(eptr);
3058             }
3059             }
3060             else
3061             #endif
3062             /* Not UTF mode */
3063             {
3064 0 0         for (i = min; i < max; i++)
3065             {
3066 0 0         if (eptr >= md->end_subject)
3067             {
3068 0 0         SCHECK_PARTIAL();
    0          
    0          
3069 0           break;
3070             }
3071 0           c = *eptr;
3072             #ifndef COMPILE_PCRE8
3073             if (c > 255)
3074             {
3075             if (op == OP_CLASS) break;
3076             }
3077             else
3078             #endif
3079 0 0         if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3080 0           eptr++;
3081             }
3082              
3083 0 0         if (possessive) continue; /* No backtracking */
3084              
3085 0 0         while (eptr >= pp)
3086             {
3087 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
3088 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3089 0           eptr--;
3090             }
3091             }
3092              
3093 0           RRETURN(MATCH_NOMATCH);
3094             }
3095             #undef BYTE_MAP
3096             }
3097             /* Control never gets here */
3098              
3099              
3100             /* Match an extended character class. In the 8-bit library, this opcode is
3101             encountered only when UTF-8 mode mode is supported. In the 16-bit and
3102             32-bit libraries, codepoints greater than 255 may be encountered even when
3103             UTF is not supported. */
3104              
3105             #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3106             case OP_XCLASS:
3107             {
3108             data = ecode + 1 + LINK_SIZE; /* Save for matching */
3109             ecode += GET(ecode, 1); /* Advance past the item */
3110              
3111             switch (*ecode)
3112             {
3113             case OP_CRSTAR:
3114             case OP_CRMINSTAR:
3115             case OP_CRPLUS:
3116             case OP_CRMINPLUS:
3117             case OP_CRQUERY:
3118             case OP_CRMINQUERY:
3119             case OP_CRPOSSTAR:
3120             case OP_CRPOSPLUS:
3121             case OP_CRPOSQUERY:
3122             c = *ecode++ - OP_CRSTAR;
3123             if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
3124             else possessive = TRUE;
3125             min = rep_min[c]; /* Pick up values from tables; */
3126             max = rep_max[c]; /* zero for max => infinity */
3127             if (max == 0) max = INT_MAX;
3128             break;
3129              
3130             case OP_CRRANGE:
3131             case OP_CRMINRANGE:
3132             case OP_CRPOSRANGE:
3133             minimize = (*ecode == OP_CRMINRANGE);
3134             possessive = (*ecode == OP_CRPOSRANGE);
3135             min = GET2(ecode, 1);
3136             max = GET2(ecode, 1 + IMM2_SIZE);
3137             if (max == 0) max = INT_MAX;
3138             ecode += 1 + 2 * IMM2_SIZE;
3139             break;
3140              
3141             default: /* No repeat follows */
3142             min = max = 1;
3143             break;
3144             }
3145              
3146             /* First, ensure the minimum number of matches are present. */
3147              
3148             for (i = 1; i <= min; i++)
3149             {
3150             if (eptr >= md->end_subject)
3151             {
3152             SCHECK_PARTIAL();
3153             RRETURN(MATCH_NOMATCH);
3154             }
3155             GETCHARINCTEST(c, eptr);
3156             if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
3157             }
3158              
3159             /* If max == min we can continue with the main loop without the
3160             need to recurse. */
3161              
3162             if (min == max) continue;
3163              
3164             /* If minimizing, keep testing the rest of the expression and advancing
3165             the pointer while it matches the class. */
3166              
3167             if (minimize)
3168             {
3169             for (fi = min;; fi++)
3170             {
3171             RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
3172             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3173             if (fi >= max) RRETURN(MATCH_NOMATCH);
3174             if (eptr >= md->end_subject)
3175             {
3176             SCHECK_PARTIAL();
3177             RRETURN(MATCH_NOMATCH);
3178             }
3179             GETCHARINCTEST(c, eptr);
3180             if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
3181             }
3182             /* Control never gets here */
3183             }
3184              
3185             /* If maximizing, find the longest possible run, then work backwards. */
3186              
3187             else
3188             {
3189             pp = eptr;
3190             for (i = min; i < max; i++)
3191             {
3192             int len = 1;
3193             if (eptr >= md->end_subject)
3194             {
3195             SCHECK_PARTIAL();
3196             break;
3197             }
3198             #ifdef SUPPORT_UTF
3199             GETCHARLENTEST(c, eptr, len);
3200             #else
3201             c = *eptr;
3202             #endif
3203             if (!PRIV(xclass)(c, data, utf)) break;
3204             eptr += len;
3205             }
3206              
3207             if (possessive) continue; /* No backtracking */
3208              
3209             for(;;)
3210             {
3211             RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
3212             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3213             if (eptr-- <= pp) break; /* Stop if tried at original pos */
3214             #ifdef SUPPORT_UTF
3215             if (utf) BACKCHAR(eptr);
3216             #endif
3217             }
3218             RRETURN(MATCH_NOMATCH);
3219             }
3220              
3221             /* Control never gets here */
3222             }
3223             #endif /* End of XCLASS */
3224              
3225             /* Match a single character, casefully */
3226              
3227             case OP_CHAR:
3228             #ifdef SUPPORT_UTF
3229             if (utf)
3230             {
3231             length = 1;
3232             ecode++;
3233             GETCHARLEN(fc, ecode, length);
3234             if (length > md->end_subject - eptr)
3235             {
3236             CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
3237             RRETURN(MATCH_NOMATCH);
3238             }
3239             while (length-- > 0) if (*ecode++ != UCHAR21INC(eptr)) RRETURN(MATCH_NOMATCH);
3240             }
3241             else
3242             #endif
3243             /* Not UTF mode */
3244             {
3245 421 100         if (md->end_subject - eptr < 1)
3246             {
3247 10 50         SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
    0          
    0          
3248 10           RRETURN(MATCH_NOMATCH);
3249             }
3250 411 100         if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
3251 296           ecode += 2;
3252             }
3253 296           break;
3254              
3255             /* Match a single character, caselessly. If we are at the end of the
3256             subject, give up immediately. */
3257              
3258             case OP_CHARI:
3259 0 0         if (eptr >= md->end_subject)
3260             {
3261 0 0         SCHECK_PARTIAL();
    0          
    0          
3262 0           RRETURN(MATCH_NOMATCH);
3263             }
3264              
3265             #ifdef SUPPORT_UTF
3266             if (utf)
3267             {
3268             length = 1;
3269             ecode++;
3270             GETCHARLEN(fc, ecode, length);
3271              
3272             /* If the pattern character's value is < 128, we have only one byte, and
3273             we know that its other case must also be one byte long, so we can use the
3274             fast lookup table. We know that there is at least one byte left in the
3275             subject. */
3276              
3277             if (fc < 128)
3278             {
3279             pcre_uint32 cc = UCHAR21(eptr);
3280             if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH);
3281             ecode++;
3282             eptr++;
3283             }
3284              
3285             /* Otherwise we must pick up the subject character. Note that we cannot
3286             use the value of "length" to check for sufficient bytes left, because the
3287             other case of the character may have more or fewer bytes. */
3288              
3289             else
3290             {
3291             pcre_uint32 dc;
3292             GETCHARINC(dc, eptr);
3293             ecode += length;
3294              
3295             /* If we have Unicode property support, we can use it to test the other
3296             case of the character, if there is one. */
3297              
3298             if (fc != dc)
3299             {
3300             #ifdef SUPPORT_UCP
3301             if (dc != UCD_OTHERCASE(fc))
3302             #endif
3303             RRETURN(MATCH_NOMATCH);
3304             }
3305             }
3306             }
3307             else
3308             #endif /* SUPPORT_UTF */
3309              
3310             /* Not UTF mode */
3311             {
3312 0 0         if (TABLE_GET(ecode[1], md->lcc, ecode[1])
3313 0           != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);
3314 0           eptr++;
3315 0           ecode += 2;
3316             }
3317 0           break;
3318              
3319             /* Match a single character repeatedly. */
3320              
3321             case OP_EXACT:
3322             case OP_EXACTI:
3323 0           min = max = GET2(ecode, 1);
3324 0           ecode += 1 + IMM2_SIZE;
3325 0           goto REPEATCHAR;
3326              
3327             case OP_POSUPTO:
3328             case OP_POSUPTOI:
3329 0           possessive = TRUE;
3330             /* Fall through */
3331              
3332             case OP_UPTO:
3333             case OP_UPTOI:
3334             case OP_MINUPTO:
3335             case OP_MINUPTOI:
3336 0           min = 0;
3337 0           max = GET2(ecode, 1);
3338 0 0         minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
    0          
3339 0           ecode += 1 + IMM2_SIZE;
3340 0           goto REPEATCHAR;
3341              
3342             case OP_POSSTAR:
3343             case OP_POSSTARI:
3344 0           possessive = TRUE;
3345 0           min = 0;
3346 0           max = INT_MAX;
3347 0           ecode++;
3348 0           goto REPEATCHAR;
3349              
3350             case OP_POSPLUS:
3351             case OP_POSPLUSI:
3352 0           possessive = TRUE;
3353 0           min = 1;
3354 0           max = INT_MAX;
3355 0           ecode++;
3356 0           goto REPEATCHAR;
3357              
3358             case OP_POSQUERY:
3359             case OP_POSQUERYI:
3360 0           possessive = TRUE;
3361 0           min = 0;
3362 0           max = 1;
3363 0           ecode++;
3364 0           goto REPEATCHAR;
3365              
3366             case OP_STAR:
3367             case OP_STARI:
3368             case OP_MINSTAR:
3369             case OP_MINSTARI:
3370             case OP_PLUS:
3371             case OP_PLUSI:
3372             case OP_MINPLUS:
3373             case OP_MINPLUSI:
3374             case OP_QUERY:
3375             case OP_QUERYI:
3376             case OP_MINQUERY:
3377             case OP_MINQUERYI:
3378 0 0         c = *ecode++ - ((op < OP_STARI)? OP_STAR : OP_STARI);
3379 0           minimize = (c & 1) != 0;
3380 0           min = rep_min[c]; /* Pick up values from tables; */
3381 0           max = rep_max[c]; /* zero for max => infinity */
3382 0 0         if (max == 0) max = INT_MAX;
3383              
3384             /* Common code for all repeated single-character matches. We first check
3385             for the minimum number of characters. If the minimum equals the maximum, we
3386             are done. Otherwise, if minimizing, check the rest of the pattern for a
3387             match; if there isn't one, advance up to the maximum, one character at a
3388             time.
3389              
3390             If maximizing, advance up to the maximum number of matching characters,
3391             until eptr is past the end of the maximum run. If possessive, we are
3392             then done (no backing up). Otherwise, match at this position; anything
3393             other than no match is immediately returned. For nomatch, back up one
3394             character, unless we are matching \R and the last thing matched was
3395             \r\n, in which case, back up two bytes. When we reach the first optional
3396             character position, we can save stack by doing a tail recurse.
3397              
3398             The various UTF/non-UTF and caseful/caseless cases are handled separately,
3399             for speed. */
3400              
3401             REPEATCHAR:
3402             #ifdef SUPPORT_UTF
3403             if (utf)
3404             {
3405             length = 1;
3406             charptr = ecode;
3407             GETCHARLEN(fc, ecode, length);
3408             ecode += length;
3409              
3410             /* Handle multibyte character matching specially here. There is
3411             support for caseless matching if UCP support is present. */
3412              
3413             if (length > 1)
3414             {
3415             #ifdef SUPPORT_UCP
3416             pcre_uint32 othercase;
3417             if (op >= OP_STARI && /* Caseless */
3418             (othercase = UCD_OTHERCASE(fc)) != fc)
3419             oclength = PRIV(ord2utf)(othercase, occhars);
3420             else oclength = 0;
3421             #endif /* SUPPORT_UCP */
3422              
3423             for (i = 1; i <= min; i++)
3424             {
3425             if (eptr <= md->end_subject - length &&
3426             memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
3427             #ifdef SUPPORT_UCP
3428             else if (oclength > 0 &&
3429             eptr <= md->end_subject - oclength &&
3430             memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
3431             #endif /* SUPPORT_UCP */
3432             else
3433             {
3434             CHECK_PARTIAL();
3435             RRETURN(MATCH_NOMATCH);
3436             }
3437             }
3438              
3439             if (min == max) continue;
3440              
3441             if (minimize)
3442             {
3443             for (fi = min;; fi++)
3444             {
3445             RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
3446             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3447             if (fi >= max) RRETURN(MATCH_NOMATCH);
3448             if (eptr <= md->end_subject - length &&
3449             memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
3450             #ifdef SUPPORT_UCP
3451             else if (oclength > 0 &&
3452             eptr <= md->end_subject - oclength &&
3453             memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
3454             #endif /* SUPPORT_UCP */
3455             else
3456             {
3457             CHECK_PARTIAL();
3458             RRETURN(MATCH_NOMATCH);
3459             }
3460             }
3461             /* Control never gets here */
3462             }
3463              
3464             else /* Maximize */
3465             {
3466             pp = eptr;
3467             for (i = min; i < max; i++)
3468             {
3469             if (eptr <= md->end_subject - length &&
3470             memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
3471             #ifdef SUPPORT_UCP
3472             else if (oclength > 0 &&
3473             eptr <= md->end_subject - oclength &&
3474             memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
3475             #endif /* SUPPORT_UCP */
3476             else
3477             {
3478             CHECK_PARTIAL();
3479             break;
3480             }
3481             }
3482              
3483             if (possessive) continue; /* No backtracking */
3484             for(;;)
3485             {
3486             if (eptr <= pp) goto TAIL_RECURSE;
3487             RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
3488             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3489             #ifdef SUPPORT_UCP
3490             eptr--;
3491             BACKCHAR(eptr);
3492             #else /* without SUPPORT_UCP */
3493             eptr -= length;
3494             #endif /* SUPPORT_UCP */
3495             }
3496             }
3497             /* Control never gets here */
3498             }
3499              
3500             /* If the length of a UTF-8 character is 1, we fall through here, and
3501             obey the code as for non-UTF-8 characters below, though in this case the
3502             value of fc will always be < 128. */
3503             }
3504             else
3505             #endif /* SUPPORT_UTF */
3506             /* When not in UTF-8 mode, load a single-byte character. */
3507 0           fc = *ecode++;
3508              
3509             /* The value of fc at this point is always one character, though we may
3510             or may not be in UTF mode. The code is duplicated for the caseless and
3511             caseful cases, for speed, since matching characters is likely to be quite
3512             common. First, ensure the minimum number of matches are present. If min =
3513             max, continue at the same level without recursing. Otherwise, if
3514             minimizing, keep trying the rest of the expression and advancing one
3515             matching character if failing, up to the maximum. Alternatively, if
3516             maximizing, find the maximum number of characters and work backwards. */
3517              
3518             DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3519             max, (char *)eptr));
3520              
3521 0 0         if (op >= OP_STARI) /* Caseless */
3522             {
3523             #ifdef COMPILE_PCRE8
3524             /* fc must be < 128 if UTF is enabled. */
3525 0           foc = md->fcc[fc];
3526             #else
3527             #ifdef SUPPORT_UTF
3528             #ifdef SUPPORT_UCP
3529             if (utf && fc > 127)
3530             foc = UCD_OTHERCASE(fc);
3531             #else
3532             if (utf && fc > 127)
3533             foc = fc;
3534             #endif /* SUPPORT_UCP */
3535             else
3536             #endif /* SUPPORT_UTF */
3537             foc = TABLE_GET(fc, md->fcc, fc);
3538             #endif /* COMPILE_PCRE8 */
3539              
3540 0 0         for (i = 1; i <= min; i++)
3541             {
3542             pcre_uint32 cc; /* Faster than pcre_uchar */
3543 0 0         if (eptr >= md->end_subject)
3544             {
3545 0 0         SCHECK_PARTIAL();
    0          
    0          
3546 0           RRETURN(MATCH_NOMATCH);
3547             }
3548 0           cc = UCHAR21TEST(eptr);
3549 0 0         if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
    0          
3550 0           eptr++;
3551             }
3552 0 0         if (min == max) continue;
3553 0 0         if (minimize)
3554             {
3555 0           for (fi = min;; fi++)
3556             {
3557             pcre_uint32 cc; /* Faster than pcre_uchar */
3558 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3559 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3560 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
3561 0 0         if (eptr >= md->end_subject)
3562             {
3563 0 0         SCHECK_PARTIAL();
    0          
    0          
3564 0           RRETURN(MATCH_NOMATCH);
3565             }
3566 0           cc = UCHAR21TEST(eptr);
3567 0 0         if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
    0          
3568 0           eptr++;
3569 0           }
3570             /* Control never gets here */
3571             }
3572             else /* Maximize */
3573             {
3574 0           pp = eptr;
3575 0 0         for (i = min; i < max; i++)
3576             {
3577             pcre_uint32 cc; /* Faster than pcre_uchar */
3578 0 0         if (eptr >= md->end_subject)
3579             {
3580 0 0         SCHECK_PARTIAL();
    0          
    0          
3581 0           break;
3582             }
3583 0           cc = UCHAR21TEST(eptr);
3584 0 0         if (fc != cc && foc != cc) break;
    0          
3585 0           eptr++;
3586             }
3587 0 0         if (possessive) continue; /* No backtracking */
3588             for (;;)
3589             {
3590 0 0         if (eptr == pp) goto TAIL_RECURSE;
3591 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
3592 0           eptr--;
3593 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3594 0           }
3595             /* Control never gets here */
3596             }
3597             }
3598              
3599             /* Caseful comparisons (includes all multi-byte characters) */
3600              
3601             else
3602             {
3603 0 0         for (i = 1; i <= min; i++)
3604             {
3605 0 0         if (eptr >= md->end_subject)
3606             {
3607 0 0         SCHECK_PARTIAL();
    0          
    0          
3608 0           RRETURN(MATCH_NOMATCH);
3609             }
3610 0 0         if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3611             }
3612              
3613 0 0         if (min == max) continue;
3614              
3615 0 0         if (minimize)
3616             {
3617 0           for (fi = min;; fi++)
3618             {
3619 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
3620 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3621 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
3622 0 0         if (eptr >= md->end_subject)
3623             {
3624 0 0         SCHECK_PARTIAL();
    0          
    0          
3625 0           RRETURN(MATCH_NOMATCH);
3626             }
3627 0 0         if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3628 0           }
3629             /* Control never gets here */
3630             }
3631             else /* Maximize */
3632             {
3633 0           pp = eptr;
3634 0 0         for (i = min; i < max; i++)
3635             {
3636 0 0         if (eptr >= md->end_subject)
3637             {
3638 0 0         SCHECK_PARTIAL();
    0          
    0          
3639 0           break;
3640             }
3641 0 0         if (fc != UCHAR21TEST(eptr)) break;
3642 0           eptr++;
3643             }
3644 0 0         if (possessive) continue; /* No backtracking */
3645             for (;;)
3646             {
3647 0 0         if (eptr == pp) goto TAIL_RECURSE;
3648 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
3649 0           eptr--;
3650 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3651 0           }
3652             /* Control never gets here */
3653             }
3654             }
3655             /* Control never gets here */
3656              
3657             /* Match a negated single one-byte character. The character we are
3658             checking can be multibyte. */
3659              
3660             case OP_NOT:
3661             case OP_NOTI:
3662 0 0         if (eptr >= md->end_subject)
3663             {
3664 0 0         SCHECK_PARTIAL();
    0          
    0          
3665 0           RRETURN(MATCH_NOMATCH);
3666             }
3667             #ifdef SUPPORT_UTF
3668             if (utf)
3669             {
3670             register pcre_uint32 ch, och;
3671              
3672             ecode++;
3673             GETCHARINC(ch, ecode);
3674             GETCHARINC(c, eptr);
3675              
3676             if (op == OP_NOT)
3677             {
3678             if (ch == c) RRETURN(MATCH_NOMATCH);
3679             }
3680             else
3681             {
3682             #ifdef SUPPORT_UCP
3683             if (ch > 127)
3684             och = UCD_OTHERCASE(ch);
3685             #else
3686             if (ch > 127)
3687             och = ch;
3688             #endif /* SUPPORT_UCP */
3689             else
3690             och = TABLE_GET(ch, md->fcc, ch);
3691             if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3692             }
3693             }
3694             else
3695             #endif
3696             {
3697 0           register pcre_uint32 ch = ecode[1];
3698 0           c = *eptr++;
3699 0 0         if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
    0          
    0          
3700 0           RRETURN(MATCH_NOMATCH);
3701 0           ecode += 2;
3702             }
3703 0           break;
3704              
3705             /* Match a negated single one-byte character repeatedly. This is almost a
3706             repeat of the code for a repeated single character, but I haven't found a
3707             nice way of commoning these up that doesn't require a test of the
3708             positive/negative option for each character match. Maybe that wouldn't add
3709             very much to the time taken, but character matching *is* what this is all
3710             about... */
3711              
3712             case OP_NOTEXACT:
3713             case OP_NOTEXACTI:
3714 0           min = max = GET2(ecode, 1);
3715 0           ecode += 1 + IMM2_SIZE;
3716 0           goto REPEATNOTCHAR;
3717              
3718             case OP_NOTUPTO:
3719             case OP_NOTUPTOI:
3720             case OP_NOTMINUPTO:
3721             case OP_NOTMINUPTOI:
3722 0           min = 0;
3723 0           max = GET2(ecode, 1);
3724 0 0         minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
    0          
3725 0           ecode += 1 + IMM2_SIZE;
3726 0           goto REPEATNOTCHAR;
3727              
3728             case OP_NOTPOSSTAR:
3729             case OP_NOTPOSSTARI:
3730 0           possessive = TRUE;
3731 0           min = 0;
3732 0           max = INT_MAX;
3733 0           ecode++;
3734 0           goto REPEATNOTCHAR;
3735              
3736             case OP_NOTPOSPLUS:
3737             case OP_NOTPOSPLUSI:
3738 0           possessive = TRUE;
3739 0           min = 1;
3740 0           max = INT_MAX;
3741 0           ecode++;
3742 0           goto REPEATNOTCHAR;
3743              
3744             case OP_NOTPOSQUERY:
3745             case OP_NOTPOSQUERYI:
3746 0           possessive = TRUE;
3747 0           min = 0;
3748 0           max = 1;
3749 0           ecode++;
3750 0           goto REPEATNOTCHAR;
3751              
3752             case OP_NOTPOSUPTO:
3753             case OP_NOTPOSUPTOI:
3754 0           possessive = TRUE;
3755 0           min = 0;
3756 0           max = GET2(ecode, 1);
3757 0           ecode += 1 + IMM2_SIZE;
3758 0           goto REPEATNOTCHAR;
3759              
3760             case OP_NOTSTAR:
3761             case OP_NOTSTARI:
3762             case OP_NOTMINSTAR:
3763             case OP_NOTMINSTARI:
3764             case OP_NOTPLUS:
3765             case OP_NOTPLUSI:
3766             case OP_NOTMINPLUS:
3767             case OP_NOTMINPLUSI:
3768             case OP_NOTQUERY:
3769             case OP_NOTQUERYI:
3770             case OP_NOTMINQUERY:
3771             case OP_NOTMINQUERYI:
3772 0 0         c = *ecode++ - ((op >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
3773 0           minimize = (c & 1) != 0;
3774 0           min = rep_min[c]; /* Pick up values from tables; */
3775 0           max = rep_max[c]; /* zero for max => infinity */
3776 0 0         if (max == 0) max = INT_MAX;
3777              
3778             /* Common code for all repeated single-byte matches. */
3779              
3780             REPEATNOTCHAR:
3781 0           GETCHARINCTEST(fc, ecode);
3782              
3783             /* The code is duplicated for the caseless and caseful cases, for speed,
3784             since matching characters is likely to be quite common. First, ensure the
3785             minimum number of matches are present. If min = max, continue at the same
3786             level without recursing. Otherwise, if minimizing, keep trying the rest of
3787             the expression and advancing one matching character if failing, up to the
3788             maximum. Alternatively, if maximizing, find the maximum number of
3789             characters and work backwards. */
3790              
3791             DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3792             max, (char *)eptr));
3793              
3794 0 0         if (op >= OP_NOTSTARI) /* Caseless */
3795             {
3796             #ifdef SUPPORT_UTF
3797             #ifdef SUPPORT_UCP
3798             if (utf && fc > 127)
3799             foc = UCD_OTHERCASE(fc);
3800             #else
3801             if (utf && fc > 127)
3802             foc = fc;
3803             #endif /* SUPPORT_UCP */
3804             else
3805             #endif /* SUPPORT_UTF */
3806 0           foc = TABLE_GET(fc, md->fcc, fc);
3807              
3808             #ifdef SUPPORT_UTF
3809             if (utf)
3810             {
3811             register pcre_uint32 d;
3812             for (i = 1; i <= min; i++)
3813             {
3814             if (eptr >= md->end_subject)
3815             {
3816             SCHECK_PARTIAL();
3817             RRETURN(MATCH_NOMATCH);
3818             }
3819             GETCHARINC(d, eptr);
3820             if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3821             }
3822             }
3823             else
3824             #endif /* SUPPORT_UTF */
3825             /* Not UTF mode */
3826             {
3827 0 0         for (i = 1; i <= min; i++)
3828             {
3829 0 0         if (eptr >= md->end_subject)
3830             {
3831 0 0         SCHECK_PARTIAL();
    0          
    0          
3832 0           RRETURN(MATCH_NOMATCH);
3833             }
3834 0 0         if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
    0          
3835 0           eptr++;
3836             }
3837             }
3838              
3839 0 0         if (min == max) continue;
3840              
3841 0 0         if (minimize)
3842             {
3843             #ifdef SUPPORT_UTF
3844             if (utf)
3845             {
3846             register pcre_uint32 d;
3847             for (fi = min;; fi++)
3848             {
3849             RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
3850             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3851             if (fi >= max) RRETURN(MATCH_NOMATCH);
3852             if (eptr >= md->end_subject)
3853             {
3854             SCHECK_PARTIAL();
3855             RRETURN(MATCH_NOMATCH);
3856             }
3857             GETCHARINC(d, eptr);
3858             if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3859             }
3860             }
3861             else
3862             #endif /*SUPPORT_UTF */
3863             /* Not UTF mode */
3864             {
3865 0           for (fi = min;; fi++)
3866             {
3867 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
3868 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3869 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
3870 0 0         if (eptr >= md->end_subject)
3871             {
3872 0 0         SCHECK_PARTIAL();
    0          
    0          
3873 0           RRETURN(MATCH_NOMATCH);
3874             }
3875 0 0         if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
    0          
3876 0           eptr++;
3877 0           }
3878             }
3879             /* Control never gets here */
3880             }
3881              
3882             /* Maximize case */
3883              
3884             else
3885             {
3886 0           pp = eptr;
3887              
3888             #ifdef SUPPORT_UTF
3889             if (utf)
3890             {
3891             register pcre_uint32 d;
3892             for (i = min; i < max; i++)
3893             {
3894             int len = 1;
3895             if (eptr >= md->end_subject)
3896             {
3897             SCHECK_PARTIAL();
3898             break;
3899             }
3900             GETCHARLEN(d, eptr, len);
3901             if (fc == d || (unsigned int)foc == d) break;
3902             eptr += len;
3903             }
3904             if (possessive) continue; /* No backtracking */
3905             for(;;)
3906             {
3907             if (eptr <= pp) goto TAIL_RECURSE;
3908             RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
3909             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3910             eptr--;
3911             BACKCHAR(eptr);
3912             }
3913             }
3914             else
3915             #endif /* SUPPORT_UTF */
3916             /* Not UTF mode */
3917             {
3918 0 0         for (i = min; i < max; i++)
3919             {
3920 0 0         if (eptr >= md->end_subject)
3921             {
3922 0 0         SCHECK_PARTIAL();
    0          
    0          
3923 0           break;
3924             }
3925 0 0         if (fc == *eptr || foc == *eptr) break;
    0          
3926 0           eptr++;
3927             }
3928 0 0         if (possessive) continue; /* No backtracking */
3929             for (;;)
3930             {
3931 0 0         if (eptr == pp) goto TAIL_RECURSE;
3932 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
3933 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3934 0           eptr--;
3935 0           }
3936             }
3937             /* Control never gets here */
3938             }
3939             }
3940              
3941             /* Caseful comparisons */
3942              
3943             else
3944             {
3945             #ifdef SUPPORT_UTF
3946             if (utf)
3947             {
3948             register pcre_uint32 d;
3949             for (i = 1; i <= min; i++)
3950             {
3951             if (eptr >= md->end_subject)
3952             {
3953             SCHECK_PARTIAL();
3954             RRETURN(MATCH_NOMATCH);
3955             }
3956             GETCHARINC(d, eptr);
3957             if (fc == d) RRETURN(MATCH_NOMATCH);
3958             }
3959             }
3960             else
3961             #endif
3962             /* Not UTF mode */
3963             {
3964 0 0         for (i = 1; i <= min; i++)
3965             {
3966 0 0         if (eptr >= md->end_subject)
3967             {
3968 0 0         SCHECK_PARTIAL();
    0          
    0          
3969 0           RRETURN(MATCH_NOMATCH);
3970             }
3971 0 0         if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3972             }
3973             }
3974              
3975 0 0         if (min == max) continue;
3976              
3977 0 0         if (minimize)
3978             {
3979             #ifdef SUPPORT_UTF
3980             if (utf)
3981             {
3982             register pcre_uint32 d;
3983             for (fi = min;; fi++)
3984             {
3985             RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
3986             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3987             if (fi >= max) RRETURN(MATCH_NOMATCH);
3988             if (eptr >= md->end_subject)
3989             {
3990             SCHECK_PARTIAL();
3991             RRETURN(MATCH_NOMATCH);
3992             }
3993             GETCHARINC(d, eptr);
3994             if (fc == d) RRETURN(MATCH_NOMATCH);
3995             }
3996             }
3997             else
3998             #endif
3999             /* Not UTF mode */
4000             {
4001 0           for (fi = min;; fi++)
4002             {
4003 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
4004 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4005 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
4006 0 0         if (eptr >= md->end_subject)
4007             {
4008 0 0         SCHECK_PARTIAL();
    0          
    0          
4009 0           RRETURN(MATCH_NOMATCH);
4010             }
4011 0 0         if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
4012 0           }
4013             }
4014             /* Control never gets here */
4015             }
4016              
4017             /* Maximize case */
4018              
4019             else
4020             {
4021 0           pp = eptr;
4022              
4023             #ifdef SUPPORT_UTF
4024             if (utf)
4025             {
4026             register pcre_uint32 d;
4027             for (i = min; i < max; i++)
4028             {
4029             int len = 1;
4030             if (eptr >= md->end_subject)
4031             {
4032             SCHECK_PARTIAL();
4033             break;
4034             }
4035             GETCHARLEN(d, eptr, len);
4036             if (fc == d) break;
4037             eptr += len;
4038             }
4039             if (possessive) continue; /* No backtracking */
4040             for(;;)
4041             {
4042             if (eptr <= pp) goto TAIL_RECURSE;
4043             RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
4044             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4045             eptr--;
4046             BACKCHAR(eptr);
4047             }
4048             }
4049             else
4050             #endif
4051             /* Not UTF mode */
4052             {
4053 0 0         for (i = min; i < max; i++)
4054             {
4055 0 0         if (eptr >= md->end_subject)
4056             {
4057 0 0         SCHECK_PARTIAL();
    0          
    0          
4058 0           break;
4059             }
4060 0 0         if (fc == *eptr) break;
4061 0           eptr++;
4062             }
4063 0 0         if (possessive) continue; /* No backtracking */
4064             for (;;)
4065             {
4066 0 0         if (eptr == pp) goto TAIL_RECURSE;
4067 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
4068 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4069 0           eptr--;
4070 0           }
4071             }
4072             /* Control never gets here */
4073             }
4074             }
4075             /* Control never gets here */
4076              
4077             /* Match a single character type repeatedly; several different opcodes
4078             share code. This is very similar to the code for single characters, but we
4079             repeat it in the interests of efficiency. */
4080              
4081             case OP_TYPEEXACT:
4082 0           min = max = GET2(ecode, 1);
4083 0           minimize = TRUE;
4084 0           ecode += 1 + IMM2_SIZE;
4085 0           goto REPEATTYPE;
4086              
4087             case OP_TYPEUPTO:
4088             case OP_TYPEMINUPTO:
4089 0           min = 0;
4090 0           max = GET2(ecode, 1);
4091 0           minimize = *ecode == OP_TYPEMINUPTO;
4092 0           ecode += 1 + IMM2_SIZE;
4093 0           goto REPEATTYPE;
4094              
4095             case OP_TYPEPOSSTAR:
4096 0           possessive = TRUE;
4097 0           min = 0;
4098 0           max = INT_MAX;
4099 0           ecode++;
4100 0           goto REPEATTYPE;
4101              
4102             case OP_TYPEPOSPLUS:
4103 4           possessive = TRUE;
4104 4           min = 1;
4105 4           max = INT_MAX;
4106 4           ecode++;
4107 4           goto REPEATTYPE;
4108              
4109             case OP_TYPEPOSQUERY:
4110 0           possessive = TRUE;
4111 0           min = 0;
4112 0           max = 1;
4113 0           ecode++;
4114 0           goto REPEATTYPE;
4115              
4116             case OP_TYPEPOSUPTO:
4117 0           possessive = TRUE;
4118 0           min = 0;
4119 0           max = GET2(ecode, 1);
4120 0           ecode += 1 + IMM2_SIZE;
4121 0           goto REPEATTYPE;
4122              
4123             case OP_TYPESTAR:
4124             case OP_TYPEMINSTAR:
4125             case OP_TYPEPLUS:
4126             case OP_TYPEMINPLUS:
4127             case OP_TYPEQUERY:
4128             case OP_TYPEMINQUERY:
4129 10           c = *ecode++ - OP_TYPESTAR;
4130 10           minimize = (c & 1) != 0;
4131 10           min = rep_min[c]; /* Pick up values from tables; */
4132 10           max = rep_max[c]; /* zero for max => infinity */
4133 10 50         if (max == 0) max = INT_MAX;
4134              
4135             /* Common code for all repeated single character type matches. Note that
4136             in UTF-8 mode, '.' matches a character of any length, but for the other
4137             character types, the valid characters are all one-byte long. */
4138              
4139             REPEATTYPE:
4140 14           ctype = *ecode++; /* Code for the character type */
4141              
4142             #ifdef SUPPORT_UCP
4143             if (ctype == OP_PROP || ctype == OP_NOTPROP)
4144             {
4145             prop_fail_result = ctype == OP_NOTPROP;
4146             prop_type = *ecode++;
4147             prop_value = *ecode++;
4148             }
4149             else prop_type = -1;
4150             #endif
4151              
4152             /* First, ensure the minimum number of matches are present. Use inline
4153             code for maximizing the speed, and do the type test once at the start
4154             (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
4155             is tidier. Also separate the UCP code, which can be the same for both UTF-8
4156             and single-bytes. */
4157              
4158 14 100         if (min > 0)
4159             {
4160             #ifdef SUPPORT_UCP
4161             if (prop_type >= 0)
4162             {
4163             switch(prop_type)
4164             {
4165             case PT_ANY:
4166             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4167             for (i = 1; i <= min; i++)
4168             {
4169             if (eptr >= md->end_subject)
4170             {
4171             SCHECK_PARTIAL();
4172             RRETURN(MATCH_NOMATCH);
4173             }
4174             GETCHARINCTEST(c, eptr);
4175             }
4176             break;
4177              
4178             case PT_LAMP:
4179             for (i = 1; i <= min; i++)
4180             {
4181             int chartype;
4182             if (eptr >= md->end_subject)
4183             {
4184             SCHECK_PARTIAL();
4185             RRETURN(MATCH_NOMATCH);
4186             }
4187             GETCHARINCTEST(c, eptr);
4188             chartype = UCD_CHARTYPE(c);
4189             if ((chartype == ucp_Lu ||
4190             chartype == ucp_Ll ||
4191             chartype == ucp_Lt) == prop_fail_result)
4192             RRETURN(MATCH_NOMATCH);
4193             }
4194             break;
4195              
4196             case PT_GC:
4197             for (i = 1; i <= min; i++)
4198             {
4199             if (eptr >= md->end_subject)
4200             {
4201             SCHECK_PARTIAL();
4202             RRETURN(MATCH_NOMATCH);
4203             }
4204             GETCHARINCTEST(c, eptr);
4205             if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
4206             RRETURN(MATCH_NOMATCH);
4207             }
4208             break;
4209              
4210             case PT_PC:
4211             for (i = 1; i <= min; i++)
4212             {
4213             if (eptr >= md->end_subject)
4214             {
4215             SCHECK_PARTIAL();
4216             RRETURN(MATCH_NOMATCH);
4217             }
4218             GETCHARINCTEST(c, eptr);
4219             if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
4220             RRETURN(MATCH_NOMATCH);
4221             }
4222             break;
4223              
4224             case PT_SC:
4225             for (i = 1; i <= min; i++)
4226             {
4227             if (eptr >= md->end_subject)
4228             {
4229             SCHECK_PARTIAL();
4230             RRETURN(MATCH_NOMATCH);
4231             }
4232             GETCHARINCTEST(c, eptr);
4233             if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
4234             RRETURN(MATCH_NOMATCH);
4235             }
4236             break;
4237              
4238             case PT_ALNUM:
4239             for (i = 1; i <= min; i++)
4240             {
4241             int category;
4242             if (eptr >= md->end_subject)
4243             {
4244             SCHECK_PARTIAL();
4245             RRETURN(MATCH_NOMATCH);
4246             }
4247             GETCHARINCTEST(c, eptr);
4248             category = UCD_CATEGORY(c);
4249             if ((category == ucp_L || category == ucp_N) == prop_fail_result)
4250             RRETURN(MATCH_NOMATCH);
4251             }
4252             break;
4253              
4254             /* Perl space used to exclude VT, but from Perl 5.18 it is included,
4255             which means that Perl space and POSIX space are now identical. PCRE
4256             was changed at release 8.34. */
4257              
4258             case PT_SPACE: /* Perl space */
4259             case PT_PXSPACE: /* POSIX space */
4260             for (i = 1; i <= min; i++)
4261             {
4262             if (eptr >= md->end_subject)
4263             {
4264             SCHECK_PARTIAL();
4265             RRETURN(MATCH_NOMATCH);
4266             }
4267             GETCHARINCTEST(c, eptr);
4268             switch(c)
4269             {
4270             HSPACE_CASES:
4271             VSPACE_CASES:
4272             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4273             break;
4274              
4275             default:
4276             if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
4277             RRETURN(MATCH_NOMATCH);
4278             break;
4279             }
4280             }
4281             break;
4282              
4283             case PT_WORD:
4284             for (i = 1; i <= min; i++)
4285             {
4286             int category;
4287             if (eptr >= md->end_subject)
4288             {
4289             SCHECK_PARTIAL();
4290             RRETURN(MATCH_NOMATCH);
4291             }
4292             GETCHARINCTEST(c, eptr);
4293             category = UCD_CATEGORY(c);
4294             if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)
4295             == prop_fail_result)
4296             RRETURN(MATCH_NOMATCH);
4297             }
4298             break;
4299              
4300             case PT_CLIST:
4301             for (i = 1; i <= min; i++)
4302             {
4303             const pcre_uint32 *cp;
4304             if (eptr >= md->end_subject)
4305             {
4306             SCHECK_PARTIAL();
4307             RRETURN(MATCH_NOMATCH);
4308             }
4309             GETCHARINCTEST(c, eptr);
4310             cp = PRIV(ucd_caseless_sets) + prop_value;
4311             for (;;)
4312             {
4313             if (c < *cp)
4314             { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4315             if (c == *cp++)
4316             { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4317             }
4318             }
4319             break;
4320              
4321             case PT_UCNC:
4322             for (i = 1; i <= min; i++)
4323             {
4324             if (eptr >= md->end_subject)
4325             {
4326             SCHECK_PARTIAL();
4327             RRETURN(MATCH_NOMATCH);
4328             }
4329             GETCHARINCTEST(c, eptr);
4330             if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
4331             c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
4332             c >= 0xe000) == prop_fail_result)
4333             RRETURN(MATCH_NOMATCH);
4334             }
4335             break;
4336              
4337             /* This should not occur */
4338              
4339             default:
4340             RRETURN(PCRE_ERROR_INTERNAL);
4341             }
4342             }
4343              
4344             /* Match extended Unicode sequences. We will get here only if the
4345             support is in the binary; otherwise a compile-time error occurs. */
4346              
4347             else if (ctype == OP_EXTUNI)
4348             {
4349             for (i = 1; i <= min; i++)
4350             {
4351             if (eptr >= md->end_subject)
4352             {
4353             SCHECK_PARTIAL();
4354             RRETURN(MATCH_NOMATCH);
4355             }
4356             else
4357             {
4358             int lgb, rgb;
4359             GETCHARINCTEST(c, eptr);
4360             lgb = UCD_GRAPHBREAK(c);
4361             while (eptr < md->end_subject)
4362             {
4363             int len = 1;
4364             if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4365             rgb = UCD_GRAPHBREAK(c);
4366             if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4367             lgb = rgb;
4368             eptr += len;
4369             }
4370             }
4371             CHECK_PARTIAL();
4372             }
4373             }
4374              
4375             else
4376             #endif /* SUPPORT_UCP */
4377              
4378             /* Handle all other cases when the coding is UTF-8 */
4379              
4380             #ifdef SUPPORT_UTF
4381             if (utf) switch(ctype)
4382             {
4383             case OP_ANY:
4384             for (i = 1; i <= min; i++)
4385             {
4386             if (eptr >= md->end_subject)
4387             {
4388             SCHECK_PARTIAL();
4389             RRETURN(MATCH_NOMATCH);
4390             }
4391             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4392             if (md->partial != 0 &&
4393             eptr + 1 >= md->end_subject &&
4394             NLBLOCK->nltype == NLTYPE_FIXED &&
4395             NLBLOCK->nllen == 2 &&
4396             UCHAR21(eptr) == NLBLOCK->nl[0])
4397             {
4398             md->hitend = TRUE;
4399             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4400             }
4401             eptr++;
4402             ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4403             }
4404             break;
4405              
4406             case OP_ALLANY:
4407             for (i = 1; i <= min; i++)
4408             {
4409             if (eptr >= md->end_subject)
4410             {
4411             SCHECK_PARTIAL();
4412             RRETURN(MATCH_NOMATCH);
4413             }
4414             eptr++;
4415             ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4416             }
4417             break;
4418              
4419             case OP_ANYBYTE:
4420             if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
4421             eptr += min;
4422             break;
4423              
4424             case OP_ANYNL:
4425             for (i = 1; i <= min; i++)
4426             {
4427             if (eptr >= md->end_subject)
4428             {
4429             SCHECK_PARTIAL();
4430             RRETURN(MATCH_NOMATCH);
4431             }
4432             GETCHARINC(c, eptr);
4433             switch(c)
4434             {
4435             default: RRETURN(MATCH_NOMATCH);
4436              
4437             case CHAR_CR:
4438             if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++;
4439             break;
4440              
4441             case CHAR_LF:
4442             break;
4443              
4444             case CHAR_VT:
4445             case CHAR_FF:
4446             case CHAR_NEL:
4447             #ifndef EBCDIC
4448             case 0x2028:
4449             case 0x2029:
4450             #endif /* Not EBCDIC */
4451             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4452             break;
4453             }
4454             }
4455             break;
4456              
4457             case OP_NOT_HSPACE:
4458             for (i = 1; i <= min; i++)
4459             {
4460             if (eptr >= md->end_subject)
4461             {
4462             SCHECK_PARTIAL();
4463             RRETURN(MATCH_NOMATCH);
4464             }
4465             GETCHARINC(c, eptr);
4466             switch(c)
4467             {
4468             HSPACE_CASES: RRETURN(MATCH_NOMATCH); /* Byte and multibyte cases */
4469             default: break;
4470             }
4471             }
4472             break;
4473              
4474             case OP_HSPACE:
4475             for (i = 1; i <= min; i++)
4476             {
4477             if (eptr >= md->end_subject)
4478             {
4479             SCHECK_PARTIAL();
4480             RRETURN(MATCH_NOMATCH);
4481             }
4482             GETCHARINC(c, eptr);
4483             switch(c)
4484             {
4485             HSPACE_CASES: break; /* Byte and multibyte cases */
4486             default: RRETURN(MATCH_NOMATCH);
4487             }
4488             }
4489             break;
4490              
4491             case OP_NOT_VSPACE:
4492             for (i = 1; i <= min; i++)
4493             {
4494             if (eptr >= md->end_subject)
4495             {
4496             SCHECK_PARTIAL();
4497             RRETURN(MATCH_NOMATCH);
4498             }
4499             GETCHARINC(c, eptr);
4500             switch(c)
4501             {
4502             VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4503             default: break;
4504             }
4505             }
4506             break;
4507              
4508             case OP_VSPACE:
4509             for (i = 1; i <= min; i++)
4510             {
4511             if (eptr >= md->end_subject)
4512             {
4513             SCHECK_PARTIAL();
4514             RRETURN(MATCH_NOMATCH);
4515             }
4516             GETCHARINC(c, eptr);
4517             switch(c)
4518             {
4519             VSPACE_CASES: break;
4520             default: RRETURN(MATCH_NOMATCH);
4521             }
4522             }
4523             break;
4524              
4525             case OP_NOT_DIGIT:
4526             for (i = 1; i <= min; i++)
4527             {
4528             if (eptr >= md->end_subject)
4529             {
4530             SCHECK_PARTIAL();
4531             RRETURN(MATCH_NOMATCH);
4532             }
4533             GETCHARINC(c, eptr);
4534             if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
4535             RRETURN(MATCH_NOMATCH);
4536             }
4537             break;
4538              
4539             case OP_DIGIT:
4540             for (i = 1; i <= min; i++)
4541             {
4542             pcre_uint32 cc;
4543             if (eptr >= md->end_subject)
4544             {
4545             SCHECK_PARTIAL();
4546             RRETURN(MATCH_NOMATCH);
4547             }
4548             cc = UCHAR21(eptr);
4549             if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0)
4550             RRETURN(MATCH_NOMATCH);
4551             eptr++;
4552             /* No need to skip more bytes - we know it's a 1-byte character */
4553             }
4554             break;
4555              
4556             case OP_NOT_WHITESPACE:
4557             for (i = 1; i <= min; i++)
4558             {
4559             pcre_uint32 cc;
4560             if (eptr >= md->end_subject)
4561             {
4562             SCHECK_PARTIAL();
4563             RRETURN(MATCH_NOMATCH);
4564             }
4565             cc = UCHAR21(eptr);
4566             if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0)
4567             RRETURN(MATCH_NOMATCH);
4568             eptr++;
4569             ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4570             }
4571             break;
4572              
4573             case OP_WHITESPACE:
4574             for (i = 1; i <= min; i++)
4575             {
4576             pcre_uint32 cc;
4577             if (eptr >= md->end_subject)
4578             {
4579             SCHECK_PARTIAL();
4580             RRETURN(MATCH_NOMATCH);
4581             }
4582             cc = UCHAR21(eptr);
4583             if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0)
4584             RRETURN(MATCH_NOMATCH);
4585             eptr++;
4586             /* No need to skip more bytes - we know it's a 1-byte character */
4587             }
4588             break;
4589              
4590             case OP_NOT_WORDCHAR:
4591             for (i = 1; i <= min; i++)
4592             {
4593             pcre_uint32 cc;
4594             if (eptr >= md->end_subject)
4595             {
4596             SCHECK_PARTIAL();
4597             RRETURN(MATCH_NOMATCH);
4598             }
4599             cc = UCHAR21(eptr);
4600             if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0)
4601             RRETURN(MATCH_NOMATCH);
4602             eptr++;
4603             ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4604             }
4605             break;
4606              
4607             case OP_WORDCHAR:
4608             for (i = 1; i <= min; i++)
4609             {
4610             pcre_uint32 cc;
4611             if (eptr >= md->end_subject)
4612             {
4613             SCHECK_PARTIAL();
4614             RRETURN(MATCH_NOMATCH);
4615             }
4616             cc = UCHAR21(eptr);
4617             if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0)
4618             RRETURN(MATCH_NOMATCH);
4619             eptr++;
4620             /* No need to skip more bytes - we know it's a 1-byte character */
4621             }
4622             break;
4623              
4624             default:
4625             RRETURN(PCRE_ERROR_INTERNAL);
4626             } /* End switch(ctype) */
4627              
4628             else
4629             #endif /* SUPPORT_UTF */
4630              
4631             /* Code for the non-UTF-8 case for minimum matching of operators other
4632             than OP_PROP and OP_NOTPROP. */
4633              
4634 4           switch(ctype)
4635             {
4636             case OP_ANY:
4637 8 100         for (i = 1; i <= min; i++)
4638             {
4639 4 50         if (eptr >= md->end_subject)
4640             {
4641 0 0         SCHECK_PARTIAL();
    0          
    0          
4642 0           RRETURN(MATCH_NOMATCH);
4643             }
4644 4 50         if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
    50          
    50          
    0          
    0          
    0          
    0          
    50          
4645 4 50         if (md->partial != 0 &&
    0          
4646 0 0         eptr + 1 >= md->end_subject &&
4647 0 0         NLBLOCK->nltype == NLTYPE_FIXED &&
4648 0 0         NLBLOCK->nllen == 2 &&
4649 0           *eptr == NLBLOCK->nl[0])
4650             {
4651 0           md->hitend = TRUE;
4652 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4653             }
4654 4           eptr++;
4655             }
4656 4           break;
4657              
4658             case OP_ALLANY:
4659 0 0         if (eptr > md->end_subject - min)
4660             {
4661 0 0         SCHECK_PARTIAL();
    0          
    0          
4662 0           RRETURN(MATCH_NOMATCH);
4663             }
4664 0           eptr += min;
4665 0           break;
4666              
4667             case OP_ANYBYTE:
4668 0 0         if (eptr > md->end_subject - min)
4669             {
4670 0 0         SCHECK_PARTIAL();
    0          
    0          
4671 0           RRETURN(MATCH_NOMATCH);
4672             }
4673 0           eptr += min;
4674 0           break;
4675              
4676             case OP_ANYNL:
4677 0 0         for (i = 1; i <= min; i++)
4678             {
4679 0 0         if (eptr >= md->end_subject)
4680             {
4681 0 0         SCHECK_PARTIAL();
    0          
    0          
4682 0           RRETURN(MATCH_NOMATCH);
4683             }
4684 0           switch(*eptr++)
4685             {
4686 0           default: RRETURN(MATCH_NOMATCH);
4687              
4688             case CHAR_CR:
4689 0 0         if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
    0          
4690 0           break;
4691              
4692             case CHAR_LF:
4693 0           break;
4694              
4695             case CHAR_VT:
4696             case CHAR_FF:
4697             case CHAR_NEL:
4698             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4699             case 0x2028:
4700             case 0x2029:
4701             #endif
4702 0 0         if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4703 0           break;
4704             }
4705             }
4706 0           break;
4707              
4708             case OP_NOT_HSPACE:
4709 0 0         for (i = 1; i <= min; i++)
4710             {
4711 0 0         if (eptr >= md->end_subject)
4712             {
4713 0 0         SCHECK_PARTIAL();
    0          
    0          
4714 0           RRETURN(MATCH_NOMATCH);
4715             }
4716 0 0         switch(*eptr++)
4717             {
4718 0           default: break;
4719             HSPACE_BYTE_CASES:
4720             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4721             HSPACE_MULTIBYTE_CASES:
4722             #endif
4723 0           RRETURN(MATCH_NOMATCH);
4724             }
4725             }
4726 0           break;
4727              
4728             case OP_HSPACE:
4729 0 0         for (i = 1; i <= min; i++)
4730             {
4731 0 0         if (eptr >= md->end_subject)
4732             {
4733 0 0         SCHECK_PARTIAL();
    0          
    0          
4734 0           RRETURN(MATCH_NOMATCH);
4735             }
4736 0 0         switch(*eptr++)
4737             {
4738 0           default: RRETURN(MATCH_NOMATCH);
4739             HSPACE_BYTE_CASES:
4740             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4741             HSPACE_MULTIBYTE_CASES:
4742             #endif
4743 0           break;
4744             }
4745             }
4746 0           break;
4747              
4748             case OP_NOT_VSPACE:
4749 0 0         for (i = 1; i <= min; i++)
4750             {
4751 0 0         if (eptr >= md->end_subject)
4752             {
4753 0 0         SCHECK_PARTIAL();
    0          
    0          
4754 0           RRETURN(MATCH_NOMATCH);
4755             }
4756 0 0         switch(*eptr++)
4757             {
4758             VSPACE_BYTE_CASES:
4759             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4760             VSPACE_MULTIBYTE_CASES:
4761             #endif
4762 0           RRETURN(MATCH_NOMATCH);
4763 0           default: break;
4764             }
4765             }
4766 0           break;
4767              
4768             case OP_VSPACE:
4769 0 0         for (i = 1; i <= min; i++)
4770             {
4771 0 0         if (eptr >= md->end_subject)
4772             {
4773 0 0         SCHECK_PARTIAL();
    0          
    0          
4774 0           RRETURN(MATCH_NOMATCH);
4775             }
4776 0 0         switch(*eptr++)
4777             {
4778 0           default: RRETURN(MATCH_NOMATCH);
4779             VSPACE_BYTE_CASES:
4780             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4781             VSPACE_MULTIBYTE_CASES:
4782             #endif
4783 0           break;
4784             }
4785             }
4786 0           break;
4787              
4788             case OP_NOT_DIGIT:
4789 0 0         for (i = 1; i <= min; i++)
4790             {
4791 0 0         if (eptr >= md->end_subject)
4792             {
4793 0 0         SCHECK_PARTIAL();
    0          
    0          
4794 0           RRETURN(MATCH_NOMATCH);
4795             }
4796 0 0         if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0)
4797 0           RRETURN(MATCH_NOMATCH);
4798 0           eptr++;
4799             }
4800 0           break;
4801              
4802             case OP_DIGIT:
4803 0 0         for (i = 1; i <= min; i++)
4804             {
4805 0 0         if (eptr >= md->end_subject)
4806             {
4807 0 0         SCHECK_PARTIAL();
    0          
    0          
4808 0           RRETURN(MATCH_NOMATCH);
4809             }
4810 0 0         if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0)
4811 0           RRETURN(MATCH_NOMATCH);
4812 0           eptr++;
4813             }
4814 0           break;
4815              
4816             case OP_NOT_WHITESPACE:
4817 0 0         for (i = 1; i <= min; i++)
4818             {
4819 0 0         if (eptr >= md->end_subject)
4820             {
4821 0 0         SCHECK_PARTIAL();
    0          
    0          
4822 0           RRETURN(MATCH_NOMATCH);
4823             }
4824 0 0         if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0)
4825 0           RRETURN(MATCH_NOMATCH);
4826 0           eptr++;
4827             }
4828 0           break;
4829              
4830             case OP_WHITESPACE:
4831 0 0         for (i = 1; i <= min; i++)
4832             {
4833 0 0         if (eptr >= md->end_subject)
4834             {
4835 0 0         SCHECK_PARTIAL();
    0          
    0          
4836 0           RRETURN(MATCH_NOMATCH);
4837             }
4838 0 0         if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0)
4839 0           RRETURN(MATCH_NOMATCH);
4840 0           eptr++;
4841             }
4842 0           break;
4843              
4844             case OP_NOT_WORDCHAR:
4845 0 0         for (i = 1; i <= min; i++)
4846             {
4847 0 0         if (eptr >= md->end_subject)
4848             {
4849 0 0         SCHECK_PARTIAL();
    0          
    0          
4850 0           RRETURN(MATCH_NOMATCH);
4851             }
4852 0 0         if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0)
4853 0           RRETURN(MATCH_NOMATCH);
4854 0           eptr++;
4855             }
4856 0           break;
4857              
4858             case OP_WORDCHAR:
4859 0 0         for (i = 1; i <= min; i++)
4860             {
4861 0 0         if (eptr >= md->end_subject)
4862             {
4863 0 0         SCHECK_PARTIAL();
    0          
    0          
4864 0           RRETURN(MATCH_NOMATCH);
4865             }
4866 0 0         if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0)
4867 0           RRETURN(MATCH_NOMATCH);
4868 0           eptr++;
4869             }
4870 0           break;
4871              
4872             default:
4873 0           RRETURN(PCRE_ERROR_INTERNAL);
4874             }
4875             }
4876              
4877             /* If min = max, continue at the same level without recursing */
4878              
4879 14 50         if (min == max) continue;
4880              
4881             /* If minimizing, we have to test the rest of the pattern before each
4882             subsequent match. Again, separate the UTF-8 case for speed, and also
4883             separate the UCP cases. */
4884              
4885 14 50         if (minimize)
4886             {
4887             #ifdef SUPPORT_UCP
4888             if (prop_type >= 0)
4889             {
4890             switch(prop_type)
4891             {
4892             case PT_ANY:
4893             for (fi = min;; fi++)
4894             {
4895             RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);
4896             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4897             if (fi >= max) RRETURN(MATCH_NOMATCH);
4898             if (eptr >= md->end_subject)
4899             {
4900             SCHECK_PARTIAL();
4901             RRETURN(MATCH_NOMATCH);
4902             }
4903             GETCHARINCTEST(c, eptr);
4904             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4905             }
4906             /* Control never gets here */
4907              
4908             case PT_LAMP:
4909             for (fi = min;; fi++)
4910             {
4911             int chartype;
4912             RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
4913             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4914             if (fi >= max) RRETURN(MATCH_NOMATCH);
4915             if (eptr >= md->end_subject)
4916             {
4917             SCHECK_PARTIAL();
4918             RRETURN(MATCH_NOMATCH);
4919             }
4920             GETCHARINCTEST(c, eptr);
4921             chartype = UCD_CHARTYPE(c);
4922             if ((chartype == ucp_Lu ||
4923             chartype == ucp_Ll ||
4924             chartype == ucp_Lt) == prop_fail_result)
4925             RRETURN(MATCH_NOMATCH);
4926             }
4927             /* Control never gets here */
4928              
4929             case PT_GC:
4930             for (fi = min;; fi++)
4931             {
4932             RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);
4933             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4934             if (fi >= max) RRETURN(MATCH_NOMATCH);
4935             if (eptr >= md->end_subject)
4936             {
4937             SCHECK_PARTIAL();
4938             RRETURN(MATCH_NOMATCH);
4939             }
4940             GETCHARINCTEST(c, eptr);
4941             if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
4942             RRETURN(MATCH_NOMATCH);
4943             }
4944             /* Control never gets here */
4945              
4946             case PT_PC:
4947             for (fi = min;; fi++)
4948             {
4949             RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);
4950             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4951             if (fi >= max) RRETURN(MATCH_NOMATCH);
4952             if (eptr >= md->end_subject)
4953             {
4954             SCHECK_PARTIAL();
4955             RRETURN(MATCH_NOMATCH);
4956             }
4957             GETCHARINCTEST(c, eptr);
4958             if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
4959             RRETURN(MATCH_NOMATCH);
4960             }
4961             /* Control never gets here */
4962              
4963             case PT_SC:
4964             for (fi = min;; fi++)
4965             {
4966             RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);
4967             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4968             if (fi >= max) RRETURN(MATCH_NOMATCH);
4969             if (eptr >= md->end_subject)
4970             {
4971             SCHECK_PARTIAL();
4972             RRETURN(MATCH_NOMATCH);
4973             }
4974             GETCHARINCTEST(c, eptr);
4975             if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
4976             RRETURN(MATCH_NOMATCH);
4977             }
4978             /* Control never gets here */
4979              
4980             case PT_ALNUM:
4981             for (fi = min;; fi++)
4982             {
4983             int category;
4984             RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
4985             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4986             if (fi >= max) RRETURN(MATCH_NOMATCH);
4987             if (eptr >= md->end_subject)
4988             {
4989             SCHECK_PARTIAL();
4990             RRETURN(MATCH_NOMATCH);
4991             }
4992             GETCHARINCTEST(c, eptr);
4993             category = UCD_CATEGORY(c);
4994             if ((category == ucp_L || category == ucp_N) == prop_fail_result)
4995             RRETURN(MATCH_NOMATCH);
4996             }
4997             /* Control never gets here */
4998              
4999             /* Perl space used to exclude VT, but from Perl 5.18 it is included,
5000             which means that Perl space and POSIX space are now identical. PCRE
5001             was changed at release 8.34. */
5002              
5003             case PT_SPACE: /* Perl space */
5004             case PT_PXSPACE: /* POSIX space */
5005             for (fi = min;; fi++)
5006             {
5007             RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);
5008             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5009             if (fi >= max) RRETURN(MATCH_NOMATCH);
5010             if (eptr >= md->end_subject)
5011             {
5012             SCHECK_PARTIAL();
5013             RRETURN(MATCH_NOMATCH);
5014             }
5015             GETCHARINCTEST(c, eptr);
5016             switch(c)
5017             {
5018             HSPACE_CASES:
5019             VSPACE_CASES:
5020             if (prop_fail_result) RRETURN(MATCH_NOMATCH);
5021             break;
5022              
5023             default:
5024             if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5025             RRETURN(MATCH_NOMATCH);
5026             break;
5027             }
5028             }
5029             /* Control never gets here */
5030              
5031             case PT_WORD:
5032             for (fi = min;; fi++)
5033             {
5034             int category;
5035             RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
5036             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5037             if (fi >= max) RRETURN(MATCH_NOMATCH);
5038             if (eptr >= md->end_subject)
5039             {
5040             SCHECK_PARTIAL();
5041             RRETURN(MATCH_NOMATCH);
5042             }
5043             GETCHARINCTEST(c, eptr);
5044             category = UCD_CATEGORY(c);
5045             if ((category == ucp_L ||
5046             category == ucp_N ||
5047             c == CHAR_UNDERSCORE)
5048             == prop_fail_result)
5049             RRETURN(MATCH_NOMATCH);
5050             }
5051             /* Control never gets here */
5052              
5053             case PT_CLIST:
5054             for (fi = min;; fi++)
5055             {
5056             const pcre_uint32 *cp;
5057             RMATCH(eptr, ecode, offset_top, md, eptrb, RM67);
5058             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5059             if (fi >= max) RRETURN(MATCH_NOMATCH);
5060             if (eptr >= md->end_subject)
5061             {
5062             SCHECK_PARTIAL();
5063             RRETURN(MATCH_NOMATCH);
5064             }
5065             GETCHARINCTEST(c, eptr);
5066             cp = PRIV(ucd_caseless_sets) + prop_value;
5067             for (;;)
5068             {
5069             if (c < *cp)
5070             { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
5071             if (c == *cp++)
5072             { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
5073             }
5074             }
5075             /* Control never gets here */
5076              
5077             case PT_UCNC:
5078             for (fi = min;; fi++)
5079             {
5080             RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
5081             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5082             if (fi >= max) RRETURN(MATCH_NOMATCH);
5083             if (eptr >= md->end_subject)
5084             {
5085             SCHECK_PARTIAL();
5086             RRETURN(MATCH_NOMATCH);
5087             }
5088             GETCHARINCTEST(c, eptr);
5089             if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
5090             c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
5091             c >= 0xe000) == prop_fail_result)
5092             RRETURN(MATCH_NOMATCH);
5093             }
5094             /* Control never gets here */
5095              
5096             /* This should never occur */
5097             default:
5098             RRETURN(PCRE_ERROR_INTERNAL);
5099             }
5100             }
5101              
5102             /* Match extended Unicode sequences. We will get here only if the
5103             support is in the binary; otherwise a compile-time error occurs. */
5104              
5105             else if (ctype == OP_EXTUNI)
5106             {
5107             for (fi = min;; fi++)
5108             {
5109             RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);
5110             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5111             if (fi >= max) RRETURN(MATCH_NOMATCH);
5112             if (eptr >= md->end_subject)
5113             {
5114             SCHECK_PARTIAL();
5115             RRETURN(MATCH_NOMATCH);
5116             }
5117             else
5118             {
5119             int lgb, rgb;
5120             GETCHARINCTEST(c, eptr);
5121             lgb = UCD_GRAPHBREAK(c);
5122             while (eptr < md->end_subject)
5123             {
5124             int len = 1;
5125             if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5126             rgb = UCD_GRAPHBREAK(c);
5127             if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5128             lgb = rgb;
5129             eptr += len;
5130             }
5131             }
5132             CHECK_PARTIAL();
5133             }
5134             }
5135             else
5136             #endif /* SUPPORT_UCP */
5137              
5138             #ifdef SUPPORT_UTF
5139             if (utf)
5140             {
5141             for (fi = min;; fi++)
5142             {
5143             RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);
5144             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5145             if (fi >= max) RRETURN(MATCH_NOMATCH);
5146             if (eptr >= md->end_subject)
5147             {
5148             SCHECK_PARTIAL();
5149             RRETURN(MATCH_NOMATCH);
5150             }
5151             if (ctype == OP_ANY && IS_NEWLINE(eptr))
5152             RRETURN(MATCH_NOMATCH);
5153             GETCHARINC(c, eptr);
5154             switch(ctype)
5155             {
5156             case OP_ANY: /* This is the non-NL case */
5157             if (md->partial != 0 && /* Take care with CRLF partial */
5158             eptr >= md->end_subject &&
5159             NLBLOCK->nltype == NLTYPE_FIXED &&
5160             NLBLOCK->nllen == 2 &&
5161             c == NLBLOCK->nl[0])
5162             {
5163             md->hitend = TRUE;
5164             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5165             }
5166             break;
5167              
5168             case OP_ALLANY:
5169             case OP_ANYBYTE:
5170             break;
5171              
5172             case OP_ANYNL:
5173             switch(c)
5174             {
5175             default: RRETURN(MATCH_NOMATCH);
5176             case CHAR_CR:
5177             if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++;
5178             break;
5179              
5180             case CHAR_LF:
5181             break;
5182              
5183             case CHAR_VT:
5184             case CHAR_FF:
5185             case CHAR_NEL:
5186             #ifndef EBCDIC
5187             case 0x2028:
5188             case 0x2029:
5189             #endif /* Not EBCDIC */
5190             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5191             break;
5192             }
5193             break;
5194              
5195             case OP_NOT_HSPACE:
5196             switch(c)
5197             {
5198             HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5199             default: break;
5200             }
5201             break;
5202              
5203             case OP_HSPACE:
5204             switch(c)
5205             {
5206             HSPACE_CASES: break;
5207             default: RRETURN(MATCH_NOMATCH);
5208             }
5209             break;
5210              
5211             case OP_NOT_VSPACE:
5212             switch(c)
5213             {
5214             VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5215             default: break;
5216             }
5217             break;
5218              
5219             case OP_VSPACE:
5220             switch(c)
5221             {
5222             VSPACE_CASES: break;
5223             default: RRETURN(MATCH_NOMATCH);
5224             }
5225             break;
5226              
5227             case OP_NOT_DIGIT:
5228             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
5229             RRETURN(MATCH_NOMATCH);
5230             break;
5231              
5232             case OP_DIGIT:
5233             if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
5234             RRETURN(MATCH_NOMATCH);
5235             break;
5236              
5237             case OP_NOT_WHITESPACE:
5238             if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
5239             RRETURN(MATCH_NOMATCH);
5240             break;
5241              
5242             case OP_WHITESPACE:
5243             if (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
5244             RRETURN(MATCH_NOMATCH);
5245             break;
5246              
5247             case OP_NOT_WORDCHAR:
5248             if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
5249             RRETURN(MATCH_NOMATCH);
5250             break;
5251              
5252             case OP_WORDCHAR:
5253             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
5254             RRETURN(MATCH_NOMATCH);
5255             break;
5256              
5257             default:
5258             RRETURN(PCRE_ERROR_INTERNAL);
5259             }
5260             }
5261             }
5262             else
5263             #endif
5264             /* Not UTF mode */
5265             {
5266 0           for (fi = min;; fi++)
5267             {
5268 0           RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);
5269 0 0         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5270 0 0         if (fi >= max) RRETURN(MATCH_NOMATCH);
5271 0 0         if (eptr >= md->end_subject)
5272             {
5273 0 0         SCHECK_PARTIAL();
    0          
    0          
5274 0           RRETURN(MATCH_NOMATCH);
5275             }
5276 0 0         if (ctype == OP_ANY && IS_NEWLINE(eptr))
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
5277 0           RRETURN(MATCH_NOMATCH);
5278 0           c = *eptr++;
5279 0           switch(ctype)
5280             {
5281             case OP_ANY: /* This is the non-NL case */
5282 0 0         if (md->partial != 0 && /* Take care with CRLF partial */
    0          
5283 0 0         eptr >= md->end_subject &&
5284 0 0         NLBLOCK->nltype == NLTYPE_FIXED &&
5285 0 0         NLBLOCK->nllen == 2 &&
5286 0           c == NLBLOCK->nl[0])
5287             {
5288 0           md->hitend = TRUE;
5289 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5290             }
5291 0           break;
5292              
5293             case OP_ALLANY:
5294             case OP_ANYBYTE:
5295 0           break;
5296              
5297             case OP_ANYNL:
5298 0           switch(c)
5299             {
5300 0           default: RRETURN(MATCH_NOMATCH);
5301             case CHAR_CR:
5302 0 0         if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
    0          
5303 0           break;
5304              
5305             case CHAR_LF:
5306 0           break;
5307              
5308             case CHAR_VT:
5309             case CHAR_FF:
5310             case CHAR_NEL:
5311             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5312             case 0x2028:
5313             case 0x2029:
5314             #endif
5315 0 0         if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5316 0           break;
5317             }
5318 0           break;
5319              
5320             case OP_NOT_HSPACE:
5321 0 0         switch(c)
5322             {
5323 0           default: break;
5324             HSPACE_BYTE_CASES:
5325             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5326             HSPACE_MULTIBYTE_CASES:
5327             #endif
5328 0           RRETURN(MATCH_NOMATCH);
5329             }
5330 0           break;
5331              
5332             case OP_HSPACE:
5333 0 0         switch(c)
5334             {
5335 0           default: RRETURN(MATCH_NOMATCH);
5336             HSPACE_BYTE_CASES:
5337             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5338             HSPACE_MULTIBYTE_CASES:
5339             #endif
5340 0           break;
5341             }
5342 0           break;
5343              
5344             case OP_NOT_VSPACE:
5345 0 0         switch(c)
5346             {
5347 0           default: break;
5348             VSPACE_BYTE_CASES:
5349             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5350             VSPACE_MULTIBYTE_CASES:
5351             #endif
5352 0           RRETURN(MATCH_NOMATCH);
5353             }
5354 0           break;
5355              
5356             case OP_VSPACE:
5357 0 0         switch(c)
5358             {
5359 0           default: RRETURN(MATCH_NOMATCH);
5360             VSPACE_BYTE_CASES:
5361             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5362             VSPACE_MULTIBYTE_CASES:
5363             #endif
5364 0           break;
5365             }
5366 0           break;
5367              
5368             case OP_NOT_DIGIT:
5369 0 0         if (MAX_255(c) && (md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
5370 0           break;
5371              
5372             case OP_DIGIT:
5373 0 0         if (!MAX_255(c) || (md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
5374 0           break;
5375              
5376             case OP_NOT_WHITESPACE:
5377 0 0         if (MAX_255(c) && (md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
5378 0           break;
5379              
5380             case OP_WHITESPACE:
5381 0 0         if (!MAX_255(c) || (md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
5382 0           break;
5383              
5384             case OP_NOT_WORDCHAR:
5385 0 0         if (MAX_255(c) && (md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
5386 0           break;
5387              
5388             case OP_WORDCHAR:
5389 0 0         if (!MAX_255(c) || (md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
5390 0           break;
5391              
5392             default:
5393 0           RRETURN(PCRE_ERROR_INTERNAL);
5394             }
5395 0           }
5396             }
5397             /* Control never gets here */
5398             }
5399              
5400             /* If maximizing, it is worth using inline code for speed, doing the type
5401             test once at the start (i.e. keep it out of the loop). Again, keep the
5402             UTF-8 and UCP stuff separate. */
5403              
5404             else
5405             {
5406 14           pp = eptr; /* Remember where we started */
5407              
5408             #ifdef SUPPORT_UCP
5409             if (prop_type >= 0)
5410             {
5411             switch(prop_type)
5412             {
5413             case PT_ANY:
5414             for (i = min; i < max; i++)
5415             {
5416             int len = 1;
5417             if (eptr >= md->end_subject)
5418             {
5419             SCHECK_PARTIAL();
5420             break;
5421             }
5422             GETCHARLENTEST(c, eptr, len);
5423             if (prop_fail_result) break;
5424             eptr+= len;
5425             }
5426             break;
5427              
5428             case PT_LAMP:
5429             for (i = min; i < max; i++)
5430             {
5431             int chartype;
5432             int len = 1;
5433             if (eptr >= md->end_subject)
5434             {
5435             SCHECK_PARTIAL();
5436             break;
5437             }
5438             GETCHARLENTEST(c, eptr, len);
5439             chartype = UCD_CHARTYPE(c);
5440             if ((chartype == ucp_Lu ||
5441             chartype == ucp_Ll ||
5442             chartype == ucp_Lt) == prop_fail_result)
5443             break;
5444             eptr+= len;
5445             }
5446             break;
5447              
5448             case PT_GC:
5449             for (i = min; i < max; i++)
5450             {
5451             int len = 1;
5452             if (eptr >= md->end_subject)
5453             {
5454             SCHECK_PARTIAL();
5455             break;
5456             }
5457             GETCHARLENTEST(c, eptr, len);
5458             if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result) break;
5459             eptr+= len;
5460             }
5461             break;
5462              
5463             case PT_PC:
5464             for (i = min; i < max; i++)
5465             {
5466             int len = 1;
5467             if (eptr >= md->end_subject)
5468             {
5469             SCHECK_PARTIAL();
5470             break;
5471             }
5472             GETCHARLENTEST(c, eptr, len);
5473             if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result) break;
5474             eptr+= len;
5475             }
5476             break;
5477              
5478             case PT_SC:
5479             for (i = min; i < max; i++)
5480             {
5481             int len = 1;
5482             if (eptr >= md->end_subject)
5483             {
5484             SCHECK_PARTIAL();
5485             break;
5486             }
5487             GETCHARLENTEST(c, eptr, len);
5488             if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result) break;
5489             eptr+= len;
5490             }
5491             break;
5492              
5493             case PT_ALNUM:
5494             for (i = min; i < max; i++)
5495             {
5496             int category;
5497             int len = 1;
5498             if (eptr >= md->end_subject)
5499             {
5500             SCHECK_PARTIAL();
5501             break;
5502             }
5503             GETCHARLENTEST(c, eptr, len);
5504             category = UCD_CATEGORY(c);
5505             if ((category == ucp_L || category == ucp_N) == prop_fail_result)
5506             break;
5507             eptr+= len;
5508             }
5509             break;
5510              
5511             /* Perl space used to exclude VT, but from Perl 5.18 it is included,
5512             which means that Perl space and POSIX space are now identical. PCRE
5513             was changed at release 8.34. */
5514              
5515             case PT_SPACE: /* Perl space */
5516             case PT_PXSPACE: /* POSIX space */
5517             for (i = min; i < max; i++)
5518             {
5519             int len = 1;
5520             if (eptr >= md->end_subject)
5521             {
5522             SCHECK_PARTIAL();
5523             break;
5524             }
5525             GETCHARLENTEST(c, eptr, len);
5526             switch(c)
5527             {
5528             HSPACE_CASES:
5529             VSPACE_CASES:
5530             if (prop_fail_result) goto ENDLOOP99; /* Break the loop */
5531             break;
5532              
5533             default:
5534             if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5535             goto ENDLOOP99; /* Break the loop */
5536             break;
5537             }
5538             eptr+= len;
5539             }
5540             ENDLOOP99:
5541             break;
5542              
5543             case PT_WORD:
5544             for (i = min; i < max; i++)
5545             {
5546             int category;
5547             int len = 1;
5548             if (eptr >= md->end_subject)
5549             {
5550             SCHECK_PARTIAL();
5551             break;
5552             }
5553             GETCHARLENTEST(c, eptr, len);
5554             category = UCD_CATEGORY(c);
5555             if ((category == ucp_L || category == ucp_N ||
5556             c == CHAR_UNDERSCORE) == prop_fail_result)
5557             break;
5558             eptr+= len;
5559             }
5560             break;
5561              
5562             case PT_CLIST:
5563             for (i = min; i < max; i++)
5564             {
5565             const pcre_uint32 *cp;
5566             int len = 1;
5567             if (eptr >= md->end_subject)
5568             {
5569             SCHECK_PARTIAL();
5570             break;
5571             }
5572             GETCHARLENTEST(c, eptr, len);
5573             cp = PRIV(ucd_caseless_sets) + prop_value;
5574             for (;;)
5575             {
5576             if (c < *cp)
5577             { if (prop_fail_result) break; else goto GOT_MAX; }
5578             if (c == *cp++)
5579             { if (prop_fail_result) goto GOT_MAX; else break; }
5580             }
5581             eptr += len;
5582             }
5583             GOT_MAX:
5584             break;
5585              
5586             case PT_UCNC:
5587             for (i = min; i < max; i++)
5588             {
5589             int len = 1;
5590             if (eptr >= md->end_subject)
5591             {
5592             SCHECK_PARTIAL();
5593             break;
5594             }
5595             GETCHARLENTEST(c, eptr, len);
5596             if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
5597             c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
5598             c >= 0xe000) == prop_fail_result)
5599             break;
5600             eptr += len;
5601             }
5602             break;
5603              
5604             default:
5605             RRETURN(PCRE_ERROR_INTERNAL);
5606             }
5607              
5608             /* eptr is now past the end of the maximum run */
5609              
5610             if (possessive) continue; /* No backtracking */
5611             for(;;)
5612             {
5613             if (eptr <= pp) goto TAIL_RECURSE;
5614             RMATCH(eptr, ecode, offset_top, md, eptrb, RM44);
5615             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5616             eptr--;
5617             if (utf) BACKCHAR(eptr);
5618             }
5619             }
5620              
5621             /* Match extended Unicode grapheme clusters. We will get here only if the
5622             support is in the binary; otherwise a compile-time error occurs. */
5623              
5624             else if (ctype == OP_EXTUNI)
5625             {
5626             for (i = min; i < max; i++)
5627             {
5628             if (eptr >= md->end_subject)
5629             {
5630             SCHECK_PARTIAL();
5631             break;
5632             }
5633             else
5634             {
5635             int lgb, rgb;
5636             GETCHARINCTEST(c, eptr);
5637             lgb = UCD_GRAPHBREAK(c);
5638             while (eptr < md->end_subject)
5639             {
5640             int len = 1;
5641             if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5642             rgb = UCD_GRAPHBREAK(c);
5643             if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5644             lgb = rgb;
5645             eptr += len;
5646             }
5647             }
5648             CHECK_PARTIAL();
5649             }
5650              
5651             /* eptr is now past the end of the maximum run */
5652              
5653             if (possessive) continue; /* No backtracking */
5654              
5655             /* We use <= pp rather than == pp to detect the start of the run while
5656             backtracking because the use of \C in UTF mode can cause BACKCHAR to
5657             move back past pp. This is just palliative; the use of \C in UTF mode
5658             is fraught with danger. */
5659              
5660             for(;;)
5661             {
5662             int lgb, rgb;
5663             PCRE_PUCHAR fptr;
5664              
5665             if (eptr <= pp) goto TAIL_RECURSE; /* At start of char run */
5666             RMATCH(eptr, ecode, offset_top, md, eptrb, RM45);
5667             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5668              
5669             /* Backtracking over an extended grapheme cluster involves inspecting
5670             the previous two characters (if present) to see if a break is
5671             permitted between them. */
5672              
5673             eptr--;
5674             if (!utf) c = *eptr; else
5675             {
5676             BACKCHAR(eptr);
5677             GETCHAR(c, eptr);
5678             }
5679             rgb = UCD_GRAPHBREAK(c);
5680              
5681             for (;;)
5682             {
5683             if (eptr <= pp) goto TAIL_RECURSE; /* At start of char run */
5684             fptr = eptr - 1;
5685             if (!utf) c = *fptr; else
5686             {
5687             BACKCHAR(fptr);
5688             GETCHAR(c, fptr);
5689             }
5690             lgb = UCD_GRAPHBREAK(c);
5691             if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5692             eptr = fptr;
5693             rgb = lgb;
5694             }
5695             }
5696             }
5697              
5698             else
5699             #endif /* SUPPORT_UCP */
5700              
5701             #ifdef SUPPORT_UTF
5702             if (utf)
5703             {
5704             switch(ctype)
5705             {
5706             case OP_ANY:
5707             for (i = min; i < max; i++)
5708             {
5709             if (eptr >= md->end_subject)
5710             {
5711             SCHECK_PARTIAL();
5712             break;
5713             }
5714             if (IS_NEWLINE(eptr)) break;
5715             if (md->partial != 0 && /* Take care with CRLF partial */
5716             eptr + 1 >= md->end_subject &&
5717             NLBLOCK->nltype == NLTYPE_FIXED &&
5718             NLBLOCK->nllen == 2 &&
5719             UCHAR21(eptr) == NLBLOCK->nl[0])
5720             {
5721             md->hitend = TRUE;
5722             if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5723             }
5724             eptr++;
5725             ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5726             }
5727             break;
5728              
5729             case OP_ALLANY:
5730             if (max < INT_MAX)
5731             {
5732             for (i = min; i < max; i++)
5733             {
5734             if (eptr >= md->end_subject)
5735             {
5736             SCHECK_PARTIAL();
5737             break;
5738             }
5739             eptr++;
5740             ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5741             }
5742             }
5743             else
5744             {
5745             eptr = md->end_subject; /* Unlimited UTF-8 repeat */
5746             SCHECK_PARTIAL();
5747             }
5748             break;
5749              
5750             /* The byte case is the same as non-UTF8 */
5751              
5752             case OP_ANYBYTE:
5753             c = max - min;
5754             if (c > (unsigned int)(md->end_subject - eptr))
5755             {
5756             eptr = md->end_subject;
5757             SCHECK_PARTIAL();
5758             }
5759             else eptr += c;
5760             break;
5761              
5762             case OP_ANYNL:
5763             for (i = min; i < max; i++)
5764             {
5765             int len = 1;
5766             if (eptr >= md->end_subject)
5767             {
5768             SCHECK_PARTIAL();
5769             break;
5770             }
5771             GETCHARLEN(c, eptr, len);
5772             if (c == CHAR_CR)
5773             {
5774             if (++eptr >= md->end_subject) break;
5775             if (UCHAR21(eptr) == CHAR_LF) eptr++;
5776             }
5777             else
5778             {
5779             if (c != CHAR_LF &&
5780             (md->bsr_anycrlf ||
5781             (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5782             #ifndef EBCDIC
5783             && c != 0x2028 && c != 0x2029
5784             #endif /* Not EBCDIC */
5785             )))
5786             break;
5787             eptr += len;
5788             }
5789             }
5790             break;
5791              
5792             case OP_NOT_HSPACE:
5793             case OP_HSPACE:
5794             for (i = min; i < max; i++)
5795             {
5796             BOOL gotspace;
5797             int len = 1;
5798             if (eptr >= md->end_subject)
5799             {
5800             SCHECK_PARTIAL();
5801             break;
5802             }
5803             GETCHARLEN(c, eptr, len);
5804             switch(c)
5805             {
5806             HSPACE_CASES: gotspace = TRUE; break;
5807             default: gotspace = FALSE; break;
5808             }
5809             if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5810             eptr += len;
5811             }
5812             break;
5813              
5814             case OP_NOT_VSPACE:
5815             case OP_VSPACE:
5816             for (i = min; i < max; i++)
5817             {
5818             BOOL gotspace;
5819             int len = 1;
5820             if (eptr >= md->end_subject)
5821             {
5822             SCHECK_PARTIAL();
5823             break;
5824             }
5825             GETCHARLEN(c, eptr, len);
5826             switch(c)
5827             {
5828             VSPACE_CASES: gotspace = TRUE; break;
5829             default: gotspace = FALSE; break;
5830             }
5831             if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5832             eptr += len;
5833             }
5834             break;
5835              
5836             case OP_NOT_DIGIT:
5837             for (i = min; i < max; i++)
5838             {
5839             int len = 1;
5840             if (eptr >= md->end_subject)
5841             {
5842             SCHECK_PARTIAL();
5843             break;
5844             }
5845             GETCHARLEN(c, eptr, len);
5846             if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
5847             eptr+= len;
5848             }
5849             break;
5850              
5851             case OP_DIGIT:
5852             for (i = min; i < max; i++)
5853             {
5854             int len = 1;
5855             if (eptr >= md->end_subject)
5856             {
5857             SCHECK_PARTIAL();
5858             break;
5859             }
5860             GETCHARLEN(c, eptr, len);
5861             if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
5862             eptr+= len;
5863             }
5864             break;
5865              
5866             case OP_NOT_WHITESPACE:
5867             for (i = min; i < max; i++)
5868             {
5869             int len = 1;
5870             if (eptr >= md->end_subject)
5871             {
5872             SCHECK_PARTIAL();
5873             break;
5874             }
5875             GETCHARLEN(c, eptr, len);
5876             if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
5877             eptr+= len;
5878             }
5879             break;
5880              
5881             case OP_WHITESPACE:
5882             for (i = min; i < max; i++)
5883             {
5884             int len = 1;
5885             if (eptr >= md->end_subject)
5886             {
5887             SCHECK_PARTIAL();
5888             break;
5889             }
5890             GETCHARLEN(c, eptr, len);
5891             if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
5892             eptr+= len;
5893             }
5894             break;
5895              
5896             case OP_NOT_WORDCHAR:
5897             for (i = min; i < max; i++)
5898             {
5899             int len = 1;
5900             if (eptr >= md->end_subject)
5901             {
5902             SCHECK_PARTIAL();
5903             break;
5904             }
5905             GETCHARLEN(c, eptr, len);
5906             if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
5907             eptr+= len;
5908             }
5909             break;
5910              
5911             case OP_WORDCHAR:
5912             for (i = min; i < max; i++)
5913             {
5914             int len = 1;
5915             if (eptr >= md->end_subject)
5916             {
5917             SCHECK_PARTIAL();
5918             break;
5919             }
5920             GETCHARLEN(c, eptr, len);
5921             if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
5922             eptr+= len;
5923             }
5924             break;
5925              
5926             default:
5927             RRETURN(PCRE_ERROR_INTERNAL);
5928             }
5929              
5930             if (possessive) continue; /* No backtracking */
5931             for(;;)
5932             {
5933             if (eptr <= pp) goto TAIL_RECURSE;
5934             RMATCH(eptr, ecode, offset_top, md, eptrb, RM46);
5935             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5936             eptr--;
5937             BACKCHAR(eptr);
5938             if (ctype == OP_ANYNL && eptr > pp && UCHAR21(eptr) == CHAR_NL &&
5939             UCHAR21(eptr - 1) == CHAR_CR) eptr--;
5940             }
5941             }
5942             else
5943             #endif /* SUPPORT_UTF */
5944             /* Not UTF mode */
5945             {
5946 14           switch(ctype)
5947             {
5948             case OP_ANY:
5949 155 50         for (i = min; i < max; i++)
5950             {
5951 155 100         if (eptr >= md->end_subject)
5952             {
5953 14 50         SCHECK_PARTIAL();
    0          
    0          
5954 14           break;
5955             }
5956 141 50         if (IS_NEWLINE(eptr)) break;
    50          
    50          
    0          
    0          
    0          
    0          
    50          
5957 141 50         if (md->partial != 0 && /* Take care with CRLF partial */
    0          
5958 0 0         eptr + 1 >= md->end_subject &&
5959 0 0         NLBLOCK->nltype == NLTYPE_FIXED &&
5960 0 0         NLBLOCK->nllen == 2 &&
5961 0           *eptr == NLBLOCK->nl[0])
5962             {
5963 0           md->hitend = TRUE;
5964 0 0         if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5965             }
5966 141           eptr++;
5967             }
5968 14           break;
5969              
5970             case OP_ALLANY:
5971             case OP_ANYBYTE:
5972 0           c = max - min;
5973 0 0         if (c > (unsigned int)(md->end_subject - eptr))
5974             {
5975 0           eptr = md->end_subject;
5976 0 0         SCHECK_PARTIAL();
    0          
    0          
5977             }
5978 0           else eptr += c;
5979 0           break;
5980              
5981             case OP_ANYNL:
5982 0 0         for (i = min; i < max; i++)
5983             {
5984 0 0         if (eptr >= md->end_subject)
5985             {
5986 0 0         SCHECK_PARTIAL();
    0          
    0          
5987 0           break;
5988             }
5989 0           c = *eptr;
5990 0 0         if (c == CHAR_CR)
5991             {
5992 0 0         if (++eptr >= md->end_subject) break;
5993 0 0         if (*eptr == CHAR_LF) eptr++;
5994             }
5995             else
5996             {
5997 0 0         if (c != CHAR_LF && (md->bsr_anycrlf ||
    0          
    0          
5998 0 0         (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
    0          
5999             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6000             && c != 0x2028 && c != 0x2029
6001             #endif
6002             ))) break;
6003 0           eptr++;
6004             }
6005             }
6006 0           break;
6007              
6008             case OP_NOT_HSPACE:
6009 0 0         for (i = min; i < max; i++)
6010             {
6011 0 0         if (eptr >= md->end_subject)
6012             {
6013 0 0         SCHECK_PARTIAL();
    0          
    0          
6014 0           break;
6015             }
6016 0 0         switch(*eptr)
6017             {
6018 0           default: eptr++; break;
6019             HSPACE_BYTE_CASES:
6020             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6021             HSPACE_MULTIBYTE_CASES:
6022             #endif
6023 0           goto ENDLOOP00;
6024             }
6025             }
6026             ENDLOOP00:
6027 0           break;
6028              
6029             case OP_HSPACE:
6030 0 0         for (i = min; i < max; i++)
6031             {
6032 0 0         if (eptr >= md->end_subject)
6033             {
6034 0 0         SCHECK_PARTIAL();
    0          
    0          
6035 0           break;
6036             }
6037 0 0         switch(*eptr)
6038             {
6039 0           default: goto ENDLOOP01;
6040             HSPACE_BYTE_CASES:
6041             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6042             HSPACE_MULTIBYTE_CASES:
6043             #endif
6044 0           eptr++; break;
6045             }
6046             }
6047             ENDLOOP01:
6048 0           break;
6049              
6050             case OP_NOT_VSPACE:
6051 0 0         for (i = min; i < max; i++)
6052             {
6053 0 0         if (eptr >= md->end_subject)
6054             {
6055 0 0         SCHECK_PARTIAL();
    0          
    0          
6056 0           break;
6057             }
6058 0 0         switch(*eptr)
6059             {
6060 0           default: eptr++; break;
6061             VSPACE_BYTE_CASES:
6062             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6063             VSPACE_MULTIBYTE_CASES:
6064             #endif
6065 0           goto ENDLOOP02;
6066             }
6067             }
6068             ENDLOOP02:
6069 0           break;
6070              
6071             case OP_VSPACE:
6072 0 0         for (i = min; i < max; i++)
6073             {
6074 0 0         if (eptr >= md->end_subject)
6075             {
6076 0 0         SCHECK_PARTIAL();
    0          
    0          
6077 0           break;
6078             }
6079 0 0         switch(*eptr)
6080             {
6081 0           default: goto ENDLOOP03;
6082             VSPACE_BYTE_CASES:
6083             #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6084             VSPACE_MULTIBYTE_CASES:
6085             #endif
6086 0           eptr++; break;
6087             }
6088             }
6089             ENDLOOP03:
6090 0           break;
6091              
6092             case OP_NOT_DIGIT:
6093 0 0         for (i = min; i < max; i++)
6094             {
6095 0 0         if (eptr >= md->end_subject)
6096             {
6097 0 0         SCHECK_PARTIAL();
    0          
    0          
6098 0           break;
6099             }
6100 0 0         if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0) break;
6101 0           eptr++;
6102             }
6103 0           break;
6104              
6105             case OP_DIGIT:
6106 0 0         for (i = min; i < max; i++)
6107             {
6108 0 0         if (eptr >= md->end_subject)
6109             {
6110 0 0         SCHECK_PARTIAL();
    0          
    0          
6111 0           break;
6112             }
6113 0 0         if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0) break;
6114 0           eptr++;
6115             }
6116 0           break;
6117              
6118             case OP_NOT_WHITESPACE:
6119 0 0         for (i = min; i < max; i++)
6120             {
6121 0 0         if (eptr >= md->end_subject)
6122             {
6123 0 0         SCHECK_PARTIAL();
    0          
    0          
6124 0           break;
6125             }
6126 0 0         if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0) break;
6127 0           eptr++;
6128             }
6129 0           break;
6130              
6131             case OP_WHITESPACE:
6132 0 0         for (i = min; i < max; i++)
6133             {
6134 0 0         if (eptr >= md->end_subject)
6135             {
6136 0 0         SCHECK_PARTIAL();
    0          
    0          
6137 0           break;
6138             }
6139 0 0         if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0) break;
6140 0           eptr++;
6141             }
6142 0           break;
6143              
6144             case OP_NOT_WORDCHAR:
6145 0 0         for (i = min; i < max; i++)
6146             {
6147 0 0         if (eptr >= md->end_subject)
6148             {
6149 0 0         SCHECK_PARTIAL();
    0          
    0          
6150 0           break;
6151             }
6152 0 0         if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0) break;
6153 0           eptr++;
6154             }
6155 0           break;
6156              
6157             case OP_WORDCHAR:
6158 0 0         for (i = min; i < max; i++)
6159             {
6160 0 0         if (eptr >= md->end_subject)
6161             {
6162 0 0         SCHECK_PARTIAL();
    0          
    0          
6163 0           break;
6164             }
6165 0 0         if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0) break;
6166 0           eptr++;
6167             }
6168 0           break;
6169              
6170             default:
6171 0           RRETURN(PCRE_ERROR_INTERNAL);
6172             }
6173              
6174 14 100         if (possessive) continue; /* No backtracking */
6175             for (;;)
6176             {
6177 62 50         if (eptr == pp) goto TAIL_RECURSE;
6178 62           RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6179 62 100         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6180 52           eptr--;
6181 52 50         if (ctype == OP_ANYNL && eptr > pp && *eptr == CHAR_LF &&
    0          
    0          
    0          
6182 0           eptr[-1] == CHAR_CR) eptr--;
6183 52           }
6184             }
6185              
6186             /* Control never gets here */
6187             }
6188              
6189             /* There's been some horrible disaster. Arrival here can only mean there is
6190             something seriously wrong in the code above or the OP_xxx definitions. */
6191              
6192             default:
6193             DPRINTF(("Unknown opcode %d\n", *ecode));
6194 0           RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
6195             }
6196              
6197             /* Do not stick any code in here without much thought; it is assumed
6198             that "continue" in the code above comes out to here to repeat the main
6199             loop. */
6200              
6201 516           } /* End of main loop */
6202             /* Control never reaches here */
6203              
6204              
6205             /* When compiling to use the heap rather than the stack for recursive calls to
6206             match(), the RRETURN() macro jumps here. The number that is saved in
6207             frame->Xwhere indicates which label we actually want to return to. */
6208              
6209             #ifdef NO_RECURSE
6210             #define LBL(val) case val: goto L_RM##val;
6211             HEAP_RETURN:
6212             switch (frame->Xwhere)
6213             {
6214             LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
6215             LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
6216             LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
6217             LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
6218             LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)
6219             LBL(65) LBL(66)
6220             #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
6221             LBL(20) LBL(21)
6222             #endif
6223             #ifdef SUPPORT_UTF
6224             LBL(16) LBL(18)
6225             LBL(22) LBL(23) LBL(28) LBL(30)
6226             LBL(32) LBL(34) LBL(42) LBL(46)
6227             #ifdef SUPPORT_UCP
6228             LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
6229             LBL(59) LBL(60) LBL(61) LBL(62) LBL(67)
6230             #endif /* SUPPORT_UCP */
6231             #endif /* SUPPORT_UTF */
6232             default:
6233             DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
6234             return PCRE_ERROR_INTERNAL;
6235             }
6236             #undef LBL
6237             #endif /* NO_RECURSE */
6238             }
6239              
6240              
6241             /***************************************************************************
6242             ****************************************************************************
6243             RECURSION IN THE match() FUNCTION
6244              
6245             Undefine all the macros that were defined above to handle this. */
6246              
6247             #ifdef NO_RECURSE
6248             #undef eptr
6249             #undef ecode
6250             #undef mstart
6251             #undef offset_top
6252             #undef eptrb
6253             #undef flags
6254              
6255             #undef callpat
6256             #undef charptr
6257             #undef data
6258             #undef next
6259             #undef pp
6260             #undef prev
6261             #undef saved_eptr
6262              
6263             #undef new_recursive
6264              
6265             #undef cur_is_word
6266             #undef condition
6267             #undef prev_is_word
6268              
6269             #undef ctype
6270             #undef length
6271             #undef max
6272             #undef min
6273             #undef number
6274             #undef offset
6275             #undef op
6276             #undef save_capture_last
6277             #undef save_offset1
6278             #undef save_offset2
6279             #undef save_offset3
6280             #undef stacksave
6281              
6282             #undef newptrb
6283              
6284             #endif
6285              
6286             /* These two are defined as macros in both cases */
6287              
6288             #undef fc
6289             #undef fi
6290              
6291             /***************************************************************************
6292             ***************************************************************************/
6293              
6294              
6295             #ifdef NO_RECURSE
6296             /*************************************************
6297             * Release allocated heap frames *
6298             *************************************************/
6299              
6300             /* This function releases all the allocated frames. The base frame is on the
6301             machine stack, and so must not be freed.
6302              
6303             Argument: the address of the base frame
6304             Returns: nothing
6305             */
6306              
6307             static void
6308             release_match_heapframes (heapframe *frame_base)
6309             {
6310             heapframe *nextframe = frame_base->Xnextframe;
6311             while (nextframe != NULL)
6312             {
6313             heapframe *oldframe = nextframe;
6314             nextframe = nextframe->Xnextframe;
6315             (PUBL(stack_free))(oldframe);
6316             }
6317             }
6318             #endif
6319              
6320              
6321             /*************************************************
6322             * Execute a Regular Expression *
6323             *************************************************/
6324              
6325             /* This function applies a compiled re to a subject string and picks out
6326             portions of the string if it matches. Two elements in the vector are set for
6327             each substring: the offsets to the start and end of the substring.
6328              
6329             Arguments:
6330             argument_re points to the compiled expression
6331             extra_data points to extra data or is NULL
6332             subject points to the subject string
6333             length length of subject string (may contain binary zeros)
6334             start_offset where to start in the subject string
6335             options option bits
6336             offsets points to a vector of ints to be filled in with offsets
6337             offsetcount the number of elements in the vector
6338              
6339             Returns: > 0 => success; value is the number of elements filled in
6340             = 0 => success, but offsets is not big enough
6341             -1 => failed to match
6342             < -1 => some kind of unexpected problem
6343             */
6344              
6345             #if defined COMPILE_PCRE8
6346             PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6347 454           pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
6348             PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
6349             int offsetcount)
6350             #elif defined COMPILE_PCRE16
6351             PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6352             pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
6353             PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
6354             int offsetcount)
6355             #elif defined COMPILE_PCRE32
6356             PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6357             pcre32_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
6358             PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
6359             int offsetcount)
6360             #endif
6361             {
6362             int rc, ocount, arg_offset_max;
6363             int newline;
6364 454           BOOL using_temporary_offsets = FALSE;
6365             BOOL anchored;
6366             BOOL startline;
6367             BOOL firstline;
6368             BOOL utf;
6369 454           BOOL has_first_char = FALSE;
6370 454           BOOL has_req_char = FALSE;
6371 454           pcre_uchar first_char = 0;
6372 454           pcre_uchar first_char2 = 0;
6373 454           pcre_uchar req_char = 0;
6374 454           pcre_uchar req_char2 = 0;
6375             match_data match_block;
6376 454           match_data *md = &match_block;
6377             const pcre_uint8 *tables;
6378 454           const pcre_uint8 *start_bits = NULL;
6379 454           PCRE_PUCHAR start_match = (PCRE_PUCHAR)subject + start_offset;
6380             PCRE_PUCHAR end_subject;
6381 454           PCRE_PUCHAR start_partial = NULL;
6382 454           PCRE_PUCHAR match_partial = NULL;
6383 454           PCRE_PUCHAR req_char_ptr = start_match - 1;
6384              
6385             const pcre_study_data *study;
6386 454           const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6387              
6388             #ifdef NO_RECURSE
6389             heapframe frame_zero;
6390             frame_zero.Xprevframe = NULL; /* Marks the top level */
6391             frame_zero.Xnextframe = NULL; /* None are allocated yet */
6392             md->match_frames_base = &frame_zero;
6393             #endif
6394              
6395             /* Check for the special magic call that measures the size of the stack used
6396             per recursive call of match(). Without the funny casting for sizeof, a Windows
6397             compiler gave this error: "unary minus operator applied to unsigned type,
6398             result still unsigned". Hopefully the cast fixes that. */
6399              
6400 454 50         if (re == NULL && extra_data == NULL && subject == NULL && length == -999 &&
    0          
    0          
    0          
    0          
6401             start_offset == -999)
6402             #ifdef NO_RECURSE
6403             return -((int)sizeof(heapframe));
6404             #else
6405 0           return match(NULL, NULL, NULL, 0, NULL, NULL, 0);
6406             #endif
6407              
6408             /* Plausibility checks */
6409              
6410 454 50         if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
6411 454 50         if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
    50          
    50          
    50          
6412 0           return PCRE_ERROR_NULL;
6413 454 50         if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
6414 454 50         if (length < 0) return PCRE_ERROR_BADLENGTH;
6415 454 50         if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
    50          
6416              
6417             /* Check that the first field in the block is the magic number. If it is not,
6418             return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
6419             REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
6420             means that the pattern is likely compiled with different endianness. */
6421              
6422 454 50         if (re->magic_number != MAGIC_NUMBER)
6423 0           return re->magic_number == REVERSED_MAGIC_NUMBER?
6424 0 0         PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
6425 454 50         if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
6426              
6427             /* These two settings are used in the code for checking a UTF-8 string that
6428             follows immediately afterwards. Other values in the md block are used only
6429             during "normal" pcre_exec() processing, not when the JIT support is in use,
6430             so they are set up later. */
6431              
6432             /* PCRE_UTF16 has the same value as PCRE_UTF8. */
6433 454           utf = md->utf = (re->options & PCRE_UTF8) != 0;
6434 454 50         md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
6435 454           ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
6436              
6437             /* Check a UTF-8 string if required. Pass back the character offset and error
6438             code for an invalid string if a results vector is available. */
6439              
6440             #ifdef SUPPORT_UTF
6441             if (utf && (options & PCRE_NO_UTF8_CHECK) == 0)
6442             {
6443             int erroroffset;
6444             int errorcode = PRIV(valid_utf)((PCRE_PUCHAR)subject, length, &erroroffset);
6445             if (errorcode != 0)
6446             {
6447             if (offsetcount >= 2)
6448             {
6449             offsets[0] = erroroffset;
6450             offsets[1] = errorcode;
6451             }
6452             #if defined COMPILE_PCRE8
6453             return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
6454             PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
6455             #elif defined COMPILE_PCRE16
6456             return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?
6457             PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
6458             #elif defined COMPILE_PCRE32
6459             return PCRE_ERROR_BADUTF32;
6460             #endif
6461             }
6462             #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
6463             /* Check that a start_offset points to the start of a UTF character. */
6464             if (start_offset > 0 && start_offset < length &&
6465             NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
6466             return PCRE_ERROR_BADUTF8_OFFSET;
6467             #endif
6468             }
6469             #endif
6470              
6471             /* If the pattern was successfully studied with JIT support, run the JIT
6472             executable instead of the rest of this function. Most options must be set at
6473             compile time for the JIT code to be usable. Fallback to the normal code path if
6474             an unsupported flag is set. */
6475              
6476             #ifdef SUPPORT_JIT
6477             if (extra_data != NULL
6478             && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |
6479             PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT
6480             && extra_data->executable_jit != NULL
6481             && (options & ~PUBLIC_JIT_EXEC_OPTIONS) == 0)
6482             {
6483             rc = PRIV(jit_exec)(extra_data, (const pcre_uchar *)subject, length,
6484             start_offset, options, offsets, offsetcount);
6485              
6486             /* PCRE_ERROR_NULL means that the selected normal or partial matching
6487             mode is not compiled. In this case we simply fallback to interpreter. */
6488              
6489             if (rc != PCRE_ERROR_JIT_BADOPTION) return rc;
6490             }
6491             #endif
6492              
6493             /* Carry on with non-JIT matching. This information is for finding all the
6494             numbers associated with a given name, for condition testing. */
6495              
6496 454           md->name_table = (pcre_uchar *)re + re->name_table_offset;
6497 454           md->name_count = re->name_count;
6498 454           md->name_entry_size = re->name_entry_size;
6499              
6500             /* Fish out the optional data from the extra_data structure, first setting
6501             the default values. */
6502              
6503 454           study = NULL;
6504 454           md->match_limit = MATCH_LIMIT;
6505 454           md->match_limit_recursion = MATCH_LIMIT_RECURSION;
6506 454           md->callout_data = NULL;
6507              
6508             /* The table pointer is always in native byte order. */
6509              
6510 454           tables = re->tables;
6511              
6512             /* The two limit values override the defaults, whatever their value. */
6513              
6514 454 50         if (extra_data != NULL)
6515             {
6516 0           unsigned long int flags = extra_data->flags;
6517 0 0         if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
6518 0           study = (const pcre_study_data *)extra_data->study_data;
6519 0 0         if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
6520 0           md->match_limit = extra_data->match_limit;
6521 0 0         if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
6522 0           md->match_limit_recursion = extra_data->match_limit_recursion;
6523 0 0         if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
6524 0           md->callout_data = extra_data->callout_data;
6525 0 0         if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
6526             }
6527              
6528             /* Limits in the regex override only if they are smaller. */
6529              
6530 454 50         if ((re->flags & PCRE_MLSET) != 0 && re->limit_match < md->match_limit)
    0          
6531 0           md->match_limit = re->limit_match;
6532              
6533 454 50         if ((re->flags & PCRE_RLSET) != 0 &&
    0          
6534 0           re->limit_recursion < md->match_limit_recursion)
6535 0           md->match_limit_recursion = re->limit_recursion;
6536              
6537             /* If the exec call supplied NULL for tables, use the inbuilt ones. This
6538             is a feature that makes it possible to save compiled regex and re-use them
6539             in other programs later. */
6540              
6541 454 50         if (tables == NULL) tables = PRIV(default_tables);
6542              
6543             /* Set up other data */
6544              
6545 454           anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
6546 454           startline = (re->flags & PCRE_STARTLINE) != 0;
6547 454           firstline = (re->options & PCRE_FIRSTLINE) != 0;
6548              
6549             /* The code starts after the real_pcre block and the capture name table. */
6550              
6551 908           md->start_code = (const pcre_uchar *)re + re->name_table_offset +
6552 454           re->name_count * re->name_entry_size;
6553              
6554 454           md->start_subject = (PCRE_PUCHAR)subject;
6555 454           md->start_offset = start_offset;
6556 454           md->end_subject = md->start_subject + length;
6557 454           end_subject = md->end_subject;
6558              
6559 454           md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
6560 454           md->use_ucp = (re->options & PCRE_UCP) != 0;
6561 454           md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
6562 454           md->ignore_skip_arg = 0;
6563              
6564             /* Some options are unpacked into BOOL variables in the hope that testing
6565             them will be faster than individual option bits. */
6566              
6567 454           md->notbol = (options & PCRE_NOTBOL) != 0;
6568 454           md->noteol = (options & PCRE_NOTEOL) != 0;
6569 454           md->notempty = (options & PCRE_NOTEMPTY) != 0;
6570 454           md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
6571              
6572 454           md->hitend = FALSE;
6573 454           md->mark = md->nomatch_mark = NULL; /* In case never set */
6574              
6575 454           md->recursive = NULL; /* No recursion at top level */
6576 454           md->hasthen = (re->flags & PCRE_HASTHEN) != 0;
6577              
6578 454           md->lcc = tables + lcc_offset;
6579 454           md->fcc = tables + fcc_offset;
6580 454           md->ctypes = tables + ctypes_offset;
6581              
6582             /* Handle different \R options. */
6583              
6584 454           switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
6585             {
6586             case 0:
6587 454 50         if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
6588 0           md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
6589             else
6590             #ifdef BSR_ANYCRLF
6591             md->bsr_anycrlf = TRUE;
6592             #else
6593 454           md->bsr_anycrlf = FALSE;
6594             #endif
6595 454           break;
6596              
6597             case PCRE_BSR_ANYCRLF:
6598 0           md->bsr_anycrlf = TRUE;
6599 0           break;
6600              
6601             case PCRE_BSR_UNICODE:
6602 0           md->bsr_anycrlf = FALSE;
6603 0           break;
6604              
6605 0           default: return PCRE_ERROR_BADNEWLINE;
6606             }
6607              
6608             /* Handle different types of newline. The three bits give eight cases. If
6609             nothing is set at run time, whatever was used at compile time applies. */
6610              
6611 454           switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
6612 454 50         (pcre_uint32)options) & PCRE_NEWLINE_BITS)
6613             {
6614 454           case 0: newline = NEWLINE; break; /* Compile-time default */
6615 0           case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
6616 0           case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
6617             case PCRE_NEWLINE_CR+
6618 0           PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
6619 0           case PCRE_NEWLINE_ANY: newline = -1; break;
6620 0           case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
6621 0           default: return PCRE_ERROR_BADNEWLINE;
6622             }
6623              
6624 454 50         if (newline == -2)
6625             {
6626 454           md->nltype = NLTYPE_ANYCRLF;
6627             }
6628 0 0         else if (newline < 0)
6629             {
6630 0           md->nltype = NLTYPE_ANY;
6631             }
6632             else
6633             {
6634 0           md->nltype = NLTYPE_FIXED;
6635 0 0         if (newline > 255)
6636             {
6637 0           md->nllen = 2;
6638 0           md->nl[0] = (newline >> 8) & 255;
6639 0           md->nl[1] = newline & 255;
6640             }
6641             else
6642             {
6643 0           md->nllen = 1;
6644 0           md->nl[0] = newline;
6645             }
6646             }
6647              
6648             /* Partial matching was originally supported only for a restricted set of
6649             regexes; from release 8.00 there are no restrictions, but the bits are still
6650             defined (though never set). So there's no harm in leaving this code. */
6651              
6652 454 50         if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
    0          
6653 0           return PCRE_ERROR_BADPARTIAL;
6654              
6655             /* If the expression has got more back references than the offsets supplied can
6656             hold, we get a temporary chunk of working store to use during the matching.
6657             Otherwise, we can use the vector supplied, rounding down its size to a multiple
6658             of 3. */
6659              
6660 454           ocount = offsetcount - (offsetcount % 3);
6661 454           arg_offset_max = (2*ocount)/3;
6662              
6663 454 50         if (re->top_backref > 0 && re->top_backref >= ocount/3)
    0          
6664             {
6665 0           ocount = re->top_backref * 3 + 3;
6666 0           md->offset_vector = (int *)(PUBL(malloc))(ocount * sizeof(int));
6667 0 0         if (md->offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
6668 0           using_temporary_offsets = TRUE;
6669             DPRINTF(("Got memory to hold back references\n"));
6670             }
6671 454           else md->offset_vector = offsets;
6672 454           md->offset_end = ocount;
6673 454           md->offset_max = (2*ocount)/3;
6674 454           md->capture_last = 0;
6675              
6676             /* Reset the working variable associated with each extraction. These should
6677             never be used unless previously set, but they get saved and restored, and so we
6678             initialize them to avoid reading uninitialized locations. Also, unset the
6679             offsets for the matched string. This is really just for tidiness with callouts,
6680             in case they inspect these fields. */
6681              
6682 454 50         if (md->offset_vector != NULL)
6683             {
6684 0           register int *iptr = md->offset_vector + ocount;
6685 0           register int *iend = iptr - re->top_bracket;
6686 0 0         if (iend < md->offset_vector + 2) iend = md->offset_vector + 2;
6687 0 0         while (--iptr >= iend) *iptr = -1;
6688 0 0         if (offsetcount > 0) md->offset_vector[0] = -1;
6689 0 0         if (offsetcount > 1) md->offset_vector[1] = -1;
6690             }
6691              
6692             /* Set up the first character to match, if available. The first_char value is
6693             never set for an anchored regular expression, but the anchoring may be forced
6694             at run time, so we have to test for anchoring. The first char may be unset for
6695             an unanchored pattern, of course. If there's no first char and the pattern was
6696             studied, there may be a bitmap of possible first characters. */
6697              
6698 454 100         if (!anchored)
6699             {
6700 400 50         if ((re->flags & PCRE_FIRSTSET) != 0)
6701             {
6702 400           has_first_char = TRUE;
6703 400           first_char = first_char2 = (pcre_uchar)(re->first_char);
6704 400 50         if ((re->flags & PCRE_FCH_CASELESS) != 0)
6705             {
6706 400           first_char2 = TABLE_GET(first_char, md->fcc, first_char);
6707             #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
6708             if (utf && first_char > 127)
6709             first_char2 = UCD_OTHERCASE(first_char);
6710             #endif
6711             }
6712             }
6713             else
6714 0 0         if (!startline && study != NULL &&
    0          
    0          
6715 0           (study->flags & PCRE_STUDY_MAPPED) != 0)
6716 0           start_bits = study->start_bits;
6717             }
6718              
6719             /* For anchored or unanchored matches, there may be a "last known required
6720             character" set. */
6721              
6722 454 100         if ((re->flags & PCRE_REQCHSET) != 0)
6723             {
6724 453           has_req_char = TRUE;
6725 453           req_char = req_char2 = (pcre_uchar)(re->req_char);
6726 453 50         if ((re->flags & PCRE_RCH_CASELESS) != 0)
6727             {
6728 0           req_char2 = TABLE_GET(req_char, md->fcc, req_char);
6729             #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
6730             if (utf && req_char > 127)
6731             req_char2 = UCD_OTHERCASE(req_char);
6732             #endif
6733             }
6734             }
6735              
6736              
6737             /* ==========================================================================*/
6738              
6739             /* Loop for handling unanchored repeated matching attempts; for anchored regexs
6740             the loop runs just once. */
6741              
6742             for(;;)
6743             {
6744 502           PCRE_PUCHAR save_end_subject = end_subject;
6745             PCRE_PUCHAR new_start_match;
6746              
6747             /* If firstline is TRUE, the start of the match is constrained to the first
6748             line of a multiline string. That is, the match must be before or at the first
6749             newline. Implement this by temporarily adjusting end_subject so that we stop
6750             scanning at a newline. If the match fails at the newline, later code breaks
6751             this loop. */
6752              
6753 502 50         if (firstline)
6754             {
6755 0           PCRE_PUCHAR t = start_match;
6756             #ifdef SUPPORT_UTF
6757             if (utf)
6758             {
6759             while (t < md->end_subject && !IS_NEWLINE(t))
6760             {
6761             t++;
6762             ACROSSCHAR(t < end_subject, *t, t++);
6763             }
6764             }
6765             else
6766             #endif
6767 0 0         while (t < md->end_subject && !IS_NEWLINE(t)) t++;
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
6768 0           end_subject = t;
6769             }
6770              
6771             /* There are some optimizations that avoid running the match if a known
6772             starting point is not found, or if a known later character is not present.
6773             However, there is an option that disables these, for testing and for ensuring
6774             that all callouts do actually occur. The option can be set in the regex by
6775             (*NO_START_OPT) or passed in match-time options. */
6776              
6777 502 50         if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
6778             {
6779             /* Advance to a unique first char if there is one. */
6780              
6781 502 100         if (has_first_char)
6782             {
6783             pcre_uchar smc;
6784              
6785 448 50         if (first_char != first_char2)
6786 0 0         while (start_match < end_subject &&
    0          
6787 0 0         (smc = UCHAR21TEST(start_match)) != first_char && smc != first_char2)
6788 0           start_match++;
6789             else
6790 5103 100         while (start_match < end_subject && UCHAR21TEST(start_match) != first_char)
    100          
6791 4655           start_match++;
6792             }
6793              
6794             /* Or to just after a linebreak for a multiline match */
6795              
6796 54 50         else if (startline)
6797             {
6798 0 0         if (start_match > md->start_subject + start_offset)
6799             {
6800             #ifdef SUPPORT_UTF
6801             if (utf)
6802             {
6803             while (start_match < end_subject && !WAS_NEWLINE(start_match))
6804             {
6805             start_match++;
6806             ACROSSCHAR(start_match < end_subject, *start_match,
6807             start_match++);
6808             }
6809             }
6810             else
6811             #endif
6812 0 0         while (start_match < end_subject && !WAS_NEWLINE(start_match))
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
6813 0           start_match++;
6814              
6815             /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
6816             and we are now at a LF, advance the match position by one more character.
6817             */
6818              
6819 0 0         if (start_match[-1] == CHAR_CR &&
    0          
6820 0 0         (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
    0          
6821 0 0         start_match < end_subject &&
6822 0           UCHAR21TEST(start_match) == CHAR_NL)
6823 0           start_match++;
6824             }
6825             }
6826              
6827             /* Or to a non-unique first byte after study */
6828              
6829 54 50         else if (start_bits != NULL)
6830             {
6831 0 0         while (start_match < end_subject)
6832             {
6833 0           register pcre_uint32 c = UCHAR21TEST(start_match);
6834             #ifndef COMPILE_PCRE8
6835             if (c > 255) c = 255;
6836             #endif
6837 0 0         if ((start_bits[c/8] & (1 << (c&7))) != 0) break;
6838 0           start_match++;
6839             }
6840             }
6841             } /* Starting optimizations */
6842              
6843             /* Restore fudged end_subject */
6844              
6845 502           end_subject = save_end_subject;
6846              
6847             /* The following two optimizations are disabled for partial matching or if
6848             disabling is explicitly requested. */
6849              
6850 502 50         if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
    50          
6851             {
6852             /* If the pattern was studied, a minimum subject length may be set. This is
6853             a lower bound; no actual string of that length may actually match the
6854             pattern. Although the value is, strictly, in characters, we treat it as
6855             bytes to avoid spending too much time in this optimization. */
6856              
6857 502 50         if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
    0          
    0          
6858 0           (pcre_uint32)(end_subject - start_match) < study->minlength)
6859             {
6860 0           rc = MATCH_NOMATCH;
6861 0           break;
6862             }
6863              
6864             /* If req_char is set, we know that that character must appear in the
6865             subject for the match to succeed. If the first character is set, req_char
6866             must be later in the subject; otherwise the test starts at the match point.
6867             This optimization can save a huge amount of backtracking in patterns with
6868             nested unlimited repeats that aren't going to match. Writing separate code
6869             for cased/caseless versions makes it go faster, as does using an
6870             autoincrement and backing off on a match.
6871              
6872             HOWEVER: when the subject string is very, very long, searching to its end
6873             can take a long time, and give bad performance on quite ordinary patterns.
6874             This showed up when somebody was matching something like /^\d+C/ on a
6875             32-megabyte string... so we don't do this when the string is sufficiently
6876             long. */
6877              
6878 502 100         if (has_req_char && end_subject - start_match < REQ_BYTE_MAX)
    50          
6879             {
6880 501 100         register PCRE_PUCHAR p = start_match + (has_first_char? 1:0);
6881              
6882             /* We don't need to repeat the search if we haven't yet reached the
6883             place we found it at last time. */
6884              
6885 501 50         if (p > req_char_ptr)
6886             {
6887 501 50         if (req_char != req_char2)
6888             {
6889 0 0         while (p < end_subject)
6890             {
6891 0           register pcre_uint32 pp = UCHAR21INCTEST(p);
6892 0 0         if (pp == req_char || pp == req_char2) { p--; break; }
    0          
6893             }
6894             }
6895             else
6896             {
6897 2371 100         while (p < end_subject)
6898             {
6899 1950 100         if (UCHAR21INCTEST(p) == req_char) { p--; break; }
6900             }
6901             }
6902              
6903             /* If we can't find the required character, break the matching loop,
6904             forcing a match failure. */
6905              
6906 501 100         if (p >= end_subject)
6907             {
6908 421           rc = MATCH_NOMATCH;
6909 421           break;
6910             }
6911              
6912             /* If we have found the required character, save the point where we
6913             found it, so that we don't search again next time round the loop if
6914             the start hasn't passed this character yet. */
6915              
6916 80           req_char_ptr = p;
6917             }
6918             }
6919             }
6920              
6921             #ifdef PCRE_DEBUG /* Sigh. Some compilers never learn. */
6922             printf(">>>> Match against: ");
6923             pchars(start_match, end_subject - start_match, TRUE, md);
6924             printf("\n");
6925             #endif
6926              
6927             /* OK, we can now run the match. If "hitend" is set afterwards, remember the
6928             first starting point for which a partial match was found. */
6929              
6930 81           md->start_match_ptr = start_match;
6931 81           md->start_used_ptr = start_match;
6932 81           md->match_call_count = 0;
6933 81           md->match_function_type = 0;
6934 81           md->end_offset_top = 0;
6935 81           md->skip_arg_count = 0;
6936 81           rc = match(start_match, md->start_code, start_match, 2, md, NULL, 0);
6937 81 50         if (md->hitend && start_partial == NULL)
    0          
6938             {
6939 0           start_partial = md->start_used_ptr;
6940 0           match_partial = start_match;
6941             }
6942              
6943 81           switch(rc)
6944             {
6945             /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
6946             the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP
6947             entirely. The only way we can do that is to re-do the match at the same
6948             point, with a flag to force SKIP with an argument to be ignored. Just
6949             treating this case as NOMATCH does not work because it does not check other
6950             alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */
6951              
6952             case MATCH_SKIP_ARG:
6953 0           new_start_match = start_match;
6954 0           md->ignore_skip_arg = md->skip_arg_count;
6955 0           break;
6956              
6957             /* SKIP passes back the next starting point explicitly, but if it is no
6958             greater than the match we have just done, treat it as NOMATCH. */
6959              
6960             case MATCH_SKIP:
6961 0 0         if (md->start_match_ptr > start_match)
6962             {
6963 0           new_start_match = md->start_match_ptr;
6964 0           break;
6965             }
6966             /* Fall through */
6967              
6968             /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6969             exactly like PRUNE. Unset ignore SKIP-with-argument. */
6970              
6971             case MATCH_NOMATCH:
6972             case MATCH_PRUNE:
6973             case MATCH_THEN:
6974 67           md->ignore_skip_arg = 0;
6975 67           new_start_match = start_match + 1;
6976             #ifdef SUPPORT_UTF
6977             if (utf)
6978             ACROSSCHAR(new_start_match < end_subject, *new_start_match,
6979             new_start_match++);
6980             #endif
6981 67           break;
6982              
6983             /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
6984              
6985             case MATCH_COMMIT:
6986 0           rc = MATCH_NOMATCH;
6987 0           goto ENDLOOP;
6988              
6989             /* Any other return is either a match, or some kind of error. */
6990              
6991             default:
6992 14           goto ENDLOOP;
6993             }
6994              
6995             /* Control reaches here for the various types of "no match at this point"
6996             result. Reset the code to MATCH_NOMATCH for subsequent checking. */
6997              
6998 67           rc = MATCH_NOMATCH;
6999              
7000             /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
7001             newline in the subject (though it may continue over the newline). Therefore,
7002             if we have just failed to match, starting at a newline, do not continue. */
7003              
7004 67 50         if (firstline && IS_NEWLINE(start_match)) break;
    0          
    0          
    0          
    0          
    0          
    0          
    0          
    0          
7005              
7006             /* Advance to new matching position */
7007              
7008 67           start_match = new_start_match;
7009              
7010             /* Break the loop if the pattern is anchored or if we have passed the end of
7011             the subject. */
7012              
7013 67 100         if (anchored || start_match > end_subject) break;
    50          
7014              
7015             /* If we have just passed a CR and we are now at a LF, and the pattern does
7016             not contain any explicit matches for \r or \n, and the newline option is CRLF
7017             or ANY or ANYCRLF, advance the match position by one more character. In
7018             normal matching start_match will aways be greater than the first position at
7019             this stage, but a failed *SKIP can cause a return at the same point, which is
7020             why the first test exists. */
7021              
7022 48 50         if (start_match > (PCRE_PUCHAR)subject + start_offset &&
    50          
7023 0 0         start_match[-1] == CHAR_CR &&
7024 0 0         start_match < end_subject &&
7025 0 0         *start_match == CHAR_NL &&
7026 0 0         (re->flags & PCRE_HASCRORLF) == 0 &&
7027 0 0         (md->nltype == NLTYPE_ANY ||
7028 0 0         md->nltype == NLTYPE_ANYCRLF ||
7029 0           md->nllen == 2))
7030 0           start_match++;
7031              
7032 48           md->mark = NULL; /* Reset for start of next match attempt */
7033 48           } /* End of for(;;) "bumpalong" loop */
7034              
7035             /* ==========================================================================*/
7036              
7037             /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
7038             conditions is true:
7039              
7040             (1) The pattern is anchored or the match was failed by (*COMMIT);
7041              
7042             (2) We are past the end of the subject;
7043              
7044             (3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
7045             this option requests that a match occur at or before the first newline in
7046             the subject.
7047              
7048             When we have a match and the offset vector is big enough to deal with any
7049             backreferences, captured substring offsets will already be set up. In the case
7050             where we had to get some local store to hold offsets for backreference
7051             processing, copy those that we can. In this case there need not be overflow if
7052             certain parts of the pattern were not used, even though there are more
7053             capturing parentheses than vector slots. */
7054              
7055             ENDLOOP:
7056              
7057 454 100         if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
    50          
7058             {
7059 14 50         if (using_temporary_offsets)
7060             {
7061 0 0         if (arg_offset_max >= 4)
7062             {
7063 0           memcpy(offsets + 2, md->offset_vector + 2,
7064 0           (arg_offset_max - 2) * sizeof(int));
7065             DPRINTF(("Copied offsets from temporary memory\n"));
7066             }
7067 0 0         if (md->end_offset_top > arg_offset_max) md->capture_last |= OVFLBIT;
7068             DPRINTF(("Freeing temporary memory\n"));
7069 0           (PUBL(free))(md->offset_vector);
7070             }
7071              
7072             /* Set the return code to the number of captured strings, or 0 if there were
7073             too many to fit into the vector. */
7074              
7075 3 50         rc = ((md->capture_last & OVFLBIT) != 0 &&
7076 3           md->end_offset_top >= arg_offset_max)?
7077 17 100         0 : md->end_offset_top/2;
7078              
7079             /* If there is space in the offset vector, set any unused pairs at the end of
7080             the pattern to -1 for backwards compatibility. It is documented that this
7081             happens. In earlier versions, the whole set of potential capturing offsets
7082             was set to -1 each time round the loop, but this is handled differently now.
7083             "Gaps" are set to -1 dynamically instead (this fixes a bug). Thus, it is only
7084             those at the end that need unsetting here. We can't just unset them all at
7085             the start of the whole thing because they may get set in one branch that is
7086             not the final matching branch. */
7087              
7088 14 100         if (md->end_offset_top/2 <= re->top_bracket && offsets != NULL)
    50          
7089             {
7090             register int *iptr, *iend;
7091 0           int resetcount = 2 + re->top_bracket * 2;
7092 0 0         if (resetcount > offsetcount) resetcount = offsetcount;
7093 0           iptr = offsets + md->end_offset_top;
7094 0           iend = offsets + resetcount;
7095 0 0         while (iptr < iend) *iptr++ = -1;
7096             }
7097              
7098             /* If there is space, set up the whole thing as substring 0. The value of
7099             md->start_match_ptr might be modified if \K was encountered on the success
7100             matching path. */
7101              
7102 14 50         if (offsetcount < 2) rc = 0; else
7103             {
7104 0           offsets[0] = (int)(md->start_match_ptr - md->start_subject);
7105 0           offsets[1] = (int)(md->end_match_ptr - md->start_subject);
7106             }
7107              
7108             /* Return MARK data if requested */
7109              
7110 14 50         if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
    0          
7111 0           *(extra_data->mark) = (pcre_uchar *)md->mark;
7112             DPRINTF((">>>> returning %d\n", rc));
7113             #ifdef NO_RECURSE
7114             release_match_heapframes(&frame_zero);
7115             #endif
7116 14           return rc;
7117             }
7118              
7119             /* Control gets here if there has been an error, or if the overall match
7120             attempt has failed at all permitted starting positions. */
7121              
7122 440 50         if (using_temporary_offsets)
7123             {
7124             DPRINTF(("Freeing temporary memory\n"));
7125 0           (PUBL(free))(md->offset_vector);
7126             }
7127              
7128             /* For anything other than nomatch or partial match, just return the code. */
7129              
7130 440 50         if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
    0          
7131             {
7132             DPRINTF((">>>> error: returning %d\n", rc));
7133             #ifdef NO_RECURSE
7134             release_match_heapframes(&frame_zero);
7135             #endif
7136 0           return rc;
7137             }
7138              
7139             /* Handle partial matches - disable any mark data */
7140              
7141 440 50         if (match_partial != NULL)
7142             {
7143             DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
7144 0           md->mark = NULL;
7145 0 0         if (offsetcount > 1)
7146             {
7147 0           offsets[0] = (int)(start_partial - (PCRE_PUCHAR)subject);
7148 0           offsets[1] = (int)(end_subject - (PCRE_PUCHAR)subject);
7149 0 0         if (offsetcount > 2)
7150 0           offsets[2] = (int)(match_partial - (PCRE_PUCHAR)subject);
7151             }
7152 0           rc = PCRE_ERROR_PARTIAL;
7153             }
7154              
7155             /* This is the classic nomatch case */
7156              
7157             else
7158             {
7159             DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
7160 440           rc = PCRE_ERROR_NOMATCH;
7161             }
7162              
7163             /* Return the MARK data if it has been requested. */
7164              
7165 440 50         if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
    0          
7166 0           *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7167             #ifdef NO_RECURSE
7168             release_match_heapframes(&frame_zero);
7169             #endif
7170 454           return rc;
7171             }
7172              
7173             /* End of pcre_exec.c */