This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
regcomp.c: Refactor join_exact() to handle all multi-char folds
[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
7e0d5ad7
KW
40/* At least one required character in the target string is expressible only in
41 * UTF-8. */
42const char* const non_utf8_target_but_utf8_required
43 = "Can't match, because target string needs to be in UTF-8\n";
44
a687059c 45/*
e50aee73 46 * pregcomp and pregexec -- regsub and regerror are not used in perl
a687059c
LW
47 *
48 * Copyright (c) 1986 by University of Toronto.
49 * Written by Henry Spencer. Not derived from licensed software.
50 *
51 * Permission is granted to anyone to use this software for any
52 * purpose on any computer system, and to redistribute it freely,
53 * subject to the following restrictions:
54 *
55 * 1. The author is not responsible for the consequences of use of
56 * this software, no matter how awful, even if they arise
57 * from defects in it.
58 *
59 * 2. The origin of this software must not be misrepresented, either
60 * by explicit claim or by omission.
61 *
62 * 3. Altered versions must be plainly marked as such, and must not
63 * be misrepresented as being the original software.
64 *
65 **** Alterations to Henry's code are...
66 ****
4bb101f2 67 **** Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
1129b882
NC
68 **** 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
69 **** by Larry Wall and others
a687059c 70 ****
9ef589d8
LW
71 **** You may distribute under the terms of either the GNU General Public
72 **** License or the Artistic License, as specified in the README file.
a687059c
LW
73 *
74 * Beware that some of this code is subtly aware of the way operator
75 * precedence is structured in regular expressions. Serious changes in
76 * regular-expression syntax might require a total rethink.
77 */
78#include "EXTERN.h"
864dbfa3 79#define PERL_IN_REGEXEC_C
a687059c 80#include "perl.h"
0f5d15d6 81
54df2634
NC
82#ifdef PERL_IN_XSUB_RE
83# include "re_comp.h"
84#else
85# include "regcomp.h"
86#endif
a687059c 87
81e983c1 88#include "inline_invlist.c"
1b0f46bf 89#include "unicode_constants.h"
81e983c1 90
ef07e810 91#define RF_tainted 1 /* tainted information used? e.g. locale */
c277df42 92#define RF_warned 2 /* warned about big count? */
faec1544 93
ab3bbdeb 94#define RF_utf8 8 /* Pattern contains multibyte chars? */
a0ed51b3 95
f2ed9b32 96#define UTF_PATTERN ((PL_reg_flags & RF_utf8) != 0)
ce862d02 97
a687059c
LW
98#ifndef STATIC
99#define STATIC static
100#endif
101
7e2509c1
KW
102/* Valid for non-utf8 strings, non-ANYOFV nodes only: avoids the reginclass
103 * call if there are no complications: i.e., if everything matchable is
104 * straight forward in the bitmap */
af364d03
KW
105#define REGINCLASS(prog,p,c) (ANYOF_FLAGS(p) ? reginclass(prog,p,c,0,0) \
106 : ANYOF_BITMAP_TEST(p,*(c)))
7d3e948e 107
c277df42
IZ
108/*
109 * Forwards.
110 */
111
f2ed9b32 112#define CHR_SVLEN(sv) (utf8_target ? sv_len_utf8(sv) : SvCUR(sv))
53c4c00c 113#define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
a0ed51b3 114
3dab1dad
YO
115#define HOPc(pos,off) \
116 (char *)(PL_reg_match_utf8 \
52657f30 117 ? reghop3((U8*)pos, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr)) \
3dab1dad
YO
118 : (U8*)(pos + off))
119#define HOPBACKc(pos, off) \
07be1b83
YO
120 (char*)(PL_reg_match_utf8\
121 ? reghopmaybe3((U8*)pos, -off, (U8*)PL_bostr) \
122 : (pos - off >= PL_bostr) \
8e11feef 123 ? (U8*)pos - off \
3dab1dad 124 : NULL)
efb30f32 125
e7409c1b 126#define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)(pos), off, (U8*)(lim)) : (U8*)(pos + off))
1aa99e6b 127#define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
1aa99e6b 128
7016d6eb
DM
129
130#define NEXTCHR_EOS -10 /* nextchr has fallen off the end */
131#define NEXTCHR_IS_EOS (nextchr < 0)
132
133#define SET_nextchr \
134 nextchr = ((locinput < PL_regeol) ? UCHARAT(locinput) : NEXTCHR_EOS)
135
136#define SET_locinput(p) \
137 locinput = (p); \
138 SET_nextchr
139
140
20d0b1e9 141/* these are unrolled below in the CCC_TRY_XXX defined */
61dad979 142#define LOAD_UTF8_CHARCLASS(class,str) STMT_START { \
9c4fdda1 143 if (!CAT2(PL_utf8_,class)) { \
cf54f63a 144 bool ok; \
9c4fdda1 145 ENTER; save_re_context(); \
cf54f63a
JL
146 ok=CAT2(is_utf8_,class)((const U8*)str); \
147 PERL_UNUSED_VAR(ok); \
148 assert(ok); assert(CAT2(PL_utf8_,class)); LEAVE; } } STMT_END
37e2e78e
KW
149/* Doesn't do an assert to verify that is correct */
150#define LOAD_UTF8_CHARCLASS_NO_CHECK(class) STMT_START { \
9c4fdda1 151 if (!CAT2(PL_utf8_,class)) { \
9d63fa07 152 bool throw_away PERL_UNUSED_DECL; \
9c4fdda1
RB
153 ENTER; save_re_context(); \
154 throw_away = CAT2(is_utf8_,class)((const U8*)" "); \
155 LEAVE; } } STMT_END
37e2e78e 156
1a4fad37
AL
157#define LOAD_UTF8_CHARCLASS_ALNUM() LOAD_UTF8_CHARCLASS(alnum,"a")
158#define LOAD_UTF8_CHARCLASS_DIGIT() LOAD_UTF8_CHARCLASS(digit,"0")
159#define LOAD_UTF8_CHARCLASS_SPACE() LOAD_UTF8_CHARCLASS(space," ")
51371543 160
37e2e78e 161#define LOAD_UTF8_CHARCLASS_GCB() /* Grapheme cluster boundaries */ \
61dad979
KW
162 /* No asserts are done for some of these, in case called on a */ \
163 /* Unicode version in which they map to nothing */ \
27d4fc33 164 LOAD_UTF8_CHARCLASS(X_regular_begin, HYPHEN_UTF8); \
61dad979 165 LOAD_UTF8_CHARCLASS(X_extend, COMBINING_GRAVE_ACCENT_UTF8); \
20d0b1e9 166
1dcf4a1b 167#define PLACEHOLDER /* Something for the preprocessor to grab onto */
d1eb3177 168
ee9a90b8
KW
169/* The actual code for CCC_TRY, which uses several variables from the routine
170 * it's callable from. It is designed to be the bulk of a case statement.
171 * FUNC is the macro or function to call on non-utf8 targets that indicate if
172 * nextchr matches the class.
173 * UTF8_TEST is the whole test string to use for utf8 targets
174 * LOAD is what to use to test, and if not present to load in the swash for the
175 * class
176 * POS_OR_NEG is either empty or ! to complement the results of FUNC or
177 * UTF8_TEST test.
178 * The logic is: Fail if we're at the end-of-string; otherwise if the target is
179 * utf8 and a variant, load the swash if necessary and test using the utf8
180 * test. Advance to the next character if test is ok, otherwise fail; If not
181 * utf8 or an invariant under utf8, use the non-utf8 test, and fail if it
182 * fails, or advance to the next character */
183
184#define _CCC_TRY_CODE(POS_OR_NEG, FUNC, UTF8_TEST, CLASS, STR) \
7016d6eb 185 if (NEXTCHR_IS_EOS) { \
ee9a90b8
KW
186 sayNO; \
187 } \
188 if (utf8_target && UTF8_IS_CONTINUED(nextchr)) { \
189 LOAD_UTF8_CHARCLASS(CLASS, STR); \
190 if (POS_OR_NEG (UTF8_TEST)) { \
191 sayNO; \
192 } \
ee9a90b8 193 } \
28b98f76
DM
194 else if (POS_OR_NEG (FUNC(nextchr))) { \
195 sayNO; \
ee9a90b8 196 } \
28b98f76 197 goto increment_locinput;
980866de 198
ee9a90b8
KW
199/* Handle the non-locale cases for a character class and its complement. It
200 * calls _CCC_TRY_CODE with a ! to complement the test for the character class.
201 * This is because that code fails when the test succeeds, so we want to have
202 * the test fail so that the code succeeds. The swash is stored in a
203 * predictable PL_ place */
cfaf538b
KW
204#define _CCC_TRY_NONLOCALE(NAME, NNAME, FUNC, \
205 CLASS, STR) \
ee9a90b8
KW
206 case NAME: \
207 _CCC_TRY_CODE( !, FUNC, \
208 cBOOL(swash_fetch(CAT2(PL_utf8_,CLASS), \
209 (U8*)locinput, TRUE)), \
210 CLASS, STR) \
211 case NNAME: \
1dcf4a1b 212 _CCC_TRY_CODE( PLACEHOLDER , FUNC, \
ee9a90b8
KW
213 cBOOL(swash_fetch(CAT2(PL_utf8_,CLASS), \
214 (U8*)locinput, TRUE)), \
215 CLASS, STR) \
216
217/* Generate the case statements for both locale and non-locale character
218 * classes in regmatch for classes that don't have special unicode semantics.
219 * Locales don't use an immediate swash, but an intermediary special locale
220 * function that is called on the pointer to the current place in the input
221 * string. That function will resolve to needing the same swash. One might
222 * think that because we don't know what the locale will match, we shouldn't
223 * check with the swash loading function that it loaded properly; ie, that we
224 * should use LOAD_UTF8_CHARCLASS_NO_CHECK for those, but what is passed to the
225 * regular LOAD_UTF8_CHARCLASS is in non-locale terms, and so locale is
226 * irrelevant here */
227#define CCC_TRY(NAME, NNAME, FUNC, \
228 NAMEL, NNAMEL, LCFUNC, LCFUNC_utf8, \
cfaf538b 229 NAMEA, NNAMEA, FUNCA, \
ee9a90b8
KW
230 CLASS, STR) \
231 case NAMEL: \
232 PL_reg_flags |= RF_tainted; \
233 _CCC_TRY_CODE( !, LCFUNC, LCFUNC_utf8((U8*)locinput), CLASS, STR) \
234 case NNAMEL: \
235 PL_reg_flags |= RF_tainted; \
1dcf4a1b
KW
236 _CCC_TRY_CODE( PLACEHOLDER, LCFUNC, LCFUNC_utf8((U8*)locinput), \
237 CLASS, STR) \
cfaf538b 238 case NAMEA: \
7016d6eb 239 if (NEXTCHR_IS_EOS || ! FUNCA(nextchr)) { \
cfaf538b
KW
240 sayNO; \
241 } \
242 /* Matched a utf8-invariant, so don't have to worry about utf8 */ \
3640db6b 243 locinput++; \
cfaf538b
KW
244 break; \
245 case NNAMEA: \
7016d6eb 246 if (NEXTCHR_IS_EOS || FUNCA(nextchr)) { \
cfaf538b
KW
247 sayNO; \
248 } \
28b98f76 249 goto increment_locinput; \
ee9a90b8
KW
250 /* Generate the non-locale cases */ \
251 _CCC_TRY_NONLOCALE(NAME, NNAME, FUNC, CLASS, STR)
252
253/* This is like CCC_TRY, but has an extra set of parameters for generating case
254 * statements to handle separate Unicode semantics nodes */
255#define CCC_TRY_U(NAME, NNAME, FUNC, \
256 NAMEL, NNAMEL, LCFUNC, LCFUNC_utf8, \
257 NAMEU, NNAMEU, FUNCU, \
cfaf538b 258 NAMEA, NNAMEA, FUNCA, \
ee9a90b8 259 CLASS, STR) \
cfaf538b
KW
260 CCC_TRY(NAME, NNAME, FUNC, \
261 NAMEL, NNAMEL, LCFUNC, LCFUNC_utf8, \
262 NAMEA, NNAMEA, FUNCA, \
263 CLASS, STR) \
ee9a90b8 264 _CCC_TRY_NONLOCALE(NAMEU, NNAMEU, FUNCU, CLASS, STR)
d1eb3177 265
3dab1dad
YO
266/* TODO: Combine JUMPABLE and HAS_TEXT to cache OP(rn) */
267
5f80c4cf 268/* for use after a quantifier and before an EXACT-like node -- japhy */
c35dcbe2
YO
269/* it would be nice to rework regcomp.sym to generate this stuff. sigh
270 *
271 * NOTE that *nothing* that affects backtracking should be in here, specifically
272 * VERBS must NOT be included. JUMPABLE is used to determine if we can ignore a
273 * node that is in between two EXACT like nodes when ascertaining what the required
274 * "follow" character is. This should probably be moved to regex compile time
275 * although it may be done at run time beause of the REF possibility - more
276 * investigation required. -- demerphq
277*/
3e901dc0
YO
278#define JUMPABLE(rn) ( \
279 OP(rn) == OPEN || \
280 (OP(rn) == CLOSE && (!cur_eval || cur_eval->u.eval.close_paren != ARG(rn))) || \
281 OP(rn) == EVAL || \
cca55fe3
JP
282 OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
283 OP(rn) == PLUS || OP(rn) == MINMOD || \
d1c771f5 284 OP(rn) == KEEPS || \
3dab1dad 285 (PL_regkind[OP(rn)] == CURLY && ARG1(rn) > 0) \
e2d8ce26 286)
ee9b8eae 287#define IS_EXACT(rn) (PL_regkind[OP(rn)] == EXACT)
e2d8ce26 288
ee9b8eae
YO
289#define HAS_TEXT(rn) ( IS_EXACT(rn) || PL_regkind[OP(rn)] == REF )
290
291#if 0
292/* Currently these are only used when PL_regkind[OP(rn)] == EXACT so
293 we don't need this definition. */
294#define IS_TEXT(rn) ( OP(rn)==EXACT || OP(rn)==REF || OP(rn)==NREF )
fab2782b 295#define IS_TEXTF(rn) ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn)==EXACTFA || OP(rn)==EXACTF || OP(rn)==REFF || OP(rn)==NREFF )
ee9b8eae
YO
296#define IS_TEXTFL(rn) ( OP(rn)==EXACTFL || OP(rn)==REFFL || OP(rn)==NREFFL )
297
298#else
299/* ... so we use this as its faster. */
300#define IS_TEXT(rn) ( OP(rn)==EXACT )
fab2782b 301#define IS_TEXTFU(rn) ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn) == EXACTFA)
ee9b8eae
YO
302#define IS_TEXTF(rn) ( OP(rn)==EXACTF )
303#define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
304
305#endif
e2d8ce26 306
a84d97b6
HS
307/*
308 Search for mandatory following text node; for lookahead, the text must
309 follow but for lookbehind (rn->flags != 0) we skip to the next step.
310*/
cca55fe3 311#define FIND_NEXT_IMPT(rn) STMT_START { \
3dab1dad
YO
312 while (JUMPABLE(rn)) { \
313 const OPCODE type = OP(rn); \
314 if (type == SUSPEND || PL_regkind[type] == CURLY) \
e2d8ce26 315 rn = NEXTOPER(NEXTOPER(rn)); \
3dab1dad 316 else if (type == PLUS) \
cca55fe3 317 rn = NEXTOPER(rn); \
3dab1dad 318 else if (type == IFMATCH) \
a84d97b6 319 rn = (rn->flags == 0) ? NEXTOPER(NEXTOPER(rn)) : rn + ARG(rn); \
e2d8ce26 320 else rn += NEXT_OFF(rn); \
3dab1dad 321 } \
5f80c4cf 322} STMT_END
74750237 323
c476f425 324
acfe0abc 325static void restore_pos(pTHX_ void *arg);
51371543 326
87c0511b 327#define REGCP_PAREN_ELEMS 3
f067efbf 328#define REGCP_OTHER_ELEMS 3
e0fa7e2b 329#define REGCP_FRAME_ELEMS 1
620d5b66
NC
330/* REGCP_FRAME_ELEMS are not part of the REGCP_OTHER_ELEMS and
331 * are needed for the regexp context stack bookkeeping. */
332
76e3520e 333STATIC CHECKPOINT
b93070ed 334S_regcppush(pTHX_ const regexp *rex, I32 parenfloor)
a0d0e21e 335{
97aff369 336 dVAR;
a3b680e6 337 const int retval = PL_savestack_ix;
a3b680e6 338 const int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
e0fa7e2b
NC
339 const UV total_elems = paren_elems_to_push + REGCP_OTHER_ELEMS;
340 const UV elems_shifted = total_elems << SAVE_TIGHT_SHIFT;
87c0511b 341 I32 p;
40a82448 342 GET_RE_DEBUG_FLAGS_DECL;
a0d0e21e 343
b93070ed
DM
344 PERL_ARGS_ASSERT_REGCPPUSH;
345
e49a9654 346 if (paren_elems_to_push < 0)
5637ef5b
NC
347 Perl_croak(aTHX_ "panic: paren_elems_to_push, %i < 0",
348 paren_elems_to_push);
e49a9654 349
e0fa7e2b
NC
350 if ((elems_shifted >> SAVE_TIGHT_SHIFT) != total_elems)
351 Perl_croak(aTHX_ "panic: paren_elems_to_push offset %"UVuf
5df417d0
JH
352 " out of range (%lu-%ld)",
353 total_elems, (unsigned long)PL_regsize, (long)parenfloor);
e0fa7e2b 354
620d5b66 355 SSGROW(total_elems + REGCP_FRAME_ELEMS);
7f69552c 356
495f47a5
DM
357 DEBUG_BUFFERS_r(
358 if ((int)PL_regsize > (int)parenfloor)
359 PerlIO_printf(Perl_debug_log,
360 "rex=0x%"UVxf" offs=0x%"UVxf": saving capture indices:\n",
361 PTR2UV(rex),
362 PTR2UV(rex->offs)
363 );
364 );
87c0511b 365 for (p = parenfloor+1; p <= (I32)PL_regsize; p++) {
b1ce53c5 366/* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
b93070ed
DM
367 SSPUSHINT(rex->offs[p].end);
368 SSPUSHINT(rex->offs[p].start);
1ca2007e 369 SSPUSHINT(rex->offs[p].start_tmp);
e7707071 370 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
495f47a5
DM
371 " \\%"UVuf": %"IVdf"(%"IVdf")..%"IVdf"\n",
372 (UV)p,
373 (IV)rex->offs[p].start,
374 (IV)rex->offs[p].start_tmp,
375 (IV)rex->offs[p].end
40a82448 376 ));
a0d0e21e 377 }
b1ce53c5 378/* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
3280af22 379 SSPUSHINT(PL_regsize);
b93070ed
DM
380 SSPUSHINT(rex->lastparen);
381 SSPUSHINT(rex->lastcloseparen);
e0fa7e2b 382 SSPUSHUV(SAVEt_REGCONTEXT | elems_shifted); /* Magic cookie. */
41123dfd 383
a0d0e21e
LW
384 return retval;
385}
386
c277df42 387/* These are needed since we do not localize EVAL nodes: */
ab3bbdeb
YO
388#define REGCP_SET(cp) \
389 DEBUG_STATE_r( \
ab3bbdeb 390 PerlIO_printf(Perl_debug_log, \
e4f74956 391 " Setting an EVAL scope, savestack=%"IVdf"\n", \
ab3bbdeb
YO
392 (IV)PL_savestack_ix)); \
393 cp = PL_savestack_ix
c3464db5 394
ab3bbdeb 395#define REGCP_UNWIND(cp) \
e4f74956 396 DEBUG_STATE_r( \
ab3bbdeb 397 if (cp != PL_savestack_ix) \
e4f74956
YO
398 PerlIO_printf(Perl_debug_log, \
399 " Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
ab3bbdeb
YO
400 (IV)(cp), (IV)PL_savestack_ix)); \
401 regcpblow(cp)
c277df42 402
a8d1f4b4
DM
403#define UNWIND_PAREN(lp, lcp) \
404 for (n = rex->lastparen; n > lp; n--) \
405 rex->offs[n].end = -1; \
406 rex->lastparen = n; \
407 rex->lastcloseparen = lcp;
408
409
f067efbf 410STATIC void
b93070ed 411S_regcppop(pTHX_ regexp *rex)
a0d0e21e 412{
97aff369 413 dVAR;
e0fa7e2b 414 UV i;
87c0511b 415 U32 paren;
a3621e74
YO
416 GET_RE_DEBUG_FLAGS_DECL;
417
7918f24d
NC
418 PERL_ARGS_ASSERT_REGCPPOP;
419
b1ce53c5 420 /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
c6bf6a65 421 i = SSPOPUV;
e0fa7e2b
NC
422 assert((i & SAVE_MASK) == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
423 i >>= SAVE_TIGHT_SHIFT; /* Parentheses elements to pop. */
b93070ed
DM
424 rex->lastcloseparen = SSPOPINT;
425 rex->lastparen = SSPOPINT;
3280af22 426 PL_regsize = SSPOPINT;
b1ce53c5 427
620d5b66 428 i -= REGCP_OTHER_ELEMS;
b1ce53c5 429 /* Now restore the parentheses context. */
495f47a5
DM
430 DEBUG_BUFFERS_r(
431 if (i || rex->lastparen + 1 <= rex->nparens)
432 PerlIO_printf(Perl_debug_log,
433 "rex=0x%"UVxf" offs=0x%"UVxf": restoring capture indices to:\n",
434 PTR2UV(rex),
435 PTR2UV(rex->offs)
436 );
437 );
87c0511b 438 paren = PL_regsize;
620d5b66 439 for ( ; i > 0; i -= REGCP_PAREN_ELEMS) {
1df70142 440 I32 tmps;
1ca2007e 441 rex->offs[paren].start_tmp = SSPOPINT;
b93070ed 442 rex->offs[paren].start = SSPOPINT;
cf93c79d 443 tmps = SSPOPINT;
b93070ed
DM
444 if (paren <= rex->lastparen)
445 rex->offs[paren].end = tmps;
495f47a5
DM
446 DEBUG_BUFFERS_r( PerlIO_printf(Perl_debug_log,
447 " \\%"UVuf": %"IVdf"(%"IVdf")..%"IVdf"%s\n",
448 (UV)paren,
449 (IV)rex->offs[paren].start,
450 (IV)rex->offs[paren].start_tmp,
451 (IV)rex->offs[paren].end,
452 (paren > rex->lastparen ? "(skipped)" : ""));
c277df42 453 );
87c0511b 454 paren--;
a0d0e21e 455 }
daf18116 456#if 1
dafc8851
JH
457 /* It would seem that the similar code in regtry()
458 * already takes care of this, and in fact it is in
459 * a better location to since this code can #if 0-ed out
460 * but the code in regtry() is needed or otherwise tests
461 * requiring null fields (pat.t#187 and split.t#{13,14}
daf18116
JH
462 * (as of patchlevel 7877) will fail. Then again,
463 * this code seems to be necessary or otherwise
225593e1
DM
464 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
465 * --jhi updated by dapm */
b93070ed 466 for (i = rex->lastparen + 1; i <= rex->nparens; i++) {
097eb12c 467 if (i > PL_regsize)
b93070ed
DM
468 rex->offs[i].start = -1;
469 rex->offs[i].end = -1;
495f47a5
DM
470 DEBUG_BUFFERS_r( PerlIO_printf(Perl_debug_log,
471 " \\%"UVuf": %s ..-1 undeffing\n",
472 (UV)i,
473 (i > PL_regsize) ? "-1" : " "
474 ));
a0d0e21e 475 }
dafc8851 476#endif
a0d0e21e
LW
477}
478
74088413
DM
479/* restore the parens and associated vars at savestack position ix,
480 * but without popping the stack */
481
482STATIC void
483S_regcp_restore(pTHX_ regexp *rex, I32 ix)
484{
485 I32 tmpix = PL_savestack_ix;
486 PL_savestack_ix = ix;
487 regcppop(rex);
488 PL_savestack_ix = tmpix;
489}
490
02db2b7b 491#define regcpblow(cp) LEAVE_SCOPE(cp) /* Ignores regcppush()ed data. */
a0d0e21e 492
a687059c 493/*
e50aee73 494 * pregexec and friends
a687059c
LW
495 */
496
76234dfb 497#ifndef PERL_IN_XSUB_RE
a687059c 498/*
c277df42 499 - pregexec - match a regexp against a string
a687059c 500 */
c277df42 501I32
49d7dfbc 502Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, register char *strend,
c3464db5 503 char *strbeg, I32 minend, SV *screamer, U32 nosave)
8fd1a950
DM
504/* stringarg: the point in the string at which to begin matching */
505/* strend: pointer to null at end of string */
506/* strbeg: real beginning of string */
507/* minend: end of match must be >= minend bytes after stringarg. */
508/* screamer: SV being matched: only used for utf8 flag, pos() etc; string
509 * itself is accessed via the pointers above */
510/* nosave: For optimizations. */
c277df42 511{
7918f24d
NC
512 PERL_ARGS_ASSERT_PREGEXEC;
513
c277df42 514 return
9041c2e3 515 regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
c277df42
IZ
516 nosave ? 0 : REXEC_COPY_STR);
517}
76234dfb 518#endif
22e551b9 519
9041c2e3 520/*
cad2e5aa
JH
521 * Need to implement the following flags for reg_anch:
522 *
523 * USE_INTUIT_NOML - Useful to call re_intuit_start() first
524 * USE_INTUIT_ML
525 * INTUIT_AUTORITATIVE_NOML - Can trust a positive answer
526 * INTUIT_AUTORITATIVE_ML
527 * INTUIT_ONCE_NOML - Intuit can match in one location only.
528 * INTUIT_ONCE_ML
529 *
530 * Another flag for this function: SECOND_TIME (so that float substrs
531 * with giant delta may be not rechecked).
532 */
533
534/* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
535
3f7c398e 536/* If SCREAM, then SvPVX_const(sv) should be compatible with strpos and strend.
cad2e5aa
JH
537 Otherwise, only SvCUR(sv) is used to get strbeg. */
538
539/* XXXX We assume that strpos is strbeg unless sv. */
540
6eb5f6b9
JH
541/* XXXX Some places assume that there is a fixed substring.
542 An update may be needed if optimizer marks as "INTUITable"
543 RExen without fixed substrings. Similarly, it is assumed that
544 lengths of all the strings are no more than minlen, thus they
545 cannot come from lookahead.
40d049e4
YO
546 (Or minlen should take into account lookahead.)
547 NOTE: Some of this comment is not correct. minlen does now take account
548 of lookahead/behind. Further research is required. -- demerphq
549
550*/
6eb5f6b9 551
2c2d71f5
JH
552/* A failure to find a constant substring means that there is no need to make
553 an expensive call to REx engine, thus we celebrate a failure. Similarly,
554 finding a substring too deep into the string means that less calls to
30944b6d
IZ
555 regtry() should be needed.
556
557 REx compiler's optimizer found 4 possible hints:
558 a) Anchored substring;
559 b) Fixed substring;
560 c) Whether we are anchored (beginning-of-line or \G);
486ec47a 561 d) First node (of those at offset 0) which may distinguish positions;
6eb5f6b9 562 We use a)b)d) and multiline-part of c), and try to find a position in the
30944b6d
IZ
563 string which does not contradict any of them.
564 */
2c2d71f5 565
6eb5f6b9
JH
566/* Most of decisions we do here should have been done at compile time.
567 The nodes of the REx which we used for the search should have been
568 deleted from the finite automaton. */
569
cad2e5aa 570char *
288b8c02 571Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
9f61653a 572 char *strend, const U32 flags, re_scream_pos_data *data)
cad2e5aa 573{
97aff369 574 dVAR;
288b8c02 575 struct regexp *const prog = (struct regexp *)SvANY(rx);
eb578fdb 576 I32 start_shift = 0;
cad2e5aa 577 /* Should be nonnegative! */
eb578fdb
KW
578 I32 end_shift = 0;
579 char *s;
580 SV *check;
a1933d95 581 char *strbeg;
cad2e5aa 582 char *t;
f2ed9b32 583 const bool utf8_target = (sv && SvUTF8(sv)) ? 1 : 0; /* if no sv we have to assume bytes */
cad2e5aa 584 I32 ml_anch;
eb578fdb 585 char *other_last = NULL; /* other substr checked before this */
bd61b366 586 char *check_at = NULL; /* check substr found at this pos */
d8080198 587 char *checked_upto = NULL; /* how far into the string we have already checked using find_byclass*/
bbe252da 588 const I32 multiline = prog->extflags & RXf_PMf_MULTILINE;
f8fc2ecf 589 RXi_GET_DECL(prog,progi);
30944b6d 590#ifdef DEBUGGING
890ce7af 591 const char * const i_strpos = strpos;
30944b6d 592#endif
a3621e74
YO
593 GET_RE_DEBUG_FLAGS_DECL;
594
7918f24d 595 PERL_ARGS_ASSERT_RE_INTUIT_START;
c33e64f0
FC
596 PERL_UNUSED_ARG(flags);
597 PERL_UNUSED_ARG(data);
7918f24d 598
f2ed9b32 599 RX_MATCH_UTF8_set(rx,utf8_target);
cad2e5aa 600
3c8556c3 601 if (RX_UTF8(rx)) {
b8d68ded
JH
602 PL_reg_flags |= RF_utf8;
603 }
ab3bbdeb 604 DEBUG_EXECUTE_r(
f2ed9b32 605 debug_start_match(rx, utf8_target, strpos, strend,
1de06328
YO
606 sv ? "Guessing start of match in sv for"
607 : "Guessing start of match in string for");
2a782b5b 608 );
cad2e5aa 609
c344f387
JH
610 /* CHR_DIST() would be more correct here but it makes things slow. */
611 if (prog->minlen > strend - strpos) {
a3621e74 612 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584 613 "String too short... [re_intuit_start]\n"));
cad2e5aa 614 goto fail;
2c2d71f5 615 }
1de06328 616
7016d6eb
DM
617 /* XXX we need to pass strbeg as a separate arg: the following is
618 * guesswork and can be wrong... */
619 if (sv && SvPOK(sv)) {
620 char * p = SvPVX(sv);
621 STRLEN cur = SvCUR(sv);
622 if (p <= strpos && strpos < p + cur) {
623 strbeg = p;
624 assert(p <= strend && strend <= p + cur);
625 }
626 else
627 strbeg = strend - cur;
628 }
629 else
630 strbeg = strpos;
631
1aa99e6b 632 PL_regeol = strend;
f2ed9b32 633 if (utf8_target) {
33b8afdf
JH
634 if (!prog->check_utf8 && prog->check_substr)
635 to_utf8_substr(prog);
636 check = prog->check_utf8;
637 } else {
7e0d5ad7
KW
638 if (!prog->check_substr && prog->check_utf8) {
639 if (! to_byte_substr(prog)) {
640 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
641 non_utf8_target_but_utf8_required));
642 goto fail;
643 }
644 }
33b8afdf
JH
645 check = prog->check_substr;
646 }
bbe252da
YO
647 if (prog->extflags & RXf_ANCH) { /* Match at beg-of-str or after \n */
648 ml_anch = !( (prog->extflags & RXf_ANCH_SINGLE)
649 || ( (prog->extflags & RXf_ANCH_BOL)
7fba1cd6 650 && !multiline ) ); /* Check after \n? */
cad2e5aa 651
7e25d62c 652 if (!ml_anch) {
bbe252da
YO
653 if ( !(prog->extflags & RXf_ANCH_GPOS) /* Checked by the caller */
654 && !(prog->intflags & PREGf_IMPLICIT) /* not a real BOL */
3f7c398e 655 /* SvCUR is not set on references: SvRV and SvPVX_const overlap */
7e25d62c
JH
656 && sv && !SvROK(sv)
657 && (strpos != strbeg)) {
a3621e74 658 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
7e25d62c
JH
659 goto fail;
660 }
661 if (prog->check_offset_min == prog->check_offset_max &&
bbe252da 662 !(prog->extflags & RXf_CANY_SEEN)) {
2c2d71f5 663 /* Substring at constant offset from beg-of-str... */
cad2e5aa
JH
664 I32 slen;
665
1aa99e6b 666 s = HOP3c(strpos, prog->check_offset_min, strend);
1de06328 667
653099ff
GS
668 if (SvTAIL(check)) {
669 slen = SvCUR(check); /* >= 1 */
cad2e5aa 670
9041c2e3 671 if ( strend - s > slen || strend - s < slen - 1
2c2d71f5 672 || (strend - s == slen && strend[-1] != '\n')) {
a3621e74 673 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
2c2d71f5 674 goto fail_finish;
cad2e5aa
JH
675 }
676 /* Now should match s[0..slen-2] */
677 slen--;
3f7c398e 678 if (slen && (*SvPVX_const(check) != *s
cad2e5aa 679 || (slen > 1
3f7c398e 680 && memNE(SvPVX_const(check), s, slen)))) {
2c2d71f5 681 report_neq:
a3621e74 682 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
2c2d71f5
JH
683 goto fail_finish;
684 }
cad2e5aa 685 }
3f7c398e 686 else if (*SvPVX_const(check) != *s
653099ff 687 || ((slen = SvCUR(check)) > 1
3f7c398e 688 && memNE(SvPVX_const(check), s, slen)))
2c2d71f5 689 goto report_neq;
c315bfe8 690 check_at = s;
2c2d71f5 691 goto success_at_start;
7e25d62c 692 }
cad2e5aa 693 }
2c2d71f5 694 /* Match is anchored, but substr is not anchored wrt beg-of-str. */
cad2e5aa 695 s = strpos;
2c2d71f5 696 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
1de06328
YO
697 end_shift = prog->check_end_shift;
698
2c2d71f5 699 if (!ml_anch) {
a3b680e6 700 const I32 end = prog->check_offset_max + CHR_SVLEN(check)
653099ff 701 - (SvTAIL(check) != 0);
a3b680e6 702 const I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
2c2d71f5
JH
703
704 if (end_shift < eshift)
705 end_shift = eshift;
706 }
cad2e5aa 707 }
2c2d71f5 708 else { /* Can match at random position */
cad2e5aa
JH
709 ml_anch = 0;
710 s = strpos;
1de06328
YO
711 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
712 end_shift = prog->check_end_shift;
713
714 /* end shift should be non negative here */
cad2e5aa
JH
715 }
716
bcdf7404 717#ifdef QDEBUGGING /* 7/99: reports of failure (with the older version) */
0033605d 718 if (end_shift < 0)
1de06328 719 Perl_croak(aTHX_ "panic: end_shift: %"IVdf" pattern:\n%s\n ",
220fc49f 720 (IV)end_shift, RX_PRECOMP(prog));
2c2d71f5
JH
721#endif
722
2c2d71f5
JH
723 restart:
724 /* Find a possible match in the region s..strend by looking for
725 the "check" substring in the region corrected by start/end_shift. */
1de06328
YO
726
727 {
728 I32 srch_start_shift = start_shift;
729 I32 srch_end_shift = end_shift;
c33e64f0
FC
730 U8* start_point;
731 U8* end_point;
1de06328
YO
732 if (srch_start_shift < 0 && strbeg - s > srch_start_shift) {
733 srch_end_shift -= ((strbeg - s) - srch_start_shift);
734 srch_start_shift = strbeg - s;
735 }
6bda09f9 736 DEBUG_OPTIMISE_MORE_r({
1de06328
YO
737 PerlIO_printf(Perl_debug_log, "Check offset min: %"IVdf" Start shift: %"IVdf" End shift %"IVdf" Real End Shift: %"IVdf"\n",
738 (IV)prog->check_offset_min,
739 (IV)srch_start_shift,
740 (IV)srch_end_shift,
741 (IV)prog->check_end_shift);
742 });
743
bbe252da 744 if (prog->extflags & RXf_CANY_SEEN) {
1de06328
YO
745 start_point= (U8*)(s + srch_start_shift);
746 end_point= (U8*)(strend - srch_end_shift);
747 } else {
748 start_point= HOP3(s, srch_start_shift, srch_start_shift < 0 ? strbeg : strend);
749 end_point= HOP3(strend, -srch_end_shift, strbeg);
750 }
6bda09f9 751 DEBUG_OPTIMISE_MORE_r({
56570a2c 752 PerlIO_printf(Perl_debug_log, "fbm_instr len=%d str=<%.*s>\n",
1de06328 753 (int)(end_point - start_point),
fc8cd66c 754 (int)(end_point - start_point) > 20 ? 20 : (int)(end_point - start_point),
1de06328
YO
755 start_point);
756 });
757
758 s = fbm_instr( start_point, end_point,
7fba1cd6 759 check, multiline ? FBMrf_MULTILINE : 0);
1de06328 760 }
cad2e5aa
JH
761 /* Update the count-of-usability, remove useless subpatterns,
762 unshift s. */
2c2d71f5 763
ab3bbdeb 764 DEBUG_EXECUTE_r({
f2ed9b32 765 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
766 SvPVX_const(check), RE_SV_DUMPLEN(check), 30);
767 PerlIO_printf(Perl_debug_log, "%s %s substr %s%s%s",
2c2d71f5 768 (s ? "Found" : "Did not find"),
f2ed9b32 769 (check == (utf8_target ? prog->anchored_utf8 : prog->anchored_substr)
ab3bbdeb
YO
770 ? "anchored" : "floating"),
771 quoted,
772 RE_SV_TAIL(check),
773 (s ? " at offset " : "...\n") );
774 });
2c2d71f5
JH
775
776 if (!s)
777 goto fail_finish;
2c2d71f5 778 /* Finish the diagnostic message */
a3621e74 779 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
2c2d71f5 780
1de06328
YO
781 /* XXX dmq: first branch is for positive lookbehind...
782 Our check string is offset from the beginning of the pattern.
783 So we need to do any stclass tests offset forward from that
784 point. I think. :-(
785 */
786
787
788
789 check_at=s;
790
791
2c2d71f5
JH
792 /* Got a candidate. Check MBOL anchoring, and the *other* substr.
793 Start with the other substr.
794 XXXX no SCREAM optimization yet - and a very coarse implementation
a0288114 795 XXXX /ttx+/ results in anchored="ttx", floating="x". floating will
2c2d71f5
JH
796 *always* match. Probably should be marked during compile...
797 Probably it is right to do no SCREAM here...
798 */
799
f2ed9b32 800 if (utf8_target ? (prog->float_utf8 && prog->anchored_utf8)
1de06328
YO
801 : (prog->float_substr && prog->anchored_substr))
802 {
30944b6d 803 /* Take into account the "other" substring. */
2c2d71f5
JH
804 /* XXXX May be hopelessly wrong for UTF... */
805 if (!other_last)
6eb5f6b9 806 other_last = strpos;
f2ed9b32 807 if (check == (utf8_target ? prog->float_utf8 : prog->float_substr)) {
30944b6d
IZ
808 do_other_anchored:
809 {
890ce7af
AL
810 char * const last = HOP3c(s, -start_shift, strbeg);
811 char *last1, *last2;
be8e71aa 812 char * const saved_s = s;
33b8afdf 813 SV* must;
2c2d71f5 814
2c2d71f5
JH
815 t = s - prog->check_offset_max;
816 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
f2ed9b32 817 && (!utf8_target
0ce71af7 818 || ((t = (char*)reghopmaybe3((U8*)s, -(prog->check_offset_max), (U8*)strpos))
2c2d71f5 819 && t > strpos)))
6f207bd3 820 NOOP;
2c2d71f5
JH
821 else
822 t = strpos;
1aa99e6b 823 t = HOP3c(t, prog->anchored_offset, strend);
6eb5f6b9
JH
824 if (t < other_last) /* These positions already checked */
825 t = other_last;
1aa99e6b 826 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
2c2d71f5
JH
827 if (last < last1)
828 last1 = last;
1de06328
YO
829 /* XXXX It is not documented what units *_offsets are in.
830 We assume bytes, but this is clearly wrong.
831 Meaning this code needs to be carefully reviewed for errors.
832 dmq.
833 */
834
2c2d71f5 835 /* On end-of-str: see comment below. */
f2ed9b32 836 must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
33b8afdf
JH
837 if (must == &PL_sv_undef) {
838 s = (char*)NULL;
1de06328 839 DEBUG_r(must = prog->anchored_utf8); /* for debug */
33b8afdf
JH
840 }
841 else
842 s = fbm_instr(
843 (unsigned char*)t,
844 HOP3(HOP3(last1, prog->anchored_offset, strend)
845 + SvCUR(must), -(SvTAIL(must)!=0), strbeg),
846 must,
7fba1cd6 847 multiline ? FBMrf_MULTILINE : 0
33b8afdf 848 );
ab3bbdeb 849 DEBUG_EXECUTE_r({
f2ed9b32 850 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
851 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
852 PerlIO_printf(Perl_debug_log, "%s anchored substr %s%s",
2c2d71f5 853 (s ? "Found" : "Contradicts"),
ab3bbdeb
YO
854 quoted, RE_SV_TAIL(must));
855 });
856
857
2c2d71f5
JH
858 if (!s) {
859 if (last1 >= last2) {
a3621e74 860 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5
JH
861 ", giving up...\n"));
862 goto fail_finish;
863 }
a3621e74 864 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5 865 ", trying floating at offset %ld...\n",
be8e71aa 866 (long)(HOP3c(saved_s, 1, strend) - i_strpos)));
1aa99e6b
IH
867 other_last = HOP3c(last1, prog->anchored_offset+1, strend);
868 s = HOP3c(last, 1, strend);
2c2d71f5
JH
869 goto restart;
870 }
871 else {
a3621e74 872 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
30944b6d 873 (long)(s - i_strpos)));
1aa99e6b
IH
874 t = HOP3c(s, -prog->anchored_offset, strbeg);
875 other_last = HOP3c(s, 1, strend);
be8e71aa 876 s = saved_s;
2c2d71f5
JH
877 if (t == strpos)
878 goto try_at_start;
2c2d71f5
JH
879 goto try_at_offset;
880 }
30944b6d 881 }
2c2d71f5
JH
882 }
883 else { /* Take into account the floating substring. */
33b8afdf 884 char *last, *last1;
be8e71aa 885 char * const saved_s = s;
33b8afdf
JH
886 SV* must;
887
888 t = HOP3c(s, -start_shift, strbeg);
889 last1 = last =
890 HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
891 if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
892 last = HOP3c(t, prog->float_max_offset, strend);
893 s = HOP3c(t, prog->float_min_offset, strend);
894 if (s < other_last)
895 s = other_last;
2c2d71f5 896 /* XXXX It is not documented what units *_offsets are in. Assume bytes. */
f2ed9b32 897 must = utf8_target ? prog->float_utf8 : prog->float_substr;
33b8afdf
JH
898 /* fbm_instr() takes into account exact value of end-of-str
899 if the check is SvTAIL(ed). Since false positives are OK,
900 and end-of-str is not later than strend we are OK. */
901 if (must == &PL_sv_undef) {
902 s = (char*)NULL;
1de06328 903 DEBUG_r(must = prog->float_utf8); /* for debug message */
33b8afdf
JH
904 }
905 else
2c2d71f5 906 s = fbm_instr((unsigned char*)s,
33b8afdf
JH
907 (unsigned char*)last + SvCUR(must)
908 - (SvTAIL(must)!=0),
7fba1cd6 909 must, multiline ? FBMrf_MULTILINE : 0);
ab3bbdeb 910 DEBUG_EXECUTE_r({
f2ed9b32 911 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
912 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
913 PerlIO_printf(Perl_debug_log, "%s floating substr %s%s",
33b8afdf 914 (s ? "Found" : "Contradicts"),
ab3bbdeb
YO
915 quoted, RE_SV_TAIL(must));
916 });
33b8afdf
JH
917 if (!s) {
918 if (last1 == last) {
a3621e74 919 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf
JH
920 ", giving up...\n"));
921 goto fail_finish;
2c2d71f5 922 }
a3621e74 923 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf 924 ", trying anchored starting at offset %ld...\n",
be8e71aa 925 (long)(saved_s + 1 - i_strpos)));
33b8afdf
JH
926 other_last = last;
927 s = HOP3c(t, 1, strend);
928 goto restart;
929 }
930 else {
a3621e74 931 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
33b8afdf
JH
932 (long)(s - i_strpos)));
933 other_last = s; /* Fix this later. --Hugo */
be8e71aa 934 s = saved_s;
33b8afdf
JH
935 if (t == strpos)
936 goto try_at_start;
937 goto try_at_offset;
938 }
2c2d71f5 939 }
cad2e5aa 940 }
2c2d71f5 941
1de06328 942
9ef43ace 943 t= (char*)HOP3( s, -prog->check_offset_max, (prog->check_offset_max<0) ? strend : strpos);
1de06328 944
6bda09f9 945 DEBUG_OPTIMISE_MORE_r(
1de06328
YO
946 PerlIO_printf(Perl_debug_log,
947 "Check offset min:%"IVdf" max:%"IVdf" S:%"IVdf" t:%"IVdf" D:%"IVdf" end:%"IVdf"\n",
948 (IV)prog->check_offset_min,
949 (IV)prog->check_offset_max,
950 (IV)(s-strpos),
951 (IV)(t-strpos),
952 (IV)(t-s),
953 (IV)(strend-strpos)
954 )
955 );
956
2c2d71f5 957 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
f2ed9b32 958 && (!utf8_target
9ef43ace 959 || ((t = (char*)reghopmaybe3((U8*)s, -prog->check_offset_max, (U8*) ((prog->check_offset_max<0) ? strend : strpos)))
1de06328
YO
960 && t > strpos)))
961 {
2c2d71f5
JH
962 /* Fixed substring is found far enough so that the match
963 cannot start at strpos. */
964 try_at_offset:
cad2e5aa 965 if (ml_anch && t[-1] != '\n') {
30944b6d
IZ
966 /* Eventually fbm_*() should handle this, but often
967 anchored_offset is not 0, so this check will not be wasted. */
968 /* XXXX In the code below we prefer to look for "^" even in
969 presence of anchored substrings. And we search even
970 beyond the found float position. These pessimizations
971 are historical artefacts only. */
972 find_anchor:
2c2d71f5 973 while (t < strend - prog->minlen) {
cad2e5aa 974 if (*t == '\n') {
4ee3650e 975 if (t < check_at - prog->check_offset_min) {
f2ed9b32 976 if (utf8_target ? prog->anchored_utf8 : prog->anchored_substr) {
4ee3650e
GS
977 /* Since we moved from the found position,
978 we definitely contradict the found anchored
30944b6d
IZ
979 substr. Due to the above check we do not
980 contradict "check" substr.
981 Thus we can arrive here only if check substr
982 is float. Redo checking for "other"=="fixed".
983 */
9041c2e3 984 strpos = t + 1;
a3621e74 985 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
e4584336 986 PL_colors[0], PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
30944b6d
IZ
987 goto do_other_anchored;
988 }
4ee3650e
GS
989 /* We don't contradict the found floating substring. */
990 /* XXXX Why not check for STCLASS? */
cad2e5aa 991 s = t + 1;
a3621e74 992 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
e4584336 993 PL_colors[0], PL_colors[1], (long)(s - i_strpos)));
cad2e5aa
JH
994 goto set_useful;
995 }
4ee3650e
GS
996 /* Position contradicts check-string */
997 /* XXXX probably better to look for check-string
998 than for "\n", so one should lower the limit for t? */
a3621e74 999 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
e4584336 1000 PL_colors[0], PL_colors[1], (long)(t + 1 - i_strpos)));
0e41cd87 1001 other_last = strpos = s = t + 1;
cad2e5aa
JH
1002 goto restart;
1003 }
1004 t++;
1005 }
a3621e74 1006 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
e4584336 1007 PL_colors[0], PL_colors[1]));
2c2d71f5 1008 goto fail_finish;
cad2e5aa 1009 }
f5952150 1010 else {
a3621e74 1011 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
e4584336 1012 PL_colors[0], PL_colors[1]));
f5952150 1013 }
cad2e5aa
JH
1014 s = t;
1015 set_useful:
f2ed9b32 1016 ++BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr); /* hooray/5 */
cad2e5aa
JH
1017 }
1018 else {
f5952150 1019 /* The found string does not prohibit matching at strpos,
2c2d71f5 1020 - no optimization of calling REx engine can be performed,
f5952150
GS
1021 unless it was an MBOL and we are not after MBOL,
1022 or a future STCLASS check will fail this. */
2c2d71f5
JH
1023 try_at_start:
1024 /* Even in this situation we may use MBOL flag if strpos is offset
1025 wrt the start of the string. */
05b4157f 1026 if (ml_anch && sv && !SvROK(sv) /* See prev comment on SvROK */
a1933d95 1027 && (strpos != strbeg) && strpos[-1] != '\n'
d506a20d 1028 /* May be due to an implicit anchor of m{.*foo} */
bbe252da 1029 && !(prog->intflags & PREGf_IMPLICIT))
d506a20d 1030 {
cad2e5aa
JH
1031 t = strpos;
1032 goto find_anchor;
1033 }
a3621e74 1034 DEBUG_EXECUTE_r( if (ml_anch)
f5952150 1035 PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
70685ca0 1036 (long)(strpos - i_strpos), PL_colors[0], PL_colors[1]);
30944b6d 1037 );
2c2d71f5 1038 success_at_start:
bbe252da 1039 if (!(prog->intflags & PREGf_NAUGHTY) /* XXXX If strpos moved? */
f2ed9b32 1040 && (utf8_target ? (
33b8afdf
JH
1041 prog->check_utf8 /* Could be deleted already */
1042 && --BmUSEFUL(prog->check_utf8) < 0
1043 && (prog->check_utf8 == prog->float_utf8)
1044 ) : (
1045 prog->check_substr /* Could be deleted already */
1046 && --BmUSEFUL(prog->check_substr) < 0
1047 && (prog->check_substr == prog->float_substr)
1048 )))
66e933ab 1049 {
cad2e5aa 1050 /* If flags & SOMETHING - do not do it many times on the same match */
a3621e74 1051 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
f2ed9b32
KW
1052 /* XXX Does the destruction order has to change with utf8_target? */
1053 SvREFCNT_dec(utf8_target ? prog->check_utf8 : prog->check_substr);
1054 SvREFCNT_dec(utf8_target ? prog->check_substr : prog->check_utf8);
a0714e2c
SS
1055 prog->check_substr = prog->check_utf8 = NULL; /* disable */
1056 prog->float_substr = prog->float_utf8 = NULL; /* clear */
1057 check = NULL; /* abort */
cad2e5aa 1058 s = strpos;
486ec47a 1059 /* XXXX If the check string was an implicit check MBOL, then we need to unset the relevant flag
c9415951
YO
1060 see http://bugs.activestate.com/show_bug.cgi?id=87173 */
1061 if (prog->intflags & PREGf_IMPLICIT)
1062 prog->extflags &= ~RXf_ANCH_MBOL;
3cf5c195
IZ
1063 /* XXXX This is a remnant of the old implementation. It
1064 looks wasteful, since now INTUIT can use many
6eb5f6b9 1065 other heuristics. */
bbe252da 1066 prog->extflags &= ~RXf_USE_INTUIT;
c9415951 1067 /* XXXX What other flags might need to be cleared in this branch? */
cad2e5aa
JH
1068 }
1069 else
1070 s = strpos;
1071 }
1072
6eb5f6b9
JH
1073 /* Last resort... */
1074 /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
1de06328
YO
1075 /* trie stclasses are too expensive to use here, we are better off to
1076 leave it to regmatch itself */
f8fc2ecf 1077 if (progi->regstclass && PL_regkind[OP(progi->regstclass)]!=TRIE) {
6eb5f6b9
JH
1078 /* minlen == 0 is possible if regstclass is \b or \B,
1079 and the fixed substr is ''$.
1080 Since minlen is already taken into account, s+1 is before strend;
1081 accidentally, minlen >= 1 guaranties no false positives at s + 1
1082 even for \b or \B. But (minlen? 1 : 0) below assumes that
1083 regstclass does not come from lookahead... */
1084 /* If regstclass takes bytelength more than 1: If charlength==1, OK.
af944926 1085 This leaves EXACTF-ish only, which are dealt with in find_byclass(). */
f8fc2ecf
YO
1086 const U8* const str = (U8*)STRING(progi->regstclass);
1087 const int cl_l = (PL_regkind[OP(progi->regstclass)] == EXACT
1088 ? CHR_DIST(str+STR_LEN(progi->regstclass), str)
66e933ab 1089 : 1);
1de06328
YO
1090 char * endpos;
1091 if (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1092 endpos= HOP3c(s, (prog->minlen ? cl_l : 0), strend);
1093 else if (prog->float_substr || prog->float_utf8)
1094 endpos= HOP3c(HOP3c(check_at, -start_shift, strbeg), cl_l, strend);
1095 else
1096 endpos= strend;
1097
d8080198
YO
1098 if (checked_upto < s)
1099 checked_upto = s;
1100 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" s: %"IVdf" endpos: %"IVdf" checked_upto: %"IVdf"\n",
1101 (IV)start_shift, (IV)(check_at - strbeg), (IV)(s - strbeg), (IV)(endpos - strbeg), (IV)(checked_upto- strbeg)));
1102
6eb5f6b9 1103 t = s;
d8080198
YO
1104 s = find_byclass(prog, progi->regstclass, checked_upto, endpos, NULL);
1105 if (s) {
1106 checked_upto = s;
1107 } else {
6eb5f6b9 1108#ifdef DEBUGGING
cbbf8932 1109 const char *what = NULL;
6eb5f6b9
JH
1110#endif
1111 if (endpos == strend) {
a3621e74 1112 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
6eb5f6b9
JH
1113 "Could not match STCLASS...\n") );
1114 goto fail;
1115 }
a3621e74 1116 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab 1117 "This position contradicts STCLASS...\n") );
bbe252da 1118 if ((prog->extflags & RXf_ANCH) && !ml_anch)
653099ff 1119 goto fail;
d8080198
YO
1120 checked_upto = HOPBACKc(endpos, start_shift);
1121 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" endpos: %"IVdf" checked_upto: %"IVdf"\n",
1122 (IV)start_shift, (IV)(check_at - strbeg), (IV)(endpos - strbeg), (IV)(checked_upto- strbeg)));
6eb5f6b9 1123 /* Contradict one of substrings */
33b8afdf 1124 if (prog->anchored_substr || prog->anchored_utf8) {
f2ed9b32 1125 if ((utf8_target ? prog->anchored_utf8 : prog->anchored_substr) == check) {
a3621e74 1126 DEBUG_EXECUTE_r( what = "anchored" );
6eb5f6b9 1127 hop_and_restart:
1aa99e6b 1128 s = HOP3c(t, 1, strend);
66e933ab
GS
1129 if (s + start_shift + end_shift > strend) {
1130 /* XXXX Should be taken into account earlier? */
a3621e74 1131 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab
GS
1132 "Could not match STCLASS...\n") );
1133 goto fail;
1134 }
5e39e1e5
HS
1135 if (!check)
1136 goto giveup;
a3621e74 1137 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1138 "Looking for %s substr starting at offset %ld...\n",
6eb5f6b9
JH
1139 what, (long)(s + start_shift - i_strpos)) );
1140 goto restart;
1141 }
66e933ab 1142 /* Have both, check_string is floating */
6eb5f6b9
JH
1143 if (t + start_shift >= check_at) /* Contradicts floating=check */
1144 goto retry_floating_check;
1145 /* Recheck anchored substring, but not floating... */
9041c2e3 1146 s = check_at;
5e39e1e5
HS
1147 if (!check)
1148 goto giveup;
a3621e74 1149 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1150 "Looking for anchored substr starting at offset %ld...\n",
6eb5f6b9
JH
1151 (long)(other_last - i_strpos)) );
1152 goto do_other_anchored;
1153 }
60e71179
GS
1154 /* Another way we could have checked stclass at the
1155 current position only: */
1156 if (ml_anch) {
1157 s = t = t + 1;
5e39e1e5
HS
1158 if (!check)
1159 goto giveup;
a3621e74 1160 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1161 "Looking for /%s^%s/m starting at offset %ld...\n",
e4584336 1162 PL_colors[0], PL_colors[1], (long)(t - i_strpos)) );
60e71179 1163 goto try_at_offset;
66e933ab 1164 }
f2ed9b32 1165 if (!(utf8_target ? prog->float_utf8 : prog->float_substr)) /* Could have been deleted */
60e71179 1166 goto fail;
486ec47a 1167 /* Check is floating substring. */
6eb5f6b9
JH
1168 retry_floating_check:
1169 t = check_at - start_shift;
a3621e74 1170 DEBUG_EXECUTE_r( what = "floating" );
6eb5f6b9
JH
1171 goto hop_and_restart;
1172 }
b7953727 1173 if (t != s) {
a3621e74 1174 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
6eb5f6b9 1175 "By STCLASS: moving %ld --> %ld\n",
b7953727
JH
1176 (long)(t - i_strpos), (long)(s - i_strpos))
1177 );
1178 }
1179 else {
a3621e74 1180 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
b7953727
JH
1181 "Does not contradict STCLASS...\n");
1182 );
1183 }
6eb5f6b9 1184 }
5e39e1e5 1185 giveup:
a3621e74 1186 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
5e39e1e5
HS
1187 PL_colors[4], (check ? "Guessed" : "Giving up"),
1188 PL_colors[5], (long)(s - i_strpos)) );
cad2e5aa 1189 return s;
2c2d71f5
JH
1190
1191 fail_finish: /* Substring not found */
33b8afdf 1192 if (prog->check_substr || prog->check_utf8) /* could be removed already */
f2ed9b32 1193 BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
cad2e5aa 1194 fail:
a3621e74 1195 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
e4584336 1196 PL_colors[4], PL_colors[5]));
bd61b366 1197 return NULL;
cad2e5aa 1198}
9661b544 1199
a0a388a1
YO
1200#define DECL_TRIE_TYPE(scan) \
1201 const enum { trie_plain, trie_utf8, trie_utf8_fold, trie_latin_utf8_fold } \
fab2782b
YO
1202 trie_type = ((scan->flags == EXACT) \
1203 ? (utf8_target ? trie_utf8 : trie_plain) \
1204 : (utf8_target ? trie_utf8_fold : trie_latin_utf8_fold))
1205
1206#define REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc, uscan, len, \
1207uvc, charid, foldlen, foldbuf, uniflags) STMT_START { \
1208 STRLEN skiplen; \
1209 switch (trie_type) { \
1210 case trie_utf8_fold: \
1211 if ( foldlen>0 ) { \
1212 uvc = utf8n_to_uvuni( (const U8*) uscan, UTF8_MAXLEN, &len, uniflags ); \
1213 foldlen -= len; \
1214 uscan += len; \
1215 len=0; \
1216 } else { \
1217 uvc = to_utf8_fold( (const U8*) uc, foldbuf, &foldlen ); \
1218 len = UTF8SKIP(uc); \
1219 skiplen = UNISKIP( uvc ); \
1220 foldlen -= skiplen; \
1221 uscan = foldbuf + skiplen; \
1222 } \
1223 break; \
1224 case trie_latin_utf8_fold: \
1225 if ( foldlen>0 ) { \
1226 uvc = utf8n_to_uvuni( (const U8*) uscan, UTF8_MAXLEN, &len, uniflags ); \
1227 foldlen -= len; \
1228 uscan += len; \
1229 len=0; \
1230 } else { \
1231 len = 1; \
1232 uvc = _to_fold_latin1( (U8) *uc, foldbuf, &foldlen, 1); \
1233 skiplen = UNISKIP( uvc ); \
1234 foldlen -= skiplen; \
1235 uscan = foldbuf + skiplen; \
1236 } \
1237 break; \
1238 case trie_utf8: \
1239 uvc = utf8n_to_uvuni( (const U8*) uc, UTF8_MAXLEN, &len, uniflags ); \
1240 break; \
1241 case trie_plain: \
1242 uvc = (UV)*uc; \
1243 len = 1; \
1244 } \
1245 if (uvc < 256) { \
1246 charid = trie->charmap[ uvc ]; \
1247 } \
1248 else { \
1249 charid = 0; \
1250 if (widecharmap) { \
1251 SV** const svpp = hv_fetch(widecharmap, \
1252 (char*)&uvc, sizeof(UV), 0); \
1253 if (svpp) \
1254 charid = (U16)SvIV(*svpp); \
1255 } \
1256 } \
4cadc6a9
YO
1257} STMT_END
1258
4cadc6a9
YO
1259#define REXEC_FBC_EXACTISH_SCAN(CoNd) \
1260STMT_START { \
1261 while (s <= e) { \
1262 if ( (CoNd) \
fac1af77 1263 && (ln == 1 || folder(s, pat_string, ln)) \
9a5a5549 1264 && (!reginfo || regtry(reginfo, &s)) ) \
4cadc6a9
YO
1265 goto got_it; \
1266 s++; \
1267 } \
1268} STMT_END
1269
1270#define REXEC_FBC_UTF8_SCAN(CoDe) \
1271STMT_START { \
7016d6eb 1272 while (s < strend && s + (uskip = UTF8SKIP(s)) <= strend) { \
4cadc6a9
YO
1273 CoDe \
1274 s += uskip; \
1275 } \
1276} STMT_END
1277
1278#define REXEC_FBC_SCAN(CoDe) \
1279STMT_START { \
1280 while (s < strend) { \
1281 CoDe \
1282 s++; \
1283 } \
1284} STMT_END
1285
1286#define REXEC_FBC_UTF8_CLASS_SCAN(CoNd) \
1287REXEC_FBC_UTF8_SCAN( \
1288 if (CoNd) { \
24b23f37 1289 if (tmp && (!reginfo || regtry(reginfo, &s))) \
4cadc6a9
YO
1290 goto got_it; \
1291 else \
1292 tmp = doevery; \
1293 } \
1294 else \
1295 tmp = 1; \
1296)
1297
1298#define REXEC_FBC_CLASS_SCAN(CoNd) \
1299REXEC_FBC_SCAN( \
1300 if (CoNd) { \
24b23f37 1301 if (tmp && (!reginfo || regtry(reginfo, &s))) \
4cadc6a9
YO
1302 goto got_it; \
1303 else \
1304 tmp = doevery; \
1305 } \
1306 else \
1307 tmp = 1; \
1308)
1309
1310#define REXEC_FBC_TRYIT \
24b23f37 1311if ((!reginfo || regtry(reginfo, &s))) \
4cadc6a9
YO
1312 goto got_it
1313
e1d1eefb 1314#define REXEC_FBC_CSCAN(CoNdUtF8,CoNd) \
f2ed9b32 1315 if (utf8_target) { \
e1d1eefb
YO
1316 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1317 } \
1318 else { \
1319 REXEC_FBC_CLASS_SCAN(CoNd); \
d981ef24 1320 }
e1d1eefb 1321
4cadc6a9 1322#define REXEC_FBC_CSCAN_PRELOAD(UtFpReLoAd,CoNdUtF8,CoNd) \
f2ed9b32 1323 if (utf8_target) { \
4cadc6a9
YO
1324 UtFpReLoAd; \
1325 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1326 } \
1327 else { \
1328 REXEC_FBC_CLASS_SCAN(CoNd); \
d981ef24 1329 }
4cadc6a9
YO
1330
1331#define REXEC_FBC_CSCAN_TAINT(CoNdUtF8,CoNd) \
1332 PL_reg_flags |= RF_tainted; \
f2ed9b32 1333 if (utf8_target) { \
4cadc6a9
YO
1334 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1335 } \
1336 else { \
1337 REXEC_FBC_CLASS_SCAN(CoNd); \
d981ef24 1338 }
4cadc6a9 1339
786e8c11
YO
1340#define DUMP_EXEC_POS(li,s,doutf8) \
1341 dump_exec_pos(li,s,(PL_regeol),(PL_bostr),(PL_reg_starttry),doutf8)
1342
cfaf538b
KW
1343
1344#define UTF8_NOLOAD(TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
1345 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n'; \
1346 tmp = TEST_NON_UTF8(tmp); \
1347 REXEC_FBC_UTF8_SCAN( \
1348 if (tmp == ! TEST_NON_UTF8((U8) *s)) { \
1349 tmp = !tmp; \
1350 IF_SUCCESS; \
1351 } \
1352 else { \
1353 IF_FAIL; \
1354 } \
1355 ); \
1356
1357#define UTF8_LOAD(TeSt1_UtF8, TeSt2_UtF8, IF_SUCCESS, IF_FAIL) \
1358 if (s == PL_bostr) { \
1359 tmp = '\n'; \
1360 } \
1361 else { \
1362 U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr); \
1363 tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT); \
1364 } \
1365 tmp = TeSt1_UtF8; \
1366 LOAD_UTF8_CHARCLASS_ALNUM(); \
1367 REXEC_FBC_UTF8_SCAN( \
1368 if (tmp == ! (TeSt2_UtF8)) { \
1369 tmp = !tmp; \
1370 IF_SUCCESS; \
1371 } \
1372 else { \
1373 IF_FAIL; \
1374 } \
1375 ); \
1376
63ac0dad
KW
1377/* The only difference between the BOUND and NBOUND cases is that
1378 * REXEC_FBC_TRYIT is called when matched in BOUND, and when non-matched in
1379 * NBOUND. This is accomplished by passing it in either the if or else clause,
1380 * with the other one being empty */
1381#define FBC_BOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1382 FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
cfaf538b
KW
1383
1384#define FBC_BOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1385 FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
63ac0dad
KW
1386
1387#define FBC_NBOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1388 FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
cfaf538b
KW
1389
1390#define FBC_NBOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1391 FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
cfaf538b 1392
63ac0dad
KW
1393
1394/* Common to the BOUND and NBOUND cases. Unfortunately the UTF8 tests need to
1395 * be passed in completely with the variable name being tested, which isn't
1396 * such a clean interface, but this is easier to read than it was before. We
1397 * are looking for the boundary (or non-boundary between a word and non-word
1398 * character. The utf8 and non-utf8 cases have the same logic, but the details
1399 * must be different. Find the "wordness" of the character just prior to this
1400 * one, and compare it with the wordness of this one. If they differ, we have
1401 * a boundary. At the beginning of the string, pretend that the previous
1402 * character was a new-line */
cfaf538b 1403#define FBC_BOUND_COMMON(UTF8_CODE, TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
63ac0dad 1404 if (utf8_target) { \
cfaf538b 1405 UTF8_CODE \
63ac0dad
KW
1406 } \
1407 else { /* Not utf8 */ \
1408 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n'; \
1409 tmp = TEST_NON_UTF8(tmp); \
1410 REXEC_FBC_SCAN( \
1411 if (tmp == ! TEST_NON_UTF8((U8) *s)) { \
1412 tmp = !tmp; \
1413 IF_SUCCESS; \
1414 } \
1415 else { \
1416 IF_FAIL; \
1417 } \
1418 ); \
1419 } \
1420 if ((!prog->minlen && tmp) && (!reginfo || regtry(reginfo, &s))) \
1421 goto got_it;
1422
786e8c11
YO
1423/* We know what class REx starts with. Try to find this position... */
1424/* if reginfo is NULL, its a dryrun */
1425/* annoyingly all the vars in this routine have different names from their counterparts
1426 in regmatch. /grrr */
1427
3c3eec57 1428STATIC char *
07be1b83 1429S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
24b23f37 1430 const char *strend, regmatch_info *reginfo)
a687059c 1431{
27da23d5 1432 dVAR;
bbe252da 1433 const I32 doevery = (prog->intflags & PREGf_SKIP) == 0;
fac1af77
KW
1434 char *pat_string; /* The pattern's exactish string */
1435 char *pat_end; /* ptr to end char of pat_string */
1436 re_fold_t folder; /* Function for computing non-utf8 folds */
1437 const U8 *fold_array; /* array for folding ords < 256 */
d8093b23 1438 STRLEN ln;
5dab1207 1439 STRLEN lnc;
eb578fdb 1440 STRLEN uskip;
fac1af77
KW
1441 U8 c1;
1442 U8 c2;
6eb5f6b9 1443 char *e;
eb578fdb
KW
1444 I32 tmp = 1; /* Scratch variable? */
1445 const bool utf8_target = PL_reg_match_utf8;
453bfd44 1446 UV utf8_fold_flags = 0;
f8fc2ecf 1447 RXi_GET_DECL(prog,progi);
7918f24d
NC
1448
1449 PERL_ARGS_ASSERT_FIND_BYCLASS;
f8fc2ecf 1450
6eb5f6b9
JH
1451 /* We know what class it must start with. */
1452 switch (OP(c)) {
f56b6394 1453 case ANYOFV:
6eb5f6b9 1454 case ANYOF:
f56b6394 1455 if (utf8_target || OP(c) == ANYOFV) {
b1e3e569
KW
1456 STRLEN inclasslen = strend - s;
1457 REXEC_FBC_UTF8_CLASS_SCAN(
1458 reginclass(prog, c, (U8*)s, &inclasslen, utf8_target));
388cc4de
HS
1459 }
1460 else {
6ef69d56 1461 REXEC_FBC_CLASS_SCAN(REGINCLASS(prog, c, (U8*)s));
a0d0e21e 1462 }
6eb5f6b9 1463 break;
f33976b4 1464 case CANY:
4cadc6a9 1465 REXEC_FBC_SCAN(
24b23f37 1466 if (tmp && (!reginfo || regtry(reginfo, &s)))
f33976b4
DB
1467 goto got_it;
1468 else
1469 tmp = doevery;
4cadc6a9 1470 );
f33976b4 1471 break;
2f7f8cb1
KW
1472
1473 case EXACTFA:
1474 if (UTF_PATTERN || utf8_target) {
1475 utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
1476 goto do_exactf_utf8;
1477 }
1478 fold_array = PL_fold_latin1; /* Latin1 folds are not affected by */
1479 folder = foldEQ_latin1; /* /a, except the sharp s one which */
1480 goto do_exactf_non_utf8; /* isn't dealt with by these */
1481
6eb5f6b9 1482 case EXACTF:
62bf7766 1483 if (utf8_target) {
77a6d856
KW
1484
1485 /* regcomp.c already folded this if pattern is in UTF-8 */
62bf7766 1486 utf8_fold_flags = 0;
fac1af77
KW
1487 goto do_exactf_utf8;
1488 }
1489 fold_array = PL_fold;
1490 folder = foldEQ;
1491 goto do_exactf_non_utf8;
1492
1493 case EXACTFL:
1494 if (UTF_PATTERN || utf8_target) {
17580e7a 1495 utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
fac1af77
KW
1496 goto do_exactf_utf8;
1497 }
1498 fold_array = PL_fold_locale;
1499 folder = foldEQ_locale;
16d951b7
KW
1500 goto do_exactf_non_utf8;
1501
3c760661
KW
1502 case EXACTFU_SS:
1503 if (UTF_PATTERN) {
1504 utf8_fold_flags = FOLDEQ_S2_ALREADY_FOLDED;
1505 }
1506 goto do_exactf_utf8;
1507
fab2782b 1508 case EXACTFU_TRICKYFOLD:
16d951b7
KW
1509 case EXACTFU:
1510 if (UTF_PATTERN || utf8_target) {
77a6d856 1511 utf8_fold_flags = (UTF_PATTERN) ? FOLDEQ_S2_ALREADY_FOLDED : 0;
16d951b7
KW
1512 goto do_exactf_utf8;
1513 }
1514
1515 /* Any 'ss' in the pattern should have been replaced by regcomp,
1516 * so we don't have to worry here about this single special case
1517 * in the Latin1 range */
1518 fold_array = PL_fold_latin1;
1519 folder = foldEQ_latin1;
fac1af77
KW
1520
1521 /* FALL THROUGH */
1522
62bf7766
KW
1523 do_exactf_non_utf8: /* Neither pattern nor string are UTF8, and there
1524 are no glitches with fold-length differences
1525 between the target string and pattern */
fac1af77
KW
1526
1527 /* The idea in the non-utf8 EXACTF* cases is to first find the
1528 * first character of the EXACTF* node and then, if necessary,
1529 * case-insensitively compare the full text of the node. c1 is the
1530 * first character. c2 is its fold. This logic will not work for
1531 * Unicode semantics and the german sharp ss, which hence should
1532 * not be compiled into a node that gets here. */
1533 pat_string = STRING(c);
1534 ln = STR_LEN(c); /* length to match in octets/bytes */
1535
8a90a8fe
KW
1536 /* We know that we have to match at least 'ln' bytes (which is the
1537 * same as characters, since not utf8). If we have to match 3
1538 * characters, and there are only 2 availabe, we know without
1539 * trying that it will fail; so don't start a match past the
1540 * required minimum number from the far end */
fac1af77
KW
1541 e = HOP3c(strend, -((I32)ln), s);
1542
1543 if (!reginfo && e < s) {
1544 e = s; /* Due to minlen logic of intuit() */
1545 }
1546
1547 c1 = *pat_string;
1548 c2 = fold_array[c1];
1549 if (c1 == c2) { /* If char and fold are the same */
1550 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1);
1551 }
1552 else {
1553 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1 || *(U8*)s == c2);
1554 }
1555 break;
1556
1557 do_exactf_utf8:
e067297c
KW
1558 {
1559 unsigned expansion;
1560
fac1af77
KW
1561
1562 /* If one of the operands is in utf8, we can't use the simpler
1563 * folding above, due to the fact that many different characters
1564 * can have the same fold, or portion of a fold, or different-
1565 * length fold */
1566 pat_string = STRING(c);
1567 ln = STR_LEN(c); /* length to match in octets/bytes */
1568 pat_end = pat_string + ln;
1569 lnc = (UTF_PATTERN) /* length to match in characters */
1570 ? utf8_length((U8 *) pat_string, (U8 *) pat_end)
1571 : ln;
1572
e067297c
KW
1573 /* We have 'lnc' characters to match in the pattern, but because of
1574 * multi-character folding, each character in the target can match
1575 * up to 3 characters (Unicode guarantees it will never exceed
1576 * this) if it is utf8-encoded; and up to 2 if not (based on the
1577 * fact that the Latin 1 folds are already determined, and the
1578 * only multi-char fold in that range is the sharp-s folding to
1579 * 'ss'. Thus, a pattern character can match as little as 1/3 of a
89378d8a
KW
1580 * string character. Adjust lnc accordingly, rounding up, so that
1581 * if we need to match at least 4+1/3 chars, that really is 5. */
e067297c 1582 expansion = (utf8_target) ? UTF8_MAX_FOLD_CHAR_EXPAND : 2;
89378d8a 1583 lnc = (lnc + expansion - 1) / expansion;
e067297c
KW
1584
1585 /* As in the non-UTF8 case, if we have to match 3 characters, and
1586 * only 2 are left, it's guaranteed to fail, so don't start a
1587 * match that would require us to go beyond the end of the string
1588 */
1589 e = HOP3c(strend, -((I32)lnc), s);
fac1af77
KW
1590
1591 if (!reginfo && e < s) {
1592 e = s; /* Due to minlen logic of intuit() */
1593 }
1594
b33105db
KW
1595 /* XXX Note that we could recalculate e to stop the loop earlier,
1596 * as the worst case expansion above will rarely be met, and as we
1597 * go along we would usually find that e moves further to the left.
1598 * This would happen only after we reached the point in the loop
1599 * where if there were no expansion we should fail. Unclear if
1600 * worth the expense */
e067297c 1601
fac1af77
KW
1602 while (s <= e) {
1603 char *my_strend= (char *)strend;
1604 if (foldEQ_utf8_flags(s, &my_strend, 0, utf8_target,
1605 pat_string, NULL, ln, cBOOL(UTF_PATTERN), utf8_fold_flags)
1606 && (!reginfo || regtry(reginfo, &s)) )
1607 {
1608 goto got_it;
1609 }
bbdd8bad 1610 s += (utf8_target) ? UTF8SKIP(s) : 1;
fac1af77
KW
1611 }
1612 break;
e067297c 1613 }
bbce6d69 1614 case BOUNDL:
3280af22 1615 PL_reg_flags |= RF_tainted;
63ac0dad
KW
1616 FBC_BOUND(isALNUM_LC,
1617 isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp)),
1618 isALNUM_LC_utf8((U8*)s));
a0ed51b3 1619 break;
bbce6d69 1620 case NBOUNDL:
3280af22 1621 PL_reg_flags |= RF_tainted;
63ac0dad
KW
1622 FBC_NBOUND(isALNUM_LC,
1623 isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp)),
1624 isALNUM_LC_utf8((U8*)s));
1625 break;
1626 case BOUND:
1627 FBC_BOUND(isWORDCHAR,
1628 isALNUM_uni(tmp),
1629 cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1630 break;
cfaf538b
KW
1631 case BOUNDA:
1632 FBC_BOUND_NOLOAD(isWORDCHAR_A,
1633 isWORDCHAR_A(tmp),
1634 isWORDCHAR_A((U8*)s));
1635 break;
a0d0e21e 1636 case NBOUND:
63ac0dad
KW
1637 FBC_NBOUND(isWORDCHAR,
1638 isALNUM_uni(tmp),
1639 cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1640 break;
cfaf538b
KW
1641 case NBOUNDA:
1642 FBC_NBOUND_NOLOAD(isWORDCHAR_A,
1643 isWORDCHAR_A(tmp),
1644 isWORDCHAR_A((U8*)s));
1645 break;
63ac0dad
KW
1646 case BOUNDU:
1647 FBC_BOUND(isWORDCHAR_L1,
1648 isALNUM_uni(tmp),
1649 cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1650 break;
1651 case NBOUNDU:
1652 FBC_NBOUND(isWORDCHAR_L1,
1653 isALNUM_uni(tmp),
1654 cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
a0ed51b3 1655 break;
bbce6d69 1656 case ALNUML:
4cadc6a9
YO
1657 REXEC_FBC_CSCAN_TAINT(
1658 isALNUM_LC_utf8((U8*)s),
1659 isALNUM_LC(*s)
1660 );
6895a8aa 1661 break;
980866de
KW
1662 case ALNUMU:
1663 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1664 LOAD_UTF8_CHARCLASS_ALNUM(),
1665 swash_fetch(PL_utf8_alnum,(U8*)s, utf8_target),
980866de
KW
1666 isWORDCHAR_L1((U8) *s)
1667 );
6895a8aa 1668 break;
980866de
KW
1669 case ALNUM:
1670 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1671 LOAD_UTF8_CHARCLASS_ALNUM(),
1672 swash_fetch(PL_utf8_alnum,(U8*)s, utf8_target),
980866de
KW
1673 isWORDCHAR((U8) *s)
1674 );
6895a8aa 1675 break;
cfaf538b 1676 case ALNUMA:
8e9da4d4
KW
1677 /* Don't need to worry about utf8, as it can match only a single
1678 * byte invariant character */
cfaf538b 1679 REXEC_FBC_CLASS_SCAN( isWORDCHAR_A(*s));
6895a8aa 1680 break;
980866de
KW
1681 case NALNUMU:
1682 REXEC_FBC_CSCAN_PRELOAD(
779d7b58 1683 LOAD_UTF8_CHARCLASS_ALNUM(),
359960d4 1684 !swash_fetch(PL_utf8_alnum,(U8*)s, utf8_target),
980866de
KW
1685 ! isWORDCHAR_L1((U8) *s)
1686 );
6895a8aa 1687 break;
a0d0e21e 1688 case NALNUM:
4cadc6a9 1689 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1690 LOAD_UTF8_CHARCLASS_ALNUM(),
1691 !swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target),
980866de 1692 ! isALNUM(*s)
4cadc6a9 1693 );
6895a8aa 1694 break;
cfaf538b 1695 case NALNUMA:
8e9da4d4
KW
1696 REXEC_FBC_CSCAN(
1697 !isWORDCHAR_A(*s),
1698 !isWORDCHAR_A(*s)
1699 );
1700 break;
bbce6d69 1701 case NALNUML:
4cadc6a9
YO
1702 REXEC_FBC_CSCAN_TAINT(
1703 !isALNUM_LC_utf8((U8*)s),
1704 !isALNUM_LC(*s)
1705 );
6895a8aa 1706 break;
980866de
KW
1707 case SPACEU:
1708 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1709 LOAD_UTF8_CHARCLASS_SPACE(),
1710 *s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target),
980866de
KW
1711 isSPACE_L1((U8) *s)
1712 );
6895a8aa 1713 break;
a0d0e21e 1714 case SPACE:
4cadc6a9 1715 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1716 LOAD_UTF8_CHARCLASS_SPACE(),
1717 *s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target),
980866de 1718 isSPACE((U8) *s)
4cadc6a9 1719 );
6895a8aa 1720 break;
cfaf538b 1721 case SPACEA:
8e9da4d4
KW
1722 /* Don't need to worry about utf8, as it can match only a single
1723 * byte invariant character */
cfaf538b 1724 REXEC_FBC_CLASS_SCAN( isSPACE_A(*s));
6895a8aa 1725 break;
bbce6d69 1726 case SPACEL:
4cadc6a9 1727 REXEC_FBC_CSCAN_TAINT(
6bbba904 1728 isSPACE_LC_utf8((U8*)s),
4cadc6a9
YO
1729 isSPACE_LC(*s)
1730 );
6895a8aa 1731 break;
980866de
KW
1732 case NSPACEU:
1733 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1734 LOAD_UTF8_CHARCLASS_SPACE(),
1735 !( *s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target)),
980866de
KW
1736 ! isSPACE_L1((U8) *s)
1737 );
6895a8aa 1738 break;
a0d0e21e 1739 case NSPACE:
4cadc6a9 1740 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1741 LOAD_UTF8_CHARCLASS_SPACE(),
1742 !(*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target)),
980866de 1743 ! isSPACE((U8) *s)
4cadc6a9 1744 );
6895a8aa 1745 break;
cfaf538b 1746 case NSPACEA:
8e9da4d4
KW
1747 REXEC_FBC_CSCAN(
1748 !isSPACE_A(*s),
1749 !isSPACE_A(*s)
1750 );
1751 break;
bbce6d69 1752 case NSPACEL:
4cadc6a9 1753 REXEC_FBC_CSCAN_TAINT(
6bbba904 1754 !isSPACE_LC_utf8((U8*)s),
4cadc6a9
YO
1755 !isSPACE_LC(*s)
1756 );
6895a8aa 1757 break;
a0d0e21e 1758 case DIGIT:
4cadc6a9 1759 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1760 LOAD_UTF8_CHARCLASS_DIGIT(),
1761 swash_fetch(PL_utf8_digit,(U8*)s, utf8_target),
4cadc6a9
YO
1762 isDIGIT(*s)
1763 );
6895a8aa 1764 break;
cfaf538b 1765 case DIGITA:
8e9da4d4
KW
1766 /* Don't need to worry about utf8, as it can match only a single
1767 * byte invariant character */
cfaf538b 1768 REXEC_FBC_CLASS_SCAN( isDIGIT_A(*s));
6895a8aa 1769 break;
b8c5462f 1770 case DIGITL:
4cadc6a9
YO
1771 REXEC_FBC_CSCAN_TAINT(
1772 isDIGIT_LC_utf8((U8*)s),
1773 isDIGIT_LC(*s)
1774 );
6895a8aa 1775 break;
a0d0e21e 1776 case NDIGIT:
4cadc6a9 1777 REXEC_FBC_CSCAN_PRELOAD(
779d7b58
KW
1778 LOAD_UTF8_CHARCLASS_DIGIT(),
1779 !swash_fetch(PL_utf8_digit,(U8*)s, utf8_target),
4cadc6a9
YO
1780 !isDIGIT(*s)
1781 );
6895a8aa 1782 break;
cfaf538b 1783 case NDIGITA:
8e9da4d4
KW
1784 REXEC_FBC_CSCAN(
1785 !isDIGIT_A(*s),
1786 !isDIGIT_A(*s)
1787 );
1788 break;
b8c5462f 1789 case NDIGITL:
4cadc6a9
YO
1790 REXEC_FBC_CSCAN_TAINT(
1791 !isDIGIT_LC_utf8((U8*)s),
1792 !isDIGIT_LC(*s)
1793 );
6895a8aa 1794 break;
e1d1eefb
YO
1795 case LNBREAK:
1796 REXEC_FBC_CSCAN(
7016d6eb
DM
1797 is_LNBREAK_utf8_safe(s, strend),
1798 is_LNBREAK_latin1_safe(s, strend)
e1d1eefb 1799 );
6895a8aa 1800 break;
e1d1eefb
YO
1801 case VERTWS:
1802 REXEC_FBC_CSCAN(
7016d6eb
DM
1803 is_VERTWS_utf8_safe(s, strend),
1804 is_VERTWS_latin1_safe(s, strend)
e1d1eefb 1805 );
6895a8aa 1806 break;
e1d1eefb
YO
1807 case NVERTWS:
1808 REXEC_FBC_CSCAN(
7016d6eb
DM
1809 !is_VERTWS_utf8_safe(s, strend),
1810 !is_VERTWS_latin1_safe(s, strend)
e1d1eefb 1811 );
6895a8aa 1812 break;
e1d1eefb
YO
1813 case HORIZWS:
1814 REXEC_FBC_CSCAN(
7016d6eb
DM
1815 is_HORIZWS_utf8_safe(s, strend),
1816 is_HORIZWS_latin1_safe(s, strend)
e1d1eefb 1817 );
6895a8aa 1818 break;
e1d1eefb
YO
1819 case NHORIZWS:
1820 REXEC_FBC_CSCAN(
7016d6eb
DM
1821 !is_HORIZWS_utf8_safe(s, strend),
1822 !is_HORIZWS_latin1_safe(s, strend)
e1d1eefb 1823 );
6895a8aa 1824 break;
0658cdde
KW
1825 case POSIXA:
1826 /* Don't need to worry about utf8, as it can match only a single
1827 * byte invariant character. The flag in this node type is the
1828 * class number to pass to _generic_isCC() to build a mask for
1829 * searching in PL_charclass[] */
1830 REXEC_FBC_CLASS_SCAN( _generic_isCC_A(*s, FLAGS(c)));
1831 break;
1832 case NPOSIXA:
1833 REXEC_FBC_CSCAN(
1834 !_generic_isCC_A(*s, FLAGS(c)),
1835 !_generic_isCC_A(*s, FLAGS(c))
1836 );
1837 break;
1838
1de06328
YO
1839 case AHOCORASICKC:
1840 case AHOCORASICK:
07be1b83 1841 {
a0a388a1 1842 DECL_TRIE_TYPE(c);
07be1b83
YO
1843 /* what trie are we using right now */
1844 reg_ac_data *aho
f8fc2ecf 1845 = (reg_ac_data*)progi->data->data[ ARG( c ) ];
3251b653
NC
1846 reg_trie_data *trie
1847 = (reg_trie_data*)progi->data->data[ aho->trie ];
85fbaab2 1848 HV *widecharmap = MUTABLE_HV(progi->data->data[ aho->trie + 1 ]);
07be1b83
YO
1849
1850 const char *last_start = strend - trie->minlen;
6148ee25 1851#ifdef DEBUGGING
07be1b83 1852 const char *real_start = s;
6148ee25 1853#endif
07be1b83 1854 STRLEN maxlen = trie->maxlen;
be8e71aa
YO
1855 SV *sv_points;
1856 U8 **points; /* map of where we were in the input string
786e8c11 1857 when reading a given char. For ASCII this
be8e71aa 1858 is unnecessary overhead as the relationship
38a44b82
NC
1859 is always 1:1, but for Unicode, especially
1860 case folded Unicode this is not true. */
f9e705e8 1861 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
786e8c11
YO
1862 U8 *bitmap=NULL;
1863
07be1b83
YO
1864
1865 GET_RE_DEBUG_FLAGS_DECL;
1866
be8e71aa
YO
1867 /* We can't just allocate points here. We need to wrap it in
1868 * an SV so it gets freed properly if there is a croak while
1869 * running the match */
1870 ENTER;
1871 SAVETMPS;
1872 sv_points=newSV(maxlen * sizeof(U8 *));
1873 SvCUR_set(sv_points,
1874 maxlen * sizeof(U8 *));
1875 SvPOK_on(sv_points);
1876 sv_2mortal(sv_points);
1877 points=(U8**)SvPV_nolen(sv_points );
1de06328
YO
1878 if ( trie_type != trie_utf8_fold
1879 && (trie->bitmap || OP(c)==AHOCORASICKC) )
1880 {
786e8c11
YO
1881 if (trie->bitmap)
1882 bitmap=(U8*)trie->bitmap;
1883 else
1884 bitmap=(U8*)ANYOF_BITMAP(c);
07be1b83 1885 }
786e8c11
YO
1886 /* this is the Aho-Corasick algorithm modified a touch
1887 to include special handling for long "unknown char"
1888 sequences. The basic idea being that we use AC as long
1889 as we are dealing with a possible matching char, when
1890 we encounter an unknown char (and we have not encountered
1891 an accepting state) we scan forward until we find a legal
1892 starting char.
1893 AC matching is basically that of trie matching, except
1894 that when we encounter a failing transition, we fall back
1895 to the current states "fail state", and try the current char
1896 again, a process we repeat until we reach the root state,
1897 state 1, or a legal transition. If we fail on the root state
1898 then we can either terminate if we have reached an accepting
1899 state previously, or restart the entire process from the beginning
1900 if we have not.
1901
1902 */
07be1b83
YO
1903 while (s <= last_start) {
1904 const U32 uniflags = UTF8_ALLOW_DEFAULT;
1905 U8 *uc = (U8*)s;
1906 U16 charid = 0;
1907 U32 base = 1;
1908 U32 state = 1;
1909 UV uvc = 0;
1910 STRLEN len = 0;
1911 STRLEN foldlen = 0;
1912 U8 *uscan = (U8*)NULL;
1913 U8 *leftmost = NULL;
786e8c11
YO
1914#ifdef DEBUGGING
1915 U32 accepted_word= 0;
1916#endif
07be1b83
YO
1917 U32 pointpos = 0;
1918
1919 while ( state && uc <= (U8*)strend ) {
1920 int failed=0;
786e8c11
YO
1921 U32 word = aho->states[ state ].wordnum;
1922
1de06328
YO
1923 if( state==1 ) {
1924 if ( bitmap ) {
1925 DEBUG_TRIE_EXECUTE_r(
1926 if ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1927 dump_exec_pos( (char *)uc, c, strend, real_start,
f2ed9b32 1928 (char *)uc, utf8_target );
1de06328
YO
1929 PerlIO_printf( Perl_debug_log,
1930 " Scanning for legal start char...\n");
1931 }
d085b490
YO
1932 );
1933 if (utf8_target) {
1934 while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1935 uc += UTF8SKIP(uc);
1936 }
1937 } else {
1938 while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1939 uc++;
1940 }
1941 }
1de06328 1942 s= (char *)uc;
786e8c11 1943 }
786e8c11
YO
1944 if (uc >(U8*)last_start) break;
1945 }
1946
1947 if ( word ) {
2e64971a 1948 U8 *lpos= points[ (pointpos - trie->wordinfo[word].len) % maxlen ];
786e8c11
YO
1949 if (!leftmost || lpos < leftmost) {
1950 DEBUG_r(accepted_word=word);
07be1b83 1951 leftmost= lpos;
786e8c11 1952 }
07be1b83 1953 if (base==0) break;
786e8c11 1954
07be1b83
YO
1955 }
1956 points[pointpos++ % maxlen]= uc;
7016d6eb
DM
1957 if (foldlen || uc < (U8*)strend) {
1958 REXEC_TRIE_READ_CHAR(trie_type, trie,
1959 widecharmap, uc,
55eed653
NC
1960 uscan, len, uvc, charid, foldlen,
1961 foldbuf, uniflags);
7016d6eb
DM
1962 DEBUG_TRIE_EXECUTE_r({
1963 dump_exec_pos( (char *)uc, c, strend,
1964 real_start, s, utf8_target);
1965 PerlIO_printf(Perl_debug_log,
1966 " Charid:%3u CP:%4"UVxf" ",
1967 charid, uvc);
1968 });
1969 }
1970 else {
1971 len = 0;
1972 charid = 0;
1973 }
1974
07be1b83
YO
1975
1976 do {
6148ee25 1977#ifdef DEBUGGING
786e8c11 1978 word = aho->states[ state ].wordnum;
6148ee25 1979#endif
07be1b83
YO
1980 base = aho->states[ state ].trans.base;
1981
786e8c11
YO
1982 DEBUG_TRIE_EXECUTE_r({
1983 if (failed)
1984 dump_exec_pos( (char *)uc, c, strend, real_start,
f2ed9b32 1985 s, utf8_target );
07be1b83 1986 PerlIO_printf( Perl_debug_log,
786e8c11
YO
1987 "%sState: %4"UVxf", word=%"UVxf,
1988 failed ? " Fail transition to " : "",
1989 (UV)state, (UV)word);
1990 });
07be1b83
YO
1991 if ( base ) {
1992 U32 tmp;
6dd2be57 1993 I32 offset;
07be1b83 1994 if (charid &&
6dd2be57
DM
1995 ( ((offset = base + charid
1996 - 1 - trie->uniquecharcount)) >= 0)
1997 && ((U32)offset < trie->lasttrans)
1998 && trie->trans[offset].check == state
1999 && (tmp=trie->trans[offset].next))
07be1b83 2000 {
786e8c11
YO
2001 DEBUG_TRIE_EXECUTE_r(
2002 PerlIO_printf( Perl_debug_log," - legal\n"));
07be1b83
YO
2003 state = tmp;
2004 break;
2005 }
2006 else {
786e8c11
YO
2007 DEBUG_TRIE_EXECUTE_r(
2008 PerlIO_printf( Perl_debug_log," - fail\n"));
2009 failed = 1;
2010 state = aho->fail[state];
07be1b83
YO
2011 }
2012 }
2013 else {
2014 /* we must be accepting here */
786e8c11
YO
2015 DEBUG_TRIE_EXECUTE_r(
2016 PerlIO_printf( Perl_debug_log," - accepting\n"));
2017 failed = 1;
07be1b83
YO
2018 break;
2019 }
2020 } while(state);
786e8c11 2021 uc += len;
07be1b83
YO
2022 if (failed) {
2023 if (leftmost)
2024 break;
786e8c11 2025 if (!state) state = 1;
07be1b83
YO
2026 }
2027 }
2028 if ( aho->states[ state ].wordnum ) {
2e64971a 2029 U8 *lpos = points[ (pointpos - trie->wordinfo[aho->states[ state ].wordnum].len) % maxlen ];
786e8c11
YO
2030 if (!leftmost || lpos < leftmost) {
2031 DEBUG_r(accepted_word=aho->states[ state ].wordnum);
07be1b83 2032 leftmost = lpos;
786e8c11 2033 }
07be1b83 2034 }
07be1b83
YO
2035 if (leftmost) {
2036 s = (char*)leftmost;
786e8c11
YO
2037 DEBUG_TRIE_EXECUTE_r({
2038 PerlIO_printf(
70685ca0
JH
2039 Perl_debug_log,"Matches word #%"UVxf" at position %"IVdf". Trying full pattern...\n",
2040 (UV)accepted_word, (IV)(s - real_start)
786e8c11
YO
2041 );
2042 });
24b23f37 2043 if (!reginfo || regtry(reginfo, &s)) {
be8e71aa
YO
2044 FREETMPS;
2045 LEAVE;
07be1b83 2046 goto got_it;
be8e71aa 2047 }
07be1b83 2048 s = HOPc(s,1);
786e8c11
YO
2049 DEBUG_TRIE_EXECUTE_r({
2050 PerlIO_printf( Perl_debug_log,"Pattern failed. Looking for new start point...\n");
2051 });
07be1b83 2052 } else {
786e8c11
YO
2053 DEBUG_TRIE_EXECUTE_r(
2054 PerlIO_printf( Perl_debug_log,"No match.\n"));
07be1b83
YO
2055 break;
2056 }
2057 }
be8e71aa
YO
2058 FREETMPS;
2059 LEAVE;
07be1b83
YO
2060 }
2061 break;
b3c9acc1 2062 default:
3c3eec57
GS
2063 Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
2064 break;
d6a28714 2065 }
6eb5f6b9
JH
2066 return 0;
2067 got_it:
2068 return s;
2069}
2070
fae667d5 2071
6eb5f6b9
JH
2072/*
2073 - regexec_flags - match a regexp against a string
2074 */
2075I32
288b8c02 2076Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, register char *strend,
6eb5f6b9 2077 char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
8fd1a950
DM
2078/* stringarg: the point in the string at which to begin matching */
2079/* strend: pointer to null at end of string */
2080/* strbeg: real beginning of string */
2081/* minend: end of match must be >= minend bytes after stringarg. */
2082/* sv: SV being matched: only used for utf8 flag, pos() etc; string
2083 * itself is accessed via the pointers above */
2084/* data: May be used for some additional optimizations.
2085 Currently its only used, with a U32 cast, for transmitting
2086 the ganch offset when doing a /g match. This will change */
2087/* nosave: For optimizations. */
2088
6eb5f6b9 2089{
97aff369 2090 dVAR;
288b8c02 2091 struct regexp *const prog = (struct regexp *)SvANY(rx);
24b23f37 2092 /*register*/ char *s;
eb578fdb 2093 regnode *c;
24b23f37 2094 /*register*/ char *startpos = stringarg;
6eb5f6b9
JH
2095 I32 minlen; /* must match at least this many chars */
2096 I32 dontbother = 0; /* how many characters not to try at end */
6eb5f6b9
JH
2097 I32 end_shift = 0; /* Same for the end. */ /* CC */
2098 I32 scream_pos = -1; /* Internal iterator of scream. */
ccac19ea 2099 char *scream_olds = NULL;
f2ed9b32 2100 const bool utf8_target = cBOOL(DO_UTF8(sv));
2757e526 2101 I32 multiline;
f8fc2ecf 2102 RXi_GET_DECL(prog,progi);
3b0527fe 2103 regmatch_info reginfo; /* create some info to pass to regtry etc */
e9105d30 2104 regexp_paren_pair *swap = NULL;
a3621e74
YO
2105 GET_RE_DEBUG_FLAGS_DECL;
2106
7918f24d 2107 PERL_ARGS_ASSERT_REGEXEC_FLAGS;
9d4ba2ae 2108 PERL_UNUSED_ARG(data);
6eb5f6b9
JH
2109
2110 /* Be paranoid... */
2111 if (prog == NULL || startpos == NULL) {
2112 Perl_croak(aTHX_ "NULL regexp parameter");
2113 return 0;
2114 }
2115
bbe252da 2116 multiline = prog->extflags & RXf_PMf_MULTILINE;
288b8c02 2117 reginfo.prog = rx; /* Yes, sorry that this is confusing. */
2757e526 2118
f2ed9b32 2119 RX_MATCH_UTF8_set(rx, utf8_target);
1de06328 2120 DEBUG_EXECUTE_r(
f2ed9b32 2121 debug_start_match(rx, utf8_target, startpos, strend,
1de06328
YO
2122 "Matching");
2123 );
bac06658 2124
6eb5f6b9 2125 minlen = prog->minlen;
1de06328
YO
2126
2127 if (strend - startpos < (minlen+(prog->check_offset_min<0?prog->check_offset_min:0))) {
a3621e74 2128 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584
JH
2129 "String too short [regexec_flags]...\n"));
2130 goto phooey;
1aa99e6b 2131 }
6eb5f6b9 2132
1de06328 2133
6eb5f6b9 2134 /* Check validity of program. */
f8fc2ecf 2135 if (UCHARAT(progi->program) != REG_MAGIC) {
6eb5f6b9
JH
2136 Perl_croak(aTHX_ "corrupted regexp program");
2137 }
2138
2139 PL_reg_flags = 0;
ed301438 2140 PL_reg_state.re_state_eval_setup_done = FALSE;
6eb5f6b9
JH
2141 PL_reg_maxiter = 0;
2142
3c8556c3 2143 if (RX_UTF8(rx))
6eb5f6b9
JH
2144 PL_reg_flags |= RF_utf8;
2145
2146 /* Mark beginning of line for ^ and lookbehind. */
3b0527fe 2147 reginfo.bol = startpos; /* XXX not used ??? */
6eb5f6b9 2148 PL_bostr = strbeg;
3b0527fe 2149 reginfo.sv = sv;
6eb5f6b9
JH
2150
2151 /* Mark end of line for $ (and such) */
2152 PL_regeol = strend;
2153
2154 /* see how far we have to get to not match where we matched before */
3b0527fe 2155 reginfo.till = startpos+minend;
6eb5f6b9 2156
6eb5f6b9
JH
2157 /* If there is a "must appear" string, look for it. */
2158 s = startpos;
2159
bbe252da 2160 if (prog->extflags & RXf_GPOS_SEEN) { /* Need to set reginfo->ganch */
6eb5f6b9 2161 MAGIC *mg;
2c296965 2162 if (flags & REXEC_IGNOREPOS){ /* Means: check only at start */
58e23c8d 2163 reginfo.ganch = startpos + prog->gofs;
2c296965 2164 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 2165 "GPOS IGNOREPOS: reginfo.ganch = startpos + %"UVxf"\n",(UV)prog->gofs));
2c296965 2166 } else if (sv && SvTYPE(sv) >= SVt_PVMG
6eb5f6b9 2167 && SvMAGIC(sv)
14befaf4
DM
2168 && (mg = mg_find(sv, PERL_MAGIC_regex_global))
2169 && mg->mg_len >= 0) {
3b0527fe 2170 reginfo.ganch = strbeg + mg->mg_len; /* Defined pos() */
2c296965 2171 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 2172 "GPOS MAGIC: reginfo.ganch = strbeg + %"IVdf"\n",(IV)mg->mg_len));
2c296965 2173
bbe252da 2174 if (prog->extflags & RXf_ANCH_GPOS) {
3b0527fe 2175 if (s > reginfo.ganch)
6eb5f6b9 2176 goto phooey;
58e23c8d 2177 s = reginfo.ganch - prog->gofs;
2c296965 2178 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 2179 "GPOS ANCH_GPOS: s = ganch - %"UVxf"\n",(UV)prog->gofs));
c584a96e
YO
2180 if (s < strbeg)
2181 goto phooey;
6eb5f6b9
JH
2182 }
2183 }
58e23c8d 2184 else if (data) {
70685ca0 2185 reginfo.ganch = strbeg + PTR2UV(data);
2c296965
YO
2186 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2187 "GPOS DATA: reginfo.ganch= strbeg + %"UVxf"\n",PTR2UV(data)));
2188
2189 } else { /* pos() not defined */
3b0527fe 2190 reginfo.ganch = strbeg;
2c296965
YO
2191 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2192 "GPOS: reginfo.ganch = strbeg\n"));
2193 }
6eb5f6b9 2194 }
288b8c02 2195 if (PL_curpm && (PM_GETRE(PL_curpm) == rx)) {
e9105d30
GG
2196 /* We have to be careful. If the previous successful match
2197 was from this regex we don't want a subsequent partially
2198 successful match to clobber the old results.
2199 So when we detect this possibility we add a swap buffer
2200 to the re, and switch the buffer each match. If we fail
2201 we switch it back, otherwise we leave it swapped.
2202 */
2203 swap = prog->offs;
2204 /* do we need a save destructor here for eval dies? */
2205 Newxz(prog->offs, (prog->nparens + 1), regexp_paren_pair);
495f47a5
DM
2206 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
2207 "rex=0x%"UVxf" saving offs: orig=0x%"UVxf" new=0x%"UVxf"\n",
2208 PTR2UV(prog),
2209 PTR2UV(swap),
2210 PTR2UV(prog->offs)
2211 ));
c74340f9 2212 }
a0714e2c 2213 if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
6eb5f6b9
JH
2214 re_scream_pos_data d;
2215
2216 d.scream_olds = &scream_olds;
2217 d.scream_pos = &scream_pos;
288b8c02 2218 s = re_intuit_start(rx, sv, s, strend, flags, &d);
3fa9c3d7 2219 if (!s) {
a3621e74 2220 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
6eb5f6b9 2221 goto phooey; /* not present */
3fa9c3d7 2222 }
6eb5f6b9
JH
2223 }
2224
1de06328 2225
6eb5f6b9
JH
2226
2227 /* Simplest case: anchored match need be tried only once. */
2228 /* [unless only anchor is BOL and multiline is set] */
bbe252da 2229 if (prog->extflags & (RXf_ANCH & ~RXf_ANCH_GPOS)) {
24b23f37 2230 if (s == startpos && regtry(&reginfo, &startpos))
6eb5f6b9 2231 goto got_it;
bbe252da
YO
2232 else if (multiline || (prog->intflags & PREGf_IMPLICIT)
2233 || (prog->extflags & RXf_ANCH_MBOL)) /* XXXX SBOL? */
6eb5f6b9
JH
2234 {
2235 char *end;
2236
2237 if (minlen)
2238 dontbother = minlen - 1;
1aa99e6b 2239 end = HOP3c(strend, -dontbother, strbeg) - 1;
6eb5f6b9 2240 /* for multiline we only have to try after newlines */
33b8afdf 2241 if (prog->check_substr || prog->check_utf8) {
92f3d482
YO
2242 /* because of the goto we can not easily reuse the macros for bifurcating the
2243 unicode/non-unicode match modes here like we do elsewhere - demerphq */
2244 if (utf8_target) {
2245 if (s == startpos)
2246 goto after_try_utf8;
2247 while (1) {
2248 if (regtry(&reginfo, &s)) {
2249 goto got_it;
2250 }
2251 after_try_utf8:
2252 if (s > end) {
2253 goto phooey;
2254 }
2255 if (prog->extflags & RXf_USE_INTUIT) {
2256 s = re_intuit_start(rx, sv, s + UTF8SKIP(s), strend, flags, NULL);
2257 if (!s) {
2258 goto phooey;
2259 }
2260 }
2261 else {
2262 s += UTF8SKIP(s);
2263 }
2264 }
2265 } /* end search for check string in unicode */
2266 else {
2267 if (s == startpos) {
2268 goto after_try_latin;
2269 }
2270 while (1) {
2271 if (regtry(&reginfo, &s)) {
2272 goto got_it;
2273 }
2274 after_try_latin:
2275 if (s > end) {
2276 goto phooey;
2277 }
2278 if (prog->extflags & RXf_USE_INTUIT) {
2279 s = re_intuit_start(rx, sv, s + 1, strend, flags, NULL);
2280 if (!s) {
2281 goto phooey;
2282 }
2283 }
2284 else {
2285 s++;
2286 }
2287 }
2288 } /* end search for check string in latin*/
2289 } /* end search for check string */
2290 else { /* search for newline */
2291 if (s > startpos) {
2292 /*XXX: The s-- is almost definitely wrong here under unicode - demeprhq*/
6eb5f6b9 2293 s--;
92f3d482 2294 }
21eede78
YO
2295 /* We can use a more efficient search as newlines are the same in unicode as they are in latin */
2296 while (s <= end) { /* note it could be possible to match at the end of the string */
6eb5f6b9 2297 if (*s++ == '\n') { /* don't need PL_utf8skip here */
24b23f37 2298 if (regtry(&reginfo, &s))
6eb5f6b9
JH
2299 goto got_it;
2300 }
92f3d482
YO
2301 }
2302 } /* end search for newline */
2303 } /* end anchored/multiline check string search */
6eb5f6b9 2304 goto phooey;
bbe252da 2305 } else if (RXf_GPOS_CHECK == (prog->extflags & RXf_GPOS_CHECK))
f9f4320a 2306 {
486ec47a 2307 /* the warning about reginfo.ganch being used without initialization
bbe252da 2308 is bogus -- we set it above, when prog->extflags & RXf_GPOS_SEEN
f9f4320a 2309 and we only enter this block when the same bit is set. */
58e23c8d 2310 char *tmp_s = reginfo.ganch - prog->gofs;
c584a96e
YO
2311
2312 if (tmp_s >= strbeg && regtry(&reginfo, &tmp_s))
6eb5f6b9
JH
2313 goto got_it;
2314 goto phooey;
2315 }
2316
2317 /* Messy cases: unanchored match. */
bbe252da 2318 if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
6eb5f6b9 2319 /* we have /x+whatever/ */
f2ed9b32 2320 /* it must be a one character string (XXXX Except UTF_PATTERN?) */
33b8afdf 2321 char ch;
bf93d4cc
GS
2322#ifdef DEBUGGING
2323 int did_match = 0;
2324#endif
f2ed9b32 2325 if (utf8_target) {
7e0d5ad7
KW
2326 if (! prog->anchored_utf8) {
2327 to_utf8_substr(prog);
2328 }
2329 ch = SvPVX_const(prog->anchored_utf8)[0];
4cadc6a9 2330 REXEC_FBC_SCAN(
6eb5f6b9 2331 if (*s == ch) {
a3621e74 2332 DEBUG_EXECUTE_r( did_match = 1 );
24b23f37 2333 if (regtry(&reginfo, &s)) goto got_it;
6eb5f6b9
JH
2334 s += UTF8SKIP(s);
2335 while (s < strend && *s == ch)
2336 s += UTF8SKIP(s);
2337 }
4cadc6a9 2338 );
7e0d5ad7 2339
6eb5f6b9
JH
2340 }
2341 else {
7e0d5ad7
KW
2342 if (! prog->anchored_substr) {
2343 if (! to_byte_substr(prog)) {
2344 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2345 non_utf8_target_but_utf8_required));
2346 goto phooey;
2347 }
2348 }
2349 ch = SvPVX_const(prog->anchored_substr)[0];
4cadc6a9 2350 REXEC_FBC_SCAN(
6eb5f6b9 2351 if (*s == ch) {
a3621e74 2352 DEBUG_EXECUTE_r( did_match = 1 );
24b23f37 2353 if (regtry(&reginfo, &s)) goto got_it;
6eb5f6b9
JH
2354 s++;
2355 while (s < strend && *s == ch)
2356 s++;
2357 }
4cadc6a9 2358 );
6eb5f6b9 2359 }
a3621e74 2360 DEBUG_EXECUTE_r(if (!did_match)
bf93d4cc 2361 PerlIO_printf(Perl_debug_log,
b7953727
JH
2362 "Did not find anchored character...\n")
2363 );
6eb5f6b9 2364 }
a0714e2c
SS
2365 else if (prog->anchored_substr != NULL
2366 || prog->anchored_utf8 != NULL
2367 || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
33b8afdf
JH
2368 && prog->float_max_offset < strend - s)) {
2369 SV *must;
2370 I32 back_max;
2371 I32 back_min;
2372 char *last;
6eb5f6b9 2373 char *last1; /* Last position checked before */
bf93d4cc
GS
2374#ifdef DEBUGGING
2375 int did_match = 0;
2376#endif
33b8afdf 2377 if (prog->anchored_substr || prog->anchored_utf8) {
7e0d5ad7
KW
2378 if (utf8_target) {
2379 if (! prog->anchored_utf8) {
2380 to_utf8_substr(prog);
2381 }
2382 must = prog->anchored_utf8;
2383 }
2384 else {
2385 if (! prog->anchored_substr) {
2386 if (! to_byte_substr(prog)) {
2387 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2388 non_utf8_target_but_utf8_required));
2389 goto phooey;
2390 }
2391 }
2392 must = prog->anchored_substr;
2393 }
33b8afdf
JH
2394 back_max = back_min = prog->anchored_offset;
2395 } else {
7e0d5ad7
KW
2396 if (utf8_target) {
2397 if (! prog->float_utf8) {
2398 to_utf8_substr(prog);
2399 }
2400 must = prog->float_utf8;
2401 }
2402 else {
2403 if (! prog->float_substr) {
2404 if (! to_byte_substr(prog)) {
2405 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2406 non_utf8_target_but_utf8_required));
2407 goto phooey;
2408 }
2409 }
2410 must = prog->float_substr;
2411 }
33b8afdf
JH
2412 back_max = prog->float_max_offset;
2413 back_min = prog->float_min_offset;
2414 }
1de06328 2415
1de06328
YO
2416 if (back_min<0) {
2417 last = strend;
2418 } else {
2419 last = HOP3c(strend, /* Cannot start after this */
2420 -(I32)(CHR_SVLEN(must)
2421 - (SvTAIL(must) != 0) + back_min), strbeg);
2422 }
6eb5f6b9
JH
2423 if (s > PL_bostr)
2424 last1 = HOPc(s, -1);
2425 else
2426 last1 = s - 1; /* bogus */
2427
a0288114 2428 /* XXXX check_substr already used to find "s", can optimize if
6eb5f6b9
JH
2429 check_substr==must. */
2430 scream_pos = -1;
2431 dontbother = end_shift;
2432 strend = HOPc(strend, -dontbother);
2433 while ( (s <= last) &&
c33e64f0 2434 (s = fbm_instr((unsigned char*)HOP3(s, back_min, (back_min<0 ? strbeg : strend)),
9041c2e3 2435 (unsigned char*)strend, must,
c33e64f0 2436 multiline ? FBMrf_MULTILINE : 0)) ) {
a3621e74 2437 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH
2438 if (HOPc(s, -back_max) > last1) {
2439 last1 = HOPc(s, -back_min);
2440 s = HOPc(s, -back_max);
2441 }
2442 else {
52657f30 2443 char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
6eb5f6b9
JH
2444
2445 last1 = HOPc(s, -back_min);
52657f30 2446 s = t;
6eb5f6b9 2447 }
f2ed9b32 2448 if (utf8_target) {
6eb5f6b9 2449 while (s <= last1) {
24b23f37 2450 if (regtry(&reginfo, &s))
6eb5f6b9 2451 goto got_it;
7016d6eb
DM
2452 if (s >= last1) {
2453 s++; /* to break out of outer loop */
2454 break;
2455 }
2456 s += UTF8SKIP(s);
6eb5f6b9
JH
2457 }
2458 }
2459 else {
2460 while (s <= last1) {
24b23f37 2461 if (regtry(&reginfo, &s))
6eb5f6b9
JH
2462 goto got_it;
2463 s++;
2464 }
2465 }
2466 }
ab3bbdeb 2467 DEBUG_EXECUTE_r(if (!did_match) {
f2ed9b32 2468 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
2469 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
2470 PerlIO_printf(Perl_debug_log, "Did not find %s substr %s%s...\n",
33b8afdf 2471 ((must == prog->anchored_substr || must == prog->anchored_utf8)
bf93d4cc 2472 ? "anchored" : "floating"),
ab3bbdeb
YO
2473 quoted, RE_SV_TAIL(must));
2474 });
6eb5f6b9
JH
2475 goto phooey;
2476 }
f8fc2ecf 2477 else if ( (c = progi->regstclass) ) {
f14c76ed 2478 if (minlen) {
f8fc2ecf 2479 const OPCODE op = OP(progi->regstclass);
66e933ab 2480 /* don't bother with what can't match */
786e8c11 2481 if (PL_regkind[op] != EXACT && op != CANY && PL_regkind[op] != TRIE)
f14c76ed
RGS
2482 strend = HOPc(strend, -(minlen - 1));
2483 }
a3621e74 2484 DEBUG_EXECUTE_r({
be8e71aa 2485 SV * const prop = sv_newmortal();
32fc9b6a 2486 regprop(prog, prop, c);
0df25f3d 2487 {
f2ed9b32 2488 RE_PV_QUOTED_DECL(quoted,utf8_target,PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb 2489 s,strend-s,60);
0df25f3d 2490 PerlIO_printf(Perl_debug_log,
1c8f8eb1 2491 "Matching stclass %.*s against %s (%d bytes)\n",
e4f74956 2492 (int)SvCUR(prop), SvPVX_const(prop),
ab3bbdeb 2493 quoted, (int)(strend - s));
0df25f3d 2494 }
ffc61ed2 2495 });
3b0527fe 2496 if (find_byclass(prog, c, s, strend, &reginfo))
6eb5f6b9 2497 goto got_it;
07be1b83 2498 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass... [regexec_flags]\n"));
d6a28714
JH
2499 }
2500 else {
2501 dontbother = 0;
a0714e2c 2502 if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
33b8afdf 2503 /* Trim the end. */
6af40bd7 2504 char *last= NULL;
33b8afdf 2505 SV* float_real;
c33e64f0
FC
2506 STRLEN len;
2507 const char *little;
33b8afdf 2508
7e0d5ad7
KW
2509 if (utf8_target) {
2510 if (! prog->float_utf8) {
2511 to_utf8_substr(prog);
2512 }
2513 float_real = prog->float_utf8;
2514 }
2515 else {
2516 if (! prog->float_substr) {
2517 if (! to_byte_substr(prog)) {
2518 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2519 non_utf8_target_but_utf8_required));
2520 goto phooey;
2521 }
2522 }
2523 float_real = prog->float_substr;
2524 }
d6a28714 2525
c33e64f0
FC
2526 little = SvPV_const(float_real, len);
2527 if (SvTAIL(float_real)) {
1a13b075
YO
2528 /* This means that float_real contains an artificial \n on the end
2529 * due to the presence of something like this: /foo$/
2530 * where we can match both "foo" and "foo\n" at the end of the string.
2531 * So we have to compare the end of the string first against the float_real
2532 * without the \n and then against the full float_real with the string.
2533 * We have to watch out for cases where the string might be smaller
2534 * than the float_real or the float_real without the \n.
2535 */
2536 char *checkpos= strend - len;
2537 DEBUG_OPTIMISE_r(
2538 PerlIO_printf(Perl_debug_log,
2539 "%sChecking for float_real.%s\n",
2540 PL_colors[4], PL_colors[5]));
2541 if (checkpos + 1 < strbeg) {
2542 /* can't match, even if we remove the trailing \n string is too short to match */
2543 DEBUG_EXECUTE_r(
2544 PerlIO_printf(Perl_debug_log,
2545 "%sString shorter than required trailing substring, cannot match.%s\n",
2546 PL_colors[4], PL_colors[5]));
2547 goto phooey;
2548 } else if (memEQ(checkpos + 1, little, len - 1)) {
2549 /* can match, the end of the string matches without the "\n" */
2550 last = checkpos + 1;
2551 } else if (checkpos < strbeg) {
2552 /* cant match, string is too short when the "\n" is included */
2553 DEBUG_EXECUTE_r(
2554 PerlIO_printf(Perl_debug_log,
2555 "%sString does not contain required trailing substring, cannot match.%s\n",
2556 PL_colors[4], PL_colors[5]));
2557 goto phooey;
2558 } else if (!multiline) {
2559 /* non multiline match, so compare with the "\n" at the end of the string */
2560 if (memEQ(checkpos, little, len)) {
2561 last= checkpos;
2562 } else {
2563 DEBUG_EXECUTE_r(
2564 PerlIO_printf(Perl_debug_log,
2565 "%sString does not contain required trailing substring, cannot match.%s\n",
2566 PL_colors[4], PL_colors[5]));
2567 goto phooey;
2568 }
2569 } else {
2570 /* multiline match, so we have to search for a place where the full string is located */
d6a28714 2571 goto find_last;
1a13b075 2572 }
c33e64f0 2573 } else {
d6a28714 2574 find_last:
9041c2e3 2575 if (len)
d6a28714 2576 last = rninstr(s, strend, little, little + len);
b8c5462f 2577 else
a0288114 2578 last = strend; /* matching "$" */
b8c5462f 2579 }
6af40bd7
YO
2580 if (!last) {
2581 /* at one point this block contained a comment which was probably
2582 * incorrect, which said that this was a "should not happen" case.
2583 * Even if it was true when it was written I am pretty sure it is
2584 * not anymore, so I have removed the comment and replaced it with
2585 * this one. Yves */
6bda09f9
YO
2586 DEBUG_EXECUTE_r(
2587 PerlIO_printf(Perl_debug_log,
6af40bd7
YO
2588 "String does not contain required substring, cannot match.\n"
2589 ));
2590 goto phooey;
bf93d4cc 2591 }
d6a28714
JH
2592 dontbother = strend - last + prog->float_min_offset;
2593 }
2594 if (minlen && (dontbother < minlen))
2595 dontbother = minlen - 1;
2596 strend -= dontbother; /* this one's always in bytes! */
2597 /* We don't know much -- general case. */
f2ed9b32 2598 if (utf8_target) {
d6a28714 2599 for (;;) {
24b23f37 2600 if (regtry(&reginfo, &s))
d6a28714
JH
2601 goto got_it;
2602 if (s >= strend)
2603 break;
b8c5462f 2604 s += UTF8SKIP(s);
d6a28714
JH
2605 };
2606 }
2607 else {
2608 do {
24b23f37 2609 if (regtry(&reginfo, &s))
d6a28714
JH
2610 goto got_it;
2611 } while (s++ < strend);
2612 }
2613 }
2614
2615 /* Failure. */
2616 goto phooey;
2617
2618got_it:
495f47a5
DM
2619 DEBUG_BUFFERS_r(
2620 if (swap)
2621 PerlIO_printf(Perl_debug_log,
2622 "rex=0x%"UVxf" freeing offs: 0x%"UVxf"\n",
2623 PTR2UV(prog),
2624 PTR2UV(swap)
2625 );
2626 );
e9105d30 2627 Safefree(swap);
288b8c02 2628 RX_MATCH_TAINTED_set(rx, PL_reg_flags & RF_tainted);
d6a28714 2629
ed301438 2630 if (PL_reg_state.re_state_eval_setup_done)
4f639d21 2631 restore_pos(aTHX_ prog);
5daac39c
NC
2632 if (RXp_PAREN_NAMES(prog))
2633 (void)hv_iterinit(RXp_PAREN_NAMES(prog));
d6a28714
JH
2634
2635 /* make sure $`, $&, $', and $digit will work later */
2636 if ( !(flags & REXEC_NOT_FIRST) ) {
d6a28714 2637 if (flags & REXEC_COPY_STR) {
f8c7b90f 2638#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC
2639 if ((SvIsCOW(sv)
2640 || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS)) {
2641 if (DEBUG_C_TEST) {
2642 PerlIO_printf(Perl_debug_log,
2643 "Copy on write: regexp capture, type %d\n",
2644 (int) SvTYPE(sv));
2645 }
77f8f7c1 2646 RX_MATCH_COPY_FREE(rx);
ed252734 2647 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
d5263905 2648 prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
ed252734 2649 assert (SvPOKp(prog->saved_copy));
6502e081
DM
2650 prog->sublen = PL_regeol - strbeg;
2651 prog->suboffset = 0;
2652 prog->subcoffset = 0;
ed252734
NC
2653 } else
2654#endif
2655 {
6502e081
DM
2656 I32 min = 0;
2657 I32 max = PL_regeol - strbeg;
2658 I32 sublen;
2659
2660 if ( (flags & REXEC_COPY_SKIP_POST)
2661 && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) /* //p */
2662 && !(PL_sawampersand & SAWAMPERSAND_RIGHT)
2663 ) { /* don't copy $' part of string */
3de645a8 2664 U32 n = 0;
6502e081
DM
2665 max = -1;
2666 /* calculate the right-most part of the string covered
2667 * by a capture. Due to look-ahead, this may be to
2668 * the right of $&, so we have to scan all captures */
2669 while (n <= prog->lastparen) {
2670 if (prog->offs[n].end > max)
2671 max = prog->offs[n].end;
2672 n++;
2673 }
2674 if (max == -1)
2675 max = (PL_sawampersand & SAWAMPERSAND_LEFT)
2676 ? prog->offs[0].start
2677 : 0;
2678 assert(max >= 0 && max <= PL_regeol - strbeg);
2679 }
2680
2681 if ( (flags & REXEC_COPY_SKIP_PRE)
2682 && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) /* //p */
2683 && !(PL_sawampersand & SAWAMPERSAND_LEFT)
2684 ) { /* don't copy $` part of string */
3de645a8 2685 U32 n = 0;
6502e081
DM
2686 min = max;
2687 /* calculate the left-most part of the string covered
2688 * by a capture. Due to look-behind, this may be to
2689 * the left of $&, so we have to scan all captures */
2690 while (min && n <= prog->lastparen) {
2691 if ( prog->offs[n].start != -1
2692 && prog->offs[n].start < min)
2693 {
2694 min = prog->offs[n].start;
2695 }
2696 n++;
2697 }
2698 if ((PL_sawampersand & SAWAMPERSAND_RIGHT)
2699 && min > prog->offs[0].end
2700 )
2701 min = prog->offs[0].end;
2702
2703 }
2704
2705 assert(min >= 0 && min <= max && min <= PL_regeol - strbeg);
2706 sublen = max - min;
2707
2708 if (RX_MATCH_COPIED(rx)) {
2709 if (sublen > prog->sublen)
2710 prog->subbeg =
2711 (char*)saferealloc(prog->subbeg, sublen+1);
2712 }
2713 else
2714 prog->subbeg = (char*)safemalloc(sublen+1);
2715 Copy(strbeg + min, prog->subbeg, sublen, char);
2716 prog->subbeg[sublen] = '\0';
2717 prog->suboffset = min;
2718 prog->sublen = sublen;
77f8f7c1 2719 RX_MATCH_COPIED_on(rx);
6502e081 2720 }
6502e081
DM
2721 prog->subcoffset = prog->suboffset;
2722 if (prog->suboffset && utf8_target) {
2723 /* Convert byte offset to chars.
2724 * XXX ideally should only compute this if @-/@+
2725 * has been seen, a la PL_sawampersand ??? */
2726
2727 /* If there's a direct correspondence between the
2728 * string which we're matching and the original SV,
2729 * then we can use the utf8 len cache associated with
2730 * the SV. In particular, it means that under //g,
2731 * sv_pos_b2u() will use the previously cached
2732 * position to speed up working out the new length of
2733 * subcoffset, rather than counting from the start of
2734 * the string each time. This stops
2735 * $x = "\x{100}" x 1E6; 1 while $x =~ /(.)/g;
2736 * from going quadratic */
2737 if (SvPOKp(sv) && SvPVX(sv) == strbeg)
2738 sv_pos_b2u(sv, &(prog->subcoffset));
2739 else
2740 prog->subcoffset = utf8_length((U8*)strbeg,
2741 (U8*)(strbeg+prog->suboffset));
2742 }
d6a28714
JH
2743 }
2744 else {
6502e081 2745 RX_MATCH_COPY_FREE(rx);
d6a28714 2746 prog->subbeg = strbeg;
6502e081
DM
2747 prog->suboffset = 0;
2748 prog->subcoffset = 0;
d6a28714
JH
2749 prog->sublen = PL_regeol - strbeg; /* strend may have been modified */
2750 }
2751 }
9041c2e3 2752
d6a28714
JH
2753 return 1;
2754
2755phooey:
a3621e74 2756 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
e4584336 2757 PL_colors[4], PL_colors[5]));
ed301438 2758 if (PL_reg_state.re_state_eval_setup_done)
4f639d21 2759 restore_pos(aTHX_ prog);
e9105d30 2760 if (swap) {
c74340f9 2761 /* we failed :-( roll it back */
495f47a5
DM
2762 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
2763 "rex=0x%"UVxf" rolling back offs: freeing=0x%"UVxf" restoring=0x%"UVxf"\n",
2764 PTR2UV(prog),
2765 PTR2UV(prog->offs),
2766 PTR2UV(swap)
2767 ));
e9105d30
GG
2768 Safefree(prog->offs);
2769 prog->offs = swap;
2770 }
d6a28714
JH
2771 return 0;
2772}
2773
6bda09f9 2774
ec43f78b
DM
2775/* Set which rex is pointed to by PL_reg_state, handling ref counting.
2776 * Do inc before dec, in case old and new rex are the same */
2777#define SET_reg_curpm(Re2) \
2778 if (PL_reg_state.re_state_eval_setup_done) { \
2779 (void)ReREFCNT_inc(Re2); \
2780 ReREFCNT_dec(PM_GETRE(PL_reg_curpm)); \
2781 PM_SETRE((PL_reg_curpm), (Re2)); \
2782 }
2783
2784
d6a28714
JH
2785/*
2786 - regtry - try match at specific point
2787 */
2788STATIC I32 /* 0 failure, 1 success */
f73aaa43 2789S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
d6a28714 2790{
97aff369 2791 dVAR;
d6a28714 2792 CHECKPOINT lastcp;
288b8c02
NC
2793 REGEXP *const rx = reginfo->prog;
2794 regexp *const prog = (struct regexp *)SvANY(rx);
f73aaa43 2795 I32 result;
f8fc2ecf 2796 RXi_GET_DECL(prog,progi);
a3621e74 2797 GET_RE_DEBUG_FLAGS_DECL;
7918f24d
NC
2798
2799 PERL_ARGS_ASSERT_REGTRY;
2800
24b23f37 2801 reginfo->cutpoint=NULL;
d6a28714 2802
ed301438
DM
2803 if ((prog->extflags & RXf_EVAL_SEEN)
2804 && !PL_reg_state.re_state_eval_setup_done)
2805 {
d6a28714
JH
2806 MAGIC *mg;
2807
ed301438 2808 PL_reg_state.re_state_eval_setup_done = TRUE;
3b0527fe 2809 if (reginfo->sv) {
d6a28714 2810 /* Make $_ available to executed code. */
3b0527fe 2811 if (reginfo->sv != DEFSV) {
59f00321 2812 SAVE_DEFSV;
414bf5ae 2813 DEFSV_set(reginfo->sv);
b8c5462f 2814 }
d6a28714 2815
3b0527fe
DM
2816 if (!(SvTYPE(reginfo->sv) >= SVt_PVMG && SvMAGIC(reginfo->sv)
2817 && (mg = mg_find(reginfo->sv, PERL_MAGIC_regex_global)))) {
d6a28714 2818 /* prepare for quick setting of pos */
d300d9fa 2819#ifdef PERL_OLD_COPY_ON_WRITE
51a9ea20
NC
2820 if (SvIsCOW(reginfo->sv))
2821 sv_force_normal_flags(reginfo->sv, 0);
d300d9fa 2822#endif
3dab1dad 2823 mg = sv_magicext(reginfo->sv, NULL, PERL_MAGIC_regex_global,
d300d9fa 2824 &PL_vtbl_mglob, NULL, 0);
d6a28714 2825 mg->mg_len = -1;
b8c5462f 2826 }
d6a28714
JH
2827 PL_reg_magic = mg;
2828 PL_reg_oldpos = mg->mg_len;
4f639d21 2829 SAVEDESTRUCTOR_X(restore_pos, prog);
d6a28714 2830 }
09687e5a 2831 if (!PL_reg_curpm) {
a02a5408 2832 Newxz(PL_reg_curpm, 1, PMOP);
09687e5a
AB
2833#ifdef USE_ITHREADS
2834 {
14a49a24 2835 SV* const repointer = &PL_sv_undef;
92313705
NC
2836 /* this regexp is also owned by the new PL_reg_curpm, which
2837 will try to free it. */
d2ece331 2838 av_push(PL_regex_padav, repointer);
09687e5a
AB
2839 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
2840 PL_regex_pad = AvARRAY(PL_regex_padav);
2841 }
2842#endif
2843 }
ec43f78b 2844 SET_reg_curpm(rx);
d6a28714
JH
2845 PL_reg_oldcurpm = PL_curpm;
2846 PL_curpm = PL_reg_curpm;
07bc277f 2847 if (RXp_MATCH_COPIED(prog)) {
d6a28714
JH
2848 /* Here is a serious problem: we cannot rewrite subbeg,
2849 since it may be needed if this match fails. Thus
2850 $` inside (?{}) could fail... */
2851 PL_reg_oldsaved = prog->subbeg;
2852 PL_reg_oldsavedlen = prog->sublen;
6502e081
DM
2853 PL_reg_oldsavedoffset = prog->suboffset;
2854 PL_reg_oldsavedcoffset = prog->suboffset;
f8c7b90f 2855#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC
2856 PL_nrs = prog->saved_copy;
2857#endif
07bc277f 2858 RXp_MATCH_COPIED_off(prog);
d6a28714
JH
2859 }
2860 else
bd61b366 2861 PL_reg_oldsaved = NULL;
d6a28714 2862 prog->subbeg = PL_bostr;
6502e081
DM
2863 prog->suboffset = 0;
2864 prog->subcoffset = 0;
d6a28714
JH
2865 prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2866 }
97ca13b7 2867#ifdef DEBUGGING
f73aaa43 2868 PL_reg_starttry = *startposp;
97ca13b7 2869#endif
f73aaa43 2870 prog->offs[0].start = *startposp - PL_bostr;
d6a28714 2871 prog->lastparen = 0;
03994de8 2872 prog->lastcloseparen = 0;
d6a28714 2873 PL_regsize = 0;
d6a28714
JH
2874
2875 /* XXXX What this code is doing here?!!! There should be no need
b93070ed 2876 to do this again and again, prog->lastparen should take care of
3dd2943c 2877 this! --ilya*/
dafc8851
JH
2878
2879 /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2880 * Actually, the code in regcppop() (which Ilya may be meaning by
b93070ed 2881 * prog->lastparen), is not needed at all by the test suite
225593e1
DM
2882 * (op/regexp, op/pat, op/split), but that code is needed otherwise
2883 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
2884 * Meanwhile, this code *is* needed for the
daf18116
JH
2885 * above-mentioned test suite tests to succeed. The common theme
2886 * on those tests seems to be returning null fields from matches.
225593e1 2887 * --jhi updated by dapm */
dafc8851 2888#if 1
d6a28714 2889 if (prog->nparens) {
b93070ed 2890 regexp_paren_pair *pp = prog->offs;
eb578fdb 2891 I32 i;
b93070ed 2892 for (i = prog->nparens; i > (I32)prog->lastparen; i--) {
f0ab9afb
NC
2893 ++pp;
2894 pp->start = -1;
2895 pp->end = -1;
d6a28714
JH
2896 }
2897 }
dafc8851 2898#endif
02db2b7b 2899 REGCP_SET(lastcp);
f73aaa43
DM
2900 result = regmatch(reginfo, *startposp, progi->program + 1);
2901 if (result != -1) {
2902 prog->offs[0].end = result;
d6a28714
JH
2903 return 1;
2904 }
24b23f37 2905 if (reginfo->cutpoint)
f73aaa43 2906 *startposp= reginfo->cutpoint;
02db2b7b 2907 REGCP_UNWIND(lastcp);
d6a28714
JH
2908 return 0;
2909}
2910
02db2b7b 2911
8ba1375e
MJD
2912#define sayYES goto yes
2913#define sayNO goto no
262b90c4 2914#define sayNO_SILENT goto no_silent
8ba1375e 2915
f9f4320a
YO
2916/* we dont use STMT_START/END here because it leads to
2917 "unreachable code" warnings, which are bogus, but distracting. */
2918#define CACHEsayNO \
c476f425
DM
2919 if (ST.cache_mask) \
2920 PL_reg_poscache[ST.cache_offset] |= ST.cache_mask; \
f9f4320a 2921 sayNO
3298f257 2922
a3621e74 2923/* this is used to determine how far from the left messages like
265c4333
YO
2924 'failed...' are printed. It should be set such that messages
2925 are inline with the regop output that created them.
a3621e74 2926*/
265c4333 2927#define REPORT_CODE_OFF 32
a3621e74
YO
2928
2929
40a82448
DM
2930#define CHRTEST_UNINIT -1001 /* c1/c2 haven't been calculated yet */
2931#define CHRTEST_VOID -1000 /* the c1/c2 "next char" test should be skipped */
9e137952 2932
86545054
DM
2933#define SLAB_FIRST(s) (&(s)->states[0])
2934#define SLAB_LAST(s) (&(s)->states[PERL_REGMATCH_SLAB_SLOTS-1])
2935
5d9a96ca
DM
2936/* grab a new slab and return the first slot in it */
2937
2938STATIC regmatch_state *
2939S_push_slab(pTHX)
2940{
a35a87e7 2941#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC
2942 dMY_CXT;
2943#endif
5d9a96ca
DM
2944 regmatch_slab *s = PL_regmatch_slab->next;
2945 if (!s) {
2946 Newx(s, 1, regmatch_slab);
2947 s->prev = PL_regmatch_slab;
2948 s->next = NULL;
2949 PL_regmatch_slab->next = s;
2950 }
2951 PL_regmatch_slab = s;
86545054 2952 return SLAB_FIRST(s);
5d9a96ca 2953}
5b47454d 2954
95b24440 2955
40a82448
DM
2956/* push a new state then goto it */
2957
4d5016e5
DM
2958#define PUSH_STATE_GOTO(state, node, input) \
2959 pushinput = input; \
40a82448
DM
2960 scan = node; \
2961 st->resume_state = state; \
2962 goto push_state;
2963
2964/* push a new state with success backtracking, then goto it */
2965
4d5016e5
DM
2966#define PUSH_YES_STATE_GOTO(state, node, input) \
2967 pushinput = input; \
40a82448
DM
2968 scan = node; \
2969 st->resume_state = state; \
2970 goto push_yes_state;
2971
aa283a38 2972
aa283a38 2973
4d5016e5 2974
d6a28714 2975/*
95b24440 2976
bf1f174e
DM
2977regmatch() - main matching routine
2978
2979This is basically one big switch statement in a loop. We execute an op,
2980set 'next' to point the next op, and continue. If we come to a point which
2981we may need to backtrack to on failure such as (A|B|C), we push a
2982backtrack state onto the backtrack stack. On failure, we pop the top
2983state, and re-enter the loop at the state indicated. If there are no more
2984states to pop, we return failure.
2985
2986Sometimes we also need to backtrack on success; for example /A+/, where
2987after successfully matching one A, we need to go back and try to
2988match another one; similarly for lookahead assertions: if the assertion
2989completes successfully, we backtrack to the state just before the assertion
2990and then carry on. In these cases, the pushed state is marked as
2991'backtrack on success too'. This marking is in fact done by a chain of
2992pointers, each pointing to the previous 'yes' state. On success, we pop to
2993the nearest yes state, discarding any intermediate failure-only states.
2994Sometimes a yes state is pushed just to force some cleanup code to be
2995called at the end of a successful match or submatch; e.g. (??{$re}) uses
2996it to free the inner regex.
2997
2998Note that failure backtracking rewinds the cursor position, while
2999success backtracking leaves it alone.
3000
3001A pattern is complete when the END op is executed, while a subpattern
3002such as (?=foo) is complete when the SUCCESS op is executed. Both of these
3003ops trigger the "pop to last yes state if any, otherwise return true"
3004behaviour.
3005
3006A common convention in this function is to use A and B to refer to the two
3007subpatterns (or to the first nodes thereof) in patterns like /A*B/: so A is
3008the subpattern to be matched possibly multiple times, while B is the entire
3009rest of the pattern. Variable and state names reflect this convention.
3010
3011The states in the main switch are the union of ops and failure/success of
3012substates associated with with that op. For example, IFMATCH is the op
3013that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
3014'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
3015successfully matched A and IFMATCH_A_fail is a state saying that we have
3016just failed to match A. Resume states always come in pairs. The backtrack
3017state we push is marked as 'IFMATCH_A', but when that is popped, we resume
3018at IFMATCH_A or IFMATCH_A_fail, depending on whether we are backtracking
3019on success or failure.
3020
3021The struct that holds a backtracking state is actually a big union, with
3022one variant for each major type of op. The variable st points to the
3023top-most backtrack struct. To make the code clearer, within each
3024block of code we #define ST to alias the relevant union.
3025
3026Here's a concrete example of a (vastly oversimplified) IFMATCH
3027implementation:
3028
3029 switch (state) {
3030 ....
3031
3032#define ST st->u.ifmatch
3033
3034 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
3035 ST.foo = ...; // some state we wish to save
95b24440 3036 ...
bf1f174e
DM
3037 // push a yes backtrack state with a resume value of
3038 // IFMATCH_A/IFMATCH_A_fail, then continue execution at the
3039 // first node of A:
4d5016e5 3040 PUSH_YES_STATE_GOTO(IFMATCH_A, A, newinput);
bf1f174e
DM
3041 // NOTREACHED
3042
3043 case IFMATCH_A: // we have successfully executed A; now continue with B
3044 next = B;
3045 bar = ST.foo; // do something with the preserved value
3046 break;
3047
3048 case IFMATCH_A_fail: // A failed, so the assertion failed
3049 ...; // do some housekeeping, then ...
3050 sayNO; // propagate the failure
3051
3052#undef ST
95b24440 3053
bf1f174e
DM
3054 ...
3055 }
95b24440 3056
bf1f174e
DM
3057For any old-timers reading this who are familiar with the old recursive
3058approach, the code above is equivalent to:
95b24440 3059
bf1f174e
DM
3060 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
3061 {
3062 int foo = ...
95b24440 3063 ...
bf1f174e
DM
3064 if (regmatch(A)) {
3065 next = B;
3066 bar = foo;
3067 break;
95b24440 3068 }
bf1f174e
DM
3069 ...; // do some housekeeping, then ...
3070 sayNO; // propagate the failure
95b24440 3071 }
bf1f174e
DM
3072
3073The topmost backtrack state, pointed to by st, is usually free. If you
3074want to claim it, populate any ST.foo fields in it with values you wish to
3075save, then do one of
3076
4d5016e5
DM
3077 PUSH_STATE_GOTO(resume_state, node, newinput);
3078 PUSH_YES_STATE_GOTO(resume_state, node, newinput);
bf1f174e
DM
3079
3080which sets that backtrack state's resume value to 'resume_state', pushes a
3081new free entry to the top of the backtrack stack, then goes to 'node'.
3082On backtracking, the free slot is popped, and the saved state becomes the
3083new free state. An ST.foo field in this new top state can be temporarily
3084accessed to retrieve values, but once the main loop is re-entered, it
3085becomes available for reuse.
3086
3087Note that the depth of the backtrack stack constantly increases during the
3088left-to-right execution of the pattern, rather than going up and down with
3089the pattern nesting. For example the stack is at its maximum at Z at the
3090end of the pattern, rather than at X in the following:
3091
3092 /(((X)+)+)+....(Y)+....Z/
3093
3094The only exceptions to this are lookahead/behind assertions and the cut,
3095(?>A), which pop all the backtrack states associated with A before
3096continuing.
3097
486ec47a 3098Backtrack state structs are allocated in slabs of about 4K in size.
bf1f174e
DM
3099PL_regmatch_state and st always point to the currently active state,
3100and PL_regmatch_slab points to the slab currently containing
3101PL_regmatch_state. The first time regmatch() is called, the first slab is
3102allocated, and is never freed until interpreter destruction. When the slab
3103is full, a new one is allocated and chained to the end. At exit from
3104regmatch(), slabs allocated since entry are freed.
3105
3106*/
95b24440 3107
40a82448 3108
5bc10b2c 3109#define DEBUG_STATE_pp(pp) \
265c4333 3110 DEBUG_STATE_r({ \
f2ed9b32 3111 DUMP_EXEC_POS(locinput, scan, utf8_target); \
5bc10b2c 3112 PerlIO_printf(Perl_debug_log, \
5d458dd8 3113 " %*s"pp" %s%s%s%s%s\n", \
5bc10b2c 3114 depth*2, "", \
13d6edb4 3115 PL_reg_name[st->resume_state], \
5d458dd8
YO
3116 ((st==yes_state||st==mark_state) ? "[" : ""), \
3117 ((st==yes_state) ? "Y" : ""), \
3118 ((st==mark_state) ? "M" : ""), \
3119 ((st==yes_state||st==mark_state) ? "]" : "") \
3120 ); \
265c4333 3121 });
5bc10b2c 3122
40a82448 3123
3dab1dad 3124#define REG_NODE_NUM(x) ((x) ? (int)((x)-prog) : -1)
95b24440 3125
3df15adc 3126#ifdef DEBUGGING
5bc10b2c 3127
ab3bbdeb 3128STATIC void
f2ed9b32 3129S_debug_start_match(pTHX_ const REGEXP *prog, const bool utf8_target,
ab3bbdeb
YO
3130 const char *start, const char *end, const char *blurb)
3131{
efd26800 3132 const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
7918f24d
NC
3133
3134 PERL_ARGS_ASSERT_DEBUG_START_MATCH;
3135
ab3bbdeb
YO
3136 if (!PL_colorset)
3137 reginitcolors();
3138 {
3139 RE_PV_QUOTED_DECL(s0, utf8_pat, PERL_DEBUG_PAD_ZERO(0),
d2c6dc5e 3140 RX_PRECOMP_const(prog), RX_PRELEN(prog), 60);
ab3bbdeb 3141
f2ed9b32 3142 RE_PV_QUOTED_DECL(s1, utf8_target, PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb
YO
3143 start, end - start, 60);
3144
3145 PerlIO_printf(Perl_debug_log,
3146 "%s%s REx%s %s against %s\n",
3147 PL_colors[4], blurb, PL_colors[5], s0, s1);
3148
f2ed9b32 3149 if (utf8_target||utf8_pat)
1de06328
YO
3150 PerlIO_printf(Perl_debug_log, "UTF-8 %s%s%s...\n",
3151 utf8_pat ? "pattern" : "",
f2ed9b32
KW
3152 utf8_pat && utf8_target ? " and " : "",
3153 utf8_target ? "string" : ""
ab3bbdeb
YO
3154 );
3155 }
3156}
3df15adc
YO
3157
3158STATIC void
786e8c11
YO
3159S_dump_exec_pos(pTHX_ const char *locinput,
3160 const regnode *scan,
3161 const char *loc_regeol,
3162 const char *loc_bostr,
3163 const char *loc_reg_starttry,
f2ed9b32 3164 const bool utf8_target)
07be1b83 3165{
786e8c11 3166 const int docolor = *PL_colors[0] || *PL_colors[2] || *PL_colors[4];
07be1b83 3167 const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
786e8c11 3168 int l = (loc_regeol - locinput) > taill ? taill : (loc_regeol - locinput);
07be1b83
YO
3169 /* The part of the string before starttry has one color
3170 (pref0_len chars), between starttry and current
3171 position another one (pref_len - pref0_len chars),
3172 after the current position the third one.
3173 We assume that pref0_len <= pref_len, otherwise we
3174 decrease pref0_len. */
786e8c11
YO
3175 int pref_len = (locinput - loc_bostr) > (5 + taill) - l
3176 ? (5 + taill) - l : locinput - loc_bostr;
07be1b83
YO
3177 int pref0_len;
3178
7918f24d
NC
3179 PERL_ARGS_ASSERT_DUMP_EXEC_POS;
3180
f2ed9b32 3181 while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
07be1b83 3182 pref_len++;
786e8c11
YO
3183 pref0_len = pref_len - (locinput - loc_reg_starttry);
3184 if (l + pref_len < (5 + taill) && l < loc_regeol - locinput)
3185 l = ( loc_regeol - locinput > (5 + taill) - pref_len
3186 ? (5 + taill) - pref_len : loc_regeol - locinput);
f2ed9b32 3187 while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
07be1b83
YO
3188 l--;
3189 if (pref0_len < 0)
3190 pref0_len = 0;
3191 if (pref0_len > pref_len)
3192 pref0_len = pref_len;
3193 {
f2ed9b32 3194 const int is_uni = (utf8_target && OP(scan) != CANY) ? 1 : 0;
0df25f3d 3195
ab3bbdeb 3196 RE_PV_COLOR_DECL(s0,len0,is_uni,PERL_DEBUG_PAD(0),
1de06328 3197 (locinput - pref_len),pref0_len, 60, 4, 5);
0df25f3d 3198
ab3bbdeb 3199 RE_PV_COLOR_DECL(s1,len1,is_uni,PERL_DEBUG_PAD(1),
3df15adc 3200 (locinput - pref_len + pref0_len),
1de06328 3201 pref_len - pref0_len, 60, 2, 3);
0df25f3d 3202
ab3bbdeb 3203 RE_PV_COLOR_DECL(s2,len2,is_uni,PERL_DEBUG_PAD(2),
1de06328 3204 locinput, loc_regeol - locinput, 10, 0, 1);
0df25f3d 3205
1de06328 3206 const STRLEN tlen=len0+len1+len2;
3df15adc 3207 PerlIO_printf(Perl_debug_log,
ab3bbdeb 3208 "%4"IVdf" <%.*s%.*s%s%.*s>%*s|",
786e8c11 3209 (IV)(locinput - loc_bostr),
07be1b83 3210 len0, s0,
07be1b83 3211 len1, s1,
07be1b83 3212 (docolor ? "" : "> <"),
07be1b83 3213 len2, s2,
f9f4320a 3214 (int)(tlen > 19 ? 0 : 19 - tlen),
07be1b83
YO
3215 "");
3216 }
3217}
3df15adc 3218
07be1b83
YO
3219#endif
3220
0a4db386
YO
3221/* reg_check_named_buff_matched()
3222 * Checks to see if a named buffer has matched. The data array of
3223 * buffer numbers corresponding to the buffer is expected to reside
3224 * in the regexp->data->data array in the slot stored in the ARG() of
3225 * node involved. Note that this routine doesn't actually care about the
3226 * name, that information is not preserved from compilation to execution.
3227 * Returns the index of the leftmost defined buffer with the given name
3228 * or 0 if non of the buffers matched.
3229 */
3230STATIC I32
7918f24d
NC
3231S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
3232{
0a4db386 3233 I32 n;
f8fc2ecf 3234 RXi_GET_DECL(rex,rexi);
ad64d0ec 3235 SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
0a4db386 3236 I32 *nums=(I32*)SvPVX(sv_dat);
7918f24d
NC
3237
3238 PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
3239
0a4db386 3240 for ( n=0; n<SvIVX(sv_dat); n++ ) {
b93070ed
DM
3241 if ((I32)rex->lastparen >= nums[n] &&
3242 rex->offs[nums[n]].end != -1)
0a4db386
YO
3243 {
3244 return nums[n];
3245 }
3246 }
3247 return 0;
3248}
3249
2f554ef7
DM
3250
3251/* free all slabs above current one - called during LEAVE_SCOPE */
3252
3253STATIC void
3254S_clear_backtrack_stack(pTHX_ void *p)
3255{
3256 regmatch_slab *s = PL_regmatch_slab->next;
3257 PERL_UNUSED_ARG(p);
3258
3259 if (!s)
3260 return;
3261 PL_regmatch_slab->next = NULL;
3262 while (s) {
3263 regmatch_slab * const osl = s;
3264 s = s->next;
3265 Safefree(osl);
3266 }
3267}
3268
3269
f73aaa43
DM
3270/* returns -1 on failure, $+[0] on success */
3271STATIC I32
3272S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
d6a28714 3273{
a35a87e7 3274#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC
3275 dMY_CXT;
3276#endif
27da23d5 3277 dVAR;
eb578fdb 3278 const bool utf8_target = PL_reg_match_utf8;
4ad0818d 3279 const U32 uniflags = UTF8_ALLOW_DEFAULT;
288b8c02
NC
3280 REGEXP *rex_sv = reginfo->prog;
3281 regexp *rex = (struct regexp *)SvANY(rex_sv);
f8fc2ecf 3282 RXi_GET_DECL(rex,rexi);
2f554ef7 3283 I32 oldsave;
5d9a96ca 3284 /* the current state. This is a cached copy of PL_regmatch_state */
eb578fdb 3285 regmatch_state *st;
5d9a96ca 3286 /* cache heavy used fields of st in registers */
eb578fdb
KW
3287 regnode *scan;
3288 regnode *next;
3289 U32 n = 0; /* general value; init to avoid compiler warning */
3290 I32 ln = 0; /* len or last; init to avoid compiler warning */
d60de1d1 3291 char *locinput = startpos;
4d5016e5 3292 char *pushinput; /* where to continue after a PUSH */
eb578fdb 3293 I32 nextchr; /* is always set to UCHARAT(locinput) */
24d3c4a9 3294
b69b0499 3295 bool result = 0; /* return value of S_regmatch */
24d3c4a9 3296 int depth = 0; /* depth of backtrack stack */
4b196cd4
YO
3297 U32 nochange_depth = 0; /* depth of GOSUB recursion with nochange */
3298 const U32 max_nochange_depth =
3299 (3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
3300 3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
77cb431f
DM
3301 regmatch_state *yes_state = NULL; /* state to pop to on success of
3302 subpattern */
e2e6a0f1
YO
3303 /* mark_state piggy backs on the yes_state logic so that when we unwind
3304 the stack on success we can update the mark_state as we go */
3305 regmatch_state *mark_state = NULL; /* last mark state we have seen */
faec1544 3306 regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
b8591aee 3307 struct regmatch_state *cur_curlyx = NULL; /* most recent curlyx */
40a82448 3308 U32 state_num;
5d458dd8
YO
3309 bool no_final = 0; /* prevent failure from backtracking? */
3310 bool do_cutgroup = 0; /* no_final only until next branch/trie entry */
d60de1d1 3311 char *startpoint = locinput;
5d458dd8
YO
3312 SV *popmark = NULL; /* are we looking for a mark? */
3313 SV *sv_commit = NULL; /* last mark name seen in failure */
3314 SV *sv_yes_mark = NULL; /* last mark name we have seen
486ec47a 3315 during a successful match */
5d458dd8
YO
3316 U32 lastopen = 0; /* last open we saw */
3317 bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;
19b95bf0 3318 SV* const oreplsv = GvSV(PL_replgv);
24d3c4a9
DM
3319 /* these three flags are set by various ops to signal information to
3320 * the very next op. They have a useful lifetime of exactly one loop
3321 * iteration, and are not preserved or restored by state pushes/pops
3322 */
3323 bool sw = 0; /* the condition value in (?(cond)a|b) */
3324 bool minmod = 0; /* the next "{n,m}" is a "{n,m}?" */
3325 int logical = 0; /* the following EVAL is:
3326 0: (?{...})
3327 1: (?(?{...})X|Y)
3328 2: (??{...})
3329 or the following IFMATCH/UNLESSM is:
3330 false: plain (?=foo)
3331 true: used as a condition: (?(?=foo))
3332 */
81ed78b2
DM
3333 PAD* last_pad = NULL;
3334 dMULTICALL;
3335 I32 gimme = G_SCALAR;
3336 CV *caller_cv = NULL; /* who called us */
3337 CV *last_pushed_cv = NULL; /* most recently called (?{}) CV */
74088413 3338 CHECKPOINT runops_cp; /* savestack position before executing EVAL */
81ed78b2 3339
95b24440 3340#ifdef DEBUGGING
e68ec53f 3341 GET_RE_DEBUG_FLAGS_DECL;
d6a28714
JH
3342#endif
3343
81ed78b2
DM
3344 /* shut up 'may be used uninitialized' compiler warnings for dMULTICALL */
3345 multicall_oldcatch = 0;
3346 multicall_cv = NULL;
3347 cx = NULL;
4f8dbb2d
JL
3348 PERL_UNUSED_VAR(multicall_cop);
3349 PERL_UNUSED_VAR(newsp);
81ed78b2
DM
3350
3351
7918f24d
NC
3352 PERL_ARGS_ASSERT_REGMATCH;
3353
3b57cd43 3354 DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
24b23f37 3355 PerlIO_printf(Perl_debug_log,"regmatch start\n");
3b57cd43 3356 }));
5d9a96ca
DM
3357 /* on first ever call to regmatch, allocate first slab */
3358 if (!PL_regmatch_slab) {
3359 Newx(PL_regmatch_slab, 1, regmatch_slab);
3360 PL_regmatch_slab->prev = NULL;
3361 PL_regmatch_slab->next = NULL;
86545054 3362 PL_regmatch_state = SLAB_FIRST(PL_regmatch_slab);
5d9a96ca
DM
3363 }
3364
2f554ef7
DM
3365 oldsave = PL_savestack_ix;
3366 SAVEDESTRUCTOR_X(S_clear_backtrack_stack, NULL);
3367 SAVEVPTR(PL_regmatch_slab);
3368 SAVEVPTR(PL_regmatch_state);
5d9a96ca
DM
3369
3370 /* grab next free state slot */
3371 st = ++PL_regmatch_state;
86545054 3372 if (st > SLAB_LAST(PL_regmatch_slab))
5d9a96ca
DM
3373 st = PL_regmatch_state = S_push_slab(aTHX);
3374
d6a28714 3375 /* Note that nextchr is a byte even in UTF */
7016d6eb 3376 SET_nextchr;
d6a28714
JH
3377 scan = prog;
3378 while (scan != NULL) {
8ba1375e 3379
a3621e74 3380 DEBUG_EXECUTE_r( {
6136c704 3381 SV * const prop = sv_newmortal();
1de06328 3382 regnode *rnext=regnext(scan);
f2ed9b32 3383 DUMP_EXEC_POS( locinput, scan, utf8_target );
32fc9b6a 3384 regprop(rex, prop, scan);
07be1b83
YO
3385
3386 PerlIO_printf(Perl_debug_log,
3387 "%3"IVdf":%*s%s(%"IVdf")\n",
f8fc2ecf 3388 (IV)(scan - rexi->program), depth*2, "",
07be1b83 3389 SvPVX_const(prop),
1de06328 3390 (PL_regkind[OP(scan)] == END || !rnext) ?
f8fc2ecf 3391 0 : (IV)(rnext - rexi->program));
2a782b5b 3392 });
d6a28714
JH
3393
3394 next = scan + NEXT_OFF(scan);
3395 if (next == scan)
3396 next = NULL;
40a82448 3397 state_num = OP(scan);
d6a28714 3398
40a82448 3399 reenter_switch:
34a81e2b 3400
7016d6eb 3401 SET_nextchr;
bf798dc4 3402
40a82448 3403 switch (state_num) {
3c0563b9 3404 case BOL: /* /^../ */
7fba1cd6 3405 if (locinput == PL_bostr)
d6a28714 3406 {
3b0527fe 3407 /* reginfo->till = reginfo->bol; */
b8c5462f
JH
3408 break;
3409 }
d6a28714 3410 sayNO;
3c0563b9
DM
3411
3412 case MBOL: /* /^../m */
12d33761 3413 if (locinput == PL_bostr ||
7016d6eb 3414 (!NEXTCHR_IS_EOS && locinput[-1] == '\n'))
d6a28714 3415 {
b8c5462f
JH
3416 break;
3417 }
d6a28714 3418 sayNO;
3c0563b9
DM
3419
3420 case SBOL: /* /^../s */
c2a73568 3421 if (locinput == PL_bostr)
b8c5462f 3422 break;
d6a28714 3423 sayNO;
3c0563b9
DM
3424
3425 case GPOS: /* \G */
3b0527fe 3426 if (locinput == reginfo->ganch)
d6a28714
JH
3427 break;
3428 sayNO;
ee9b8eae 3429
3c0563b9 3430 case KEEPS: /* \K */
ee9b8eae 3431 /* update the startpoint */
b93070ed