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
)
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 eptr
= md
->end_match_ptr
;
1171 ecode
= md
->start_code
+ code_offset
;
1172 save_capture_last
= md
->capture_last
;
1173 matched_once
= TRUE
;
1174 mstart
= md
->start_match_ptr
; /* In case \K changed it */
1178 /* See comment in the code for capturing groups above about handling
1181 if (rrc
== MATCH_THEN
)
1183 next
= ecode
+ GET(ecode
,1);
1184 if (md
->start_match_ptr
< next
&&
1185 (*ecode
== OP_ALT
|| *next
== OP_ALT
))
1186 rrc
= MATCH_NOMATCH
;
1189 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
1190 md
->capture_last
= save_capture_last
;
1191 ecode
+= GET(ecode
, 1);
1192 if (*ecode
!= OP_ALT
) break;
1197 md
->offset_vector
[offset
] = save_offset1
;
1198 md
->offset_vector
[offset
+1] = save_offset2
;
1199 md
->offset_vector
[md
->offset_end
- number
] = save_offset3
;
1202 if (allow_zero
|| matched_once
)
1204 ecode
+= 1 + LINK_SIZE
;
1208 RRETURN(MATCH_NOMATCH
);
1211 /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
1212 as a non-capturing bracket. */
1214 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1215 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1217 DPRINTF(("insufficient capture room: treat as non-capturing\n"));
1219 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1220 /* VVVVVVVVVVVVVVVVVVVVVVVVV */
1222 /* Non-capturing possessive bracket with unlimited repeat. We come here
1223 from BRAZERO with allow_zero = TRUE. The code is similar to the above,
1224 without the capturing complication. It is written out separately for speed
1231 POSSESSIVE_NON_CAPTURE
:
1232 matched_once
= FALSE
;
1233 code_offset
= (int)(ecode
- md
->start_code
);
1234 save_capture_last
= md
->capture_last
;
1238 if (op
>= OP_SBRA
) md
->match_function_type
= MATCH_CBEGROUP
;
1239 RMATCH(eptr
, ecode
+ PRIV(OP_lengths
)[*ecode
], offset_top
, md
,
1241 if (rrc
== MATCH_KETRPOS
)
1243 offset_top
= md
->end_offset_top
;
1244 eptr
= md
->end_match_ptr
;
1245 ecode
= md
->start_code
+ code_offset
;
1246 matched_once
= TRUE
;
1247 mstart
= md
->start_match_ptr
; /* In case \K reset it */
1251 /* See comment in the code for capturing groups above about handling
1254 if (rrc
== MATCH_THEN
)
1256 next
= ecode
+ GET(ecode
,1);
1257 if (md
->start_match_ptr
< next
&&
1258 (*ecode
== OP_ALT
|| *next
== OP_ALT
))
1259 rrc
= MATCH_NOMATCH
;
1262 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
1263 ecode
+= GET(ecode
, 1);
1264 if (*ecode
!= OP_ALT
) break;
1265 md
->capture_last
= save_capture_last
;
1268 if (matched_once
|| allow_zero
)
1270 ecode
+= 1 + LINK_SIZE
;
1273 RRETURN(MATCH_NOMATCH
);
1275 /* Control never reaches here. */
1277 /* Conditional group: compilation checked that there are no more than two
1278 branches. If the condition is false, skipping the first branch takes us
1279 past the end of the item if there is only one branch, but that's exactly
1285 /* The variable codelink will be added to ecode when the condition is
1286 false, to get to the second branch. Setting it to the offset to the ALT
1287 or KET, then incrementing ecode achieves this effect. We now have ecode
1288 pointing to the condition or callout. */
1290 codelink
= GET(ecode
, 1); /* Offset to the second branch */
1291 ecode
+= 1 + LINK_SIZE
; /* From this opcode */
1293 /* Because of the way auto-callout works during compile, a callout item is
1294 inserted between OP_COND and an assertion condition. */
1296 if (*ecode
== OP_CALLOUT
)
1298 if (PUBL(callout
) != NULL
)
1300 PUBL(callout_block
) cb
;
1301 cb
.version
= 2; /* Version 1 of the callout block */
1302 cb
.callout_number
= ecode
[1];
1303 cb
.offset_vector
= md
->offset_vector
;
1304 #if defined COMPILE_PCRE8
1305 cb
.subject
= (PCRE_SPTR
)md
->start_subject
;
1306 #elif defined COMPILE_PCRE16
1307 cb
.subject
= (PCRE_SPTR16
)md
->start_subject
;
1308 #elif defined COMPILE_PCRE32
1309 cb
.subject
= (PCRE_SPTR32
)md
->start_subject
;
1311 cb
.subject_length
= (int)(md
->end_subject
- md
->start_subject
);
1312 cb
.start_match
= (int)(mstart
- md
->start_subject
);
1313 cb
.current_position
= (int)(eptr
- md
->start_subject
);
1314 cb
.pattern_position
= GET(ecode
, 2);
1315 cb
.next_item_length
= GET(ecode
, 2 + LINK_SIZE
);
1316 cb
.capture_top
= offset_top
/2;
1317 cb
.capture_last
= md
->capture_last
& CAPLMASK
;
1318 /* Internal change requires this for API compatibility. */
1319 if (cb
.capture_last
== 0) cb
.capture_last
= -1;
1320 cb
.callout_data
= md
->callout_data
;
1321 cb
.mark
= md
->nomatch_mark
;
1322 if ((rrc
= (*PUBL(callout
))(&cb
)) > 0) RRETURN(MATCH_NOMATCH
);
1323 if (rrc
< 0) RRETURN(rrc
);
1326 /* Advance ecode past the callout, so it now points to the condition. We
1327 must adjust codelink so that the value of ecode+codelink is unchanged. */
1329 ecode
+= PRIV(OP_lengths
)[OP_CALLOUT
];
1330 codelink
-= PRIV(OP_lengths
)[OP_CALLOUT
];
1333 /* Test the various possible conditions */
1336 switch(condcode
= *ecode
)
1338 case OP_RREF
: /* Numbered group recursion test */
1339 if (md
->recursive
!= NULL
) /* Not recursing => FALSE */
1341 unsigned int recno
= GET2(ecode
, 1); /* Recursion group number*/
1342 condition
= (recno
== RREF_ANY
|| recno
== md
->recursive
->group_num
);
1346 case OP_DNRREF
: /* Duplicate named group recursion test */
1347 if (md
->recursive
!= NULL
)
1349 int count
= GET2(ecode
, 1 + IMM2_SIZE
);
1350 pcre_uchar
*slot
= md
->name_table
+ GET2(ecode
, 1) * md
->name_entry_size
;
1353 unsigned int recno
= GET2(slot
, 0);
1354 condition
= recno
== md
->recursive
->group_num
;
1355 if (condition
) break;
1356 slot
+= md
->name_entry_size
;
1361 case OP_CREF
: /* Numbered group used test */
1362 offset
= GET2(ecode
, 1) << 1; /* Doubled ref number */
1363 condition
= offset
< offset_top
&& md
->offset_vector
[offset
] >= 0;
1366 case OP_DNCREF
: /* Duplicate named group used test */
1368 int count
= GET2(ecode
, 1 + IMM2_SIZE
);
1369 pcre_uchar
*slot
= md
->name_table
+ GET2(ecode
, 1) * md
->name_entry_size
;
1372 offset
= GET2(slot
, 0) << 1;
1373 condition
= offset
< offset_top
&& md
->offset_vector
[offset
] >= 0;
1374 if (condition
) break;
1375 slot
+= md
->name_entry_size
;
1380 case OP_DEF
: /* DEFINE - always false */
1383 /* The condition is an assertion. Call match() to evaluate it - setting
1384 md->match_function_type to MATCH_CONDASSERT causes it to stop at the end
1388 md
->match_function_type
= MATCH_CONDASSERT
;
1389 RMATCH(eptr
, ecode
, offset_top
, md
, NULL
, RM3
);
1390 if (rrc
== MATCH_MATCH
)
1392 if (md
->end_offset_top
> offset_top
)
1393 offset_top
= md
->end_offset_top
; /* Captures may have happened */
1396 /* Advance ecode past the assertion to the start of the first branch,
1397 but adjust it so that the general choosing code below works. */
1399 ecode
+= GET(ecode
, 1);
1400 while (*ecode
== OP_ALT
) ecode
+= GET(ecode
, 1);
1401 ecode
+= 1 + LINK_SIZE
- PRIV(OP_lengths
)[condcode
];
1404 /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
1405 assertion; it is therefore treated as NOMATCH. Any other return is an
1408 else if (rrc
!= MATCH_NOMATCH
&& rrc
!= MATCH_THEN
)
1410 RRETURN(rrc
); /* Need braces because of following else */
1415 /* Choose branch according to the condition */
1417 ecode
+= condition
? PRIV(OP_lengths
)[condcode
] : codelink
;
1419 /* We are now at the branch that is to be obeyed. As there is only one, we
1420 can use tail recursion to avoid using another stack frame, except when
1421 there is unlimited repeat of a possibly empty group. In the latter case, a
1422 recursive call to match() is always required, unless the second alternative
1423 doesn't exist, in which case we can just plough on. Note that, for
1424 compatibility with Perl, the | in a conditional group is NOT treated as
1425 creating two alternatives. If a THEN is encountered in the branch, it
1426 propagates out to the enclosing alternative (unless nested in a deeper set
1427 of alternatives, of course). */
1429 if (condition
|| ecode
[-(1+LINK_SIZE
)] == OP_ALT
)
1436 md
->match_function_type
= MATCH_CBEGROUP
;
1437 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM49
);
1441 /* Condition false & no alternative; continue after the group. */
1449 /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1450 to close any currently open capturing brackets. */
1453 number
= GET2(ecode
, 1); /* Must be less than 65536 */
1454 offset
= number
<< 1;
1457 printf("end bracket %d at *ACCEPT", number
);
1461 md
->capture_last
= (md
->capture_last
& OVFLMASK
) | number
;
1462 if (offset
>= md
->offset_max
) md
->capture_last
|= OVFLBIT
; else
1464 md
->offset_vector
[offset
] =
1465 md
->offset_vector
[md
->offset_end
- number
];
1466 md
->offset_vector
[offset
+1] = (int)(eptr
- md
->start_subject
);
1467 if (offset_top
<= offset
) offset_top
= offset
+ 2;
1469 ecode
+= 1 + IMM2_SIZE
;
1473 /* End of the pattern, either real or forced. */
1477 case OP_ASSERT_ACCEPT
:
1479 /* If we have matched an empty string, fail if not in an assertion and not
1480 in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
1481 is set and we have matched at the start of the subject. In both cases,
1482 backtracking will then try other alternatives, if any. */
1484 if (eptr
== mstart
&& op
!= OP_ASSERT_ACCEPT
&&
1485 md
->recursive
== NULL
&&
1487 (md
->notempty_atstart
&&
1488 mstart
== md
->start_subject
+ md
->start_offset
)))
1489 RRETURN(MATCH_NOMATCH
);
1491 /* Otherwise, we have a match. */
1493 md
->end_match_ptr
= eptr
; /* Record where we ended */
1494 md
->end_offset_top
= offset_top
; /* and how many extracts were taken */
1495 md
->start_match_ptr
= mstart
; /* and the start (\K can modify) */
1497 /* For some reason, the macros don't work properly if an expression is
1498 given as the argument to RRETURN when the heap is in use. */
1500 rrc
= (op
== OP_END
)? MATCH_MATCH
: MATCH_ACCEPT
;
1503 /* Assertion brackets. Check the alternative branches in turn - the
1504 matching won't pass the KET for an assertion. If any one branch matches,
1505 the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
1506 start of each branch to move the current point backwards, so the code at
1507 this level is identical to the lookahead case. When the assertion is part
1508 of a condition, we want to return immediately afterwards. The caller of
1509 this incarnation of the match() function will have set MATCH_CONDASSERT in
1510 md->match_function type, and one of these opcodes will be the first opcode
1511 that is processed. We use a local variable that is preserved over calls to
1512 match() to remember this case. */
1516 save_mark
= md
->mark
;
1517 if (md
->match_function_type
== MATCH_CONDASSERT
)
1520 md
->match_function_type
= 0;
1522 else condassert
= FALSE
;
1524 /* Loop for each branch */
1528 RMATCH(eptr
, ecode
+ 1 + LINK_SIZE
, offset_top
, md
, NULL
, RM4
);
1530 /* A match means that the assertion is true; break out of the loop
1531 that matches its alternatives. */
1533 if (rrc
== MATCH_MATCH
|| rrc
== MATCH_ACCEPT
)
1535 mstart
= md
->start_match_ptr
; /* In case \K reset it */
1539 /* If not matched, restore the previous mark setting. */
1541 md
->mark
= save_mark
;
1543 /* See comment in the code for capturing groups above about handling
1546 if (rrc
== MATCH_THEN
)
1548 next
= ecode
+ GET(ecode
,1);
1549 if (md
->start_match_ptr
< next
&&
1550 (*ecode
== OP_ALT
|| *next
== OP_ALT
))
1551 rrc
= MATCH_NOMATCH
;
1554 /* Anything other than NOMATCH causes the entire assertion to fail,
1555 passing back the return code. This includes COMMIT, SKIP, PRUNE and an
1556 uncaptured THEN, which means they take their normal effect. This
1557 consistent approach does not always have exactly the same effect as in
1560 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
1561 ecode
+= GET(ecode
, 1);
1563 while (*ecode
== OP_ALT
); /* Continue for next alternative */
1565 /* If we have tried all the alternative branches, the assertion has
1566 failed. If not, we broke out after a match. */
1568 if (*ecode
== OP_KET
) RRETURN(MATCH_NOMATCH
);
1570 /* If checking an assertion for a condition, return MATCH_MATCH. */
1572 if (condassert
) RRETURN(MATCH_MATCH
);
1574 /* Continue from after a successful assertion, updating the offsets high
1575 water mark, since extracts may have been taken during the assertion. */
1577 do ecode
+= GET(ecode
,1); while (*ecode
== OP_ALT
);
1578 ecode
+= 1 + LINK_SIZE
;
1579 offset_top
= md
->end_offset_top
;
1582 /* Negative assertion: all branches must fail to match for the assertion to
1586 case OP_ASSERTBACK_NOT
:
1587 save_mark
= md
->mark
;
1588 if (md
->match_function_type
== MATCH_CONDASSERT
)
1591 md
->match_function_type
= 0;
1593 else condassert
= FALSE
;
1595 /* Loop for each alternative branch. */
1599 RMATCH(eptr
, ecode
+ 1 + LINK_SIZE
, offset_top
, md
, NULL
, RM5
);
1600 md
->mark
= save_mark
; /* Always restore the mark setting */
1604 case MATCH_MATCH
: /* A successful match means */
1605 case MATCH_ACCEPT
: /* the assertion has failed. */
1606 RRETURN(MATCH_NOMATCH
);
1608 case MATCH_NOMATCH
: /* Carry on with next branch */
1611 /* See comment in the code for capturing groups above about handling
1615 next
= ecode
+ GET(ecode
,1);
1616 if (md
->start_match_ptr
< next
&&
1617 (*ecode
== OP_ALT
|| *next
== OP_ALT
))
1619 rrc
= MATCH_NOMATCH
;
1622 /* Otherwise fall through. */
1624 /* COMMIT, SKIP, PRUNE, and an uncaptured THEN cause the whole
1625 assertion to fail to match, without considering any more alternatives.
1626 Failing to match means the assertion is true. This is a consistent
1627 approach, but does not always have the same effect as in Perl. */
1631 case MATCH_SKIP_ARG
:
1633 do ecode
+= GET(ecode
,1); while (*ecode
== OP_ALT
);
1634 goto NEG_ASSERT_TRUE
; /* Break out of alternation loop */
1636 /* Anything else is an error */
1642 /* Continue with next branch */
1644 ecode
+= GET(ecode
,1);
1646 while (*ecode
== OP_ALT
);
1648 /* All branches in the assertion failed to match. */
1651 if (condassert
) RRETURN(MATCH_MATCH
); /* Condition assertion */
1652 ecode
+= 1 + LINK_SIZE
; /* Continue with current branch */
1655 /* Move the subject pointer back. This occurs only at the start of
1656 each branch of a lookbehind assertion. If we are too close to the start to
1657 move back, this match function fails. When working with UTF-8 we move
1658 back a number of characters, not bytes. */
1668 if (eptr
< md
->start_subject
) RRETURN(MATCH_NOMATCH
);
1675 /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
1678 eptr
-= GET(ecode
, 1);
1679 if (eptr
< md
->start_subject
) RRETURN(MATCH_NOMATCH
);
1682 /* Save the earliest consulted character, then skip to next op code */
1684 if (eptr
< md
->start_used_ptr
) md
->start_used_ptr
= eptr
;
1685 ecode
+= 1 + LINK_SIZE
;
1688 /* The callout item calls an external function, if one is provided, passing
1689 details of the match so far. This is mainly for debugging, though the
1690 function is able to force a failure. */
1693 if (PUBL(callout
) != NULL
)
1695 PUBL(callout_block
) cb
;
1696 cb
.version
= 2; /* Version 1 of the callout block */
1697 cb
.callout_number
= ecode
[1];
1698 cb
.offset_vector
= md
->offset_vector
;
1699 #if defined COMPILE_PCRE8
1700 cb
.subject
= (PCRE_SPTR
)md
->start_subject
;
1701 #elif defined COMPILE_PCRE16
1702 cb
.subject
= (PCRE_SPTR16
)md
->start_subject
;
1703 #elif defined COMPILE_PCRE32
1704 cb
.subject
= (PCRE_SPTR32
)md
->start_subject
;
1706 cb
.subject_length
= (int)(md
->end_subject
- md
->start_subject
);
1707 cb
.start_match
= (int)(mstart
- md
->start_subject
);
1708 cb
.current_position
= (int)(eptr
- md
->start_subject
);
1709 cb
.pattern_position
= GET(ecode
, 2);
1710 cb
.next_item_length
= GET(ecode
, 2 + LINK_SIZE
);
1711 cb
.capture_top
= offset_top
/2;
1712 cb
.capture_last
= md
->capture_last
& CAPLMASK
;
1713 /* Internal change requires this for API compatibility. */
1714 if (cb
.capture_last
== 0) cb
.capture_last
= -1;
1715 cb
.callout_data
= md
->callout_data
;
1716 cb
.mark
= md
->nomatch_mark
;
1717 if ((rrc
= (*PUBL(callout
))(&cb
)) > 0) RRETURN(MATCH_NOMATCH
);
1718 if (rrc
< 0) RRETURN(rrc
);
1720 ecode
+= 2 + 2*LINK_SIZE
;
1723 /* Recursion either matches the current regex, or some subexpression. The
1724 offset data is the offset to the starting bracket from the start of the
1725 whole pattern. (This is so that it works from duplicated subpatterns.)
1727 The state of the capturing groups is preserved over recursion, and
1728 re-instated afterwards. We don't know how many are started and not yet
1729 finished (offset_top records the completed total) so we just have to save
1730 all the potential data. There may be up to 65535 such values, which is too
1731 large to put on the stack, but using malloc for small numbers seems
1732 expensive. As a compromise, the stack is used when there are no more than
1733 REC_STACK_SAVE_MAX values to store; otherwise malloc is used.
1735 There are also other values that have to be saved. We use a chained
1736 sequence of blocks that actually live on the stack. Thanks to Robin Houston
1737 for the original version of this logic. It has, however, been hacked around
1738 a lot, so he is not to blame for the current way it works. */
1745 callpat
= md
->start_code
+ GET(ecode
, 1);
1746 recno
= (callpat
== md
->start_code
)? 0 :
1747 GET2(callpat
, 1 + LINK_SIZE
);
1749 /* Check for repeating a recursion without advancing the subject pointer.
1750 This should catch convoluted mutual recursions. (Some simple cases are
1751 caught at compile time.) */
1753 for (ri
= md
->recursive
; ri
!= NULL
; ri
= ri
->prevrec
)
1754 if (recno
== ri
->group_num
&& eptr
== ri
->subject_position
)
1755 RRETURN(PCRE_ERROR_RECURSELOOP
);
1757 /* Add to "recursing stack" */
1759 new_recursive
.group_num
= recno
;
1760 new_recursive
.saved_capture_last
= md
->capture_last
;
1761 new_recursive
.subject_position
= eptr
;
1762 new_recursive
.prevrec
= md
->recursive
;
1763 md
->recursive
= &new_recursive
;
1765 /* Where to continue from afterwards */
1767 ecode
+= 1 + LINK_SIZE
;
1769 /* Now save the offset data */
1771 new_recursive
.saved_max
= md
->offset_end
;
1772 if (new_recursive
.saved_max
<= REC_STACK_SAVE_MAX
)
1773 new_recursive
.offset_save
= stacksave
;
1776 new_recursive
.offset_save
=
1777 (int *)(PUBL(malloc
))(new_recursive
.saved_max
* sizeof(int));
1778 if (new_recursive
.offset_save
== NULL
) RRETURN(PCRE_ERROR_NOMEMORY
);
1780 memcpy(new_recursive
.offset_save
, md
->offset_vector
,
1781 new_recursive
.saved_max
* sizeof(int));
1783 /* OK, now we can do the recursion. After processing each alternative,
1784 restore the offset data and the last captured value. If there were nested
1785 recursions, md->recursive might be changed, so reset it before looping.
1788 DPRINTF(("Recursing into group %d\n", new_recursive
.group_num
));
1789 cbegroup
= (*callpat
>= OP_SBRA
);
1792 if (cbegroup
) md
->match_function_type
= MATCH_CBEGROUP
;
1793 RMATCH(eptr
, callpat
+ PRIV(OP_lengths
)[*callpat
], offset_top
,
1795 memcpy(md
->offset_vector
, new_recursive
.offset_save
,
1796 new_recursive
.saved_max
* sizeof(int));
1797 md
->capture_last
= new_recursive
.saved_capture_last
;
1798 md
->recursive
= new_recursive
.prevrec
;
1799 if (rrc
== MATCH_MATCH
|| rrc
== MATCH_ACCEPT
)
1801 DPRINTF(("Recursion matched\n"));
1802 if (new_recursive
.offset_save
!= stacksave
)
1803 (PUBL(free
))(new_recursive
.offset_save
);
1805 /* Set where we got to in the subject, and reset the start in case
1806 it was changed by \K. This *is* propagated back out of a recursion,
1807 for Perl compatibility. */
1809 eptr
= md
->end_match_ptr
;
1810 mstart
= md
->start_match_ptr
;
1811 goto RECURSION_MATCHED
; /* Exit loop; end processing */
1814 /* PCRE does not allow THEN, SKIP, PRUNE or COMMIT to escape beyond a
1815 recursion; they cause a NOMATCH for the entire recursion. These codes
1816 are defined in a range that can be tested for. */
1818 if (rrc
>= MATCH_BACKTRACK_MIN
&& rrc
<= MATCH_BACKTRACK_MAX
)
1819 RRETURN(MATCH_NOMATCH
);
1821 /* Any return code other than NOMATCH is an error. */
1823 if (rrc
!= MATCH_NOMATCH
)
1825 DPRINTF(("Recursion gave error %d\n", rrc
));
1826 if (new_recursive
.offset_save
!= stacksave
)
1827 (PUBL(free
))(new_recursive
.offset_save
);
1831 md
->recursive
= &new_recursive
;
1832 callpat
+= GET(callpat
, 1);
1834 while (*callpat
== OP_ALT
);
1836 DPRINTF(("Recursion didn't match\n"));
1837 md
->recursive
= new_recursive
.prevrec
;
1838 if (new_recursive
.offset_save
!= stacksave
)
1839 (PUBL(free
))(new_recursive
.offset_save
);
1840 RRETURN(MATCH_NOMATCH
);
1846 /* An alternation is the end of a branch; scan along to find the end of the
1847 bracketed group and go to there. */
1850 do ecode
+= GET(ecode
,1); while (*ecode
== OP_ALT
);
1853 /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1854 indicating that it may occur zero times. It may repeat infinitely, or not
1855 at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1856 with fixed upper repeat limits are compiled as a number of copies, with the
1857 optional ones preceded by BRAZERO or BRAMINZERO. */
1861 RMATCH(eptr
, next
, offset_top
, md
, eptrb
, RM10
);
1862 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
1863 do next
+= GET(next
, 1); while (*next
== OP_ALT
);
1864 ecode
= next
+ 1 + LINK_SIZE
;
1869 do next
+= GET(next
, 1); while (*next
== OP_ALT
);
1870 RMATCH(eptr
, next
+ 1+LINK_SIZE
, offset_top
, md
, eptrb
, RM11
);
1871 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
1877 do next
+= GET(next
,1); while (*next
== OP_ALT
);
1878 ecode
= next
+ 1 + LINK_SIZE
;
1881 /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
1882 here; just jump to the group, with allow_zero set TRUE. */
1887 if (op
== OP_CBRAPOS
|| op
== OP_SCBRAPOS
) goto POSSESSIVE_CAPTURE
;
1888 goto POSSESSIVE_NON_CAPTURE
;
1890 /* End of a group, repeated or non-repeating. */
1896 prev
= ecode
- GET(ecode
, 1);
1898 /* If this was a group that remembered the subject start, in order to break
1899 infinite repeats of empty string matches, retrieve the subject start from
1900 the chain. Otherwise, set it NULL. */
1902 if (*prev
>= OP_SBRA
|| *prev
== OP_ONCE
)
1904 saved_eptr
= eptrb
->epb_saved_eptr
; /* Value at start of group */
1905 eptrb
= eptrb
->epb_prev
; /* Backup to previous group */
1907 else saved_eptr
= NULL
;
1909 /* If we are at the end of an assertion group or a non-capturing atomic
1910 group, stop matching and return MATCH_MATCH, but record the current high
1911 water mark for use by positive assertions. We also need to record the match
1912 start in case it was changed by \K. */
1914 if ((*prev
>= OP_ASSERT
&& *prev
<= OP_ASSERTBACK_NOT
) ||
1915 *prev
== OP_ONCE_NC
)
1917 md
->end_match_ptr
= eptr
; /* For ONCE_NC */
1918 md
->end_offset_top
= offset_top
;
1919 md
->start_match_ptr
= mstart
;
1920 RRETURN(MATCH_MATCH
); /* Sets md->mark */
1923 /* For capturing groups we have to check the group number back at the start
1924 and if necessary complete handling an extraction by setting the offsets and
1925 bumping the high water mark. Whole-pattern recursion is coded as a recurse
1926 into group 0, so it won't be picked up here. Instead, we catch it when the
1927 OP_END is reached. Other recursion is handled here. We just have to record
1928 the current subject position and start match pointer and give a MATCH
1931 if (*prev
== OP_CBRA
|| *prev
== OP_SCBRA
||
1932 *prev
== OP_CBRAPOS
|| *prev
== OP_SCBRAPOS
)
1934 number
= GET2(prev
, 1+LINK_SIZE
);
1935 offset
= number
<< 1;
1938 printf("end bracket %d", number
);
1942 /* Handle a recursively called group. */
1944 if (md
->recursive
!= NULL
&& md
->recursive
->group_num
== number
)
1946 md
->end_match_ptr
= eptr
;
1947 md
->start_match_ptr
= mstart
;
1948 RRETURN(MATCH_MATCH
);
1951 /* Deal with capturing */
1953 md
->capture_last
= (md
->capture_last
& OVFLMASK
) | number
;
1954 if (offset
>= md
->offset_max
) md
->capture_last
|= OVFLBIT
; else
1956 /* If offset is greater than offset_top, it means that we are
1957 "skipping" a capturing group, and that group's offsets must be marked
1958 unset. In earlier versions of PCRE, all the offsets were unset at the
1959 start of matching, but this doesn't work because atomic groups and
1960 assertions can cause a value to be set that should later be unset.
1961 Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
1962 part of the atomic group, but this is not on the final matching path,
1963 so must be unset when 2 is set. (If there is no group 2, there is no
1964 problem, because offset_top will then be 2, indicating no capture.) */
1966 if (offset
> offset_top
)
1968 register int *iptr
= md
->offset_vector
+ offset_top
;
1969 register int *iend
= md
->offset_vector
+ offset
;
1970 while (iptr
< iend
) *iptr
++ = -1;
1973 /* Now make the extraction */
1975 md
->offset_vector
[offset
] =
1976 md
->offset_vector
[md
->offset_end
- number
];
1977 md
->offset_vector
[offset
+1] = (int)(eptr
- md
->start_subject
);
1978 if (offset_top
<= offset
) offset_top
= offset
+ 2;
1982 /* For an ordinary non-repeating ket, just continue at this level. This
1983 also happens for a repeating ket if no characters were matched in the
1984 group. This is the forcible breaking of infinite loops as implemented in
1985 Perl 5.005. For a non-repeating atomic group that includes captures,
1986 establish a backup point by processing the rest of the pattern at a lower
1987 level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
1988 original OP_ONCE level, thereby bypassing intermediate backup points, but
1989 resetting any captures that happened along the way. */
1991 if (*ecode
== OP_KET
|| eptr
== saved_eptr
)
1993 if (*prev
== OP_ONCE
)
1995 RMATCH(eptr
, ecode
+ 1 + LINK_SIZE
, offset_top
, md
, eptrb
, RM12
);
1996 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
1997 md
->once_target
= prev
; /* Level at which to change to MATCH_NOMATCH */
1998 RRETURN(MATCH_ONCE
);
2000 ecode
+= 1 + LINK_SIZE
; /* Carry on at this level */
2004 /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
2005 and return the MATCH_KETRPOS. This makes it possible to do the repeats one
2006 at a time from the outer level, thus saving stack. */
2008 if (*ecode
== OP_KETRPOS
)
2010 md
->start_match_ptr
= mstart
; /* In case \K reset it */
2011 md
->end_match_ptr
= eptr
;
2012 md
->end_offset_top
= offset_top
;
2013 RRETURN(MATCH_KETRPOS
);
2016 /* The normal repeating kets try the rest of the pattern or restart from
2017 the preceding bracket, in the appropriate order. In the second case, we can
2018 use tail recursion to avoid using another stack frame, unless we have an
2019 an atomic group or an unlimited repeat of a group that can match an empty
2022 if (*ecode
== OP_KETRMIN
)
2024 RMATCH(eptr
, ecode
+ 1 + LINK_SIZE
, offset_top
, md
, eptrb
, RM7
);
2025 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2026 if (*prev
== OP_ONCE
)
2028 RMATCH(eptr
, prev
, offset_top
, md
, eptrb
, RM8
);
2029 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2030 md
->once_target
= prev
; /* Level at which to change to MATCH_NOMATCH */
2031 RRETURN(MATCH_ONCE
);
2033 if (*prev
>= OP_SBRA
) /* Could match an empty string */
2035 RMATCH(eptr
, prev
, offset_top
, md
, eptrb
, RM50
);
2041 else /* OP_KETRMAX */
2043 RMATCH(eptr
, prev
, offset_top
, md
, eptrb
, RM13
);
2044 if (rrc
== MATCH_ONCE
&& md
->once_target
== prev
) rrc
= MATCH_NOMATCH
;
2045 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2046 if (*prev
== OP_ONCE
)
2048 RMATCH(eptr
, ecode
+ 1 + LINK_SIZE
, offset_top
, md
, eptrb
, RM9
);
2049 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2050 md
->once_target
= prev
;
2051 RRETURN(MATCH_ONCE
);
2053 ecode
+= 1 + LINK_SIZE
;
2056 /* Control never gets here */
2058 /* Not multiline mode: start of subject assertion, unless notbol. */
2061 if (md
->notbol
&& eptr
== md
->start_subject
) RRETURN(MATCH_NOMATCH
);
2063 /* Start of subject assertion */
2066 if (eptr
!= md
->start_subject
) RRETURN(MATCH_NOMATCH
);
2070 /* Multiline mode: start of subject unless notbol, or after any newline. */
2073 if (md
->notbol
&& eptr
== md
->start_subject
) RRETURN(MATCH_NOMATCH
);
2074 if (eptr
!= md
->start_subject
&&
2075 (eptr
== md
->end_subject
|| !WAS_NEWLINE(eptr
)))
2076 RRETURN(MATCH_NOMATCH
);
2080 /* Start of match assertion */
2083 if (eptr
!= md
->start_subject
+ md
->start_offset
) RRETURN(MATCH_NOMATCH
);
2087 /* Reset the start of match point */
2094 /* Multiline mode: assert before any newline, or before end of subject
2095 unless noteol is set. */
2098 if (eptr
< md
->end_subject
)
2100 if (!IS_NEWLINE(eptr
))
2102 if (md
->partial
!= 0 &&
2103 eptr
+ 1 >= md
->end_subject
&&
2104 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
2105 NLBLOCK
->nllen
== 2 &&
2106 UCHAR21TEST(eptr
) == NLBLOCK
->nl
[0])
2109 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
2111 RRETURN(MATCH_NOMATCH
);
2116 if (md
->noteol
) RRETURN(MATCH_NOMATCH
);
2122 /* Not multiline mode: assert before a terminating newline or before end of
2123 subject unless noteol is set. */
2126 if (md
->noteol
) RRETURN(MATCH_NOMATCH
);
2127 if (!md
->endonly
) goto ASSERT_NL_OR_EOS
;
2129 /* ... else fall through for endonly */
2131 /* End of subject assertion (\z) */
2134 if (eptr
< md
->end_subject
) RRETURN(MATCH_NOMATCH
);
2139 /* End of subject or ending \n assertion (\Z) */
2143 if (eptr
< md
->end_subject
&&
2144 (!IS_NEWLINE(eptr
) || eptr
!= md
->end_subject
- md
->nllen
))
2146 if (md
->partial
!= 0 &&
2147 eptr
+ 1 >= md
->end_subject
&&
2148 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
2149 NLBLOCK
->nllen
== 2 &&
2150 UCHAR21TEST(eptr
) == NLBLOCK
->nl
[0])
2153 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
2155 RRETURN(MATCH_NOMATCH
);
2158 /* Either at end of string or \n before end. */
2164 /* Word boundary assertions */
2166 case OP_NOT_WORD_BOUNDARY
:
2167 case OP_WORD_BOUNDARY
:
2170 /* Find out if the previous and current characters are "word" characters.
2171 It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
2172 be "non-word" characters. Remember the earliest consulted character for
2173 partial matching. */
2178 /* Get status of previous character */
2180 if (eptr
== md
->start_subject
) prev_is_word
= FALSE
; else
2182 PCRE_PUCHAR lastptr
= eptr
- 1;
2184 if (lastptr
< md
->start_used_ptr
) md
->start_used_ptr
= lastptr
;
2185 GETCHAR(c
, lastptr
);
2189 if (c
== '_') prev_is_word
= TRUE
; else
2191 int cat
= UCD_CATEGORY(c
);
2192 prev_is_word
= (cat
== ucp_L
|| cat
== ucp_N
);
2197 prev_is_word
= c
< 256 && (md
->ctypes
[c
] & ctype_word
) != 0;
2200 /* Get status of next character */
2202 if (eptr
>= md
->end_subject
)
2205 cur_is_word
= FALSE
;
2213 if (c
== '_') cur_is_word
= TRUE
; else
2215 int cat
= UCD_CATEGORY(c
);
2216 cur_is_word
= (cat
== ucp_L
|| cat
== ucp_N
);
2221 cur_is_word
= c
< 256 && (md
->ctypes
[c
] & ctype_word
) != 0;
2227 /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
2228 consistency with the behaviour of \w we do use it in this case. */
2231 /* Get status of previous character */
2233 if (eptr
== md
->start_subject
) prev_is_word
= FALSE
; else
2235 if (eptr
<= md
->start_used_ptr
) md
->start_used_ptr
= eptr
- 1;
2240 if (c
== '_') prev_is_word
= TRUE
; else
2242 int cat
= UCD_CATEGORY(c
);
2243 prev_is_word
= (cat
== ucp_L
|| cat
== ucp_N
);
2248 prev_is_word
= MAX_255(eptr
[-1])
2249 && ((md
->ctypes
[eptr
[-1]] & ctype_word
) != 0);
2252 /* Get status of next character */
2254 if (eptr
>= md
->end_subject
)
2257 cur_is_word
= FALSE
;
2264 if (c
== '_') cur_is_word
= TRUE
; else
2266 int cat
= UCD_CATEGORY(c
);
2267 cur_is_word
= (cat
== ucp_L
|| cat
== ucp_N
);
2272 cur_is_word
= MAX_255(*eptr
)
2273 && ((md
->ctypes
[*eptr
] & ctype_word
) != 0);
2276 /* Now see if the situation is what we want */
2278 if ((*ecode
++ == OP_WORD_BOUNDARY
)?
2279 cur_is_word
== prev_is_word
: cur_is_word
!= prev_is_word
)
2280 RRETURN(MATCH_NOMATCH
);
2284 /* Match any single character type except newline; have to take care with
2285 CRLF newlines and partial matching. */
2288 if (IS_NEWLINE(eptr
)) RRETURN(MATCH_NOMATCH
);
2289 if (md
->partial
!= 0 &&
2290 eptr
+ 1 >= md
->end_subject
&&
2291 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
2292 NLBLOCK
->nllen
== 2 &&
2293 UCHAR21TEST(eptr
) == NLBLOCK
->nl
[0])
2296 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
2301 /* Match any single character whatsoever. */
2304 if (eptr
>= md
->end_subject
) /* DO NOT merge the eptr++ here; it must */
2305 { /* not be updated before SCHECK_PARTIAL. */
2307 RRETURN(MATCH_NOMATCH
);
2311 if (utf
) ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
2316 /* Match a single byte, even in UTF-8 mode. This opcode really does match
2317 any byte, even newline, independent of the setting of PCRE_DOTALL. */
2320 if (eptr
>= md
->end_subject
) /* DO NOT merge the eptr++ here; it must */
2321 { /* not be updated before SCHECK_PARTIAL. */
2323 RRETURN(MATCH_NOMATCH
);
2330 if (eptr
>= md
->end_subject
)
2333 RRETURN(MATCH_NOMATCH
);
2335 GETCHARINCTEST(c
, eptr
);
2337 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2340 (md
->ctypes
[c
] & ctype_digit
) != 0
2342 RRETURN(MATCH_NOMATCH
);
2347 if (eptr
>= md
->end_subject
)
2350 RRETURN(MATCH_NOMATCH
);
2352 GETCHARINCTEST(c
, eptr
);
2354 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2357 (md
->ctypes
[c
] & ctype_digit
) == 0
2359 RRETURN(MATCH_NOMATCH
);
2363 case OP_NOT_WHITESPACE
:
2364 if (eptr
>= md
->end_subject
)
2367 RRETURN(MATCH_NOMATCH
);
2369 GETCHARINCTEST(c
, eptr
);
2371 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2374 (md
->ctypes
[c
] & ctype_space
) != 0
2376 RRETURN(MATCH_NOMATCH
);
2381 if (eptr
>= md
->end_subject
)
2384 RRETURN(MATCH_NOMATCH
);
2386 GETCHARINCTEST(c
, eptr
);
2388 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2391 (md
->ctypes
[c
] & ctype_space
) == 0
2393 RRETURN(MATCH_NOMATCH
);
2397 case OP_NOT_WORDCHAR
:
2398 if (eptr
>= md
->end_subject
)
2401 RRETURN(MATCH_NOMATCH
);
2403 GETCHARINCTEST(c
, eptr
);
2405 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2408 (md
->ctypes
[c
] & ctype_word
) != 0
2410 RRETURN(MATCH_NOMATCH
);
2415 if (eptr
>= md
->end_subject
)
2418 RRETURN(MATCH_NOMATCH
);
2420 GETCHARINCTEST(c
, eptr
);
2422 #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2425 (md
->ctypes
[c
] & ctype_word
) == 0
2427 RRETURN(MATCH_NOMATCH
);
2432 if (eptr
>= md
->end_subject
)
2435 RRETURN(MATCH_NOMATCH
);
2437 GETCHARINCTEST(c
, eptr
);
2440 default: RRETURN(MATCH_NOMATCH
);
2443 if (eptr
>= md
->end_subject
)
2447 else if (UCHAR21TEST(eptr
) == CHAR_LF
) eptr
++;
2459 #endif /* Not EBCDIC */
2460 if (md
->bsr_anycrlf
) RRETURN(MATCH_NOMATCH
);
2467 if (eptr
>= md
->end_subject
)
2470 RRETURN(MATCH_NOMATCH
);
2472 GETCHARINCTEST(c
, eptr
);
2475 HSPACE_CASES
: RRETURN(MATCH_NOMATCH
); /* Byte and multibyte cases */
2482 if (eptr
>= md
->end_subject
)
2485 RRETURN(MATCH_NOMATCH
);
2487 GETCHARINCTEST(c
, eptr
);
2490 HSPACE_CASES
: break; /* Byte and multibyte cases */
2491 default: RRETURN(MATCH_NOMATCH
);
2497 if (eptr
>= md
->end_subject
)
2500 RRETURN(MATCH_NOMATCH
);
2502 GETCHARINCTEST(c
, eptr
);
2505 VSPACE_CASES
: RRETURN(MATCH_NOMATCH
);
2512 if (eptr
>= md
->end_subject
)
2515 RRETURN(MATCH_NOMATCH
);
2517 GETCHARINCTEST(c
, eptr
);
2520 VSPACE_CASES
: break;
2521 default: RRETURN(MATCH_NOMATCH
);
2527 /* Check the next character by Unicode property. We will get here only
2528 if the support is in the binary; otherwise a compile-time error occurs. */
2532 if (eptr
>= md
->end_subject
)
2535 RRETURN(MATCH_NOMATCH
);
2537 GETCHARINCTEST(c
, eptr
);
2539 const pcre_uint32
*cp
;
2540 const ucd_record
*prop
= GET_UCD(c
);
2545 if (op
== OP_NOTPROP
) RRETURN(MATCH_NOMATCH
);
2549 if ((prop
->chartype
== ucp_Lu
||
2550 prop
->chartype
== ucp_Ll
||
2551 prop
->chartype
== ucp_Lt
) == (op
== OP_NOTPROP
))
2552 RRETURN(MATCH_NOMATCH
);
2556 if ((ecode
[2] != PRIV(ucp_gentype
)[prop
->chartype
]) == (op
== OP_PROP
))
2557 RRETURN(MATCH_NOMATCH
);
2561 if ((ecode
[2] != prop
->chartype
) == (op
== OP_PROP
))
2562 RRETURN(MATCH_NOMATCH
);
2566 if ((ecode
[2] != prop
->script
) == (op
== OP_PROP
))
2567 RRETURN(MATCH_NOMATCH
);
2570 /* These are specials */
2573 if ((PRIV(ucp_gentype
)[prop
->chartype
] == ucp_L
||
2574 PRIV(ucp_gentype
)[prop
->chartype
] == ucp_N
) == (op
== OP_NOTPROP
))
2575 RRETURN(MATCH_NOMATCH
);
2578 /* Perl space used to exclude VT, but from Perl 5.18 it is included,
2579 which means that Perl space and POSIX space are now identical. PCRE
2580 was changed at release 8.34. */
2582 case PT_SPACE
: /* Perl space */
2583 case PT_PXSPACE
: /* POSIX space */
2588 if (op
== OP_NOTPROP
) RRETURN(MATCH_NOMATCH
);
2592 if ((PRIV(ucp_gentype
)[prop
->chartype
] == ucp_Z
) ==
2593 (op
== OP_NOTPROP
)) RRETURN(MATCH_NOMATCH
);
2599 if ((PRIV(ucp_gentype
)[prop
->chartype
] == ucp_L
||
2600 PRIV(ucp_gentype
)[prop
->chartype
] == ucp_N
||
2601 c
== CHAR_UNDERSCORE
) == (op
== OP_NOTPROP
))
2602 RRETURN(MATCH_NOMATCH
);
2606 cp
= PRIV(ucd_caseless_sets
) + ecode
[2];
2610 { if (op
== OP_PROP
) { RRETURN(MATCH_NOMATCH
); } else break; }
2612 { if (op
== OP_PROP
) break; else { RRETURN(MATCH_NOMATCH
); } }
2617 if ((c
== CHAR_DOLLAR_SIGN
|| c
== CHAR_COMMERCIAL_AT
||
2618 c
== CHAR_GRAVE_ACCENT
|| (c
>= 0xa0 && c
<= 0xd7ff) ||
2619 c
>= 0xe000) == (op
== OP_NOTPROP
))
2620 RRETURN(MATCH_NOMATCH
);
2623 /* This should never occur */
2626 RRETURN(PCRE_ERROR_INTERNAL
);
2633 /* Match an extended Unicode sequence. We will get here only if the support
2634 is in the binary; otherwise a compile-time error occurs. */
2637 if (eptr
>= md
->end_subject
)
2640 RRETURN(MATCH_NOMATCH
);
2645 GETCHARINCTEST(c
, eptr
);
2646 lgb
= UCD_GRAPHBREAK(c
);
2647 while (eptr
< md
->end_subject
)
2650 if (!utf
) c
= *eptr
; else { GETCHARLEN(c
, eptr
, len
); }
2651 rgb
= UCD_GRAPHBREAK(c
);
2652 if ((PRIV(ucp_gbtable
)[lgb
] & (1 << rgb
)) == 0) break;
2660 #endif /* SUPPORT_UCP */
2663 /* Match a back reference, possibly repeatedly. Look past the end of the
2664 item to see if there is repeat information following. The code is similar
2665 to that for character classes, but repeated for efficiency. Then obey
2666 similar code to character type repeats - written out again for speed.
2667 However, if the referenced string is the empty string, always treat
2668 it as matched, any number of times (otherwise there could be infinite
2669 loops). If the reference is unset, there are two possibilities:
2671 (a) In the default, Perl-compatible state, set the length negative;
2672 this ensures that every attempt at a match fails. We can't just fail
2673 here, because of the possibility of quantifiers with zero minima.
2675 (b) If the JavaScript compatibility flag is set, set the length to zero
2676 so that the back reference matches an empty string.
2678 Otherwise, set the length to the length of what was matched by the
2679 referenced subpattern.
2681 The OP_REF and OP_REFI opcodes are used for a reference to a numbered group
2682 or to a non-duplicated named group. For a duplicated named group, OP_DNREF
2683 and OP_DNREFI are used. In this case we must scan the list of groups to
2684 which the name refers, and use the first one that is set. */
2688 caseless
= op
== OP_DNREFI
;
2690 int count
= GET2(ecode
, 1+IMM2_SIZE
);
2691 pcre_uchar
*slot
= md
->name_table
+ GET2(ecode
, 1) * md
->name_entry_size
;
2692 ecode
+= 1 + 2*IMM2_SIZE
;
2694 /* Setting the default length first and initializing 'offset' avoids
2695 compiler warnings in the REF_REPEAT code. */
2697 length
= (md
->jscript_compat
)? 0 : -1;
2702 offset
= GET2(slot
, 0) << 1;
2703 if (offset
< offset_top
&& md
->offset_vector
[offset
] >= 0)
2705 length
= md
->offset_vector
[offset
+1] - md
->offset_vector
[offset
];
2708 slot
+= md
->name_entry_size
;
2715 caseless
= op
== OP_REFI
;
2716 offset
= GET2(ecode
, 1) << 1; /* Doubled ref number */
2717 ecode
+= 1 + IMM2_SIZE
;
2718 if (offset
>= offset_top
|| md
->offset_vector
[offset
] < 0)
2719 length
= (md
->jscript_compat
)? 0 : -1;
2721 length
= md
->offset_vector
[offset
+1] - md
->offset_vector
[offset
];
2723 /* Set up for repetition, or handle the non-repeated case */
2734 c
= *ecode
++ - OP_CRSTAR
;
2735 minimize
= (c
& 1) != 0;
2736 min
= rep_min
[c
]; /* Pick up values from tables; */
2737 max
= rep_max
[c
]; /* zero for max => infinity */
2738 if (max
== 0) max
= INT_MAX
;
2743 minimize
= (*ecode
== OP_CRMINRANGE
);
2744 min
= GET2(ecode
, 1);
2745 max
= GET2(ecode
, 1 + IMM2_SIZE
);
2746 if (max
== 0) max
= INT_MAX
;
2747 ecode
+= 1 + 2 * IMM2_SIZE
;
2750 default: /* No repeat follows */
2751 if ((length
= match_ref(offset
, eptr
, length
, md
, caseless
)) < 0)
2753 if (length
== -2) eptr
= md
->end_subject
; /* Partial match */
2755 RRETURN(MATCH_NOMATCH
);
2758 continue; /* With the main loop */
2761 /* Handle repeated back references. If the length of the reference is
2762 zero, just continue with the main loop. If the length is negative, it
2763 means the reference is unset in non-Java-compatible mode. If the minimum is
2764 zero, we can continue at the same level without recursion. For any other
2765 minimum, carrying on will result in NOMATCH. */
2767 if (length
== 0) continue;
2768 if (length
< 0 && min
== 0) continue;
2770 /* First, ensure the minimum number of matches are present. We get back
2771 the length of the reference string explicitly rather than passing the
2772 address of eptr, so that eptr can be a register variable. */
2774 for (i
= 1; i
<= min
; i
++)
2777 if ((slength
= match_ref(offset
, eptr
, length
, md
, caseless
)) < 0)
2779 if (slength
== -2) eptr
= md
->end_subject
; /* Partial match */
2781 RRETURN(MATCH_NOMATCH
);
2786 /* If min = max, continue at the same level without recursion.
2787 They are not both allowed to be zero. */
2789 if (min
== max
) continue;
2791 /* If minimizing, keep trying and advancing the pointer */
2795 for (fi
= min
;; fi
++)
2798 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM14
);
2799 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2800 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
2801 if ((slength
= match_ref(offset
, eptr
, length
, md
, caseless
)) < 0)
2803 if (slength
== -2) eptr
= md
->end_subject
; /* Partial match */
2805 RRETURN(MATCH_NOMATCH
);
2809 /* Control never gets here */
2812 /* If maximizing, find the longest string and work backwards */
2817 for (i
= min
; i
< max
; i
++)
2820 if ((slength
= match_ref(offset
, eptr
, length
, md
, caseless
)) < 0)
2822 /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2823 the soft partial matching case. */
2825 if (slength
== -2 && md
->partial
!= 0 &&
2826 md
->end_subject
> md
->start_used_ptr
)
2829 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
2838 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM15
);
2839 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2842 RRETURN(MATCH_NOMATCH
);
2844 /* Control never gets here */
2846 /* Match a bit-mapped character class, possibly repeatedly. This op code is
2847 used when all the characters in the class have values in the range 0-255,
2848 and either the matching is caseful, or the characters are in the range
2849 0-127 when UTF-8 processing is enabled. The only difference between
2850 OP_CLASS and OP_NCLASS occurs when a data character outside the range is
2853 First, look past the end of the item to see if there is repeat information
2854 following. Then obey similar code to character type repeats - written out
2860 /* The data variable is saved across frames, so the byte map needs to
2862 #define BYTE_MAP ((pcre_uint8 *)data)
2863 data
= ecode
+ 1; /* Save for matching */
2864 ecode
+= 1 + (32 / sizeof(pcre_uchar
)); /* Advance past the item */
2877 c
= *ecode
++ - OP_CRSTAR
;
2878 if (c
< OP_CRPOSSTAR
- OP_CRSTAR
) minimize
= (c
& 1) != 0;
2879 else possessive
= TRUE
;
2880 min
= rep_min
[c
]; /* Pick up values from tables; */
2881 max
= rep_max
[c
]; /* zero for max => infinity */
2882 if (max
== 0) max
= INT_MAX
;
2888 minimize
= (*ecode
== OP_CRMINRANGE
);
2889 possessive
= (*ecode
== OP_CRPOSRANGE
);
2890 min
= GET2(ecode
, 1);
2891 max
= GET2(ecode
, 1 + IMM2_SIZE
);
2892 if (max
== 0) max
= INT_MAX
;
2893 ecode
+= 1 + 2 * IMM2_SIZE
;
2896 default: /* No repeat follows */
2901 /* First, ensure the minimum number of matches are present. */
2906 for (i
= 1; i
<= min
; i
++)
2908 if (eptr
>= md
->end_subject
)
2911 RRETURN(MATCH_NOMATCH
);
2913 GETCHARINC(c
, eptr
);
2916 if (op
== OP_CLASS
) RRETURN(MATCH_NOMATCH
);
2919 if ((BYTE_MAP
[c
/8] & (1 << (c
&7))) == 0) RRETURN(MATCH_NOMATCH
);
2926 for (i
= 1; i
<= min
; i
++)
2928 if (eptr
>= md
->end_subject
)
2931 RRETURN(MATCH_NOMATCH
);
2934 #ifndef COMPILE_PCRE8
2937 if (op
== OP_CLASS
) RRETURN(MATCH_NOMATCH
);
2941 if ((BYTE_MAP
[c
/8] & (1 << (c
&7))) == 0) RRETURN(MATCH_NOMATCH
);
2945 /* If max == min we can continue with the main loop without the
2948 if (min
== max
) continue;
2950 /* If minimizing, keep testing the rest of the expression and advancing
2951 the pointer while it matches the class. */
2958 for (fi
= min
;; fi
++)
2960 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM16
);
2961 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2962 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
2963 if (eptr
>= md
->end_subject
)
2966 RRETURN(MATCH_NOMATCH
);
2968 GETCHARINC(c
, eptr
);
2971 if (op
== OP_CLASS
) RRETURN(MATCH_NOMATCH
);
2974 if ((BYTE_MAP
[c
/8] & (1 << (c
&7))) == 0) RRETURN(MATCH_NOMATCH
);
2981 for (fi
= min
;; fi
++)
2983 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM17
);
2984 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
2985 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
2986 if (eptr
>= md
->end_subject
)
2989 RRETURN(MATCH_NOMATCH
);
2992 #ifndef COMPILE_PCRE8
2995 if (op
== OP_CLASS
) RRETURN(MATCH_NOMATCH
);
2999 if ((BYTE_MAP
[c
/8] & (1 << (c
&7))) == 0) RRETURN(MATCH_NOMATCH
);
3002 /* Control never gets here */
3005 /* If maximizing, find the longest possible run, then work backwards. */
3014 for (i
= min
; i
< max
; i
++)
3017 if (eptr
>= md
->end_subject
)
3022 GETCHARLEN(c
, eptr
, len
);
3025 if (op
== OP_CLASS
) break;
3028 if ((BYTE_MAP
[c
/8] & (1 << (c
&7))) == 0) break;
3032 if (possessive
) continue; /* No backtracking */
3036 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM18
);
3037 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3038 if (eptr
-- == pp
) break; /* Stop if tried at original pos */
3046 for (i
= min
; i
< max
; i
++)
3048 if (eptr
>= md
->end_subject
)
3054 #ifndef COMPILE_PCRE8
3057 if (op
== OP_CLASS
) break;
3061 if ((BYTE_MAP
[c
/8] & (1 << (c
&7))) == 0) break;
3065 if (possessive
) continue; /* No backtracking */
3069 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM19
);
3070 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3075 RRETURN(MATCH_NOMATCH
);
3079 /* Control never gets here */
3082 /* Match an extended character class. In the 8-bit library, this opcode is
3083 encountered only when UTF-8 mode mode is supported. In the 16-bit and
3084 32-bit libraries, codepoints greater than 255 may be encountered even when
3085 UTF is not supported. */
3087 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3090 data
= ecode
+ 1 + LINK_SIZE
; /* Save for matching */
3091 ecode
+= GET(ecode
, 1); /* Advance past the item */
3104 c
= *ecode
++ - OP_CRSTAR
;
3105 if (c
< OP_CRPOSSTAR
- OP_CRSTAR
) minimize
= (c
& 1) != 0;
3106 else possessive
= TRUE
;
3107 min
= rep_min
[c
]; /* Pick up values from tables; */
3108 max
= rep_max
[c
]; /* zero for max => infinity */
3109 if (max
== 0) max
= INT_MAX
;
3115 minimize
= (*ecode
== OP_CRMINRANGE
);
3116 possessive
= (*ecode
== OP_CRPOSRANGE
);
3117 min
= GET2(ecode
, 1);
3118 max
= GET2(ecode
, 1 + IMM2_SIZE
);
3119 if (max
== 0) max
= INT_MAX
;
3120 ecode
+= 1 + 2 * IMM2_SIZE
;
3123 default: /* No repeat follows */
3128 /* First, ensure the minimum number of matches are present. */
3130 for (i
= 1; i
<= min
; i
++)
3132 if (eptr
>= md
->end_subject
)
3135 RRETURN(MATCH_NOMATCH
);
3137 GETCHARINCTEST(c
, eptr
);
3138 if (!PRIV(xclass
)(c
, data
, utf
)) RRETURN(MATCH_NOMATCH
);
3141 /* If max == min we can continue with the main loop without the
3144 if (min
== max
) continue;
3146 /* If minimizing, keep testing the rest of the expression and advancing
3147 the pointer while it matches the class. */
3151 for (fi
= min
;; fi
++)
3153 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM20
);
3154 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3155 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
3156 if (eptr
>= md
->end_subject
)
3159 RRETURN(MATCH_NOMATCH
);
3161 GETCHARINCTEST(c
, eptr
);
3162 if (!PRIV(xclass
)(c
, data
, utf
)) RRETURN(MATCH_NOMATCH
);
3164 /* Control never gets here */
3167 /* If maximizing, find the longest possible run, then work backwards. */
3172 for (i
= min
; i
< max
; i
++)
3175 if (eptr
>= md
->end_subject
)
3181 GETCHARLENTEST(c
, eptr
, len
);
3185 if (!PRIV(xclass
)(c
, data
, utf
)) break;
3189 if (possessive
) continue; /* No backtracking */
3193 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM21
);
3194 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3195 if (eptr
-- == pp
) break; /* Stop if tried at original pos */
3197 if (utf
) BACKCHAR(eptr
);
3200 RRETURN(MATCH_NOMATCH
);
3203 /* Control never gets here */
3205 #endif /* End of XCLASS */
3207 /* Match a single character, casefully */
3215 GETCHARLEN(fc
, ecode
, length
);
3216 if (length
> md
->end_subject
- eptr
)
3218 CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */
3219 RRETURN(MATCH_NOMATCH
);
3221 while (length
-- > 0) if (*ecode
++ != UCHAR21INC(eptr
)) RRETURN(MATCH_NOMATCH
);
3227 if (md
->end_subject
- eptr
< 1)
3229 SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */
3230 RRETURN(MATCH_NOMATCH
);
3232 if (ecode
[1] != *eptr
++) RRETURN(MATCH_NOMATCH
);
3237 /* Match a single character, caselessly. If we are at the end of the
3238 subject, give up immediately. */
3241 if (eptr
>= md
->end_subject
)
3244 RRETURN(MATCH_NOMATCH
);
3252 GETCHARLEN(fc
, ecode
, length
);
3254 /* If the pattern character's value is < 128, we have only one byte, and
3255 we know that its other case must also be one byte long, so we can use the
3256 fast lookup table. We know that there is at least one byte left in the
3261 pcre_uint32 cc
= UCHAR21(eptr
);
3262 if (md
->lcc
[fc
] != TABLE_GET(cc
, md
->lcc
, cc
)) RRETURN(MATCH_NOMATCH
);
3267 /* Otherwise we must pick up the subject character. Note that we cannot
3268 use the value of "length" to check for sufficient bytes left, because the
3269 other case of the character may have more or fewer bytes. */
3274 GETCHARINC(dc
, eptr
);
3277 /* If we have Unicode property support, we can use it to test the other
3278 case of the character, if there is one. */
3283 if (dc
!= UCD_OTHERCASE(fc
))
3285 RRETURN(MATCH_NOMATCH
);
3290 #endif /* SUPPORT_UTF */
3294 if (TABLE_GET(ecode
[1], md
->lcc
, ecode
[1])
3295 != TABLE_GET(*eptr
, md
->lcc
, *eptr
)) RRETURN(MATCH_NOMATCH
);
3301 /* Match a single character repeatedly. */
3305 min
= max
= GET2(ecode
, 1);
3306 ecode
+= 1 + IMM2_SIZE
;
3319 max
= GET2(ecode
, 1);
3320 minimize
= *ecode
== OP_MINUPTO
|| *ecode
== OP_MINUPTOI
;
3321 ecode
+= 1 + IMM2_SIZE
;
3360 c
= *ecode
++ - ((op
< OP_STARI
)? OP_STAR
: OP_STARI
);
3361 minimize
= (c
& 1) != 0;
3362 min
= rep_min
[c
]; /* Pick up values from tables; */
3363 max
= rep_max
[c
]; /* zero for max => infinity */
3364 if (max
== 0) max
= INT_MAX
;
3366 /* Common code for all repeated single-character matches. We first check
3367 for the minimum number of characters. If the minimum equals the maximum, we
3368 are done. Otherwise, if minimizing, check the rest of the pattern for a
3369 match; if there isn't one, advance up to the maximum, one character at a
3372 If maximizing, advance up to the maximum number of matching characters,
3373 until eptr is past the end of the maximum run. If possessive, we are
3374 then done (no backing up). Otherwise, match at this position; anything
3375 other than no match is immediately returned. For nomatch, back up one
3376 character, unless we are matching \R and the last thing matched was
3377 \r\n, in which case, back up two bytes. When we reach the first optional
3378 character position, we can save stack by doing a tail recurse.
3380 The various UTF/non-UTF and caseful/caseless cases are handled separately,
3389 GETCHARLEN(fc
, ecode
, length
);
3392 /* Handle multibyte character matching specially here. There is
3393 support for caseless matching if UCP support is present. */
3398 pcre_uint32 othercase
;
3399 if (op
>= OP_STARI
&& /* Caseless */
3400 (othercase
= UCD_OTHERCASE(fc
)) != fc
)
3401 oclength
= PRIV(ord2utf
)(othercase
, occhars
);
3403 #endif /* SUPPORT_UCP */
3405 for (i
= 1; i
<= min
; i
++)
3407 if (eptr
<= md
->end_subject
- length
&&
3408 memcmp(eptr
, charptr
, IN_UCHARS(length
)) == 0) eptr
+= length
;
3410 else if (oclength
> 0 &&
3411 eptr
<= md
->end_subject
- oclength
&&
3412 memcmp(eptr
, occhars
, IN_UCHARS(oclength
)) == 0) eptr
+= oclength
;
3413 #endif /* SUPPORT_UCP */
3417 RRETURN(MATCH_NOMATCH
);
3421 if (min
== max
) continue;
3425 for (fi
= min
;; fi
++)
3427 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM22
);
3428 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3429 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
3430 if (eptr
<= md
->end_subject
- length
&&
3431 memcmp(eptr
, charptr
, IN_UCHARS(length
)) == 0) eptr
+= length
;
3433 else if (oclength
> 0 &&
3434 eptr
<= md
->end_subject
- oclength
&&
3435 memcmp(eptr
, occhars
, IN_UCHARS(oclength
)) == 0) eptr
+= oclength
;
3436 #endif /* SUPPORT_UCP */
3440 RRETURN(MATCH_NOMATCH
);
3443 /* Control never gets here */
3449 for (i
= min
; i
< max
; i
++)
3451 if (eptr
<= md
->end_subject
- length
&&
3452 memcmp(eptr
, charptr
, IN_UCHARS(length
)) == 0) eptr
+= length
;
3454 else if (oclength
> 0 &&
3455 eptr
<= md
->end_subject
- oclength
&&
3456 memcmp(eptr
, occhars
, IN_UCHARS(oclength
)) == 0) eptr
+= oclength
;
3457 #endif /* SUPPORT_UCP */
3465 if (possessive
) continue; /* No backtracking */
3468 if (eptr
== pp
) goto TAIL_RECURSE
;
3469 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM23
);
3470 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3474 #else /* without SUPPORT_UCP */
3476 #endif /* SUPPORT_UCP */
3479 /* Control never gets here */
3482 /* If the length of a UTF-8 character is 1, we fall through here, and
3483 obey the code as for non-UTF-8 characters below, though in this case the
3484 value of fc will always be < 128. */
3487 #endif /* SUPPORT_UTF */
3488 /* When not in UTF-8 mode, load a single-byte character. */
3491 /* The value of fc at this point is always one character, though we may
3492 or may not be in UTF mode. The code is duplicated for the caseless and
3493 caseful cases, for speed, since matching characters is likely to be quite
3494 common. First, ensure the minimum number of matches are present. If min =
3495 max, continue at the same level without recursing. Otherwise, if
3496 minimizing, keep trying the rest of the expression and advancing one
3497 matching character if failing, up to the maximum. Alternatively, if
3498 maximizing, find the maximum number of characters and work backwards. */
3500 DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc
, min
, max
,
3501 max
, (char *)eptr
));
3503 if (op
>= OP_STARI
) /* Caseless */
3505 #ifdef COMPILE_PCRE8
3506 /* fc must be < 128 if UTF is enabled. */
3511 if (utf
&& fc
> 127)
3512 foc
= UCD_OTHERCASE(fc
);
3514 if (utf
&& fc
> 127)
3516 #endif /* SUPPORT_UCP */
3518 #endif /* SUPPORT_UTF */
3519 foc
= TABLE_GET(fc
, md
->fcc
, fc
);
3520 #endif /* COMPILE_PCRE8 */
3522 for (i
= 1; i
<= min
; i
++)
3524 pcre_uint32 cc
; /* Faster than pcre_uchar */
3525 if (eptr
>= md
->end_subject
)
3528 RRETURN(MATCH_NOMATCH
);
3530 cc
= UCHAR21TEST(eptr
);
3531 if (fc
!= cc
&& foc
!= cc
) RRETURN(MATCH_NOMATCH
);
3534 if (min
== max
) continue;
3537 for (fi
= min
;; fi
++)
3539 pcre_uint32 cc
; /* Faster than pcre_uchar */
3540 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM24
);
3541 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3542 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
3543 if (eptr
>= md
->end_subject
)
3546 RRETURN(MATCH_NOMATCH
);
3548 cc
= UCHAR21TEST(eptr
);
3549 if (fc
!= cc
&& foc
!= cc
) RRETURN(MATCH_NOMATCH
);
3552 /* Control never gets here */
3557 for (i
= min
; i
< max
; i
++)
3559 pcre_uint32 cc
; /* Faster than pcre_uchar */
3560 if (eptr
>= md
->end_subject
)
3565 cc
= UCHAR21TEST(eptr
);
3566 if (fc
!= cc
&& foc
!= cc
) break;
3569 if (possessive
) continue; /* No backtracking */
3572 if (eptr
== pp
) goto TAIL_RECURSE
;
3573 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM25
);
3575 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3577 /* Control never gets here */
3581 /* Caseful comparisons (includes all multi-byte characters) */
3585 for (i
= 1; i
<= min
; i
++)
3587 if (eptr
>= md
->end_subject
)
3590 RRETURN(MATCH_NOMATCH
);
3592 if (fc
!= UCHAR21INCTEST(eptr
)) RRETURN(MATCH_NOMATCH
);
3595 if (min
== max
) continue;
3599 for (fi
= min
;; fi
++)
3601 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM26
);
3602 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3603 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
3604 if (eptr
>= md
->end_subject
)
3607 RRETURN(MATCH_NOMATCH
);
3609 if (fc
!= UCHAR21INCTEST(eptr
)) RRETURN(MATCH_NOMATCH
);
3611 /* Control never gets here */
3616 for (i
= min
; i
< max
; i
++)
3618 if (eptr
>= md
->end_subject
)
3623 if (fc
!= UCHAR21TEST(eptr
)) break;
3626 if (possessive
) continue; /* No backtracking */
3629 if (eptr
== pp
) goto TAIL_RECURSE
;
3630 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM27
);
3632 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3634 /* Control never gets here */
3637 /* Control never gets here */
3639 /* Match a negated single one-byte character. The character we are
3640 checking can be multibyte. */
3644 if (eptr
>= md
->end_subject
)
3647 RRETURN(MATCH_NOMATCH
);
3652 register pcre_uint32 ch
, och
;
3655 GETCHARINC(ch
, ecode
);
3656 GETCHARINC(c
, eptr
);
3660 if (ch
== c
) RRETURN(MATCH_NOMATCH
);
3666 och
= UCD_OTHERCASE(ch
);
3670 #endif /* SUPPORT_UCP */
3672 och
= TABLE_GET(ch
, md
->fcc
, ch
);
3673 if (ch
== c
|| och
== c
) RRETURN(MATCH_NOMATCH
);
3679 register pcre_uint32 ch
= ecode
[1];
3681 if (ch
== c
|| (op
== OP_NOTI
&& TABLE_GET(ch
, md
->fcc
, ch
) == c
))
3682 RRETURN(MATCH_NOMATCH
);
3687 /* Match a negated single one-byte character repeatedly. This is almost a
3688 repeat of the code for a repeated single character, but I haven't found a
3689 nice way of commoning these up that doesn't require a test of the
3690 positive/negative option for each character match. Maybe that wouldn't add
3691 very much to the time taken, but character matching *is* what this is all
3696 min
= max
= GET2(ecode
, 1);
3697 ecode
+= 1 + IMM2_SIZE
;
3703 case OP_NOTMINUPTOI
:
3705 max
= GET2(ecode
, 1);
3706 minimize
= *ecode
== OP_NOTMINUPTO
|| *ecode
== OP_NOTMINUPTOI
;
3707 ecode
+= 1 + IMM2_SIZE
;
3711 case OP_NOTPOSSTARI
:
3719 case OP_NOTPOSPLUSI
:
3726 case OP_NOTPOSQUERY
:
3727 case OP_NOTPOSQUERYI
:
3735 case OP_NOTPOSUPTOI
:
3738 max
= GET2(ecode
, 1);
3739 ecode
+= 1 + IMM2_SIZE
;
3745 case OP_NOTMINSTARI
:
3749 case OP_NOTMINPLUSI
:
3752 case OP_NOTMINQUERY
:
3753 case OP_NOTMINQUERYI
:
3754 c
= *ecode
++ - ((op
>= OP_NOTSTARI
)? OP_NOTSTARI
: OP_NOTSTAR
);
3755 minimize
= (c
& 1) != 0;
3756 min
= rep_min
[c
]; /* Pick up values from tables; */
3757 max
= rep_max
[c
]; /* zero for max => infinity */
3758 if (max
== 0) max
= INT_MAX
;
3760 /* Common code for all repeated single-byte matches. */
3763 GETCHARINCTEST(fc
, ecode
);
3765 /* The code is duplicated for the caseless and caseful cases, for speed,
3766 since matching characters is likely to be quite common. First, ensure the
3767 minimum number of matches are present. If min = max, continue at the same
3768 level without recursing. Otherwise, if minimizing, keep trying the rest of
3769 the expression and advancing one matching character if failing, up to the
3770 maximum. Alternatively, if maximizing, find the maximum number of
3771 characters and work backwards. */
3773 DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc
, min
, max
,
3774 max
, (char *)eptr
));
3776 if (op
>= OP_NOTSTARI
) /* Caseless */
3780 if (utf
&& fc
> 127)
3781 foc
= UCD_OTHERCASE(fc
);
3783 if (utf
&& fc
> 127)
3785 #endif /* SUPPORT_UCP */
3787 #endif /* SUPPORT_UTF */
3788 foc
= TABLE_GET(fc
, md
->fcc
, fc
);
3793 register pcre_uint32 d
;
3794 for (i
= 1; i
<= min
; i
++)
3796 if (eptr
>= md
->end_subject
)
3799 RRETURN(MATCH_NOMATCH
);
3801 GETCHARINC(d
, eptr
);
3802 if (fc
== d
|| (unsigned int)foc
== d
) RRETURN(MATCH_NOMATCH
);
3806 #endif /* SUPPORT_UTF */
3809 for (i
= 1; i
<= min
; i
++)
3811 if (eptr
>= md
->end_subject
)
3814 RRETURN(MATCH_NOMATCH
);
3816 if (fc
== *eptr
|| foc
== *eptr
) RRETURN(MATCH_NOMATCH
);
3821 if (min
== max
) continue;
3828 register pcre_uint32 d
;
3829 for (fi
= min
;; fi
++)
3831 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM28
);
3832 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3833 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
3834 if (eptr
>= md
->end_subject
)
3837 RRETURN(MATCH_NOMATCH
);
3839 GETCHARINC(d
, eptr
);
3840 if (fc
== d
|| (unsigned int)foc
== d
) RRETURN(MATCH_NOMATCH
);
3844 #endif /*SUPPORT_UTF */
3847 for (fi
= min
;; fi
++)
3849 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM29
);
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 if (fc
== *eptr
|| foc
== *eptr
) RRETURN(MATCH_NOMATCH
);
3861 /* Control never gets here */
3873 register pcre_uint32 d
;
3874 for (i
= min
; i
< max
; i
++)
3877 if (eptr
>= md
->end_subject
)
3882 GETCHARLEN(d
, eptr
, len
);
3883 if (fc
== d
|| (unsigned int)foc
== d
) break;
3886 if (possessive
) continue; /* No backtracking */
3889 if (eptr
== pp
) goto TAIL_RECURSE
;
3890 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM30
);
3891 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3897 #endif /* SUPPORT_UTF */
3900 for (i
= min
; i
< max
; i
++)
3902 if (eptr
>= md
->end_subject
)
3907 if (fc
== *eptr
|| foc
== *eptr
) break;
3910 if (possessive
) continue; /* No backtracking */
3913 if (eptr
== pp
) goto TAIL_RECURSE
;
3914 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM31
);
3915 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3919 /* Control never gets here */
3923 /* Caseful comparisons */
3930 register pcre_uint32 d
;
3931 for (i
= 1; i
<= min
; i
++)
3933 if (eptr
>= md
->end_subject
)
3936 RRETURN(MATCH_NOMATCH
);
3938 GETCHARINC(d
, eptr
);
3939 if (fc
== d
) RRETURN(MATCH_NOMATCH
);
3946 for (i
= 1; i
<= min
; i
++)
3948 if (eptr
>= md
->end_subject
)
3951 RRETURN(MATCH_NOMATCH
);
3953 if (fc
== *eptr
++) RRETURN(MATCH_NOMATCH
);
3957 if (min
== max
) continue;
3964 register pcre_uint32 d
;
3965 for (fi
= min
;; fi
++)
3967 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM32
);
3968 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
3969 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
3970 if (eptr
>= md
->end_subject
)
3973 RRETURN(MATCH_NOMATCH
);
3975 GETCHARINC(d
, eptr
);
3976 if (fc
== d
) RRETURN(MATCH_NOMATCH
);
3983 for (fi
= min
;; fi
++)
3985 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM33
);
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 if (fc
== *eptr
++) RRETURN(MATCH_NOMATCH
);
3996 /* Control never gets here */
4008 register pcre_uint32 d
;
4009 for (i
= min
; i
< max
; i
++)
4012 if (eptr
>= md
->end_subject
)
4017 GETCHARLEN(d
, eptr
, len
);
4021 if (possessive
) continue; /* No backtracking */
4024 if (eptr
== pp
) goto TAIL_RECURSE
;
4025 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM34
);
4026 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4035 for (i
= min
; i
< max
; i
++)
4037 if (eptr
>= md
->end_subject
)
4042 if (fc
== *eptr
) break;
4045 if (possessive
) continue; /* No backtracking */
4048 if (eptr
== pp
) goto TAIL_RECURSE
;
4049 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM35
);
4050 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4054 /* Control never gets here */
4057 /* Control never gets here */
4059 /* Match a single character type repeatedly; several different opcodes
4060 share code. This is very similar to the code for single characters, but we
4061 repeat it in the interests of efficiency. */
4064 min
= max
= GET2(ecode
, 1);
4066 ecode
+= 1 + IMM2_SIZE
;
4070 case OP_TYPEMINUPTO
:
4072 max
= GET2(ecode
, 1);
4073 minimize
= *ecode
== OP_TYPEMINUPTO
;
4074 ecode
+= 1 + IMM2_SIZE
;
4077 case OP_TYPEPOSSTAR
:
4084 case OP_TYPEPOSPLUS
:
4091 case OP_TYPEPOSQUERY
:
4098 case OP_TYPEPOSUPTO
:
4101 max
= GET2(ecode
, 1);
4102 ecode
+= 1 + IMM2_SIZE
;
4106 case OP_TYPEMINSTAR
:
4108 case OP_TYPEMINPLUS
:
4110 case OP_TYPEMINQUERY
:
4111 c
= *ecode
++ - OP_TYPESTAR
;
4112 minimize
= (c
& 1) != 0;
4113 min
= rep_min
[c
]; /* Pick up values from tables; */
4114 max
= rep_max
[c
]; /* zero for max => infinity */
4115 if (max
== 0) max
= INT_MAX
;
4117 /* Common code for all repeated single character type matches. Note that
4118 in UTF-8 mode, '.' matches a character of any length, but for the other
4119 character types, the valid characters are all one-byte long. */
4122 ctype
= *ecode
++; /* Code for the character type */
4125 if (ctype
== OP_PROP
|| ctype
== OP_NOTPROP
)
4127 prop_fail_result
= ctype
== OP_NOTPROP
;
4128 prop_type
= *ecode
++;
4129 prop_value
= *ecode
++;
4131 else prop_type
= -1;
4134 /* First, ensure the minimum number of matches are present. Use inline
4135 code for maximizing the speed, and do the type test once at the start
4136 (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
4137 is tidier. Also separate the UCP code, which can be the same for both UTF-8
4138 and single-bytes. */
4148 if (prop_fail_result
) RRETURN(MATCH_NOMATCH
);
4149 for (i
= 1; i
<= min
; i
++)
4151 if (eptr
>= md
->end_subject
)
4154 RRETURN(MATCH_NOMATCH
);
4156 GETCHARINCTEST(c
, eptr
);
4161 for (i
= 1; i
<= min
; i
++)
4164 if (eptr
>= md
->end_subject
)
4167 RRETURN(MATCH_NOMATCH
);
4169 GETCHARINCTEST(c
, eptr
);
4170 chartype
= UCD_CHARTYPE(c
);
4171 if ((chartype
== ucp_Lu
||
4172 chartype
== ucp_Ll
||
4173 chartype
== ucp_Lt
) == prop_fail_result
)
4174 RRETURN(MATCH_NOMATCH
);
4179 for (i
= 1; i
<= min
; i
++)
4181 if (eptr
>= md
->end_subject
)
4184 RRETURN(MATCH_NOMATCH
);
4186 GETCHARINCTEST(c
, eptr
);
4187 if ((UCD_CATEGORY(c
) == prop_value
) == prop_fail_result
)
4188 RRETURN(MATCH_NOMATCH
);
4193 for (i
= 1; i
<= min
; i
++)
4195 if (eptr
>= md
->end_subject
)
4198 RRETURN(MATCH_NOMATCH
);
4200 GETCHARINCTEST(c
, eptr
);
4201 if ((UCD_CHARTYPE(c
) == prop_value
) == prop_fail_result
)
4202 RRETURN(MATCH_NOMATCH
);
4207 for (i
= 1; i
<= min
; i
++)
4209 if (eptr
>= md
->end_subject
)
4212 RRETURN(MATCH_NOMATCH
);
4214 GETCHARINCTEST(c
, eptr
);
4215 if ((UCD_SCRIPT(c
) == prop_value
) == prop_fail_result
)
4216 RRETURN(MATCH_NOMATCH
);
4221 for (i
= 1; i
<= min
; i
++)
4224 if (eptr
>= md
->end_subject
)
4227 RRETURN(MATCH_NOMATCH
);
4229 GETCHARINCTEST(c
, eptr
);
4230 category
= UCD_CATEGORY(c
);
4231 if ((category
== ucp_L
|| category
== ucp_N
) == prop_fail_result
)
4232 RRETURN(MATCH_NOMATCH
);
4236 /* Perl space used to exclude VT, but from Perl 5.18 it is included,
4237 which means that Perl space and POSIX space are now identical. PCRE
4238 was changed at release 8.34. */
4240 case PT_SPACE
: /* Perl space */
4241 case PT_PXSPACE
: /* POSIX space */
4242 for (i
= 1; i
<= min
; i
++)
4244 if (eptr
>= md
->end_subject
)
4247 RRETURN(MATCH_NOMATCH
);
4249 GETCHARINCTEST(c
, eptr
);
4254 if (prop_fail_result
) RRETURN(MATCH_NOMATCH
);
4258 if ((UCD_CATEGORY(c
) == ucp_Z
) == prop_fail_result
)
4259 RRETURN(MATCH_NOMATCH
);
4266 for (i
= 1; i
<= min
; i
++)
4269 if (eptr
>= md
->end_subject
)
4272 RRETURN(MATCH_NOMATCH
);
4274 GETCHARINCTEST(c
, eptr
);
4275 category
= UCD_CATEGORY(c
);
4276 if ((category
== ucp_L
|| category
== ucp_N
|| c
== CHAR_UNDERSCORE
)
4277 == prop_fail_result
)
4278 RRETURN(MATCH_NOMATCH
);
4283 for (i
= 1; i
<= min
; i
++)
4285 const pcre_uint32
*cp
;
4286 if (eptr
>= md
->end_subject
)
4289 RRETURN(MATCH_NOMATCH
);
4291 GETCHARINCTEST(c
, eptr
);
4292 cp
= PRIV(ucd_caseless_sets
) + prop_value
;
4296 { if (prop_fail_result
) break; else { RRETURN(MATCH_NOMATCH
); } }
4298 { if (prop_fail_result
) { RRETURN(MATCH_NOMATCH
); } else break; }
4304 for (i
= 1; i
<= min
; i
++)
4306 if (eptr
>= md
->end_subject
)
4309 RRETURN(MATCH_NOMATCH
);
4311 GETCHARINCTEST(c
, eptr
);
4312 if ((c
== CHAR_DOLLAR_SIGN
|| c
== CHAR_COMMERCIAL_AT
||
4313 c
== CHAR_GRAVE_ACCENT
|| (c
>= 0xa0 && c
<= 0xd7ff) ||
4314 c
>= 0xe000) == prop_fail_result
)
4315 RRETURN(MATCH_NOMATCH
);
4319 /* This should not occur */
4322 RRETURN(PCRE_ERROR_INTERNAL
);
4326 /* Match extended Unicode sequences. We will get here only if the
4327 support is in the binary; otherwise a compile-time error occurs. */
4329 else if (ctype
== OP_EXTUNI
)
4331 for (i
= 1; i
<= min
; i
++)
4333 if (eptr
>= md
->end_subject
)
4336 RRETURN(MATCH_NOMATCH
);
4341 GETCHARINCTEST(c
, eptr
);
4342 lgb
= UCD_GRAPHBREAK(c
);
4343 while (eptr
< md
->end_subject
)
4346 if (!utf
) c
= *eptr
; else { GETCHARLEN(c
, eptr
, len
); }
4347 rgb
= UCD_GRAPHBREAK(c
);
4348 if ((PRIV(ucp_gbtable
)[lgb
] & (1 << rgb
)) == 0) break;
4358 #endif /* SUPPORT_UCP */
4360 /* Handle all other cases when the coding is UTF-8 */
4363 if (utf
) switch(ctype
)
4366 for (i
= 1; i
<= min
; i
++)
4368 if (eptr
>= md
->end_subject
)
4371 RRETURN(MATCH_NOMATCH
);
4373 if (IS_NEWLINE(eptr
)) RRETURN(MATCH_NOMATCH
);
4374 if (md
->partial
!= 0 &&
4375 eptr
+ 1 >= md
->end_subject
&&
4376 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
4377 NLBLOCK
->nllen
== 2 &&
4378 UCHAR21(eptr
) == NLBLOCK
->nl
[0])
4381 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
4384 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
4389 for (i
= 1; i
<= min
; i
++)
4391 if (eptr
>= md
->end_subject
)
4394 RRETURN(MATCH_NOMATCH
);
4397 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
4402 if (eptr
> md
->end_subject
- min
) RRETURN(MATCH_NOMATCH
);
4407 for (i
= 1; i
<= min
; i
++)
4409 if (eptr
>= md
->end_subject
)
4412 RRETURN(MATCH_NOMATCH
);
4414 GETCHARINC(c
, eptr
);
4417 default: RRETURN(MATCH_NOMATCH
);
4420 if (eptr
< md
->end_subject
&& UCHAR21(eptr
) == CHAR_LF
) eptr
++;
4432 #endif /* Not EBCDIC */
4433 if (md
->bsr_anycrlf
) RRETURN(MATCH_NOMATCH
);
4440 for (i
= 1; i
<= min
; i
++)
4442 if (eptr
>= md
->end_subject
)
4445 RRETURN(MATCH_NOMATCH
);
4447 GETCHARINC(c
, eptr
);
4450 HSPACE_CASES
: RRETURN(MATCH_NOMATCH
); /* Byte and multibyte cases */
4457 for (i
= 1; i
<= min
; i
++)
4459 if (eptr
>= md
->end_subject
)
4462 RRETURN(MATCH_NOMATCH
);
4464 GETCHARINC(c
, eptr
);
4467 HSPACE_CASES
: break; /* Byte and multibyte cases */
4468 default: RRETURN(MATCH_NOMATCH
);
4474 for (i
= 1; i
<= min
; i
++)
4476 if (eptr
>= md
->end_subject
)
4479 RRETURN(MATCH_NOMATCH
);
4481 GETCHARINC(c
, eptr
);
4484 VSPACE_CASES
: RRETURN(MATCH_NOMATCH
);
4491 for (i
= 1; i
<= min
; i
++)
4493 if (eptr
>= md
->end_subject
)
4496 RRETURN(MATCH_NOMATCH
);
4498 GETCHARINC(c
, eptr
);
4501 VSPACE_CASES
: break;
4502 default: RRETURN(MATCH_NOMATCH
);
4508 for (i
= 1; i
<= min
; i
++)
4510 if (eptr
>= md
->end_subject
)
4513 RRETURN(MATCH_NOMATCH
);
4515 GETCHARINC(c
, eptr
);
4516 if (c
< 128 && (md
->ctypes
[c
] & ctype_digit
) != 0)
4517 RRETURN(MATCH_NOMATCH
);
4522 for (i
= 1; i
<= min
; i
++)
4525 if (eptr
>= md
->end_subject
)
4528 RRETURN(MATCH_NOMATCH
);
4531 if (cc
>= 128 || (md
->ctypes
[cc
] & ctype_digit
) == 0)
4532 RRETURN(MATCH_NOMATCH
);
4534 /* No need to skip more bytes - we know it's a 1-byte character */
4538 case OP_NOT_WHITESPACE
:
4539 for (i
= 1; i
<= min
; i
++)
4542 if (eptr
>= md
->end_subject
)
4545 RRETURN(MATCH_NOMATCH
);
4548 if (cc
< 128 && (md
->ctypes
[cc
] & ctype_space
) != 0)
4549 RRETURN(MATCH_NOMATCH
);
4551 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
4556 for (i
= 1; i
<= min
; i
++)
4559 if (eptr
>= md
->end_subject
)
4562 RRETURN(MATCH_NOMATCH
);
4565 if (cc
>= 128 || (md
->ctypes
[cc
] & ctype_space
) == 0)
4566 RRETURN(MATCH_NOMATCH
);
4568 /* No need to skip more bytes - we know it's a 1-byte character */
4572 case OP_NOT_WORDCHAR
:
4573 for (i
= 1; i
<= min
; i
++)
4576 if (eptr
>= md
->end_subject
)
4579 RRETURN(MATCH_NOMATCH
);
4582 if (cc
< 128 && (md
->ctypes
[cc
] & ctype_word
) != 0)
4583 RRETURN(MATCH_NOMATCH
);
4585 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
4590 for (i
= 1; i
<= min
; i
++)
4593 if (eptr
>= md
->end_subject
)
4596 RRETURN(MATCH_NOMATCH
);
4599 if (cc
>= 128 || (md
->ctypes
[cc
] & ctype_word
) == 0)
4600 RRETURN(MATCH_NOMATCH
);
4602 /* No need to skip more bytes - we know it's a 1-byte character */
4607 RRETURN(PCRE_ERROR_INTERNAL
);
4608 } /* End switch(ctype) */
4611 #endif /* SUPPORT_UTF */
4613 /* Code for the non-UTF-8 case for minimum matching of operators other
4614 than OP_PROP and OP_NOTPROP. */
4619 for (i
= 1; i
<= min
; i
++)
4621 if (eptr
>= md
->end_subject
)
4624 RRETURN(MATCH_NOMATCH
);
4626 if (IS_NEWLINE(eptr
)) RRETURN(MATCH_NOMATCH
);
4627 if (md
->partial
!= 0 &&
4628 eptr
+ 1 >= md
->end_subject
&&
4629 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
4630 NLBLOCK
->nllen
== 2 &&
4631 *eptr
== NLBLOCK
->nl
[0])
4634 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
4641 if (eptr
> md
->end_subject
- min
)
4644 RRETURN(MATCH_NOMATCH
);
4650 if (eptr
> md
->end_subject
- min
)
4653 RRETURN(MATCH_NOMATCH
);
4659 for (i
= 1; i
<= min
; i
++)
4661 if (eptr
>= md
->end_subject
)
4664 RRETURN(MATCH_NOMATCH
);
4668 default: RRETURN(MATCH_NOMATCH
);
4671 if (eptr
< md
->end_subject
&& *eptr
== CHAR_LF
) eptr
++;
4680 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4684 if (md
->bsr_anycrlf
) RRETURN(MATCH_NOMATCH
);
4691 for (i
= 1; i
<= min
; i
++)
4693 if (eptr
>= md
->end_subject
)
4696 RRETURN(MATCH_NOMATCH
);
4702 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4703 HSPACE_MULTIBYTE_CASES
:
4705 RRETURN(MATCH_NOMATCH
);
4711 for (i
= 1; i
<= min
; i
++)
4713 if (eptr
>= md
->end_subject
)
4716 RRETURN(MATCH_NOMATCH
);
4720 default: RRETURN(MATCH_NOMATCH
);
4722 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4723 HSPACE_MULTIBYTE_CASES
:
4731 for (i
= 1; i
<= min
; i
++)
4733 if (eptr
>= md
->end_subject
)
4736 RRETURN(MATCH_NOMATCH
);
4741 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4742 VSPACE_MULTIBYTE_CASES
:
4744 RRETURN(MATCH_NOMATCH
);
4751 for (i
= 1; i
<= min
; i
++)
4753 if (eptr
>= md
->end_subject
)
4756 RRETURN(MATCH_NOMATCH
);
4760 default: RRETURN(MATCH_NOMATCH
);
4762 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4763 VSPACE_MULTIBYTE_CASES
:
4771 for (i
= 1; i
<= min
; i
++)
4773 if (eptr
>= md
->end_subject
)
4776 RRETURN(MATCH_NOMATCH
);
4778 if (MAX_255(*eptr
) && (md
->ctypes
[*eptr
] & ctype_digit
) != 0)
4779 RRETURN(MATCH_NOMATCH
);
4785 for (i
= 1; i
<= min
; i
++)
4787 if (eptr
>= md
->end_subject
)
4790 RRETURN(MATCH_NOMATCH
);
4792 if (!MAX_255(*eptr
) || (md
->ctypes
[*eptr
] & ctype_digit
) == 0)
4793 RRETURN(MATCH_NOMATCH
);
4798 case OP_NOT_WHITESPACE
:
4799 for (i
= 1; i
<= min
; i
++)
4801 if (eptr
>= md
->end_subject
)
4804 RRETURN(MATCH_NOMATCH
);
4806 if (MAX_255(*eptr
) && (md
->ctypes
[*eptr
] & ctype_space
) != 0)
4807 RRETURN(MATCH_NOMATCH
);
4813 for (i
= 1; i
<= min
; i
++)
4815 if (eptr
>= md
->end_subject
)
4818 RRETURN(MATCH_NOMATCH
);
4820 if (!MAX_255(*eptr
) || (md
->ctypes
[*eptr
] & ctype_space
) == 0)
4821 RRETURN(MATCH_NOMATCH
);
4826 case OP_NOT_WORDCHAR
:
4827 for (i
= 1; i
<= min
; i
++)
4829 if (eptr
>= md
->end_subject
)
4832 RRETURN(MATCH_NOMATCH
);
4834 if (MAX_255(*eptr
) && (md
->ctypes
[*eptr
] & ctype_word
) != 0)
4835 RRETURN(MATCH_NOMATCH
);
4841 for (i
= 1; i
<= min
; i
++)
4843 if (eptr
>= md
->end_subject
)
4846 RRETURN(MATCH_NOMATCH
);
4848 if (!MAX_255(*eptr
) || (md
->ctypes
[*eptr
] & ctype_word
) == 0)
4849 RRETURN(MATCH_NOMATCH
);
4855 RRETURN(PCRE_ERROR_INTERNAL
);
4859 /* If min = max, continue at the same level without recursing */
4861 if (min
== max
) continue;
4863 /* If minimizing, we have to test the rest of the pattern before each
4864 subsequent match. Again, separate the UTF-8 case for speed, and also
4865 separate the UCP cases. */
4875 for (fi
= min
;; fi
++)
4877 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM36
);
4878 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4879 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
4880 if (eptr
>= md
->end_subject
)
4883 RRETURN(MATCH_NOMATCH
);
4885 GETCHARINCTEST(c
, eptr
);
4886 if (prop_fail_result
) RRETURN(MATCH_NOMATCH
);
4888 /* Control never gets here */
4891 for (fi
= min
;; fi
++)
4894 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM37
);
4895 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4896 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
4897 if (eptr
>= md
->end_subject
)
4900 RRETURN(MATCH_NOMATCH
);
4902 GETCHARINCTEST(c
, eptr
);
4903 chartype
= UCD_CHARTYPE(c
);
4904 if ((chartype
== ucp_Lu
||
4905 chartype
== ucp_Ll
||
4906 chartype
== ucp_Lt
) == prop_fail_result
)
4907 RRETURN(MATCH_NOMATCH
);
4909 /* Control never gets here */
4912 for (fi
= min
;; fi
++)
4914 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM38
);
4915 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4916 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
4917 if (eptr
>= md
->end_subject
)
4920 RRETURN(MATCH_NOMATCH
);
4922 GETCHARINCTEST(c
, eptr
);
4923 if ((UCD_CATEGORY(c
) == prop_value
) == prop_fail_result
)
4924 RRETURN(MATCH_NOMATCH
);
4926 /* Control never gets here */
4929 for (fi
= min
;; fi
++)
4931 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM39
);
4932 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4933 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
4934 if (eptr
>= md
->end_subject
)
4937 RRETURN(MATCH_NOMATCH
);
4939 GETCHARINCTEST(c
, eptr
);
4940 if ((UCD_CHARTYPE(c
) == prop_value
) == prop_fail_result
)
4941 RRETURN(MATCH_NOMATCH
);
4943 /* Control never gets here */
4946 for (fi
= min
;; fi
++)
4948 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM40
);
4949 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4950 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
4951 if (eptr
>= md
->end_subject
)
4954 RRETURN(MATCH_NOMATCH
);
4956 GETCHARINCTEST(c
, eptr
);
4957 if ((UCD_SCRIPT(c
) == prop_value
) == prop_fail_result
)
4958 RRETURN(MATCH_NOMATCH
);
4960 /* Control never gets here */
4963 for (fi
= min
;; fi
++)
4966 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM59
);
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 category
= UCD_CATEGORY(c
);
4976 if ((category
== ucp_L
|| category
== ucp_N
) == prop_fail_result
)
4977 RRETURN(MATCH_NOMATCH
);
4979 /* Control never gets here */
4981 /* Perl space used to exclude VT, but from Perl 5.18 it is included,
4982 which means that Perl space and POSIX space are now identical. PCRE
4983 was changed at release 8.34. */
4985 case PT_SPACE
: /* Perl space */
4986 case PT_PXSPACE
: /* POSIX space */
4987 for (fi
= min
;; fi
++)
4989 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM61
);
4990 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
4991 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
4992 if (eptr
>= md
->end_subject
)
4995 RRETURN(MATCH_NOMATCH
);
4997 GETCHARINCTEST(c
, eptr
);
5002 if (prop_fail_result
) RRETURN(MATCH_NOMATCH
);
5006 if ((UCD_CATEGORY(c
) == ucp_Z
) == prop_fail_result
)
5007 RRETURN(MATCH_NOMATCH
);
5011 /* Control never gets here */
5014 for (fi
= min
;; fi
++)
5017 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM62
);
5018 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5019 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
5020 if (eptr
>= md
->end_subject
)
5023 RRETURN(MATCH_NOMATCH
);
5025 GETCHARINCTEST(c
, eptr
);
5026 category
= UCD_CATEGORY(c
);
5027 if ((category
== ucp_L
||
5028 category
== ucp_N
||
5029 c
== CHAR_UNDERSCORE
)
5030 == prop_fail_result
)
5031 RRETURN(MATCH_NOMATCH
);
5033 /* Control never gets here */
5036 for (fi
= min
;; fi
++)
5038 const pcre_uint32
*cp
;
5039 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM67
);
5040 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5041 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
5042 if (eptr
>= md
->end_subject
)
5045 RRETURN(MATCH_NOMATCH
);
5047 GETCHARINCTEST(c
, eptr
);
5048 cp
= PRIV(ucd_caseless_sets
) + prop_value
;
5052 { if (prop_fail_result
) break; else { RRETURN(MATCH_NOMATCH
); } }
5054 { if (prop_fail_result
) { RRETURN(MATCH_NOMATCH
); } else break; }
5057 /* Control never gets here */
5060 for (fi
= min
;; fi
++)
5062 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM60
);
5063 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5064 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
5065 if (eptr
>= md
->end_subject
)
5068 RRETURN(MATCH_NOMATCH
);
5070 GETCHARINCTEST(c
, eptr
);
5071 if ((c
== CHAR_DOLLAR_SIGN
|| c
== CHAR_COMMERCIAL_AT
||
5072 c
== CHAR_GRAVE_ACCENT
|| (c
>= 0xa0 && c
<= 0xd7ff) ||
5073 c
>= 0xe000) == prop_fail_result
)
5074 RRETURN(MATCH_NOMATCH
);
5076 /* Control never gets here */
5078 /* This should never occur */
5080 RRETURN(PCRE_ERROR_INTERNAL
);
5084 /* Match extended Unicode sequences. We will get here only if the
5085 support is in the binary; otherwise a compile-time error occurs. */
5087 else if (ctype
== OP_EXTUNI
)
5089 for (fi
= min
;; fi
++)
5091 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM41
);
5092 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5093 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
5094 if (eptr
>= md
->end_subject
)
5097 RRETURN(MATCH_NOMATCH
);
5102 GETCHARINCTEST(c
, eptr
);
5103 lgb
= UCD_GRAPHBREAK(c
);
5104 while (eptr
< md
->end_subject
)
5107 if (!utf
) c
= *eptr
; else { GETCHARLEN(c
, eptr
, len
); }
5108 rgb
= UCD_GRAPHBREAK(c
);
5109 if ((PRIV(ucp_gbtable
)[lgb
] & (1 << rgb
)) == 0) break;
5118 #endif /* SUPPORT_UCP */
5123 for (fi
= min
;; fi
++)
5125 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM42
);
5126 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5127 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
5128 if (eptr
>= md
->end_subject
)
5131 RRETURN(MATCH_NOMATCH
);
5133 if (ctype
== OP_ANY
&& IS_NEWLINE(eptr
))
5134 RRETURN(MATCH_NOMATCH
);
5135 GETCHARINC(c
, eptr
);
5138 case OP_ANY
: /* This is the non-NL case */
5139 if (md
->partial
!= 0 && /* Take care with CRLF partial */
5140 eptr
>= md
->end_subject
&&
5141 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
5142 NLBLOCK
->nllen
== 2 &&
5143 c
== NLBLOCK
->nl
[0])
5146 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
5157 default: RRETURN(MATCH_NOMATCH
);
5159 if (eptr
< md
->end_subject
&& UCHAR21(eptr
) == CHAR_LF
) eptr
++;
5171 #endif /* Not EBCDIC */
5172 if (md
->bsr_anycrlf
) RRETURN(MATCH_NOMATCH
);
5180 HSPACE_CASES
: RRETURN(MATCH_NOMATCH
);
5188 HSPACE_CASES
: break;
5189 default: RRETURN(MATCH_NOMATCH
);
5196 VSPACE_CASES
: RRETURN(MATCH_NOMATCH
);
5204 VSPACE_CASES
: break;
5205 default: RRETURN(MATCH_NOMATCH
);
5210 if (c
< 256 && (md
->ctypes
[c
] & ctype_digit
) != 0)
5211 RRETURN(MATCH_NOMATCH
);
5215 if (c
>= 256 || (md
->ctypes
[c
] & ctype_digit
) == 0)
5216 RRETURN(MATCH_NOMATCH
);
5219 case OP_NOT_WHITESPACE
:
5220 if (c
< 256 && (md
->ctypes
[c
] & ctype_space
) != 0)
5221 RRETURN(MATCH_NOMATCH
);
5225 if (c
>= 256 || (md
->ctypes
[c
] & ctype_space
) == 0)
5226 RRETURN(MATCH_NOMATCH
);
5229 case OP_NOT_WORDCHAR
:
5230 if (c
< 256 && (md
->ctypes
[c
] & ctype_word
) != 0)
5231 RRETURN(MATCH_NOMATCH
);
5235 if (c
>= 256 || (md
->ctypes
[c
] & ctype_word
) == 0)
5236 RRETURN(MATCH_NOMATCH
);
5240 RRETURN(PCRE_ERROR_INTERNAL
);
5248 for (fi
= min
;; fi
++)
5250 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM43
);
5251 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5252 if (fi
>= max
) RRETURN(MATCH_NOMATCH
);
5253 if (eptr
>= md
->end_subject
)
5256 RRETURN(MATCH_NOMATCH
);
5258 if (ctype
== OP_ANY
&& IS_NEWLINE(eptr
))
5259 RRETURN(MATCH_NOMATCH
);
5263 case OP_ANY
: /* This is the non-NL case */
5264 if (md
->partial
!= 0 && /* Take care with CRLF partial */
5265 eptr
>= md
->end_subject
&&
5266 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
5267 NLBLOCK
->nllen
== 2 &&
5268 c
== NLBLOCK
->nl
[0])
5271 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
5282 default: RRETURN(MATCH_NOMATCH
);
5284 if (eptr
< md
->end_subject
&& *eptr
== CHAR_LF
) eptr
++;
5293 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5297 if (md
->bsr_anycrlf
) RRETURN(MATCH_NOMATCH
);
5307 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5308 HSPACE_MULTIBYTE_CASES
:
5310 RRETURN(MATCH_NOMATCH
);
5317 default: RRETURN(MATCH_NOMATCH
);
5319 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5320 HSPACE_MULTIBYTE_CASES
:
5331 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5332 VSPACE_MULTIBYTE_CASES
:
5334 RRETURN(MATCH_NOMATCH
);
5341 default: RRETURN(MATCH_NOMATCH
);
5343 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5344 VSPACE_MULTIBYTE_CASES
:
5351 if (MAX_255(c
) && (md
->ctypes
[c
] & ctype_digit
) != 0) RRETURN(MATCH_NOMATCH
);
5355 if (!MAX_255(c
) || (md
->ctypes
[c
] & ctype_digit
) == 0) RRETURN(MATCH_NOMATCH
);
5358 case OP_NOT_WHITESPACE
:
5359 if (MAX_255(c
) && (md
->ctypes
[c
] & ctype_space
) != 0) RRETURN(MATCH_NOMATCH
);
5363 if (!MAX_255(c
) || (md
->ctypes
[c
] & ctype_space
) == 0) RRETURN(MATCH_NOMATCH
);
5366 case OP_NOT_WORDCHAR
:
5367 if (MAX_255(c
) && (md
->ctypes
[c
] & ctype_word
) != 0) RRETURN(MATCH_NOMATCH
);
5371 if (!MAX_255(c
) || (md
->ctypes
[c
] & ctype_word
) == 0) RRETURN(MATCH_NOMATCH
);
5375 RRETURN(PCRE_ERROR_INTERNAL
);
5379 /* Control never gets here */
5382 /* If maximizing, it is worth using inline code for speed, doing the type
5383 test once at the start (i.e. keep it out of the loop). Again, keep the
5384 UTF-8 and UCP stuff separate. */
5388 pp
= eptr
; /* Remember where we started */
5396 for (i
= min
; i
< max
; i
++)
5399 if (eptr
>= md
->end_subject
)
5404 GETCHARLENTEST(c
, eptr
, len
);
5405 if (prop_fail_result
) break;
5411 for (i
= min
; i
< max
; i
++)
5415 if (eptr
>= md
->end_subject
)
5420 GETCHARLENTEST(c
, eptr
, len
);
5421 chartype
= UCD_CHARTYPE(c
);
5422 if ((chartype
== ucp_Lu
||
5423 chartype
== ucp_Ll
||
5424 chartype
== ucp_Lt
) == prop_fail_result
)
5431 for (i
= min
; i
< max
; i
++)
5434 if (eptr
>= md
->end_subject
)
5439 GETCHARLENTEST(c
, eptr
, len
);
5440 if ((UCD_CATEGORY(c
) == prop_value
) == prop_fail_result
) break;
5446 for (i
= min
; i
< max
; i
++)
5449 if (eptr
>= md
->end_subject
)
5454 GETCHARLENTEST(c
, eptr
, len
);
5455 if ((UCD_CHARTYPE(c
) == prop_value
) == prop_fail_result
) break;
5461 for (i
= min
; i
< max
; i
++)
5464 if (eptr
>= md
->end_subject
)
5469 GETCHARLENTEST(c
, eptr
, len
);
5470 if ((UCD_SCRIPT(c
) == prop_value
) == prop_fail_result
) break;
5476 for (i
= min
; i
< max
; i
++)
5480 if (eptr
>= md
->end_subject
)
5485 GETCHARLENTEST(c
, eptr
, len
);
5486 category
= UCD_CATEGORY(c
);
5487 if ((category
== ucp_L
|| category
== ucp_N
) == prop_fail_result
)
5493 /* Perl space used to exclude VT, but from Perl 5.18 it is included,
5494 which means that Perl space and POSIX space are now identical. PCRE
5495 was changed at release 8.34. */
5497 case PT_SPACE
: /* Perl space */
5498 case PT_PXSPACE
: /* POSIX space */
5499 for (i
= min
; i
< max
; i
++)
5502 if (eptr
>= md
->end_subject
)
5507 GETCHARLENTEST(c
, eptr
, len
);
5512 if (prop_fail_result
) goto ENDLOOP99
; /* Break the loop */
5516 if ((UCD_CATEGORY(c
) == ucp_Z
) == prop_fail_result
)
5517 goto ENDLOOP99
; /* Break the loop */
5526 for (i
= min
; i
< max
; i
++)
5530 if (eptr
>= md
->end_subject
)
5535 GETCHARLENTEST(c
, eptr
, len
);
5536 category
= UCD_CATEGORY(c
);
5537 if ((category
== ucp_L
|| category
== ucp_N
||
5538 c
== CHAR_UNDERSCORE
) == prop_fail_result
)
5545 for (i
= min
; i
< max
; i
++)
5547 const pcre_uint32
*cp
;
5549 if (eptr
>= md
->end_subject
)
5554 GETCHARLENTEST(c
, eptr
, len
);
5555 cp
= PRIV(ucd_caseless_sets
) + prop_value
;
5559 { if (prop_fail_result
) break; else goto GOT_MAX
; }
5561 { if (prop_fail_result
) goto GOT_MAX
; else break; }
5569 for (i
= min
; i
< max
; i
++)
5572 if (eptr
>= md
->end_subject
)
5577 GETCHARLENTEST(c
, eptr
, len
);
5578 if ((c
== CHAR_DOLLAR_SIGN
|| c
== CHAR_COMMERCIAL_AT
||
5579 c
== CHAR_GRAVE_ACCENT
|| (c
>= 0xa0 && c
<= 0xd7ff) ||
5580 c
>= 0xe000) == prop_fail_result
)
5587 RRETURN(PCRE_ERROR_INTERNAL
);
5590 /* eptr is now past the end of the maximum run */
5592 if (possessive
) continue; /* No backtracking */
5595 if (eptr
== pp
) goto TAIL_RECURSE
;
5596 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM44
);
5597 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5599 if (utf
) BACKCHAR(eptr
);
5603 /* Match extended Unicode grapheme clusters. We will get here only if the
5604 support is in the binary; otherwise a compile-time error occurs. */
5606 else if (ctype
== OP_EXTUNI
)
5608 for (i
= min
; i
< max
; i
++)
5610 if (eptr
>= md
->end_subject
)
5618 GETCHARINCTEST(c
, eptr
);
5619 lgb
= UCD_GRAPHBREAK(c
);
5620 while (eptr
< md
->end_subject
)
5623 if (!utf
) c
= *eptr
; else { GETCHARLEN(c
, eptr
, len
); }
5624 rgb
= UCD_GRAPHBREAK(c
);
5625 if ((PRIV(ucp_gbtable
)[lgb
] & (1 << rgb
)) == 0) break;
5633 /* eptr is now past the end of the maximum run */
5635 if (possessive
) continue; /* No backtracking */
5642 if (eptr
== pp
) goto TAIL_RECURSE
; /* At start of char run */
5643 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM45
);
5644 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5646 /* Backtracking over an extended grapheme cluster involves inspecting
5647 the previous two characters (if present) to see if a break is
5648 permitted between them. */
5651 if (!utf
) c
= *eptr
; else
5656 rgb
= UCD_GRAPHBREAK(c
);
5660 if (eptr
== pp
) goto TAIL_RECURSE
; /* At start of char run */
5662 if (!utf
) c
= *fptr
; else
5667 lgb
= UCD_GRAPHBREAK(c
);
5668 if ((PRIV(ucp_gbtable
)[lgb
] & (1 << rgb
)) == 0) break;
5676 #endif /* SUPPORT_UCP */
5686 for (i
= min
; i
< max
; i
++)
5688 if (eptr
>= md
->end_subject
)
5693 if (IS_NEWLINE(eptr
)) break;
5694 if (md
->partial
!= 0 && /* Take care with CRLF partial */
5695 eptr
+ 1 >= md
->end_subject
&&
5696 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
5697 NLBLOCK
->nllen
== 2 &&
5698 UCHAR21(eptr
) == NLBLOCK
->nl
[0])
5701 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
5704 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
5708 /* Handle unlimited UTF-8 repeat */
5712 for (i
= min
; i
< max
; i
++)
5714 if (eptr
>= md
->end_subject
)
5719 if (IS_NEWLINE(eptr
)) break;
5720 if (md
->partial
!= 0 && /* Take care with CRLF partial */
5721 eptr
+ 1 >= md
->end_subject
&&
5722 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
5723 NLBLOCK
->nllen
== 2 &&
5724 UCHAR21(eptr
) == NLBLOCK
->nl
[0])
5727 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
5730 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
5738 for (i
= min
; i
< max
; i
++)
5740 if (eptr
>= md
->end_subject
)
5746 ACROSSCHAR(eptr
< md
->end_subject
, *eptr
, eptr
++);
5751 eptr
= md
->end_subject
; /* Unlimited UTF-8 repeat */
5756 /* The byte case is the same as non-UTF8 */
5760 if (c
> (unsigned int)(md
->end_subject
- eptr
))
5762 eptr
= md
->end_subject
;
5769 for (i
= min
; i
< max
; i
++)
5772 if (eptr
>= md
->end_subject
)
5777 GETCHARLEN(c
, eptr
, len
);
5780 if (++eptr
>= md
->end_subject
) break;
5781 if (UCHAR21(eptr
) == CHAR_LF
) eptr
++;
5787 (c
!= CHAR_VT
&& c
!= CHAR_FF
&& c
!= CHAR_NEL
5789 && c
!= 0x2028 && c
!= 0x2029
5790 #endif /* Not EBCDIC */
5800 for (i
= min
; i
< max
; i
++)
5804 if (eptr
>= md
->end_subject
)
5809 GETCHARLEN(c
, eptr
, len
);
5812 HSPACE_CASES
: gotspace
= TRUE
; break;
5813 default: gotspace
= FALSE
; break;
5815 if (gotspace
== (ctype
== OP_NOT_HSPACE
)) break;
5822 for (i
= min
; i
< max
; i
++)
5826 if (eptr
>= md
->end_subject
)
5831 GETCHARLEN(c
, eptr
, len
);
5834 VSPACE_CASES
: gotspace
= TRUE
; break;
5835 default: gotspace
= FALSE
; break;
5837 if (gotspace
== (ctype
== OP_NOT_VSPACE
)) break;
5843 for (i
= min
; i
< max
; i
++)
5846 if (eptr
>= md
->end_subject
)
5851 GETCHARLEN(c
, eptr
, len
);
5852 if (c
< 256 && (md
->ctypes
[c
] & ctype_digit
) != 0) break;
5858 for (i
= min
; i
< max
; i
++)
5861 if (eptr
>= md
->end_subject
)
5866 GETCHARLEN(c
, eptr
, len
);
5867 if (c
>= 256 ||(md
->ctypes
[c
] & ctype_digit
) == 0) break;
5872 case OP_NOT_WHITESPACE
:
5873 for (i
= min
; i
< max
; i
++)
5876 if (eptr
>= md
->end_subject
)
5881 GETCHARLEN(c
, eptr
, len
);
5882 if (c
< 256 && (md
->ctypes
[c
] & ctype_space
) != 0) break;
5888 for (i
= min
; i
< max
; i
++)
5891 if (eptr
>= md
->end_subject
)
5896 GETCHARLEN(c
, eptr
, len
);
5897 if (c
>= 256 ||(md
->ctypes
[c
] & ctype_space
) == 0) break;
5902 case OP_NOT_WORDCHAR
:
5903 for (i
= min
; i
< max
; i
++)
5906 if (eptr
>= md
->end_subject
)
5911 GETCHARLEN(c
, eptr
, len
);
5912 if (c
< 256 && (md
->ctypes
[c
] & ctype_word
) != 0) break;
5918 for (i
= min
; i
< max
; i
++)
5921 if (eptr
>= md
->end_subject
)
5926 GETCHARLEN(c
, eptr
, len
);
5927 if (c
>= 256 || (md
->ctypes
[c
] & ctype_word
) == 0) break;
5933 RRETURN(PCRE_ERROR_INTERNAL
);
5936 if (possessive
) continue; /* No backtracking */
5939 if (eptr
== pp
) goto TAIL_RECURSE
;
5940 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM46
);
5941 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
5944 if (ctype
== OP_ANYNL
&& eptr
> pp
&& UCHAR21(eptr
) == CHAR_NL
&&
5945 UCHAR21(eptr
- 1) == CHAR_CR
) eptr
--;
5949 #endif /* SUPPORT_UTF */
5955 for (i
= min
; i
< max
; i
++)
5957 if (eptr
>= md
->end_subject
)
5962 if (IS_NEWLINE(eptr
)) break;
5963 if (md
->partial
!= 0 && /* Take care with CRLF partial */
5964 eptr
+ 1 >= md
->end_subject
&&
5965 NLBLOCK
->nltype
== NLTYPE_FIXED
&&
5966 NLBLOCK
->nllen
== 2 &&
5967 *eptr
== NLBLOCK
->nl
[0])
5970 if (md
->partial
> 1) RRETURN(PCRE_ERROR_PARTIAL
);
5979 if (c
> (unsigned int)(md
->end_subject
- eptr
))
5981 eptr
= md
->end_subject
;
5988 for (i
= min
; i
< max
; i
++)
5990 if (eptr
>= md
->end_subject
)
5998 if (++eptr
>= md
->end_subject
) break;
5999 if (*eptr
== CHAR_LF
) eptr
++;
6003 if (c
!= CHAR_LF
&& (md
->bsr_anycrlf
||
6004 (c
!= CHAR_VT
&& c
!= CHAR_FF
&& c
!= CHAR_NEL
6005 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6006 && c
!= 0x2028 && c
!= 0x2029
6015 for (i
= min
; i
< max
; i
++)
6017 if (eptr
>= md
->end_subject
)
6024 default: eptr
++; break;
6026 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6027 HSPACE_MULTIBYTE_CASES
:
6036 for (i
= min
; i
< max
; i
++)
6038 if (eptr
>= md
->end_subject
)
6045 default: goto ENDLOOP01
;
6047 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6048 HSPACE_MULTIBYTE_CASES
:
6057 for (i
= min
; i
< max
; i
++)
6059 if (eptr
>= md
->end_subject
)
6066 default: eptr
++; break;
6068 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6069 VSPACE_MULTIBYTE_CASES
:
6078 for (i
= min
; i
< max
; i
++)
6080 if (eptr
>= md
->end_subject
)
6087 default: goto ENDLOOP03
;
6089 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
6090 VSPACE_MULTIBYTE_CASES
:
6099 for (i
= min
; i
< max
; i
++)
6101 if (eptr
>= md
->end_subject
)
6106 if (MAX_255(*eptr
) && (md
->ctypes
[*eptr
] & ctype_digit
) != 0) break;
6112 for (i
= min
; i
< max
; i
++)
6114 if (eptr
>= md
->end_subject
)
6119 if (!MAX_255(*eptr
) || (md
->ctypes
[*eptr
] & ctype_digit
) == 0) break;
6124 case OP_NOT_WHITESPACE
:
6125 for (i
= min
; i
< max
; i
++)
6127 if (eptr
>= md
->end_subject
)
6132 if (MAX_255(*eptr
) && (md
->ctypes
[*eptr
] & ctype_space
) != 0) break;
6138 for (i
= min
; i
< max
; i
++)
6140 if (eptr
>= md
->end_subject
)
6145 if (!MAX_255(*eptr
) || (md
->ctypes
[*eptr
] & ctype_space
) == 0) break;
6150 case OP_NOT_WORDCHAR
:
6151 for (i
= min
; i
< max
; i
++)
6153 if (eptr
>= md
->end_subject
)
6158 if (MAX_255(*eptr
) && (md
->ctypes
[*eptr
] & ctype_word
) != 0) break;
6164 for (i
= min
; i
< max
; i
++)
6166 if (eptr
>= md
->end_subject
)
6171 if (!MAX_255(*eptr
) || (md
->ctypes
[*eptr
] & ctype_word
) == 0) break;
6177 RRETURN(PCRE_ERROR_INTERNAL
);
6180 if (possessive
) continue; /* No backtracking */
6183 if (eptr
== pp
) goto TAIL_RECURSE
;
6184 RMATCH(eptr
, ecode
, offset_top
, md
, eptrb
, RM47
);
6185 if (rrc
!= MATCH_NOMATCH
) RRETURN(rrc
);
6187 if (ctype
== OP_ANYNL
&& eptr
> pp
&& *eptr
== CHAR_LF
&&
6188 eptr
[-1] == CHAR_CR
) eptr
--;
6192 /* Control never gets here */
6195 /* There's been some horrible disaster. Arrival here can only mean there is
6196 something seriously wrong in the code above or the OP_xxx definitions. */
6199 DPRINTF(("Unknown opcode %d\n", *ecode
));
6200 RRETURN(PCRE_ERROR_UNKNOWN_OPCODE
);
6203 /* Do not stick any code in here without much thought; it is assumed
6204 that "continue" in the code above comes out to here to repeat the main
6207 } /* End of main loop */
6208 /* Control never reaches here */
6211 /* When compiling to use the heap rather than the stack for recursive calls to
6212 match(), the RRETURN() macro jumps here. The number that is saved in
6213 frame->Xwhere indicates which label we actually want to return to. */
6216 #define LBL(val) case val: goto L_RM##val;
6218 switch (frame
->Xwhere
)
6220 LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
6221 LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
6222 LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
6223 LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
6224 LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)
6226 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
6231 LBL(22) LBL(23) LBL(28) LBL(30)
6232 LBL(32) LBL(34) LBL(42) LBL(46)
6234 LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
6235 LBL(59) LBL(60) LBL(61) LBL(62) LBL(67)
6236 #endif /* SUPPORT_UCP */
6237 #endif /* SUPPORT_UTF */
6239 DPRINTF(("jump error in pcre match: label %d non-existent\n", frame
->Xwhere
));
6240 return PCRE_ERROR_INTERNAL
;
6243 #endif /* NO_RECURSE */
6247 /***************************************************************************
6248 ****************************************************************************
6249 RECURSION IN THE match() FUNCTION
6251 Undefine all the macros that were defined above to handle this. */
6269 #undef new_recursive
6282 #undef save_capture_last
6292 /* These two are defined as macros in both cases */
6297 /***************************************************************************
6298 ***************************************************************************/
6302 /*************************************************
6303 * Release allocated heap frames *
6304 *************************************************/
6306 /* This function releases all the allocated frames. The base frame is on the
6307 machine stack, and so must not be freed.
6309 Argument: the address of the base frame
6314 release_match_heapframes (heapframe
*frame_base
)
6316 heapframe
*nextframe
= frame_base
->Xnextframe
;
6317 while (nextframe
!= NULL
)
6319 heapframe
*oldframe
= nextframe
;
6320 nextframe
= nextframe
->Xnextframe
;
6321 (PUBL(stack_free
))(oldframe
);
6327 /*************************************************
6328 * Execute a Regular Expression *
6329 *************************************************/
6331 /* This function applies a compiled re to a subject string and picks out
6332 portions of the string if it matches. Two elements in the vector are set for
6333 each substring: the offsets to the start and end of the substring.
6336 argument_re points to the compiled expression
6337 extra_data points to extra data or is NULL
6338 subject points to the subject string
6339 length length of subject string (may contain binary zeros)
6340 start_offset where to start in the subject string
6342 offsets points to a vector of ints to be filled in with offsets
6343 offsetcount the number of elements in the vector
6345 Returns: > 0 => success; value is the number of elements filled in
6346 = 0 => success, but offsets is not big enough
6347 -1 => failed to match
6348 < -1 => some kind of unexpected problem
6351 #if defined COMPILE_PCRE8
6352 PCRE_EXP_DEFN
int PCRE_CALL_CONVENTION
6353 pcre_exec(const pcre
*argument_re
, const pcre_extra
*extra_data
,
6354 PCRE_SPTR subject
, int length
, int start_offset
, int options
, int *offsets
,
6356 #elif defined COMPILE_PCRE16
6357 PCRE_EXP_DEFN
int PCRE_CALL_CONVENTION
6358 pcre16_exec(const pcre16
*argument_re
, const pcre16_extra
*extra_data
,
6359 PCRE_SPTR16 subject
, int length
, int start_offset
, int options
, int *offsets
,
6361 #elif defined COMPILE_PCRE32
6362 PCRE_EXP_DEFN
int PCRE_CALL_CONVENTION
6363 pcre32_exec(const pcre32
*argument_re
, const pcre32_extra
*extra_data
,
6364 PCRE_SPTR32 subject
, int length
, int start_offset
, int options
, int *offsets
,
6368 int rc
, ocount
, arg_offset_max
;
6370 BOOL using_temporary_offsets
= FALSE
;
6375 BOOL has_first_char
= FALSE
;
6376 BOOL has_req_char
= FALSE
;
6377 pcre_uchar first_char
= 0;
6378 pcre_uchar first_char2
= 0;
6379 pcre_uchar req_char
= 0;
6380 pcre_uchar req_char2
= 0;
6381 match_data match_block
;
6382 match_data
*md
= &match_block
;
6383 const pcre_uint8
*tables
;
6384 const pcre_uint8
*start_bits
= NULL
;
6385 PCRE_PUCHAR start_match
= (PCRE_PUCHAR
)subject
+ start_offset
;
6386 PCRE_PUCHAR end_subject
;
6387 PCRE_PUCHAR start_partial
= NULL
;
6388 PCRE_PUCHAR match_partial
= NULL
;
6389 PCRE_PUCHAR req_char_ptr
= start_match
- 1;
6391 const pcre_study_data
*study
;
6392 const REAL_PCRE
*re
= (const REAL_PCRE
*)argument_re
;
6395 heapframe frame_zero
;
6396 frame_zero
.Xprevframe
= NULL
; /* Marks the top level */
6397 frame_zero
.Xnextframe
= NULL
; /* None are allocated yet */
6398 md
->match_frames_base
= &frame_zero
;
6401 /* Check for the special magic call that measures the size of the stack used
6402 per recursive call of match(). Without the funny casting for sizeof, a Windows
6403 compiler gave this error: "unary minus operator applied to unsigned type,
6404 result still unsigned". Hopefully the cast fixes that. */
6406 if (re
== NULL
&& extra_data
== NULL
&& subject
== NULL
&& length
== -999 &&
6407 start_offset
== -999)
6409 return -((int)sizeof(heapframe
));
6411 return match(NULL
, NULL
, NULL
, 0, NULL
, NULL
, 0);
6414 /* Plausibility checks */
6416 if ((options
& ~PUBLIC_EXEC_OPTIONS
) != 0) return PCRE_ERROR_BADOPTION
;
6417 if (re
== NULL
|| subject
== NULL
|| (offsets
== NULL
&& offsetcount
> 0))
6418 return PCRE_ERROR_NULL
;
6419 if (offsetcount
< 0) return PCRE_ERROR_BADCOUNT
;
6420 if (length
< 0) return PCRE_ERROR_BADLENGTH
;
6421 if (start_offset
< 0 || start_offset
> length
) return PCRE_ERROR_BADOFFSET
;
6423 /* Check that the first field in the block is the magic number. If it is not,
6424 return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
6425 REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
6426 means that the pattern is likely compiled with different endianness. */
6428 if (re
->magic_number
!= MAGIC_NUMBER
)
6429 return re
->magic_number
== REVERSED_MAGIC_NUMBER
?
6430 PCRE_ERROR_BADENDIANNESS
:PCRE_ERROR_BADMAGIC
;
6431 if ((re
->flags
& PCRE_MODE
) == 0) return PCRE_ERROR_BADMODE
;
6433 /* These two settings are used in the code for checking a UTF-8 string that
6434 follows immediately afterwards. Other values in the md block are used only
6435 during "normal" pcre_exec() processing, not when the JIT support is in use,
6436 so they are set up later. */
6438 /* PCRE_UTF16 has the same value as PCRE_UTF8. */
6439 utf
= md
->utf
= (re
->options
& PCRE_UTF8
) != 0;
6440 md
->partial
= ((options
& PCRE_PARTIAL_HARD
) != 0)? 2 :
6441 ((options
& PCRE_PARTIAL_SOFT
) != 0)? 1 : 0;
6443 /* Check a UTF-8 string if required. Pass back the character offset and error
6444 code for an invalid string if a results vector is available. */
6447 if (utf
&& (options
& PCRE_NO_UTF8_CHECK
) == 0)
6450 int errorcode
= PRIV(valid_utf
)((PCRE_PUCHAR
)subject
, length
, &erroroffset
);
6453 if (offsetcount
>= 2)
6455 offsets
[0] = erroroffset
;
6456 offsets
[1] = errorcode
;
6458 #if defined COMPILE_PCRE8
6459 return (errorcode
<= PCRE_UTF8_ERR5
&& md
->partial
> 1)?
6460 PCRE_ERROR_SHORTUTF8
: PCRE_ERROR_BADUTF8
;
6461 #elif defined COMPILE_PCRE16
6462 return (errorcode
<= PCRE_UTF16_ERR1
&& md
->partial
> 1)?
6463 PCRE_ERROR_SHORTUTF16
: PCRE_ERROR_BADUTF16
;
6464 #elif defined COMPILE_PCRE32
6465 return PCRE_ERROR_BADUTF32
;
6468 #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
6469 /* Check that a start_offset points to the start of a UTF character. */
6470 if (start_offset
> 0 && start_offset
< length
&&
6471 NOT_FIRSTCHAR(((PCRE_PUCHAR
)subject
)[start_offset
]))
6472 return PCRE_ERROR_BADUTF8_OFFSET
;
6477 /* If the pattern was successfully studied with JIT support, run the JIT
6478 executable instead of the rest of this function. Most options must be set at
6479 compile time for the JIT code to be usable. Fallback to the normal code path if
6480 an unsupported flag is set. */
6483 if (extra_data
!= NULL
6484 && (extra_data
->flags
& (PCRE_EXTRA_EXECUTABLE_JIT
|
6485 PCRE_EXTRA_TABLES
)) == PCRE_EXTRA_EXECUTABLE_JIT
6486 && extra_data
->executable_jit
!= NULL
6487 && (options
& ~PUBLIC_JIT_EXEC_OPTIONS
) == 0)
6489 rc
= PRIV(jit_exec
)(extra_data
, (const pcre_uchar
*)subject
, length
,
6490 start_offset
, options
, offsets
, offsetcount
);
6492 /* PCRE_ERROR_NULL means that the selected normal or partial matching
6493 mode is not compiled. In this case we simply fallback to interpreter. */
6495 if (rc
!= PCRE_ERROR_JIT_BADOPTION
) return rc
;
6499 /* Carry on with non-JIT matching. This information is for finding all the
6500 numbers associated with a given name, for condition testing. */
6502 md
->name_table
= (pcre_uchar
*)re
+ re
->name_table_offset
;
6503 md
->name_count
= re
->name_count
;
6504 md
->name_entry_size
= re
->name_entry_size
;
6506 /* Fish out the optional data from the extra_data structure, first setting
6507 the default values. */
6510 md
->match_limit
= MATCH_LIMIT
;
6511 md
->match_limit_recursion
= MATCH_LIMIT_RECURSION
;
6512 md
->callout_data
= NULL
;
6514 /* The table pointer is always in native byte order. */
6516 tables
= re
->tables
;
6518 /* The two limit values override the defaults, whatever their value. */
6520 if (extra_data
!= NULL
)
6522 register unsigned int flags
= extra_data
->flags
;
6523 if ((flags
& PCRE_EXTRA_STUDY_DATA
) != 0)
6524 study
= (const pcre_study_data
*)extra_data
->study_data
;
6525 if ((flags
& PCRE_EXTRA_MATCH_LIMIT
) != 0)
6526 md
->match_limit
= extra_data
->match_limit
;
6527 if ((flags
& PCRE_EXTRA_MATCH_LIMIT_RECURSION
) != 0)
6528 md
->match_limit_recursion
= extra_data
->match_limit_recursion
;
6529 if ((flags
& PCRE_EXTRA_CALLOUT_DATA
) != 0)
6530 md
->callout_data
= extra_data
->callout_data
;
6531 if ((flags
& PCRE_EXTRA_TABLES
) != 0) tables
= extra_data
->tables
;
6534 /* Limits in the regex override only if they are smaller. */
6536 if ((re
->flags
& PCRE_MLSET
) != 0 && re
->limit_match
< md
->match_limit
)
6537 md
->match_limit
= re
->limit_match
;
6539 if ((re
->flags
& PCRE_RLSET
) != 0 &&
6540 re
->limit_recursion
< md
->match_limit_recursion
)
6541 md
->match_limit_recursion
= re
->limit_recursion
;
6543 /* If the exec call supplied NULL for tables, use the inbuilt ones. This
6544 is a feature that makes it possible to save compiled regex and re-use them
6545 in other programs later. */
6547 if (tables
== NULL
) tables
= PRIV(default_tables
);
6549 /* Set up other data */
6551 anchored
= ((re
->options
| options
) & PCRE_ANCHORED
) != 0;
6552 startline
= (re
->flags
& PCRE_STARTLINE
) != 0;
6553 firstline
= (re
->options
& PCRE_FIRSTLINE
) != 0;
6555 /* The code starts after the real_pcre block and the capture name table. */
6557 md
->start_code
= (const pcre_uchar
*)re
+ re
->name_table_offset
+
6558 re
->name_count
* re
->name_entry_size
;
6560 md
->start_subject
= (PCRE_PUCHAR
)subject
;
6561 md
->start_offset
= start_offset
;
6562 md
->end_subject
= md
->start_subject
+ length
;
6563 end_subject
= md
->end_subject
;
6565 md
->endonly
= (re
->options
& PCRE_DOLLAR_ENDONLY
) != 0;
6566 md
->use_ucp
= (re
->options
& PCRE_UCP
) != 0;
6567 md
->jscript_compat
= (re
->options
& PCRE_JAVASCRIPT_COMPAT
) != 0;
6568 md
->ignore_skip_arg
= 0;
6570 /* Some options are unpacked into BOOL variables in the hope that testing
6571 them will be faster than individual option bits. */
6573 md
->notbol
= (options
& PCRE_NOTBOL
) != 0;
6574 md
->noteol
= (options
& PCRE_NOTEOL
) != 0;
6575 md
->notempty
= (options
& PCRE_NOTEMPTY
) != 0;
6576 md
->notempty_atstart
= (options
& PCRE_NOTEMPTY_ATSTART
) != 0;
6579 md
->mark
= md
->nomatch_mark
= NULL
; /* In case never set */
6581 md
->recursive
= NULL
; /* No recursion at top level */
6582 md
->hasthen
= (re
->flags
& PCRE_HASTHEN
) != 0;
6584 md
->lcc
= tables
+ lcc_offset
;
6585 md
->fcc
= tables
+ fcc_offset
;
6586 md
->ctypes
= tables
+ ctypes_offset
;
6588 /* Handle different \R options. */
6590 switch (options
& (PCRE_BSR_ANYCRLF
|PCRE_BSR_UNICODE
))
6593 if ((re
->options
& (PCRE_BSR_ANYCRLF
|PCRE_BSR_UNICODE
)) != 0)
6594 md
->bsr_anycrlf
= (re
->options
& PCRE_BSR_ANYCRLF
) != 0;
6597 md
->bsr_anycrlf
= TRUE
;
6599 md
->bsr_anycrlf
= FALSE
;
6603 case PCRE_BSR_ANYCRLF
:
6604 md
->bsr_anycrlf
= TRUE
;
6607 case PCRE_BSR_UNICODE
:
6608 md
->bsr_anycrlf
= FALSE
;
6611 default: return PCRE_ERROR_BADNEWLINE
;
6614 /* Handle different types of newline. The three bits give eight cases. If
6615 nothing is set at run time, whatever was used at compile time applies. */
6617 switch ((((options
& PCRE_NEWLINE_BITS
) == 0)? re
->options
:
6618 (pcre_uint32
)options
) & PCRE_NEWLINE_BITS
)
6620 case 0: newline
= NEWLINE
; break; /* Compile-time default */
6621 case PCRE_NEWLINE_CR
: newline
= CHAR_CR
; break;
6622 case PCRE_NEWLINE_LF
: newline
= CHAR_NL
; break;
6623 case PCRE_NEWLINE_CR
+
6624 PCRE_NEWLINE_LF
: newline
= (CHAR_CR
<< 8) | CHAR_NL
; break;
6625 case PCRE_NEWLINE_ANY
: newline
= -1; break;
6626 case PCRE_NEWLINE_ANYCRLF
: newline
= -2; break;
6627 default: return PCRE_ERROR_BADNEWLINE
;
6632 md
->nltype
= NLTYPE_ANYCRLF
;
6634 else if (newline
< 0)
6636 md
->nltype
= NLTYPE_ANY
;
6640 md
->nltype
= NLTYPE_FIXED
;
6644 md
->nl
[0] = (newline
>> 8) & 255;
6645 md
->nl
[1] = newline
& 255;
6650 md
->nl
[0] = newline
;
6654 /* Partial matching was originally supported only for a restricted set of
6655 regexes; from release 8.00 there are no restrictions, but the bits are still
6656 defined (though never set). So there's no harm in leaving this code. */
6658 if (md
->partial
&& (re
->flags
& PCRE_NOPARTIAL
) != 0)
6659 return PCRE_ERROR_BADPARTIAL
;
6661 /* If the expression has got more back references than the offsets supplied can
6662 hold, we get a temporary chunk of working store to use during the matching.
6663 Otherwise, we can use the vector supplied, rounding down its size to a multiple
6666 ocount
= offsetcount
- (offsetcount
% 3);
6667 arg_offset_max
= (2*ocount
)/3;
6669 if (re
->top_backref
> 0 && re
->top_backref
>= ocount
/3)
6671 ocount
= re
->top_backref
* 3 + 3;
6672 md
->offset_vector
= (int *)(PUBL(malloc
))(ocount
* sizeof(int));
6673 if (md
->offset_vector
== NULL
) return PCRE_ERROR_NOMEMORY
;
6674 using_temporary_offsets
= TRUE
;
6675 DPRINTF(("Got memory to hold back references\n"));
6677 else md
->offset_vector
= offsets
;
6678 md
->offset_end
= ocount
;
6679 md
->offset_max
= (2*ocount
)/3;
6680 md
->capture_last
= 0;
6682 /* Reset the working variable associated with each extraction. These should
6683 never be used unless previously set, but they get saved and restored, and so we
6684 initialize them to avoid reading uninitialized locations. Also, unset the
6685 offsets for the matched string. This is really just for tidiness with callouts,
6686 in case they inspect these fields. */
6688 if (md
->offset_vector
!= NULL
)
6690 register int *iptr
= md
->offset_vector
+ ocount
;
6691 register int *iend
= iptr
- re
->top_bracket
;
6692 if (iend
< md
->offset_vector
+ 2) iend
= md
->offset_vector
+ 2;
6693 while (--iptr
>= iend
) *iptr
= -1;
6694 md
->offset_vector
[0] = md
->offset_vector
[1] = -1;
6697 /* Set up the first character to match, if available. The first_char value is
6698 never set for an anchored regular expression, but the anchoring may be forced
6699 at run time, so we have to test for anchoring. The first char may be unset for
6700 an unanchored pattern, of course. If there's no first char and the pattern was
6701 studied, there may be a bitmap of possible first characters. */
6705 if ((re
->flags
& PCRE_FIRSTSET
) != 0)
6707 has_first_char
= TRUE
;
6708 first_char
= first_char2
= (pcre_uchar
)(re
->first_char
);
6709 if ((re
->flags
& PCRE_FCH_CASELESS
) != 0)
6711 first_char2
= TABLE_GET(first_char
, md
->fcc
, first_char
);
6712 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
6713 if (utf
&& first_char
> 127)
6714 first_char2
= UCD_OTHERCASE(first_char
);
6719 if (!startline
&& study
!= NULL
&&
6720 (study
->flags
& PCRE_STUDY_MAPPED
) != 0)
6721 start_bits
= study
->start_bits
;
6724 /* For anchored or unanchored matches, there may be a "last known required
6727 if ((re
->flags
& PCRE_REQCHSET
) != 0)
6729 has_req_char
= TRUE
;
6730 req_char
= req_char2
= (pcre_uchar
)(re
->req_char
);
6731 if ((re
->flags
& PCRE_RCH_CASELESS
) != 0)
6733 req_char2
= TABLE_GET(req_char
, md
->fcc
, req_char
);
6734 #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
6735 if (utf
&& req_char
> 127)
6736 req_char2
= UCD_OTHERCASE(req_char
);
6742 /* ==========================================================================*/
6744 /* Loop for handling unanchored repeated matching attempts; for anchored regexs
6745 the loop runs just once. */
6749 PCRE_PUCHAR save_end_subject
= end_subject
;
6750 PCRE_PUCHAR new_start_match
;
6752 /* If firstline is TRUE, the start of the match is constrained to the first
6753 line of a multiline string. That is, the match must be before or at the first
6754 newline. Implement this by temporarily adjusting end_subject so that we stop
6755 scanning at a newline. If the match fails at the newline, later code breaks
6760 PCRE_PUCHAR t
= start_match
;
6764 while (t
< md
->end_subject
&& !IS_NEWLINE(t
))
6767 ACROSSCHAR(t
< end_subject
, *t
, t
++);
6772 while (t
< md
->end_subject
&& !IS_NEWLINE(t
)) t
++;
6776 /* There are some optimizations that avoid running the match if a known
6777 starting point is not found, or if a known later character is not present.
6778 However, there is an option that disables these, for testing and for ensuring
6779 that all callouts do actually occur. The option can be set in the regex by
6780 (*NO_START_OPT) or passed in match-time options. */
6782 if (((options
| re
->options
) & PCRE_NO_START_OPTIMIZE
) == 0)
6784 /* Advance to a unique first char if there is one. */
6790 if (first_char
!= first_char2
)
6791 while (start_match
< end_subject
&&
6792 (smc
= UCHAR21TEST(start_match
)) != first_char
&& smc
!= first_char2
)
6795 while (start_match
< end_subject
&& UCHAR21TEST(start_match
) != first_char
)
6799 /* Or to just after a linebreak for a multiline match */
6803 if (start_match
> md
->start_subject
+ start_offset
)
6808 while (start_match
< end_subject
&& !WAS_NEWLINE(start_match
))
6811 ACROSSCHAR(start_match
< end_subject
, *start_match
,
6817 while (start_match
< end_subject
&& !WAS_NEWLINE(start_match
))
6820 /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
6821 and we are now at a LF, advance the match position by one more character.
6824 if (start_match
[-1] == CHAR_CR
&&
6825 (md
->nltype
== NLTYPE_ANY
|| md
->nltype
== NLTYPE_ANYCRLF
) &&
6826 start_match
< end_subject
&&
6827 UCHAR21TEST(start_match
) == CHAR_NL
)
6832 /* Or to a non-unique first byte after study */
6834 else if (start_bits
!= NULL
)
6836 while (start_match
< end_subject
)
6838 register pcre_uint32 c
= UCHAR21TEST(start_match
);
6839 #ifndef COMPILE_PCRE8
6840 if (c
> 255) c
= 255;
6842 if ((start_bits
[c
/8] & (1 << (c
&7))) != 0) break;
6846 } /* Starting optimizations */
6848 /* Restore fudged end_subject */
6850 end_subject
= save_end_subject
;
6852 /* The following two optimizations are disabled for partial matching or if
6853 disabling is explicitly requested. */
6855 if (((options
| re
->options
) & PCRE_NO_START_OPTIMIZE
) == 0 && !md
->partial
)
6857 /* If the pattern was studied, a minimum subject length may be set. This is
6858 a lower bound; no actual string of that length may actually match the
6859 pattern. Although the value is, strictly, in characters, we treat it as
6860 bytes to avoid spending too much time in this optimization. */
6862 if (study
!= NULL
&& (study
->flags
& PCRE_STUDY_MINLEN
) != 0 &&
6863 (pcre_uint32
)(end_subject
- start_match
) < study
->minlength
)
6869 /* If req_char is set, we know that that character must appear in the
6870 subject for the match to succeed. If the first character is set, req_char
6871 must be later in the subject; otherwise the test starts at the match point.
6872 This optimization can save a huge amount of backtracking in patterns with
6873 nested unlimited repeats that aren't going to match. Writing separate code
6874 for cased/caseless versions makes it go faster, as does using an
6875 autoincrement and backing off on a match.
6877 HOWEVER: when the subject string is very, very long, searching to its end
6878 can take a long time, and give bad performance on quite ordinary patterns.
6879 This showed up when somebody was matching something like /^\d+C/ on a
6880 32-megabyte string... so we don't do this when the string is sufficiently
6883 if (has_req_char
&& end_subject
- start_match
< REQ_BYTE_MAX
)
6885 register PCRE_PUCHAR p
= start_match
+ (has_first_char
? 1:0);
6887 /* We don't need to repeat the search if we haven't yet reached the
6888 place we found it at last time. */
6890 if (p
> req_char_ptr
)
6892 if (req_char
!= req_char2
)
6894 while (p
< end_subject
)
6896 register pcre_uint32 pp
= UCHAR21INCTEST(p
);
6897 if (pp
== req_char
|| pp
== req_char2
) { p
--; break; }
6902 while (p
< end_subject
)
6904 if (UCHAR21INCTEST(p
) == req_char
) { p
--; break; }
6908 /* If we can't find the required character, break the matching loop,
6909 forcing a match failure. */
6911 if (p
>= end_subject
)
6917 /* If we have found the required character, save the point where we
6918 found it, so that we don't search again next time round the loop if
6919 the start hasn't passed this character yet. */
6926 #ifdef PCRE_DEBUG /* Sigh. Some compilers never learn. */
6927 printf(">>>> Match against: ");
6928 pchars(start_match
, end_subject
- start_match
, TRUE
, md
);
6932 /* OK, we can now run the match. If "hitend" is set afterwards, remember the
6933 first starting point for which a partial match was found. */
6935 md
->start_match_ptr
= start_match
;
6936 md
->start_used_ptr
= start_match
;
6937 md
->match_call_count
= 0;
6938 md
->match_function_type
= 0;
6939 md
->end_offset_top
= 0;
6940 md
->skip_arg_count
= 0;
6941 rc
= match(start_match
, md
->start_code
, start_match
, 2, md
, NULL
, 0);
6942 if (md
->hitend
&& start_partial
== NULL
)
6944 start_partial
= md
->start_used_ptr
;
6945 match_partial
= start_match
;
6950 /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
6951 the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP
6952 entirely. The only way we can do that is to re-do the match at the same
6953 point, with a flag to force SKIP with an argument to be ignored. Just
6954 treating this case as NOMATCH does not work because it does not check other
6955 alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */
6957 case MATCH_SKIP_ARG
:
6958 new_start_match
= start_match
;
6959 md
->ignore_skip_arg
= md
->skip_arg_count
;
6962 /* SKIP passes back the next starting point explicitly, but if it is no
6963 greater than the match we have just done, treat it as NOMATCH. */
6966 if (md
->start_match_ptr
> start_match
)
6968 new_start_match
= md
->start_match_ptr
;
6973 /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6974 exactly like PRUNE. Unset ignore SKIP-with-argument. */
6979 md
->ignore_skip_arg
= 0;
6980 new_start_match
= start_match
+ 1;
6983 ACROSSCHAR(new_start_match
< end_subject
, *new_start_match
,
6988 /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
6994 /* Any other return is either a match, or some kind of error. */
7000 /* Control reaches here for the various types of "no match at this point"
7001 result. Reset the code to MATCH_NOMATCH for subsequent checking. */
7005 /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
7006 newline in the subject (though it may continue over the newline). Therefore,
7007 if we have just failed to match, starting at a newline, do not continue. */
7009 if (firstline
&& IS_NEWLINE(start_match
)) break;
7011 /* Advance to new matching position */
7013 start_match
= new_start_match
;
7015 /* Break the loop if the pattern is anchored or if we have passed the end of
7018 if (anchored
|| start_match
> end_subject
) break;
7020 /* If we have just passed a CR and we are now at a LF, and the pattern does
7021 not contain any explicit matches for \r or \n, and the newline option is CRLF
7022 or ANY or ANYCRLF, advance the match position by one more character. In
7023 normal matching start_match will aways be greater than the first position at
7024 this stage, but a failed *SKIP can cause a return at the same point, which is
7025 why the first test exists. */
7027 if (start_match
> (PCRE_PUCHAR
)subject
+ start_offset
&&
7028 start_match
[-1] == CHAR_CR
&&
7029 start_match
< end_subject
&&
7030 *start_match
== CHAR_NL
&&
7031 (re
->flags
& PCRE_HASCRORLF
) == 0 &&
7032 (md
->nltype
== NLTYPE_ANY
||
7033 md
->nltype
== NLTYPE_ANYCRLF
||
7037 md
->mark
= NULL
; /* Reset for start of next match attempt */
7038 } /* End of for(;;) "bumpalong" loop */
7040 /* ==========================================================================*/
7042 /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
7045 (1) The pattern is anchored or the match was failed by (*COMMIT);
7047 (2) We are past the end of the subject;
7049 (3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
7050 this option requests that a match occur at or before the first newline in
7053 When we have a match and the offset vector is big enough to deal with any
7054 backreferences, captured substring offsets will already be set up. In the case
7055 where we had to get some local store to hold offsets for backreference
7056 processing, copy those that we can. In this case there need not be overflow if
7057 certain parts of the pattern were not used, even though there are more
7058 capturing parentheses than vector slots. */
7062 if (rc
== MATCH_MATCH
|| rc
== MATCH_ACCEPT
)
7064 if (using_temporary_offsets
)
7066 if (arg_offset_max
>= 4)
7068 memcpy(offsets
+ 2, md
->offset_vector
+ 2,
7069 (arg_offset_max
- 2) * sizeof(int));
7070 DPRINTF(("Copied offsets from temporary memory\n"));
7072 if (md
->end_offset_top
> arg_offset_max
) md
->capture_last
|= OVFLBIT
;
7073 DPRINTF(("Freeing temporary memory\n"));
7074 (PUBL(free
))(md
->offset_vector
);
7077 /* Set the return code to the number of captured strings, or 0 if there were
7078 too many to fit into the vector. */
7080 rc
= ((md
->capture_last
& OVFLBIT
) != 0 &&
7081 md
->end_offset_top
>= arg_offset_max
)?
7082 0 : md
->end_offset_top
/2;
7084 /* If there is space in the offset vector, set any unused pairs at the end of
7085 the pattern to -1 for backwards compatibility. It is documented that this
7086 happens. In earlier versions, the whole set of potential capturing offsets
7087 was set to -1 each time round the loop, but this is handled differently now.
7088 "Gaps" are set to -1 dynamically instead (this fixes a bug). Thus, it is only
7089 those at the end that need unsetting here. We can't just unset them all at
7090 the start of the whole thing because they may get set in one branch that is
7091 not the final matching branch. */
7093 if (md
->end_offset_top
/2 <= re
->top_bracket
&& offsets
!= NULL
)
7095 register int *iptr
, *iend
;
7096 int resetcount
= 2 + re
->top_bracket
* 2;
7097 if (resetcount
> offsetcount
) resetcount
= offsetcount
;
7098 iptr
= offsets
+ md
->end_offset_top
;
7099 iend
= offsets
+ resetcount
;
7100 while (iptr
< iend
) *iptr
++ = -1;
7103 /* If there is space, set up the whole thing as substring 0. The value of
7104 md->start_match_ptr might be modified if \K was encountered on the success
7107 if (offsetcount
< 2) rc
= 0; else
7109 offsets
[0] = (int)(md
->start_match_ptr
- md
->start_subject
);
7110 offsets
[1] = (int)(md
->end_match_ptr
- md
->start_subject
);
7113 /* Return MARK data if requested */
7115 if (extra_data
!= NULL
&& (extra_data
->flags
& PCRE_EXTRA_MARK
) != 0)
7116 *(extra_data
->mark
) = (pcre_uchar
*)md
->mark
;
7117 DPRINTF((">>>> returning %d\n", rc
));
7119 release_match_heapframes(&frame_zero
);
7124 /* Control gets here if there has been an error, or if the overall match
7125 attempt has failed at all permitted starting positions. */
7127 if (using_temporary_offsets
)
7129 DPRINTF(("Freeing temporary memory\n"));
7130 (PUBL(free
))(md
->offset_vector
);
7133 /* For anything other than nomatch or partial match, just return the code. */
7135 if (rc
!= MATCH_NOMATCH
&& rc
!= PCRE_ERROR_PARTIAL
)
7137 DPRINTF((">>>> error: returning %d\n", rc
));
7139 release_match_heapframes(&frame_zero
);
7144 /* Handle partial matches - disable any mark data */
7146 if (match_partial
!= NULL
)
7148 DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
7150 if (offsetcount
> 1)
7152 offsets
[0] = (int)(start_partial
- (PCRE_PUCHAR
)subject
);
7153 offsets
[1] = (int)(end_subject
- (PCRE_PUCHAR
)subject
);
7154 if (offsetcount
> 2)
7155 offsets
[2] = (int)(match_partial
- (PCRE_PUCHAR
)subject
);
7157 rc
= PCRE_ERROR_PARTIAL
;
7160 /* This is the classic nomatch case */
7164 DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
7165 rc
= PCRE_ERROR_NOMATCH
;
7168 /* Return the MARK data if it has been requested. */
7170 if (extra_data
!= NULL
&& (extra_data
->flags
& PCRE_EXTRA_MARK
) != 0)
7171 *(extra_data
->mark
) = (pcre_uchar
*)md
->nomatch_mark
;
7173 release_match_heapframes(&frame_zero
);
7178 /* End of pcre_exec.c */