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