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