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