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