This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Reinstate aa3f85c5f369736a7e50055b726cf2ca11336ce9.
[perl5.git] / regexec.c
CommitLineData
a0d0e21e
LW		 1/* regexec.c
2 */
3
4/*
4ac71550
TC		 5 * One Ring to rule them all, One Ring to find them
6 &
7 * [p.v of _The Lord of the Rings_, opening poem]
8 * [p.50 of _The Lord of the Rings_, I/iii: "The Shadow of the Past"]
9 * [p.254 of _The Lord of the Rings_, II/ii: "The Council of Elrond"]
a0d0e21e
LW		 10 */
11
61296642
DM		 12/* This file contains functions for executing a regular expression. See
13 * also regcomp.c which funnily enough, contains functions for compiling
166f8a29 14 * a regular expression.
e4a054ea
DM		 15 *
16 * This file is also copied at build time to ext/re/re_exec.c, where
17 * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
18 * This causes the main functions to be compiled under new names and with
19 * debugging support added, which makes "use re 'debug'" work.
166f8a29
DM		 20 */
21
a687059c
LW		 22/* NOTE: this is derived from Henry Spencer's regexp code, and should not
23 * confused with the original package (see point 3 below). Thanks, Henry!
24 */
25
26/* Additional note: this code is very heavily munged from Henry's version
27 * in places. In some spots I've traded clarity for efficiency, so don't
28 * blame Henry for some of the lack of readability.
29 */
30
e50aee73
AD		 31/* The names of the functions have been changed from regcomp and
32 * regexec to pregcomp and pregexec in order to avoid conflicts
33 * with the POSIX routines of the same names.
34*/
35
b9d5759e 36#ifdef PERL_EXT_RE_BUILD
54df2634 37#include "re_top.h"
9041c2e3 38#endif
56953603 39
a687059c 40/*
e50aee73 41 * pregcomp and pregexec -- regsub and regerror are not used in perl
a687059c
LW		 42 *
43 * Copyright (c) 1986 by University of Toronto.
44 * Written by Henry Spencer. Not derived from licensed software.
45 *
46 * Permission is granted to anyone to use this software for any
47 * purpose on any computer system, and to redistribute it freely,
48 * subject to the following restrictions:
49 *
50 * 1. The author is not responsible for the consequences of use of
51 * this software, no matter how awful, even if they arise
52 * from defects in it.
53 *
54 * 2. The origin of this software must not be misrepresented, either
55 * by explicit claim or by omission.
56 *
57 * 3. Altered versions must be plainly marked as such, and must not
58 * be misrepresented as being the original software.
59 *
60 **** Alterations to Henry's code are...
61 ****
4bb101f2 62 **** Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
1129b882
NC		 63 **** 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
64 **** by Larry Wall and others
a687059c 65 ****
9ef589d8
LW		 66 **** You may distribute under the terms of either the GNU General Public
67 **** License or the Artistic License, as specified in the README file.
a687059c
LW		 68 *
69 * Beware that some of this code is subtly aware of the way operator
70 * precedence is structured in regular expressions. Serious changes in
71 * regular-expression syntax might require a total rethink.
72 */
73#include "EXTERN.h"
864dbfa3 74#define PERL_IN_REGEXEC_C
a687059c 75#include "perl.h"
0f5d15d6 76
54df2634
NC		 77#ifdef PERL_IN_XSUB_RE
78# include "re_comp.h"
79#else
80# include "regcomp.h"
81#endif
a687059c 82
c277df42
IZ		 83#define RF_tainted 1 /* tainted information used? */
84#define RF_warned 2 /* warned about big count? */
faec1544 85
ab3bbdeb 86#define RF_utf8 8 /* Pattern contains multibyte chars? */
a0ed51b3 87
f2ed9b32 88#define UTF_PATTERN ((PL_reg_flags & RF_utf8) != 0)
ce862d02
IZ		 89
90#define RS_init 1 /* eval environment created */
91#define RS_set 2 /* replsv value is set */
c277df42 92
a687059c
LW		 93#ifndef STATIC
94#define STATIC static
95#endif
96
32fc9b6a 97#define REGINCLASS(prog,p,c) (ANYOF_FLAGS(p) ? reginclass(prog,p,c,0,0) : ANYOF_BITMAP_TEST(p,*(c)))
7d3e948e 98
c277df42
IZ		 99/*
100 * Forwards.
101 */
102
f2ed9b32 103#define CHR_SVLEN(sv) (utf8_target ? sv_len_utf8(sv) : SvCUR(sv))
53c4c00c 104#define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
a0ed51b3 105
3dab1dad
YO		 106#define HOPc(pos,off) \
107 (char *)(PL_reg_match_utf8 \
52657f30 108 ? reghop3((U8*)pos, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr)) \
3dab1dad
YO		 109 : (U8*)(pos + off))
110#define HOPBACKc(pos, off) \
07be1b83
YO		 111 (char*)(PL_reg_match_utf8\
112 ? reghopmaybe3((U8*)pos, -off, (U8*)PL_bostr) \
113 : (pos - off >= PL_bostr) \
8e11feef 114 ? (U8*)pos - off \
3dab1dad 115 : NULL)
efb30f32 116
e7409c1b 117#define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)(pos), off, (U8*)(lim)) : (U8*)(pos + off))
1aa99e6b 118#define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
1aa99e6b 119
20d0b1e9 120/* these are unrolled below in the CCC_TRY_XXX defined */
1a4fad37
AL		 121#define LOAD_UTF8_CHARCLASS(class,str) STMT_START { \
122 if (!CAT2(PL_utf8_,class)) { bool ok; ENTER; save_re_context(); ok=CAT2(is_utf8_,class)((const U8*)str); assert(ok); LEAVE; } } STMT_END
37e2e78e
KW		 123
124/* Doesn't do an assert to verify that is correct */
125#define LOAD_UTF8_CHARCLASS_NO_CHECK(class) STMT_START { \
126 if (!CAT2(PL_utf8_,class)) { bool ok; ENTER; save_re_context(); ok=CAT2(is_utf8_,class)((const U8*)" "); LEAVE; } } STMT_END
127
1a4fad37
AL		 128#define LOAD_UTF8_CHARCLASS_ALNUM() LOAD_UTF8_CHARCLASS(alnum,"a")
129#define LOAD_UTF8_CHARCLASS_DIGIT() LOAD_UTF8_CHARCLASS(digit,"0")
130#define LOAD_UTF8_CHARCLASS_SPACE() LOAD_UTF8_CHARCLASS(space," ")
51371543 131
37e2e78e 132#define LOAD_UTF8_CHARCLASS_GCB() /* Grapheme cluster boundaries */ \
d275fa5e
CB		 133 LOAD_UTF8_CHARCLASS(X_begin, " "); \
134 LOAD_UTF8_CHARCLASS(X_non_hangul, "A"); \
37e2e78e
KW		 135 /* These are utf8 constants, and not utf-ebcdic constants, so the \
136 * assert should likely and hopefully fail on an EBCDIC machine */ \
d275fa5e 137 LOAD_UTF8_CHARCLASS(X_extend, "\xcc\x80"); /* U+0300 */ \
37e2e78e
KW		 138 \
139 /* No asserts are done for these, in case called on an early \
140 * Unicode version in which they map to nothing */ \
d275fa5e
CB		 141 LOAD_UTF8_CHARCLASS_NO_CHECK(X_prepend);/* U+0E40 "\xe0\xb9\x80" */ \
142 LOAD_UTF8_CHARCLASS_NO_CHECK(X_L); /* U+1100 "\xe1\x84\x80" */ \
143 LOAD_UTF8_CHARCLASS_NO_CHECK(X_LV); /* U+AC00 "\xea\xb0\x80" */ \
144 LOAD_UTF8_CHARCLASS_NO_CHECK(X_LVT); /* U+AC01 "\xea\xb0\x81" */ \
145 LOAD_UTF8_CHARCLASS_NO_CHECK(X_LV_LVT_V);/* U+AC01 "\xea\xb0\x81" */\
146 LOAD_UTF8_CHARCLASS_NO_CHECK(X_T); /* U+11A8 "\xe1\x86\xa8" */ \
37e2e78e 147 LOAD_UTF8_CHARCLASS_NO_CHECK(X_V) /* U+1160 "\xe1\x85\xa0" */
20d0b1e9 148
d1eb3177
YO		 149/*
150 We dont use PERL_LEGACY_UNICODE_CHARCLASS_MAPPINGS as the direct test
151 so that it is possible to override the option here without having to
152 rebuild the entire core. as we are required to do if we change regcomp.h
153 which is where PERL_LEGACY_UNICODE_CHARCLASS_MAPPINGS is defined.
154*/
155#if PERL_LEGACY_UNICODE_CHARCLASS_MAPPINGS
156#define BROKEN_UNICODE_CHARCLASS_MAPPINGS
157#endif
158
159#ifdef BROKEN_UNICODE_CHARCLASS_MAPPINGS
160#define LOAD_UTF8_CHARCLASS_PERL_WORD() LOAD_UTF8_CHARCLASS_ALNUM()
161#define LOAD_UTF8_CHARCLASS_PERL_SPACE() LOAD_UTF8_CHARCLASS_SPACE()
162#define LOAD_UTF8_CHARCLASS_POSIX_DIGIT() LOAD_UTF8_CHARCLASS_DIGIT()
163#define RE_utf8_perl_word PL_utf8_alnum
164#define RE_utf8_perl_space PL_utf8_space
165#define RE_utf8_posix_digit PL_utf8_digit
166#define perl_word alnum
167#define perl_space space
168#define posix_digit digit
169#else
170#define LOAD_UTF8_CHARCLASS_PERL_WORD() LOAD_UTF8_CHARCLASS(perl_word,"a")
171#define LOAD_UTF8_CHARCLASS_PERL_SPACE() LOAD_UTF8_CHARCLASS(perl_space," ")
172#define LOAD_UTF8_CHARCLASS_POSIX_DIGIT() LOAD_UTF8_CHARCLASS(posix_digit,"0")
173#define RE_utf8_perl_word PL_utf8_perl_word
174#define RE_utf8_perl_space PL_utf8_perl_space
175#define RE_utf8_posix_digit PL_utf8_posix_digit
176#endif
177
178
20d0b1e9
YO		 179#define CCC_TRY_AFF(NAME,NAMEL,CLASS,STR,LCFUNC_utf8,FUNC,LCFUNC) \
180 case NAMEL: \
181 PL_reg_flags |= RF_tainted; \
182 /* FALL THROUGH */ \
183 case NAME: \
184 if (!nextchr) \
185 sayNO; \
f2ed9b32 186 if (utf8_target && UTF8_IS_CONTINUED(nextchr)) { \
20d0b1e9
YO		 187 if (!CAT2(PL_utf8_,CLASS)) { \
188 bool ok; \
189 ENTER; \
190 save_re_context(); \
191 ok=CAT2(is_utf8_,CLASS)((const U8*)STR); \
192 assert(ok); \
193 LEAVE; \
194 } \
195 if (!(OP(scan) == NAME \
f2ed9b32 196 ? cBOOL(swash_fetch(CAT2(PL_utf8_,CLASS), (U8*)locinput, utf8_target)) \
20d0b1e9
YO		 197 : LCFUNC_utf8((U8*)locinput))) \
198 { \
199 sayNO; \
200 } \
201 locinput += PL_utf8skip[nextchr]; \
202 nextchr = UCHARAT(locinput); \
203 break; \
204 } \
205 if (!(OP(scan) == NAME ? FUNC(nextchr) : LCFUNC(nextchr))) \
206 sayNO; \
207 nextchr = UCHARAT(++locinput); \
208 break
209
210#define CCC_TRY_NEG(NAME,NAMEL,CLASS,STR,LCFUNC_utf8,FUNC,LCFUNC) \
211 case NAMEL: \
212 PL_reg_flags |= RF_tainted; \
213 /* FALL THROUGH */ \
214 case NAME : \
215 if (!nextchr && locinput >= PL_regeol) \
216 sayNO; \
f2ed9b32 217 if (utf8_target && UTF8_IS_CONTINUED(nextchr)) { \
20d0b1e9
YO		 218 if (!CAT2(PL_utf8_,CLASS)) { \
219 bool ok; \
220 ENTER; \
221 save_re_context(); \
222 ok=CAT2(is_utf8_,CLASS)((const U8*)STR); \
223 assert(ok); \
224 LEAVE; \
225 } \
226 if ((OP(scan) == NAME \
f2ed9b32 227 ? cBOOL(swash_fetch(CAT2(PL_utf8_,CLASS), (U8*)locinput, utf8_target)) \
20d0b1e9
YO		 228 : LCFUNC_utf8((U8*)locinput))) \
229 { \
230 sayNO; \
231 } \
232 locinput += PL_utf8skip[nextchr]; \
233 nextchr = UCHARAT(locinput); \
234 break; \
235 } \
236 if ((OP(scan) == NAME ? FUNC(nextchr) : LCFUNC(nextchr))) \
237 sayNO; \
238 nextchr = UCHARAT(++locinput); \
239 break
240
241
d1eb3177
YO		 242
243
244
3dab1dad
YO		 245/* TODO: Combine JUMPABLE and HAS_TEXT to cache OP(rn) */
246
5f80c4cf 247/* for use after a quantifier and before an EXACT-like node -- japhy */
3e901dc0
YO		 248/* it would be nice to rework regcomp.sym to generate this stuff. sigh */
249#define JUMPABLE(rn) ( \
250 OP(rn) == OPEN || \
251 (OP(rn) == CLOSE && (!cur_eval || cur_eval->u.eval.close_paren != ARG(rn))) || \
252 OP(rn) == EVAL || \
cca55fe3
JP		 253 OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
254 OP(rn) == PLUS || OP(rn) == MINMOD || \
ee9b8eae 255 OP(rn) == KEEPS || (PL_regkind[OP(rn)] == VERB) || \
3dab1dad 256 (PL_regkind[OP(rn)] == CURLY && ARG1(rn) > 0) \
e2d8ce26 257)
ee9b8eae 258#define IS_EXACT(rn) (PL_regkind[OP(rn)] == EXACT)
e2d8ce26 259
ee9b8eae
YO		 260#define HAS_TEXT(rn) ( IS_EXACT(rn) || PL_regkind[OP(rn)] == REF )
261
262#if 0
263/* Currently these are only used when PL_regkind[OP(rn)] == EXACT so
264 we don't need this definition. */
265#define IS_TEXT(rn) ( OP(rn)==EXACT || OP(rn)==REF || OP(rn)==NREF )
266#define IS_TEXTF(rn) ( OP(rn)==EXACTF || OP(rn)==REFF || OP(rn)==NREFF )
267#define IS_TEXTFL(rn) ( OP(rn)==EXACTFL || OP(rn)==REFFL || OP(rn)==NREFFL )
268
269#else
270/* ... so we use this as its faster. */
271#define IS_TEXT(rn) ( OP(rn)==EXACT )
272#define IS_TEXTF(rn) ( OP(rn)==EXACTF )
273#define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
274
275#endif
e2d8ce26 276
a84d97b6
HS		 277/*
278 Search for mandatory following text node; for lookahead, the text must
279 follow but for lookbehind (rn->flags != 0) we skip to the next step.
280*/
cca55fe3 281#define FIND_NEXT_IMPT(rn) STMT_START { \
3dab1dad
YO		 282 while (JUMPABLE(rn)) { \
283 const OPCODE type = OP(rn); \
284 if (type == SUSPEND || PL_regkind[type] == CURLY) \
e2d8ce26 285 rn = NEXTOPER(NEXTOPER(rn)); \
3dab1dad 286 else if (type == PLUS) \
cca55fe3 287 rn = NEXTOPER(rn); \
3dab1dad 288 else if (type == IFMATCH) \
a84d97b6 289 rn = (rn->flags == 0) ? NEXTOPER(NEXTOPER(rn)) : rn + ARG(rn); \
e2d8ce26 290 else rn += NEXT_OFF(rn); \
3dab1dad 291 } \
5f80c4cf 292} STMT_END
74750237 293
c476f425 294
acfe0abc 295static void restore_pos(pTHX_ void *arg);
51371543 296
620d5b66
NC		 297#define REGCP_PAREN_ELEMS 4
298#define REGCP_OTHER_ELEMS 5
e0fa7e2b 299#define REGCP_FRAME_ELEMS 1
620d5b66
NC		 300/* REGCP_FRAME_ELEMS are not part of the REGCP_OTHER_ELEMS and
301 * are needed for the regexp context stack bookkeeping. */
302
76e3520e 303STATIC CHECKPOINT
cea2e8a9 304S_regcppush(pTHX_ I32 parenfloor)
a0d0e21e 305{
97aff369 306 dVAR;
a3b680e6 307 const int retval = PL_savestack_ix;
a3b680e6 308 const int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
e0fa7e2b
NC		 309 const UV total_elems = paren_elems_to_push + REGCP_OTHER_ELEMS;
310 const UV elems_shifted = total_elems << SAVE_TIGHT_SHIFT;
a0d0e21e 311 int p;
40a82448 312 GET_RE_DEBUG_FLAGS_DECL;
a0d0e21e 313
e49a9654
IH		 314 if (paren_elems_to_push < 0)
315 Perl_croak(aTHX_ "panic: paren_elems_to_push < 0");
316
e0fa7e2b
NC		 317 if ((elems_shifted >> SAVE_TIGHT_SHIFT) != total_elems)
318 Perl_croak(aTHX_ "panic: paren_elems_to_push offset %"UVuf
5df417d0
JH		 319 " out of range (%lu-%ld)",
320 total_elems, (unsigned long)PL_regsize, (long)parenfloor);
e0fa7e2b 321
620d5b66 322 SSGROW(total_elems + REGCP_FRAME_ELEMS);
7f69552c 323
3280af22 324 for (p = PL_regsize; p > parenfloor; p--) {
b1ce53c5 325/* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
f0ab9afb
NC		 326 SSPUSHINT(PL_regoffs[p].end);
327 SSPUSHINT(PL_regoffs[p].start);
3280af22 328 SSPUSHPTR(PL_reg_start_tmp[p]);
a0d0e21e 329 SSPUSHINT(p);
e7707071 330 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
40a82448 331 " saving \\%"UVuf" %"IVdf"(%"IVdf")..%"IVdf"\n",
f0ab9afb 332 (UV)p, (IV)PL_regoffs[p].start,
40a82448 333 (IV)(PL_reg_start_tmp[p] - PL_bostr),
f0ab9afb 334 (IV)PL_regoffs[p].end
40a82448 335 ));
a0d0e21e 336 }
b1ce53c5 337/* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
f0ab9afb 338 SSPUSHPTR(PL_regoffs);
3280af22
NIS		 339 SSPUSHINT(PL_regsize);
340 SSPUSHINT(*PL_reglastparen);
a01268b5 341 SSPUSHINT(*PL_reglastcloseparen);
3280af22 342 SSPUSHPTR(PL_reginput);
e0fa7e2b 343 SSPUSHUV(SAVEt_REGCONTEXT | elems_shifted); /* Magic cookie. */
41123dfd 344
a0d0e21e
LW		 345 return retval;
346}
347
c277df42 348/* These are needed since we do not localize EVAL nodes: */
ab3bbdeb
YO		 349#define REGCP_SET(cp) \
350 DEBUG_STATE_r( \
ab3bbdeb 351 PerlIO_printf(Perl_debug_log, \
e4f74956 352 " Setting an EVAL scope, savestack=%"IVdf"\n", \
ab3bbdeb
YO		 353 (IV)PL_savestack_ix)); \
354 cp = PL_savestack_ix
c3464db5 355
ab3bbdeb 356#define REGCP_UNWIND(cp) \
e4f74956 357 DEBUG_STATE_r( \
ab3bbdeb 358 if (cp != PL_savestack_ix) \
e4f74956
YO		 359 PerlIO_printf(Perl_debug_log, \
360 " Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
ab3bbdeb
YO		 361 (IV)(cp), (IV)PL_savestack_ix)); \
362 regcpblow(cp)
c277df42 363
76e3520e 364STATIC char *
097eb12c 365S_regcppop(pTHX_ const regexp *rex)
a0d0e21e 366{
97aff369 367 dVAR;
e0fa7e2b 368 UV i;
a0d0e21e 369 char *input;
a3621e74
YO		 370 GET_RE_DEBUG_FLAGS_DECL;
371
7918f24d
NC		 372 PERL_ARGS_ASSERT_REGCPPOP;
373
b1ce53c5 374 /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
c6bf6a65 375 i = SSPOPUV;
e0fa7e2b
NC		 376 assert((i & SAVE_MASK) == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
377 i >>= SAVE_TIGHT_SHIFT; /* Parentheses elements to pop. */
a0d0e21e 378 input = (char *) SSPOPPTR;
a01268b5 379 *PL_reglastcloseparen = SSPOPINT;
3280af22
NIS		 380 *PL_reglastparen = SSPOPINT;
381 PL_regsize = SSPOPINT;
f0ab9afb 382 PL_regoffs=(regexp_paren_pair *) SSPOPPTR;
b1ce53c5 383
620d5b66 384 i -= REGCP_OTHER_ELEMS;
b1ce53c5 385 /* Now restore the parentheses context. */
620d5b66 386 for ( ; i > 0; i -= REGCP_PAREN_ELEMS) {
1df70142 387 I32 tmps;
097eb12c 388 U32 paren = (U32)SSPOPINT;
3280af22 389 PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
f0ab9afb 390 PL_regoffs[paren].start = SSPOPINT;
cf93c79d 391 tmps = SSPOPINT;
3280af22 392 if (paren <= *PL_reglastparen)
f0ab9afb 393 PL_regoffs[paren].end = tmps;
e7707071 394 DEBUG_BUFFERS_r(
c3464db5 395 PerlIO_printf(Perl_debug_log,
b900a521 396 " restoring \\%"UVuf" to %"IVdf"(%"IVdf")..%"IVdf"%s\n",
f0ab9afb 397 (UV)paren, (IV)PL_regoffs[paren].start,
b900a521 398 (IV)(PL_reg_start_tmp[paren] - PL_bostr),
f0ab9afb 399 (IV)PL_regoffs[paren].end,
3280af22 400 (paren > *PL_reglastparen ? "(no)" : ""));
c277df42 401 );
a0d0e21e 402 }
e7707071 403 DEBUG_BUFFERS_r(
bb7a0f54 404 if (*PL_reglastparen + 1 <= rex->nparens) {
c3464db5 405 PerlIO_printf(Perl_debug_log,
faccc32b 406 " restoring \\%"IVdf"..\\%"IVdf" to undef\n",
4f639d21 407 (IV)(*PL_reglastparen + 1), (IV)rex->nparens);
c277df42
IZ		 408 }
409 );
daf18116 410#if 1
dafc8851
JH		 411 /* It would seem that the similar code in regtry()
412 * already takes care of this, and in fact it is in
413 * a better location to since this code can #if 0-ed out
414 * but the code in regtry() is needed or otherwise tests
415 * requiring null fields (pat.t#187 and split.t#{13,14}
daf18116
JH		 416 * (as of patchlevel 7877) will fail. Then again,
417 * this code seems to be necessary or otherwise
225593e1
DM		 418 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
419 * --jhi updated by dapm */
3b6647e0 420 for (i = *PL_reglastparen + 1; i <= rex->nparens; i++) {
097eb12c 421 if (i > PL_regsize)
f0ab9afb
NC		 422 PL_regoffs[i].start = -1;
423 PL_regoffs[i].end = -1;
a0d0e21e 424 }
dafc8851 425#endif
a0d0e21e
LW		 426 return input;
427}
428
02db2b7b 429#define regcpblow(cp) LEAVE_SCOPE(cp) /* Ignores regcppush()ed data. */
a0d0e21e 430
a687059c 431/*
e50aee73 432 * pregexec and friends
a687059c
LW		 433 */
434
76234dfb 435#ifndef PERL_IN_XSUB_RE
a687059c 436/*
c277df42 437 - pregexec - match a regexp against a string
a687059c 438 */
c277df42 439I32
49d7dfbc 440Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, register char *strend,
c3464db5 441 char *strbeg, I32 minend, SV *screamer, U32 nosave)
c277df42
IZ		 442/* strend: pointer to null at end of string */
443/* strbeg: real beginning of string */
444/* minend: end of match must be >=minend after stringarg. */
445/* nosave: For optimizations. */
446{
7918f24d
NC		 447 PERL_ARGS_ASSERT_PREGEXEC;
448
c277df42 449 return
9041c2e3 450 regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
c277df42
IZ		 451 nosave ? 0 : REXEC_COPY_STR);
452}
76234dfb 453#endif
22e551b9 454
9041c2e3 455/*
cad2e5aa
JH		 456 * Need to implement the following flags for reg_anch:
457 *
458 * USE_INTUIT_NOML - Useful to call re_intuit_start() first
459 * USE_INTUIT_ML
460 * INTUIT_AUTORITATIVE_NOML - Can trust a positive answer
461 * INTUIT_AUTORITATIVE_ML
462 * INTUIT_ONCE_NOML - Intuit can match in one location only.
463 * INTUIT_ONCE_ML
464 *
465 * Another flag for this function: SECOND_TIME (so that float substrs
466 * with giant delta may be not rechecked).
467 */
468
469/* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
470
3f7c398e 471/* If SCREAM, then SvPVX_const(sv) should be compatible with strpos and strend.
cad2e5aa
JH		 472 Otherwise, only SvCUR(sv) is used to get strbeg. */
473
474/* XXXX We assume that strpos is strbeg unless sv. */
475
6eb5f6b9
JH		 476/* XXXX Some places assume that there is a fixed substring.
477 An update may be needed if optimizer marks as "INTUITable"
478 RExen without fixed substrings. Similarly, it is assumed that
479 lengths of all the strings are no more than minlen, thus they
480 cannot come from lookahead.
40d049e4
YO		 481 (Or minlen should take into account lookahead.)
482 NOTE: Some of this comment is not correct. minlen does now take account
483 of lookahead/behind. Further research is required. -- demerphq
484
485*/
6eb5f6b9 486
2c2d71f5
JH		 487/* A failure to find a constant substring means that there is no need to make
488 an expensive call to REx engine, thus we celebrate a failure. Similarly,
489 finding a substring too deep into the string means that less calls to
30944b6d
IZ		 490 regtry() should be needed.
491
492 REx compiler's optimizer found 4 possible hints:
493 a) Anchored substring;
494 b) Fixed substring;
495 c) Whether we are anchored (beginning-of-line or \G);
496 d) First node (of those at offset 0) which may distingush positions;
6eb5f6b9 497 We use a)b)d) and multiline-part of c), and try to find a position in the
30944b6d
IZ		 498 string which does not contradict any of them.
499 */
2c2d71f5 500
6eb5f6b9
JH		 501/* Most of decisions we do here should have been done at compile time.
502 The nodes of the REx which we used for the search should have been
503 deleted from the finite automaton. */
504
cad2e5aa 505char *
288b8c02 506Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
9f61653a 507 char *strend, const U32 flags, re_scream_pos_data *data)
cad2e5aa 508{
97aff369 509 dVAR;
288b8c02 510 struct regexp *const prog = (struct regexp *)SvANY(rx);
b7953727 511 register I32 start_shift = 0;
cad2e5aa 512 /* Should be nonnegative! */
b7953727 513 register I32 end_shift = 0;
2c2d71f5
JH		 514 register char *s;
515 register SV *check;
a1933d95 516 char *strbeg;
cad2e5aa 517 char *t;
f2ed9b32 518 const bool utf8_target = (sv && SvUTF8(sv)) ? 1 : 0; /* if no sv we have to assume bytes */
cad2e5aa 519 I32 ml_anch;
bd61b366
SS		 520 register char *other_last = NULL; /* other substr checked before this */
521 char *check_at = NULL; /* check substr found at this pos */
bbe252da 522 const I32 multiline = prog->extflags & RXf_PMf_MULTILINE;
f8fc2ecf 523 RXi_GET_DECL(prog,progi);
30944b6d 524#ifdef DEBUGGING
890ce7af 525 const char * const i_strpos = strpos;
30944b6d 526#endif
a3621e74
YO		 527 GET_RE_DEBUG_FLAGS_DECL;
528
7918f24d
NC		 529 PERL_ARGS_ASSERT_RE_INTUIT_START;
530
f2ed9b32 531 RX_MATCH_UTF8_set(rx,utf8_target);
cad2e5aa 532
3c8556c3 533 if (RX_UTF8(rx)) {
b8d68ded
JH		 534 PL_reg_flags |= RF_utf8;
535 }
ab3bbdeb 536 DEBUG_EXECUTE_r(
f2ed9b32 537 debug_start_match(rx, utf8_target, strpos, strend,
1de06328
YO		 538 sv ? "Guessing start of match in sv for"
539 : "Guessing start of match in string for");
2a782b5b 540 );
cad2e5aa 541
c344f387
JH		 542 /* CHR_DIST() would be more correct here but it makes things slow. */
543 if (prog->minlen > strend - strpos) {
a3621e74 544 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584 545 "String too short... [re_intuit_start]\n"));
cad2e5aa 546 goto fail;
2c2d71f5 547 }
1de06328 548
a1933d95 549 strbeg = (sv && SvPOK(sv)) ? strend - SvCUR(sv) : strpos;
1aa99e6b 550 PL_regeol = strend;
f2ed9b32 551 if (utf8_target) {
33b8afdf
JH		 552 if (!prog->check_utf8 && prog->check_substr)
553 to_utf8_substr(prog);
554 check = prog->check_utf8;
555 } else {
556 if (!prog->check_substr && prog->check_utf8)
557 to_byte_substr(prog);
558 check = prog->check_substr;
559 }
1de06328 560 if (check == &PL_sv_undef) {
a3621e74 561 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
1de06328 562 "Non-utf8 string cannot match utf8 check string\n"));
33b8afdf
JH		 563 goto fail;
564 }
bbe252da
YO		 565 if (prog->extflags & RXf_ANCH) { /* Match at beg-of-str or after \n */
566 ml_anch = !( (prog->extflags & RXf_ANCH_SINGLE)
567 || ( (prog->extflags & RXf_ANCH_BOL)
7fba1cd6 568 && !multiline ) ); /* Check after \n? */
cad2e5aa 569
7e25d62c 570 if (!ml_anch) {
bbe252da
YO		 571 if ( !(prog->extflags & RXf_ANCH_GPOS) /* Checked by the caller */
572 && !(prog->intflags & PREGf_IMPLICIT) /* not a real BOL */
3f7c398e 573 /* SvCUR is not set on references: SvRV and SvPVX_const overlap */
7e25d62c
JH		 574 && sv && !SvROK(sv)
575 && (strpos != strbeg)) {
a3621e74 576 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
7e25d62c
JH		 577 goto fail;
578 }
579 if (prog->check_offset_min == prog->check_offset_max &&
bbe252da 580 !(prog->extflags & RXf_CANY_SEEN)) {
2c2d71f5 581 /* Substring at constant offset from beg-of-str... */
cad2e5aa
JH		 582 I32 slen;
583
1aa99e6b 584 s = HOP3c(strpos, prog->check_offset_min, strend);
1de06328 585
653099ff
GS		 586 if (SvTAIL(check)) {
587 slen = SvCUR(check); /* >= 1 */
cad2e5aa 588
9041c2e3 589 if ( strend - s > slen || strend - s < slen - 1
2c2d71f5 590 || (strend - s == slen && strend[-1] != '\n')) {
a3621e74 591 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
2c2d71f5 592 goto fail_finish;
cad2e5aa
JH		 593 }
594 /* Now should match s[0..slen-2] */
595 slen--;
3f7c398e 596 if (slen && (*SvPVX_const(check) != *s
cad2e5aa 597 || (slen > 1
3f7c398e 598 && memNE(SvPVX_const(check), s, slen)))) {
2c2d71f5 599 report_neq:
a3621e74 600 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
2c2d71f5
JH		 601 goto fail_finish;
602 }
cad2e5aa 603 }
3f7c398e 604 else if (*SvPVX_const(check) != *s
653099ff 605 || ((slen = SvCUR(check)) > 1
3f7c398e 606 && memNE(SvPVX_const(check), s, slen)))
2c2d71f5 607 goto report_neq;
c315bfe8 608 check_at = s;
2c2d71f5 609 goto success_at_start;
7e25d62c 610 }
cad2e5aa 611 }
2c2d71f5 612 /* Match is anchored, but substr is not anchored wrt beg-of-str. */
cad2e5aa 613 s = strpos;
2c2d71f5 614 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
1de06328
YO		 615 end_shift = prog->check_end_shift;
616
2c2d71f5 617 if (!ml_anch) {
a3b680e6 618 const I32 end = prog->check_offset_max + CHR_SVLEN(check)
653099ff 619 - (SvTAIL(check) != 0);
a3b680e6 620 const I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
2c2d71f5
JH		 621
622 if (end_shift < eshift)
623 end_shift = eshift;
624 }
cad2e5aa 625 }
2c2d71f5 626 else { /* Can match at random position */
cad2e5aa
JH		 627 ml_anch = 0;
628 s = strpos;
1de06328
YO		 629 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
630 end_shift = prog->check_end_shift;
631
632 /* end shift should be non negative here */
cad2e5aa
JH		 633 }
634
bcdf7404 635#ifdef QDEBUGGING /* 7/99: reports of failure (with the older version) */
0033605d 636 if (end_shift < 0)
1de06328 637 Perl_croak(aTHX_ "panic: end_shift: %"IVdf" pattern:\n%s\n ",
220fc49f 638 (IV)end_shift, RX_PRECOMP(prog));
2c2d71f5
JH		 639#endif
640
2c2d71f5
JH		 641 restart:
642 /* Find a possible match in the region s..strend by looking for
643 the "check" substring in the region corrected by start/end_shift. */
1de06328
YO		 644
645 {
646 I32 srch_start_shift = start_shift;
647 I32 srch_end_shift = end_shift;
648 if (srch_start_shift < 0 && strbeg - s > srch_start_shift) {
649 srch_end_shift -= ((strbeg - s) - srch_start_shift);
650 srch_start_shift = strbeg - s;
651 }
6bda09f9 652 DEBUG_OPTIMISE_MORE_r({
1de06328
YO		 653 PerlIO_printf(Perl_debug_log, "Check offset min: %"IVdf" Start shift: %"IVdf" End shift %"IVdf" Real End Shift: %"IVdf"\n",
654 (IV)prog->check_offset_min,
655 (IV)srch_start_shift,
656 (IV)srch_end_shift,
657 (IV)prog->check_end_shift);
658 });
659
cad2e5aa 660 if (flags & REXEC_SCREAM) {
cad2e5aa 661 I32 p = -1; /* Internal iterator of scream. */
a3b680e6 662 I32 * const pp = data ? data->scream_pos : &p;
cad2e5aa 663
2c2d71f5
JH		 664 if (PL_screamfirst[BmRARE(check)] >= 0
665 || ( BmRARE(check) == '\n'
85c508c3 666 && (BmPREVIOUS(check) == SvCUR(check) - 1)
2c2d71f5 667 && SvTAIL(check) ))
9041c2e3 668 s = screaminstr(sv, check,
1de06328 669 srch_start_shift + (s - strbeg), srch_end_shift, pp, 0);
cad2e5aa 670 else
2c2d71f5 671 goto fail_finish;
4addbd3b 672 /* we may be pointing at the wrong string */
07bc277f 673 if (s && RXp_MATCH_COPIED(prog))
3f7c398e 674 s = strbeg + (s - SvPVX_const(sv));
cad2e5aa
JH		 675 if (data)
676 *data->scream_olds = s;
677 }
1de06328
YO		 678 else {
679 U8* start_point;
680 U8* end_point;
bbe252da 681 if (prog->extflags & RXf_CANY_SEEN) {
1de06328
YO		 682 start_point= (U8*)(s + srch_start_shift);
683 end_point= (U8*)(strend - srch_end_shift);
684 } else {
685 start_point= HOP3(s, srch_start_shift, srch_start_shift < 0 ? strbeg : strend);
686 end_point= HOP3(strend, -srch_end_shift, strbeg);
687 }
6bda09f9 688 DEBUG_OPTIMISE_MORE_r({
56570a2c 689 PerlIO_printf(Perl_debug_log, "fbm_instr len=%d str=<%.*s>\n",
1de06328 690 (int)(end_point - start_point),
fc8cd66c 691 (int)(end_point - start_point) > 20 ? 20 : (int)(end_point - start_point),
1de06328
YO		 692 start_point);
693 });
694
695 s = fbm_instr( start_point, end_point,
7fba1cd6 696 check, multiline ? FBMrf_MULTILINE : 0);
1de06328
YO		 697 }
698 }
cad2e5aa
JH		 699 /* Update the count-of-usability, remove useless subpatterns,
700 unshift s. */
2c2d71f5 701
ab3bbdeb 702 DEBUG_EXECUTE_r({
f2ed9b32 703 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO		 704 SvPVX_const(check), RE_SV_DUMPLEN(check), 30);
705 PerlIO_printf(Perl_debug_log, "%s %s substr %s%s%s",
2c2d71f5 706 (s ? "Found" : "Did not find"),
f2ed9b32 707 (check == (utf8_target ? prog->anchored_utf8 : prog->anchored_substr)
ab3bbdeb
YO		 708 ? "anchored" : "floating"),
709 quoted,
710 RE_SV_TAIL(check),
711 (s ? " at offset " : "...\n") );
712 });
2c2d71f5
JH		 713
714 if (!s)
715 goto fail_finish;
2c2d71f5 716 /* Finish the diagnostic message */
a3621e74 717 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
2c2d71f5 718
1de06328
YO		 719 /* XXX dmq: first branch is for positive lookbehind...
720 Our check string is offset from the beginning of the pattern.
721 So we need to do any stclass tests offset forward from that
722 point. I think. :-(
723 */
724
725
726
727 check_at=s;
728
729
2c2d71f5
JH		 730 /* Got a candidate. Check MBOL anchoring, and the *other* substr.
731 Start with the other substr.
732 XXXX no SCREAM optimization yet - and a very coarse implementation
a0288114 733 XXXX /ttx+/ results in anchored="ttx", floating="x". floating will
2c2d71f5
JH		 734 *always* match. Probably should be marked during compile...
735 Probably it is right to do no SCREAM here...
736 */
737
f2ed9b32 738 if (utf8_target ? (prog->float_utf8 && prog->anchored_utf8)
1de06328
YO		 739 : (prog->float_substr && prog->anchored_substr))
740 {
30944b6d 741 /* Take into account the "other" substring. */
2c2d71f5
JH		 742 /* XXXX May be hopelessly wrong for UTF... */
743 if (!other_last)
6eb5f6b9 744 other_last = strpos;
f2ed9b32 745 if (check == (utf8_target ? prog->float_utf8 : prog->float_substr)) {
30944b6d
IZ		 746 do_other_anchored:
747 {
890ce7af
AL		 748 char * const last = HOP3c(s, -start_shift, strbeg);
749 char *last1, *last2;
be8e71aa 750 char * const saved_s = s;
33b8afdf 751 SV* must;
2c2d71f5 752
2c2d71f5
JH		 753 t = s - prog->check_offset_max;
754 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
f2ed9b32 755 && (!utf8_target
0ce71af7 756 || ((t = (char*)reghopmaybe3((U8*)s, -(prog->check_offset_max), (U8*)strpos))
2c2d71f5 757 && t > strpos)))
6f207bd3 758 NOOP;
2c2d71f5
JH		 759 else
760 t = strpos;
1aa99e6b 761 t = HOP3c(t, prog->anchored_offset, strend);
6eb5f6b9
JH		 762 if (t < other_last) /* These positions already checked */
763 t = other_last;
1aa99e6b 764 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
2c2d71f5
JH		 765 if (last < last1)
766 last1 = last;
1de06328
YO		 767 /* XXXX It is not documented what units *_offsets are in.
768 We assume bytes, but this is clearly wrong.
769 Meaning this code needs to be carefully reviewed for errors.
770 dmq.
771 */
772
2c2d71f5 773 /* On end-of-str: see comment below. */
f2ed9b32 774 must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
33b8afdf
JH		 775 if (must == &PL_sv_undef) {
776 s = (char*)NULL;
1de06328 777 DEBUG_r(must = prog->anchored_utf8); /* for debug */
33b8afdf
JH		 778 }
779 else
780 s = fbm_instr(
781 (unsigned char*)t,
782 HOP3(HOP3(last1, prog->anchored_offset, strend)
783 + SvCUR(must), -(SvTAIL(must)!=0), strbeg),
784 must,
7fba1cd6 785 multiline ? FBMrf_MULTILINE : 0
33b8afdf 786 );
ab3bbdeb 787 DEBUG_EXECUTE_r({
f2ed9b32 788 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO		 789 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
790 PerlIO_printf(Perl_debug_log, "%s anchored substr %s%s",
2c2d71f5 791 (s ? "Found" : "Contradicts"),
ab3bbdeb
YO		 792 quoted, RE_SV_TAIL(must));
793 });
794
795
2c2d71f5
JH		 796 if (!s) {
797 if (last1 >= last2) {
a3621e74 798 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5
JH		 799 ", giving up...\n"));
800 goto fail_finish;
801 }
a3621e74 802 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5 803 ", trying floating at offset %ld...\n",
be8e71aa 804 (long)(HOP3c(saved_s, 1, strend) - i_strpos)));
1aa99e6b
IH		 805 other_last = HOP3c(last1, prog->anchored_offset+1, strend);
806 s = HOP3c(last, 1, strend);
2c2d71f5
JH		 807 goto restart;
808 }
809 else {
a3621e74 810 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
30944b6d 811 (long)(s - i_strpos)));
1aa99e6b
IH		 812 t = HOP3c(s, -prog->anchored_offset, strbeg);
813 other_last = HOP3c(s, 1, strend);
be8e71aa 814 s = saved_s;
2c2d71f5
JH		 815 if (t == strpos)
816 goto try_at_start;
2c2d71f5
JH		 817 goto try_at_offset;
818 }
30944b6d 819 }
2c2d71f5
JH		 820 }
821 else { /* Take into account the floating substring. */
33b8afdf 822 char *last, *last1;
be8e71aa 823 char * const saved_s = s;
33b8afdf
JH		 824 SV* must;
825
826 t = HOP3c(s, -start_shift, strbeg);
827 last1 = last =
828 HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
829 if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
830 last = HOP3c(t, prog->float_max_offset, strend);
831 s = HOP3c(t, prog->float_min_offset, strend);
832 if (s < other_last)
833 s = other_last;
2c2d71f5 834 /* XXXX It is not documented what units *_offsets are in. Assume bytes. */
f2ed9b32 835 must = utf8_target ? prog->float_utf8 : prog->float_substr;
33b8afdf
JH		 836 /* fbm_instr() takes into account exact value of end-of-str
837 if the check is SvTAIL(ed). Since false positives are OK,
838 and end-of-str is not later than strend we are OK. */
839 if (must == &PL_sv_undef) {
840 s = (char*)NULL;
1de06328 841 DEBUG_r(must = prog->float_utf8); /* for debug message */
33b8afdf
JH		 842 }
843 else
2c2d71f5 844 s = fbm_instr((unsigned char*)s,
33b8afdf
JH		 845 (unsigned char*)last + SvCUR(must)
846 - (SvTAIL(must)!=0),
7fba1cd6 847 must, multiline ? FBMrf_MULTILINE : 0);
ab3bbdeb 848 DEBUG_EXECUTE_r({
f2ed9b32 849 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO		 850 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
851 PerlIO_printf(Perl_debug_log, "%s floating substr %s%s",
33b8afdf 852 (s ? "Found" : "Contradicts"),
ab3bbdeb
YO		 853 quoted, RE_SV_TAIL(must));
854 });
33b8afdf
JH		 855 if (!s) {
856 if (last1 == last) {
a3621e74 857 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf
JH		 858 ", giving up...\n"));
859 goto fail_finish;
2c2d71f5 860 }
a3621e74 861 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf 862 ", trying anchored starting at offset %ld...\n",
be8e71aa 863 (long)(saved_s + 1 - i_strpos)));
33b8afdf
JH		 864 other_last = last;
865 s = HOP3c(t, 1, strend);
866 goto restart;
867 }
868 else {
a3621e74 869 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
33b8afdf
JH		 870 (long)(s - i_strpos)));
871 other_last = s; /* Fix this later. --Hugo */
be8e71aa 872 s = saved_s;
33b8afdf
JH		 873 if (t == strpos)
874 goto try_at_start;
875 goto try_at_offset;
876 }
2c2d71f5 877 }
cad2e5aa 878 }
2c2d71f5 879
1de06328 880
9ef43ace 881 t= (char*)HOP3( s, -prog->check_offset_max, (prog->check_offset_max<0) ? strend : strpos);
1de06328 882
6bda09f9 883 DEBUG_OPTIMISE_MORE_r(
1de06328
YO		 884 PerlIO_printf(Perl_debug_log,
885 "Check offset min:%"IVdf" max:%"IVdf" S:%"IVdf" t:%"IVdf" D:%"IVdf" end:%"IVdf"\n",
886 (IV)prog->check_offset_min,
887 (IV)prog->check_offset_max,
888 (IV)(s-strpos),
889 (IV)(t-strpos),
890 (IV)(t-s),
891 (IV)(strend-strpos)
892 )
893 );
894
2c2d71f5 895 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
f2ed9b32 896 && (!utf8_target
9ef43ace 897 || ((t = (char*)reghopmaybe3((U8*)s, -prog->check_offset_max, (U8*) ((prog->check_offset_max<0) ? strend : strpos)))
1de06328
YO		 898 && t > strpos)))
899 {
2c2d71f5
JH		 900 /* Fixed substring is found far enough so that the match
901 cannot start at strpos. */
902 try_at_offset:
cad2e5aa 903 if (ml_anch && t[-1] != '\n') {
30944b6d
IZ		 904 /* Eventually fbm_*() should handle this, but often
905 anchored_offset is not 0, so this check will not be wasted. */
906 /* XXXX In the code below we prefer to look for "^" even in
907 presence of anchored substrings. And we search even
908 beyond the found float position. These pessimizations
909 are historical artefacts only. */
910 find_anchor:
2c2d71f5 911 while (t < strend - prog->minlen) {
cad2e5aa 912 if (*t == '\n') {
4ee3650e 913 if (t < check_at - prog->check_offset_min) {
f2ed9b32 914 if (utf8_target ? prog->anchored_utf8 : prog->anchored_substr) {
4ee3650e
GS		 915 /* Since we moved from the found position,
916 we definitely contradict the found anchored
30944b6d
IZ		 917 substr. Due to the above check we do not
918 contradict "check" substr.
919 Thus we can arrive here only if check substr
920 is float. Redo checking for "other"=="fixed".
921 */
9041c2e3 922 strpos = t + 1;
a3621e74 923 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
e4584336 924 PL_colors[0], PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
30944b6d
IZ		 925 goto do_other_anchored;
926 }
4ee3650e
GS		 927 /* We don't contradict the found floating substring. */
928 /* XXXX Why not check for STCLASS? */
cad2e5aa 929 s = t + 1;
a3621e74 930 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
e4584336 931 PL_colors[0], PL_colors[1], (long)(s - i_strpos)));
cad2e5aa
JH		 932 goto set_useful;
933 }
4ee3650e
GS		 934 /* Position contradicts check-string */
935 /* XXXX probably better to look for check-string
936 than for "\n", so one should lower the limit for t? */
a3621e74 937 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
e4584336 938 PL_colors[0], PL_colors[1], (long)(t + 1 - i_strpos)));
0e41cd87 939 other_last = strpos = s = t + 1;
cad2e5aa
JH		 940 goto restart;
941 }
942 t++;
943 }
a3621e74 944 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
e4584336 945 PL_colors[0], PL_colors[1]));
2c2d71f5 946 goto fail_finish;
cad2e5aa 947 }
f5952150 948 else {
a3621e74 949 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
e4584336 950 PL_colors[0], PL_colors[1]));
f5952150 951 }
cad2e5aa
JH		 952 s = t;
953 set_useful:
f2ed9b32 954 ++BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr); /* hooray/5 */
cad2e5aa
JH		 955 }
956 else {
f5952150 957 /* The found string does not prohibit matching at strpos,
2c2d71f5 958 - no optimization of calling REx engine can be performed,
f5952150
GS		 959 unless it was an MBOL and we are not after MBOL,
960 or a future STCLASS check will fail this. */
2c2d71f5
JH		 961 try_at_start:
962 /* Even in this situation we may use MBOL flag if strpos is offset
963 wrt the start of the string. */
05b4157f 964 if (ml_anch && sv && !SvROK(sv) /* See prev comment on SvROK */
a1933d95 965 && (strpos != strbeg) && strpos[-1] != '\n'
d506a20d 966 /* May be due to an implicit anchor of m{.*foo} */
bbe252da 967 && !(prog->intflags & PREGf_IMPLICIT))
d506a20d 968 {
cad2e5aa
JH		 969 t = strpos;
970 goto find_anchor;
971 }
a3621e74 972 DEBUG_EXECUTE_r( if (ml_anch)
f5952150 973 PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
70685ca0 974 (long)(strpos - i_strpos), PL_colors[0], PL_colors[1]);
30944b6d 975 );
2c2d71f5 976 success_at_start:
bbe252da 977 if (!(prog->intflags & PREGf_NAUGHTY) /* XXXX If strpos moved? */
f2ed9b32 978 && (utf8_target ? (
33b8afdf
JH		 979 prog->check_utf8 /* Could be deleted already */
980 && --BmUSEFUL(prog->check_utf8) < 0
981 && (prog->check_utf8 == prog->float_utf8)
982 ) : (
983 prog->check_substr /* Could be deleted already */
984 && --BmUSEFUL(prog->check_substr) < 0
985 && (prog->check_substr == prog->float_substr)
986 )))
66e933ab 987 {
cad2e5aa 988 /* If flags & SOMETHING - do not do it many times on the same match */
a3621e74 989 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
f2ed9b32
KW		 990 /* XXX Does the destruction order has to change with utf8_target? */
991 SvREFCNT_dec(utf8_target ? prog->check_utf8 : prog->check_substr);
992 SvREFCNT_dec(utf8_target ? prog->check_substr : prog->check_utf8);
a0714e2c
SS		 993 prog->check_substr = prog->check_utf8 = NULL; /* disable */
994 prog->float_substr = prog->float_utf8 = NULL; /* clear */
995 check = NULL; /* abort */
cad2e5aa 996 s = strpos;
c9415951
YO		 997 /* XXXX If the check string was an implicit check MBOL, then we need to unset the relevent flag
998 see http://bugs.activestate.com/show_bug.cgi?id=87173 */
999 if (prog->intflags & PREGf_IMPLICIT)
1000 prog->extflags &= ~RXf_ANCH_MBOL;
3cf5c195
IZ		 1001 /* XXXX This is a remnant of the old implementation. It
1002 looks wasteful, since now INTUIT can use many
6eb5f6b9 1003 other heuristics. */
bbe252da 1004 prog->extflags &= ~RXf_USE_INTUIT;
c9415951 1005 /* XXXX What other flags might need to be cleared in this branch? */
cad2e5aa
JH		 1006 }
1007 else
1008 s = strpos;
1009 }
1010
6eb5f6b9
JH		 1011 /* Last resort... */
1012 /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
1de06328
YO		 1013 /* trie stclasses are too expensive to use here, we are better off to
1014 leave it to regmatch itself */
f8fc2ecf 1015 if (progi->regstclass && PL_regkind[OP(progi->regstclass)]!=TRIE) {
6eb5f6b9
JH		 1016 /* minlen == 0 is possible if regstclass is \b or \B,
1017 and the fixed substr is ''$.
1018 Since minlen is already taken into account, s+1 is before strend;
1019 accidentally, minlen >= 1 guaranties no false positives at s + 1
1020 even for \b or \B. But (minlen? 1 : 0) below assumes that
1021 regstclass does not come from lookahead... */
1022 /* If regstclass takes bytelength more than 1: If charlength==1, OK.
1023 This leaves EXACTF only, which is dealt with in find_byclass(). */
f8fc2ecf
YO		 1024 const U8* const str = (U8*)STRING(progi->regstclass);
1025 const int cl_l = (PL_regkind[OP(progi->regstclass)] == EXACT
1026 ? CHR_DIST(str+STR_LEN(progi->regstclass), str)
66e933ab 1027 : 1);
1de06328
YO		 1028 char * endpos;
1029 if (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1030 endpos= HOP3c(s, (prog->minlen ? cl_l : 0), strend);
1031 else if (prog->float_substr || prog->float_utf8)
1032 endpos= HOP3c(HOP3c(check_at, -start_shift, strbeg), cl_l, strend);
1033 else
1034 endpos= strend;
1035
70685ca0
JH		 1036 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" s: %"IVdf" endpos: %"IVdf"\n",
1037 (IV)start_shift, (IV)(check_at - strbeg), (IV)(s - strbeg), (IV)(endpos - strbeg)));
1de06328 1038
6eb5f6b9 1039 t = s;
f8fc2ecf 1040 s = find_byclass(prog, progi->regstclass, s, endpos, NULL);
6eb5f6b9
JH		 1041 if (!s) {
1042#ifdef DEBUGGING
cbbf8932 1043 const char *what = NULL;
6eb5f6b9
JH		 1044#endif
1045 if (endpos == strend) {
a3621e74 1046 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
6eb5f6b9
JH		 1047 "Could not match STCLASS...\n") );
1048 goto fail;
1049 }
a3621e74 1050 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab 1051 "This position contradicts STCLASS...\n") );
bbe252da 1052 if ((prog->extflags & RXf_ANCH) && !ml_anch)
653099ff 1053 goto fail;
6eb5f6b9 1054 /* Contradict one of substrings */
33b8afdf 1055 if (prog->anchored_substr || prog->anchored_utf8) {
f2ed9b32 1056 if ((utf8_target ? prog->anchored_utf8 : prog->anchored_substr) == check) {
a3621e74 1057 DEBUG_EXECUTE_r( what = "anchored" );
6eb5f6b9 1058 hop_and_restart:
1aa99e6b 1059 s = HOP3c(t, 1, strend);
66e933ab
GS		 1060 if (s + start_shift + end_shift > strend) {
1061 /* XXXX Should be taken into account earlier? */
a3621e74 1062 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab
GS		 1063 "Could not match STCLASS...\n") );
1064 goto fail;
1065 }
5e39e1e5
HS		 1066 if (!check)
1067 goto giveup;
a3621e74 1068 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1069 "Looking for %s substr starting at offset %ld...\n",
6eb5f6b9
JH		 1070 what, (long)(s + start_shift - i_strpos)) );
1071 goto restart;
1072 }
66e933ab 1073 /* Have both, check_string is floating */
6eb5f6b9
JH		 1074 if (t + start_shift >= check_at) /* Contradicts floating=check */
1075 goto retry_floating_check;
1076 /* Recheck anchored substring, but not floating... */
9041c2e3 1077 s = check_at;
5e39e1e5
HS		 1078 if (!check)
1079 goto giveup;
a3621e74 1080 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1081 "Looking for anchored substr starting at offset %ld...\n",
6eb5f6b9
JH		 1082 (long)(other_last - i_strpos)) );
1083 goto do_other_anchored;
1084 }
60e71179
GS		 1085 /* Another way we could have checked stclass at the
1086 current position only: */
1087 if (ml_anch) {
1088 s = t = t + 1;
5e39e1e5
HS		 1089 if (!check)
1090 goto giveup;
a3621e74 1091 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1092 "Looking for /%s^%s/m starting at offset %ld...\n",
e4584336 1093 PL_colors[0], PL_colors[1], (long)(t - i_strpos)) );
60e71179 1094 goto try_at_offset;
66e933ab 1095 }
f2ed9b32 1096 if (!(utf8_target ? prog->float_utf8 : prog->float_substr)) /* Could have been deleted */
60e71179 1097 goto fail;
6eb5f6b9
JH		 1098 /* Check is floating subtring. */
1099 retry_floating_check:
1100 t = check_at - start_shift;
a3621e74 1101 DEBUG_EXECUTE_r( what = "floating" );
6eb5f6b9
JH		 1102 goto hop_and_restart;
1103 }
b7953727 1104 if (t != s) {
a3621e74 1105 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
6eb5f6b9 1106 "By STCLASS: moving %ld --> %ld\n",
b7953727
JH		 1107 (long)(t - i_strpos), (long)(s - i_strpos))
1108 );
1109 }
1110 else {
a3621e74 1111 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
b7953727
JH		 1112 "Does not contradict STCLASS...\n");
1113 );
1114 }
6eb5f6b9 1115 }
5e39e1e5 1116 giveup:
a3621e74 1117 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
5e39e1e5
HS		 1118 PL_colors[4], (check ? "Guessed" : "Giving up"),
1119 PL_colors[5], (long)(s - i_strpos)) );
cad2e5aa 1120 return s;
2c2d71f5
JH		 1121
1122 fail_finish: /* Substring not found */
33b8afdf 1123 if (prog->check_substr || prog->check_utf8) /* could be removed already */
f2ed9b32 1124 BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
cad2e5aa 1125 fail:
a3621e74 1126 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
e4584336 1127 PL_colors[4], PL_colors[5]));
bd61b366 1128 return NULL;
cad2e5aa 1129}
9661b544 1130
a0a388a1
YO		 1131#define DECL_TRIE_TYPE(scan) \
1132 const enum { trie_plain, trie_utf8, trie_utf8_fold, trie_latin_utf8_fold } \
1133 trie_type = (scan->flags != EXACT) \
f2ed9b32
KW		 1134 ? (utf8_target ? trie_utf8_fold : (UTF_PATTERN ? trie_latin_utf8_fold : trie_plain)) \
1135 : (utf8_target ? trie_utf8 : trie_plain)
3b0527fe 1136
55eed653
NC		 1137#define REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc, uscan, len, \
1138uvc, charid, foldlen, foldbuf, uniflags) STMT_START { \
4cadc6a9
YO		 1139 switch (trie_type) { \
1140 case trie_utf8_fold: \
1141 if ( foldlen>0 ) { \
0abd0d78 1142 uvc = utf8n_to_uvuni( uscan, UTF8_MAXLEN, &len, uniflags ); \
4cadc6a9
YO		 1143 foldlen -= len; \
1144 uscan += len; \
1145 len=0; \
1146 } else { \
0abd0d78 1147 uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN, &len, uniflags ); \
4cadc6a9
YO		 1148 uvc = to_uni_fold( uvc, foldbuf, &foldlen ); \
1149 foldlen -= UNISKIP( uvc ); \
1150 uscan = foldbuf + UNISKIP( uvc ); \
1151 } \
1152 break; \
a0a388a1
YO		 1153 case trie_latin_utf8_fold: \
1154 if ( foldlen>0 ) { \
1155 uvc = utf8n_to_uvuni( uscan, UTF8_MAXLEN, &len, uniflags ); \
1156 foldlen -= len; \
1157 uscan += len; \
1158 len=0; \
1159 } else { \
1160 len = 1; \
1161 uvc = to_uni_fold( *(U8*)uc, foldbuf, &foldlen ); \
1162 foldlen -= UNISKIP( uvc ); \
1163 uscan = foldbuf + UNISKIP( uvc ); \
1164 } \
1165 break; \
4cadc6a9
YO		 1166 case trie_utf8: \
1167 uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN, &len, uniflags ); \
1168 break; \
1169 case trie_plain: \
1170 uvc = (UV)*uc; \
1171 len = 1; \
1172 } \
4cadc6a9
YO		 1173 if (uvc < 256) { \
1174 charid = trie->charmap[ uvc ]; \
1175 } \
1176 else { \
1177 charid = 0; \
55eed653
NC		 1178 if (widecharmap) { \
1179 SV** const svpp = hv_fetch(widecharmap, \
4cadc6a9
YO		 1180 (char*)&uvc, sizeof(UV), 0); \
1181 if (svpp) \
1182 charid = (U16)SvIV(*svpp); \
1183 } \
1184 } \
1185} STMT_END
1186
a0a388a1
YO		 1187#define REXEC_FBC_EXACTISH_CHECK(CoNd) \
1188{ \
1189 char *my_strend= (char *)strend; \
4cadc6a9
YO		 1190 if ( (CoNd) \
1191 && (ln == len || \
f2ed9b32
KW		 1192 foldEQ_utf8(s, &my_strend, 0, utf8_target, \
1193 m, NULL, ln, cBOOL(UTF_PATTERN))) \
a0a388a1 1194 && (!reginfo || regtry(reginfo, &s)) ) \
4cadc6a9
YO		 1195 goto got_it; \
1196 else { \
1197 U8 foldbuf[UTF8_MAXBYTES_CASE+1]; \
1198 uvchr_to_utf8(tmpbuf, c); \
1199 f = to_utf8_fold(tmpbuf, foldbuf, &foldlen); \
1200 if ( f != c \
1201 && (f == c1 || f == c2) \
a0a388a1 1202 && (ln == len || \
f2ed9b32
KW		 1203 foldEQ_utf8(s, &my_strend, 0, utf8_target,\
1204 m, NULL, ln, cBOOL(UTF_PATTERN)))\
a0a388a1 1205 && (!reginfo || regtry(reginfo, &s)) ) \
4cadc6a9
YO		 1206 goto got_it; \
1207 } \
a0a388a1
YO		 1208} \
1209s += len
4cadc6a9
YO		 1210
1211#define REXEC_FBC_EXACTISH_SCAN(CoNd) \
1212STMT_START { \
1213 while (s <= e) { \
1214 if ( (CoNd) \
4c1b470c
KW		 1215 && (ln == 1 || (OP(c) == EXACTF \
1216 ? foldEQ(s, m, ln) \
1217 : foldEQ_locale(s, m, ln))) \
24b23f37 1218 && (!reginfo || regtry(reginfo, &s)) ) \
4cadc6a9
YO		 1219 goto got_it; \
1220 s++; \
1221 } \
1222} STMT_END
1223
1224#define REXEC_FBC_UTF8_SCAN(CoDe) \
1225STMT_START { \
1226 while (s + (uskip = UTF8SKIP(s)) <= strend) { \
1227 CoDe \
1228 s += uskip; \
1229 } \
1230} STMT_END
1231
1232#define REXEC_FBC_SCAN(CoDe) \
1233STMT_START { \
1234 while (s < strend) { \
1235 CoDe \
1236 s++; \
1237 } \
1238} STMT_END
1239
1240#define REXEC_FBC_UTF8_CLASS_SCAN(CoNd) \
1241REXEC_FBC_UTF8_SCAN( \
1242 if (CoNd) { \
24b23f37 1243 if (tmp && (!reginfo || regtry(reginfo, &s))) \
4cadc6a9
YO		 1244 goto got_it; \
1245 else \
1246 tmp = doevery; \
1247 } \
1248 else \
1249 tmp = 1; \
1250)
1251
1252#define REXEC_FBC_CLASS_SCAN(CoNd) \
1253REXEC_FBC_SCAN( \
1254 if (CoNd) { \
24b23f37 1255 if (tmp && (!reginfo || regtry(reginfo, &s))) \
4cadc6a9
YO		 1256 goto got_it; \
1257 else \
1258 tmp = doevery; \
1259 } \
1260 else \
1261 tmp = 1; \
1262)
1263
1264#define REXEC_FBC_TRYIT \
24b23f37 1265if ((!reginfo || regtry(reginfo, &s))) \
4cadc6a9
YO		 1266 goto got_it
1267
e1d1eefb 1268#define REXEC_FBC_CSCAN(CoNdUtF8,CoNd) \
f2ed9b32 1269 if (utf8_target) { \
e1d1eefb
YO		 1270 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1271 } \
1272 else { \
1273 REXEC_FBC_CLASS_SCAN(CoNd); \
1274 } \
1275 break
1276
4cadc6a9 1277#define REXEC_FBC_CSCAN_PRELOAD(UtFpReLoAd,CoNdUtF8,CoNd) \
f2ed9b32 1278 if (utf8_target) { \
4cadc6a9
YO		 1279 UtFpReLoAd; \
1280 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1281 } \
1282 else { \
1283 REXEC_FBC_CLASS_SCAN(CoNd); \
1284 } \
1285 break
1286
1287#define REXEC_FBC_CSCAN_TAINT(CoNdUtF8,CoNd) \
1288 PL_reg_flags |= RF_tainted; \
f2ed9b32 1289 if (utf8_target) { \
4cadc6a9
YO		 1290 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1291 } \
1292 else { \
1293 REXEC_FBC_CLASS_SCAN(CoNd); \
1294 } \
1295 break
1296
786e8c11
YO		 1297#define DUMP_EXEC_POS(li,s,doutf8) \
1298 dump_exec_pos(li,s,(PL_regeol),(PL_bostr),(PL_reg_starttry),doutf8)
1299
1300/* We know what class REx starts with. Try to find this position... */
1301/* if reginfo is NULL, its a dryrun */
1302/* annoyingly all the vars in this routine have different names from their counterparts
1303 in regmatch. /grrr */
1304
3c3eec57 1305STATIC char *
07be1b83 1306S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
24b23f37 1307 const char *strend, regmatch_info *reginfo)
a687059c 1308{
27da23d5 1309 dVAR;
bbe252da 1310 const I32 doevery = (prog->intflags & PREGf_SKIP) == 0;
6eb5f6b9 1311 char *m;
d8093b23 1312 STRLEN ln;
5dab1207 1313 STRLEN lnc;
078c425b 1314 register STRLEN uskip;
d8093b23
G		 1315 unsigned int c1;
1316 unsigned int c2;
6eb5f6b9
JH		 1317 char *e;
1318 register I32 tmp = 1; /* Scratch variable? */
f2ed9b32 1319 register const bool utf8_target = PL_reg_match_utf8;
f8fc2ecf 1320 RXi_GET_DECL(prog,progi);
7918f24d
NC		 1321
1322 PERL_ARGS_ASSERT_FIND_BYCLASS;
f8fc2ecf 1323
6eb5f6b9
JH		 1324 /* We know what class it must start with. */
1325 switch (OP(c)) {
6eb5f6b9 1326 case ANYOF:
f2ed9b32 1327 if (utf8_target) {
4cadc6a9 1328 REXEC_FBC_UTF8_CLASS_SCAN((ANYOF_FLAGS(c) & ANYOF_UNICODE) ||
388cc4de 1329 !UTF8_IS_INVARIANT((U8)s[0]) ?
f2ed9b32 1330 reginclass(prog, c, (U8*)s, 0, utf8_target) :
4cadc6a9 1331 REGINCLASS(prog, c, (U8*)s));
388cc4de
HS		 1332 }
1333 else {
1334 while (s < strend) {
1335 STRLEN skip = 1;
1336
32fc9b6a 1337 if (REGINCLASS(prog, c, (U8*)s) ||
388cc4de
HS		 1338 (ANYOF_FOLD_SHARP_S(c, s, strend) &&
1339 /* The assignment of 2 is intentional:
1340 * for the folded sharp s, the skip is 2. */
1341 (skip = SHARP_S_SKIP))) {
24b23f37 1342 if (tmp && (!reginfo || regtry(reginfo, &s)))
388cc4de
HS		 1343 goto got_it;
1344 else
1345 tmp = doevery;
1346 }
1347 else
1348 tmp = 1;
1349 s += skip;
1350 }
a0d0e21e 1351 }
6eb5f6b9 1352 break;
f33976b4 1353 case CANY:
4cadc6a9 1354 REXEC_FBC_SCAN(
24b23f37 1355 if (tmp && (!reginfo || regtry(reginfo, &s)))
f33976b4
DB		 1356 goto got_it;
1357 else
1358 tmp = doevery;
4cadc6a9 1359 );
f33976b4 1360 break;
6eb5f6b9 1361 case EXACTF:
5dab1207
NIS		 1362 m = STRING(c);
1363 ln = STR_LEN(c); /* length to match in octets/bytes */
1364 lnc = (I32) ln; /* length to match in characters */
f2ed9b32 1365 if (UTF_PATTERN) {
a2a2844f 1366 STRLEN ulen1, ulen2;
5dab1207 1367 U8 *sm = (U8 *) m;
89ebb4a3
JH		 1368 U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
1369 U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
97dc7d3e
RGS		 1370 /* used by commented-out code below */
1371 /*const U32 uniflags = UTF8_ALLOW_DEFAULT;*/
a0a388a1
YO		 1372
1373 /* XXX: Since the node will be case folded at compile
1374 time this logic is a little odd, although im not
1375 sure that its actually wrong. --dmq */
1376
1377 c1 = to_utf8_lower((U8*)m, tmpbuf1, &ulen1);
1378 c2 = to_utf8_upper((U8*)m, tmpbuf2, &ulen2);
1379
1380 /* XXX: This is kinda strange. to_utf8_XYZ returns the
1381 codepoint of the first character in the converted
1382 form, yet originally we did the extra step.
1383 No tests fail by commenting this code out however
1384 so Ive left it out. -- dmq.
1385
89ebb4a3 1386 c1 = utf8n_to_uvchr(tmpbuf1, UTF8_MAXBYTES_CASE,
041457d9 1387 0, uniflags);
89ebb4a3 1388 c2 = utf8n_to_uvchr(tmpbuf2, UTF8_MAXBYTES_CASE,
041457d9 1389 0, uniflags);
a0a388a1
YO		 1390 */
1391
5dab1207
NIS		 1392 lnc = 0;
1393 while (sm < ((U8 *) m + ln)) {
1394 lnc++;
1395 sm += UTF8SKIP(sm);
1396 }
1aa99e6b
IH		 1397 }
1398 else {
1399 c1 = *(U8*)m;
1400 c2 = PL_fold[c1];
1401 }
6eb5f6b9
JH		 1402 goto do_exactf;
1403 case EXACTFL:
5dab1207
NIS		 1404 m = STRING(c);
1405 ln = STR_LEN(c);
1406 lnc = (I32) ln;
d8093b23 1407 c1 = *(U8*)m;
6eb5f6b9
JH		 1408 c2 = PL_fold_locale[c1];
1409 do_exactf:
db12adc6 1410 e = HOP3c(strend, -((I32)lnc), s);
b3c9acc1 1411
3b0527fe 1412 if (!reginfo && e < s)
6eb5f6b9 1413 e = s; /* Due to minlen logic of intuit() */
1aa99e6b 1414
60a8b682
JH		 1415 /* The idea in the EXACTF* cases is to first find the
1416 * first character of the EXACTF* node and then, if
1417 * necessary, case-insensitively compare the full
1418 * text of the node. The c1 and c2 are the first
1419 * characters (though in Unicode it gets a bit
1420 * more complicated because there are more cases
7f16dd3d
JH		 1421 * than just upper and lower: one needs to use
1422 * the so-called folding case for case-insensitive
1423 * matching (called "loose matching" in Unicode).
4c1b470c 1424 * foldEQ_utf8() will do just that. */
60a8b682 1425
f2ed9b32 1426 if (utf8_target || UTF_PATTERN) {
575cac57 1427 UV c, f;
89ebb4a3 1428 U8 tmpbuf [UTF8_MAXBYTES+1];
a0a388a1
YO		 1429 STRLEN len = 1;
1430 STRLEN foldlen;
4ad0818d 1431 const U32 uniflags = UTF8_ALLOW_DEFAULT;
09091399 1432 if (c1 == c2) {
5dab1207
NIS		 1433 /* Upper and lower of 1st char are equal -
1434 * probably not a "letter". */
1aa99e6b 1435 while (s <= e) {
f2ed9b32 1436 if (utf8_target) {
a0a388a1 1437 c = utf8n_to_uvchr((U8*)s, UTF8_MAXBYTES, &len,
041457d9 1438 uniflags);
a0a388a1
YO		 1439 } else {
1440 c = *((U8*)s);
1441 }
4cadc6a9 1442 REXEC_FBC_EXACTISH_CHECK(c == c1);
1aa99e6b 1443 }
09091399
JH		 1444 }
1445 else {
1aa99e6b 1446 while (s <= e) {
f2ed9b32 1447 if (utf8_target) {
a0a388a1 1448 c = utf8n_to_uvchr((U8*)s, UTF8_MAXBYTES, &len,
041457d9 1449 uniflags);
a0a388a1
YO		 1450 } else {
1451 c = *((U8*)s);
1452 }
80aecb99 1453
60a8b682 1454 /* Handle some of the three Greek sigmas cases.
8c01da3c
JH		 1455 * Note that not all the possible combinations
1456 * are handled here: some of them are handled
1457 * by the standard folding rules, and some of
1458 * them (the character class or ANYOF cases)
1459 * are handled during compiletime in
1460 * regexec.c:S_regclass(). */
880bd946
JH		 1461 if (c == (UV)UNICODE_GREEK_CAPITAL_LETTER_SIGMA ||
1462 c == (UV)UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA)
1463 c = (UV)UNICODE_GREEK_SMALL_LETTER_SIGMA;
80aecb99 1464
4cadc6a9 1465 REXEC_FBC_EXACTISH_CHECK(c == c1 || c == c2);
1aa99e6b 1466 }
09091399 1467 }
1aa99e6b
IH		 1468 }
1469 else {
a0a388a1 1470 /* Neither pattern nor string are UTF8 */
1aa99e6b 1471 if (c1 == c2)
4cadc6a9 1472 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1);
1aa99e6b 1473 else
4cadc6a9 1474 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1 || *(U8*)s == c2);
b3c9acc1
IZ		 1475 }
1476 break;
bbce6d69 1477 case BOUNDL:
3280af22 1478 PL_reg_flags |= RF_tainted;
bbce6d69 1479 /* FALL THROUGH */
a0d0e21e 1480 case BOUND:
f2ed9b32 1481 if (utf8_target) {
12d33761 1482 if (s == PL_bostr)
ffc61ed2
JH		 1483 tmp = '\n';
1484 else {
6136c704 1485 U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);
4ad0818d 1486 tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);
ffc61ed2
JH		 1487 }
1488 tmp = ((OP(c) == BOUND ?
9041c2e3 1489 isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
1a4fad37 1490 LOAD_UTF8_CHARCLASS_ALNUM();
4cadc6a9 1491 REXEC_FBC_UTF8_SCAN(
ffc61ed2 1492 if (tmp == !(OP(c) == BOUND ?
f2ed9b32 1493 cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)) :
ffc61ed2
JH		 1494 isALNUM_LC_utf8((U8*)s)))
1495 {
1496 tmp = !tmp;
4cadc6a9 1497 REXEC_FBC_TRYIT;
a687059c 1498 }
4cadc6a9 1499 );
a0d0e21e 1500 }
667bb95a 1501 else {
12d33761 1502 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';
ffc61ed2 1503 tmp = ((OP(c) == BOUND ? isALNUM(tmp) : isALNUM_LC(tmp)) != 0);
4cadc6a9 1504 REXEC_FBC_SCAN(
ffc61ed2
JH		 1505 if (tmp ==
1506 !(OP(c) == BOUND ? isALNUM(*s) : isALNUM_LC(*s))) {
1507 tmp = !tmp;
4cadc6a9 1508 REXEC_FBC_TRYIT;
a0ed51b3 1509 }
4cadc6a9 1510 );
a0ed51b3 1511 }
24b23f37 1512 if ((!prog->minlen && tmp) && (!reginfo || regtry(reginfo, &s)))
a0ed51b3
LW		 1513 goto got_it;
1514 break;
bbce6d69 1515 case NBOUNDL:
3280af22 1516 PL_reg_flags |= RF_tainted;
bbce6d69 1517 /* FALL THROUGH */
a0d0e21e 1518 case NBOUND:
f2ed9b32 1519 if (utf8_target) {
12d33761 1520 if (s == PL_bostr)
ffc61ed2
JH		 1521 tmp = '\n';
1522 else {
6136c704 1523 U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);
4ad0818d 1524 tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);
ffc61ed2
JH		 1525 }
1526 tmp = ((OP(c) == NBOUND ?
9041c2e3 1527 isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
1a4fad37 1528 LOAD_UTF8_CHARCLASS_ALNUM();
4cadc6a9 1529 REXEC_FBC_UTF8_SCAN(
ffc61ed2 1530 if (tmp == !(OP(c) == NBOUND ?
f2ed9b32 1531 cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)) :
ffc61ed2
JH		 1532 isALNUM_LC_utf8((U8*)s)))
1533 tmp = !tmp;
4cadc6a9
YO		 1534 else REXEC_FBC_TRYIT;
1535 );
a0d0e21e 1536 }
667bb95a 1537 else {
12d33761 1538 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';
ffc61ed2
JH		 1539 tmp = ((OP(c) == NBOUND ?
1540 isALNUM(tmp) : isALNUM_LC(tmp)) != 0);
4cadc6a9 1541 REXEC_FBC_SCAN(
ffc61ed2
JH		 1542 if (tmp ==
1543 !(OP(c) == NBOUND ? isALNUM(*s) : isALNUM_LC(*s)))
1544 tmp = !tmp;
4cadc6a9
YO		 1545 else REXEC_FBC_TRYIT;
1546 );
a0ed51b3 1547 }
24b23f37 1548 if ((!prog->minlen && !tmp) && (!reginfo || regtry(reginfo, &s)))
a0ed51b3
LW		 1549 goto got_it;
1550 break;
a0d0e21e 1551 case ALNUM:
4cadc6a9 1552 REXEC_FBC_CSCAN_PRELOAD(
d1eb3177 1553 LOAD_UTF8_CHARCLASS_PERL_WORD(),
f2ed9b32 1554 swash_fetch(RE_utf8_perl_word, (U8*)s, utf8_target),
4cadc6a9
YO		 1555 isALNUM(*s)
1556 );
bbce6d69 1557 case ALNUML:
4cadc6a9
YO		 1558 REXEC_FBC_CSCAN_TAINT(
1559 isALNUM_LC_utf8((U8*)s),
1560 isALNUM_LC(*s)
1561 );
a0d0e21e 1562 case NALNUM:
4cadc6a9 1563 REXEC_FBC_CSCAN_PRELOAD(
d1eb3177 1564 LOAD_UTF8_CHARCLASS_PERL_WORD(),
f2ed9b32 1565 !swash_fetch(RE_utf8_perl_word, (U8*)s, utf8_target),
4cadc6a9
YO		 1566 !isALNUM(*s)
1567 );
bbce6d69 1568 case NALNUML:
4cadc6a9
YO		 1569 REXEC_FBC_CSCAN_TAINT(
1570 !isALNUM_LC_utf8((U8*)s),
1571 !isALNUM_LC(*s)
1572 );
a0d0e21e 1573 case SPACE:
4cadc6a9 1574 REXEC_FBC_CSCAN_PRELOAD(
d1eb3177 1575 LOAD_UTF8_CHARCLASS_PERL_SPACE(),
f2ed9b32 1576 *s == ' ' || swash_fetch(RE_utf8_perl_space,(U8*)s, utf8_target),
4cadc6a9
YO		 1577 isSPACE(*s)
1578 );
bbce6d69 1579 case SPACEL:
4cadc6a9
YO		 1580 REXEC_FBC_CSCAN_TAINT(
1581 *s == ' ' || isSPACE_LC_utf8((U8*)s),
1582 isSPACE_LC(*s)
1583 );
a0d0e21e 1584 case NSPACE:
4cadc6a9 1585 REXEC_FBC_CSCAN_PRELOAD(
d1eb3177 1586 LOAD_UTF8_CHARCLASS_PERL_SPACE(),
f2ed9b32 1587 !(*s == ' ' || swash_fetch(RE_utf8_perl_space,(U8*)s, utf8_target)),
4cadc6a9
YO		 1588 !isSPACE(*s)
1589 );
bbce6d69 1590 case NSPACEL:
4cadc6a9
YO		 1591 REXEC_FBC_CSCAN_TAINT(
1592 !(*s == ' ' || isSPACE_LC_utf8((U8*)s)),
1593 !isSPACE_LC(*s)
1594 );
a0d0e21e 1595 case DIGIT:
4cadc6a9 1596 REXEC_FBC_CSCAN_PRELOAD(
d1eb3177 1597 LOAD_UTF8_CHARCLASS_POSIX_DIGIT(),
f2ed9b32 1598 swash_fetch(RE_utf8_posix_digit,(U8*)s, utf8_target),
4cadc6a9
YO		 1599 isDIGIT(*s)
1600 );
b8c5462f 1601 case DIGITL:
4cadc6a9
YO		 1602 REXEC_FBC_CSCAN_TAINT(
1603 isDIGIT_LC_utf8((U8*)s),
1604 isDIGIT_LC(*s)
1605 );
a0d0e21e 1606 case NDIGIT:
4cadc6a9 1607 REXEC_FBC_CSCAN_PRELOAD(
d1eb3177 1608 LOAD_UTF8_CHARCLASS_POSIX_DIGIT(),
f2ed9b32 1609 !swash_fetch(RE_utf8_posix_digit,(U8*)s, utf8_target),
4cadc6a9
YO		 1610 !isDIGIT(*s)
1611 );
b8c5462f 1612 case NDIGITL:
4cadc6a9
YO		 1613 REXEC_FBC_CSCAN_TAINT(
1614 !isDIGIT_LC_utf8((U8*)s),
1615 !isDIGIT_LC(*s)
1616 );
e1d1eefb
YO		 1617 case LNBREAK:
1618 REXEC_FBC_CSCAN(
1619 is_LNBREAK_utf8(s),
1620 is_LNBREAK_latin1(s)
1621 );
1622 case VERTWS:
1623 REXEC_FBC_CSCAN(
1624 is_VERTWS_utf8(s),
1625 is_VERTWS_latin1(s)
1626 );
1627 case NVERTWS:
1628 REXEC_FBC_CSCAN(
1629 !is_VERTWS_utf8(s),
1630 !is_VERTWS_latin1(s)
1631 );
1632 case HORIZWS:
1633 REXEC_FBC_CSCAN(
1634 is_HORIZWS_utf8(s),
1635 is_HORIZWS_latin1(s)
1636 );
1637 case NHORIZWS:
1638 REXEC_FBC_CSCAN(
1639 !is_HORIZWS_utf8(s),
1640 !is_HORIZWS_latin1(s)
1641 );
1de06328
YO		 1642 case AHOCORASICKC:
1643 case AHOCORASICK:
07be1b83 1644 {
a0a388a1 1645 DECL_TRIE_TYPE(c);
07be1b83
YO		 1646 /* what trie are we using right now */
1647 reg_ac_data *aho
f8fc2ecf 1648 = (reg_ac_data*)progi->data->data[ ARG( c ) ];
3251b653
NC		 1649 reg_trie_data *trie
1650 = (reg_trie_data*)progi->data->data[ aho->trie ];
85fbaab2 1651 HV *widecharmap = MUTABLE_HV(progi->data->data[ aho->trie + 1 ]);
07be1b83
YO		 1652
1653 const char *last_start = strend - trie->minlen;
6148ee25 1654#ifdef DEBUGGING
07be1b83 1655 const char *real_start = s;
6148ee25 1656#endif
07be1b83 1657 STRLEN maxlen = trie->maxlen;
be8e71aa
YO		 1658 SV *sv_points;
1659 U8 **points; /* map of where we were in the input string
786e8c11 1660 when reading a given char. For ASCII this
be8e71aa 1661 is unnecessary overhead as the relationship
38a44b82
NC		 1662 is always 1:1, but for Unicode, especially
1663 case folded Unicode this is not true. */
f9e705e8 1664 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
786e8c11
YO		 1665 U8 *bitmap=NULL;
1666
07be1b83
YO		 1667
1668 GET_RE_DEBUG_FLAGS_DECL;
1669
be8e71aa
YO		 1670 /* We can't just allocate points here. We need to wrap it in
1671 * an SV so it gets freed properly if there is a croak while
1672 * running the match */
1673 ENTER;
1674 SAVETMPS;
1675 sv_points=newSV(maxlen * sizeof(U8 *));
1676 SvCUR_set(sv_points,
1677 maxlen * sizeof(U8 *));
1678 SvPOK_on(sv_points);
1679 sv_2mortal(sv_points);
1680 points=(U8**)SvPV_nolen(sv_points );
1de06328
YO		 1681 if ( trie_type != trie_utf8_fold
1682 && (trie->bitmap || OP(c)==AHOCORASICKC) )
1683 {
786e8c11
YO		 1684 if (trie->bitmap)
1685 bitmap=(U8*)trie->bitmap;
1686 else
1687 bitmap=(U8*)ANYOF_BITMAP(c);
07be1b83 1688 }
786e8c11
YO		 1689 /* this is the Aho-Corasick algorithm modified a touch
1690 to include special handling for long "unknown char"
1691 sequences. The basic idea being that we use AC as long
1692 as we are dealing with a possible matching char, when
1693 we encounter an unknown char (and we have not encountered
1694 an accepting state) we scan forward until we find a legal
1695 starting char.
1696 AC matching is basically that of trie matching, except
1697 that when we encounter a failing transition, we fall back
1698 to the current states "fail state", and try the current char
1699 again, a process we repeat until we reach the root state,
1700 state 1, or a legal transition. If we fail on the root state
1701 then we can either terminate if we have reached an accepting
1702 state previously, or restart the entire process from the beginning
1703 if we have not.
1704
1705 */
07be1b83
YO		 1706 while (s <= last_start) {
1707 const U32 uniflags = UTF8_ALLOW_DEFAULT;
1708 U8 *uc = (U8*)s;
1709 U16 charid = 0;
1710 U32 base = 1;
1711 U32 state = 1;
1712 UV uvc = 0;
1713 STRLEN len = 0;
1714 STRLEN foldlen = 0;
1715 U8 *uscan = (U8*)NULL;
1716 U8 *leftmost = NULL;
786e8c11
YO		 1717#ifdef DEBUGGING
1718 U32 accepted_word= 0;
1719#endif
07be1b83
YO		 1720 U32 pointpos = 0;
1721
1722 while ( state && uc <= (U8*)strend ) {
1723 int failed=0;
786e8c11
YO		 1724 U32 word = aho->states[ state ].wordnum;
1725
1de06328
YO		 1726 if( state==1 ) {
1727 if ( bitmap ) {
1728 DEBUG_TRIE_EXECUTE_r(
1729 if ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1730 dump_exec_pos( (char *)uc, c, strend, real_start,
f2ed9b32 1731 (char *)uc, utf8_target );
1de06328
YO		 1732 PerlIO_printf( Perl_debug_log,
1733 " Scanning for legal start char...\n");
1734 }
1735 );
1736 while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1737 uc++;
786e8c11 1738 }
1de06328 1739 s= (char *)uc;
786e8c11 1740 }
786e8c11
YO		 1741 if (uc >(U8*)last_start) break;
1742 }
1743
1744 if ( word ) {
2e64971a 1745 U8 *lpos= points[ (pointpos - trie->wordinfo[word].len) % maxlen ];
786e8c11
YO		 1746 if (!leftmost || lpos < leftmost) {
1747 DEBUG_r(accepted_word=word);
07be1b83 1748 leftmost= lpos;
786e8c11 1749 }
07be1b83 1750 if (base==0) break;
786e8c11 1751
07be1b83
YO		 1752 }
1753 points[pointpos++ % maxlen]= uc;
55eed653
NC		 1754 REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc,
1755 uscan, len, uvc, charid, foldlen,
1756 foldbuf, uniflags);
786e8c11
YO		 1757 DEBUG_TRIE_EXECUTE_r({
1758 dump_exec_pos( (char *)uc, c, strend, real_start,
f2ed9b32 1759 s, utf8_target );
07be1b83 1760 PerlIO_printf(Perl_debug_log,
786e8c11
YO		 1761 " Charid:%3u CP:%4"UVxf" ",
1762 charid, uvc);
1763 });
07be1b83
YO		 1764
1765 do {
6148ee25 1766#ifdef DEBUGGING
786e8c11 1767 word = aho->states[ state ].wordnum;
6148ee25 1768#endif
07be1b83
YO		 1769 base = aho->states[ state ].trans.base;
1770
786e8c11
YO		 1771 DEBUG_TRIE_EXECUTE_r({
1772 if (failed)
1773 dump_exec_pos( (char *)uc, c, strend, real_start,
f2ed9b32 1774 s, utf8_target );
07be1b83 1775 PerlIO_printf( Perl_debug_log,
786e8c11
YO		 1776 "%sState: %4"UVxf", word=%"UVxf,
1777 failed ? " Fail transition to " : "",
1778 (UV)state, (UV)word);
1779 });
07be1b83
YO		 1780 if ( base ) {
1781 U32 tmp;
6dd2be57 1782 I32 offset;
07be1b83 1783 if (charid &&
6dd2be57
DM		 1784 ( ((offset = base + charid
1785 - 1 - trie->uniquecharcount)) >= 0)
1786 && ((U32)offset < trie->lasttrans)
1787 && trie->trans[offset].check == state
1788 && (tmp=trie->trans[offset].next))
07be1b83 1789 {
786e8c11
YO		 1790 DEBUG_TRIE_EXECUTE_r(
1791 PerlIO_printf( Perl_debug_log," - legal\n"));
07be1b83
YO		 1792 state = tmp;
1793 break;
1794 }
1795 else {
786e8c11
YO		 1796 DEBUG_TRIE_EXECUTE_r(
1797 PerlIO_printf( Perl_debug_log," - fail\n"));
1798 failed = 1;
1799 state = aho->fail[state];
07be1b83
YO		 1800 }
1801 }
1802 else {
1803 /* we must be accepting here */
786e8c11
YO		 1804 DEBUG_TRIE_EXECUTE_r(
1805 PerlIO_printf( Perl_debug_log," - accepting\n"));
1806 failed = 1;
07be1b83
YO		 1807 break;
1808 }
1809 } while(state);
786e8c11 1810 uc += len;
07be1b83
YO		 1811 if (failed) {
1812 if (leftmost)
1813 break;
786e8c11 1814 if (!state) state = 1;
07be1b83
YO		 1815 }
1816 }
1817 if ( aho->states[ state ].wordnum ) {
2e64971a 1818 U8 *lpos = points[ (pointpos - trie->wordinfo[aho->states[ state ].wordnum].len) % maxlen ];
786e8c11
YO		 1819 if (!leftmost || lpos < leftmost) {
1820 DEBUG_r(accepted_word=aho->states[ state ].wordnum);
07be1b83 1821 leftmost = lpos;
786e8c11 1822 }
07be1b83 1823 }
07be1b83
YO		 1824 if (leftmost) {
1825 s = (char*)leftmost;
786e8c11
YO		 1826 DEBUG_TRIE_EXECUTE_r({
1827 PerlIO_printf(
70685ca0
JH		 1828 Perl_debug_log,"Matches word #%"UVxf" at position %"IVdf". Trying full pattern...\n",
1829 (UV)accepted_word, (IV)(s - real_start)
786e8c11
YO		 1830 );
1831 });
24b23f37 1832 if (!reginfo || regtry(reginfo, &s)) {
be8e71aa
YO		 1833 FREETMPS;
1834 LEAVE;
07be1b83 1835 goto got_it;
be8e71aa 1836 }
07be1b83 1837 s = HOPc(s,1);
786e8c11
YO		 1838 DEBUG_TRIE_EXECUTE_r({
1839 PerlIO_printf( Perl_debug_log,"Pattern failed. Looking for new start point...\n");
1840 });
07be1b83 1841 } else {
786e8c11
YO		 1842 DEBUG_TRIE_EXECUTE_r(
1843 PerlIO_printf( Perl_debug_log,"No match.\n"));
07be1b83
YO		 1844 break;
1845 }
1846 }
be8e71aa
YO		 1847 FREETMPS;
1848 LEAVE;
07be1b83
YO		 1849 }
1850 break;
b3c9acc1 1851 default:
3c3eec57
GS		 1852 Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
1853 break;
d6a28714 1854 }
6eb5f6b9
JH		 1855 return 0;
1856 got_it:
1857 return s;
1858}
1859
fae667d5 1860
6eb5f6b9
JH		 1861/*
1862 - regexec_flags - match a regexp against a string
1863 */
1864I32
288b8c02 1865Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, register char *strend,
6eb5f6b9
JH		 1866 char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
1867/* strend: pointer to null at end of string */
1868/* strbeg: real beginning of string */
1869/* minend: end of match must be >=minend after stringarg. */
58e23c8d
YO		 1870/* data: May be used for some additional optimizations.
1871 Currently its only used, with a U32 cast, for transmitting
1872 the ganch offset when doing a /g match. This will change */
6eb5f6b9
JH		 1873/* nosave: For optimizations. */
1874{
97aff369 1875 dVAR;
288b8c02 1876 struct regexp *const prog = (struct regexp *)SvANY(rx);
24b23f37 1877 /*register*/ char *s;
6eb5f6b9 1878 register regnode *c;
24b23f37 1879 /*register*/ char *startpos = stringarg;
6eb5f6b9
JH		 1880 I32 minlen; /* must match at least this many chars */
1881 I32 dontbother = 0; /* how many characters not to try at end */
6eb5f6b9
JH		 1882 I32 end_shift = 0; /* Same for the end. */ /* CC */
1883 I32 scream_pos = -1; /* Internal iterator of scream. */
ccac19ea 1884 char *scream_olds = NULL;
f2ed9b32 1885 const bool utf8_target = cBOOL(DO_UTF8(sv));
2757e526 1886 I32 multiline;
f8fc2ecf 1887 RXi_GET_DECL(prog,progi);
3b0527fe 1888 regmatch_info reginfo; /* create some info to pass to regtry etc */
e9105d30 1889 regexp_paren_pair *swap = NULL;
a3621e74
YO		 1890 GET_RE_DEBUG_FLAGS_DECL;
1891
7918f24d 1892 PERL_ARGS_ASSERT_REGEXEC_FLAGS;
9d4ba2ae 1893 PERL_UNUSED_ARG(data);
6eb5f6b9
JH		 1894
1895 /* Be paranoid... */
1896 if (prog == NULL || startpos == NULL) {
1897 Perl_croak(aTHX_ "NULL regexp parameter");
1898 return 0;
1899 }
1900
bbe252da 1901 multiline = prog->extflags & RXf_PMf_MULTILINE;
288b8c02 1902 reginfo.prog = rx; /* Yes, sorry that this is confusing. */
2757e526 1903
f2ed9b32 1904 RX_MATCH_UTF8_set(rx, utf8_target);
1de06328 1905 DEBUG_EXECUTE_r(
f2ed9b32 1906 debug_start_match(rx, utf8_target, startpos, strend,
1de06328
YO		 1907 "Matching");
1908 );
bac06658 1909
6eb5f6b9 1910 minlen = prog->minlen;
1de06328
YO		 1911
1912 if (strend - startpos < (minlen+(prog->check_offset_min<0?prog->check_offset_min:0))) {
a3621e74 1913 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584
JH		 1914 "String too short [regexec_flags]...\n"));
1915 goto phooey;
1aa99e6b 1916 }
6eb5f6b9 1917
1de06328 1918
6eb5f6b9 1919 /* Check validity of program. */
f8fc2ecf 1920 if (UCHARAT(progi->program) != REG_MAGIC) {
6eb5f6b9
JH		 1921 Perl_croak(aTHX_ "corrupted regexp program");
1922 }
1923
1924 PL_reg_flags = 0;
1925 PL_reg_eval_set = 0;
1926 PL_reg_maxiter = 0;
1927
3c8556c3 1928 if (RX_UTF8(rx))
6eb5f6b9
JH		 1929 PL_reg_flags |= RF_utf8;
1930
1931 /* Mark beginning of line for ^ and lookbehind. */
3b0527fe 1932 reginfo.bol = startpos; /* XXX not used ??? */
6eb5f6b9 1933 PL_bostr = strbeg;
3b0527fe 1934 reginfo.sv = sv;
6eb5f6b9
JH		 1935
1936 /* Mark end of line for $ (and such) */
1937 PL_regeol = strend;
1938
1939 /* see how far we have to get to not match where we matched before */
3b0527fe 1940 reginfo.till = startpos+minend;
6eb5f6b9 1941
6eb5f6b9
JH		 1942 /* If there is a "must appear" string, look for it. */
1943 s = startpos;
1944
bbe252da 1945 if (prog->extflags & RXf_GPOS_SEEN) { /* Need to set reginfo->ganch */
6eb5f6b9 1946 MAGIC *mg;
2c296965 1947 if (flags & REXEC_IGNOREPOS){ /* Means: check only at start */
58e23c8d 1948 reginfo.ganch = startpos + prog->gofs;
2c296965 1949 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 1950 "GPOS IGNOREPOS: reginfo.ganch = startpos + %"UVxf"\n",(UV)prog->gofs));
2c296965 1951 } else if (sv && SvTYPE(sv) >= SVt_PVMG
6eb5f6b9 1952 && SvMAGIC(sv)
14befaf4
DM		 1953 && (mg = mg_find(sv, PERL_MAGIC_regex_global))
1954 && mg->mg_len >= 0) {
3b0527fe 1955 reginfo.ganch = strbeg + mg->mg_len; /* Defined pos() */
2c296965 1956 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 1957 "GPOS MAGIC: reginfo.ganch = strbeg + %"IVdf"\n",(IV)mg->mg_len));
2c296965 1958
bbe252da 1959 if (prog->extflags & RXf_ANCH_GPOS) {
3b0527fe 1960 if (s > reginfo.ganch)
6eb5f6b9 1961 goto phooey;
58e23c8d 1962 s = reginfo.ganch - prog->gofs;
2c296965 1963 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 1964 "GPOS ANCH_GPOS: s = ganch - %"UVxf"\n",(UV)prog->gofs));
c584a96e
YO		 1965 if (s < strbeg)
1966 goto phooey;
6eb5f6b9
JH		 1967 }
1968 }
58e23c8d 1969 else if (data) {
70685ca0 1970 reginfo.ganch = strbeg + PTR2UV(data);
2c296965
YO		 1971 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
1972 "GPOS DATA: reginfo.ganch= strbeg + %"UVxf"\n",PTR2UV(data)));
1973
1974 } else { /* pos() not defined */
3b0527fe 1975 reginfo.ganch = strbeg;
2c296965
YO		 1976 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
1977 "GPOS: reginfo.ganch = strbeg\n"));
1978 }
6eb5f6b9 1979 }
288b8c02 1980 if (PL_curpm && (PM_GETRE(PL_curpm) == rx)) {
e9105d30
GG		 1981 /* We have to be careful. If the previous successful match
1982 was from this regex we don't want a subsequent partially
1983 successful match to clobber the old results.
1984 So when we detect this possibility we add a swap buffer
1985 to the re, and switch the buffer each match. If we fail
1986 we switch it back, otherwise we leave it swapped.
1987 */
1988 swap = prog->offs;
1989 /* do we need a save destructor here for eval dies? */
1990 Newxz(prog->offs, (prog->nparens + 1), regexp_paren_pair);
c74340f9 1991 }
a0714e2c 1992 if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
6eb5f6b9
JH		 1993 re_scream_pos_data d;
1994
1995 d.scream_olds = &scream_olds;
1996 d.scream_pos = &scream_pos;
288b8c02 1997 s = re_intuit_start(rx, sv, s, strend, flags, &d);
3fa9c3d7 1998 if (!s) {
a3621e74 1999 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
6eb5f6b9 2000 goto phooey; /* not present */
3fa9c3d7 2001 }
6eb5f6b9
JH		 2002 }
2003
1de06328 2004
6eb5f6b9
JH		 2005
2006 /* Simplest case: anchored match need be tried only once. */
2007 /* [unless only anchor is BOL and multiline is set] */
bbe252da 2008 if (prog->extflags & (RXf_ANCH & ~RXf_ANCH_GPOS)) {
24b23f37 2009 if (s == startpos && regtry(&reginfo, &startpos))
6eb5f6b9 2010 goto got_it;
bbe252da
YO		 2011 else if (multiline || (prog->intflags & PREGf_IMPLICIT)
2012 || (prog->extflags & RXf_ANCH_MBOL)) /* XXXX SBOL? */
6eb5f6b9
JH		 2013 {
2014 char *end;
2015
2016 if (minlen)
2017 dontbother = minlen - 1;
1aa99e6b 2018 end = HOP3c(strend, -dontbother, strbeg) - 1;
6eb5f6b9 2019 /* for multiline we only have to try after newlines */
33b8afdf 2020 if (prog->check_substr || prog->check_utf8) {
6eb5f6b9
JH		 2021 if (s == startpos)
2022 goto after_try;
2023 while (1) {
24b23f37 2024 if (regtry(&reginfo, &s))
6eb5f6b9
JH		 2025 goto got_it;
2026 after_try:
5339e136 2027 if (s > end)
6eb5f6b9 2028 goto phooey;
bbe252da 2029 if (prog->extflags & RXf_USE_INTUIT) {
288b8c02 2030 s = re_intuit_start(rx, sv, s + 1, strend, flags, NULL);
6eb5f6b9
JH		 2031 if (!s)
2032 goto phooey;
2033 }
2034 else
2035 s++;
2036 }
2037 } else {
2038 if (s > startpos)
2039 s--;
2040 while (s < end) {
2041 if (*s++ == '\n') { /* don't need PL_utf8skip here */
24b23f37 2042 if (regtry(&reginfo, &s))
6eb5f6b9
JH		 2043 goto got_it;
2044 }
2045 }
2046 }
2047 }
2048 goto phooey;
bbe252da 2049 } else if (RXf_GPOS_CHECK == (prog->extflags & RXf_GPOS_CHECK))
f9f4320a
YO		 2050 {
2051 /* the warning about reginfo.ganch being used without intialization
bbe252da 2052 is bogus -- we set it above, when prog->extflags & RXf_GPOS_SEEN
f9f4320a 2053 and we only enter this block when the same bit is set. */
58e23c8d 2054 char *tmp_s = reginfo.ganch - prog->gofs;
c584a96e
YO		 2055
2056 if (tmp_s >= strbeg && regtry(&reginfo, &tmp_s))
6eb5f6b9
JH		 2057 goto got_it;
2058 goto phooey;
2059 }
2060
2061 /* Messy cases: unanchored match. */
bbe252da 2062 if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
6eb5f6b9 2063 /* we have /x+whatever/ */
f2ed9b32 2064 /* it must be a one character string (XXXX Except UTF_PATTERN?) */
33b8afdf 2065 char ch;
bf93d4cc
GS		 2066#ifdef DEBUGGING
2067 int did_match = 0;
2068#endif
f2ed9b32
KW		 2069 if (!(utf8_target ? prog->anchored_utf8 : prog->anchored_substr))
2070 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2071 ch = SvPVX_const(utf8_target ? prog->anchored_utf8 : prog->anchored_substr)[0];
bf93d4cc 2072
f2ed9b32 2073 if (utf8_target) {
4cadc6a9 2074 REXEC_FBC_SCAN(
6eb5f6b9 2075 if (*s == ch) {
a3621e74 2076 DEBUG_EXECUTE_r( did_match = 1 );
24b23f37 2077 if (regtry(&reginfo, &s)) goto got_it;
6eb5f6b9
JH		 2078 s += UTF8SKIP(s);
2079 while (s < strend && *s == ch)
2080 s += UTF8SKIP(s);
2081 }
4cadc6a9 2082 );
6eb5f6b9
JH		 2083 }
2084 else {
4cadc6a9 2085 REXEC_FBC_SCAN(
6eb5f6b9 2086 if (*s == ch) {
a3621e74 2087 DEBUG_EXECUTE_r( did_match = 1 );
24b23f37 2088 if (regtry(&reginfo, &s)) goto got_it;
6eb5f6b9
JH		 2089 s++;
2090 while (s < strend && *s == ch)
2091 s++;
2092 }
4cadc6a9 2093 );
6eb5f6b9 2094 }
a3621e74 2095 DEBUG_EXECUTE_r(if (!did_match)
bf93d4cc 2096 PerlIO_printf(Perl_debug_log,
b7953727
JH		 2097 "Did not find anchored character...\n")
2098 );
6eb5f6b9 2099 }
a0714e2c
SS		 2100 else if (prog->anchored_substr != NULL
2101 || prog->anchored_utf8 != NULL
2102 || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
33b8afdf
JH		 2103 && prog->float_max_offset < strend - s)) {
2104 SV *must;
2105 I32 back_max;
2106 I32 back_min;
2107 char *last;
6eb5f6b9 2108 char *last1; /* Last position checked before */
bf93d4cc
GS		 2109#ifdef DEBUGGING
2110 int did_match = 0;
2111#endif
33b8afdf 2112 if (prog->anchored_substr || prog->anchored_utf8) {
f2ed9b32
KW		 2113 if (!(utf8_target ? prog->anchored_utf8 : prog->anchored_substr))
2114 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2115 must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
33b8afdf
JH		 2116 back_max = back_min = prog->anchored_offset;
2117 } else {
f2ed9b32
KW		 2118 if (!(utf8_target ? prog->float_utf8 : prog->float_substr))
2119 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2120 must = utf8_target ? prog->float_utf8 : prog->float_substr;
33b8afdf
JH		 2121 back_max = prog->float_max_offset;
2122 back_min = prog->float_min_offset;
2123 }
1de06328
YO		 2124
2125
33b8afdf
JH		 2126 if (must == &PL_sv_undef)
2127 /* could not downgrade utf8 check substring, so must fail */
2128 goto phooey;
2129
1de06328
YO		 2130 if (back_min<0) {
2131 last = strend;
2132 } else {
2133 last = HOP3c(strend, /* Cannot start after this */
2134 -(I32)(CHR_SVLEN(must)
2135 - (SvTAIL(must) != 0) + back_min), strbeg);
2136 }
6eb5f6b9
JH		 2137 if (s > PL_bostr)
2138 last1 = HOPc(s, -1);
2139 else
2140 last1 = s - 1; /* bogus */
2141
a0288114 2142 /* XXXX check_substr already used to find "s", can optimize if
6eb5f6b9
JH		 2143 check_substr==must. */
2144 scream_pos = -1;
2145 dontbother = end_shift;
2146 strend = HOPc(strend, -dontbother);
2147 while ( (s <= last) &&
9041c2e3 2148 ((flags & REXEC_SCREAM)
1de06328 2149 ? (s = screaminstr(sv, must, HOP3c(s, back_min, (back_min<0 ? strbeg : strend)) - strbeg,
6eb5f6b9 2150 end_shift, &scream_pos, 0))
1de06328 2151 : (s = fbm_instr((unsigned char*)HOP3(s, back_min, (back_min<0 ? strbeg : strend)),
9041c2e3 2152 (unsigned char*)strend, must,
7fba1cd6 2153 multiline ? FBMrf_MULTILINE : 0))) ) {
4addbd3b 2154 /* we may be pointing at the wrong string */
07bc277f 2155 if ((flags & REXEC_SCREAM) && RXp_MATCH_COPIED(prog))
3f7c398e 2156 s = strbeg + (s - SvPVX_const(sv));
a3621e74 2157 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH		 2158 if (HOPc(s, -back_max) > last1) {
2159 last1 = HOPc(s, -back_min);
2160 s = HOPc(s, -back_max);
2161 }
2162 else {
52657f30 2163 char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
6eb5f6b9
JH		 2164
2165 last1 = HOPc(s, -back_min);
52657f30 2166 s = t;
6eb5f6b9 2167 }
f2ed9b32 2168 if (utf8_target) {
6eb5f6b9 2169 while (s <= last1) {
24b23f37 2170 if (regtry(&reginfo, &s))
6eb5f6b9
JH		 2171 goto got_it;
2172 s += UTF8SKIP(s);
2173 }
2174 }
2175 else {
2176 while (s <= last1) {
24b23f37 2177 if (regtry(&reginfo, &s))
6eb5f6b9
JH		 2178 goto got_it;
2179 s++;
2180 }
2181 }
2182 }
ab3bbdeb 2183 DEBUG_EXECUTE_r(if (!did_match) {
f2ed9b32 2184 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO		 2185 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
2186 PerlIO_printf(Perl_debug_log, "Did not find %s substr %s%s...\n",
33b8afdf 2187 ((must == prog->anchored_substr || must == prog->anchored_utf8)
bf93d4cc 2188 ? "anchored" : "floating"),
ab3bbdeb
YO		 2189 quoted, RE_SV_TAIL(must));
2190 });
6eb5f6b9
JH		 2191 goto phooey;
2192 }
f8fc2ecf 2193 else if ( (c = progi->regstclass) ) {
f14c76ed 2194 if (minlen) {
f8fc2ecf 2195 const OPCODE op = OP(progi->regstclass);
66e933ab 2196 /* don't bother with what can't match */
786e8c11 2197 if (PL_regkind[op] != EXACT && op != CANY && PL_regkind[op] != TRIE)
f14c76ed
RGS		 2198 strend = HOPc(strend, -(minlen - 1));
2199 }
a3621e74 2200 DEBUG_EXECUTE_r({
be8e71aa 2201 SV * const prop = sv_newmortal();
32fc9b6a 2202 regprop(prog, prop, c);
0df25f3d 2203 {
f2ed9b32 2204 RE_PV_QUOTED_DECL(quoted,utf8_target,PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb 2205 s,strend-s,60);
0df25f3d 2206 PerlIO_printf(Perl_debug_log,
1c8f8eb1 2207 "Matching stclass %.*s against %s (%d bytes)\n",
e4f74956 2208 (int)SvCUR(prop), SvPVX_const(prop),
ab3bbdeb 2209 quoted, (int)(strend - s));
0df25f3d 2210 }
ffc61ed2 2211 });
3b0527fe 2212 if (find_byclass(prog, c, s, strend, &reginfo))
6eb5f6b9 2213 goto got_it;
07be1b83 2214 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass... [regexec_flags]\n"));
d6a28714
JH		 2215 }
2216 else {
2217 dontbother = 0;
a0714e2c 2218 if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
33b8afdf 2219 /* Trim the end. */
d6a28714 2220 char *last;
33b8afdf
JH		 2221 SV* float_real;
2222
f2ed9b32
KW		 2223 if (!(utf8_target ? prog->float_utf8 : prog->float_substr))
2224 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2225 float_real = utf8_target ? prog->float_utf8 : prog->float_substr;
d6a28714
JH		 2226
2227 if (flags & REXEC_SCREAM) {
33b8afdf 2228 last = screaminstr(sv, float_real, s - strbeg,
d6a28714
JH		 2229 end_shift, &scream_pos, 1); /* last one */
2230 if (!last)
ffc61ed2 2231 last = scream_olds; /* Only one occurrence. */
4addbd3b 2232 /* we may be pointing at the wrong string */
07bc277f 2233 else if (RXp_MATCH_COPIED(prog))
3f7c398e 2234 s = strbeg + (s - SvPVX_const(sv));
b8c5462f 2235 }
d6a28714
JH		 2236 else {
2237 STRLEN len;
cfd0369c 2238 const char * const little = SvPV_const(float_real, len);
d6a28714 2239
33b8afdf 2240 if (SvTAIL(float_real)) {
d6a28714
JH		 2241 if (memEQ(strend - len + 1, little, len - 1))
2242 last = strend - len + 1;
7fba1cd6 2243 else if (!multiline)
9041c2e3 2244 last = memEQ(strend - len, little, len)
bd61b366 2245 ? strend - len : NULL;
b8c5462f 2246 else
d6a28714
JH		 2247 goto find_last;
2248 } else {
2249 find_last:
9041c2e3 2250 if (len)
d6a28714 2251 last = rninstr(s, strend, little, little + len);
b8c5462f 2252 else
a0288114 2253 last = strend; /* matching "$" */
b8c5462f 2254 }
b8c5462f 2255 }
bf93d4cc 2256 if (last == NULL) {
6bda09f9
YO		 2257 DEBUG_EXECUTE_r(
2258 PerlIO_printf(Perl_debug_log,
2259 "%sCan't trim the tail, match fails (should not happen)%s\n",
2260 PL_colors[4], PL_colors[5]));
bf93d4cc
GS		 2261 goto phooey; /* Should not happen! */
2262 }
d6a28714
JH		 2263 dontbother = strend - last + prog->float_min_offset;
2264 }
2265 if (minlen && (dontbother < minlen))
2266 dontbother = minlen - 1;
2267 strend -= dontbother; /* this one's always in bytes! */
2268 /* We don't know much -- general case. */
f2ed9b32 2269 if (utf8_target) {
d6a28714 2270 for (;;) {
24b23f37 2271 if (regtry(&reginfo, &s))
d6a28714
JH		 2272 goto got_it;
2273 if (s >= strend)
2274 break;
b8c5462f 2275 s += UTF8SKIP(s);
d6a28714
JH		 2276 };
2277 }
2278 else {
2279 do {
24b23f37 2280 if (regtry(&reginfo, &s))
d6a28714
JH		 2281 goto got_it;
2282 } while (s++ < strend);
2283 }
2284 }
2285
2286 /* Failure. */
2287 goto phooey;
2288
2289got_it:
e9105d30 2290 Safefree(swap);
288b8c02 2291 RX_MATCH_TAINTED_set(rx, PL_reg_flags & RF_tainted);
d6a28714 2292
19b95bf0 2293 if (PL_reg_eval_set)
4f639d21 2294 restore_pos(aTHX_ prog);
5daac39c
NC		 2295 if (RXp_PAREN_NAMES(prog))
2296 (void)hv_iterinit(RXp_PAREN_NAMES(prog));
d6a28714
JH		 2297
2298 /* make sure $`, $&, $', and $digit will work later */
2299 if ( !(flags & REXEC_NOT_FIRST) ) {
288b8c02 2300 RX_MATCH_COPY_FREE(rx);
d6a28714 2301 if (flags & REXEC_COPY_STR) {
be8e71aa 2302 const I32 i = PL_regeol - startpos + (stringarg - strbeg);
f8c7b90f 2303#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC		 2304 if ((SvIsCOW(sv)
2305 || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS)) {
2306 if (DEBUG_C_TEST) {
2307 PerlIO_printf(Perl_debug_log,
2308 "Copy on write: regexp capture, type %d\n",
2309 (int) SvTYPE(sv));
2310 }
2311 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
d5263905 2312 prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
ed252734
NC		 2313 assert (SvPOKp(prog->saved_copy));
2314 } else
2315#endif
2316 {
288b8c02 2317 RX_MATCH_COPIED_on(rx);
ed252734
NC		 2318 s = savepvn(strbeg, i);
2319 prog->subbeg = s;
2320 }
d6a28714 2321 prog->sublen = i;
d6a28714
JH		 2322 }
2323 else {
2324 prog->subbeg = strbeg;
2325 prog->sublen = PL_regeol - strbeg; /* strend may have been modified */
2326 }
2327 }
9041c2e3 2328
d6a28714
JH		 2329 return 1;
2330
2331phooey:
a3621e74 2332 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
e4584336 2333 PL_colors[4], PL_colors[5]));
d6a28714 2334 if (PL_reg_eval_set)
4f639d21 2335 restore_pos(aTHX_ prog);
e9105d30 2336 if (swap) {
c74340f9 2337 /* we failed :-( roll it back */
e9105d30
GG		 2338 Safefree(prog->offs);
2339 prog->offs = swap;
2340 }
2341
d6a28714
JH		 2342 return 0;
2343}
2344
6bda09f9 2345
d6a28714
JH		 2346/*
2347 - regtry - try match at specific point
2348 */
2349STATIC I32 /* 0 failure, 1 success */
24b23f37 2350S_regtry(pTHX_ regmatch_info *reginfo, char **startpos)
d6a28714 2351{
97aff369 2352 dVAR;
d6a28714 2353 CHECKPOINT lastcp;
288b8c02
NC		 2354 REGEXP *const rx = reginfo->prog;
2355 regexp *const prog = (struct regexp *)SvANY(rx);
f8fc2ecf 2356 RXi_GET_DECL(prog,progi);
a3621e74 2357 GET_RE_DEBUG_FLAGS_DECL;
7918f24d
NC		 2358
2359 PERL_ARGS_ASSERT_REGTRY;
2360
24b23f37 2361 reginfo->cutpoint=NULL;
d6a28714 2362
bbe252da 2363 if ((prog->extflags & RXf_EVAL_SEEN) && !PL_reg_eval_set) {
d6a28714
JH		 2364 MAGIC *mg;
2365
2366 PL_reg_eval_set = RS_init;
a3621e74 2367 DEBUG_EXECUTE_r(DEBUG_s(
b900a521
JH		 2368 PerlIO_printf(Perl_debug_log, " setting stack tmpbase at %"IVdf"\n",
2369 (IV)(PL_stack_sp - PL_stack_base));
d6a28714 2370 ));
ea8d6ae1 2371 SAVESTACK_CXPOS();
d6a28714
JH		 2372 cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
2373 /* Otherwise OP_NEXTSTATE will free whatever on stack now. */
2374 SAVETMPS;
2375 /* Apparently this is not needed, judging by wantarray. */
e8347627 2376 /* SAVEI8(cxstack[cxstack_ix].blk_gimme);
d6a28714
JH		 2377 cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
2378
3b0527fe 2379 if (reginfo->sv) {
d6a28714 2380 /* Make $_ available to executed code. */
3b0527fe 2381 if (reginfo->sv != DEFSV) {
59f00321 2382 SAVE_DEFSV;
414bf5ae 2383 DEFSV_set(reginfo->sv);
b8c5462f 2384 }
d6a28714 2385
3b0527fe
DM		 2386 if (!(SvTYPE(reginfo->sv) >= SVt_PVMG && SvMAGIC(reginfo->sv)
2387 && (mg = mg_find(reginfo->sv, PERL_MAGIC_regex_global)))) {
d6a28714 2388 /* prepare for quick setting of pos */
d300d9fa 2389#ifdef PERL_OLD_COPY_ON_WRITE
51a9ea20
NC		 2390 if (SvIsCOW(reginfo->sv))
2391 sv_force_normal_flags(reginfo->sv, 0);
d300d9fa 2392#endif
3dab1dad 2393 mg = sv_magicext(reginfo->sv, NULL, PERL_MAGIC_regex_global,
d300d9fa 2394 &PL_vtbl_mglob, NULL, 0);
d6a28714 2395 mg->mg_len = -1;
b8c5462f 2396 }
d6a28714
JH		 2397 PL_reg_magic = mg;
2398 PL_reg_oldpos = mg->mg_len;
4f639d21 2399 SAVEDESTRUCTOR_X(restore_pos, prog);
d6a28714 2400 }
09687e5a 2401 if (!PL_reg_curpm) {
a02a5408 2402 Newxz(PL_reg_curpm, 1, PMOP);
09687e5a
AB		 2403#ifdef USE_ITHREADS
2404 {
14a49a24 2405 SV* const repointer = &PL_sv_undef;
92313705
NC		 2406 /* this regexp is also owned by the new PL_reg_curpm, which
2407 will try to free it. */
d2ece331 2408 av_push(PL_regex_padav, repointer);
09687e5a
AB		 2409 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
2410 PL_regex_pad = AvARRAY(PL_regex_padav);
2411 }
2412#endif
2413 }
86c29d75
NC		 2414#ifdef USE_ITHREADS
2415 /* It seems that non-ithreads works both with and without this code.
2416 So for efficiency reasons it seems best not to have the code
2417 compiled when it is not needed. */
92313705
NC		 2418 /* This is safe against NULLs: */
2419 ReREFCNT_dec(PM_GETRE(PL_reg_curpm));
2420 /* PM_reg_curpm owns a reference to this regexp. */
2421 ReREFCNT_inc(rx);
86c29d75 2422#endif
288b8c02 2423 PM_SETRE(PL_reg_curpm, rx);
d6a28714
JH		 2424 PL_reg_oldcurpm = PL_curpm;
2425 PL_curpm = PL_reg_curpm;
07bc277f 2426 if (RXp_MATCH_COPIED(prog)) {
d6a28714
JH		 2427 /* Here is a serious problem: we cannot rewrite subbeg,
2428 since it may be needed if this match fails. Thus
2429 $` inside (?{}) could fail... */
2430 PL_reg_oldsaved = prog->subbeg;
2431 PL_reg_oldsavedlen = prog->sublen;
f8c7b90f 2432#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC		 2433 PL_nrs = prog->saved_copy;
2434#endif
07bc277f 2435 RXp_MATCH_COPIED_off(prog);
d6a28714
JH		 2436 }
2437 else
bd61b366 2438 PL_reg_oldsaved = NULL;
d6a28714
JH		 2439 prog->subbeg = PL_bostr;
2440 prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2441 }
24b23f37 2442 DEBUG_EXECUTE_r(PL_reg_starttry = *startpos);
f0ab9afb 2443 prog->offs[0].start = *startpos - PL_bostr;
24b23f37 2444 PL_reginput = *startpos;
d6a28714 2445 PL_reglastparen = &prog->lastparen;
a01268b5 2446 PL_reglastcloseparen = &prog->lastcloseparen;
d6a28714 2447 prog->lastparen = 0;
03994de8 2448 prog->lastcloseparen = 0;
d6a28714 2449 PL_regsize = 0;
f0ab9afb 2450 PL_regoffs = prog->offs;
d6a28714
JH		 2451 if (PL_reg_start_tmpl <= prog->nparens) {
2452 PL_reg_start_tmpl = prog->nparens*3/2 + 3;
2453 if(PL_reg_start_tmp)
2454 Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2455 else
a02a5408 2456 Newx(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
d6a28714
JH		 2457 }
2458
2459 /* XXXX What this code is doing here?!!! There should be no need
2460 to do this again and again, PL_reglastparen should take care of
3dd2943c 2461 this! --ilya*/
dafc8851
JH		 2462
2463 /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2464 * Actually, the code in regcppop() (which Ilya may be meaning by
daf18116 2465 * PL_reglastparen), is not needed at all by the test suite
225593e1
DM		 2466 * (op/regexp, op/pat, op/split), but that code is needed otherwise
2467 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
2468 * Meanwhile, this code *is* needed for the
daf18116
JH		 2469 * above-mentioned test suite tests to succeed. The common theme
2470 * on those tests seems to be returning null fields from matches.
225593e1 2471 * --jhi updated by dapm */
dafc8851 2472#if 1
d6a28714 2473 if (prog->nparens) {
f0ab9afb 2474 regexp_paren_pair *pp = PL_regoffs;
097eb12c 2475 register I32 i;
eb160463 2476 for (i = prog->nparens; i > (I32)*PL_reglastparen; i--) {
f0ab9afb
NC		 2477 ++pp;
2478 pp->start = -1;
2479 pp->end = -1;
d6a28714
JH		 2480 }
2481 }
dafc8851 2482#endif
02db2b7b 2483 REGCP_SET(lastcp);
f8fc2ecf 2484 if (regmatch(reginfo, progi->program + 1)) {
f0ab9afb 2485 PL_regoffs[0].end = PL_reginput - PL_bostr;
d6a28714
JH		 2486 return 1;
2487 }
24b23f37
YO		 2488 if (reginfo->cutpoint)
2489 *startpos= reginfo->cutpoint;
02db2b7b 2490 REGCP_UNWIND(lastcp);
d6a28714
JH		 2491 return 0;
2492}
2493
02db2b7b 2494
8ba1375e
MJD		 2495#define sayYES goto yes
2496#define sayNO goto no
262b90c4 2497#define sayNO_SILENT goto no_silent
8ba1375e 2498
f9f4320a
YO		 2499/* we dont use STMT_START/END here because it leads to
2500 "unreachable code" warnings, which are bogus, but distracting. */
2501#define CACHEsayNO \
c476f425
DM		 2502 if (ST.cache_mask) \
2503 PL_reg_poscache[ST.cache_offset] |= ST.cache_mask; \
f9f4320a 2504 sayNO
3298f257 2505
a3621e74 2506/* this is used to determine how far from the left messages like
265c4333
YO		 2507 'failed...' are printed. It should be set such that messages
2508 are inline with the regop output that created them.
a3621e74 2509*/
265c4333 2510#define REPORT_CODE_OFF 32
a3621e74
YO		 2511
2512
40a82448
DM		 2513#define CHRTEST_UNINIT -1001 /* c1/c2 haven't been calculated yet */
2514#define CHRTEST_VOID -1000 /* the c1/c2 "next char" test should be skipped */
9e137952 2515
86545054
DM		 2516#define SLAB_FIRST(s) (&(s)->states[0])
2517#define SLAB_LAST(s) (&(s)->states[PERL_REGMATCH_SLAB_SLOTS-1])
2518
5d9a96ca
DM		 2519/* grab a new slab and return the first slot in it */
2520
2521STATIC regmatch_state *
2522S_push_slab(pTHX)
2523{
a35a87e7 2524#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC		 2525 dMY_CXT;
2526#endif
5d9a96ca
DM		 2527 regmatch_slab *s = PL_regmatch_slab->next;
2528 if (!s) {
2529 Newx(s, 1, regmatch_slab);
2530 s->prev = PL_regmatch_slab;
2531 s->next = NULL;
2532 PL_regmatch_slab->next = s;
2533 }
2534 PL_regmatch_slab = s;
86545054 2535 return SLAB_FIRST(s);
5d9a96ca 2536}
5b47454d 2537
95b24440 2538
40a82448
DM		 2539/* push a new state then goto it */
2540
2541#define PUSH_STATE_GOTO(state, node) \
2542 scan = node; \
2543 st->resume_state = state; \
2544 goto push_state;
2545
2546/* push a new state with success backtracking, then goto it */
2547
2548#define PUSH_YES_STATE_GOTO(state, node) \
2549 scan = node; \
2550 st->resume_state = state; \
2551 goto push_yes_state;
2552
aa283a38 2553
aa283a38 2554
d6a28714 2555/*
95b24440 2556
bf1f174e
DM		 2557regmatch() - main matching routine
2558
2559This is basically one big switch statement in a loop. We execute an op,
2560set 'next' to point the next op, and continue. If we come to a point which
2561we may need to backtrack to on failure such as (A|B|C), we push a
2562backtrack state onto the backtrack stack. On failure, we pop the top
2563state, and re-enter the loop at the state indicated. If there are no more
2564states to pop, we return failure.
2565
2566Sometimes we also need to backtrack on success; for example /A+/, where
2567after successfully matching one A, we need to go back and try to
2568match another one; similarly for lookahead assertions: if the assertion
2569completes successfully, we backtrack to the state just before the assertion
2570and then carry on. In these cases, the pushed state is marked as
2571'backtrack on success too'. This marking is in fact done by a chain of
2572pointers, each pointing to the previous 'yes' state. On success, we pop to
2573the nearest yes state, discarding any intermediate failure-only states.
2574Sometimes a yes state is pushed just to force some cleanup code to be
2575called at the end of a successful match or submatch; e.g. (??{$re}) uses
2576it to free the inner regex.
2577
2578Note that failure backtracking rewinds the cursor position, while
2579success backtracking leaves it alone.
2580
2581A pattern is complete when the END op is executed, while a subpattern
2582such as (?=foo) is complete when the SUCCESS op is executed. Both of these
2583ops trigger the "pop to last yes state if any, otherwise return true"
2584behaviour.
2585
2586A common convention in this function is to use A and B to refer to the two
2587subpatterns (or to the first nodes thereof) in patterns like /A*B/: so A is
2588the subpattern to be matched possibly multiple times, while B is the entire
2589rest of the pattern. Variable and state names reflect this convention.
2590
2591The states in the main switch are the union of ops and failure/success of
2592substates associated with with that op. For example, IFMATCH is the op
2593that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
2594'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
2595successfully matched A and IFMATCH_A_fail is a state saying that we have
2596just failed to match A. Resume states always come in pairs. The backtrack
2597state we push is marked as 'IFMATCH_A', but when that is popped, we resume
2598at IFMATCH_A or IFMATCH_A_fail, depending on whether we are backtracking
2599on success or failure.
2600
2601The struct that holds a backtracking state is actually a big union, with
2602one variant for each major type of op. The variable st points to the
2603top-most backtrack struct. To make the code clearer, within each
2604block of code we #define ST to alias the relevant union.
2605
2606Here's a concrete example of a (vastly oversimplified) IFMATCH
2607implementation:
2608
2609 switch (state) {
2610 ....
2611
2612#define ST st->u.ifmatch
2613
2614 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
2615 ST.foo = ...; // some state we wish to save
95b24440 2616 ...
bf1f174e
DM		 2617 // push a yes backtrack state with a resume value of
2618 // IFMATCH_A/IFMATCH_A_fail, then continue execution at the
2619 // first node of A:
2620 PUSH_YES_STATE_GOTO(IFMATCH_A, A);
2621 // NOTREACHED
2622
2623 case IFMATCH_A: // we have successfully executed A; now continue with B
2624 next = B;
2625 bar = ST.foo; // do something with the preserved value
2626 break;
2627
2628 case IFMATCH_A_fail: // A failed, so the assertion failed
2629 ...; // do some housekeeping, then ...
2630 sayNO; // propagate the failure
2631
2632#undef ST
95b24440 2633
bf1f174e
DM		 2634 ...
2635 }
95b24440 2636
bf1f174e
DM		 2637For any old-timers reading this who are familiar with the old recursive
2638approach, the code above is equivalent to:
95b24440 2639
bf1f174e
DM		 2640 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
2641 {
2642 int foo = ...
95b24440 2643 ...
bf1f174e
DM		 2644 if (regmatch(A)) {
2645 next = B;
2646 bar = foo;
2647 break;
95b24440 2648 }
bf1f174e
DM		 2649 ...; // do some housekeeping, then ...
2650 sayNO; // propagate the failure
95b24440 2651 }
bf1f174e
DM		 2652
2653The topmost backtrack state, pointed to by st, is usually free. If you
2654want to claim it, populate any ST.foo fields in it with values you wish to
2655save, then do one of
2656
2657 PUSH_STATE_GOTO(resume_state, node);
2658 PUSH_YES_STATE_GOTO(resume_state, node);
2659
2660which sets that backtrack state's resume value to 'resume_state', pushes a
2661new free entry to the top of the backtrack stack, then goes to 'node'.
2662On backtracking, the free slot is popped, and the saved state becomes the
2663new free state. An ST.foo field in this new top state can be temporarily
2664accessed to retrieve values, but once the main loop is re-entered, it
2665becomes available for reuse.
2666
2667Note that the depth of the backtrack stack constantly increases during the
2668left-to-right execution of the pattern, rather than going up and down with
2669the pattern nesting. For example the stack is at its maximum at Z at the
2670end of the pattern, rather than at X in the following:
2671
2672 /(((X)+)+)+....(Y)+....Z/
2673
2674The only exceptions to this are lookahead/behind assertions and the cut,
2675(?>A), which pop all the backtrack states associated with A before
2676continuing.
2677
2678Bascktrack state structs are allocated in slabs of about 4K in size.
2679PL_regmatch_state and st always point to the currently active state,
2680and PL_regmatch_slab points to the slab currently containing
2681PL_regmatch_state. The first time regmatch() is called, the first slab is
2682allocated, and is never freed until interpreter destruction. When the slab
2683is full, a new one is allocated and chained to the end. At exit from
2684regmatch(), slabs allocated since entry are freed.
2685
2686*/
95b24440 2687
40a82448 2688
5bc10b2c 2689#define DEBUG_STATE_pp(pp) \
265c4333 2690 DEBUG_STATE_r({ \
f2ed9b32 2691 DUMP_EXEC_POS(locinput, scan, utf8_target); \
5bc10b2c 2692 PerlIO_printf(Perl_debug_log, \
5d458dd8 2693 " %*s"pp" %s%s%s%s%s\n", \
5bc10b2c 2694 depth*2, "", \
13d6edb4 2695 PL_reg_name[st->resume_state], \
5d458dd8
YO		 2696 ((st==yes_state||st==mark_state) ? "[" : ""), \
2697 ((st==yes_state) ? "Y" : ""), \
2698 ((st==mark_state) ? "M" : ""), \
2699 ((st==yes_state||st==mark_state) ? "]" : "") \
2700 ); \
265c4333 2701 });
5bc10b2c 2702
40a82448 2703
3dab1dad 2704#define REG_NODE_NUM(x) ((x) ? (int)((x)-prog) : -1)
95b24440 2705
3df15adc 2706#ifdef DEBUGGING
5bc10b2c 2707
ab3bbdeb 2708STATIC void
f2ed9b32 2709S_debug_start_match(pTHX_ const REGEXP *prog, const bool utf8_target,
ab3bbdeb
YO		 2710 const char *start, const char *end, const char *blurb)
2711{
efd26800 2712 const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
7918f24d
NC		 2713
2714 PERL_ARGS_ASSERT_DEBUG_START_MATCH;
2715
ab3bbdeb
YO		 2716 if (!PL_colorset)
2717 reginitcolors();
2718 {
2719 RE_PV_QUOTED_DECL(s0, utf8_pat, PERL_DEBUG_PAD_ZERO(0),
d2c6dc5e 2720 RX_PRECOMP_const(prog), RX_PRELEN(prog), 60);
ab3bbdeb 2721
f2ed9b32 2722 RE_PV_QUOTED_DECL(s1, utf8_target, PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb
YO		 2723 start, end - start, 60);
2724
2725 PerlIO_printf(Perl_debug_log,
2726 "%s%s REx%s %s against %s\n",
2727 PL_colors[4], blurb, PL_colors[5], s0, s1);
2728
f2ed9b32 2729 if (utf8_target||utf8_pat)
1de06328
YO		 2730 PerlIO_printf(Perl_debug_log, "UTF-8 %s%s%s...\n",
2731 utf8_pat ? "pattern" : "",
f2ed9b32
KW		 2732 utf8_pat && utf8_target ? " and " : "",
2733 utf8_target ? "string" : ""
ab3bbdeb
YO		 2734 );
2735 }
2736}
3df15adc
YO		 2737
2738STATIC void
786e8c11
YO		 2739S_dump_exec_pos(pTHX_ const char *locinput,
2740 const regnode *scan,
2741 const char *loc_regeol,
2742 const char *loc_bostr,
2743 const char *loc_reg_starttry,
f2ed9b32 2744 const bool utf8_target)
07be1b83 2745{
786e8c11 2746 const int docolor = *PL_colors[0] || *PL_colors[2] || *PL_colors[4];
07be1b83 2747 const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
786e8c11 2748 int l = (loc_regeol - locinput) > taill ? taill : (loc_regeol - locinput);
07be1b83
YO		 2749 /* The part of the string before starttry has one color
2750 (pref0_len chars), between starttry and current
2751 position another one (pref_len - pref0_len chars),
2752 after the current position the third one.
2753 We assume that pref0_len <= pref_len, otherwise we
2754 decrease pref0_len. */
786e8c11
YO		 2755 int pref_len = (locinput - loc_bostr) > (5 + taill) - l
2756 ? (5 + taill) - l : locinput - loc_bostr;
07be1b83
YO		 2757 int pref0_len;
2758
7918f24d
NC		 2759 PERL_ARGS_ASSERT_DUMP_EXEC_POS;
2760
f2ed9b32 2761 while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
07be1b83 2762 pref_len++;
786e8c11
YO		 2763 pref0_len = pref_len - (locinput - loc_reg_starttry);
2764 if (l + pref_len < (5 + taill) && l < loc_regeol - locinput)
2765 l = ( loc_regeol - locinput > (5 + taill) - pref_len
2766 ? (5 + taill) - pref_len : loc_regeol - locinput);
f2ed9b32 2767 while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
07be1b83
YO		 2768 l--;
2769 if (pref0_len < 0)
2770 pref0_len = 0;
2771 if (pref0_len > pref_len)
2772 pref0_len = pref_len;
2773 {
f2ed9b32 2774 const int is_uni = (utf8_target && OP(scan) != CANY) ? 1 : 0;
0df25f3d 2775
ab3bbdeb 2776 RE_PV_COLOR_DECL(s0,len0,is_uni,PERL_DEBUG_PAD(0),
1de06328 2777 (locinput - pref_len),pref0_len, 60, 4, 5);
0df25f3d 2778
ab3bbdeb 2779 RE_PV_COLOR_DECL(s1,len1,is_uni,PERL_DEBUG_PAD(1),
3df15adc 2780 (locinput - pref_len + pref0_len),
1de06328 2781 pref_len - pref0_len, 60, 2, 3);
0df25f3d 2782
ab3bbdeb 2783 RE_PV_COLOR_DECL(s2,len2,is_uni,PERL_DEBUG_PAD(2),
1de06328 2784 locinput, loc_regeol - locinput, 10, 0, 1);
0df25f3d 2785
1de06328 2786 const STRLEN tlen=len0+len1+len2;
3df15adc 2787 PerlIO_printf(Perl_debug_log,
ab3bbdeb 2788 "%4"IVdf" <%.*s%.*s%s%.*s>%*s|",
786e8c11 2789 (IV)(locinput - loc_bostr),
07be1b83 2790 len0, s0,
07be1b83 2791 len1, s1,
07be1b83 2792 (docolor ? "" : "> <"),
07be1b83 2793 len2, s2,
f9f4320a 2794 (int)(tlen > 19 ? 0 : 19 - tlen),
07be1b83
YO		 2795 "");
2796 }
2797}
3df15adc 2798
07be1b83
YO		 2799#endif
2800
0a4db386
YO		 2801/* reg_check_named_buff_matched()
2802 * Checks to see if a named buffer has matched. The data array of
2803 * buffer numbers corresponding to the buffer is expected to reside
2804 * in the regexp->data->data array in the slot stored in the ARG() of
2805 * node involved. Note that this routine doesn't actually care about the
2806 * name, that information is not preserved from compilation to execution.
2807 * Returns the index of the leftmost defined buffer with the given name
2808 * or 0 if non of the buffers matched.
2809 */
2810STATIC I32
7918f24d
NC		 2811S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
2812{
0a4db386 2813 I32 n;
f8fc2ecf 2814 RXi_GET_DECL(rex,rexi);
ad64d0ec 2815 SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
0a4db386 2816 I32 *nums=(I32*)SvPVX(sv_dat);
7918f24d
NC		 2817
2818 PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
2819
0a4db386
YO		 2820 for ( n=0; n<SvIVX(sv_dat); n++ ) {
2821 if ((I32)*PL_reglastparen >= nums[n] &&
f0ab9afb 2822 PL_regoffs[nums[n]].end != -1)
0a4db386
YO		 2823 {
2824 return nums[n];
2825 }
2826 }
2827 return 0;
2828}
2829
2f554ef7
DM		 2830
2831/* free all slabs above current one - called during LEAVE_SCOPE */
2832
2833STATIC void
2834S_clear_backtrack_stack(pTHX_ void *p)
2835{
2836 regmatch_slab *s = PL_regmatch_slab->next;
2837 PERL_UNUSED_ARG(p);
2838
2839 if (!s)
2840 return;
2841 PL_regmatch_slab->next = NULL;
2842 while (s) {
2843 regmatch_slab * const osl = s;
2844 s = s->next;
2845 Safefree(osl);
2846 }
2847}
2848
2849
28d8d7f4
YO		 2850#define SETREX(Re1,Re2) \
2851 if (PL_reg_eval_set) PM_SETRE((PL_reg_curpm), (Re2)); \
2852 Re1 = (Re2)
2853
d6a28714 2854STATIC I32 /* 0 failure, 1 success */
24b23f37 2855S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
d6a28714 2856{
a35a87e7 2857#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC		 2858 dMY_CXT;
2859#endif
27da23d5 2860 dVAR;
f2ed9b32 2861 register const bool utf8_target = PL_reg_match_utf8;
4ad0818d 2862 const U32 uniflags = UTF8_ALLOW_DEFAULT;
288b8c02
NC		 2863 REGEXP *rex_sv = reginfo->prog;
2864 regexp *rex = (struct regexp *)SvANY(rex_sv);
f8fc2ecf 2865 RXi_GET_DECL(rex,rexi);
2f554ef7 2866 I32 oldsave;
5d9a96ca
DM		 2867 /* the current state. This is a cached copy of PL_regmatch_state */
2868 register regmatch_state *st;
5d9a96ca
DM		 2869 /* cache heavy used fields of st in registers */
2870 register regnode *scan;
2871 register regnode *next;
438e9bae 2872 register U32 n = 0; /* general value; init to avoid compiler warning */
24d3c4a9 2873 register I32 ln = 0; /* len or last; init to avoid compiler warning */
5d9a96ca 2874 register char *locinput = PL_reginput;
5d9a96ca 2875 register I32 nextchr; /* is always set to UCHARAT(locinput) */
24d3c4a9 2876
b69b0499 2877 bool result = 0; /* return value of S_regmatch */
24d3c4a9 2878 int depth = 0; /* depth of backtrack stack */
4b196cd4
YO		 2879 U32 nochange_depth = 0; /* depth of GOSUB recursion with nochange */
2880 const U32 max_nochange_depth =
2881 (3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
2882 3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
77cb431f
DM		 2883 regmatch_state *yes_state = NULL; /* state to pop to on success of
2884 subpattern */
e2e6a0f1
YO		 2885 /* mark_state piggy backs on the yes_state logic so that when we unwind
2886 the stack on success we can update the mark_state as we go */
2887 regmatch_state *mark_state = NULL; /* last mark state we have seen */
faec1544 2888 regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
b8591aee 2889 struct regmatch_state *cur_curlyx = NULL; /* most recent curlyx */
40a82448 2890 U32 state_num;
5d458dd8
YO		 2891 bool no_final = 0; /* prevent failure from backtracking? */
2892 bool do_cutgroup = 0; /* no_final only until next branch/trie entry */
e2e6a0f1 2893 char *startpoint = PL_reginput;
5d458dd8
YO		 2894 SV *popmark = NULL; /* are we looking for a mark? */
2895 SV *sv_commit = NULL; /* last mark name seen in failure */
2896 SV *sv_yes_mark = NULL; /* last mark name we have seen
2897 during a successfull match */
2898 U32 lastopen = 0; /* last open we saw */
2899 bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;
19b95bf0 2900 SV* const oreplsv = GvSV(PL_replgv);
24d3c4a9
DM		 2901 /* these three flags are set by various ops to signal information to
2902 * the very next op. They have a useful lifetime of exactly one loop
2903 * iteration, and are not preserved or restored by state pushes/pops
2904 */
2905 bool sw = 0; /* the condition value in (?(cond)a|b) */
2906 bool minmod = 0; /* the next "{n,m}" is a "{n,m}?" */
2907 int logical = 0; /* the following EVAL is:
2908 0: (?{...})
2909 1: (?(?{...})X|Y)
2910 2: (??{...})
2911 or the following IFMATCH/UNLESSM is:
2912 false: plain (?=foo)
2913 true: used as a condition: (?(?=foo))
2914 */
95b24440 2915#ifdef DEBUGGING
e68ec53f 2916 GET_RE_DEBUG_FLAGS_DECL;
d6a28714
JH		 2917#endif
2918
7918f24d
NC		 2919 PERL_ARGS_ASSERT_REGMATCH;
2920
3b57cd43 2921 DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
24b23f37 2922 PerlIO_printf(Perl_debug_log,"regmatch start\n");
3b57cd43 2923 }));
5d9a96ca
DM		 2924 /* on first ever call to regmatch, allocate first slab */
2925 if (!PL_regmatch_slab) {
2926 Newx(PL_regmatch_slab, 1, regmatch_slab);
2927 PL_regmatch_slab->prev = NULL;
2928 PL_regmatch_slab->next = NULL;
86545054 2929 PL_regmatch_state = SLAB_FIRST(PL_regmatch_slab);
5d9a96ca
DM		 2930 }
2931
2f554ef7
DM		 2932 oldsave = PL_savestack_ix;
2933 SAVEDESTRUCTOR_X(S_clear_backtrack_stack, NULL);
2934 SAVEVPTR(PL_regmatch_slab);
2935 SAVEVPTR(PL_regmatch_state);
5d9a96ca
DM		 2936
2937 /* grab next free state slot */
2938 st = ++PL_regmatch_state;
86545054 2939 if (st > SLAB_LAST(PL_regmatch_slab))
5d9a96ca
DM		 2940 st = PL_regmatch_state = S_push_slab(aTHX);
2941
d6a28714
JH		 2942 /* Note that nextchr is a byte even in UTF */
2943 nextchr = UCHARAT(locinput);
2944 scan = prog;
2945 while (scan != NULL) {
8ba1375e 2946
a3621e74 2947 DEBUG_EXECUTE_r( {
6136c704 2948 SV * const prop = sv_newmortal();
1de06328 2949 regnode *rnext=regnext(scan);
f2ed9b32 2950 DUMP_EXEC_POS( locinput, scan, utf8_target );
32fc9b6a 2951 regprop(rex, prop, scan);
07be1b83
YO		 2952
2953 PerlIO_printf(Perl_debug_log,
2954 "%3"IVdf":%*s%s(%"IVdf")\n",
f8fc2ecf 2955 (IV)(scan - rexi->program), depth*2, "",
07be1b83 2956 SvPVX_const(prop),
1de06328 2957 (PL_regkind[OP(scan)] == END || !rnext) ?
f8fc2ecf 2958 0 : (IV)(rnext - rexi->program));
2a782b5b 2959 });
d6a28714
JH		 2960
2961 next = scan + NEXT_OFF(scan);
2962 if (next == scan)
2963 next = NULL;
40a82448 2964 state_num = OP(scan);
d6a28714 2965
40a82448 2966 reenter_switch:
34a81e2b
B		 2967
2968 assert(PL_reglastparen == &rex->lastparen);
2969 assert(PL_reglastcloseparen == &rex->lastcloseparen);
2970 assert(PL_regoffs == rex->offs);
2971
40a82448 2972 switch (state_num) {
d6a28714 2973 case BOL:
7fba1cd6 2974 if (locinput == PL_bostr)
d6a28714 2975 {
3b0527fe 2976 /* reginfo->till = reginfo->bol; */
b8c5462f
JH		 2977 break;
2978 }
d6a28714
JH		 2979 sayNO;
2980 case MBOL:
12d33761
HS		 2981 if (locinput == PL_bostr ||
2982 ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n'))
d6a28714 2983 {
b8c5462f
JH		 2984 break;
2985 }
d6a28714
JH		 2986 sayNO;
2987 case SBOL:
c2a73568 2988 if (locinput == PL_bostr)
b8c5462f 2989 break;
d6a28714
JH		 2990 sayNO;
2991 case GPOS:
3b0527fe 2992 if (locinput == reginfo->ganch)
d6a28714
JH		 2993 break;
2994 sayNO;
ee9b8eae
YO		 2995
2996 case KEEPS:
2997 /* update the startpoint */
f0ab9afb 2998 st->u.keeper.val = PL_regoffs[0].start;
ee9b8eae 2999 PL_reginput = locinput;
f0ab9afb 3000 PL_regoffs[0].start = locinput - PL_bostr;
ee9b8eae
YO		 3001 PUSH_STATE_GOTO(KEEPS_next, next);
3002 /*NOT-REACHED*/
3003 case KEEPS_next_fail:
3004 /* rollback the start point change */
f0ab9afb 3005 PL_regoffs[0].start = st->u.keeper.val;
ee9b8eae
YO		 3006 sayNO_SILENT;
3007 /*NOT-REACHED*/
d6a28714 3008 case EOL:
d6a28714
JH		 3009 goto seol;
3010 case MEOL:
d6a28714 3011 if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
b8c5462f 3012 sayNO;
b8c5462f 3013 break;
d6a28714
JH		 3014 case SEOL:
3015 seol:
3016 if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
b8c5462f 3017 sayNO;
d6a28714 3018 if (PL_regeol - locinput > 1)
b8c5462f 3019 sayNO;
b8c5462f 3020 break;
d6a28714
JH		 3021 case EOS:
3022 if (PL_regeol != locinput)
b8c5462f 3023 sayNO;
d6a28714 3024 break;
ffc61ed2 3025 case SANY:
d6a28714 3026 if (!nextchr && locinput >= PL_regeol)
4633a7c4 3027 sayNO;
f2ed9b32 3028 if (utf8_target) {
f33976b4
DB		 3029 locinput += PL_utf8skip[nextchr];
3030 if (locinput > PL_regeol)
3031 sayNO;
3032 nextchr = UCHARAT(locinput);
3033 }
3034 else
3035 nextchr = UCHARAT(++locinput);
3036 break;
3037 case CANY:
3038 if (!nextchr && locinput >= PL_regeol)
3039 sayNO;
b8c5462f 3040 nextchr = UCHARAT(++locinput);
a0d0e21e 3041 break;
ffc61ed2 3042 case REG_ANY:
1aa99e6b
IH		 3043 if ((!nextchr && locinput >= PL_regeol) || nextchr == '\n')
3044 sayNO;
f2ed9b32 3045 if (utf8_target) {
b8c5462f 3046 locinput += PL_utf8skip[nextchr];
d6a28714
JH		 3047 if (locinput > PL_regeol)
3048 sayNO;
a0ed51b3 3049 nextchr = UCHARAT(locinput);
a0ed51b3 3050 }
1aa99e6b
IH		 3051 else
3052 nextchr = UCHARAT(++locinput);
a0ed51b3 3053 break;
166ba7cd
DM		 3054
3055#undef ST
3056#define ST st->u.trie
786e8c11
YO		 3057 case TRIEC:
3058 /* In this case the charclass data is available inline so
3059 we can fail fast without a lot of extra overhead.
3060 */
f2ed9b32 3061 if (scan->flags == EXACT || !utf8_target) {
786e8c11
YO		 3062 if(!ANYOF_BITMAP_TEST(scan, *locinput)) {
3063 DEBUG_EXECUTE_r(
3064 PerlIO_printf(Perl_debug_log,
3065 "%*s %sfailed to match trie start class...%s\n",
5bc10b2c 3066 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
786e8c11
YO		 3067 );
3068 sayNO_SILENT;
3069 /* NOTREACHED */
3070 }
3071 }
3072 /* FALL THROUGH */
5b47454d 3073 case TRIE:
2e64971a
DM		 3074 /* the basic plan of execution of the trie is:
3075 * At the beginning, run though all the states, and
3076 * find the longest-matching word. Also remember the position
3077 * of the shortest matching word. For example, this pattern:
3078 * 1 2 3 4 5
3079 * ab|a|x|abcd|abc
3080 * when matched against the string "abcde", will generate
3081 * accept states for all words except 3, with the longest
3082 * matching word being 4, and the shortest being 1 (with
3083 * the position being after char 1 of the string).
3084 *
3085 * Then for each matching word, in word order (i.e. 1,2,4,5),
3086 * we run the remainder of the pattern; on each try setting
3087 * the current position to the character following the word,
3088 * returning to try the next word on failure.
3089 *
3090 * We avoid having to build a list of words at runtime by
3091 * using a compile-time structure, wordinfo[].prev, which
3092 * gives, for each word, the previous accepting word (if any).
3093 * In the case above it would contain the mappings 1->2, 2->0,
3094 * 3->0, 4->5, 5->1. We can use this table to generate, from
3095 * the longest word (4 above), a list of all words, by
3096 * following the list of prev pointers; this gives us the
3097 * unordered list 4,5,1,2. Then given the current word we have
3098 * just tried, we can go through the list and find the
3099 * next-biggest word to try (so if we just failed on word 2,
3100 * the next in the list is 4).
3101 *
3102 * Since at runtime we don't record the matching position in
3103 * the string for each word, we have to work that out for
3104 * each word we're about to process. The wordinfo table holds
3105 * the character length of each word; given that we recorded
3106 * at the start: the position of the shortest word and its
3107 * length in chars, we just need to move the pointer the
3108 * difference between the two char lengths. Depending on
3109 * Unicode status and folding, that's cheap or expensive.
3110 *
3111 * This algorithm is optimised for the case where are only a
3112 * small number of accept states, i.e. 0,1, or maybe 2.
3113 * With lots of accepts states, and having to try all of them,
3114 * it becomes quadratic on number of accept states to find all
3115 * the next words.
3116 */
3117
3dab1dad 3118 {
07be1b83 3119 /* what type of TRIE am I? (utf8 makes this contextual) */
a0a388a1 3120 DECL_TRIE_TYPE(scan);
3dab1dad
YO		 3121
3122 /* what trie are we using right now */
be8e71aa 3123 reg_trie_data * const trie
f8fc2ecf 3124 = (reg_trie_data*)rexi->data->data[ ARG( scan ) ];
85fbaab2 3125 HV * widecharmap = MUTABLE_HV(rexi->data->data[ ARG( scan ) + 1 ]);
3dab1dad 3126 U32 state = trie->startstate;
166ba7cd 3127
3dab1dad
YO		 3128 if (trie->bitmap && trie_type != trie_utf8_fold &&
3129 !TRIE_BITMAP_TEST(trie,*locinput)
3130 ) {
3131 if (trie->states[ state ].wordnum) {
3132 DEBUG_EXECUTE_r(
3133 PerlIO_printf(Perl_debug_log,
3134 "%*s %smatched empty string...%s\n",
5bc10b2c 3135 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3dab1dad
YO		 3136 );
3137 break;
3138 } else {
3139 DEBUG_EXECUTE_r(
3140 PerlIO_printf(Perl_debug_log,
786e8c11 3141 "%*s %sfailed to match trie start class...%s\n",
5bc10b2c 3142 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3dab1dad
YO		 3143 );
3144 sayNO_SILENT;
3145 }
3146 }
166ba7cd 3147
786e8c11
YO		 3148 {
3149 U8 *uc = ( U8* )locinput;
3150
3151 STRLEN len = 0;
3152 STRLEN foldlen = 0;
3153 U8 *uscan = (U8*)NULL;
786e8c11 3154 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
2e64971a
DM		 3155 U32 charcount = 0; /* how many input chars we have matched */
3156 U32 accepted = 0; /* have we seen any accepting states? */
786e8c11 3157
786e8c11
YO		 3158 ST.B = next;
3159 ST.jump = trie->jump;
786e8c11 3160 ST.me = scan;
2e64971a
DM		 3161 ST.firstpos = NULL;
3162 ST.longfold = FALSE; /* char longer if folded => it's harder */
3163 ST.nextword = 0;
3164
3165 /* fully traverse the TRIE; note the position of the
3166 shortest accept state and the wordnum of the longest
3167 accept state */
07be1b83 3168
a3621e74 3169 while ( state && uc <= (U8*)PL_regeol ) {
786e8c11 3170 U32 base = trie->states[ state ].trans.base;
f9f4320a 3171 UV uvc = 0;
786e8c11 3172 U16 charid;
2e64971a
DM		 3173 U16 wordnum;
3174 wordnum = trie->states[ state ].wordnum;
3175
3176 if (wordnum) { /* it's an accept state */
3177 if (!accepted) {
3178 accepted = 1;
3179 /* record first match position */
3180 if (ST.longfold) {
3181 ST.firstpos = (U8*)locinput;
3182 ST.firstchars = 0;
5b47454d 3183 }
2e64971a
DM		 3184 else {
3185 ST.firstpos = uc;
3186 ST.firstchars = charcount;
3187 }
3188 }
3189 if (!ST.nextword || wordnum < ST.nextword)
3190 ST.nextword = wordnum;
3191 ST.topword = wordnum;
786e8c11 3192 }
a3621e74 3193
07be1b83 3194 DEBUG_TRIE_EXECUTE_r({
f2ed9b32 3195 DUMP_EXEC_POS( (char *)uc, scan, utf8_target );
a3621e74 3196 PerlIO_printf( Perl_debug_log,
2e64971a 3197 "%*s %sState: %4"UVxf" Accepted: %c ",
5bc10b2c 3198 2+depth * 2, "", PL_colors[4],
2e64971a 3199 (UV)state, (accepted ? 'Y' : 'N'));
07be1b83 3200 });
a3621e74 3201
2e64971a 3202 /* read a char and goto next state */
a3621e74 3203 if ( base ) {
6dd2be57 3204 I32 offset;
55eed653
NC		 3205 REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc,
3206 uscan, len, uvc, charid, foldlen,
3207 foldbuf, uniflags);
2e64971a
DM		 3208 charcount++;
3209 if (foldlen>0)
3210 ST.longfold = TRUE;
5b47454d 3211 if (charid &&
6dd2be57
DM		 3212 ( ((offset =
3213 base + charid - 1 - trie->uniquecharcount)) >= 0)
3214
3215 && ((U32)offset < trie->lasttrans)
3216 && trie->trans[offset].check == state)
5b47454d 3217 {
6dd2be57 3218 state = trie->trans[offset].next;
5b47454d
DM		 3219 }
3220 else {
3221 state = 0;
3222 }
3223 uc += len;
3224
3225 }
3226 else {
a3621e74
YO		 3227 state = 0;
3228 }
3229 DEBUG_TRIE_EXECUTE_r(
e4584336 3230 PerlIO_printf( Perl_debug_log,
786e8c11 3231 "Charid:%3x CP:%4"UVxf" After State: %4"UVxf"%s\n",
e4584336 3232 charid, uvc, (UV)state, PL_colors[5] );
a3621e74
YO		 3233 );
3234 }
2e64971a 3235 if (!accepted)
a3621e74 3236 sayNO;
a3621e74 3237
2e64971a
DM		 3238 /* calculate total number of accept states */
3239 {
3240 U16 w = ST.topword;
3241 accepted = 0;
3242 while (w) {
3243 w = trie->wordinfo[w].prev;
3244 accepted++;
3245 }
3246 ST.accepted = accepted;
3247 }
3248
166ba7cd
DM		 3249 DEBUG_EXECUTE_r(
3250 PerlIO_printf( Perl_debug_log,
3251 "%*s %sgot %"IVdf" possible matches%s\n",
5bc10b2c 3252 REPORT_CODE_OFF + depth * 2, "",
166ba7cd
DM		 3253 PL_colors[4], (IV)ST.accepted, PL_colors[5] );
3254 );
2e64971a 3255 goto trie_first_try; /* jump into the fail handler */
786e8c11 3256 }}
fae667d5 3257 /* NOTREACHED */
2e64971a
DM		 3258
3259 case TRIE_next_fail: /* we failed - try next alternative */
fae667d5
YO		 3260 if ( ST.jump) {
3261 REGCP_UNWIND(ST.cp);
3262 for (n = *PL_reglastparen; n > ST.lastparen; n--)
f0ab9afb 3263 PL_regoffs[n].end = -1;
fae667d5
YO		 3264 *PL_reglastparen = n;
3265 }
2e64971a
DM		 3266 if (!--ST.accepted) {
3267 DEBUG_EXECUTE_r({
3268 PerlIO_printf( Perl_debug_log,
3269 "%*s %sTRIE failed...%s\n",
3270 REPORT_CODE_OFF+depth*2, "",
3271 PL_colors[4],
3272 PL_colors[5] );
3273 });
3274 sayNO_SILENT;
3275 }
3276 {
3277 /* Find next-highest word to process. Note that this code
3278 * is O(N^2) per trie run (O(N) per branch), so keep tight */
d9a396a3
DM		 3279 register U16 min = 0;
3280 register U16 word;
2e64971a
DM		 3281 register U16 const nextword = ST.nextword;
3282 register reg_trie_wordinfo * const wordinfo
3283 = ((reg_trie_data*)rexi->data->data[ARG(ST.me)])->wordinfo;
3284 for (word=ST.topword; word; word=wordinfo[word].prev) {
3285 if (word > nextword && (!min || word < min))
3286 min = word;
3287 }
3288 ST.nextword = min;
3289 }
3290
fae667d5 3291 trie_first_try:
5d458dd8
YO		 3292 if (do_cutgroup) {
3293 do_cutgroup = 0;
3294 no_final = 0;
3295 }
fae667d5
YO		 3296
3297 if ( ST.jump) {
3298 ST.lastparen = *PL_reglastparen;
3299 REGCP_SET(ST.cp);
2e64971a 3300 }
a3621e74 3301
2e64971a 3302 /* find start char of end of current word */
166ba7cd 3303 {
2e64971a
DM		 3304 U32 chars; /* how many chars to skip */
3305 U8 *uc = ST.firstpos;
3306 reg_trie_data * const trie
3307 = (reg_trie_data*)rexi->data->data[ARG(ST.me)];
3308
3309 assert((trie->wordinfo[ST.nextword].len - trie->prefixlen)
3310 >= ST.firstchars);
3311 chars = (trie->wordinfo[ST.nextword].len - trie->prefixlen)
3312 - ST.firstchars;
3313
3314 if (ST.longfold) {
3315 /* the hard option - fold each char in turn and find
3316 * its folded length (which may be different */
3317 U8 foldbuf[UTF8_MAXBYTES_CASE + 1];
3318 STRLEN foldlen;
3319 STRLEN len;
d9a396a3 3320 UV uvc;
2e64971a
DM		 3321 U8 *uscan;
3322
3323 while (chars) {
f2ed9b32 3324 if (utf8_target) {
2e64971a
DM		 3325 uvc = utf8n_to_uvuni((U8*)uc, UTF8_MAXLEN, &len,
3326 uniflags);
3327 uc += len;
3328 }
3329 else {
3330 uvc = *uc;
3331 uc++;
3332 }
3333 uvc = to_uni_fold(uvc, foldbuf, &foldlen);
3334 uscan = foldbuf;
3335 while (foldlen) {
3336 if (!--chars)
3337 break;
3338 uvc = utf8n_to_uvuni(uscan, UTF8_MAXLEN, &len,
3339 uniflags);
3340 uscan += len;
3341 foldlen -= len;
3342 }
3343 }
a3621e74 3344 }
2e64971a 3345 else {
f2ed9b32 3346 if (utf8_target)
2e64971a
DM		 3347 while (chars--)
3348 uc += UTF8SKIP(uc);
3349 else
3350 uc += chars;
3351 }
3352 PL_reginput = (char *)uc;
3353 }
166ba7cd 3354
2e64971a
DM		 3355 scan = (ST.jump && ST.jump[ST.nextword])
3356 ? ST.me + ST.jump[ST.nextword]
3357 : ST.B;
166ba7cd 3358
2e64971a
DM		 3359 DEBUG_EXECUTE_r({
3360 PerlIO_printf( Perl_debug_log,
3361 "%*s %sTRIE matched word #%d, continuing%s\n",
3362 REPORT_CODE_OFF+depth*2, "",
3363 PL_colors[4],
3364 ST.nextword,
3365 PL_colors[5]
3366 );
3367 });
3368
3369 if (ST.accepted > 1 || has_cutgroup) {
3370 PUSH_STATE_GOTO(TRIE_next, scan);
3371 /* NOTREACHED */
166ba7cd 3372 }
2e64971a
DM		 3373 /* only one choice left - just continue */
3374 DEBUG_EXECUTE_r({
3375 AV *const trie_words
3376 = MUTABLE_AV(rexi->data->data[ARG(ST.me)+TRIE_WORDS_OFFSET]);
3377 SV ** const tmp = av_fetch( trie_words,
3378 ST.nextword-1, 0 );
3379 SV *sv= tmp ? sv_newmortal() : NULL;
3380
3381 PerlIO_printf( Perl_debug_log,
3382 "%*s %sonly one match left, short-circuiting: #%d <%s>%s\n",
3383 REPORT_CODE_OFF+depth*2, "", PL_colors[4],
3384 ST.nextword,
3385 tmp ? pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 0,
3386 PL_colors[0], PL_colors[1],
3387 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)
3388 )
3389 : "not compiled under -Dr",
3390 PL_colors[5] );
3391 });
3392
3393 locinput = PL_reginput;
3394 nextchr = UCHARAT(locinput);
3395 continue; /* execute rest of RE */
166ba7cd 3396 /* NOTREACHED */
166ba7cd
DM		 3397#undef ST
3398
95b24440
DM		 3399 case EXACT: {
3400 char *s = STRING(scan);
24d3c4a9 3401 ln = STR_LEN(scan);
f2ed9b32 3402 if (utf8_target != UTF_PATTERN) {
bc517b45 3403 /* The target and the pattern have differing utf8ness. */
1aa99e6b 3404 char *l = locinput;
24d3c4a9 3405 const char * const e = s + ln;
a72c7584 3406
f2ed9b32 3407 if (utf8_target) {
5ff6fc6d 3408 /* The target is utf8, the pattern is not utf8. */
1aa99e6b 3409 while (s < e) {
a3b680e6 3410 STRLEN ulen;
1aa99e6b 3411 if (l >= PL_regeol)
5ff6fc6d
JH		 3412 sayNO;
3413 if (NATIVE_TO_UNI(*(U8*)s) !=
89ebb4a3 3414 utf8n_to_uvuni((U8*)l, UTF8_MAXBYTES, &ulen,
041457d9 3415 uniflags))
5ff6fc6d 3416 sayNO;
bc517b45 3417 l += ulen;
5ff6fc6d 3418 s ++;
1aa99e6b 3419 }
5ff6fc6d
JH		 3420 }
3421 else {
3422 /* The target is not utf8, the pattern is utf8. */
1aa99e6b 3423 while (s < e) {
a3b680e6 3424 STRLEN ulen;
1aa99e6b
IH		 3425 if (l >= PL_regeol)
3426 sayNO;
5ff6fc6d 3427 if (NATIVE_TO_UNI(*((U8*)l)) !=
89ebb4a3 3428 utf8n_to_uvuni((U8*)s, UTF8_MAXBYTES, &ulen,
041457d9 3429 uniflags))
1aa99e6b 3430 sayNO;
bc517b45 3431 s += ulen;
a72c7584 3432 l ++;
1aa99e6b 3433 }
5ff6fc6d 3434 }
1aa99e6b
IH		 3435 locinput = l;
3436 nextchr = UCHARAT(locinput);
3437 break;
3438 }
bc517b45 3439 /* The target and the pattern have the same utf8ness. */
d6a28714
JH		 3440 /* Inline the first character, for speed. */
3441 if (UCHARAT(s) != nextchr)
3442 sayNO;
24d3c4a9 3443 if (PL_regeol - locinput < ln)
d6a28714 3444 sayNO;
24d3c4a9 3445 if (ln > 1 && memNE(s, locinput, ln))
d6a28714 3446 sayNO;
24d3c4a9 3447 locinput += ln;
d6a28714
JH		 3448 nextchr = UCHARAT(locinput);
3449 break;
95b24440 3450 }
d6a28714 3451 case EXACTFL:
b8c5462f
JH		 3452 PL_reg_flags |= RF_tainted;
3453 /* FALL THROUGH */
95b24440 3454 case EXACTF: {
be8e71aa 3455 char * const s = STRING(scan);
24d3c4a9 3456 ln = STR_LEN(scan);
d6a28714 3457
f2ed9b32 3458 if (utf8_target || UTF_PATTERN) {
d07ddd77 3459 /* Either target or the pattern are utf8. */
be8e71aa 3460 const char * const l = locinput;
d07ddd77 3461 char *e = PL_regeol;
bc517b45 3462
f2ed9b32
KW		 3463 if (! foldEQ_utf8(s, 0, ln, cBOOL(UTF_PATTERN),
3464 l, &e, 0, utf8_target)) {
5486206c
JH		 3465 /* One more case for the sharp s:
3466 * pack("U0U*", 0xDF) =~ /ss/i,
3467 * the 0xC3 0x9F are the UTF-8
3468 * byte sequence for the U+00DF. */
e1d1eefb 3469
f2ed9b32 3470 if (!(utf8_target &&
e1d1eefb 3471 toLOWER(s[0]) == 's' &&
24d3c4a9 3472 ln >= 2 &&
5486206c
JH		 3473 toLOWER(s[1]) == 's' &&
3474 (U8)l[0] == 0xC3 &&
3475 e - l >= 2 &&
3476 (U8)l[1] == 0x9F))
3477 sayNO;
3478 }
d07ddd77
JH		 3479 locinput = e;
3480 nextchr = UCHARAT(locinput);
3481 break;
a0ed51b3 3482 }
d6a28714 3483
bc517b45
JH		 3484 /* Neither the target and the pattern are utf8. */
3485
d6a28714
JH		 3486 /* Inline the first character, for speed. */
3487 if (UCHARAT(s) != nextchr &&
3488 UCHARAT(s) != ((OP(scan) == EXACTF)
3489 ? PL_fold : PL_fold_locale)[nextchr])
a0ed51b3 3490 sayNO;
24d3c4a9 3491 if (PL_regeol - locinput < ln)
b8c5462f 3492 sayNO;
24d3c4a9 3493 if (ln > 1 && (OP(scan) == EXACTF
4c1b470c
KW		 3494 ? ! foldEQ(s, locinput, ln)
3495 : ! foldEQ_locale(s, locinput, ln)))
4633a7c4 3496 sayNO;
24d3c4a9 3497 locinput += ln;
d6a28714 3498 nextchr = UCHARAT(locinput);
a0d0e21e 3499 break;
95b24440 3500 }
b2680017
YO		 3501 case BOUNDL:
3502 case NBOUNDL:
3503 PL_reg_flags |= RF_tainted;
3504 /* FALL THROUGH */
3505 case BOUND:
3506 case NBOUND:
3507 /* was last char in word? */
f2ed9b32 3508 if (utf8_target) {
b2680017
YO		 3509 if (locinput == PL_bostr)
3510 ln = '\n';
3511 else {
3512 const U8 * const r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
3513
3514 ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, uniflags);
3515 }
3516 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
3517 ln = isALNUM_uni(ln);
3518 LOAD_UTF8_CHARCLASS_ALNUM();
f2ed9b32 3519 n = swash_fetch(PL_utf8_alnum, (U8*)locinput, utf8_target);
b2680017
YO		 3520 }
3521 else {
3522 ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(ln));
3523 n = isALNUM_LC_utf8((U8*)locinput);
3524 }
3525 }
3526 else {
3527 ln = (locinput != PL_bostr) ?
3528 UCHARAT(locinput - 1) : '\n';
3529 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
3530 ln = isALNUM(ln);
3531 n = isALNUM(nextchr);
3532 }
3533 else {
3534 ln = isALNUM_LC(ln);
3535 n = isALNUM_LC(nextchr);
3536 }
3537 }
3538 if (((!ln) == (!n)) == (OP(scan) == BOUND ||
3539 OP(scan) == BOUNDL))
3540 sayNO;
3541 break;
d6a28714 3542 case ANYOF:
f2ed9b32 3543 if (utf8_target) {
9e55ce06
JH		 3544 STRLEN inclasslen = PL_regeol - locinput;
3545
f2ed9b32 3546 if (!reginclass(rex, scan, (U8*)locinput, &inclasslen, utf8_target))
262b90c4 3547 goto anyof_fail;
ffc61ed2
JH		 3548 if (locinput >= PL_regeol)
3549 sayNO;
0f0076b4 3550 locinput += inclasslen ? inclasslen : UTF8SKIP(locinput);
b8c5462f 3551 nextchr = UCHARAT(locinput);
e0f9d4a8 3552 break;
ffc61ed2
JH		 3553 }
3554 else {
3555 if (nextchr < 0)
3556 nextchr = UCHARAT(locinput);
32fc9b6a 3557 if (!REGINCLASS(rex, scan, (U8*)locinput))
262b90c4 3558 goto anyof_fail;
ffc61ed2
JH		 3559 if (!nextchr && locinput >= PL_regeol)
3560 sayNO;
3561 nextchr = UCHARAT(++locinput);
e0f9d4a8
JH		 3562 break;
3563 }
262b90c4 3564 anyof_fail:
e0f9d4a8
JH		 3565 /* If we might have the case of the German sharp s
3566 * in a casefolding Unicode character class. */
3567
ebc501f0
JH		 3568 if (ANYOF_FOLD_SHARP_S(scan, locinput, PL_regeol)) {
3569 locinput += SHARP_S_SKIP;
e0f9d4a8 3570 nextchr = UCHARAT(locinput);
ffc61ed2 3571 }
e0f9d4a8
JH		 3572 else
3573 sayNO;
b8c5462f 3574 break;
20d0b1e9 3575 /* Special char classes - The defines start on line 129 or so */
d1eb3177
YO		 3576 CCC_TRY_AFF( ALNUM, ALNUML, perl_word, "a", isALNUM_LC_utf8, isALNUM, isALNUM_LC);
3577 CCC_TRY_NEG(NALNUM, NALNUML, perl_word, "a", isALNUM_LC_utf8, isALNUM, isALNUM_LC);
20d0b1e9 3578
d1eb3177
YO		 3579 CCC_TRY_AFF( SPACE, SPACEL, perl_space, " ", isSPACE_LC_utf8, isSPACE, isSPACE_LC);
3580 CCC_TRY_NEG(NSPACE, NSPACEL, perl_space, " ", isSPACE_LC_utf8, isSPACE, isSPACE_LC);
20d0b1e9 3581
d1eb3177
YO		 3582 CCC_TRY_AFF( DIGIT, DIGITL, posix_digit, "0", isDIGIT_LC_utf8, isDIGIT, isDIGIT_LC);
3583 CCC_TRY_NEG(NDIGIT, NDIGITL, posix_digit, "0", isDIGIT_LC_utf8, isDIGIT, isDIGIT_LC);
20d0b1e9 3584
37e2e78e
KW		 3585 case CLUMP: /* Match \X: logical Unicode character. This is defined as
3586 a Unicode extended Grapheme Cluster */
3587 /* From http://www.unicode.org/reports/tr29 (5.2 version). An
3588 extended Grapheme Cluster is:
3589
3590 CR LF
3591 | Prepend* Begin Extend*
3592 | .
3593
3594 Begin is (Hangul-syllable | ! Control)
3595 Extend is (Grapheme_Extend | Spacing_Mark)
3596 Control is [ GCB_Control CR LF ]
3597
3598 The discussion below shows how the code for CLUMP is derived
3599 from this regex. Note that most of these concepts are from
3600 property values of the Grapheme Cluster Boundary (GCB) property.
3601 No code point can have multiple property values for a given
3602 property. Thus a code point in Prepend can't be in Control, but
3603 it must be in !Control. This is why Control above includes
3604 GCB_Control plus CR plus LF. The latter two are used in the GCB
3605 property separately, and so can't be in GCB_Control, even though
3606 they logically are controls. Control is not the same as gc=cc,
3607 but includes format and other characters as well.
3608
3609 The Unicode definition of Hangul-syllable is:
3610 L+
3611 | (L* ( ( V | LV ) V* | LVT ) T*)
3612 | T+
3613 )
3614 Each of these is a value for the GCB property, and hence must be
3615 disjoint, so the order they are tested is immaterial, so the
3616 above can safely be changed to
3617 T+
3618 | L+
3619 | (L* ( LVT | ( V | LV ) V*) T*)
3620
3621 The last two terms can be combined like this:
3622 L* ( L
3623 | (( LVT | ( V | LV ) V*) T*))
3624
3625 And refactored into this:
3626 L* (L | LVT T* | V V* T* | LV V* T*)
3627
3628 That means that if we have seen any L's at all we can quit
3629 there, but if the next character is a LVT, a V or and LV we
3630 should keep going.
3631
3632 There is a subtlety with Prepend* which showed up in testing.
3633 Note that the Begin, and only the Begin is required in:
3634 | Prepend* Begin Extend*
3635 Also, Begin contains '! Control'. A Prepend must be a '!
3636 Control', which means it must be a Begin. What it comes down to
3637 is that if we match Prepend* and then find no suitable Begin
3638 afterwards, that if we backtrack the last Prepend, that one will
3639 be a suitable Begin.
3640 */
3641
b7c83a7e 3642 if (locinput >= PL_regeol)
a0ed51b3 3643 sayNO;
f2ed9b32 3644 if (! utf8_target) {
37e2e78e
KW		 3645
3646 /* Match either CR LF or '.', as all the other possibilities
3647 * require utf8 */
3648 locinput++; /* Match the . or CR */
3649 if (nextchr == '\r'
3650 && locinput < PL_regeol
3651 && UCHARAT(locinput) == '\n') locinput++;
3652 }
3653 else {
3654
3655 /* Utf8: See if is ( CR LF ); already know that locinput <
3656 * PL_regeol, so locinput+1 is in bounds */
3657 if (nextchr == '\r' && UCHARAT(locinput + 1) == '\n') {
3658 locinput += 2;
3659 }
3660 else {
3661 /* In case have to backtrack to beginning, then match '.' */
3662 char *starting = locinput;
3663
3664 /* In case have to backtrack the last prepend */
3665 char *previous_prepend = 0;
3666
3667 LOAD_UTF8_CHARCLASS_GCB();
3668
3669 /* Match (prepend)* */
3670 while (locinput < PL_regeol
3671 && swash_fetch(PL_utf8_X_prepend,
f2ed9b32 3672 (U8*)locinput, utf8_target))
37e2e78e
KW		 3673 {
3674 previous_prepend = locinput;
3675 locinput += UTF8SKIP(locinput);
3676 }
3677
3678 /* As noted above, if we matched a prepend character, but
3679 * the next thing won't match, back off the last prepend we
3680 * matched, as it is guaranteed to match the begin */
3681 if (previous_prepend
3682 && (locinput >= PL_regeol
3683 || ! swash_fetch(PL_utf8_X_begin,
f2ed9b32 3684 (U8*)locinput, utf8_target)))
37e2e78e
KW		 3685 {
3686 locinput = previous_prepend;
3687 }
3688
3689 /* Note that here we know PL_regeol > locinput, as we
3690 * tested that upon input to this switch case, and if we
3691 * moved locinput forward, we tested the result just above
3692 * and it either passed, or we backed off so that it will
3693 * now pass */
f2ed9b32 3694 if (! swash_fetch(PL_utf8_X_begin, (U8*)locinput, utf8_target)) {
37e2e78e
KW		 3695
3696 /* Here did not match the required 'Begin' in the
3697 * second term. So just match the very first
3698 * character, the '.' of the final term of the regex */
3699 locinput = starting + UTF8SKIP(starting);
3700 } else {
3701
3702 /* Here is the beginning of a character that can have
3703 * an extender. It is either a hangul syllable, or a
3704 * non-control */
3705 if (swash_fetch(PL_utf8_X_non_hangul,
f2ed9b32 3706 (U8*)locinput, utf8_target))
37e2e78e
KW		 3707 {
3708
3709 /* Here not a Hangul syllable, must be a
3710 * ('! * Control') */
3711 locinput += UTF8SKIP(locinput);
3712 } else {
3713
3714 /* Here is a Hangul syllable. It can be composed
3715 * of several individual characters. One
3716 * possibility is T+ */
3717 if (swash_fetch(PL_utf8_X_T,
f2ed9b32 3718 (U8*)locinput, utf8_target))
37e2e78e
KW		 3719 {
3720 while (locinput < PL_regeol
3721 && swash_fetch(PL_utf8_X_T,
f2ed9b32 3722 (U8*)locinput, utf8_target))
37e2e78e
KW		 3723 {
3724 locinput += UTF8SKIP(locinput);
3725 }
3726 } else {
3727
3728 /* Here, not T+, but is a Hangul. That means
3729 * it is one of the others: L, LV, LVT or V,
3730 * and matches:
3731 * L* (L | LVT T* | V V* T* | LV V* T*) */
3732
3733 /* Match L* */
3734 while (locinput < PL_regeol
3735 && swash_fetch(PL_utf8_X_L,
f2ed9b32 3736 (U8*)locinput, utf8_target))
37e2e78e
KW		 3737 {
3738 locinput += UTF8SKIP(locinput);
3739 }
3740
3741 /* Here, have exhausted L*. If the next
3742 * character is not an LV, LVT nor V, it means
3743 * we had to have at least one L, so matches L+
3744 * in the original equation, we have a complete
3745 * hangul syllable. Are done. */
3746
3747 if (locinput < PL_regeol
3748 && swash_fetch(PL_utf8_X_LV_LVT_V,
f2ed9b32 3749 (U8*)locinput, utf8_target))
37e2e78e
KW		 3750 {
3751
3752 /* Otherwise keep going. Must be LV, LVT
3753 * or V. See if LVT */
3754 if (swash_fetch(PL_utf8_X_LVT,
f2ed9b32 3755 (U8*)locinput, utf8_target))
37e2e78e
KW		 3756 {
3757 locinput += UTF8SKIP(locinput);
3758 } else {
3759
3760 /* Must be V or LV. Take it, then
3761 * match V* */
3762 locinput += UTF8SKIP(locinput);
3763 while (locinput < PL_regeol
3764 && swash_fetch(PL_utf8_X_V,
f2ed9b32 3765 (U8*)locinput, utf8_target))
37e2e78e
KW		 3766 {
3767 locinput += UTF8SKIP(locinput);
3768 }
3769 }
3770
3771 /* And any of LV, LVT, or V can be followed
3772 * by T* */
3773 while (locinput < PL_regeol
3774 && swash_fetch(PL_utf8_X_T,
3775 (U8*)locinput,
f2ed9b32 3776 utf8_target))
37e2e78e
KW		 3777 {
3778 locinput += UTF8SKIP(locinput);
3779 }
3780 }
3781 }
3782 }
3783
3784 /* Match any extender */
3785 while (locinput < PL_regeol
3786 && swash_fetch(PL_utf8_X_extend,
f2ed9b32 3787 (U8*)locinput, utf8_target))
37e2e78e
KW		 3788 {
3789 locinput += UTF8SKIP(locinput);
3790 }
3791 }
3792 }
3793 if (locinput > PL_regeol) sayNO;
3794 }
a0ed51b3
LW		 3795 nextchr = UCHARAT(locinput);
3796 break;
81714fb9
YO		 3797
3798 case NREFFL:
3799 {
3800 char *s;
ff1157ca 3801 char type;
81714fb9
YO		 3802 PL_reg_flags |= RF_tainted;
3803 /* FALL THROUGH */
3804 case NREF:
3805 case NREFF:
ff1157ca 3806 type = OP(scan);
0a4db386
YO		 3807 n = reg_check_named_buff_matched(rex,scan);
3808
3809 if ( n ) {
3810 type = REF + ( type - NREF );
3811 goto do_ref;
3812 } else {
81714fb9 3813 sayNO;
0a4db386
YO		 3814 }
3815 /* unreached */
c8756f30 3816 case REFFL:
3280af22 3817 PL_reg_flags |= RF_tainted;
c8756f30 3818 /* FALL THROUGH */
c277df42 3819 case REF:
81714fb9 3820 case REFF:
c277df42 3821 n = ARG(scan); /* which paren pair */
81714fb9
YO		 3822 type = OP(scan);
3823 do_ref:
f0ab9afb 3824 ln = PL_regoffs[n].start;
2c2d71f5 3825 PL_reg_leftiter = PL_reg_maxiter; /* Void cache */
3b6647e0 3826 if (*PL_reglastparen < n || ln == -1)
af3f8c16 3827 sayNO; /* Do not match unless seen CLOSEn. */
f0ab9afb 3828 if (ln == PL_regoffs[n].end)
a0d0e21e 3829 break;
a0ed51b3 3830
24d3c4a9 3831 s = PL_bostr + ln;
f2ed9b32 3832 if (utf8_target && type != REF) { /* REF can do byte comparison */
a0ed51b3 3833 char *l = locinput;
f0ab9afb 3834 const char *e = PL_bostr + PL_regoffs[n].end;
a0ed51b3
LW		 3835 /*
3836 * Note that we can't do the "other character" lookup trick as
3837 * in the 8-bit case (no pun intended) because in Unicode we
3838 * have to map both upper and title case to lower case.
3839 */
81714fb9 3840 if (type == REFF) {
a0ed51b3 3841 while (s < e) {
a3b680e6
AL		 3842 STRLEN ulen1, ulen2;
3843 U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
3844 U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
3845
a0ed51b3
LW		 3846 if (l >= PL_regeol)
3847 sayNO;
a2a2844f
JH		 3848 toLOWER_utf8((U8*)s, tmpbuf1, &ulen1);
3849 toLOWER_utf8((U8*)l, tmpbuf2, &ulen2);
7114a2d2 3850 if (ulen1 != ulen2 || memNE((char *)tmpbuf1, (char *)tmpbuf2, ulen1))
a0ed51b3 3851 sayNO;
a2a2844f
JH		 3852 s += ulen1;
3853 l += ulen2;
a0ed51b3
LW		 3854 }
3855 }
3856 locinput = l;
3857 nextchr = UCHARAT(locinput);
3858 break;
3859 }
3860
a0d0e21e 3861 /* Inline the first character, for speed. */
76e3520e 3862 if (UCHARAT(s) != nextchr &&
81714fb9
YO		 3863 (type == REF ||
3864 (UCHARAT(s) != (type == REFF
3865 ? PL_fold : PL_fold_locale)[nextchr])))
4633a7c4 3866 sayNO;
f0ab9afb 3867 ln = PL_regoffs[n].end - ln;
24d3c4a9 3868 if (locinput + ln > PL_regeol)
4633a7c4 3869 sayNO;
81714fb9 3870 if (ln > 1 && (type == REF
24d3c4a9 3871 ? memNE(s, locinput, ln)
81714fb9 3872 : (type == REFF
4c1b470c
KW		 3873 ? ! foldEQ(s, locinput, ln)
3874 : ! foldEQ_locale(s, locinput, ln))))
4633a7c4 3875 sayNO;
24d3c4a9 3876 locinput += ln;
76e3520e 3877 nextchr = UCHARAT(locinput);
a0d0e21e 3878 break;
81714fb9 3879 }
a0d0e21e 3880 case NOTHING:
c277df42 3881 case TAIL:
a0d0e21e
LW		 3882 break;
3883 case BACK:
3884 break;
40a82448
DM		 3885
3886#undef ST
3887#define ST st->u.eval
c277df42 3888 {
c277df42 3889 SV *ret;
d2f13c59 3890 REGEXP *re_sv;
6bda09f9 3891 regexp *re;
f8fc2ecf 3892 regexp_internal *rei;
1a147d38
YO		 3893 regnode *startpoint;
3894
3895 case GOSTART:
e7707071
YO		 3896 case GOSUB: /* /(...(?1))/ /(...(?&foo))/ */
3897 if (cur_eval && cur_eval->locinput==locinput) {
24b23f37 3898 if (cur_eval->u.eval.close_paren == (U32)ARG(scan))
1a147d38 3899 Perl_croak(aTHX_ "Infinite recursion in regex");
4b196cd4 3900 if ( ++nochange_depth > max_nochange_depth )
1a147d38
YO		 3901 Perl_croak(aTHX_
3902 "Pattern subroutine nesting without pos change"
3903 " exceeded limit in regex");
6bda09f9
YO		 3904 } else {
3905 nochange_depth = 0;
1a147d38 3906 }
288b8c02 3907 re_sv = rex_sv;
6bda09f9 3908 re = rex;
f8fc2ecf 3909 rei = rexi;
288b8c02 3910 (void)ReREFCNT_inc(rex_sv);
1a147d38 3911 if (OP(scan)==GOSUB) {
6bda09f9
YO		 3912 startpoint = scan + ARG2L(scan);
3913 ST.close_paren = ARG(scan);
3914 } else {
f8fc2ecf 3915 startpoint = rei->program+1;
6bda09f9
YO		 3916 ST.close_paren = 0;
3917 }
3918 goto eval_recurse_doit;
3919 /* NOTREACHED */
3920 case EVAL: /* /(?{A})B/ /(??{A})B/ and /(?(?{A})X|Y)B/ */
3921 if (cur_eval && cur_eval->locinput==locinput) {
4b196cd4 3922 if ( ++nochange_depth > max_nochange_depth )
1a147d38 3923 Perl_croak(aTHX_ "EVAL without pos change exceeded limit in regex");
6bda09f9
YO		 3924 } else {
3925 nochange_depth = 0;
3926 }
8e5e9ebe 3927 {
4aabdb9b
DM		 3928 /* execute the code in the {...} */
3929 dSP;
6136c704 3930 SV ** const before = SP;
4aabdb9b
DM		 3931 OP_4tree * const oop = PL_op;
3932 COP * const ocurcop = PL_curcop;
3933 PAD *old_comppad;
d80618d2 3934 char *saved_regeol = PL_regeol;
4aabdb9b
DM		 3935
3936 n = ARG(scan);
f8fc2ecf 3937 PL_op = (OP_4tree*)rexi->data->data[n];
24b23f37
YO		 3938 DEBUG_STATE_r( PerlIO_printf(Perl_debug_log,
3939 " re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
f8fc2ecf 3940 PAD_SAVE_LOCAL(old_comppad, (PAD*)rexi->data->data[n + 2]);
f0ab9afb 3941 PL_regoffs[0].end = PL_reg_magic->mg_len = locinput - PL_bostr;
4aabdb9b 3942
2bf803e2
YO		 3943 if (sv_yes_mark) {
3944 SV *sv_mrk = get_sv("REGMARK", 1);
3945 sv_setsv(sv_mrk, sv_yes_mark);
3946 }
3947
8e5e9ebe
RGS		 3948 CALLRUNOPS(aTHX); /* Scalar context. */
3949 SPAGAIN;
3950 if (SP == before)
075aa684 3951 ret = &PL_sv_undef; /* protect against empty (?{}) blocks. */
8e5e9ebe
RGS		 3952 else {
3953 ret = POPs;
3954 PUTBACK;
3955 }
4aabdb9b
DM		 3956
3957 PL_op = oop;
3958 PAD_RESTORE_LOCAL(old_comppad);
3959 PL_curcop = ocurcop;
d80618d2 3960 PL_regeol = saved_regeol;
24d3c4a9 3961 if (!logical) {
4aabdb9b
DM		 3962 /* /(?{...})/ */
3963 sv_setsv(save_scalar(PL_replgv), ret);
4aabdb9b
DM		 3964 break;
3965 }
8e5e9ebe 3966 }
24d3c4a9
DM		 3967 if (logical == 2) { /* Postponed subexpression: /(??{...})/ */
3968 logical = 0;
4aabdb9b 3969 {
4f639d21
DM		 3970 /* extract RE object from returned value; compiling if
3971 * necessary */
6136c704 3972 MAGIC *mg = NULL;
288b8c02 3973 REGEXP *rx = NULL;
5c35adbb
NC		 3974
3975 if (SvROK(ret)) {
288b8c02 3976 SV *const sv = SvRV(ret);
5c35adbb
NC		 3977
3978 if (SvTYPE(sv) == SVt_REGEXP) {
d2f13c59 3979 rx = (REGEXP*) sv;
5c35adbb
NC		 3980 } else if (SvSMAGICAL(sv)) {
3981 mg = mg_find(sv, PERL_MAGIC_qr);
3982 assert(mg);
3983 }
3984 } else if (SvTYPE(ret) == SVt_REGEXP) {
d2f13c59 3985 rx = (REGEXP*) ret;
5c35adbb 3986 } else if (SvSMAGICAL(ret)) {
124ee91a
NC		 3987 if (SvGMAGICAL(ret)) {
3988 /* I don't believe that there is ever qr magic
3989 here. */
3990 assert(!mg_find(ret, PERL_MAGIC_qr));
faf82a0b 3991 sv_unmagic(ret, PERL_MAGIC_qr);
124ee91a
NC		 3992 }
3993 else {
faf82a0b 3994 mg = mg_find(ret, PERL_MAGIC_qr);
124ee91a
NC		 3995 /* testing suggests mg only ends up non-NULL for
3996 scalars who were upgraded and compiled in the
3997 else block below. In turn, this is only
3998 triggered in the "postponed utf8 string" tests
3999 in t/op/pat.t */
4000 }
0f5d15d6 4001 }
faf82a0b 4002
0f5d15d6 4003 if (mg) {
d2f13c59 4004 rx = (REGEXP *) mg->mg_obj; /*XXX:dmq*/
e2560c33 4005 assert(rx);
0f5d15d6 4006 }
288b8c02 4007 if (rx) {
f0826785 4008 rx = reg_temp_copy(NULL, rx);
288b8c02 4009 }
0f5d15d6 4010 else {
c737faaf 4011 U32 pm_flags = 0;
a3b680e6 4012 const I32 osize = PL_regsize;
0f5d15d6 4013
b9ad30b4
NC		 4014 if (DO_UTF8(ret)) {
4015 assert (SvUTF8(ret));
4016 } else if (SvUTF8(ret)) {
4017 /* Not doing UTF-8, despite what the SV says. Is
4018 this only if we're trapped in use 'bytes'? */
4019 /* Make a copy of the octet sequence, but without
4020 the flag on, as the compiler now honours the
4021 SvUTF8 flag on ret. */
4022 STRLEN len;
4023 const char *const p = SvPV(ret, len);
4024 ret = newSVpvn_flags(p, len, SVs_TEMP);
4025 }
288b8c02 4026 rx = CALLREGCOMP(ret, pm_flags);
9041c2e3 4027 if (!(SvFLAGS(ret)
faf82a0b 4028 & (SVs_TEMP | SVs_PADTMP | SVf_READONLY
3ce3ed55 4029 | SVs_GMG))) {
a2794585
NC		 4030 /* This isn't a first class regexp. Instead, it's
4031 caching a regexp onto an existing, Perl visible
4032 scalar. */
ad64d0ec 4033 sv_magic(ret, MUTABLE_SV(rx), PERL_MAGIC_qr, 0, 0);
3ce3ed55 4034 }
0f5d15d6 4035 PL_regsize = osize;
0f5d15d6 4036 }
288b8c02
NC		 4037 re_sv = rx;
4038 re = (struct regexp *)SvANY(rx);
4aabdb9b 4039 }
07bc277f 4040 RXp_MATCH_COPIED_off(re);
28d8d7f4
YO		 4041 re->subbeg = rex->subbeg;
4042 re->sublen = rex->sublen;
f8fc2ecf 4043 rei = RXi_GET(re);
6bda09f9 4044 DEBUG_EXECUTE_r(
f2ed9b32 4045 debug_start_match(re_sv, utf8_target, locinput, PL_regeol,
6bda09f9
YO		 4046 "Matching embedded");
4047 );
f8fc2ecf 4048 startpoint = rei->program + 1;
1a147d38 4049 ST.close_paren = 0; /* only used for GOSUB */
6bda09f9
YO		 4050 /* borrowed from regtry */
4051 if (PL_reg_start_tmpl <= re->nparens) {
4052 PL_reg_start_tmpl = re->nparens*3/2 + 3;
4053 if(PL_reg_start_tmp)
4054 Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
4055 else
4056 Newx(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
dd5def09 4057 }
aa283a38 4058
1a147d38 4059 eval_recurse_doit: /* Share code with GOSUB below this line */
aa283a38 4060 /* run the pattern returned from (??{...}) */
40a82448
DM		 4061 ST.cp = regcppush(0); /* Save *all* the positions. */
4062 REGCP_SET(ST.lastcp);
6bda09f9 4063
f0ab9afb 4064 PL_regoffs = re->offs; /* essentially NOOP on GOSUB */
6bda09f9 4065
0357f1fd
ML		 4066 /* see regtry, specifically PL_reglast(?:close)?paren is a pointer! (i dont know why) :dmq */
4067 PL_reglastparen = &re->lastparen;
4068 PL_reglastcloseparen = &re->lastcloseparen;
4069 re->lastparen = 0;
4070 re->lastcloseparen = 0;
4071
4aabdb9b 4072 PL_reginput = locinput;
ae0beba1 4073 PL_regsize = 0;
4aabdb9b
DM		 4074
4075 /* XXXX This is too dramatic a measure... */
4076 PL_reg_maxiter = 0;
4077
faec1544 4078 ST.toggle_reg_flags = PL_reg_flags;
3c8556c3 4079 if (RX_UTF8(re_sv))
faec1544
DM		 4080 PL_reg_flags |= RF_utf8;
4081 else
4082 PL_reg_flags &= ~RF_utf8;
4083 ST.toggle_reg_flags ^= PL_reg_flags; /* diff of old and new */
4084
288b8c02 4085 ST.prev_rex = rex_sv;
faec1544 4086 ST.prev_curlyx = cur_curlyx;
288b8c02
NC		 4087 SETREX(rex_sv,re_sv);
4088 rex = re;
f8fc2ecf 4089 rexi = rei;
faec1544 4090 cur_curlyx = NULL;
40a82448 4091 ST.B = next;
faec1544
DM		 4092 ST.prev_eval = cur_eval;
4093 cur_eval = st;
faec1544 4094 /* now continue from first node in postoned RE */
6bda09f9 4095 PUSH_YES_STATE_GOTO(EVAL_AB, startpoint);
4aabdb9b 4096 /* NOTREACHED */
a0ed51b3 4097 }
24d3c4a9 4098 /* logical is 1, /(?(?{...})X|Y)/ */
f2338a2e 4099 sw = cBOOL(SvTRUE(ret));
24d3c4a9 4100 logical = 0;
c277df42
IZ		 4101 break;
4102 }
40a82448 4103
faec1544
DM		 4104 case EVAL_AB: /* cleanup after a successful (??{A})B */
4105 /* note: this is called twice; first after popping B, then A */
4106 PL_reg_flags ^= ST.toggle_reg_flags;
288b8c02
NC		 4107 ReREFCNT_dec(rex_sv);
4108 SETREX(rex_sv,ST.prev_rex);
4109 rex = (struct regexp *)SvANY(rex_sv);
f8fc2ecf 4110 rexi = RXi_GET(rex);
faec1544
DM		 4111 regcpblow(ST.cp);
4112 cur_eval = ST.prev_eval;
4113 cur_curlyx = ST.prev_curlyx;
34a81e2b
B		 4114
4115 /* rex was changed so update the pointer in PL_reglastparen and PL_reglastcloseparen */
0357f1fd
ML		 4116 PL_reglastparen = &rex->lastparen;
4117 PL_reglastcloseparen = &rex->lastcloseparen;
34a81e2b
B		 4118 /* also update PL_regoffs */
4119 PL_regoffs = rex->offs;
0357f1fd 4120
40a82448
DM		 4121 /* XXXX This is too dramatic a measure... */
4122 PL_reg_maxiter = 0;
e7707071 4123 if ( nochange_depth )
4b196cd4 4124 nochange_depth--;
262b90c4 4125 sayYES;
40a82448 4126
40a82448 4127
faec1544
DM		 4128 case EVAL_AB_fail: /* unsuccessfully ran A or B in (??{A})B */
4129 /* note: this is called twice; first after popping B, then A */
4130 PL_reg_flags ^= ST.toggle_reg_flags;
288b8c02
NC		 4131 ReREFCNT_dec(rex_sv);
4132 SETREX(rex_sv,ST.prev_rex);
4133 rex = (struct regexp *)SvANY(rex_sv);
f8fc2ecf 4134 rexi = RXi_GET(rex);
34a81e2b 4135 /* rex was changed so update the pointer in PL_reglastparen and PL_reglastcloseparen */
0357f1fd
ML		 4136 PL_reglastparen = &rex->lastparen;
4137 PL_reglastcloseparen = &rex->lastcloseparen;
4138
40a82448
DM		 4139 PL_reginput = locinput;
4140 REGCP_UNWIND(ST.lastcp);
4141 regcppop(rex);
faec1544
DM		 4142 cur_eval = ST.prev_eval;
4143 cur_curlyx = ST.prev_curlyx;
4144 /* XXXX This is too dramatic a measure... */
4145 PL_reg_maxiter = 0;
e7707071 4146 if ( nochange_depth )
4b196cd4 4147 nochange_depth--;
40a82448 4148 sayNO_SILENT;
40a82448
DM		 4149#undef ST
4150
a0d0e21e 4151 case OPEN:
c277df42 4152 n = ARG(scan); /* which paren pair */
3280af22
NIS		 4153 PL_reg_start_tmp[n] = locinput;
4154 if (n > PL_regsize)
4155 PL_regsize = n;
e2e6a0f1 4156 lastopen = n;
a0d0e21e
LW		 4157 break;
4158 case CLOSE:
c277df42 4159 n = ARG(scan); /* which paren pair */
f0ab9afb
NC		 4160 PL_regoffs[n].start = PL_reg_start_tmp[n] - PL_bostr;
4161 PL_regoffs[n].end = locinput - PL_bostr;
7f69552c
YO		 4162 /*if (n > PL_regsize)
4163 PL_regsize = n;*/
3b6647e0 4164 if (n > *PL_reglastparen)
3280af22 4165 *PL_reglastparen = n;
a01268b5 4166 *PL_reglastcloseparen = n;
3b6647e0 4167 if (cur_eval && cur_eval->u.eval.close_paren == n) {
6bda09f9
YO		 4168 goto fake_end;
4169 }
a0d0e21e 4170 break;
e2e6a0f1
YO		 4171 case ACCEPT:
4172 if (ARG(scan)){
4173 regnode *cursor;
4174 for (cursor=scan;
4175 cursor && OP(cursor)!=END;
4176 cursor=regnext(cursor))
4177 {
4178 if ( OP(cursor)==CLOSE ){
4179 n = ARG(cursor);
4180 if ( n <= lastopen ) {
f0ab9afb
NC		 4181 PL_regoffs[n].start
4182 = PL_reg_start_tmp[n] - PL_bostr;
4183 PL_regoffs[n].end = locinput - PL_bostr;
e2e6a0f1
YO		 4184 /*if (n > PL_regsize)
4185 PL_regsize = n;*/
3b6647e0 4186 if (n > *PL_reglastparen)
e2e6a0f1
YO		 4187 *PL_reglastparen = n;
4188 *PL_reglastcloseparen = n;
3b6647e0
RB		 4189 if ( n == ARG(scan) || (cur_eval &&
4190 cur_eval->u.eval.close_paren == n))
e2e6a0f1
YO		 4191 break;
4192 }
4193 }
4194 }
4195 }
4196 goto fake_end;
4197 /*NOTREACHED*/
c277df42
IZ		 4198 case GROUPP:
4199 n = ARG(scan); /* which paren pair */
f2338a2e 4200 sw = cBOOL(*PL_reglastparen >= n && PL_regoffs[n].end != -1);
c277df42 4201 break;
0a4db386
YO		 4202 case NGROUPP:
4203 /* reg_check_named_buff_matched returns 0 for no match */
f2338a2e 4204 sw = cBOOL(0 < reg_check_named_buff_matched(rex,scan));
0a4db386 4205 break;
1a147d38 4206 case INSUBP:
0a4db386 4207 n = ARG(scan);
3b6647e0 4208 sw = (cur_eval && (!n || cur_eval->u.eval.close_paren == n));
0a4db386
YO		 4209 break;
4210 case DEFINEP:
4211 sw = 0;
4212 break;
c277df42 4213 case IFTHEN:
2c2d71f5 4214 PL_reg_leftiter = PL_reg_maxiter; /* Void cache */
24d3c4a9 4215 if (sw)
c277df42
IZ		 4216 next = NEXTOPER(NEXTOPER(scan));
4217 else {
4218 next = scan + ARG(scan);
4219 if (OP(next) == IFTHEN) /* Fake one. */
4220 next = NEXTOPER(NEXTOPER(next));
4221 }
4222 break;
4223 case LOGICAL:
24d3c4a9 4224 logical = scan->flags;
c277df42 4225 break;
c476f425 4226
2ab05381 4227/*******************************************************************
2ab05381 4228
c476f425
DM		 4229The CURLYX/WHILEM pair of ops handle the most generic case of the /A*B/
4230pattern, where A and B are subpatterns. (For simple A, CURLYM or
4231STAR/PLUS/CURLY/CURLYN are used instead.)
2ab05381 4232
c476f425 4233A*B is compiled as <CURLYX><A><WHILEM><B>
2ab05381 4234
c476f425
DM		 4235On entry to the subpattern, CURLYX is called. This pushes a CURLYX
4236state, which contains the current count, initialised to -1. It also sets
4237cur_curlyx to point to this state, with any previous value saved in the
4238state block.
2ab05381 4239
c476f425
DM		 4240CURLYX then jumps straight to the WHILEM op, rather than executing A,
4241since the pattern may possibly match zero times (i.e. it's a while {} loop
4242rather than a do {} while loop).
2ab05381 4243
c476f425
DM		 4244Each entry to WHILEM represents a successful match of A. The count in the
4245CURLYX block is incremented, another WHILEM state is pushed, and execution
4246passes to A or B depending on greediness and the current count.
2ab05381 4247
c476f425
DM		 4248For example, if matching against the string a1a2a3b (where the aN are
4249substrings that match /A/), then the match progresses as follows: (the
4250pushed states are interspersed with the bits of strings matched so far):
2ab05381 4251
c476f425
DM		 4252 <CURLYX cnt=-1>
4253 <CURLYX cnt=0><WHILEM>
4254 <CURLYX cnt=1><WHILEM> a1 <WHILEM>
4255 <CURLYX cnt=2><WHILEM> a1 <WHILEM> a2 <WHILEM>
4256 <CURLYX cnt=3><WHILEM> a1 <WHILEM> a2 <WHILEM> a3 <WHILEM>
4257 <CURLYX cnt=3><WHILEM> a1 <WHILEM> a2 <WHILEM> a3 <WHILEM> b
2ab05381 4258
c476f425
DM		 4259(Contrast this with something like CURLYM, which maintains only a single
4260backtrack state:
2ab05381 4261
c476f425
DM		 4262 <CURLYM cnt=0> a1
4263 a1 <CURLYM cnt=1> a2
4264 a1 a2 <CURLYM cnt=2> a3
4265 a1 a2 a3 <CURLYM cnt=3> b
4266)
2ab05381 4267
c476f425
DM		 4268Each WHILEM state block marks a point to backtrack to upon partial failure
4269of A or B, and also contains some minor state data related to that
4270iteration. The CURLYX block, pointed to by cur_curlyx, contains the
4271overall state, such as the count, and pointers to the A and B ops.
2ab05381 4272
c476f425
DM		 4273This is complicated slightly by nested CURLYX/WHILEM's. Since cur_curlyx
4274must always point to the *current* CURLYX block, the rules are:
2ab05381 4275
c476f425
DM		 4276When executing CURLYX, save the old cur_curlyx in the CURLYX state block,
4277and set cur_curlyx to point the new block.
2ab05381 4278
c476f425
DM		 4279When popping the CURLYX block after a successful or unsuccessful match,
4280restore the previous cur_curlyx.
2ab05381 4281
c476f425
DM		 4282When WHILEM is about to execute B, save the current cur_curlyx, and set it
4283to the outer one saved in the CURLYX block.
2ab05381 4284
c476f425
DM		 4285When popping the WHILEM block after a successful or unsuccessful B match,
4286restore the previous cur_curlyx.
2ab05381 4287
c476f425
DM		 4288Here's an example for the pattern (AI* BI)*BO
4289I and O refer to inner and outer, C and W refer to CURLYX and WHILEM:
2ab05381 4290
c476f425
DM		 4291cur_
4292curlyx backtrack stack
4293------ ---------------
4294NULL
4295CO <CO prev=NULL> <WO>
4296CI <CO prev=NULL> <WO> <CI prev=CO> <WI> ai
4297CO <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi
4298NULL <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi <WO prev=CO> bo
2ab05381 4299
c476f425
DM		 4300At this point the pattern succeeds, and we work back down the stack to
4301clean up, restoring as we go:
95b24440 4302
c476f425
DM		 4303CO <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi
4304CI <CO prev=NULL> <WO> <CI prev=CO> <WI> ai
4305CO <CO prev=NULL> <WO>
4306NULL
a0374537 4307
c476f425
DM		 4308*******************************************************************/
4309
4310#define ST st->u.curlyx
4311
4312 case CURLYX: /* start of /A*B/ (for complex A) */
4313 {
4314 /* No need to save/restore up to this paren */
4315 I32 parenfloor = scan->flags;
4316
4317 assert(next); /* keep Coverity happy */
4318 if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
4319 next += ARG(next);
4320
4321 /* XXXX Probably it is better to teach regpush to support
4322 parenfloor > PL_regsize... */
4323 if (parenfloor > (I32)*PL_reglastparen)
4324 parenfloor = *PL_reglastparen; /* Pessimization... */
4325
4326 ST.prev_curlyx= cur_curlyx;
4327 cur_curlyx = st;
4328 ST.cp = PL_savestack_ix;
4329
4330 /* these fields contain the state of the current curly.
4331 * they are accessed by subsequent WHILEMs */
4332 ST.parenfloor = parenfloor;
d02d6d97 4333 ST.me = scan;
c476f425 4334 ST.B = next;
24d3c4a9
DM		 4335 ST.minmod = minmod;
4336 minmod = 0;
c476f425
DM		 4337 ST.count = -1; /* this will be updated by WHILEM */
4338 ST.lastloc = NULL; /* this will be updated by WHILEM */
4339
4340 PL_reginput = locinput;
4341 PUSH_YES_STATE_GOTO(CURLYX_end, PREVOPER(next));
5f66b61c 4342 /* NOTREACHED */
c476f425 4343 }
a0d0e21e 4344
c476f425 4345 case CURLYX_end: /* just finished matching all of A*B */
c476f425
DM		 4346 cur_curlyx = ST.prev_curlyx;
4347 sayYES;
4348 /* NOTREACHED */
a0d0e21e 4349
c476f425
DM		 4350 case CURLYX_end_fail: /* just failed to match all of A*B */
4351 regcpblow(ST.cp);
4352 cur_curlyx = ST.prev_curlyx;
4353 sayNO;
4354 /* NOTREACHED */
4633a7c4 4355
a0d0e21e 4356
c476f425
DM		 4357#undef ST
4358#define ST st->u.whilem
4359
4360 case WHILEM: /* just matched an A in /A*B/ (for complex A) */
4361 {
4362 /* see the discussion above about CURLYX/WHILEM */
c476f425 4363 I32 n;
d02d6d97
DM		 4364 int min = ARG1(cur_curlyx->u.curlyx.me);
4365 int max = ARG2(cur_curlyx->u.curlyx.me);
4366 regnode *A = NEXTOPER(cur_curlyx->u.curlyx.me) + EXTRA_STEP_2ARGS;
4367
c476f425
DM		 4368 assert(cur_curlyx); /* keep Coverity happy */
4369 n = ++cur_curlyx->u.curlyx.count; /* how many A's matched */
4370 ST.save_lastloc = cur_curlyx->u.curlyx.lastloc;
4371 ST.cache_offset = 0;
4372 ST.cache_mask = 0;
4373
4374 PL_reginput = locinput;
4375
4376 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
d02d6d97
DM		 4377 "%*s whilem: matched %ld out of %d..%d\n",
4378 REPORT_CODE_OFF+depth*2, "", (long)n, min, max)
c476f425 4379 );
a0d0e21e 4380
c476f425 4381 /* First just match a string of min A's. */
a0d0e21e 4382
d02d6d97 4383 if (n < min) {
c476f425 4384 cur_curlyx->u.curlyx.lastloc = locinput;
d02d6d97 4385 PUSH_STATE_GOTO(WHILEM_A_pre, A);
c476f425
DM		 4386 /* NOTREACHED */
4387 }
4388
4389 /* If degenerate A matches "", assume A done. */
4390
4391 if (locinput == cur_curlyx->u.curlyx.lastloc) {
4392 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4393 "%*s whilem: empty match detected, trying continuation...\n",
4394 REPORT_CODE_OFF+depth*2, "")
4395 );
4396 goto do_whilem_B_max;
4397 }
4398
4399 /* super-linear cache processing */
4400
4401 if (scan->flags) {
a0d0e21e 4402
2c2d71f5 4403 if (!PL_reg_maxiter) {
c476f425
DM		 4404 /* start the countdown: Postpone detection until we
4405 * know the match is not *that* much linear. */
2c2d71f5 4406 PL_reg_maxiter = (PL_regeol - PL_bostr + 1) * (scan->flags>>4);
66bf836d
DM		 4407 /* possible overflow for long strings and many CURLYX's */
4408 if (PL_reg_maxiter < 0)
4409 PL_reg_maxiter = I32_MAX;
2c2d71f5
JH		 4410 PL_reg_leftiter = PL_reg_maxiter;
4411 }
c476f425 4412
2c2d71f5 4413 if (PL_reg_leftiter-- == 0) {
c476f425 4414 /* initialise cache */
3298f257 4415 const I32 size = (PL_reg_maxiter + 7)/8;
2c2d71f5 4416 if (PL_reg_poscache) {
eb160463 4417 if ((I32)PL_reg_poscache_size < size) {
2c2d71f5
JH		 4418 Renew(PL_reg_poscache, size, char);
4419 PL_reg_poscache_size = size;
4420 }
4421 Zero(PL_reg_poscache, size, char);
4422 }
4423 else {
4424 PL_reg_poscache_size = size;
a02a5408 4425 Newxz(PL_reg_poscache, size, char);
2c2d71f5 4426 }
c476f425
DM		 4427 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4428 "%swhilem: Detected a super-linear match, switching on caching%s...\n",
4429 PL_colors[4], PL_colors[5])
4430 );
2c2d71f5 4431 }
c476f425 4432
2c2d71f5 4433 if (PL_reg_leftiter < 0) {
c476f425
DM		 4434 /* have we already failed at this position? */
4435 I32 offset, mask;
4436 offset = (scan->flags & 0xf) - 1
4437 + (locinput - PL_bostr) * (scan->flags>>4);
4438 mask = 1 << (offset % 8);
4439 offset /= 8;
4440 if (PL_reg_poscache[offset] & mask) {
4441 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4442 "%*s whilem: (cache) already tried at this position...\n",
4443 REPORT_CODE_OFF+depth*2, "")
2c2d71f5 4444 );
3298f257 4445 sayNO; /* cache records failure */
2c2d71f5 4446 }
c476f425
DM		 4447 ST.cache_offset = offset;
4448 ST.cache_mask = mask;
2c2d71f5 4449 }
c476f425 4450 }
2c2d71f5 4451
c476f425 4452 /* Prefer B over A for minimal matching. */
a687059c 4453
c476f425
DM		 4454 if (cur_curlyx->u.curlyx.minmod) {
4455 ST.save_curlyx = cur_curlyx;
4456 cur_curlyx = cur_curlyx->u.curlyx.prev_curlyx;
4457 ST.cp = regcppush(ST.save_curlyx->u.curlyx.parenfloor);
4458 REGCP_SET(ST.lastcp);
4459 PUSH_YES_STATE_GOTO(WHILEM_B_min, ST.save_curlyx->u.curlyx.B);
4460 /* NOTREACHED */
4461 }
a0d0e21e 4462
c476f425
DM		 4463 /* Prefer A over B for maximal matching. */
4464
d02d6d97 4465 if (n < max) { /* More greed allowed? */
c476f425
DM		 4466 ST.cp = regcppush(cur_curlyx->u.curlyx.parenfloor);
4467 cur_curlyx->u.curlyx.lastloc = locinput;
4468 REGCP_SET(ST.lastcp);
d02d6d97 4469 PUSH_STATE_GOTO(WHILEM_A_max, A);
c476f425
DM		 4470 /* NOTREACHED */
4471 }
4472 goto do_whilem_B_max;
4473 }
4474 /* NOTREACHED */
4475
4476 case WHILEM_B_min: /* just matched B in a minimal match */
4477 case WHILEM_B_max: /* just matched B in a maximal match */
4478 cur_curlyx = ST.save_curlyx;
4479 sayYES;
4480 /* NOTREACHED */
4481
4482 case WHILEM_B_max_fail: /* just failed to match B in a maximal match */
4483 cur_curlyx = ST.save_curlyx;
4484 cur_curlyx->u.curlyx.lastloc = ST.save_lastloc;
4485 cur_curlyx->u.curlyx.count--;
4486 CACHEsayNO;
4487 /* NOTREACHED */
4488
4489 case WHILEM_A_min_fail: /* just failed to match A in a minimal match */
4490 REGCP_UNWIND(ST.lastcp);
4491 regcppop(rex);
4492 /* FALL THROUGH */
4493 case WHILEM_A_pre_fail: /* just failed to match even minimal A */
4494 cur_curlyx->u.curlyx.lastloc = ST.save_lastloc;
4495 cur_curlyx->u.curlyx.count--;
4496 CACHEsayNO;
4497 /* NOTREACHED */
4498
4499 case WHILEM_A_max_fail: /* just failed to match A in a maximal match */
4500 REGCP_UNWIND(ST.lastcp);
4501 regcppop(rex); /* Restore some previous $<digit>s? */
4502 PL_reginput = locinput;
4503 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
4504 "%*s whilem: failed, trying continuation...\n",
4505 REPORT_CODE_OFF+depth*2, "")
4506 );
4507 do_whilem_B_max:
4508 if (cur_curlyx->u.curlyx.count >= REG_INFTY
4509 && ckWARN(WARN_REGEXP)
4510 && !(PL_reg_flags & RF_warned))
4511 {
4512 PL_reg_flags |= RF_warned;
4513 Perl_warner(aTHX_ packWARN(WARN_REGEXP), "%s limit (%d) exceeded",
4514 "Complex regular subexpression recursion",
4515 REG_INFTY - 1);
4516 }
4517
4518 /* now try B */
4519 ST.save_curlyx = cur_curlyx;
4520 cur_curlyx = cur_curlyx->u.curlyx.prev_curlyx;
4521 PUSH_YES_STATE_GOTO(WHILEM_B_max, ST.save_curlyx->u.curlyx.B);
4522 /* NOTREACHED */
4523
4524 case WHILEM_B_min_fail: /* just failed to match B in a minimal match */
4525 cur_curlyx = ST.save_curlyx;
4526 REGCP_UNWIND(ST.lastcp);
4527 regcppop(rex);
4528
d02d6d97 4529 if (cur_curlyx->u.curlyx.count >= /*max*/ARG2(cur_curlyx->u.curlyx.me)) {
c476f425
DM		 4530 /* Maximum greed exceeded */
4531 if (cur_curlyx->u.curlyx.count >= REG_INFTY
4532 && ckWARN(WARN_REGEXP)
4533 && !(PL_reg_flags & RF_warned))
4534 {
3280af22 4535 PL_reg_flags |= RF_warned;
c476f425
DM		 4536 Perl_warner(aTHX_ packWARN(WARN_REGEXP),
4537 "%s limit (%d) exceeded",
4538 "Complex regular subexpression recursion",
4539 REG_INFTY - 1);
a0d0e21e 4540 }
c476f425 4541 cur_curlyx->u.curlyx.count--;
3ab3c9b4 4542 CACHEsayNO;
a0d0e21e 4543 }
c476f425
DM		 4544
4545 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
4546 "%*s trying longer...\n", REPORT_CODE_OFF+depth*2, "")
4547 );
4548 /* Try grabbing another A and see if it helps. */
4549 PL_reginput = locinput;
4550 cur_curlyx->u.curlyx.lastloc = locinput;
4551 ST.cp = regcppush(cur_curlyx->u.curlyx.parenfloor);
4552 REGCP_SET(ST.lastcp);
d02d6d97
DM		 4553 PUSH_STATE_GOTO(WHILEM_A_min,
4554 /*A*/ NEXTOPER(ST.save_curlyx->u.curlyx.me) + EXTRA_STEP_2ARGS);
5f66b61c 4555 /* NOTREACHED */
40a82448
DM		 4556
4557#undef ST
4558#define ST st->u.branch
4559
4560 case BRANCHJ: /* /(...|A|...)/ with long next pointer */
c277df42
IZ		 4561 next = scan + ARG(scan);
4562 if (next == scan)
4563 next = NULL;
40a82448
DM		 4564 scan = NEXTOPER(scan);
4565 /* FALL THROUGH */
c277df42 4566
40a82448
DM		 4567 case BRANCH: /* /(...|A|...)/ */
4568 scan = NEXTOPER(scan); /* scan now points to inner node */
40a82448
DM		 4569 ST.lastparen = *PL_reglastparen;
4570 ST.next_branch = next;
4571 REGCP_SET(ST.cp);
4572 PL_reginput = locinput;
02db2b7b 4573
40a82448 4574 /* Now go into the branch */
5d458dd8
YO		 4575 if (has_cutgroup) {
4576 PUSH_YES_STATE_GOTO(BRANCH_next, scan);
4577 } else {
4578 PUSH_STATE_GOTO(BRANCH_next, scan);
4579 }
40a82448 4580 /* NOTREACHED */
5d458dd8
YO		 4581 case CUTGROUP:
4582 PL_reginput = locinput;
4583 sv_yes_mark = st->u.mark.mark_name = scan->flags ? NULL :
ad64d0ec 4584 MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
5d458dd8
YO		 4585 PUSH_STATE_GOTO(CUTGROUP_next,next);
4586 /* NOTREACHED */
4587 case CUTGROUP_next_fail:
4588 do_cutgroup = 1;
4589 no_final = 1;
4590 if (st->u.mark.mark_name)
4591 sv_commit = st->u.mark.mark_name;
4592 sayNO;
4593 /* NOTREACHED */
4594 case BRANCH_next:
4595 sayYES;
4596 /* NOTREACHED */
40a82448 4597 case BRANCH_next_fail: /* that branch failed; try the next, if any */
5d458dd8
YO		 4598 if (do_cutgroup) {
4599 do_cutgroup = 0;
4600 no_final = 0;
4601 }
40a82448
DM		 4602 REGCP_UNWIND(ST.cp);
4603 for (n = *PL_reglastparen; n > ST.lastparen; n--)
f0ab9afb 4604 PL_regoffs[n].end = -1;
40a82448 4605 *PL_reglastparen = n;
0a4db386 4606 /*dmq: *PL_reglastcloseparen = n; */
40a82448
DM		 4607 scan = ST.next_branch;
4608 /* no more branches? */
5d458dd8
YO		 4609 if (!scan || (OP(scan) != BRANCH && OP(scan) != BRANCHJ)) {
4610 DEBUG_EXECUTE_r({
4611 PerlIO_printf( Perl_debug_log,
4612 "%*s %sBRANCH failed...%s\n",
4613 REPORT_CODE_OFF+depth*2, "",
4614 PL_colors[4],
4615 PL_colors[5] );
4616 });
4617 sayNO_SILENT;
4618 }
40a82448
DM		 4619 continue; /* execute next BRANCH[J] op */
4620 /* NOTREACHED */
4621
a0d0e21e 4622 case MINMOD:
24d3c4a9 4623 minmod = 1;
a0d0e21e 4624 break;
40a82448
DM		 4625
4626#undef ST
4627#define ST st->u.curlym
4628
4629 case CURLYM: /* /A{m,n}B/ where A is fixed-length */
4630
4631 /* This is an optimisation of CURLYX that enables us to push
84d2fa14 4632 * only a single backtracking state, no matter how many matches
40a82448
DM		 4633 * there are in {m,n}. It relies on the pattern being constant
4634 * length, with no parens to influence future backrefs
4635 */
4636
4637 ST.me = scan;
dc45a647 4638 scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
40a82448
DM		 4639
4640 /* if paren positive, emulate an OPEN/CLOSE around A */
4641 if (ST.me->flags) {
3b6647e0 4642 U32 paren = ST.me->flags;
40a82448
DM		 4643 if (paren > PL_regsize)
4644 PL_regsize = paren;
3b6647e0 4645 if (paren > *PL_reglastparen)
40a82448 4646 *PL_reglastparen = paren;
c277df42 4647 scan += NEXT_OFF(scan); /* Skip former OPEN. */
6407bf3b 4648 }
40a82448
DM		 4649 ST.A = scan;
4650 ST.B = next;
4651 ST.alen = 0;
4652 ST.count = 0;
24d3c4a9
DM		 4653 ST.minmod = minmod;
4654 minmod = 0;
40a82448
DM		 4655 ST.c1 = CHRTEST_UNINIT;
4656 REGCP_SET(ST.cp);
6407bf3b 4657
40a82448
DM		 4658 if (!(ST.minmod ? ARG1(ST.me) : ARG2(ST.me))) /* min/max */
4659 goto curlym_do_B;
4660
4661 curlym_do_A: /* execute the A in /A{m,n}B/ */
6407bf3b 4662 PL_reginput = locinput;
40a82448
DM		 4663 PUSH_YES_STATE_GOTO(CURLYM_A, ST.A); /* match A */
4664 /* NOTREACHED */
5f80c4cf 4665
40a82448
DM		 4666 case CURLYM_A: /* we've just matched an A */
4667 locinput = st->locinput;
4668 nextchr = UCHARAT(locinput);
4669
4670 ST.count++;
4671 /* after first match, determine A's length: u.curlym.alen */
4672 if (ST.count == 1) {
4673 if (PL_reg_match_utf8) {
4674 char *s = locinput;
4675 while (s < PL_reginput) {
4676 ST.alen++;
4677 s += UTF8SKIP(s);
4678 }
4679 }
4680 else {
4681 ST.alen = PL_reginput - locinput;
4682 }
4683 if (ST.alen == 0)
4684 ST.count = ST.minmod ? ARG1(ST.me) : ARG2(ST.me);
4685 }
0cadcf80
DM		 4686 DEBUG_EXECUTE_r(
4687 PerlIO_printf(Perl_debug_log,
40a82448 4688 "%*s CURLYM now matched %"IVdf" times, len=%"IVdf"...\n",
5bc10b2c 4689 (int)(REPORT_CODE_OFF+(depth*2)), "",
40a82448 4690 (IV) ST.count, (IV)ST.alen)
0cadcf80
DM		 4691 );
4692
40a82448 4693 locinput = PL_reginput;
0a4db386
YO		 4694
4695 if (cur_eval && cur_eval->u.eval.close_paren &&
24b23f37 4696 cur_eval->u.eval.close_paren == (U32)ST.me->flags)
0a4db386
YO		 4697 goto fake_end;
4698
c966426a
DM		 4699 {
4700 I32 max = (ST.minmod ? ARG1(ST.me) : ARG2(ST.me));
4701 if ( max == REG_INFTY || ST.count < max )
4702 goto curlym_do_A; /* try to match another A */
4703 }
40a82448 4704 goto curlym_do_B; /* try to match B */
5f80c4cf 4705
40a82448
DM		 4706 case CURLYM_A_fail: /* just failed to match an A */
4707 REGCP_UNWIND(ST.cp);
0a4db386
YO		 4708
4709 if (ST.minmod || ST.count < ARG1(ST.me) /* min*/
4710 || (cur_eval && cur_eval->u.eval.close_paren &&
24b23f37 4711 cur_eval->u.eval.close_paren == (U32)ST.me->flags))
40a82448 4712 sayNO;
0cadcf80 4713
40a82448
DM		 4714 curlym_do_B: /* execute the B in /A{m,n}B/ */
4715 PL_reginput = locinput;
4716 if (ST.c1 == CHRTEST_UNINIT) {
4717 /* calculate c1 and c2 for possible match of 1st char
4718 * following curly */
4719 ST.c1 = ST.c2 = CHRTEST_VOID;
4720 if (HAS_TEXT(ST.B) || JUMPABLE(ST.B)) {
4721 regnode *text_node = ST.B;
4722 if (! HAS_TEXT(text_node))
4723 FIND_NEXT_IMPT(text_node);
ee9b8eae
YO		 4724 /* this used to be
4725
4726 (HAS_TEXT(text_node) && PL_regkind[OP(text_node)] == EXACT)
4727
4728 But the former is redundant in light of the latter.
4729
4730 if this changes back then the macro for
4731 IS_TEXT and friends need to change.
4732 */
4733 if (PL_regkind[OP(text_node)] == EXACT)
40a82448 4734 {
ee9b8eae 4735
40a82448
DM		 4736 ST.c1 = (U8)*STRING(text_node);
4737 ST.c2 =
ee9b8eae 4738 (IS_TEXTF(text_node))
40a82448 4739 ? PL_fold[ST.c1]
ee9b8eae 4740 : (IS_TEXTFL(text_node))
40a82448
DM		 4741 ? PL_fold_locale[ST.c1]
4742 : ST.c1;
c277df42 4743 }
c277df42 4744 }
40a82448
DM		 4745 }
4746
4747 DEBUG_EXECUTE_r(
4748 PerlIO_printf(Perl_debug_log,
4749 "%*s CURLYM trying tail with matches=%"IVdf"...\n",
5bc10b2c 4750 (int)(REPORT_CODE_OFF+(depth*2)),
40a82448
DM		 4751 "", (IV)ST.count)
4752 );
4753 if (ST.c1 != CHRTEST_VOID
4754 && UCHARAT(PL_reginput) != ST.c1
4755 && UCHARAT(PL_reginput) != ST.c2)
4756 {
4757 /* simulate B failing */
3e901dc0
YO		 4758 DEBUG_OPTIMISE_r(
4759 PerlIO_printf(Perl_debug_log,
4760 "%*s CURLYM Fast bail c1=%"IVdf" c2=%"IVdf"\n",
4761 (int)(REPORT_CODE_OFF+(depth*2)),"",
4762 (IV)ST.c1,(IV)ST.c2
4763 ));
40a82448
DM		 4764 state_num = CURLYM_B_fail;
4765 goto reenter_switch;
4766 }
4767
4768 if (ST.me->flags) {
4769 /* mark current A as captured */
4770 I32 paren = ST.me->flags;
4771 if (ST.count) {
f0ab9afb 4772 PL_regoffs[paren].start
40a82448 4773 = HOPc(PL_reginput, -ST.alen) - PL_bostr;
f0ab9afb 4774 PL_regoffs[paren].end = PL_reginput - PL_bostr;
0a4db386 4775 /*dmq: *PL_reglastcloseparen = paren; */
c277df42 4776 }
40a82448 4777 else
f0ab9afb 4778 PL_regoffs[paren].end = -1;
0a4db386 4779 if (cur_eval && cur_eval->u.eval.close_paren &&
24b23f37 4780 cur_eval->u.eval.close_paren == (U32)ST.me->flags)
0a4db386
YO		 4781 {
4782 if (ST.count)
4783 goto fake_end;
4784 else
4785 sayNO;
4786 }
c277df42 4787 }
0a4db386 4788
40a82448 4789 PUSH_STATE_GOTO(CURLYM_B, ST.B); /* match B */
5f66b61c 4790 /* NOTREACHED */
40a82448
DM		 4791
4792 case CURLYM_B_fail: /* just failed to match a B */
4793 REGCP_UNWIND(ST.cp);
4794 if (ST.minmod) {
84d2fa14
HS		 4795 I32 max = ARG2(ST.me);
4796 if (max != REG_INFTY && ST.count == max)
40a82448
DM		 4797 sayNO;
4798 goto curlym_do_A; /* try to match a further A */
4799 }
4800 /* backtrack one A */
4801 if (ST.count == ARG1(ST.me) /* min */)
4802 sayNO;
4803 ST.count--;
4804 locinput = HOPc(locinput, -ST.alen);
4805 goto curlym_do_B; /* try to match B */
4806
c255a977
DM		 4807#undef ST
4808#define ST st->u.curly
40a82448 4809
c255a977
DM		 4810#define CURLY_SETPAREN(paren, success) \
4811 if (paren) { \
4812 if (success) { \
f0ab9afb
NC		 4813 PL_regoffs[paren].start = HOPc(locinput, -1) - PL_bostr; \
4814 PL_regoffs[paren].end = locinput - PL_bostr; \
0a4db386 4815 *PL_reglastcloseparen = paren; \
c255a977
DM		 4816 } \
4817 else \
f0ab9afb 4818 PL_regoffs[paren].end = -1; \
c255a977
DM		 4819 }
4820
4821 case STAR: /* /A*B/ where A is width 1 */
4822 ST.paren = 0;
4823 ST.min = 0;
4824 ST.max = REG_INFTY;
a0d0e21e
LW		 4825 scan = NEXTOPER(scan);
4826 goto repeat;
c255a977
DM		 4827 case PLUS: /* /A+B/ where A is width 1 */
4828 ST.paren = 0;
4829 ST.min = 1;
4830 ST.max = REG_INFTY;
c277df42 4831 scan = NEXTOPER(scan);
c255a977
DM		 4832 goto repeat;
4833 case CURLYN: /* /(A){m,n}B/ where A is width 1 */
4834 ST.paren = scan->flags; /* Which paren to set */
4835 if (ST.paren > PL_regsize)
4836 PL_regsize = ST.paren;
3b6647e0 4837 if (ST.paren > *PL_reglastparen)
c255a977
DM		 4838 *PL_reglastparen = ST.paren;
4839 ST.min = ARG1(scan); /* min to match */
4840 ST.max = ARG2(scan); /* max to match */
0a4db386 4841 if (cur_eval && cur_eval->u.eval.close_paren &&
86413ec0 4842 cur_eval->u.eval.close_paren == (U32)ST.paren) {
0a4db386
YO		 4843 ST.min=1;
4844 ST.max=1;
4845 }
c255a977
DM		 4846 scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
4847 goto repeat;
4848 case CURLY: /* /A{m,n}B/ where A is width 1 */
4849 ST.paren = 0;
4850 ST.min = ARG1(scan); /* min to match */
4851 ST.max = ARG2(scan); /* max to match */
4852 scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
c277df42 4853 repeat:
a0d0e21e
LW		 4854 /*
4855 * Lookahead to avoid useless match attempts
4856 * when we know what character comes next.
c255a977 4857 *
5f80c4cf
JP		 4858 * Used to only do .*x and .*?x, but now it allows
4859 * for )'s, ('s and (?{ ... })'s to be in the way
4860 * of the quantifier and the EXACT-like node. -- japhy
4861 */
4862
c255a977
DM		 4863 if (ST.min > ST.max) /* XXX make this a compile-time check? */
4864 sayNO;
cca55fe3 4865 if (HAS_TEXT(next) || JUMPABLE(next)) {
5f80c4cf
JP		 4866 U8 *s;
4867 regnode *text_node = next;
4868
3dab1dad
YO		 4869 if (! HAS_TEXT(text_node))
4870 FIND_NEXT_IMPT(text_node);
5f80c4cf 4871
9e137952 4872 if (! HAS_TEXT(text_node))
c255a977 4873 ST.c1 = ST.c2 = CHRTEST_VOID;
5f80c4cf 4874 else {
ee9b8eae 4875 if ( PL_regkind[OP(text_node)] != EXACT ) {
c255a977 4876 ST.c1 = ST.c2 = CHRTEST_VOID;
44a68960 4877 goto assume_ok_easy;
cca55fe3 4878 }
be8e71aa
YO		 4879 else
4880 s = (U8*)STRING(text_node);
ee9b8eae
YO		 4881
4882 /* Currently we only get here when
4883
4884 PL_rekind[OP(text_node)] == EXACT
4885
4886 if this changes back then the macro for IS_TEXT and
4887 friends need to change. */
f2ed9b32 4888 if (!UTF_PATTERN) {
c255a977 4889 ST.c2 = ST.c1 = *s;
ee9b8eae 4890 if (IS_TEXTF(text_node))
c255a977 4891 ST.c2 = PL_fold[ST.c1];
ee9b8eae 4892 else if (IS_TEXTFL(text_node))
c255a977 4893 ST.c2 = PL_fold_locale[ST.c1];
1aa99e6b 4894 }
f2ed9b32 4895 else { /* UTF_PATTERN */
ee9b8eae 4896 if (IS_TEXTF(text_node)) {
a2a2844f 4897 STRLEN ulen1, ulen2;
89ebb4a3
JH		 4898 U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
4899 U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
a2a2844f
JH		 4900
4901 to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
4902 to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
e294cc5d
JH		 4903#ifdef EBCDIC
4904 ST.c1 = utf8n_to_uvchr(tmpbuf1, UTF8_MAXLEN, 0,
4905 ckWARN(WARN_UTF8) ?
4906 0 : UTF8_ALLOW_ANY);
4907 ST.c2 = utf8n_to_uvchr(tmpbuf2, UTF8_MAXLEN, 0,
4908 ckWARN(WARN_UTF8) ?
4909 0 : UTF8_ALLOW_ANY);
4910#else
c255a977 4911 ST.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
e294cc5d 4912 uniflags);
c255a977 4913 ST.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
e294cc5d
JH		 4914 uniflags);
4915#endif
5f80c4cf
JP		 4916 }
4917 else {
c255a977 4918 ST.c2 = ST.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
041457d9 4919 uniflags);
5f80c4cf 4920 }
1aa99e6b
IH		 4921 }
4922 }
bbce6d69 4923 }
a0d0e21e 4924 else
c255a977 4925 ST.c1 = ST.c2 = CHRTEST_VOID;
cca55fe3 4926 assume_ok_easy:
c255a977
DM		 4927
4928 ST.A = scan;
4929 ST.B = next;
3280af22 4930 PL_reginput = locinput;
24d3c4a9
DM		 4931 if (minmod) {
4932 minmod = 0;
e2e6a0f1 4933 if (ST.min && regrepeat(rex, ST.A, ST.min, depth) < ST.min)
4633a7c4 4934 sayNO;
c255a977 4935 ST.count = ST.min;
a0ed51b3 4936 locinput = PL_reginput;
c255a977
DM		 4937 REGCP_SET(ST.cp);
4938 if (ST.c1 == CHRTEST_VOID)
4939 goto curly_try_B_min;
4940
4941 ST.oldloc = locinput;
4942
4943 /* set ST.maxpos to the furthest point along the
4944 * string that could possibly match */
4945 if (ST.max == REG_INFTY) {
4946 ST.maxpos = PL_regeol - 1;
f2ed9b32 4947 if (utf8_target)
c255a977
DM		 4948 while (UTF8_IS_CONTINUATION(*(U8*)ST.maxpos))
4949 ST.maxpos--;
4950 }
f2ed9b32 4951 else if (utf8_target) {
c255a977
DM		 4952 int m = ST.max - ST.min;
4953 for (ST.maxpos = locinput;
4954 m >0 && ST.maxpos + UTF8SKIP(ST.maxpos) <= PL_regeol; m--)
4955 ST.maxpos += UTF8SKIP(ST.maxpos);
4956 }
4957 else {
4958 ST.maxpos = locinput + ST.max - ST.min;
4959 if (ST.maxpos >= PL_regeol)
4960 ST.maxpos = PL_regeol - 1;
4961 }
4962 goto curly_try_B_min_known;
4963
4964 }
4965 else {
e2e6a0f1 4966 ST.count = regrepeat(rex, ST.A, ST.max, depth);
c255a977
DM		 4967 locinput = PL_reginput;
4968 if (ST.count < ST.min)
4969 sayNO;
4970 if ((ST.count > ST.min)
4971 && (PL_regkind[OP(ST.B)] == EOL) && (OP(ST.B) != MEOL))
4972 {
4973 /* A{m,n} must come at the end of the string, there's
4974 * no point in backing off ... */
4975 ST.min = ST.count;
4976 /* ...except that $ and \Z can match before *and* after
4977 newline at the end. Consider "\n\n" =~ /\n+\Z\n/.
4978 We may back off by one in this case. */
4979 if (UCHARAT(PL_reginput - 1) == '\n' && OP(ST.B) != EOS)
4980 ST.min--;
4981 }
4982 REGCP_SET(ST.cp);
4983 goto curly_try_B_max;
4984 }
4985 /* NOTREACHED */
4986
4987
4988 case CURLY_B_min_known_fail:
4989 /* failed to find B in a non-greedy match where c1,c2 valid */
4990 if (ST.paren && ST.count)
f0ab9afb 4991 PL_regoffs[ST.paren].end = -1;
c255a977
DM		 4992
4993 PL_reginput = locinput; /* Could be reset... */
4994 REGCP_UNWIND(ST.cp);
4995 /* Couldn't or didn't -- move forward. */
4996 ST.oldloc = locinput;
f2ed9b32 4997 if (utf8_target)
c255a977
DM		 4998 locinput += UTF8SKIP(locinput);
4999 else
5000 locinput++;
5001 ST.count++;
5002 curly_try_B_min_known:
5003 /* find the next place where 'B' could work, then call B */
5004 {
5005 int n;
f2ed9b32 5006 if (utf8_target) {
c255a977
DM		 5007 n = (ST.oldloc == locinput) ? 0 : 1;
5008 if (ST.c1 == ST.c2) {
5009 STRLEN len;
5010 /* set n to utf8_distance(oldloc, locinput) */
5011 while (locinput <= ST.maxpos &&
5012 utf8n_to_uvchr((U8*)locinput,
5013 UTF8_MAXBYTES, &len,
5014 uniflags) != (UV)ST.c1) {
5015 locinput += len;
5016 n++;
5017 }
1aa99e6b
IH		 5018 }
5019 else {
c255a977
DM		 5020 /* set n to utf8_distance(oldloc, locinput) */
5021 while (locinput <= ST.maxpos) {
5022 STRLEN len;
5023 const UV c = utf8n_to_uvchr((U8*)locinput,
5024 UTF8_MAXBYTES, &len,
5025 uniflags);
5026 if (c == (UV)ST.c1 || c == (UV)ST.c2)
5027 break;
5028 locinput += len;
5029 n++;
1aa99e6b 5030 }
0fe9bf95
IZ		 5031 }
5032 }
c255a977
DM		 5033 else {
5034 if (ST.c1 == ST.c2) {
5035 while (locinput <= ST.maxpos &&
5036 UCHARAT(locinput) != ST.c1)
5037 locinput++;
bbce6d69 5038 }
c255a977
DM		 5039 else {
5040 while (locinput <= ST.maxpos
5041 && UCHARAT(locinput) != ST.c1
5042 && UCHARAT(locinput) != ST.c2)
5043 locinput++;
a0ed51b3 5044 }
c255a977
DM		 5045 n = locinput - ST.oldloc;
5046 }
5047 if (locinput > ST.maxpos)
5048 sayNO;
5049 /* PL_reginput == oldloc now */
5050 if (n) {
5051 ST.count += n;
e2e6a0f1 5052 if (regrepeat(rex, ST.A, n, depth) < n)
4633a7c4 5053 sayNO;
a0d0e21e 5054 }
c255a977
DM		 5055 PL_reginput = locinput;
5056 CURLY_SETPAREN(ST.paren, ST.count);
0a4db386 5057 if (cur_eval && cur_eval->u.eval.close_paren &&
86413ec0 5058 cur_eval->u.eval.close_paren == (U32)ST.paren) {
0a4db386
YO		 5059 goto fake_end;
5060 }
c255a977 5061 PUSH_STATE_GOTO(CURLY_B_min_known, ST.B);
a0d0e21e 5062 }
c255a977
DM		 5063 /* NOTREACHED */
5064
5065
5066 case CURLY_B_min_fail:
5067 /* failed to find B in a non-greedy match where c1,c2 invalid */
5068 if (ST.paren && ST.count)
f0ab9afb 5069 PL_regoffs[ST.paren].end = -1;
c255a977
DM		 5070
5071 REGCP_UNWIND(ST.cp);
5072 /* failed -- move forward one */
5073 PL_reginput = locinput;
e2e6a0f1 5074 if (regrepeat(rex, ST.A, 1, depth)) {
c255a977 5075 ST.count++;
a0ed51b3 5076 locinput = PL_reginput;
c255a977
DM		 5077 if (ST.count <= ST.max || (ST.max == REG_INFTY &&
5078 ST.count > 0)) /* count overflow ? */
15272685 5079 {
c255a977
DM		 5080 curly_try_B_min:
5081 CURLY_SETPAREN(ST.paren, ST.count);
0a4db386 5082 if (cur_eval && cur_eval->u.eval.close_paren &&
86413ec0 5083 cur_eval->u.eval.close_paren == (U32)ST.paren) {
0a4db386
YO		 5084 goto fake_end;
5085 }
c255a977 5086 PUSH_STATE_GOTO(CURLY_B_min, ST.B);
a0d0e21e
LW		 5087 }
5088 }
4633a7c4 5089 sayNO;
c255a977
DM		 5090 /* NOTREACHED */
5091
5092
5093 curly_try_B_max:
5094 /* a successful greedy match: now try to match B */
40d049e4 5095 if (cur_eval && cur_eval->u.eval.close_paren &&
86413ec0 5096 cur_eval->u.eval.close_paren == (U32)ST.paren) {
40d049e4
YO		 5097 goto fake_end;
5098 }
c255a977
DM		 5099 {
5100 UV c = 0;
5101 if (ST.c1 != CHRTEST_VOID)
f2ed9b32 5102 c = utf8_target ? utf8n_to_uvchr((U8*)PL_reginput,
c255a977 5103 UTF8_MAXBYTES, 0, uniflags)
466787eb 5104 : (UV) UCHARAT(PL_reginput);
c255a977
DM		 5105 /* If it could work, try it. */
5106 if (ST.c1 == CHRTEST_VOID || c == (UV)ST.c1 || c == (UV)ST.c2) {
5107 CURLY_SETPAREN(ST.paren, ST.count);
5108 PUSH_STATE_GOTO(CURLY_B_max, ST.B);
5109 /* NOTREACHED */
5110 }
5111 }
5112 /* FALL THROUGH */
5113 case CURLY_B_max_fail:
5114 /* failed to find B in a greedy match */
5115 if (ST.paren && ST.count)
f0ab9afb 5116 PL_regoffs[ST.paren].end = -1;
c255a977
DM		 5117
5118 REGCP_UNWIND(ST.cp);
5119 /* back up. */
5120 if (--ST.count < ST.min)
5121 sayNO;
5122 PL_reginput = locinput = HOPc(locinput, -1);
5123 goto curly_try_B_max;
5124
5125#undef ST
5126
a0d0e21e 5127 case END:
6bda09f9 5128 fake_end:
faec1544
DM		 5129 if (cur_eval) {
5130 /* we've just finished A in /(??{A})B/; now continue with B */
5131 I32 tmpix;
faec1544
DM		 5132 st->u.eval.toggle_reg_flags
5133 = cur_eval->u.eval.toggle_reg_flags;
5134 PL_reg_flags ^= st->u.eval.toggle_reg_flags;
5135
288b8c02
NC		 5136 st->u.eval.prev_rex = rex_sv; /* inner */
5137 SETREX(rex_sv,cur_eval->u.eval.prev_rex);
5138 rex = (struct regexp *)SvANY(rex_sv);
f8fc2ecf 5139 rexi = RXi_GET(rex);
faec1544 5140 cur_curlyx = cur_eval->u.eval.prev_curlyx;
288b8c02 5141 ReREFCNT_inc(rex_sv);
faec1544 5142 st->u.eval.cp = regcppush(0); /* Save *all* the positions. */
34a81e2b
B		 5143
5144 /* rex was changed so update the pointer in PL_reglastparen and PL_reglastcloseparen */
5145 PL_reglastparen = &rex->lastparen;
5146 PL_reglastcloseparen = &rex->lastcloseparen;
5147
faec1544
DM		 5148 REGCP_SET(st->u.eval.lastcp);
5149 PL_reginput = locinput;
5150
5151 /* Restore parens of the outer rex without popping the
5152 * savestack */
5153 tmpix = PL_savestack_ix;
5154 PL_savestack_ix = cur_eval->u.eval.lastcp;
5155 regcppop(rex);
5156 PL_savestack_ix = tmpix;
5157
5158 st->u.eval.prev_eval = cur_eval;
5159 cur_eval = cur_eval->u.eval.prev_eval;
5160 DEBUG_EXECUTE_r(
2a49f0f5
JH		 5161 PerlIO_printf(Perl_debug_log, "%*s EVAL trying tail ... %"UVxf"\n",
5162 REPORT_CODE_OFF+depth*2, "",PTR2UV(cur_eval)););
e7707071
YO		 5163 if ( nochange_depth )
5164 nochange_depth--;
5165
5166 PUSH_YES_STATE_GOTO(EVAL_AB,
faec1544
DM		 5167 st->u.eval.prev_eval->u.eval.B); /* match B */
5168 }
5169
3b0527fe 5170 if (locinput < reginfo->till) {
a3621e74 5171 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
7821416a
IZ		 5172 "%sMatch possible, but length=%ld is smaller than requested=%ld, failing!%s\n",
5173 PL_colors[4],
5174 (long)(locinput - PL_reg_starttry),
3b0527fe 5175 (long)(reginfo->till - PL_reg_starttry),
7821416a 5176 PL_colors[5]));
58e23c8d 5177
262b90c4 5178 sayNO_SILENT; /* Cannot match: too short. */
7821416a
IZ		 5179 }
5180 PL_reginput = locinput; /* put where regtry can find it */
262b90c4 5181 sayYES; /* Success! */
dad79028
DM		 5182
5183 case SUCCEED: /* successful SUSPEND/UNLESSM/IFMATCH/CURLYM */
5184 DEBUG_EXECUTE_r(
5185 PerlIO_printf(Perl_debug_log,
5186 "%*s %ssubpattern success...%s\n",
5bc10b2c 5187 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5]));
3280af22 5188 PL_reginput = locinput; /* put where regtry can find it */
262b90c4 5189 sayYES; /* Success! */
dad79028 5190
40a82448
DM		 5191#undef ST
5192#define ST st->u.ifmatch
5193
5194 case SUSPEND: /* (?>A) */
5195 ST.wanted = 1;
9fe1d20c 5196 PL_reginput = locinput;
9041c2e3 5197 goto do_ifmatch;
dad79028 5198
40a82448
DM		 5199 case UNLESSM: /* -ve lookaround: (?!A), or with flags, (?<!A) */
5200 ST.wanted = 0;
dad79028
DM		 5201 goto ifmatch_trivial_fail_test;
5202
40a82448
DM		 5203 case IFMATCH: /* +ve lookaround: (?=A), or with flags, (?<=A) */
5204 ST.wanted = 1;
dad79028 5205 ifmatch_trivial_fail_test:
a0ed51b3 5206 if (scan->flags) {
52657f30 5207 char * const s = HOPBACKc(locinput, scan->flags);
dad79028
DM		 5208 if (!s) {
5209 /* trivial fail */
24d3c4a9
DM		 5210 if (logical) {
5211 logical = 0;
f2338a2e 5212 sw = 1 - cBOOL(ST.wanted);
dad79028 5213 }
40a82448 5214 else if (ST.wanted)
dad79028
DM		 5215 sayNO;
5216 next = scan + ARG(scan);
5217 if (next == scan)
5218 next = NULL;
5219 break;
5220 }
efb30f32 5221 PL_reginput = s;
a0ed51b3
LW		 5222 }
5223 else
5224 PL_reginput = locinput;
5225
c277df42 5226 do_ifmatch:
40a82448 5227 ST.me = scan;
24d3c4a9 5228 ST.logical = logical;
24d786f4
YO		 5229 logical = 0; /* XXX: reset state of logical once it has been saved into ST */
5230
40a82448
DM		 5231 /* execute body of (?...A) */
5232 PUSH_YES_STATE_GOTO(IFMATCH_A, NEXTOPER(NEXTOPER(scan)));
5233 /* NOTREACHED */
5234
5235 case IFMATCH_A_fail: /* body of (?...A) failed */
5236 ST.wanted = !ST.wanted;
5237 /* FALL THROUGH */
5238
5239 case IFMATCH_A: /* body of (?...A) succeeded */
24d3c4a9 5240 if (ST.logical) {
f2338a2e 5241 sw = cBOOL(ST.wanted);
40a82448
DM		 5242 }
5243 else if (!ST.wanted)
5244 sayNO;
5245
5246 if (OP(ST.me) == SUSPEND)
5247 locinput = PL_reginput;
5248 else {
5249 locinput = PL_reginput = st->locinput;
5250 nextchr = UCHARAT(locinput);
5251 }
5252 scan = ST.me + ARG(ST.me);
5253 if (scan == ST.me)
5254 scan = NULL;
5255 continue; /* execute B */
5256
5257#undef ST
dad79028 5258
c277df42 5259 case LONGJMP:
c277df42
IZ		 5260 next = scan + ARG(scan);
5261 if (next == scan)
5262 next = NULL;
a0d0e21e 5263 break;
54612592 5264 case COMMIT:
e2e6a0f1
YO		 5265 reginfo->cutpoint = PL_regeol;
5266 /* FALLTHROUGH */
5d458dd8 5267 case PRUNE:
24b23f37 5268 PL_reginput = locinput;
e2e6a0f1 5269 if (!scan->flags)
ad64d0ec 5270 sv_yes_mark = sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
54612592
YO		 5271 PUSH_STATE_GOTO(COMMIT_next,next);
5272 /* NOTREACHED */
5273 case COMMIT_next_fail:
5274 no_final = 1;
5275 /* FALLTHROUGH */
7f69552c
YO		 5276 case OPFAIL:
5277 sayNO;
e2e6a0f1
YO		 5278 /* NOTREACHED */
5279
5280#define ST st->u.mark
5281 case MARKPOINT:
5282 ST.prev_mark = mark_state;
5d458dd8 5283 ST.mark_name = sv_commit = sv_yes_mark
ad64d0ec 5284 = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
e2e6a0f1
YO		 5285 mark_state = st;
5286 ST.mark_loc = PL_reginput = locinput;
5287 PUSH_YES_STATE_GOTO(MARKPOINT_next,next);
5288 /* NOTREACHED */
5289 case MARKPOINT_next:
5290 mark_state = ST.prev_mark;
5291 sayYES;
5292 /* NOTREACHED */
5293 case MARKPOINT_next_fail:
5d458dd8 5294 if (popmark && sv_eq(ST.mark_name,popmark))
e2e6a0f1
YO		 5295 {
5296 if (ST.mark_loc > startpoint)
5297 reginfo->cutpoint = HOPBACKc(ST.mark_loc, 1);
5298 popmark = NULL; /* we found our mark */
5299 sv_commit = ST.mark_name;
5300
5301 DEBUG_EXECUTE_r({
5d458dd8 5302 PerlIO_printf(Perl_debug_log,
e2e6a0f1
YO		 5303 "%*s %ssetting cutpoint to mark:%"SVf"...%s\n",
5304 REPORT_CODE_OFF+depth*2, "",
be2597df 5305 PL_colors[4], SVfARG(sv_commit), PL_colors[5]);
e2e6a0f1
YO		 5306 });
5307 }
5308 mark_state = ST.prev_mark;
5d458dd8
YO		 5309 sv_yes_mark = mark_state ?
5310 mark_state->u.mark.mark_name : NULL;
e2e6a0f1
YO		 5311 sayNO;
5312 /* NOTREACHED */
5d458dd8
YO		 5313 case SKIP:
5314 PL_reginput = locinput;
5315 if (scan->flags) {
2bf803e2 5316 /* (*SKIP) : if we fail we cut here*/
5d458dd8 5317 ST.mark_name = NULL;
e2e6a0f1 5318 ST.mark_loc = locinput;
5d458dd8
YO		 5319 PUSH_STATE_GOTO(SKIP_next,next);
5320 } else {
2bf803e2 5321 /* (*SKIP:NAME) : if there is a (*MARK:NAME) fail where it was,
5d458dd8
YO		 5322 otherwise do nothing. Meaning we need to scan
5323 */
5324 regmatch_state *cur = mark_state;
ad64d0ec 5325 SV *find = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
5d458dd8
YO		 5326
5327 while (cur) {
5328 if ( sv_eq( cur->u.mark.mark_name,
5329 find ) )
5330 {
5331 ST.mark_name = find;
5332 PUSH_STATE_GOTO( SKIP_next, next );
5333 }
5334 cur = cur->u.mark.prev_mark;
5335 }
e2e6a0f1 5336 }
2bf803e2 5337 /* Didn't find our (*MARK:NAME) so ignore this (*SKIP:NAME) */
5d458dd8
YO		 5338 break;
5339 case SKIP_next_fail:
5340 if (ST.mark_name) {
5341 /* (*CUT:NAME) - Set up to search for the name as we
5342 collapse the stack*/
5343 popmark = ST.mark_name;
5344 } else {
5345 /* (*CUT) - No name, we cut here.*/
e2e6a0f1
YO		 5346 if (ST.mark_loc > startpoint)
5347 reginfo->cutpoint = HOPBACKc(ST.mark_loc, 1);
5d458dd8
YO		 5348 /* but we set sv_commit to latest mark_name if there
5349 is one so they can test to see how things lead to this
5350 cut */
5351 if (mark_state)
5352 sv_commit=mark_state->u.mark.mark_name;
5353 }
e2e6a0f1
YO		 5354 no_final = 1;
5355 sayNO;
5356 /* NOTREACHED */
5357#undef ST
32e6a07c
YO		 5358 case FOLDCHAR:
5359 n = ARG(scan);
f2ed9b32 5360 if ( n == (U32)what_len_TRICKYFOLD(locinput,utf8_target,ln) ) {
e64b1bd1 5361 locinput += ln;
f2ed9b32 5362 } else if ( 0xDF == n && !utf8_target && !UTF_PATTERN ) {
e64b1bd1
YO		 5363 sayNO;
5364 } else {
5365 U8 folded[UTF8_MAXBYTES_CASE+1];
5366 STRLEN foldlen;
5367 const char * const l = locinput;
5368 char *e = PL_regeol;
5369 to_uni_fold(n, folded, &foldlen);
5370
4c1b470c 5371 if (! foldEQ_utf8((const char*) folded, 0, foldlen, 1,
f2ed9b32 5372 l, &e, 0, utf8_target)) {
32e6a07c 5373 sayNO;
e64b1bd1
YO		 5374 }
5375 locinput = e;
32e6a07c
YO		 5376 }
5377 nextchr = UCHARAT(locinput);
5378 break;
e1d1eefb 5379 case LNBREAK:
f2ed9b32 5380 if ((n=is_LNBREAK(locinput,utf8_target))) {
e1d1eefb
YO		 5381 locinput += n;
5382 nextchr = UCHARAT(locinput);
5383 } else
5384 sayNO;
5385 break;
5386
5387#define CASE_CLASS(nAmE) \
5388 case nAmE: \
f2ed9b32 5389 if ((n=is_##nAmE(locinput,utf8_target))) { \
e1d1eefb
YO		 5390 locinput += n; \
5391 nextchr = UCHARAT(locinput); \
5392 } else \
5393 sayNO; \
5394 break; \
5395 case N##nAmE: \
f2ed9b32 5396 if ((n=is_##nAmE(locinput,utf8_target))) { \
e1d1eefb
YO		 5397 sayNO; \
5398 } else { \
5399 locinput += UTF8SKIP(locinput); \
5400 nextchr = UCHARAT(locinput); \
5401 } \
5402 break
5403
5404 CASE_CLASS(VERTWS);
5405 CASE_CLASS(HORIZWS);
5406#undef CASE_CLASS
5407
a0d0e21e 5408 default:
b900a521 5409 PerlIO_printf(Perl_error_log, "%"UVxf" %d\n",
d7d93a81 5410 PTR2UV(scan), OP(scan));
cea2e8a9 5411 Perl_croak(aTHX_ "regexp memory corruption");
5d458dd8
YO		 5412
5413 } /* end switch */
95b24440 5414
5d458dd8
YO		 5415 /* switch break jumps here */
5416 scan = next; /* prepare to execute the next op and ... */
5417 continue; /* ... jump back to the top, reusing st */
95b24440
DM		 5418 /* NOTREACHED */
5419
40a82448
DM		 5420 push_yes_state:
5421 /* push a state that backtracks on success */
5422 st->u.yes.prev_yes_state = yes_state;
5423 yes_state = st;
5424 /* FALL THROUGH */
5425 push_state:
5426 /* push a new regex state, then continue at scan */
5427 {
5428 regmatch_state *newst;
5429
24b23f37
YO		 5430 DEBUG_STACK_r({
5431 regmatch_state *cur = st;
5432 regmatch_state *curyes = yes_state;
5433 int curd = depth;
5434 regmatch_slab *slab = PL_regmatch_slab;
5435 for (;curd > -1;cur--,curd--) {
5436 if (cur < SLAB_FIRST(slab)) {
5437 slab = slab->prev;
5438 cur = SLAB_LAST(slab);
5439 }
5440 PerlIO_printf(Perl_error_log, "%*s#%-3d %-10s %s\n",
5441 REPORT_CODE_OFF + 2 + depth * 2,"",
13d6edb4 5442 curd, PL_reg_name[cur->resume_state],
24b23f37
YO		 5443 (curyes == cur) ? "yes" : ""
5444 );
5445 if (curyes == cur)
5446 curyes = cur->u.yes.prev_yes_state;
5447 }
5448 } else
5449 DEBUG_STATE_pp("push")
5450 );
40a82448 5451 depth++;
40a82448
DM		 5452 st->locinput = locinput;
5453 newst = st+1;
5454 if (newst > SLAB_LAST(PL_regmatch_slab))
5455 newst = S_push_slab(aTHX);
5456 PL_regmatch_state = newst;
786e8c11 5457
40a82448
DM		 5458 locinput = PL_reginput;
5459 nextchr = UCHARAT(locinput);
5460 st = newst;
5461 continue;
5462 /* NOTREACHED */
5463 }
a0d0e21e 5464 }
a687059c 5465
a0d0e21e
LW		 5466 /*
5467 * We get here only if there's trouble -- normally "case END" is
5468 * the terminating point.
5469 */
cea2e8a9 5470 Perl_croak(aTHX_ "corrupted regexp pointers");
a0d0e21e 5471 /*NOTREACHED*/
4633a7c4
LW		 5472 sayNO;
5473
262b90c4 5474yes:
77cb431f
DM		 5475 if (yes_state) {
5476 /* we have successfully completed a subexpression, but we must now
5477 * pop to the state marked by yes_state and continue from there */
77cb431f 5478 assert(st != yes_state);
5bc10b2c
DM		 5479#ifdef DEBUGGING
5480 while (st != yes_state) {
5481 st--;
5482 if (st < SLAB_FIRST(PL_regmatch_slab)) {
5483 PL_regmatch_slab = PL_regmatch_slab->prev;
5484 st = SLAB_LAST(PL_regmatch_slab);
5485 }
e2e6a0f1 5486 DEBUG_STATE_r({
54612592
YO		 5487 if (no_final) {
5488 DEBUG_STATE_pp("pop (no final)");
5489 } else {
5490 DEBUG_STATE_pp("pop (yes)");
5491 }
e2e6a0f1 5492 });
5bc10b2c
DM		 5493 depth--;
5494 }
5495#else
77cb431f
DM		 5496 while (yes_state < SLAB_FIRST(PL_regmatch_slab)
5497 || yes_state > SLAB_LAST(PL_regmatch_slab))
5498 {
5499 /* not in this slab, pop slab */
5500 depth -= (st - SLAB_FIRST(PL_regmatch_slab) + 1);
5501 PL_regmatch_slab = PL_regmatch_slab->prev;
5502 st = SLAB_LAST(PL_regmatch_slab);
5503 }
5504 depth -= (st - yes_state);
5bc10b2c 5505#endif
77cb431f
DM		 5506 st = yes_state;
5507 yes_state = st->u.yes.prev_yes_state;
5508 PL_regmatch_state = st;
24b23f37 5509
5d458dd8
YO		 5510 if (no_final) {
5511 locinput= st->locinput;
5512 nextchr = UCHARAT(locinput);
5513 }
54612592 5514 state_num = st->resume_state + no_final;
24d3c4a9 5515 goto reenter_switch;
77cb431f
DM		 5516 }
5517
a3621e74 5518 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch successful!%s\n",
e4584336 5519 PL_colors[4], PL_colors[5]));
02db2b7b 5520
19b95bf0
DM		 5521 if (PL_reg_eval_set) {
5522 /* each successfully executed (?{...}) block does the equivalent of
5523 * local $^R = do {...}
5524 * When popping the save stack, all these locals would be undone;
5525 * bypass this by setting the outermost saved $^R to the latest
5526 * value */
5527 if (oreplsv != GvSV(PL_replgv))
5528 sv_setsv(oreplsv, GvSV(PL_replgv));
5529 }
95b24440 5530 result = 1;
aa283a38 5531 goto final_exit;
4633a7c4
LW		 5532
5533no:
a3621e74 5534 DEBUG_EXECUTE_r(
7821416a 5535 PerlIO_printf(Perl_debug_log,
786e8c11 5536 "%*s %sfailed...%s\n",
5bc10b2c 5537 REPORT_CODE_OFF+depth*2, "",
786e8c11 5538 PL_colors[4], PL_colors[5])
7821416a 5539 );
aa283a38 5540
262b90c4 5541no_silent:
54612592
YO		 5542 if (no_final) {
5543 if (yes_state) {
5544 goto yes;
5545 } else {
5546 goto final_exit;
5547 }
5548 }
aa283a38
DM		 5549 if (depth) {
5550 /* there's a previous state to backtrack to */
40a82448
DM		 5551 st--;
5552 if (st < SLAB_FIRST(PL_regmatch_slab)) {
5553 PL_regmatch_slab = PL_regmatch_slab->prev;
5554 st = SLAB_LAST(PL_regmatch_slab);
5555 }
5556 PL_regmatch_state = st;
40a82448
DM		 5557 locinput= st->locinput;
5558 nextchr = UCHARAT(locinput);
5559
5bc10b2c
DM		 5560 DEBUG_STATE_pp("pop");
5561 depth--;
262b90c4
DM		 5562 if (yes_state == st)
5563 yes_state = st->u.yes.prev_yes_state;
5bc10b2c 5564
24d3c4a9
DM		 5565 state_num = st->resume_state + 1; /* failure = success + 1 */
5566 goto reenter_switch;
95b24440 5567 }
24d3c4a9 5568 result = 0;
aa283a38 5569
262b90c4 5570 final_exit:
bbe252da 5571 if (rex->intflags & PREGf_VERBARG_SEEN) {
5d458dd8
YO		 5572 SV *sv_err = get_sv("REGERROR", 1);
5573 SV *sv_mrk = get_sv("REGMARK", 1);
5574 if (result) {
e2e6a0f1 5575 sv_commit = &PL_sv_no;
5d458dd8
YO		 5576 if (!sv_yes_mark)
5577 sv_yes_mark = &PL_sv_yes;
5578 } else {
5579 if (!sv_commit)
5580 sv_commit = &PL_sv_yes;
5581 sv_yes_mark = &PL_sv_no;
5582 }
5583 sv_setsv(sv_err, sv_commit);
5584 sv_setsv(sv_mrk, sv_yes_mark);
e2e6a0f1 5585 }
19b95bf0 5586
2f554ef7
DM		 5587 /* clean up; in particular, free all slabs above current one */
5588 LEAVE_SCOPE(oldsave);
5d9a96ca 5589
95b24440 5590 return result;
a687059c
LW		 5591}
5592
5593/*
5594 - regrepeat - repeatedly match something simple, report how many
5595 */
5596/*
5597 * [This routine now assumes that it will only match on things of length 1.
5598 * That was true before, but now we assume scan - reginput is the count,
a0ed51b3 5599 * rather than incrementing count on every character. [Er, except utf8.]]
a687059c 5600 */
76e3520e 5601STATIC I32
e2e6a0f1 5602S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth)
a687059c 5603{
27da23d5 5604 dVAR;
a0d0e21e 5605 register char *scan;
a0d0e21e 5606 register I32 c;
3280af22 5607 register char *loceol = PL_regeol;
a0ed51b3 5608 register I32 hardcount = 0;
f2ed9b32 5609 register bool utf8_target = PL_reg_match_utf8;
4f55667c
SP		 5610#ifndef DEBUGGING
5611 PERL_UNUSED_ARG(depth);
5612#endif
a0d0e21e 5613
7918f24d
NC		 5614 PERL_ARGS_ASSERT_REGREPEAT;
5615
3280af22 5616 scan = PL_reginput;
faf11cac
HS		 5617 if (max == REG_INFTY)
5618 max = I32_MAX;
5619 else if (max < loceol - scan)
7f596f4c 5620 loceol = scan + max;
a0d0e21e 5621 switch (OP(p)) {
22c35a8c 5622 case REG_ANY:
f2ed9b32 5623 if (utf8_target) {
ffc61ed2 5624 loceol = PL_regeol;
1aa99e6b 5625 while (scan < loceol && hardcount < max && *scan != '\n') {
ffc61ed2
JH		 5626 scan += UTF8SKIP(scan);
5627 hardcount++;
5628 }
5629 } else {
5630 while (scan < loceol && *scan != '\n')
5631 scan++;
a0ed51b3
LW		 5632 }
5633 break;
ffc61ed2 5634 case SANY:
f2ed9b32 5635 if (utf8_target) {
def8e4ea 5636 loceol = PL_regeol;
a0804c9e 5637 while (scan < loceol && hardcount < max) {
def8e4ea
JH		 5638 scan += UTF8SKIP(scan);
5639 hardcount++;
5640 }
5641 }
5642 else
5643 scan = loceol;
a0ed51b3 5644 break;
f33976b4
DB		 5645 case CANY:
5646 scan = loceol;
5647 break;
090f7165
JH		 5648 case EXACT: /* length of string is 1 */
5649 c = (U8)*STRING(p);
5650 while (scan < loceol && UCHARAT(scan) == c)
5651 scan++;
bbce6d69 5652 break;
5653 case EXACTF: /* length of string is 1 */
cd439c50 5654 c = (U8)*STRING(p);
bbce6d69 5655 while (scan < loceol &&
22c35a8c 5656 (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold[c]))
bbce6d69 5657 scan++;
5658 break;
5659 case EXACTFL: /* length of string is 1 */
3280af22 5660 PL_reg_flags |= RF_tainted;
cd439c50 5661 c = (U8)*STRING(p);
bbce6d69 5662 while (scan < loceol &&
22c35a8c 5663 (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold_locale[c]))
a0d0e21e
LW		 5664 scan++;
5665 break;
5666 case ANYOF:
f2ed9b32 5667 if (utf8_target) {
ffc61ed2 5668 loceol = PL_regeol;
cfc92286 5669 while (hardcount < max && scan < loceol &&
f2ed9b32 5670 reginclass(prog, p, (U8*)scan, 0, utf8_target)) {
ffc61ed2
JH		 5671 scan += UTF8SKIP(scan);
5672 hardcount++;
5673 }
5674 } else {
32fc9b6a 5675 while (scan < loceol && REGINCLASS(prog, p, (U8*)scan))
ffc61ed2
JH		 5676 scan++;
5677 }
a0d0e21e
LW		 5678 break;
5679 case ALNUM:
f2ed9b32 5680 if (utf8_target) {
ffc61ed2 5681 loceol = PL_regeol;
1a4fad37 5682 LOAD_UTF8_CHARCLASS_ALNUM();
1aa99e6b 5683 while (hardcount < max && scan < loceol &&
f2ed9b32 5684 swash_fetch(PL_utf8_alnum, (U8*)scan, utf8_target)) {
ffc61ed2
JH		 5685 scan += UTF8SKIP(scan);
5686 hardcount++;
5687 }
5688 } else {
5689 while (scan < loceol && isALNUM(*scan))
5690 scan++;
a0ed51b3
LW		 5691 }
5692 break;
bbce6d69 5693 case ALNUML:
3280af22 5694 PL_reg_flags |= RF_tainted;
f2ed9b32 5695 if (utf8_target) {
ffc61ed2 5696 loceol = PL_regeol;
1aa99e6b
IH		 5697 while (hardcount < max && scan < loceol &&
5698 isALNUM_LC_utf8((U8*)scan)) {
ffc61ed2
JH		 5699 scan += UTF8SKIP(scan);
5700 hardcount++;
5701 }
5702 } else {
5703 while (scan < loceol && isALNUM_LC(*scan))
5704 scan++;
a0ed51b3
LW		 5705 }
5706 break;
a0d0e21e 5707 case NALNUM:
f2ed9b32 5708 if (utf8_target) {
ffc61ed2 5709 loceol = PL_regeol;
1a4fad37 5710 LOAD_UTF8_CHARCLASS_ALNUM();
1aa99e6b 5711 while (hardcount < max && scan < loceol &&
f2ed9b32 5712 !swash_fetch(PL_utf8_alnum, (U8*)scan, utf8_target)) {
ffc61ed2
JH		 5713 scan += UTF8SKIP(scan);
5714 hardcount++;
5715 }
5716 } else {
5717 while (scan < loceol && !isALNUM(*scan))
5718 scan++;
a0ed51b3
LW		 5719 }
5720 break;
bbce6d69 5721 case NALNUML:
3280af22 5722 PL_reg_flags |= RF_tainted;
f2ed9b32 5723 if (utf8_target) {
ffc61ed2 5724 loceol = PL_regeol;
1aa99e6b
IH		 5725 while (hardcount < max && scan < loceol &&
5726 !isALNUM_LC_utf8((U8*)scan)) {
ffc61ed2
JH		 5727 scan += UTF8SKIP(scan);
5728 hardcount++;
5729 }
5730 } else {
5731 while (scan < loceol && !isALNUM_LC(*scan))
5732 scan++;
a0ed51b3
LW		 5733 }
5734 break;
a0d0e21e 5735 case SPACE:
f2ed9b32 5736 if (utf8_target) {
ffc61ed2 5737 loceol = PL_regeol;
1a4fad37 5738 LOAD_UTF8_CHARCLASS_SPACE();
1aa99e6b 5739 while (hardcount < max && scan < loceol &&
3568d838 5740 (*scan == ' ' ||
f2ed9b32 5741 swash_fetch(PL_utf8_space,(U8*)scan, utf8_target))) {
ffc61ed2
JH		 5742 scan += UTF8SKIP(scan);
5743 hardcount++;
5744 }
5745 } else {
5746 while (scan < loceol && isSPACE(*scan))
5747 scan++;
a0ed51b3
LW		 5748 }
5749 break;
bbce6d69 5750 case SPACEL:
3280af22 5751 PL_reg_flags |= RF_tainted;
f2ed9b32 5752 if (utf8_target) {
ffc61ed2 5753 loceol = PL_regeol;
1aa99e6b 5754 while (hardcount < max && scan < loceol &&
ffc61ed2
JH		 5755 (*scan == ' ' || isSPACE_LC_utf8((U8*)scan))) {
5756 scan += UTF8SKIP(scan);
5757 hardcount++;
5758 }
5759 } else {
5760 while (scan < loceol && isSPACE_LC(*scan))
5761 scan++;
a0ed51b3
LW		 5762 }
5763 break;
a0d0e21e 5764 case NSPACE:
f2ed9b32 5765 if (utf8_target) {
ffc61ed2 5766 loceol = PL_regeol;
1a4fad37 5767 LOAD_UTF8_CHARCLASS_SPACE();
1aa99e6b 5768 while (hardcount < max && scan < loceol &&
3568d838 5769 !(*scan == ' ' ||
f2ed9b32 5770 swash_fetch(PL_utf8_space,(U8*)scan, utf8_target))) {
ffc61ed2
JH		 5771 scan += UTF8SKIP(scan);
5772 hardcount++;
5773 }
5774 } else {
5775 while (scan < loceol && !isSPACE(*scan))
5776 scan++;
a0ed51b3 5777 }
0008a298 5778 break;
bbce6d69 5779 case NSPACEL:
3280af22 5780 PL_reg_flags |= RF_tainted;
f2ed9b32 5781 if (utf8_target) {
ffc61ed2 5782 loceol = PL_regeol;
1aa99e6b 5783 while (hardcount < max && scan < loceol &&
ffc61ed2
JH		 5784 !(*scan == ' ' || isSPACE_LC_utf8((U8*)scan))) {
5785 scan += UTF8SKIP(scan);
5786 hardcount++;
5787 }
5788 } else {
5789 while (scan < loceol && !isSPACE_LC(*scan))
5790 scan++;
a0ed51b3
LW		 5791 }
5792 break;
a0d0e21e 5793 case DIGIT:
f2ed9b32 5794 if (utf8_target) {
ffc61ed2 5795 loceol = PL_regeol;
1a4fad37 5796 LOAD_UTF8_CHARCLASS_DIGIT();
1aa99e6b 5797 while (hardcount < max && scan < loceol &&
f2ed9b32 5798 swash_fetch(PL_utf8_digit, (U8*)scan, utf8_target)) {
ffc61ed2
JH		 5799 scan += UTF8SKIP(scan);
5800 hardcount++;
5801 }
5802 } else {
5803 while (scan < loceol && isDIGIT(*scan))
5804 scan++;
a0ed51b3
LW		 5805 }
5806 break;
a0d0e21e 5807 case NDIGIT:
f2ed9b32 5808 if (utf8_target) {
ffc61ed2 5809 loceol = PL_regeol;
1a4fad37 5810 LOAD_UTF8_CHARCLASS_DIGIT();
1aa99e6b 5811 while (hardcount < max && scan < loceol &&
f2ed9b32 5812 !swash_fetch(PL_utf8_digit, (U8*)scan, utf8_target)) {
ffc61ed2
JH		 5813 scan += UTF8SKIP(scan);
5814 hardcount++;
5815 }
5816 } else {
5817 while (scan < loceol && !isDIGIT(*scan))
5818 scan++;
a0ed51b3 5819 }
e1d1eefb 5820 case LNBREAK:
f2ed9b32 5821 if (utf8_target) {
e1d1eefb
YO		 5822 loceol = PL_regeol;
5823 while (hardcount < max && scan < loceol && (c=is_LNBREAK_utf8(scan))) {
5824 scan += c;
5825 hardcount++;
5826 }
5827 } else {
5828 /*
5829 LNBREAK can match two latin chars, which is ok,
5830 because we have a null terminated string, but we
5831 have to use hardcount in this situation
5832 */
5833 while (scan < loceol && (c=is_LNBREAK_latin1(scan))) {
5834 scan+=c;
5835 hardcount++;
5836 }
5837 }
5838 break;
5839 case HORIZWS:
f2ed9b32 5840 if (utf8_target) {
e1d1eefb
YO		 5841 loceol = PL_regeol;
5842 while (hardcount < max && scan < loceol && (c=is_HORIZWS_utf8(scan))) {
5843 scan += c;
5844 hardcount++;
5845 }
5846 } else {
5847 while (scan < loceol && is_HORIZWS_latin1(scan))
5848 scan++;
5849 }
a0ed51b3 5850 break;
e1d1eefb 5851 case NHORIZWS:
f2ed9b32 5852 if (utf8_target) {
e1d1eefb
YO		 5853 loceol = PL_regeol;
5854 while (hardcount < max && scan < loceol && !is_HORIZWS_utf8(scan)) {
5855 scan += UTF8SKIP(scan);
5856 hardcount++;
5857 }
5858 } else {
5859 while (scan < loceol && !is_HORIZWS_latin1(scan))
5860 scan++;
5861
5862 }
5863 break;
5864 case VERTWS:
f2ed9b32 5865 if (utf8_target) {
e1d1eefb
YO		 5866 loceol = PL_regeol;
5867 while (hardcount < max && scan < loceol && (c=is_VERTWS_utf8(scan))) {
5868 scan += c;
5869 hardcount++;
5870 }
5871 } else {
5872 while (scan < loceol && is_VERTWS_latin1(scan))
5873 scan++;
5874
5875 }
5876 break;
5877 case NVERTWS:
f2ed9b32 5878 if (utf8_target) {
e1d1eefb
YO		 5879 loceol = PL_regeol;
5880 while (hardcount < max && scan < loceol && !is_VERTWS_utf8(scan)) {
5881 scan += UTF8SKIP(scan);
5882 hardcount++;
5883 }
5884 } else {
5885 while (scan < loceol && !is_VERTWS_latin1(scan))
5886 scan++;
5887
5888 }
5889 break;
5890
a0d0e21e
LW		 5891 default: /* Called on something of 0 width. */
5892 break; /* So match right here or not at all. */
5893 }
a687059c 5894
a0ed51b3
LW		 5895 if (hardcount)
5896 c = hardcount;
5897 else
5898 c = scan - PL_reginput;
3280af22 5899 PL_reginput = scan;
a687059c 5900
a3621e74 5901 DEBUG_r({
e68ec53f 5902 GET_RE_DEBUG_FLAGS_DECL;
be8e71aa 5903 DEBUG_EXECUTE_r({
e68ec53f
YO		 5904 SV * const prop = sv_newmortal();
5905 regprop(prog, prop, p);
5906 PerlIO_printf(Perl_debug_log,
be8e71aa 5907 "%*s %s can match %"IVdf" times out of %"IVdf"...\n",
e2e6a0f1 5908 REPORT_CODE_OFF + depth*2, "", SvPVX_const(prop),(IV)c,(IV)max);
a3621e74 5909 });
be8e71aa 5910 });
9041c2e3 5911
a0d0e21e 5912 return(c);
a687059c
LW		 5913}
5914
c277df42 5915
be8e71aa 5916#if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
c277df42 5917/*
ffc61ed2
JH		 5918- regclass_swash - prepare the utf8 swash
5919*/
5920
5921SV *
32fc9b6a 5922Perl_regclass_swash(pTHX_ const regexp *prog, register const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
ffc61ed2 5923{
97aff369 5924 dVAR;
9e55ce06
JH		 5925 SV *sw = NULL;
5926 SV *si = NULL;
5927 SV *alt = NULL;
f8fc2ecf
YO		 5928 RXi_GET_DECL(prog,progi);
5929 const struct reg_data * const data = prog ? progi->data : NULL;
ffc61ed2 5930
7918f24d
NC		 5931 PERL_ARGS_ASSERT_REGCLASS_SWASH;
5932
4f639d21 5933 if (data && data->count) {
a3b680e6 5934 const U32 n = ARG(node);
ffc61ed2 5935
4f639d21 5936 if (data->what[n] == 's') {
ad64d0ec
NC		 5937 SV * const rv = MUTABLE_SV(data->data[n]);
5938 AV * const av = MUTABLE_AV(SvRV(rv));
2d03de9c 5939 SV **const ary = AvARRAY(av);
9e55ce06 5940 SV **a, **b;
9041c2e3 5941
711a919c 5942 /* See the end of regcomp.c:S_regclass() for
9e55ce06
JH		 5943 * documentation of these array elements. */
5944
b11f357e 5945 si = *ary;
fe5bfecd
JH		 5946 a = SvROK(ary[1]) ? &ary[1] : NULL;
5947 b = SvTYPE(ary[2]) == SVt_PVAV ? &ary[2] : NULL;
b11f357e 5948
ffc61ed2
JH		 5949 if (a)
5950 sw = *a;
5951 else if (si && doinit) {
5952 sw = swash_init("utf8", "", si, 1, 0);
5953 (void)av_store(av, 1, sw);
5954 }
9e55ce06
JH		 5955 if (b)
5956 alt = *b;
ffc61ed2
JH		 5957 }
5958 }
5959
9e55ce06
JH		 5960 if (listsvp)
5961 *listsvp = si;
5962 if (altsvp)
5963 *altsvp = alt;
ffc61ed2
JH		 5964
5965 return sw;
5966}
76234dfb 5967#endif
ffc61ed2
JH		 5968
5969/*
ba7b4546 5970 - reginclass - determine if a character falls into a character class
832705d4
JH		 5971
5972 The n is the ANYOF regnode, the p is the target string, lenp
5973 is pointer to the maximum length of how far to go in the p
5974 (if the lenp is zero, UTF8SKIP(p) is used),
f2ed9b32 5975 utf8_target tells whether the target string is in UTF-8.
832705d4 5976
bbce6d69 5977 */
5978
76e3520e 5979STATIC bool
f2ed9b32 5980S_reginclass(pTHX_ const regexp *prog, register const regnode *n, register const U8* p, STRLEN* lenp, register bool utf8_target)
bbce6d69 5981{
27da23d5 5982 dVAR;
a3b680e6 5983 const char flags = ANYOF_FLAGS(n);
bbce6d69 5984 bool match = FALSE;
cc07378b 5985 UV c = *p;
ae9ddab8 5986 STRLEN len = 0;
9e55ce06 5987 STRLEN plen;
1aa99e6b 5988
7918f24d
NC		 5989 PERL_ARGS_ASSERT_REGINCLASS;
5990
f2ed9b32 5991 if (utf8_target && !UTF8_IS_INVARIANT(c)) {
19f67299 5992 c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &len,
6182169b
KW		 5993 (UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV)
5994 | UTF8_ALLOW_FFFF | UTF8_CHECK_ONLY);
5995 /* see [perl #37836] for UTF8_ALLOW_ANYUV; [perl #38293] for
5996 * UTF8_ALLOW_FFFF */
e8a70c6f
SP		 5997 if (len == (STRLEN)-1)
5998 Perl_croak(aTHX_ "Malformed UTF-8 character (fatal)");
19f67299 5999 }
bbce6d69 6000
0f0076b4 6001 plen = lenp ? *lenp : UNISKIP(NATIVE_TO_UNI(c));
f2ed9b32 6002 if (utf8_target || (flags & ANYOF_UNICODE)) {
9e55ce06
JH		 6003 if (lenp)
6004 *lenp = 0;
f2ed9b32 6005 if (utf8_target && !ANYOF_RUNTIME(n)) {
ffc61ed2
JH		 6006 if (len != (STRLEN)-1 && c < 256 && ANYOF_BITMAP_TEST(n, c))
6007 match = TRUE;
bbce6d69 6008 }
f2ed9b32 6009 if (!match && utf8_target && (flags & ANYOF_UNICODE_ALL) && c >= 256)
1aa99e6b 6010 match = TRUE;
ffc61ed2 6011 if (!match) {
9e55ce06 6012 AV *av;
32fc9b6a 6013 SV * const sw = regclass_swash(prog, n, TRUE, 0, (SV**)&av);
ffc61ed2
JH		 6014
6015 if (sw) {
3f0c5693 6016 U8 * utf8_p;
f2ed9b32 6017 if (utf8_target) {
3f0c5693
KW		 6018 utf8_p = (U8 *) p;
6019 } else {
6020 STRLEN len = 1;
6021 utf8_p = bytes_to_utf8(p, &len);
6022 }
6023 if (swash_fetch(sw, utf8_p, 1))
ffc61ed2
JH		 6024 match = TRUE;
6025 else if (flags & ANYOF_FOLD) {
9e55ce06
JH		 6026 if (!match && lenp && av) {
6027 I32 i;
9e55ce06 6028 for (i = 0; i <= av_len(av); i++) {
890ce7af 6029 SV* const sv = *av_fetch(av, i, FALSE);
9e55ce06 6030 STRLEN len;
890ce7af 6031 const char * const s = SvPV_const(sv, len);
3f0c5693 6032 if (len <= plen && memEQ(s, (char*)utf8_p, len)) {
9e55ce06
JH		 6033 *lenp = len;
6034 match = TRUE;
6035 break;
6036 }
6037 }
6038 }
6039 if (!match) {
89ebb4a3 6040 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
4a623e43 6041
3f0c5693
KW		 6042 STRLEN tmplen;
6043 to_utf8_fold(utf8_p, tmpbuf, &tmplen);
6044 if (swash_fetch(sw, tmpbuf, 1))
9e55ce06
JH		 6045 match = TRUE;
6046 }
ffc61ed2 6047 }
b3a04dd3
KW		 6048
6049 /* If we allocated a string above, free it */
f2ed9b32 6050 if (! utf8_target) Safefree(utf8_p);
ffc61ed2 6051 }
bbce6d69 6052 }
9e55ce06 6053 if (match && lenp && *lenp == 0)
0f0076b4 6054 *lenp = UNISKIP(NATIVE_TO_UNI(c));
bbce6d69 6055 }
1aa99e6b 6056 if (!match && c < 256) {
ffc61ed2
JH		 6057 if (ANYOF_BITMAP_TEST(n, c))
6058 match = TRUE;
6059 else if (flags & ANYOF_FOLD) {
eb160463 6060 U8 f;
a0ed51b3 6061
ffc61ed2
JH		 6062 if (flags & ANYOF_LOCALE) {
6063 PL_reg_flags |= RF_tainted;
6064 f = PL_fold_locale[c];
6065 }
6066 else
6067 f = PL_fold[c];
6068 if (f != c && ANYOF_BITMAP_TEST(n, f))
6069 match = TRUE;
6070 }
6071
6072 if (!match && (flags & ANYOF_CLASS)) {
a0ed51b3 6073 PL_reg_flags |= RF_tainted;
ffc61ed2
JH		 6074 if (
6075 (ANYOF_CLASS_TEST(n, ANYOF_ALNUM) && isALNUM_LC(c)) ||
6076 (ANYOF_CLASS_TEST(n, ANYOF_NALNUM) && !isALNUM_LC(c)) ||
6077 (ANYOF_CLASS_TEST(n, ANYOF_SPACE) && isSPACE_LC(c)) ||
6078 (ANYOF_CLASS_TEST(n, ANYOF_NSPACE) && !isSPACE_LC(c)) ||
6079 (ANYOF_CLASS_TEST(n, ANYOF_DIGIT) && isDIGIT_LC(c)) ||
6080 (ANYOF_CLASS_TEST(n, ANYOF_NDIGIT) && !isDIGIT_LC(c)) ||
6081 (ANYOF_CLASS_TEST(n, ANYOF_ALNUMC) && isALNUMC_LC(c)) ||
6082 (ANYOF_CLASS_TEST(n, ANYOF_NALNUMC) && !isALNUMC_LC(c)) ||
6083 (ANYOF_CLASS_TEST(n, ANYOF_ALPHA) && isALPHA_LC(c)) ||
6084 (ANYOF_CLASS_TEST(n, ANYOF_NALPHA) && !isALPHA_LC(c)) ||
6085 (ANYOF_CLASS_TEST(n, ANYOF_ASCII) && isASCII(c)) ||
6086 (ANYOF_CLASS_TEST(n, ANYOF_NASCII) && !isASCII(c)) ||
6087 (ANYOF_CLASS_TEST(n, ANYOF_CNTRL) && isCNTRL_LC(c)) ||
6088 (ANYOF_CLASS_TEST(n, ANYOF_NCNTRL) && !isCNTRL_LC(c)) ||
6089 (ANYOF_CLASS_TEST(n, ANYOF_GRAPH) && isGRAPH_LC(c)) ||
6090 (ANYOF_CLASS_TEST(n, ANYOF_NGRAPH) && !isGRAPH_LC(c)) ||
6091 (ANYOF_CLASS_TEST(n, ANYOF_LOWER) && isLOWER_LC(c)) ||
6092 (ANYOF_CLASS_TEST(n, ANYOF_NLOWER) && !isLOWER_LC(c)) ||
6093 (ANYOF_CLASS_TEST(n, ANYOF_PRINT) && isPRINT_LC(c)) ||
6094 (ANYOF_CLASS_TEST(n, ANYOF_NPRINT) && !isPRINT_LC(c)) ||
6095 (ANYOF_CLASS_TEST(n, ANYOF_PUNCT) && isPUNCT_LC(c)) ||
6096 (ANYOF_CLASS_TEST(n, ANYOF_NPUNCT) && !isPUNCT_LC(c)) ||
6097 (ANYOF_CLASS_TEST(n, ANYOF_UPPER) && isUPPER_LC(c)) ||
6098 (ANYOF_CLASS_TEST(n, ANYOF_NUPPER) && !isUPPER_LC(c)) ||
6099 (ANYOF_CLASS_TEST(n, ANYOF_XDIGIT) && isXDIGIT(c)) ||
6100 (ANYOF_CLASS_TEST(n, ANYOF_NXDIGIT) && !isXDIGIT(c)) ||
6101 (ANYOF_CLASS_TEST(n, ANYOF_PSXSPC) && isPSXSPC(c)) ||
6102 (ANYOF_CLASS_TEST(n, ANYOF_NPSXSPC) && !isPSXSPC(c)) ||
6103 (ANYOF_CLASS_TEST(n, ANYOF_BLANK) && isBLANK(c)) ||
6104 (ANYOF_CLASS_TEST(n, ANYOF_NBLANK) && !isBLANK(c))
6105 ) /* How's that for a conditional? */
6106 {
6107 match = TRUE;
6108 }
a0ed51b3 6109 }
a0ed51b3
LW		 6110 }
6111
a0ed51b3
LW		 6112 return (flags & ANYOF_INVERT) ? !match : match;
6113}
161b471a 6114
dfe13c55 6115STATIC U8 *
0ce71af7 6116S_reghop3(U8 *s, I32 off, const U8* lim)
9041c2e3 6117{
97aff369 6118 dVAR;
7918f24d
NC		 6119
6120 PERL_ARGS_ASSERT_REGHOP3;
6121
a0ed51b3 6122 if (off >= 0) {
1aa99e6b 6123 while (off-- && s < lim) {
ffc61ed2 6124 /* XXX could check well-formedness here */
a0ed51b3 6125 s += UTF8SKIP(s);
ffc61ed2 6126 }
a0ed51b3
LW		 6127 }
6128 else {
1de06328
YO		 6129 while (off++ && s > lim) {
6130 s--;
6131 if (UTF8_IS_CONTINUED(*s)) {
6132 while (s > lim && UTF8_IS_CONTINUATION(*s))
6133 s--;
a0ed51b3 6134 }
1de06328 6135 /* XXX could check well-formedness here */
a0ed51b3
LW		 6136 }
6137 }
6138 return s;
6139}
161b471a 6140
f9f4320a
YO		 6141#ifdef XXX_dmq
6142/* there are a bunch of places where we use two reghop3's that should
6143 be replaced with this routine. but since thats not done yet
6144 we ifdef it out - dmq
6145*/
dfe13c55 6146STATIC U8 *
1de06328
YO		 6147S_reghop4(U8 *s, I32 off, const U8* llim, const U8* rlim)
6148{
6149 dVAR;
7918f24d
NC		 6150
6151 PERL_ARGS_ASSERT_REGHOP4;
6152
1de06328
YO		 6153 if (off >= 0) {
6154 while (off-- && s < rlim) {
6155 /* XXX could check well-formedness here */
6156 s += UTF8SKIP(s);
6157 }
6158 }
6159 else {
6160 while (off++ && s > llim) {
6161 s--;
6162 if (UTF8_IS_CONTINUED(*s)) {
6163 while (s > llim && UTF8_IS_CONTINUATION(*s))
6164 s--;
6165 }
6166 /* XXX could check well-formedness here */
6167 }
6168 }
6169 return s;
6170}
f9f4320a 6171#endif
1de06328
YO		 6172
6173STATIC U8 *
0ce71af7 6174S_reghopmaybe3(U8* s, I32 off, const U8* lim)
a0ed51b3 6175{
97aff369 6176 dVAR;
7918f24d
NC		 6177
6178 PERL_ARGS_ASSERT_REGHOPMAYBE3;
6179
a0ed51b3 6180 if (off >= 0) {
1aa99e6b 6181 while (off-- && s < lim) {
ffc61ed2 6182 /* XXX could check well-formedness here */
a0ed51b3 6183 s += UTF8SKIP(s);
ffc61ed2 6184 }
a0ed51b3 6185 if (off >= 0)
3dab1dad 6186 return NULL;
a0ed51b3
LW		 6187 }
6188 else {
1de06328
YO		 6189 while (off++ && s > lim) {
6190 s--;
6191 if (UTF8_IS_CONTINUED(*s)) {
6192 while (s > lim && UTF8_IS_CONTINUATION(*s))
6193 s--;
a0ed51b3 6194 }
1de06328 6195 /* XXX could check well-formedness here */
a0ed51b3
LW		 6196 }
6197 if (off <= 0)
3dab1dad 6198 return NULL;
a0ed51b3
LW		 6199 }
6200 return s;
6201}
51371543 6202
51371543 6203static void
acfe0abc 6204restore_pos(pTHX_ void *arg)
51371543 6205{
97aff369 6206 dVAR;
097eb12c 6207 regexp * const rex = (regexp *)arg;
51371543
GS		 6208 if (PL_reg_eval_set) {
6209 if (PL_reg_oldsaved) {
4f639d21
DM		 6210 rex->subbeg = PL_reg_oldsaved;
6211 rex->sublen = PL_reg_oldsavedlen;
f8c7b90f 6212#ifdef PERL_OLD_COPY_ON_WRITE
4f639d21 6213 rex->saved_copy = PL_nrs;
ed252734 6214#endif
07bc277f 6215 RXp_MATCH_COPIED_on(rex);
51371543
GS		 6216 }
6217 PL_reg_magic->mg_len = PL_reg_oldpos;
6218 PL_reg_eval_set = 0;
6219 PL_curpm = PL_reg_oldcurpm;
6220 }
6221}
33b8afdf
JH		 6222
6223STATIC void
6224S_to_utf8_substr(pTHX_ register regexp *prog)
6225{
a1cac82e 6226 int i = 1;
7918f24d
NC		 6227
6228 PERL_ARGS_ASSERT_TO_UTF8_SUBSTR;
6229
a1cac82e
NC		 6230 do {
6231 if (prog->substrs->data[i].substr
6232 && !prog->substrs->data[i].utf8_substr) {
6233 SV* const sv = newSVsv(prog->substrs->data[i].substr);
6234 prog->substrs->data[i].utf8_substr = sv;
6235 sv_utf8_upgrade(sv);
610460f9
NC		 6236 if (SvVALID(prog->substrs->data[i].substr)) {
6237 const U8 flags = BmFLAGS(prog->substrs->data[i].substr);
6238 if (flags & FBMcf_TAIL) {
6239 /* Trim the trailing \n that fbm_compile added last
6240 time. */
6241 SvCUR_set(sv, SvCUR(sv) - 1);
6242 /* Whilst this makes the SV technically "invalid" (as its
6243 buffer is no longer followed by "\0") when fbm_compile()
6244 adds the "\n" back, a "\0" is restored. */
6245 }
6246 fbm_compile(sv, flags);
6247 }
a1cac82e
NC		 6248 if (prog->substrs->data[i].substr == prog->check_substr)
6249 prog->check_utf8 = sv;
6250 }
6251 } while (i--);
33b8afdf
JH		 6252}
6253
6254STATIC void
6255S_to_byte_substr(pTHX_ register regexp *prog)
6256{
97aff369 6257 dVAR;
a1cac82e 6258 int i = 1;
7918f24d
NC		 6259
6260 PERL_ARGS_ASSERT_TO_BYTE_SUBSTR;
6261
a1cac82e
NC		 6262 do {
6263 if (prog->substrs->data[i].utf8_substr
6264 && !prog->substrs->data[i].substr) {
6265 SV* sv = newSVsv(prog->substrs->data[i].utf8_substr);
6266 if (sv_utf8_downgrade(sv, TRUE)) {
610460f9
NC		 6267 if (SvVALID(prog->substrs->data[i].utf8_substr)) {
6268 const U8 flags
6269 = BmFLAGS(prog->substrs->data[i].utf8_substr);
6270 if (flags & FBMcf_TAIL) {
6271 /* Trim the trailing \n that fbm_compile added last
6272 time. */
6273 SvCUR_set(sv, SvCUR(sv) - 1);
6274 }
6275 fbm_compile(sv, flags);
6276 }
a1cac82e
NC		 6277 } else {
6278 SvREFCNT_dec(sv);
6279 sv = &PL_sv_undef;
6280 }
6281 prog->substrs->data[i].substr = sv;
6282 if (prog->substrs->data[i].utf8_substr == prog->check_utf8)
6283 prog->check_substr = sv;
33b8afdf 6284 }
a1cac82e 6285 } while (i--);
33b8afdf 6286}
66610fdd
RGS		 6287
6288/*
6289 * Local variables:
6290 * c-indentation-style: bsd
6291 * c-basic-offset: 4
6292 * indent-tabs-mode: t
6293 * End:
6294 *
37442d52
RGS		 6295 * ex: set ts=8 sts=4 sw=4 noet:
6296 */
Unnamed repository; edit this file 'description' to name the repository.