1 /*************************************************
2 * Perl-Compatible Regular Expressions *
3 *************************************************/
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.
8 Written by Philip Hazel
9 Copyright (c) 1997-2014 University of Cambridge
11 -----------------------------------------------------------------------------
12 Redistribution and use in source and binary forms, with or without
13 modification, are permitted provided that the following conditions are met:
15 * Redistributions of source code must retain the above copyright notice,
16 this list of conditions and the following disclaimer.
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.
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.
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 -----------------------------------------------------------------------------
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. */
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 */
52 #include "pcre_internal.h"
54 /* Undefine some potentially clashing cpp symbols */
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
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 */
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. */
77 #define MATCH_CONDASSERT 1 /* Called to check a condition assertion */
78 #define MATCH_CBEGROUP 2 /* Could-be-empty unlimited repeat group */
80 /* Non-error returns from the match() function. Error returns are externally
81 defined PCRE_ERROR_xxx codes, which are all negative. */
84 #define MATCH_NOMATCH 0
86 /* Special internal returns from the match() function. Make them sufficiently
87 negative to avoid the external error codes. */
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
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. */
106 #define REC_STACK_SAVE_MAX 30
108 /* Min and max values for the common repeats; for the maxima, 0 => infinity */
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, };
114 /*************************************************
115 * Debugging function to print chars *
116 *************************************************/
118 /* Print a sequence of chars in printable format, stopping at the end of the
119 subject if the requested.
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
131 pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
135 if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
137 if (isprint(c = UCHAR21INCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c);
143 /*************************************************
144 * Match a back-reference *
145 *************************************************/
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.
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
159 Returns: >= 0 the number of subject bytes matched
161 -2 partial match; always given if at end subject
165 match_ref(int offset, register PCRE_PUCHAR eptr, int length, match_data *md,
168 PCRE_PUCHAR eptr_start = eptr;
169 register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
170 #if defined SUPPORT_UTF && defined SUPPORT_UCP
175 if (eptr >= md->end_subject)
176 printf("matching subject <null>");
179 printf("matching subject ");
180 pchars(eptr, length, TRUE, md);
182 printf(" against backref ");
183 pchars(p, length, FALSE, md);
187 /* Always fail if reference not set (and not JavaScript compatible - in that
188 case the length is passed as zero). */
190 if (length < 0) return -1;
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
198 #if defined SUPPORT_UTF && defined SUPPORT_UCP
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
210 PCRE_PUCHAR endptr = p + length;
214 const ucd_record *ur;
215 if (eptr >= md->end_subject) return -2; /* Partial match */
219 if (c != d && c != d + ur->other_case)
221 const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
224 if (c < *pp) return -1;
225 if (c == *pp++) break;
233 /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
234 is no UCP support. */
239 if (eptr >= md->end_subject) return -2; /* Partial match */
240 cc = UCHAR21TEST(eptr);
242 if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1;
249 /* In the caseful case, we can just compare the bytes, whether or not we
250 are in UTF-8 mode. */
256 if (eptr >= md->end_subject) return -2; /* Partial match */
257 if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1;
261 return (int)(eptr - eptr_start);
266 /***************************************************************************
267 ****************************************************************************
268 RECURSION IN THE match() FUNCTION
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
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....
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
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.
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 ***************************************************************************/
304 /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
305 below must be updated in sync. */
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 };
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. */
320 #define REGISTER register
323 #define RMATCH(ra,rb,rc,rd,re,rw) \
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__); \
329 #define RRETURN(ra) \
331 printf("match() returned %d from line %d\n", ra, __LINE__); \
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
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. */
349 #define RMATCH(ra,rb,rc,rd,re,rw)\
351 heapframe *newframe = frame->Xnextframe;\
352 if (newframe == NULL)\
354 newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
355 if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
356 newframe->Xnextframe = NULL;\
357 frame->Xnextframe = newframe;\
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;\
368 DPRINTF(("restarting from line %d\n", __LINE__));\
371 DPRINTF(("jumped back to line %d\n", __LINE__));\
376 heapframe *oldframe = frame;\
377 frame = oldframe->Xprevframe;\
387 /* Structure for remembering the local variables in a private frame */
389 typedef struct heapframe {
390 struct heapframe *Xprevframe;
391 struct heapframe *Xnextframe;
393 /* Function arguments that may change */
396 const pcre_uchar *Xecode;
400 unsigned int Xrdepth;
402 /* Function local variables */
404 PCRE_PUCHAR Xcallpat;
406 PCRE_PUCHAR Xcharptr;
412 PCRE_PUCHAR Xsaved_eptr;
414 recursion_info Xnew_recursive;
422 unsigned int Xprop_value;
423 int Xprop_fail_result;
425 pcre_uchar Xocchars[6];
435 unsigned int Xnumber;
438 pcre_int32 Xsave_capture_last;
439 int Xsave_offset1, Xsave_offset2, Xsave_offset3;
440 int Xstacksave[REC_STACK_SAVE_MAX];
444 /* Where to jump back to */
453 /***************************************************************************
454 ***************************************************************************/
458 /*************************************************
459 * Match from current position *
460 *************************************************/
462 /* This function is called recursively in many circumstances. Whenever it
463 returns a negative (error) response, the outer incarnation must also return the
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
473 #define CHECK_PARTIAL()\
474 if (md->partial != 0 && eptr >= md->end_subject && \
475 eptr > md->start_used_ptr) \
478 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
481 #define SCHECK_PARTIAL()\
482 if (md->partial != 0 && eptr > md->start_used_ptr) \
485 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
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.
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
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
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)
513 match(REGISTER PCRE_PUCHAR eptr, REGISTER const pcre_uchar *ecode,
514 PCRE_PUCHAR mstart, int offset_top, match_data *md, eptrblock *eptrb,
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. */
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 */
526 BOOL minimize, possessive; /* Quantifier options */
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". */
538 heapframe *frame = (heapframe *)md->match_frames_base;
540 /* Copy in the original argument variables */
543 frame->Xecode = ecode;
544 frame->Xmstart = mstart;
545 frame->Xoffset_top = offset_top;
546 frame->Xeptrb = eptrb;
547 frame->Xrdepth = rdepth;
549 /* This is where control jumps back to to effect "recursion" */
553 /* Macros make the argument variables come from the current frame */
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
562 /* Ditto for the local variables */
565 #define charptr frame->Xcharptr
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
575 #define new_recursive frame->Xnew_recursive
577 #define cur_is_word frame->Xcur_is_word
578 #define condition frame->Xcondition
579 #define prev_is_word frame->Xprev_is_word
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
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
604 #define newptrb frame->Xnewptrb
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. */
610 #else /* NO_RECURSE not defined */
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
623 const pcre_uchar *charptr;
625 const pcre_uchar *callpat;
626 const pcre_uchar *data;
627 const pcre_uchar *next;
629 const pcre_uchar *prev;
630 PCRE_PUCHAR saved_eptr;
632 recursion_info new_recursive;
640 unsigned int prop_value;
641 int prop_fail_result;
643 pcre_uchar occhars[6];
654 pcre_int32 save_capture_last;
655 int save_offset1, save_offset2, save_offset3;
656 int stacksave[REC_STACK_SAVE_MAX];
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
669 return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
672 int len = (char *)&rdepth - (char *)eptr;
673 return (len > 0)? -len : len;
676 #endif /* NO_RECURSE */
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. */
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
689 #define save_mark data
691 /* These statements are here to stop the compiler complaining about unitialized
696 prop_fail_result = 0;
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
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. */
716 utf = md->utf; /* Local copy of the flag */
721 /* First check that we haven't called match() too many times, or that we
722 haven't exceeded the recursive call limit. */
724 if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
725 if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
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.
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(). */
739 if (md->match_function_type == MATCH_CBEGROUP)
741 newptrb.epb_saved_eptr = eptr;
742 newptrb.epb_prev = eptrb;
744 md->match_function_type = 0;
747 /* Now start processing the opcodes. */
751 minimize = possessive = FALSE;
757 md->nomatch_mark = ecode + 2;
758 md->mark = NULL; /* In case previously set by assertion */
759 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
761 if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
762 md->mark == NULL) md->mark = ecode + 2;
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
771 else if (rrc == MATCH_SKIP_ARG &&
772 STRCMP_UC_UC_TEST(ecode + 2, md->start_match_ptr) == 0)
774 md->start_match_ptr = eptr;
780 RRETURN(MATCH_NOMATCH);
783 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
785 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
786 RRETURN(MATCH_COMMIT);
789 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
791 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
792 RRETURN(MATCH_PRUNE);
795 md->nomatch_mark = ecode + 2;
796 md->mark = NULL; /* In case previously set by assertion */
797 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
799 if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
800 md->mark == NULL) md->mark = ecode + 2;
801 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
802 RRETURN(MATCH_PRUNE);
805 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
807 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
808 md->start_match_ptr = eptr; /* Pass back current position */
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. */
820 md->skip_arg_count++;
821 if (md->skip_arg_count <= md->ignore_skip_arg)
823 ecode += PRIV(OP_lengths)[*ecode] + ecode[1];
826 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
828 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
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. */
835 md->start_match_ptr = ecode + 2;
836 RRETURN(MATCH_SKIP_ARG);
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. */
843 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
845 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
846 md->start_match_ptr = ecode;
850 md->nomatch_mark = ecode + 2;
851 md->mark = NULL; /* In case previously set by assertion */
852 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top,
854 if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
855 md->mark == NULL) md->mark = ecode + 2;
856 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
857 md->start_match_ptr = ecode;
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.
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. */
876 save_mark = md->mark;
879 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
880 if (rrc == MATCH_MATCH) /* Note: _not_ MATCH_ACCEPT */
882 mstart = md->start_match_ptr;
885 if (rrc == MATCH_THEN)
887 next = ecode + GET(ecode,1);
888 if (md->start_match_ptr < next &&
889 (*ecode == OP_ALT || *next == OP_ALT))
893 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
894 ecode += GET(ecode,1);
895 md->mark = save_mark;
897 while (*ecode == OP_ALT);
899 /* If hit the end of the group (which could be repeated), fail */
901 if (*ecode != OP_ONCE_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
903 /* Continue as from after the group, updating the offsets high water
904 mark, since extracts may have been taken. */
906 do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
908 offset_top = md->end_offset_top;
909 eptr = md->end_match_ptr;
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
916 if (*ecode == OP_KET || eptr == saved_eptr)
918 ecode += 1+LINK_SIZE;
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. */
926 if (*ecode == OP_KETRMIN)
928 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
929 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
933 else /* OP_KETRMAX */
935 RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
936 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
937 ecode += 1 + LINK_SIZE;
940 /* Control never gets here */
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.
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. */
958 number = GET2(ecode, 1+LINK_SIZE);
959 offset = number << 1;
962 printf("start bracket %d\n", number);
964 pchars(eptr, 16, TRUE, md);
968 if (offset < md->offset_max)
970 save_offset1 = md->offset_vector[offset];
971 save_offset2 = md->offset_vector[offset+1];
972 save_offset3 = md->offset_vector[md->offset_end - number];
973 save_capture_last = md->capture_last;
974 save_mark = md->mark;
976 DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
977 md->offset_vector[md->offset_end - number] =
978 (int)(eptr - md->start_subject);
982 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
983 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
985 if (rrc == MATCH_ONCE) break; /* Backing up through an atomic group */
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)). */
998 if (rrc == MATCH_THEN)
1000 next = ecode + GET(ecode,1);
1001 if (md->start_match_ptr < next &&
1002 (*ecode == OP_ALT || *next == OP_ALT))
1003 rrc = MATCH_NOMATCH;
1006 /* Anything other than NOMATCH is passed back. */
1008 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1009 md->capture_last = save_capture_last;
1010 ecode += GET(ecode, 1);
1011 md->mark = save_mark;
1012 if (*ecode != OP_ALT) break;
1015 DPRINTF(("bracket %d failed\n", number));
1016 md->offset_vector[offset] = save_offset1;
1017 md->offset_vector[offset+1] = save_offset2;
1018 md->offset_vector[md->offset_end - number] = save_offset3;
1020 /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
1025 /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
1026 as a non-capturing bracket. */
1028 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1029 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1031 DPRINTF(("insufficient capture room: treat as non-capturing\n"));
1033 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1034 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1036 /* Non-capturing or atomic group, except for possessive with unlimited
1037 repeat and ONCE group with no captures. Loop for all the alternatives.
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.
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.
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. */
1059 DPRINTF(("start non-capturing bracket\n"));
1063 if (op >= OP_SBRA || op == OP_ONCE)
1064 md->match_function_type = MATCH_CBEGROUP;
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
1070 else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
1072 ecode += PRIV(OP_lengths)[*ecode];
1076 /* In all other cases, we have to make another call to match(). */
1078 save_mark = md->mark;
1079 save_capture_last = md->capture_last;
1080 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
1083 /* See comment in the code for capturing groups above about handling
1086 if (rrc == MATCH_THEN)
1088 next = ecode + GET(ecode,1);
1089 if (md->start_match_ptr < next &&
1090 (*ecode == OP_ALT || *next == OP_ALT))
1091 rrc = MATCH_NOMATCH;
1094 if (rrc != MATCH_NOMATCH)
1096 if (rrc == MATCH_ONCE)
1098 const pcre_uchar *scode = ecode;
1099 if (*scode != OP_ONCE) /* If not at start, find it */
1101 while (*scode == OP_ALT) scode += GET(scode, 1);
1102 scode -= GET(scode, 1);
1104 if (md->once_target == scode) rrc = MATCH_NOMATCH;
1108 ecode += GET(ecode, 1);
1109 md->mark = save_mark;
1110 if (*ecode != OP_ALT) break;
1111 md->capture_last = save_capture_last;
1114 RRETURN(MATCH_NOMATCH);
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. */
1129 number = GET2(ecode, 1+LINK_SIZE);
1130 offset = number << 1;
1133 printf("start possessive bracket %d\n", number);
1135 pchars(eptr, 16, TRUE, md);
1139 if (offset >= md->offset_max) goto POSSESSIVE_NON_CAPTURE;
1141 matched_once = FALSE;
1142 code_offset = (int)(ecode - md->start_code);
1144 save_offset1 = md->offset_vector[offset];
1145 save_offset2 = md->offset_vector[offset+1];
1146 save_offset3 = md->offset_vector[md->offset_end - number];
1147 save_capture_last = md->capture_last;
1149 DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
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. */
1162 md->offset_vector[md->offset_end - number] =
1163 (int)(eptr - md->start_subject);
1164 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1165 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
1167 if (rrc == MATCH_KETRPOS)
1169 offset_top = md->end_offset_top;
1170 ecode = md->start_code + code_offset;
1171 save_capture_last = md->capture_last;
1172 matched_once = TRUE;
1173 mstart = md->start_match_ptr; /* In case \K changed it */
1174 if (eptr == md->end_match_ptr) /* Matched an empty string */
1176 do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1179 eptr = md->end_match_ptr;
1183 /* See comment in the code for capturing groups above about handling
1186 if (rrc == MATCH_THEN)
1188 next = ecode + GET(ecode,1);
1189 if (md->start_match_ptr < next &&
1190 (*ecode == OP_ALT || *next == OP_ALT))
1191 rrc = MATCH_NOMATCH;
1194 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1195 md->capture_last = save_capture_last;
1196 ecode += GET(ecode, 1);
1197 if (*ecode != OP_ALT) break;
1202 md->offset_vector[offset] = save_offset1;
1203 md->offset_vector[offset+1] = save_offset2;
1204 md->offset_vector[md->offset_end - number] = save_offset3;
1207 if (allow_zero || matched_once)
1209 ecode += 1 + LINK_SIZE;
1213 RRETURN(MATCH_NOMATCH);
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
1224 POSSESSIVE_NON_CAPTURE:
1225 matched_once = FALSE;
1226 code_offset = (int)(ecode - md->start_code);
1227 save_capture_last = md->capture_last;
1231 if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1232 RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
1234 if (rrc == MATCH_KETRPOS)
1236 offset_top = md->end_offset_top;
1237 ecode = md->start_code + code_offset;
1238 matched_once = TRUE;
1239 mstart = md->start_match_ptr; /* In case \K reset it */
1240 if (eptr == md->end_match_ptr) /* Matched an empty string */
1242 do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
1245 eptr = md->end_match_ptr;
1249 /* See comment in the code for capturing groups above about handling
1252 if (rrc == MATCH_THEN)
1254 next = ecode + GET(ecode,1);
1255 if (md->start_match_ptr < next &&
1256 (*ecode == OP_ALT || *next == OP_ALT))
1257 rrc = MATCH_NOMATCH;
1260 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1261 ecode += GET(ecode, 1);
1262 if (*ecode != OP_ALT) break;
1263 md->capture_last = save_capture_last;
1266 if (matched_once || allow_zero)
1268 ecode += 1 + LINK_SIZE;
1271 RRETURN(MATCH_NOMATCH);
1273 /* Control never reaches here. */
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
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. */
1288 codelink = GET(ecode, 1); /* Offset to the second branch */
1289 ecode += 1 + LINK_SIZE; /* From this opcode */
1291 /* Because of the way auto-callout works during compile, a callout item is
1292 inserted between OP_COND and an assertion condition. */
1294 if (*ecode == OP_CALLOUT)
1296 if (PUBL(callout) != NULL)
1298 PUBL(callout_block) cb;
1299 cb.version = 2; /* Version 1 of the callout block */
1300 cb.callout_number = ecode[1];
1301 cb.offset_vector = md->offset_vector;
1302 #if defined COMPILE_PCRE8
1303 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;
1309 cb.subject_length = (int)(md->end_subject - md->start_subject);
1310 cb.start_match = (int)(mstart - md->start_subject);
1311 cb.current_position = (int)(eptr - md->start_subject);
1312 cb.pattern_position = GET(ecode, 2);
1313 cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1314 cb.capture_top = offset_top/2;
1315 cb.capture_last = md->capture_last & CAPLMASK;
1316 /* Internal change requires this for API compatibility. */
1317 if (cb.capture_last == 0) cb.capture_last = -1;
1318 cb.callout_data = md->callout_data;
1319 cb.mark = md->nomatch_mark;
1320 if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1321 if (rrc < 0) RRETURN(rrc);
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. */
1327 ecode += PRIV(OP_lengths)[OP_CALLOUT];
1328 codelink -= PRIV(OP_lengths)[OP_CALLOUT];
1331 /* Test the various possible conditions */
1334 switch(condcode = *ecode)
1336 case OP_RREF: /* Numbered group recursion test */
1337 if (md->recursive != NULL) /* Not recursing => FALSE */
1339 unsigned int recno = GET2(ecode, 1); /* Recursion group number*/
1340 condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1344 case OP_DNRREF: /* Duplicate named group recursion test */
1345 if (md->recursive != NULL)
1347 int count = GET2(ecode, 1 + IMM2_SIZE);
1348 pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1351 unsigned int recno = GET2(slot, 0);
1352 condition = recno == md->recursive->group_num;
1353 if (condition) break;
1354 slot += md->name_entry_size;
1359 case OP_CREF: /* Numbered group used test */
1360 offset = GET2(ecode, 1) << 1; /* Doubled ref number */
1361 condition = offset < offset_top && md->offset_vector[offset] >= 0;
1364 case OP_DNCREF: /* Duplicate named group used test */
1366 int count = GET2(ecode, 1 + IMM2_SIZE);
1367 pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1370 offset = GET2(slot, 0) << 1;
1371 condition = offset < offset_top && md->offset_vector[offset] >= 0;
1372 if (condition) break;
1373 slot += md->name_entry_size;
1378 case OP_DEF: /* DEFINE - always false */
1379 case OP_FAIL: /* From optimized (?!) condition */
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
1387 md->match_function_type = MATCH_CONDASSERT;
1388 RMATCH(eptr, ecode, offset_top, md, NULL, RM3);
1389 if (rrc == MATCH_MATCH)
1391 if (md->end_offset_top > offset_top)
1392 offset_top = md->end_offset_top; /* Captures may have happened */
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! */
1400 if (*ecode == OP_BRAZERO) ecode++;
1401 ecode += GET(ecode, 1);
1402 while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1403 ecode += 1 + LINK_SIZE - PRIV(OP_lengths)[condcode];
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
1410 else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1412 RRETURN(rrc); /* Need braces because of following else */
1417 /* Choose branch according to the condition */
1419 ecode += condition? PRIV(OP_lengths)[condcode] : codelink;
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). */
1431 if (condition || ecode[-(1+LINK_SIZE)] == OP_ALT)
1438 md->match_function_type = MATCH_CBEGROUP;
1439 RMATCH(eptr, ecode, offset_top, md, eptrb, RM49);
1443 /* Condition false & no alternative; continue after the group. */
1451 /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1452 to close any currently open capturing brackets. */
1455 number = GET2(ecode, 1); /* Must be less than 65536 */
1456 offset = number << 1;
1459 printf("end bracket %d at *ACCEPT", number);
1463 md->capture_last = (md->capture_last & OVFLMASK) | number;
1464 if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
1466 md->offset_vector[offset] =
1467 md->offset_vector[md->offset_end - number];
1468 md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
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. */
1474 if (offset >= offset_top)
1476 register int *iptr = md->offset_vector + offset_top;
1477 register int *iend = md->offset_vector + offset;
1478 while (iptr < iend) *iptr++ = -1;
1479 offset_top = offset + 2;
1482 ecode += 1 + IMM2_SIZE;
1486 /* End of the pattern, either real or forced. */
1490 case OP_ASSERT_ACCEPT:
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. */
1497 if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
1498 md->recursive == NULL &&
1500 (md->notempty_atstart &&
1501 mstart == md->start_subject + md->start_offset)))
1502 RRETURN(MATCH_NOMATCH);
1504 /* Otherwise, we have a match. */
1506 md->end_match_ptr = eptr; /* Record where we ended */
1507 md->end_offset_top = offset_top; /* and how many extracts were taken */
1508 md->start_match_ptr = mstart; /* and the start (\K can modify) */
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. */
1513 rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
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. */
1529 save_mark = md->mark;
1530 if (md->match_function_type == MATCH_CONDASSERT)
1533 md->match_function_type = 0;
1535 else condassert = FALSE;
1537 /* Loop for each branch */
1541 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
1543 /* A match means that the assertion is true; break out of the loop
1544 that matches its alternatives. */
1546 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1548 mstart = md->start_match_ptr; /* In case \K reset it */
1552 /* If not matched, restore the previous mark setting. */
1554 md->mark = save_mark;
1556 /* See comment in the code for capturing groups above about handling
1559 if (rrc == MATCH_THEN)
1561 next = ecode + GET(ecode,1);
1562 if (md->start_match_ptr < next &&
1563 (*ecode == OP_ALT || *next == OP_ALT))
1564 rrc = MATCH_NOMATCH;
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
1573 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1574 ecode += GET(ecode, 1);
1576 while (*ecode == OP_ALT); /* Continue for next alternative */
1578 /* If we have tried all the alternative branches, the assertion has
1579 failed. If not, we broke out after a match. */
1581 if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
1583 /* If checking an assertion for a condition, return MATCH_MATCH. */
1585 if (condassert) RRETURN(MATCH_MATCH);
1587 /* Continue from after a successful assertion, updating the offsets high
1588 water mark, since extracts may have been taken during the assertion. */
1590 do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1591 ecode += 1 + LINK_SIZE;
1592 offset_top = md->end_offset_top;
1595 /* Negative assertion: all branches must fail to match for the assertion to
1599 case OP_ASSERTBACK_NOT:
1600 save_mark = md->mark;
1601 if (md->match_function_type == MATCH_CONDASSERT)
1604 md->match_function_type = 0;
1606 else condassert = FALSE;
1608 /* Loop for each alternative branch. */
1612 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1613 md->mark = save_mark; /* Always restore the mark setting */
1617 case MATCH_MATCH: /* A successful match means */
1618 case MATCH_ACCEPT: /* the assertion has failed. */
1619 RRETURN(MATCH_NOMATCH);
1621 case MATCH_NOMATCH: /* Carry on with next branch */
1624 /* See comment in the code for capturing groups above about handling
1628 next = ecode + GET(ecode,1);
1629 if (md->start_match_ptr < next &&
1630 (*ecode == OP_ALT || *next == OP_ALT))
1632 rrc = MATCH_NOMATCH;
1635 /* Otherwise fall through. */
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. */
1644 case MATCH_SKIP_ARG:
1646 do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1647 goto NEG_ASSERT_TRUE; /* Break out of alternation loop */
1649 /* Anything else is an error */
1655 /* Continue with next branch */
1657 ecode += GET(ecode,1);
1659 while (*ecode == OP_ALT);
1661 /* All branches in the assertion failed to match. */
1664 if (condassert) RRETURN(MATCH_MATCH); /* Condition assertion */
1665 ecode += 1 + LINK_SIZE; /* Continue with current branch */
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. */
1681 if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1688 /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
1691 eptr -= GET(ecode, 1);
1692 if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1695 /* Save the earliest consulted character, then skip to next op code */
1697 if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1698 ecode += 1 + LINK_SIZE;
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. */
1706 if (PUBL(callout) != NULL)
1708 PUBL(callout_block) cb;
1709 cb.version = 2; /* Version 1 of the callout block */
1710 cb.callout_number = ecode[1];
1711 cb.offset_vector = md->offset_vector;
1712 #if defined COMPILE_PCRE8
1713 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;
1719 cb.subject_length = (int)(md->end_subject - md->start_subject);
1720 cb.start_match = (int)(mstart - md->start_subject);
1721 cb.current_position = (int)(eptr - md->start_subject);
1722 cb.pattern_position = GET(ecode, 2);
1723 cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1724 cb.capture_top = offset_top/2;
1725 cb.capture_last = md->capture_last & CAPLMASK;
1726 /* Internal change requires this for API compatibility. */
1727 if (cb.capture_last == 0) cb.capture_last = -1;
1728 cb.callout_data = md->callout_data;
1729 cb.mark = md->nomatch_mark;
1730 if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1731 if (rrc < 0) RRETURN(rrc);
1733 ecode += 2 + 2*LINK_SIZE;
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.)
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.
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. */
1758 callpat = md->start_code + GET(ecode, 1);
1759 recno = (callpat == md->start_code)? 0 :
1760 GET2(callpat, 1 + LINK_SIZE);
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.) */
1766 for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
1767 if (recno == ri->group_num && eptr == ri->subject_position)
1768 RRETURN(PCRE_ERROR_RECURSELOOP);
1770 /* Add to "recursing stack" */
1772 new_recursive.group_num = recno;
1773 new_recursive.saved_capture_last = md->capture_last;
1774 new_recursive.subject_position = eptr;
1775 new_recursive.prevrec = md->recursive;
1776 md->recursive = &new_recursive;
1778 /* Where to continue from afterwards */
1780 ecode += 1 + LINK_SIZE;
1782 /* Now save the offset data */
1784 new_recursive.saved_max = md->offset_end;
1785 if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
1786 new_recursive.offset_save = stacksave;
1789 new_recursive.offset_save =
1790 (int *)(PUBL(malloc))(new_recursive.saved_max * sizeof(int));
1791 if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
1793 memcpy(new_recursive.offset_save, md->offset_vector,
1794 new_recursive.saved_max * sizeof(int));
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.
1801 DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1802 cbegroup = (*callpat >= OP_SBRA);
1805 if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
1806 RMATCH(eptr, callpat + PRIV(OP_lengths)[*callpat], offset_top,
1808 memcpy(md->offset_vector, new_recursive.offset_save,
1809 new_recursive.saved_max * sizeof(int));
1810 md->capture_last = new_recursive.saved_capture_last;
1811 md->recursive = new_recursive.prevrec;
1812 if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1814 DPRINTF(("Recursion matched\n"));
1815 if (new_recursive.offset_save != stacksave)
1816 (PUBL(free))(new_recursive.offset_save);
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. */
1822 eptr = md->end_match_ptr;
1823 mstart = md->start_match_ptr;
1824 goto RECURSION_MATCHED; /* Exit loop; end processing */
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. */
1831 if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX)
1833 if (new_recursive.offset_save != stacksave)
1834 (PUBL(free))(new_recursive.offset_save);
1835 RRETURN(MATCH_NOMATCH);
1838 /* Any return code other than NOMATCH is an error. */
1840 if (rrc != MATCH_NOMATCH)
1842 DPRINTF(("Recursion gave error %d\n", rrc));
1843 if (new_recursive.offset_save != stacksave)
1844 (PUBL(free))(new_recursive.offset_save);
1848 md->recursive = &new_recursive;
1849 callpat += GET(callpat, 1);
1851 while (*callpat == OP_ALT);
1853 DPRINTF(("Recursion didn't match\n"));
1854 md->recursive = new_recursive.prevrec;
1855 if (new_recursive.offset_save != stacksave)
1856 (PUBL(free))(new_recursive.offset_save);
1857 RRETURN(MATCH_NOMATCH);
1863 /* An alternation is the end of a branch; scan along to find the end of the
1864 bracketed group and go to there. */
1867 do ecode += GET(ecode,1); while (*ecode == OP_ALT);
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. */
1878 RMATCH(eptr, next, offset_top, md, eptrb, RM10);
1879 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1880 do next += GET(next, 1); while (*next == OP_ALT);
1881 ecode = next + 1 + LINK_SIZE;
1886 do next += GET(next, 1); while (*next == OP_ALT);
1887 RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
1888 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1894 do next += GET(next,1); while (*next == OP_ALT);
1895 ecode = next + 1 + LINK_SIZE;
1898 /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
1899 here; just jump to the group, with allow_zero set TRUE. */
1904 if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
1905 goto POSSESSIVE_NON_CAPTURE;
1907 /* End of a group, repeated or non-repeating. */
1913 prev = ecode - GET(ecode, 1);
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. */
1919 if (*prev >= OP_SBRA || *prev == OP_ONCE)
1921 saved_eptr = eptrb->epb_saved_eptr; /* Value at start of group */
1922 eptrb = eptrb->epb_prev; /* Backup to previous group */
1924 else saved_eptr = NULL;
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. */
1931 if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
1932 *prev == OP_ONCE_NC)
1934 md->end_match_ptr = eptr; /* For ONCE_NC */
1935 md->end_offset_top = offset_top;
1936 md->start_match_ptr = mstart;
1937 RRETURN(MATCH_MATCH); /* Sets md->mark */
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
1948 if (*prev == OP_CBRA || *prev == OP_SCBRA ||
1949 *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
1951 number = GET2(prev, 1+LINK_SIZE);
1952 offset = number << 1;
1955 printf("end bracket %d", number);
1959 /* Handle a recursively called group. */
1961 if (md->recursive != NULL && md->recursive->group_num == number)
1963 md->end_match_ptr = eptr;
1964 md->start_match_ptr = mstart;
1965 RRETURN(MATCH_MATCH);
1968 /* Deal with capturing */
1970 md->capture_last = (md->capture_last & OVFLMASK) | number;
1971 if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
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.) */
1983 if (offset > offset_top)
1985 register int *iptr = md->offset_vector + offset_top;
1986 register int *iend = md->offset_vector + offset;
1987 while (iptr < iend) *iptr++ = -1;
1990 /* Now make the extraction */
1992 md->offset_vector[offset] =
1993 md->offset_vector[md->offset_end - number];
1994 md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1995 if (offset_top <= offset) offset_top = offset + 2;
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. */
2004 if (*ecode == OP_KETRPOS)
2006 md->start_match_ptr = mstart; /* In case \K reset it */
2007 md->end_match_ptr = eptr;
2008 md->end_offset_top = offset_top;
2009 RRETURN(MATCH_KETRPOS);
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. */
2021 if (*ecode == OP_KET || eptr == saved_eptr)
2023 if (*prev == OP_ONCE)
2025 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
2026 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2027 md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
2028 RRETURN(MATCH_ONCE);
2030 ecode += 1 + LINK_SIZE; /* Carry on at this level */
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
2040 if (*ecode == OP_KETRMIN)
2042 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM7);
2043 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2044 if (*prev == OP_ONCE)
2046 RMATCH(eptr, prev, offset_top, md, eptrb, RM8);
2047 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2048 md->once_target = prev; /* Level at which to change to MATCH_NOMATCH */
2049 RRETURN(MATCH_ONCE);
2051 if (*prev >= OP_SBRA) /* Could match an empty string */
2053 RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2059 else /* OP_KETRMAX */
2061 RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2062 if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
2063 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2064 if (*prev == OP_ONCE)
2066 RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM9);
2067 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2068 md->once_target = prev;
2069 RRETURN(MATCH_ONCE);
2071 ecode += 1 + LINK_SIZE;
2074 /* Control never gets here */
2076 /* Not multiline mode: start of subject assertion, unless notbol. */
2079 if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
2081 /* Start of subject assertion */
2084 if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
2088 /* Multiline mode: start of subject unless notbol, or after any newline. */
2091 if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
2092 if (eptr != md->start_subject &&
2093 (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
2094 RRETURN(MATCH_NOMATCH);
2098 /* Start of match assertion */
2101 if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
2105 /* Reset the start of match point */
2112 /* Multiline mode: assert before any newline, or before end of subject
2113 unless noteol is set. */
2116 if (eptr < md->end_subject)
2118 if (!IS_NEWLINE(eptr))
2120 if (md->partial != 0 &&
2121 eptr + 1 >= md->end_subject &&
2122 NLBLOCK->nltype == NLTYPE_FIXED &&
2123 NLBLOCK->nllen == 2 &&
2124 UCHAR21TEST(eptr) == NLBLOCK->nl[0])
2127 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2129 RRETURN(MATCH_NOMATCH);
2134 if (md->noteol) RRETURN(MATCH_NOMATCH);
2140 /* Not multiline mode: assert before a terminating newline or before end of
2141 subject unless noteol is set. */
2144 if (md->noteol) RRETURN(MATCH_NOMATCH);
2145 if (!md->endonly) goto ASSERT_NL_OR_EOS;
2147 /* ... else fall through for endonly */
2149 /* End of subject assertion (\z) */
2152 if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
2157 /* End of subject or ending \n assertion (\Z) */
2161 if (eptr < md->end_subject &&
2162 (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2164 if (md->partial != 0 &&
2165 eptr + 1 >= md->end_subject &&
2166 NLBLOCK->nltype == NLTYPE_FIXED &&
2167 NLBLOCK->nllen == 2 &&
2168 UCHAR21TEST(eptr) == NLBLOCK->nl[0])
2171 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2173 RRETURN(MATCH_NOMATCH);
2176 /* Either at end of string or \n before end. */
2182 /* Word boundary assertions */
2184 case OP_NOT_WORD_BOUNDARY:
2185 case OP_WORD_BOUNDARY:
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. */
2196 /* Get status of previous character */
2198 if (eptr == md->start_subject) prev_is_word = FALSE; else
2200 PCRE_PUCHAR lastptr = eptr - 1;
2202 if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
2203 GETCHAR(c, lastptr);
2207 if (c == '_') prev_is_word = TRUE; else
2209 int cat = UCD_CATEGORY(c);
2210 prev_is_word = (cat == ucp_L || cat == ucp_N);
2215 prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
2218 /* Get status of next character */
2220 if (eptr >= md->end_subject)
2223 cur_is_word = FALSE;
2231 if (c == '_') cur_is_word = TRUE; else
2233 int cat = UCD_CATEGORY(c);
2234 cur_is_word = (cat == ucp_L || cat == ucp_N);
2239 cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
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. */
2249 /* Get status of previous character */
2251 if (eptr == md->start_subject) prev_is_word = FALSE; else
2253 if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
2258 if (c == '_') prev_is_word = TRUE; else
2260 int cat = UCD_CATEGORY(c);
2261 prev_is_word = (cat == ucp_L || cat == ucp_N);
2266 prev_is_word = MAX_255(eptr[-1])
2267 && ((md->ctypes[eptr[-1]] & ctype_word) != 0);
2270 /* Get status of next character */
2272 if (eptr >= md->end_subject)
2275 cur_is_word = FALSE;
2282 if (c == '_') cur_is_word = TRUE; else
2284 int cat = UCD_CATEGORY(c);
2285 cur_is_word = (cat == ucp_L || cat == ucp_N);
2290 cur_is_word = MAX_255(*eptr)
2291 && ((md->ctypes[*eptr] & ctype_word) != 0);
2294 /* Now see if the situation is what we want */
2296 if ((*ecode++ == OP_WORD_BOUNDARY)?
2297 cur_is_word == prev_is_word : cur_is_word != prev_is_word)
2298 RRETURN(MATCH_NOMATCH);
2302 /* Match any single character type except newline; have to take care with
2303 CRLF newlines and partial matching. */
2306 if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2307 if (md->partial != 0 &&
2308 eptr + 1 >= md->end_subject &&
2309 NLBLOCK->nltype == NLTYPE_FIXED &&
2310 NLBLOCK->nllen == 2 &&
2311 UCHAR21TEST(eptr) == NLBLOCK->nl[0])
2314 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2319 /* Match any single character whatsoever. */
2322 if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2323 { /* not be updated before SCHECK_PARTIAL. */
2325 RRETURN(MATCH_NOMATCH);
2329 if (utf) ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
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. */
2338 if (eptr >= md->end_subject) /* DO NOT merge the eptr++ here; it must */
2339 { /* not be updated before SCHECK_PARTIAL. */
2341 RRETURN(MATCH_NOMATCH);
2348 if (eptr >= md->end_subject)
2351 RRETURN(MATCH_NOMATCH);
2353 GETCHARINCTEST(c, eptr);
2355 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2358 (md->ctypes[c] & ctype_digit) != 0
2360 RRETURN(MATCH_NOMATCH);
2365 if (eptr >= md->end_subject)
2368 RRETURN(MATCH_NOMATCH);
2370 GETCHARINCTEST(c, eptr);
2372 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2375 (md->ctypes[c] & ctype_digit) == 0
2377 RRETURN(MATCH_NOMATCH);
2381 case OP_NOT_WHITESPACE:
2382 if (eptr >= md->end_subject)
2385 RRETURN(MATCH_NOMATCH);
2387 GETCHARINCTEST(c, eptr);
2389 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2392 (md->ctypes[c] & ctype_space) != 0
2394 RRETURN(MATCH_NOMATCH);
2399 if (eptr >= md->end_subject)
2402 RRETURN(MATCH_NOMATCH);
2404 GETCHARINCTEST(c, eptr);
2406 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2409 (md->ctypes[c] & ctype_space) == 0
2411 RRETURN(MATCH_NOMATCH);
2415 case OP_NOT_WORDCHAR:
2416 if (eptr >= md->end_subject)
2419 RRETURN(MATCH_NOMATCH);
2421 GETCHARINCTEST(c, eptr);
2423 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2426 (md->ctypes[c] & ctype_word) != 0
2428 RRETURN(MATCH_NOMATCH);
2433 if (eptr >= md->end_subject)
2436 RRETURN(MATCH_NOMATCH);
2438 GETCHARINCTEST(c, eptr);
2440 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2443 (md->ctypes[c] & ctype_word) == 0
2445 RRETURN(MATCH_NOMATCH);
2450 if (eptr >= md->end_subject)
2453 RRETURN(MATCH_NOMATCH);
2455 GETCHARINCTEST(c, eptr);
2458 default: RRETURN(MATCH_NOMATCH);
2461 if (eptr >= md->end_subject)
2465 else if (UCHAR21TEST(eptr) == CHAR_LF) eptr++;
2477 #endif /* Not EBCDIC */
2478 if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2485 if (eptr >= md->end_subject)
2488 RRETURN(MATCH_NOMATCH);
2490 GETCHARINCTEST(c, eptr);
2493 HSPACE_CASES: RRETURN(MATCH_NOMATCH); /* Byte and multibyte cases */
2500 if (eptr >= md->end_subject)
2503 RRETURN(MATCH_NOMATCH);
2505 GETCHARINCTEST(c, eptr);
2508 HSPACE_CASES: break; /* Byte and multibyte cases */
2509 default: RRETURN(MATCH_NOMATCH);
2515 if (eptr >= md->end_subject)
2518 RRETURN(MATCH_NOMATCH);
2520 GETCHARINCTEST(c, eptr);
2523 VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2530 if (eptr >= md->end_subject)
2533 RRETURN(MATCH_NOMATCH);
2535 GETCHARINCTEST(c, eptr);
2538 VSPACE_CASES: break;
2539 default: RRETURN(MATCH_NOMATCH);
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. */
2550 if (eptr >= md->end_subject)
2553 RRETURN(MATCH_NOMATCH);
2555 GETCHARINCTEST(c, eptr);
2557 const pcre_uint32 *cp;
2558 const ucd_record *prop = GET_UCD(c);
2563 if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2567 if ((prop->chartype == ucp_Lu ||
2568 prop->chartype == ucp_Ll ||
2569 prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2570 RRETURN(MATCH_NOMATCH);
2574 if ((ecode[2] != PRIV(ucp_gentype)[prop->chartype]) == (op == OP_PROP))
2575 RRETURN(MATCH_NOMATCH);
2579 if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2580 RRETURN(MATCH_NOMATCH);
2584 if ((ecode[2] != prop->script) == (op == OP_PROP))
2585 RRETURN(MATCH_NOMATCH);
2588 /* These are specials */
2591 if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2592 PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2593 RRETURN(MATCH_NOMATCH);
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. */
2600 case PT_SPACE: /* Perl space */
2601 case PT_PXSPACE: /* POSIX space */
2606 if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2610 if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) ==
2611 (op == OP_NOTPROP)) RRETURN(MATCH_NOMATCH);
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);
2624 cp = PRIV(ucd_caseless_sets) + ecode[2];
2628 { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2630 { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
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);
2641 /* This should never occur */
2644 RRETURN(PCRE_ERROR_INTERNAL);
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. */
2655 if (eptr >= md->end_subject)
2658 RRETURN(MATCH_NOMATCH);
2663 GETCHARINCTEST(c, eptr);
2664 lgb = UCD_GRAPHBREAK(c);
2665 while (eptr < md->end_subject)
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;
2678 #endif /* SUPPORT_UCP */
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:
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.
2693 (b) If the JavaScript compatibility flag is set, set the length to zero
2694 so that the back reference matches an empty string.
2696 Otherwise, set the length to the length of what was matched by the
2697 referenced subpattern.
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. */
2706 caseless = op == OP_DNREFI;
2708 int count = GET2(ecode, 1+IMM2_SIZE);
2709 pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
2710 ecode += 1 + 2*IMM2_SIZE;
2712 /* Setting the default length first and initializing 'offset' avoids
2713 compiler warnings in the REF_REPEAT code. */
2715 length = (md->jscript_compat)? 0 : -1;
2720 offset = GET2(slot, 0) << 1;
2721 if (offset < offset_top && md->offset_vector[offset] >= 0)
2723 length = md->offset_vector[offset+1] - md->offset_vector[offset];
2726 slot += md->name_entry_size;
2733 caseless = op == OP_REFI;
2734 offset = GET2(ecode, 1) << 1; /* Doubled ref number */
2735 ecode += 1 + IMM2_SIZE;
2736 if (offset >= offset_top || md->offset_vector[offset] < 0)
2737 length = (md->jscript_compat)? 0 : -1;
2739 length = md->offset_vector[offset+1] - md->offset_vector[offset];
2741 /* Set up for repetition, or handle the non-repeated case */
2752 c = *ecode++ - OP_CRSTAR;
2753 minimize = (c & 1) != 0;
2754 min = rep_min[c]; /* Pick up values from tables; */
2755 max = rep_max[c]; /* zero for max => infinity */
2756 if (max == 0) max = INT_MAX;
2761 minimize = (*ecode == OP_CRMINRANGE);
2762 min = GET2(ecode, 1);
2763 max = GET2(ecode, 1 + IMM2_SIZE);
2764 if (max == 0) max = INT_MAX;
2765 ecode += 1 + 2 * IMM2_SIZE;
2768 default: /* No repeat follows */
2769 if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2771 if (length == -2) eptr = md->end_subject; /* Partial match */
2773 RRETURN(MATCH_NOMATCH);
2776 continue; /* With the main loop */
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. */
2785 if (length == 0) continue;
2786 if (length < 0 && min == 0) continue;
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. */
2792 for (i = 1; i <= min; i++)
2795 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2797 if (slength == -2) eptr = md->end_subject; /* Partial match */
2799 RRETURN(MATCH_NOMATCH);
2804 /* If min = max, continue at the same level without recursion.
2805 They are not both allowed to be zero. */
2807 if (min == max) continue;
2809 /* If minimizing, keep trying and advancing the pointer */
2813 for (fi = min;; fi++)
2816 RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
2817 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2818 if (fi >= max) RRETURN(MATCH_NOMATCH);
2819 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2821 if (slength == -2) eptr = md->end_subject; /* Partial match */
2823 RRETURN(MATCH_NOMATCH);
2827 /* Control never gets here */
2830 /* If maximizing, find the longest string and work backwards */
2835 for (i = min; i < max; i++)
2838 if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2840 /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2841 the soft partial matching case. */
2843 if (slength == -2 && md->partial != 0 &&
2844 md->end_subject > md->start_used_ptr)
2847 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2856 RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
2857 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2860 RRETURN(MATCH_NOMATCH);
2862 /* Control never gets here */
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
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
2878 /* The data variable is saved across frames, so the byte map needs to
2880 #define BYTE_MAP ((pcre_uint8 *)data)
2881 data = ecode + 1; /* Save for matching */
2882 ecode += 1 + (32 / sizeof(pcre_uchar)); /* Advance past the item */
2895 c = *ecode++ - OP_CRSTAR;
2896 if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
2897 else possessive = TRUE;
2898 min = rep_min[c]; /* Pick up values from tables; */
2899 max = rep_max[c]; /* zero for max => infinity */
2900 if (max == 0) max = INT_MAX;
2906 minimize = (*ecode == OP_CRMINRANGE);
2907 possessive = (*ecode == OP_CRPOSRANGE);
2908 min = GET2(ecode, 1);
2909 max = GET2(ecode, 1 + IMM2_SIZE);
2910 if (max == 0) max = INT_MAX;
2911 ecode += 1 + 2 * IMM2_SIZE;
2914 default: /* No repeat follows */
2919 /* First, ensure the minimum number of matches are present. */
2924 for (i = 1; i <= min; i++)
2926 if (eptr >= md->end_subject)
2929 RRETURN(MATCH_NOMATCH);
2931 GETCHARINC(c, eptr);
2934 if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2937 if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2944 for (i = 1; i <= min; i++)
2946 if (eptr >= md->end_subject)
2949 RRETURN(MATCH_NOMATCH);
2952 #ifndef COMPILE_PCRE8
2955 if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2959 if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2963 /* If max == min we can continue with the main loop without the
2966 if (min == max) continue;
2968 /* If minimizing, keep testing the rest of the expression and advancing
2969 the pointer while it matches the class. */
2976 for (fi = min;; fi++)
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)
2984 RRETURN(MATCH_NOMATCH);
2986 GETCHARINC(c, eptr);
2989 if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2992 if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2999 for (fi = min;; fi++)
3001 RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
3002 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3003 if (fi >= max) RRETURN(MATCH_NOMATCH);
3004 if (eptr >= md->end_subject)
3007 RRETURN(MATCH_NOMATCH);
3010 #ifndef COMPILE_PCRE8
3013 if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
3017 if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
3020 /* Control never gets here */
3023 /* If maximizing, find the longest possible run, then work backwards. */
3032 for (i = min; i < max; i++)
3035 if (eptr >= md->end_subject)
3040 GETCHARLEN(c, eptr, len);
3043 if (op == OP_CLASS) break;
3046 if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3050 if (possessive) continue; /* No backtracking */
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 */
3064 for (i = min; i < max; i++)
3066 if (eptr >= md->end_subject)
3072 #ifndef COMPILE_PCRE8
3075 if (op == OP_CLASS) break;
3079 if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3083 if (possessive) continue; /* No backtracking */
3087 RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
3088 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3093 RRETURN(MATCH_NOMATCH);
3097 /* Control never gets here */
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. */
3105 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3108 data = ecode + 1 + LINK_SIZE; /* Save for matching */
3109 ecode += GET(ecode, 1); /* Advance past the item */
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;
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;
3141 default: /* No repeat follows */
3146 /* First, ensure the minimum number of matches are present. */
3148 for (i = 1; i <= min; i++)
3150 if (eptr >= md->end_subject)
3153 RRETURN(MATCH_NOMATCH);
3155 GETCHARINCTEST(c, eptr);
3156 if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
3159 /* If max == min we can continue with the main loop without the
3162 if (min == max) continue;
3164 /* If minimizing, keep testing the rest of the expression and advancing
3165 the pointer while it matches the class. */
3169 for (fi = min;; fi++)
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)
3177 RRETURN(MATCH_NOMATCH);
3179 GETCHARINCTEST(c, eptr);
3180 if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
3182 /* Control never gets here */
3185 /* If maximizing, find the longest possible run, then work backwards. */
3190 for (i = min; i < max; i++)
3193 if (eptr >= md->end_subject)
3199 GETCHARLENTEST(c, eptr, len);
3203 if (!PRIV(xclass)(c, data, utf)) break;
3207 if (possessive) continue; /* No backtracking */
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 */
3215 if (utf) BACKCHAR(eptr);
3218 RRETURN(MATCH_NOMATCH);
3221 /* Control never gets here */
3223 #endif /* End of XCLASS */
3225 /* Match a single character, casefully */
3233 GETCHARLEN(fc, ecode, length);
3234 if (length > md->end_subject - eptr)
3236 CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
3237 RRETURN(MATCH_NOMATCH);
3239 while (length-- > 0) if (*ecode++ != UCHAR21INC(eptr)) RRETURN(MATCH_NOMATCH);
3245 if (md->end_subject - eptr < 1)
3247 SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
3248 RRETURN(MATCH_NOMATCH);
3250 if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
3255 /* Match a single character, caselessly. If we are at the end of the
3256 subject, give up immediately. */
3259 if (eptr >= md->end_subject)
3262 RRETURN(MATCH_NOMATCH);
3270 GETCHARLEN(fc, ecode, length);
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
3279 pcre_uint32 cc = UCHAR21(eptr);
3280 if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH);
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. */
3292 GETCHARINC(dc, eptr);
3295 /* If we have Unicode property support, we can use it to test the other
3296 case of the character, if there is one. */
3301 if (dc != UCD_OTHERCASE(fc))
3303 RRETURN(MATCH_NOMATCH);
3308 #endif /* SUPPORT_UTF */
3312 if (TABLE_GET(ecode[1], md->lcc, ecode[1])
3313 != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);
3319 /* Match a single character repeatedly. */
3323 min = max = GET2(ecode, 1);
3324 ecode += 1 + IMM2_SIZE;
3337 max = GET2(ecode, 1);
3338 minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
3339 ecode += 1 + IMM2_SIZE;
3378 c = *ecode++ - ((op < OP_STARI)? OP_STAR : OP_STARI);
3379 minimize = (c & 1) != 0;
3380 min = rep_min[c]; /* Pick up values from tables; */
3381 max = rep_max[c]; /* zero for max => infinity */
3382 if (max == 0) max = INT_MAX;
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
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.
3398 The various UTF/non-UTF and caseful/caseless cases are handled separately,
3407 GETCHARLEN(fc, ecode, length);
3410 /* Handle multibyte character matching specially here. There is
3411 support for caseless matching if UCP support is present. */
3416 pcre_uint32 othercase;
3417 if (op >= OP_STARI && /* Caseless */
3418 (othercase = UCD_OTHERCASE(fc)) != fc)
3419 oclength = PRIV(ord2utf)(othercase, occhars);
3421 #endif /* SUPPORT_UCP */
3423 for (i = 1; i <= min; i++)
3425 if (eptr <= md->end_subject - length &&
3426 memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
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 */
3435 RRETURN(MATCH_NOMATCH);
3439 if (min == max) continue;
3443 for (fi = min;; fi++)
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;
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 */
3458 RRETURN(MATCH_NOMATCH);
3461 /* Control never gets here */
3467 for (i = min; i < max; i++)
3469 if (eptr <= md->end_subject - length &&
3470 memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
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 */
3483 if (possessive) continue; /* No backtracking */
3486 if (eptr <= pp) goto TAIL_RECURSE;
3487 RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
3488 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3492 #else /* without SUPPORT_UCP */
3494 #endif /* SUPPORT_UCP */
3497 /* Control never gets here */
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. */
3505 #endif /* SUPPORT_UTF */
3506 /* When not in UTF-8 mode, load a single-byte character. */
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. */
3518 DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3519 max, (char *)eptr));
3521 if (op >= OP_STARI) /* Caseless */
3523 #ifdef COMPILE_PCRE8
3524 /* fc must be < 128 if UTF is enabled. */
3529 if (utf && fc > 127)
3530 foc = UCD_OTHERCASE(fc);
3532 if (utf && fc > 127)
3534 #endif /* SUPPORT_UCP */
3536 #endif /* SUPPORT_UTF */
3537 foc = TABLE_GET(fc, md->fcc, fc);
3538 #endif /* COMPILE_PCRE8 */
3540 for (i = 1; i <= min; i++)
3542 pcre_uint32 cc; /* Faster than pcre_uchar */
3543 if (eptr >= md->end_subject)
3546 RRETURN(MATCH_NOMATCH);
3548 cc = UCHAR21TEST(eptr);
3549 if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3552 if (min == max) continue;
3555 for (fi = min;; fi++)
3557 pcre_uint32 cc; /* Faster than pcre_uchar */
3558 RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3559 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3560 if (fi >= max) RRETURN(MATCH_NOMATCH);
3561 if (eptr >= md->end_subject)
3564 RRETURN(MATCH_NOMATCH);
3566 cc = UCHAR21TEST(eptr);
3567 if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3570 /* Control never gets here */
3575 for (i = min; i < max; i++)
3577 pcre_uint32 cc; /* Faster than pcre_uchar */
3578 if (eptr >= md->end_subject)
3583 cc = UCHAR21TEST(eptr);
3584 if (fc != cc && foc != cc) break;
3587 if (possessive) continue; /* No backtracking */
3590 if (eptr == pp) goto TAIL_RECURSE;
3591 RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
3593 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3595 /* Control never gets here */
3599 /* Caseful comparisons (includes all multi-byte characters) */
3603 for (i = 1; i <= min; i++)
3605 if (eptr >= md->end_subject)
3608 RRETURN(MATCH_NOMATCH);
3610 if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3613 if (min == max) continue;
3617 for (fi = min;; fi++)
3619 RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
3620 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3621 if (fi >= max) RRETURN(MATCH_NOMATCH);
3622 if (eptr >= md->end_subject)
3625 RRETURN(MATCH_NOMATCH);
3627 if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3629 /* Control never gets here */
3634 for (i = min; i < max; i++)
3636 if (eptr >= md->end_subject)
3641 if (fc != UCHAR21TEST(eptr)) break;
3644 if (possessive) continue; /* No backtracking */
3647 if (eptr == pp) goto TAIL_RECURSE;
3648 RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
3650 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3652 /* Control never gets here */
3655 /* Control never gets here */
3657 /* Match a negated single one-byte character. The character we are
3658 checking can be multibyte. */
3662 if (eptr >= md->end_subject)
3665 RRETURN(MATCH_NOMATCH);
3670 register pcre_uint32 ch, och;
3673 GETCHARINC(ch, ecode);
3674 GETCHARINC(c, eptr);
3678 if (ch == c) RRETURN(MATCH_NOMATCH);
3684 och = UCD_OTHERCASE(ch);
3688 #endif /* SUPPORT_UCP */
3690 och = TABLE_GET(ch, md->fcc, ch);
3691 if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3697 register pcre_uint32 ch = ecode[1];
3699 if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3700 RRETURN(MATCH_NOMATCH);
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
3714 min = max = GET2(ecode, 1);
3715 ecode += 1 + IMM2_SIZE;
3721 case OP_NOTMINUPTOI:
3723 max = GET2(ecode, 1);
3724 minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
3725 ecode += 1 + IMM2_SIZE;
3729 case OP_NOTPOSSTARI:
3737 case OP_NOTPOSPLUSI:
3744 case OP_NOTPOSQUERY:
3745 case OP_NOTPOSQUERYI:
3753 case OP_NOTPOSUPTOI:
3756 max = GET2(ecode, 1);
3757 ecode += 1 + IMM2_SIZE;
3763 case OP_NOTMINSTARI:
3767 case OP_NOTMINPLUSI:
3770 case OP_NOTMINQUERY:
3771 case OP_NOTMINQUERYI:
3772 c = *ecode++ - ((op >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
3773 minimize = (c & 1) != 0;
3774 min = rep_min[c]; /* Pick up values from tables; */
3775 max = rep_max[c]; /* zero for max => infinity */
3776 if (max == 0) max = INT_MAX;
3778 /* Common code for all repeated single-byte matches. */
3781 GETCHARINCTEST(fc, ecode);
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. */
3791 DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3792 max, (char *)eptr));
3794 if (op >= OP_NOTSTARI) /* Caseless */
3798 if (utf && fc > 127)
3799 foc = UCD_OTHERCASE(fc);
3801 if (utf && fc > 127)
3803 #endif /* SUPPORT_UCP */
3805 #endif /* SUPPORT_UTF */
3806 foc = TABLE_GET(fc, md->fcc, fc);
3811 register pcre_uint32 d;
3812 for (i = 1; i <= min; i++)
3814 if (eptr >= md->end_subject)
3817 RRETURN(MATCH_NOMATCH);
3819 GETCHARINC(d, eptr);
3820 if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3824 #endif /* SUPPORT_UTF */
3827 for (i = 1; i <= min; i++)
3829 if (eptr >= md->end_subject)
3832 RRETURN(MATCH_NOMATCH);
3834 if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
3839 if (min == max) continue;
3846 register pcre_uint32 d;
3847 for (fi = min;; fi++)
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)
3855 RRETURN(MATCH_NOMATCH);
3857 GETCHARINC(d, eptr);
3858 if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3862 #endif /*SUPPORT_UTF */
3865 for (fi = min;; fi++)
3867 RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
3868 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3869 if (fi >= max) RRETURN(MATCH_NOMATCH);
3870 if (eptr >= md->end_subject)
3873 RRETURN(MATCH_NOMATCH);
3875 if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
3879 /* Control never gets here */
3891 register pcre_uint32 d;
3892 for (i = min; i < max; i++)
3895 if (eptr >= md->end_subject)
3900 GETCHARLEN(d, eptr, len);
3901 if (fc == d || (unsigned int)foc == d) break;
3904 if (possessive) continue; /* No backtracking */
3907 if (eptr <= pp) goto TAIL_RECURSE;
3908 RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
3909 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3915 #endif /* SUPPORT_UTF */
3918 for (i = min; i < max; i++)
3920 if (eptr >= md->end_subject)
3925 if (fc == *eptr || foc == *eptr) break;
3928 if (possessive) continue; /* No backtracking */
3931 if (eptr == pp) goto TAIL_RECURSE;
3932 RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
3933 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3937 /* Control never gets here */
3941 /* Caseful comparisons */
3948 register pcre_uint32 d;
3949 for (i = 1; i <= min; i++)
3951 if (eptr >= md->end_subject)
3954 RRETURN(MATCH_NOMATCH);
3956 GETCHARINC(d, eptr);
3957 if (fc == d) RRETURN(MATCH_NOMATCH);
3964 for (i = 1; i <= min; i++)
3966 if (eptr >= md->end_subject)
3969 RRETURN(MATCH_NOMATCH);
3971 if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3975 if (min == max) continue;
3982 register pcre_uint32 d;
3983 for (fi = min;; fi++)
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)
3991 RRETURN(MATCH_NOMATCH);
3993 GETCHARINC(d, eptr);
3994 if (fc == d) RRETURN(MATCH_NOMATCH);
4001 for (fi = min;; fi++)
4003 RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
4004 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4005 if (fi >= max) RRETURN(MATCH_NOMATCH);
4006 if (eptr >= md->end_subject)
4009 RRETURN(MATCH_NOMATCH);
4011 if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
4014 /* Control never gets here */
4026 register pcre_uint32 d;
4027 for (i = min; i < max; i++)
4030 if (eptr >= md->end_subject)
4035 GETCHARLEN(d, eptr, len);
4039 if (possessive) continue; /* No backtracking */
4042 if (eptr <= pp) goto TAIL_RECURSE;
4043 RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
4044 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4053 for (i = min; i < max; i++)
4055 if (eptr >= md->end_subject)
4060 if (fc == *eptr) break;
4063 if (possessive) continue; /* No backtracking */
4066 if (eptr == pp) goto TAIL_RECURSE;
4067 RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
4068 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4072 /* Control never gets here */
4075 /* Control never gets here */
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. */
4082 min = max = GET2(ecode, 1);
4084 ecode += 1 + IMM2_SIZE;
4088 case OP_TYPEMINUPTO:
4090 max = GET2(ecode, 1);
4091 minimize = *ecode == OP_TYPEMINUPTO;
4092 ecode += 1 + IMM2_SIZE;
4095 case OP_TYPEPOSSTAR:
4102 case OP_TYPEPOSPLUS:
4109 case OP_TYPEPOSQUERY:
4116 case OP_TYPEPOSUPTO:
4119 max = GET2(ecode, 1);
4120 ecode += 1 + IMM2_SIZE;
4124 case OP_TYPEMINSTAR:
4126 case OP_TYPEMINPLUS:
4128 case OP_TYPEMINQUERY:
4129 c = *ecode++ - OP_TYPESTAR;
4130 minimize = (c & 1) != 0;
4131 min = rep_min[c]; /* Pick up values from tables; */
4132 max = rep_max[c]; /* zero for max => infinity */
4133 if (max == 0) max = INT_MAX;
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. */
4140 ctype = *ecode++; /* Code for the character type */
4143 if (ctype == OP_PROP || ctype == OP_NOTPROP)
4145 prop_fail_result = ctype == OP_NOTPROP;
4146 prop_type = *ecode++;
4147 prop_value = *ecode++;
4149 else prop_type = -1;
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. */
4166 if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4167 for (i = 1; i <= min; i++)
4169 if (eptr >= md->end_subject)
4172 RRETURN(MATCH_NOMATCH);
4174 GETCHARINCTEST(c, eptr);
4179 for (i = 1; i <= min; i++)
4182 if (eptr >= md->end_subject)
4185 RRETURN(MATCH_NOMATCH);
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);
4197 for (i = 1; i <= min; i++)
4199 if (eptr >= md->end_subject)
4202 RRETURN(MATCH_NOMATCH);
4204 GETCHARINCTEST(c, eptr);
4205 if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
4206 RRETURN(MATCH_NOMATCH);
4211 for (i = 1; i <= min; i++)
4213 if (eptr >= md->end_subject)
4216 RRETURN(MATCH_NOMATCH);
4218 GETCHARINCTEST(c, eptr);
4219 if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
4220 RRETURN(MATCH_NOMATCH);
4225 for (i = 1; i <= min; i++)
4227 if (eptr >= md->end_subject)
4230 RRETURN(MATCH_NOMATCH);
4232 GETCHARINCTEST(c, eptr);
4233 if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
4234 RRETURN(MATCH_NOMATCH);
4239 for (i = 1; i <= min; i++)
4242 if (eptr >= md->end_subject)
4245 RRETURN(MATCH_NOMATCH);
4247 GETCHARINCTEST(c, eptr);
4248 category = UCD_CATEGORY(c);
4249 if ((category == ucp_L || category == ucp_N) == prop_fail_result)
4250 RRETURN(MATCH_NOMATCH);
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. */
4258 case PT_SPACE: /* Perl space */
4259 case PT_PXSPACE: /* POSIX space */
4260 for (i = 1; i <= min; i++)
4262 if (eptr >= md->end_subject)
4265 RRETURN(MATCH_NOMATCH);
4267 GETCHARINCTEST(c, eptr);
4272 if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4276 if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
4277 RRETURN(MATCH_NOMATCH);
4284 for (i = 1; i <= min; i++)
4287 if (eptr >= md->end_subject)
4290 RRETURN(MATCH_NOMATCH);
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);
4301 for (i = 1; i <= min; i++)
4303 const pcre_uint32 *cp;
4304 if (eptr >= md->end_subject)
4307 RRETURN(MATCH_NOMATCH);
4309 GETCHARINCTEST(c, eptr);
4310 cp = PRIV(ucd_caseless_sets) + prop_value;
4314 { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4316 { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4322 for (i = 1; i <= min; i++)
4324 if (eptr >= md->end_subject)
4327 RRETURN(MATCH_NOMATCH);
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);
4337 /* This should not occur */
4340 RRETURN(PCRE_ERROR_INTERNAL);
4344 /* Match extended Unicode sequences. We will get here only if the
4345 support is in the binary; otherwise a compile-time error occurs. */
4347 else if (ctype == OP_EXTUNI)
4349 for (i = 1; i <= min; i++)
4351 if (eptr >= md->end_subject)
4354 RRETURN(MATCH_NOMATCH);
4359 GETCHARINCTEST(c, eptr);
4360 lgb = UCD_GRAPHBREAK(c);
4361 while (eptr < md->end_subject)
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;
4376 #endif /* SUPPORT_UCP */
4378 /* Handle all other cases when the coding is UTF-8 */
4381 if (utf) switch(ctype)
4384 for (i = 1; i <= min; i++)
4386 if (eptr >= md->end_subject)
4389 RRETURN(MATCH_NOMATCH);
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])
4399 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4402 ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4407 for (i = 1; i <= min; i++)
4409 if (eptr >= md->end_subject)
4412 RRETURN(MATCH_NOMATCH);
4415 ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4420 if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
4425 for (i = 1; i <= min; i++)
4427 if (eptr >= md->end_subject)
4430 RRETURN(MATCH_NOMATCH);
4432 GETCHARINC(c, eptr);
4435 default: RRETURN(MATCH_NOMATCH);
4438 if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++;
4450 #endif /* Not EBCDIC */
4451 if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4458 for (i = 1; i <= min; i++)
4460 if (eptr >= md->end_subject)
4463 RRETURN(MATCH_NOMATCH);
4465 GETCHARINC(c, eptr);
4468 HSPACE_CASES: RRETURN(MATCH_NOMATCH); /* Byte and multibyte cases */
4475 for (i = 1; i <= min; i++)
4477 if (eptr >= md->end_subject)
4480 RRETURN(MATCH_NOMATCH);
4482 GETCHARINC(c, eptr);
4485 HSPACE_CASES: break; /* Byte and multibyte cases */
4486 default: RRETURN(MATCH_NOMATCH);
4492 for (i = 1; i <= min; i++)
4494 if (eptr >= md->end_subject)
4497 RRETURN(MATCH_NOMATCH);
4499 GETCHARINC(c, eptr);
4502 VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4509 for (i = 1; i <= min; i++)
4511 if (eptr >= md->end_subject)
4514 RRETURN(MATCH_NOMATCH);
4516 GETCHARINC(c, eptr);
4519 VSPACE_CASES: break;
4520 default: RRETURN(MATCH_NOMATCH);
4526 for (i = 1; i <= min; i++)
4528 if (eptr >= md->end_subject)
4531 RRETURN(MATCH_NOMATCH);
4533 GETCHARINC(c, eptr);
4534 if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
4535 RRETURN(MATCH_NOMATCH);
4540 for (i = 1; i <= min; i++)
4543 if (eptr >= md->end_subject)
4546 RRETURN(MATCH_NOMATCH);
4549 if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0)
4550 RRETURN(MATCH_NOMATCH);
4552 /* No need to skip more bytes - we know it's a 1-byte character */
4556 case OP_NOT_WHITESPACE:
4557 for (i = 1; i <= min; i++)
4560 if (eptr >= md->end_subject)
4563 RRETURN(MATCH_NOMATCH);
4566 if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0)
4567 RRETURN(MATCH_NOMATCH);
4569 ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4574 for (i = 1; i <= min; i++)
4577 if (eptr >= md->end_subject)
4580 RRETURN(MATCH_NOMATCH);
4583 if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0)
4584 RRETURN(MATCH_NOMATCH);
4586 /* No need to skip more bytes - we know it's a 1-byte character */
4590 case OP_NOT_WORDCHAR:
4591 for (i = 1; i <= min; i++)
4594 if (eptr >= md->end_subject)
4597 RRETURN(MATCH_NOMATCH);
4600 if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0)
4601 RRETURN(MATCH_NOMATCH);
4603 ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4608 for (i = 1; i <= min; i++)
4611 if (eptr >= md->end_subject)
4614 RRETURN(MATCH_NOMATCH);
4617 if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0)
4618 RRETURN(MATCH_NOMATCH);
4620 /* No need to skip more bytes - we know it's a 1-byte character */
4625 RRETURN(PCRE_ERROR_INTERNAL);
4626 } /* End switch(ctype) */
4629 #endif /* SUPPORT_UTF */
4631 /* Code for the non-UTF-8 case for minimum matching of operators other
4632 than OP_PROP and OP_NOTPROP. */
4637 for (i = 1; i <= min; i++)
4639 if (eptr >= md->end_subject)
4642 RRETURN(MATCH_NOMATCH);
4644 if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4645 if (md->partial != 0 &&
4646 eptr + 1 >= md->end_subject &&
4647 NLBLOCK->nltype == NLTYPE_FIXED &&
4648 NLBLOCK->nllen == 2 &&
4649 *eptr == NLBLOCK->nl[0])
4652 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4659 if (eptr > md->end_subject - min)
4662 RRETURN(MATCH_NOMATCH);
4668 if (eptr > md->end_subject - min)
4671 RRETURN(MATCH_NOMATCH);
4677 for (i = 1; i <= min; i++)
4679 if (eptr >= md->end_subject)
4682 RRETURN(MATCH_NOMATCH);
4686 default: RRETURN(MATCH_NOMATCH);
4689 if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4698 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4702 if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4709 for (i = 1; i <= min; i++)
4711 if (eptr >= md->end_subject)
4714 RRETURN(MATCH_NOMATCH);
4720 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4721 HSPACE_MULTIBYTE_CASES:
4723 RRETURN(MATCH_NOMATCH);
4729 for (i = 1; i <= min; i++)
4731 if (eptr >= md->end_subject)
4734 RRETURN(MATCH_NOMATCH);
4738 default: RRETURN(MATCH_NOMATCH);
4740 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4741 HSPACE_MULTIBYTE_CASES:
4749 for (i = 1; i <= min; i++)
4751 if (eptr >= md->end_subject)
4754 RRETURN(MATCH_NOMATCH);
4759 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4760 VSPACE_MULTIBYTE_CASES:
4762 RRETURN(MATCH_NOMATCH);
4769 for (i = 1; i <= min; i++)
4771 if (eptr >= md->end_subject)
4774 RRETURN(MATCH_NOMATCH);
4778 default: RRETURN(MATCH_NOMATCH);
4780 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4781 VSPACE_MULTIBYTE_CASES:
4789 for (i = 1; i <= min; i++)
4791 if (eptr >= md->end_subject)
4794 RRETURN(MATCH_NOMATCH);
4796 if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0)
4797 RRETURN(MATCH_NOMATCH);
4803 for (i = 1; i <= min; i++)
4805 if (eptr >= md->end_subject)
4808 RRETURN(MATCH_NOMATCH);
4810 if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0)
4811 RRETURN(MATCH_NOMATCH);
4816 case OP_NOT_WHITESPACE:
4817 for (i = 1; i <= min; i++)
4819 if (eptr >= md->end_subject)
4822 RRETURN(MATCH_NOMATCH);
4824 if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0)
4825 RRETURN(MATCH_NOMATCH);
4831 for (i = 1; i <= min; i++)
4833 if (eptr >= md->end_subject)
4836 RRETURN(MATCH_NOMATCH);
4838 if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0)
4839 RRETURN(MATCH_NOMATCH);
4844 case OP_NOT_WORDCHAR:
4845 for (i = 1; i <= min; i++)
4847 if (eptr >= md->end_subject)
4850 RRETURN(MATCH_NOMATCH);
4852 if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0)
4853 RRETURN(MATCH_NOMATCH);
4859 for (i = 1; i <= min; i++)
4861 if (eptr >= md->end_subject)
4864 RRETURN(MATCH_NOMATCH);
4866 if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0)
4867 RRETURN(MATCH_NOMATCH);
4873 RRETURN(PCRE_ERROR_INTERNAL);
4877 /* If min = max, continue at the same level without recursing */
4879 if (min == max) continue;
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. */
4893 for (fi = min;; fi++)
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)
4901 RRETURN(MATCH_NOMATCH);
4903 GETCHARINCTEST(c, eptr);
4904 if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4906 /* Control never gets here */
4909 for (fi = min;; fi++)
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)
4918 RRETURN(MATCH_NOMATCH);
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);
4927 /* Control never gets here */
4930 for (fi = min;; fi++)
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)
4938 RRETURN(MATCH_NOMATCH);
4940 GETCHARINCTEST(c, eptr);
4941 if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
4942 RRETURN(MATCH_NOMATCH);
4944 /* Control never gets here */
4947 for (fi = min;; fi++)
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)
4955 RRETURN(MATCH_NOMATCH);
4957 GETCHARINCTEST(c, eptr);
4958 if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
4959 RRETURN(MATCH_NOMATCH);
4961 /* Control never gets here */
4964 for (fi = min;; fi++)
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)
4972 RRETURN(MATCH_NOMATCH);
4974 GETCHARINCTEST(c, eptr);
4975 if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
4976 RRETURN(MATCH_NOMATCH);
4978 /* Control never gets here */
4981 for (fi = min;; fi++)
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)
4990 RRETURN(MATCH_NOMATCH);
4992 GETCHARINCTEST(c, eptr);
4993 category = UCD_CATEGORY(c);
4994 if ((category == ucp_L || category == ucp_N) == prop_fail_result)
4995 RRETURN(MATCH_NOMATCH);
4997 /* Control never gets here */
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. */
5003 case PT_SPACE: /* Perl space */
5004 case PT_PXSPACE: /* POSIX space */
5005 for (fi = min;; fi++)
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)
5013 RRETURN(MATCH_NOMATCH);
5015 GETCHARINCTEST(c, eptr);
5020 if (prop_fail_result) RRETURN(MATCH_NOMATCH);
5024 if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5025 RRETURN(MATCH_NOMATCH);
5029 /* Control never gets here */
5032 for (fi = min;; fi++)
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)
5041 RRETURN(MATCH_NOMATCH);
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);
5051 /* Control never gets here */
5054 for (fi = min;; fi++)
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)
5063 RRETURN(MATCH_NOMATCH);
5065 GETCHARINCTEST(c, eptr);
5066 cp = PRIV(ucd_caseless_sets) + prop_value;
5070 { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
5072 { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
5075 /* Control never gets here */
5078 for (fi = min;; fi++)
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)
5086 RRETURN(MATCH_NOMATCH);
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);
5094 /* Control never gets here */
5096 /* This should never occur */
5098 RRETURN(PCRE_ERROR_INTERNAL);
5102 /* Match extended Unicode sequences. We will get here only if the
5103 support is in the binary; otherwise a compile-time error occurs. */
5105 else if (ctype == OP_EXTUNI)
5107 for (fi = min;; fi++)
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)
5115 RRETURN(MATCH_NOMATCH);
5120 GETCHARINCTEST(c, eptr);
5121 lgb = UCD_GRAPHBREAK(c);
5122 while (eptr < md->end_subject)
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;
5136 #endif /* SUPPORT_UCP */
5141 for (fi = min;; fi++)
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)
5149 RRETURN(MATCH_NOMATCH);
5151 if (ctype == OP_ANY && IS_NEWLINE(eptr))
5152 RRETURN(MATCH_NOMATCH);
5153 GETCHARINC(c, eptr);
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])
5164 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5175 default: RRETURN(MATCH_NOMATCH);
5177 if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++;
5189 #endif /* Not EBCDIC */
5190 if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5198 HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5206 HSPACE_CASES: break;
5207 default: RRETURN(MATCH_NOMATCH);
5214 VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5222 VSPACE_CASES: break;
5223 default: RRETURN(MATCH_NOMATCH);
5228 if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
5229 RRETURN(MATCH_NOMATCH);
5233 if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
5234 RRETURN(MATCH_NOMATCH);
5237 case OP_NOT_WHITESPACE:
5238 if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
5239 RRETURN(MATCH_NOMATCH);
5243 if (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
5244 RRETURN(MATCH_NOMATCH);
5247 case OP_NOT_WORDCHAR:
5248 if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
5249 RRETURN(MATCH_NOMATCH);
5253 if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
5254 RRETURN(MATCH_NOMATCH);
5258 RRETURN(PCRE_ERROR_INTERNAL);
5266 for (fi = min;; fi++)
5268 RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);
5269 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5270 if (fi >= max) RRETURN(MATCH_NOMATCH);
5271 if (eptr >= md->end_subject)
5274 RRETURN(MATCH_NOMATCH);
5276 if (ctype == OP_ANY && IS_NEWLINE(eptr))
5277 RRETURN(MATCH_NOMATCH);
5281 case OP_ANY: /* This is the non-NL case */
5282 if (md->partial != 0 && /* Take care with CRLF partial */
5283 eptr >= md->end_subject &&
5284 NLBLOCK->nltype == NLTYPE_FIXED &&
5285 NLBLOCK->nllen == 2 &&
5286 c == NLBLOCK->nl[0])
5289 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5300 default: RRETURN(MATCH_NOMATCH);
5302 if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5311 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5315 if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5325 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5326 HSPACE_MULTIBYTE_CASES:
5328 RRETURN(MATCH_NOMATCH);
5335 default: RRETURN(MATCH_NOMATCH);
5337 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5338 HSPACE_MULTIBYTE_CASES:
5349 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5350 VSPACE_MULTIBYTE_CASES:
5352 RRETURN(MATCH_NOMATCH);
5359 default: RRETURN(MATCH_NOMATCH);
5361 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5362 VSPACE_MULTIBYTE_CASES:
5369 if (MAX_255(c) && (md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
5373 if (!MAX_255(c) || (md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
5376 case OP_NOT_WHITESPACE:
5377 if (MAX_255(c) && (md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
5381 if (!MAX_255(c) || (md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
5384 case OP_NOT_WORDCHAR:
5385 if (MAX_255(c) && (md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
5389 if (!MAX_255(c) || (md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
5393 RRETURN(PCRE_ERROR_INTERNAL);
5397 /* Control never gets here */
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. */
5406 pp = eptr; /* Remember where we started */
5414 for (i = min; i < max; i++)
5417 if (eptr >= md->end_subject)
5422 GETCHARLENTEST(c, eptr, len);
5423 if (prop_fail_result) break;
5429 for (i = min; i < max; i++)
5433 if (eptr >= md->end_subject)
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)
5449 for (i = min; i < max; i++)
5452 if (eptr >= md->end_subject)
5457 GETCHARLENTEST(c, eptr, len);
5458 if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result) break;
5464 for (i = min; i < max; i++)
5467 if (eptr >= md->end_subject)
5472 GETCHARLENTEST(c, eptr, len);
5473 if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result) break;
5479 for (i = min; i < max; i++)
5482 if (eptr >= md->end_subject)
5487 GETCHARLENTEST(c, eptr, len);
5488 if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result) break;
5494 for (i = min; i < max; i++)
5498 if (eptr >= md->end_subject)
5503 GETCHARLENTEST(c, eptr, len);
5504 category = UCD_CATEGORY(c);
5505 if ((category == ucp_L || category == ucp_N) == prop_fail_result)
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. */
5515 case PT_SPACE: /* Perl space */
5516 case PT_PXSPACE: /* POSIX space */
5517 for (i = min; i < max; i++)
5520 if (eptr >= md->end_subject)
5525 GETCHARLENTEST(c, eptr, len);
5530 if (prop_fail_result) goto ENDLOOP99; /* Break the loop */
5534 if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5535 goto ENDLOOP99; /* Break the loop */
5544 for (i = min; i < max; i++)
5548 if (eptr >= md->end_subject)
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)
5563 for (i = min; i < max; i++)
5565 const pcre_uint32 *cp;
5567 if (eptr >= md->end_subject)
5572 GETCHARLENTEST(c, eptr, len);
5573 cp = PRIV(ucd_caseless_sets) + prop_value;
5577 { if (prop_fail_result) break; else goto GOT_MAX; }
5579 { if (prop_fail_result) goto GOT_MAX; else break; }
5587 for (i = min; i < max; i++)
5590 if (eptr >= md->end_subject)
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)
5605 RRETURN(PCRE_ERROR_INTERNAL);
5608 /* eptr is now past the end of the maximum run */
5610 if (possessive) continue; /* No backtracking */
5613 if (eptr <= pp) goto TAIL_RECURSE;
5614 RMATCH(eptr, ecode, offset_top, md, eptrb, RM44);
5615 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5617 if (utf) BACKCHAR(eptr);
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. */
5624 else if (ctype == OP_EXTUNI)
5626 for (i = min; i < max; i++)
5628 if (eptr >= md->end_subject)
5636 GETCHARINCTEST(c, eptr);
5637 lgb = UCD_GRAPHBREAK(c);
5638 while (eptr < md->end_subject)
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;
5651 /* eptr is now past the end of the maximum run */
5653 if (possessive) continue; /* No backtracking */
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. */
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);
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. */
5674 if (!utf) c = *eptr; else
5679 rgb = UCD_GRAPHBREAK(c);
5683 if (eptr <= pp) goto TAIL_RECURSE; /* At start of char run */
5685 if (!utf) c = *fptr; else
5690 lgb = UCD_GRAPHBREAK(c);
5691 if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5699 #endif /* SUPPORT_UCP */
5707 for (i = min; i < max; i++)
5709 if (eptr >= md->end_subject)
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])
5722 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5725 ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5732 for (i = min; i < max; i++)
5734 if (eptr >= md->end_subject)
5740 ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5745 eptr = md->end_subject; /* Unlimited UTF-8 repeat */
5750 /* The byte case is the same as non-UTF8 */
5754 if (c > (unsigned int)(md->end_subject - eptr))
5756 eptr = md->end_subject;
5763 for (i = min; i < max; i++)
5766 if (eptr >= md->end_subject)
5771 GETCHARLEN(c, eptr, len);
5774 if (++eptr >= md->end_subject) break;
5775 if (UCHAR21(eptr) == CHAR_LF) eptr++;
5781 (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5783 && c != 0x2028 && c != 0x2029
5784 #endif /* Not EBCDIC */
5794 for (i = min; i < max; i++)
5798 if (eptr >= md->end_subject)
5803 GETCHARLEN(c, eptr, len);
5806 HSPACE_CASES: gotspace = TRUE; break;
5807 default: gotspace = FALSE; break;
5809 if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5816 for (i = min; i < max; i++)
5820 if (eptr >= md->end_subject)
5825 GETCHARLEN(c, eptr, len);
5828 VSPACE_CASES: gotspace = TRUE; break;
5829 default: gotspace = FALSE; break;
5831 if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5837 for (i = min; i < max; i++)
5840 if (eptr >= md->end_subject)
5845 GETCHARLEN(c, eptr, len);
5846 if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
5852 for (i = min; i < max; i++)
5855 if (eptr >= md->end_subject)
5860 GETCHARLEN(c, eptr, len);
5861 if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
5866 case OP_NOT_WHITESPACE:
5867 for (i = min; i < max; i++)
5870 if (eptr >= md->end_subject)
5875 GETCHARLEN(c, eptr, len);
5876 if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
5882 for (i = min; i < max; i++)
5885 if (eptr >= md->end_subject)
5890 GETCHARLEN(c, eptr, len);
5891 if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
5896 case OP_NOT_WORDCHAR:
5897 for (i = min; i < max; i++)
5900 if (eptr >= md->end_subject)
5905 GETCHARLEN(c, eptr, len);
5906 if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
5912 for (i = min; i < max; i++)
5915 if (eptr >= md->end_subject)
5920 GETCHARLEN(c, eptr, len);
5921 if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
5927 RRETURN(PCRE_ERROR_INTERNAL);
5930 if (possessive) continue; /* No backtracking */
5933 if (eptr <= pp) goto TAIL_RECURSE;
5934 RMATCH(eptr, ecode, offset_top, md, eptrb, RM46);
5935 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5938 if (ctype == OP_ANYNL && eptr > pp && UCHAR21(eptr) == CHAR_NL &&
5939 UCHAR21(eptr - 1) == CHAR_CR) eptr--;
5943 #endif /* SUPPORT_UTF */
5949 for (i = min; i < max; i++)
5951 if (eptr >= md->end_subject)
5956 if (IS_NEWLINE(eptr)) break;
5957 if (md->partial != 0 && /* Take care with CRLF partial */
5958 eptr + 1 >= md->end_subject &&
5959 NLBLOCK->nltype == NLTYPE_FIXED &&
5960 NLBLOCK->nllen == 2 &&
5961 *eptr == NLBLOCK->nl[0])
5964 if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5973 if (c > (unsigned int)(md->end_subject - eptr))
5975 eptr = md->end_subject;
5982 for (i = min; i < max; i++)
5984 if (eptr >= md->end_subject)
5992 if (++eptr >= md->end_subject) break;
5993 if (*eptr == CHAR_LF) eptr++;
5997 if (c != CHAR_LF && (md->bsr_anycrlf ||
5998 (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5999 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6000 && c != 0x2028 && c != 0x2029
6009 for (i = min; i < max; i++)
6011 if (eptr >= md->end_subject)
6018 default: eptr++; break;
6020 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6021 HSPACE_MULTIBYTE_CASES:
6030 for (i = min; i < max; i++)
6032 if (eptr >= md->end_subject)
6039 default: goto ENDLOOP01;
6041 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6042 HSPACE_MULTIBYTE_CASES:
6051 for (i = min; i < max; i++)
6053 if (eptr >= md->end_subject)
6060 default: eptr++; break;
6062 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6063 VSPACE_MULTIBYTE_CASES:
6072 for (i = min; i < max; i++)
6074 if (eptr >= md->end_subject)
6081 default: goto ENDLOOP03;
6083 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6084 VSPACE_MULTIBYTE_CASES:
6093 for (i = min; i < max; i++)
6095 if (eptr >= md->end_subject)
6100 if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0) break;
6106 for (i = min; i < max; i++)
6108 if (eptr >= md->end_subject)
6113 if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0) break;
6118 case OP_NOT_WHITESPACE:
6119 for (i = min; i < max; i++)
6121 if (eptr >= md->end_subject)
6126 if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0) break;
6132 for (i = min; i < max; i++)
6134 if (eptr >= md->end_subject)
6139 if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0) break;
6144 case OP_NOT_WORDCHAR:
6145 for (i = min; i < max; i++)
6147 if (eptr >= md->end_subject)
6152 if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0) break;
6158 for (i = min; i < max; i++)
6160 if (eptr >= md->end_subject)
6165 if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0) break;
6171 RRETURN(PCRE_ERROR_INTERNAL);
6174 if (possessive) continue; /* No backtracking */
6177 if (eptr == pp) goto TAIL_RECURSE;
6178 RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6179 if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6181 if (ctype == OP_ANYNL && eptr > pp && *eptr == CHAR_LF &&
6182 eptr[-1] == CHAR_CR) eptr--;
6186 /* Control never gets here */
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. */
6193 DPRINTF(("Unknown opcode %d\n", *ecode));
6194 RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
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
6201 } /* End of main loop */
6202 /* Control never reaches here */
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. */
6210 #define LBL(val) case val: goto L_RM##val;
6212 switch (frame->Xwhere)
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)
6220 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
6225 LBL(22) LBL(23) LBL(28) LBL(30)
6226 LBL(32) LBL(34) LBL(42) LBL(46)
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 */
6233 DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
6234 return PCRE_ERROR_INTERNAL;
6237 #endif /* NO_RECURSE */
6241 /***************************************************************************
6242 ****************************************************************************
6243 RECURSION IN THE match() FUNCTION
6245 Undefine all the macros that were defined above to handle this. */
6263 #undef new_recursive
6276 #undef save_capture_last
6286 /* These two are defined as macros in both cases */
6291 /***************************************************************************
6292 ***************************************************************************/
6296 /*************************************************
6297 * Release allocated heap frames *
6298 *************************************************/
6300 /* This function releases all the allocated frames. The base frame is on the
6301 machine stack, and so must not be freed.
6303 Argument: the address of the base frame
6308 release_match_heapframes (heapframe *frame_base)
6310 heapframe *nextframe = frame_base->Xnextframe;
6311 while (nextframe != NULL)
6313 heapframe *oldframe = nextframe;
6314 nextframe = nextframe->Xnextframe;
6315 (PUBL(stack_free))(oldframe);
6321 /*************************************************
6322 * Execute a Regular Expression *
6323 *************************************************/
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.
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
6336 offsets points to a vector of ints to be filled in with offsets
6337 offsetcount the number of elements in the vector
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
6345 #if defined COMPILE_PCRE8
6346 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6347 pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
6348 PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
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,
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,
6362 int rc, ocount, arg_offset_max;
6364 BOOL using_temporary_offsets = FALSE;
6369 BOOL has_first_char = FALSE;
6370 BOOL has_req_char = FALSE;
6371 pcre_uchar first_char = 0;
6372 pcre_uchar first_char2 = 0;
6373 pcre_uchar req_char = 0;
6374 pcre_uchar req_char2 = 0;
6375 match_data match_block;
6376 match_data *md = &match_block;
6377 const pcre_uint8 *tables;
6378 const pcre_uint8 *start_bits = NULL;
6379 PCRE_PUCHAR start_match = (PCRE_PUCHAR)subject + start_offset;
6380 PCRE_PUCHAR end_subject;
6381 PCRE_PUCHAR start_partial = NULL;
6382 PCRE_PUCHAR match_partial = NULL;
6383 PCRE_PUCHAR req_char_ptr = start_match - 1;
6385 const pcre_study_data *study;
6386 const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
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;
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. */
6400 if (re == NULL && extra_data == NULL && subject == NULL && length == -999 &&
6401 start_offset == -999)
6403 return -((int)sizeof(heapframe));
6405 return match(NULL, NULL, NULL, 0, NULL, NULL, 0);
6408 /* Plausibility checks */
6410 if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
6411 if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
6412 return PCRE_ERROR_NULL;
6413 if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
6414 if (length < 0) return PCRE_ERROR_BADLENGTH;
6415 if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
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. */
6422 if (re->magic_number != MAGIC_NUMBER)
6423 return re->magic_number == REVERSED_MAGIC_NUMBER?
6424 PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
6425 if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
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. */
6432 /* PCRE_UTF16 has the same value as PCRE_UTF8. */
6433 utf = md->utf = (re->options & PCRE_UTF8) != 0;
6434 md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
6435 ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
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. */
6441 if (utf && (options & PCRE_NO_UTF8_CHECK) == 0)
6444 int errorcode = PRIV(valid_utf)((PCRE_PUCHAR)subject, length, &erroroffset);
6447 if (offsetcount >= 2)
6449 offsets[0] = erroroffset;
6450 offsets[1] = errorcode;
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;
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;
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. */
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)
6483 rc = PRIV(jit_exec)(extra_data, (const pcre_uchar *)subject, length,
6484 start_offset, options, offsets, offsetcount);
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. */
6489 if (rc != PCRE_ERROR_JIT_BADOPTION) return rc;
6493 /* Carry on with non-JIT matching. This information is for finding all the
6494 numbers associated with a given name, for condition testing. */
6496 md->name_table = (pcre_uchar *)re + re->name_table_offset;
6497 md->name_count = re->name_count;
6498 md->name_entry_size = re->name_entry_size;
6500 /* Fish out the optional data from the extra_data structure, first setting
6501 the default values. */
6504 md->match_limit = MATCH_LIMIT;
6505 md->match_limit_recursion = MATCH_LIMIT_RECURSION;
6506 md->callout_data = NULL;
6508 /* The table pointer is always in native byte order. */
6510 tables = re->tables;
6512 /* The two limit values override the defaults, whatever their value. */
6514 if (extra_data != NULL)
6516 unsigned long int flags = extra_data->flags;
6517 if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
6518 study = (const pcre_study_data *)extra_data->study_data;
6519 if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
6520 md->match_limit = extra_data->match_limit;
6521 if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
6522 md->match_limit_recursion = extra_data->match_limit_recursion;
6523 if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
6524 md->callout_data = extra_data->callout_data;
6525 if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
6528 /* Limits in the regex override only if they are smaller. */
6530 if ((re->flags & PCRE_MLSET) != 0 && re->limit_match < md->match_limit)
6531 md->match_limit = re->limit_match;
6533 if ((re->flags & PCRE_RLSET) != 0 &&
6534 re->limit_recursion < md->match_limit_recursion)
6535 md->match_limit_recursion = re->limit_recursion;
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. */
6541 if (tables == NULL) tables = PRIV(default_tables);
6543 /* Set up other data */
6545 anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
6546 startline = (re->flags & PCRE_STARTLINE) != 0;
6547 firstline = (re->options & PCRE_FIRSTLINE) != 0;
6549 /* The code starts after the real_pcre block and the capture name table. */
6551 md->start_code = (const pcre_uchar *)re + re->name_table_offset +
6552 re->name_count * re->name_entry_size;
6554 md->start_subject = (PCRE_PUCHAR)subject;
6555 md->start_offset = start_offset;
6556 md->end_subject = md->start_subject + length;
6557 end_subject = md->end_subject;
6559 md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
6560 md->use_ucp = (re->options & PCRE_UCP) != 0;
6561 md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
6562 md->ignore_skip_arg = 0;
6564 /* Some options are unpacked into BOOL variables in the hope that testing
6565 them will be faster than individual option bits. */
6567 md->notbol = (options & PCRE_NOTBOL) != 0;
6568 md->noteol = (options & PCRE_NOTEOL) != 0;
6569 md->notempty = (options & PCRE_NOTEMPTY) != 0;
6570 md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
6573 md->mark = md->nomatch_mark = NULL; /* In case never set */
6575 md->recursive = NULL; /* No recursion at top level */
6576 md->hasthen = (re->flags & PCRE_HASTHEN) != 0;
6578 md->lcc = tables + lcc_offset;
6579 md->fcc = tables + fcc_offset;
6580 md->ctypes = tables + ctypes_offset;
6582 /* Handle different \R options. */
6584 switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
6587 if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
6588 md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
6591 md->bsr_anycrlf = TRUE;
6593 md->bsr_anycrlf = FALSE;
6597 case PCRE_BSR_ANYCRLF:
6598 md->bsr_anycrlf = TRUE;
6601 case PCRE_BSR_UNICODE:
6602 md->bsr_anycrlf = FALSE;
6605 default: return PCRE_ERROR_BADNEWLINE;
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. */
6611 switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
6612 (pcre_uint32)options) & PCRE_NEWLINE_BITS)
6614 case 0: newline = NEWLINE; break; /* Compile-time default */
6615 case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
6616 case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
6617 case PCRE_NEWLINE_CR+
6618 PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
6619 case PCRE_NEWLINE_ANY: newline = -1; break;
6620 case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
6621 default: return PCRE_ERROR_BADNEWLINE;
6626 md->nltype = NLTYPE_ANYCRLF;
6628 else if (newline < 0)
6630 md->nltype = NLTYPE_ANY;
6634 md->nltype = NLTYPE_FIXED;
6638 md->nl[0] = (newline >> 8) & 255;
6639 md->nl[1] = newline & 255;
6644 md->nl[0] = newline;
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. */
6652 if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
6653 return PCRE_ERROR_BADPARTIAL;
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
6660 ocount = offsetcount - (offsetcount % 3);
6661 arg_offset_max = (2*ocount)/3;
6663 if (re->top_backref > 0 && re->top_backref >= ocount/3)
6665 ocount = re->top_backref * 3 + 3;
6666 md->offset_vector = (int *)(PUBL(malloc))(ocount * sizeof(int));
6667 if (md->offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
6668 using_temporary_offsets = TRUE;
6669 DPRINTF(("Got memory to hold back references\n"));
6671 else md->offset_vector = offsets;
6672 md->offset_end = ocount;
6673 md->offset_max = (2*ocount)/3;
6674 md->capture_last = 0;
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. */
6682 if (md->offset_vector != NULL)
6684 register int *iptr = md->offset_vector + ocount;
6685 register int *iend = iptr - re->top_bracket;
6686 if (iend < md->offset_vector + 2) iend = md->offset_vector + 2;
6687 while (--iptr >= iend) *iptr = -1;
6688 if (offsetcount > 0) md->offset_vector[0] = -1;
6689 if (offsetcount > 1) md->offset_vector[1] = -1;
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. */
6700 if ((re->flags & PCRE_FIRSTSET) != 0)
6702 has_first_char = TRUE;
6703 first_char = first_char2 = (pcre_uchar)(re->first_char);
6704 if ((re->flags & PCRE_FCH_CASELESS) != 0)
6706 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);
6714 if (!startline && study != NULL &&
6715 (study->flags & PCRE_STUDY_MAPPED) != 0)
6716 start_bits = study->start_bits;
6719 /* For anchored or unanchored matches, there may be a "last known required
6722 if ((re->flags & PCRE_REQCHSET) != 0)
6724 has_req_char = TRUE;
6725 req_char = req_char2 = (pcre_uchar)(re->req_char);
6726 if ((re->flags & PCRE_RCH_CASELESS) != 0)
6728 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);
6737 /* ==========================================================================*/
6739 /* Loop for handling unanchored repeated matching attempts; for anchored regexs
6740 the loop runs just once. */
6744 PCRE_PUCHAR save_end_subject = end_subject;
6745 PCRE_PUCHAR new_start_match;
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
6755 PCRE_PUCHAR t = start_match;
6759 while (t < md->end_subject && !IS_NEWLINE(t))
6762 ACROSSCHAR(t < end_subject, *t, t++);
6767 while (t < md->end_subject && !IS_NEWLINE(t)) t++;
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. */
6777 if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
6779 /* Advance to a unique first char if there is one. */
6785 if (first_char != first_char2)
6786 while (start_match < end_subject &&
6787 (smc = UCHAR21TEST(start_match)) != first_char && smc != first_char2)
6790 while (start_match < end_subject && UCHAR21TEST(start_match) != first_char)
6794 /* Or to just after a linebreak for a multiline match */
6798 if (start_match > md->start_subject + start_offset)
6803 while (start_match < end_subject && !WAS_NEWLINE(start_match))
6806 ACROSSCHAR(start_match < end_subject, *start_match,
6812 while (start_match < end_subject && !WAS_NEWLINE(start_match))
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.
6819 if (start_match[-1] == CHAR_CR &&
6820 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
6821 start_match < end_subject &&
6822 UCHAR21TEST(start_match) == CHAR_NL)
6827 /* Or to a non-unique first byte after study */
6829 else if (start_bits != NULL)
6831 while (start_match < end_subject)
6833 register pcre_uint32 c = UCHAR21TEST(start_match);
6834 #ifndef COMPILE_PCRE8
6835 if (c > 255) c = 255;
6837 if ((start_bits[c/8] & (1 << (c&7))) != 0) break;
6841 } /* Starting optimizations */
6843 /* Restore fudged end_subject */
6845 end_subject = save_end_subject;
6847 /* The following two optimizations are disabled for partial matching or if
6848 disabling is explicitly requested. */
6850 if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
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. */
6857 if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
6858 (pcre_uint32)(end_subject - start_match) < study->minlength)
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.
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
6878 if (has_req_char && end_subject - start_match < REQ_BYTE_MAX)
6880 register PCRE_PUCHAR p = start_match + (has_first_char? 1:0);
6882 /* We don't need to repeat the search if we haven't yet reached the
6883 place we found it at last time. */
6885 if (p > req_char_ptr)
6887 if (req_char != req_char2)
6889 while (p < end_subject)
6891 register pcre_uint32 pp = UCHAR21INCTEST(p);
6892 if (pp == req_char || pp == req_char2) { p--; break; }
6897 while (p < end_subject)
6899 if (UCHAR21INCTEST(p) == req_char) { p--; break; }
6903 /* If we can't find the required character, break the matching loop,
6904 forcing a match failure. */
6906 if (p >= end_subject)
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. */
6921 #ifdef PCRE_DEBUG /* Sigh. Some compilers never learn. */
6922 printf(">>>> Match against: ");
6923 pchars(start_match, end_subject - start_match, TRUE, md);
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. */
6930 md->start_match_ptr = start_match;
6931 md->start_used_ptr = start_match;
6932 md->match_call_count = 0;
6933 md->match_function_type = 0;
6934 md->end_offset_top = 0;
6935 md->skip_arg_count = 0;
6936 rc = match(start_match, md->start_code, start_match, 2, md, NULL, 0);
6937 if (md->hitend && start_partial == NULL)
6939 start_partial = md->start_used_ptr;
6940 match_partial = start_match;
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. */
6952 case MATCH_SKIP_ARG:
6953 new_start_match = start_match;
6954 md->ignore_skip_arg = md->skip_arg_count;
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. */
6961 if (md->start_match_ptr > start_match)
6963 new_start_match = md->start_match_ptr;
6968 /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6969 exactly like PRUNE. Unset ignore SKIP-with-argument. */
6974 md->ignore_skip_arg = 0;
6975 new_start_match = start_match + 1;
6978 ACROSSCHAR(new_start_match < end_subject, *new_start_match,
6983 /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
6989 /* Any other return is either a match, or some kind of error. */
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. */
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. */
7004 if (firstline && IS_NEWLINE(start_match)) break;
7006 /* Advance to new matching position */
7008 start_match = new_start_match;
7010 /* Break the loop if the pattern is anchored or if we have passed the end of
7013 if (anchored || start_match > end_subject) break;
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. */
7022 if (start_match > (PCRE_PUCHAR)subject + start_offset &&
7023 start_match[-1] == CHAR_CR &&
7024 start_match < end_subject &&
7025 *start_match == CHAR_NL &&
7026 (re->flags & PCRE_HASCRORLF) == 0 &&
7027 (md->nltype == NLTYPE_ANY ||
7028 md->nltype == NLTYPE_ANYCRLF ||
7032 md->mark = NULL; /* Reset for start of next match attempt */
7033 } /* End of for(;;) "bumpalong" loop */
7035 /* ==========================================================================*/
7037 /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
7040 (1) The pattern is anchored or the match was failed by (*COMMIT);
7042 (2) We are past the end of the subject;
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
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. */
7057 if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
7059 if (using_temporary_offsets)
7061 if (arg_offset_max >= 4)
7063 memcpy(offsets + 2, md->offset_vector + 2,
7064 (arg_offset_max - 2) * sizeof(int));
7065 DPRINTF(("Copied offsets from temporary memory\n"));
7067 if (md->end_offset_top > arg_offset_max) md->capture_last |= OVFLBIT;
7068 DPRINTF(("Freeing temporary memory\n"));
7069 (PUBL(free))(md->offset_vector);
7072 /* Set the return code to the number of captured strings, or 0 if there were
7073 too many to fit into the vector. */
7075 rc = ((md->capture_last & OVFLBIT) != 0 &&
7076 md->end_offset_top >= arg_offset_max)?
7077 0 : md->end_offset_top/2;
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. */
7088 if (md->end_offset_top/2 <= re->top_bracket && offsets != NULL)
7090 register int *iptr, *iend;
7091 int resetcount = 2 + re->top_bracket * 2;
7092 if (resetcount > offsetcount) resetcount = offsetcount;
7093 iptr = offsets + md->end_offset_top;
7094 iend = offsets + resetcount;
7095 while (iptr < iend) *iptr++ = -1;
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
7102 if (offsetcount < 2) rc = 0; else
7104 offsets[0] = (int)(md->start_match_ptr - md->start_subject);
7105 offsets[1] = (int)(md->end_match_ptr - md->start_subject);
7108 /* Return MARK data if requested */
7110 if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7111 *(extra_data->mark) = (pcre_uchar *)md->mark;
7112 DPRINTF((">>>> returning %d\n", rc));
7114 release_match_heapframes(&frame_zero);
7119 /* Control gets here if there has been an error, or if the overall match
7120 attempt has failed at all permitted starting positions. */
7122 if (using_temporary_offsets)
7124 DPRINTF(("Freeing temporary memory\n"));
7125 (PUBL(free))(md->offset_vector);
7128 /* For anything other than nomatch or partial match, just return the code. */
7130 if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
7132 DPRINTF((">>>> error: returning %d\n", rc));
7134 release_match_heapframes(&frame_zero);
7139 /* Handle partial matches - disable any mark data */
7141 if (match_partial != NULL)
7143 DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
7145 if (offsetcount > 1)
7147 offsets[0] = (int)(start_partial - (PCRE_PUCHAR)subject);
7148 offsets[1] = (int)(end_subject - (PCRE_PUCHAR)subject);
7149 if (offsetcount > 2)
7150 offsets[2] = (int)(match_partial - (PCRE_PUCHAR)subject);
7152 rc = PCRE_ERROR_PARTIAL;
7155 /* This is the classic nomatch case */
7159 DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
7160 rc = PCRE_ERROR_NOMATCH;
7163 /* Return the MARK data if it has been requested. */
7165 if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7166 *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7168 release_match_heapframes(&frame_zero);
7173 /* End of pcre_exec.c */