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