This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Move t/op/rt69056.t test into t/op/subst.t
[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
JH
1823 MAGIC *mg;
1824
1825 if (flags & REXEC_IGNOREPOS) /* Means: check only at start */
58e23c8d 1826 reginfo.ganch = startpos + prog->gofs;
6eb5f6b9
JH
1827 else if (sv && SvTYPE(sv) >= SVt_PVMG
1828 && SvMAGIC(sv)
14befaf4
DM
1829 && (mg = mg_find(sv, PERL_MAGIC_regex_global))
1830 && mg->mg_len >= 0) {
3b0527fe 1831 reginfo.ganch = strbeg + mg->mg_len; /* Defined pos() */
bbe252da 1832 if (prog->extflags & RXf_ANCH_GPOS) {
3b0527fe 1833 if (s > reginfo.ganch)
6eb5f6b9 1834 goto phooey;
58e23c8d 1835 s = reginfo.ganch - prog->gofs;
c584a96e
YO
1836 if (s < strbeg)
1837 goto phooey;
6eb5f6b9
JH
1838 }
1839 }
58e23c8d 1840 else if (data) {
70685ca0 1841 reginfo.ganch = strbeg + PTR2UV(data);
58e23c8d 1842 } else /* pos() not defined */
3b0527fe 1843 reginfo.ganch = strbeg;
6eb5f6b9 1844 }
288b8c02 1845 if (PL_curpm && (PM_GETRE(PL_curpm) == rx)) {
e9105d30
GG
1846 /* We have to be careful. If the previous successful match
1847 was from this regex we don't want a subsequent partially
1848 successful match to clobber the old results.
1849 So when we detect this possibility we add a swap buffer
1850 to the re, and switch the buffer each match. If we fail
1851 we switch it back, otherwise we leave it swapped.
1852 */
1853 swap = prog->offs;
1854 /* do we need a save destructor here for eval dies? */
1855 Newxz(prog->offs, (prog->nparens + 1), regexp_paren_pair);
c74340f9 1856 }
a0714e2c 1857 if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
6eb5f6b9
JH
1858 re_scream_pos_data d;
1859
1860 d.scream_olds = &scream_olds;
1861 d.scream_pos = &scream_pos;
288b8c02 1862 s = re_intuit_start(rx, sv, s, strend, flags, &d);
3fa9c3d7 1863 if (!s) {
a3621e74 1864 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
6eb5f6b9 1865 goto phooey; /* not present */
3fa9c3d7 1866 }
6eb5f6b9
JH
1867 }
1868
1de06328 1869
6eb5f6b9
JH
1870
1871 /* Simplest case: anchored match need be tried only once. */
1872 /* [unless only anchor is BOL and multiline is set] */
bbe252da 1873 if (prog->extflags & (RXf_ANCH & ~RXf_ANCH_GPOS)) {
24b23f37 1874 if (s == startpos && regtry(&reginfo, &startpos))
6eb5f6b9 1875 goto got_it;
bbe252da
YO
1876 else if (multiline || (prog->intflags & PREGf_IMPLICIT)
1877 || (prog->extflags & RXf_ANCH_MBOL)) /* XXXX SBOL? */
6eb5f6b9
JH
1878 {
1879 char *end;
1880
1881 if (minlen)
1882 dontbother = minlen - 1;
1aa99e6b 1883 end = HOP3c(strend, -dontbother, strbeg) - 1;
6eb5f6b9 1884 /* for multiline we only have to try after newlines */
33b8afdf 1885 if (prog->check_substr || prog->check_utf8) {
6eb5f6b9
JH
1886 if (s == startpos)
1887 goto after_try;
1888 while (1) {
24b23f37 1889 if (regtry(&reginfo, &s))
6eb5f6b9
JH
1890 goto got_it;
1891 after_try:
5339e136 1892 if (s > end)
6eb5f6b9 1893 goto phooey;
bbe252da 1894 if (prog->extflags & RXf_USE_INTUIT) {
288b8c02 1895 s = re_intuit_start(rx, sv, s + 1, strend, flags, NULL);
6eb5f6b9
JH
1896 if (!s)
1897 goto phooey;
1898 }
1899 else
1900 s++;
1901 }
1902 } else {
1903 if (s > startpos)
1904 s--;
1905 while (s < end) {
1906 if (*s++ == '\n') { /* don't need PL_utf8skip here */
24b23f37 1907 if (regtry(&reginfo, &s))
6eb5f6b9
JH
1908 goto got_it;
1909 }
1910 }
1911 }
1912 }
1913 goto phooey;
bbe252da 1914 } else if (RXf_GPOS_CHECK == (prog->extflags & RXf_GPOS_CHECK))
f9f4320a
YO
1915 {
1916 /* the warning about reginfo.ganch being used without intialization
bbe252da 1917 is bogus -- we set it above, when prog->extflags & RXf_GPOS_SEEN
f9f4320a 1918 and we only enter this block when the same bit is set. */
58e23c8d 1919 char *tmp_s = reginfo.ganch - prog->gofs;
c584a96e
YO
1920
1921 if (tmp_s >= strbeg && regtry(&reginfo, &tmp_s))
6eb5f6b9
JH
1922 goto got_it;
1923 goto phooey;
1924 }
1925
1926 /* Messy cases: unanchored match. */
bbe252da 1927 if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
6eb5f6b9
JH
1928 /* we have /x+whatever/ */
1929 /* it must be a one character string (XXXX Except UTF?) */
33b8afdf 1930 char ch;
bf93d4cc
GS
1931#ifdef DEBUGGING
1932 int did_match = 0;
1933#endif
33b8afdf
JH
1934 if (!(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr))
1935 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
3f7c398e 1936 ch = SvPVX_const(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr)[0];
bf93d4cc 1937
1aa99e6b 1938 if (do_utf8) {
4cadc6a9 1939 REXEC_FBC_SCAN(
6eb5f6b9 1940 if (*s == ch) {
a3621e74 1941 DEBUG_EXECUTE_r( did_match = 1 );
24b23f37 1942 if (regtry(&reginfo, &s)) goto got_it;
6eb5f6b9
JH
1943 s += UTF8SKIP(s);
1944 while (s < strend && *s == ch)
1945 s += UTF8SKIP(s);
1946 }
4cadc6a9 1947 );
6eb5f6b9
JH
1948 }
1949 else {
4cadc6a9 1950 REXEC_FBC_SCAN(
6eb5f6b9 1951 if (*s == ch) {
a3621e74 1952 DEBUG_EXECUTE_r( did_match = 1 );
24b23f37 1953 if (regtry(&reginfo, &s)) goto got_it;
6eb5f6b9
JH
1954 s++;
1955 while (s < strend && *s == ch)
1956 s++;
1957 }
4cadc6a9 1958 );
6eb5f6b9 1959 }
a3621e74 1960 DEBUG_EXECUTE_r(if (!did_match)
bf93d4cc 1961 PerlIO_printf(Perl_debug_log,
b7953727
JH
1962 "Did not find anchored character...\n")
1963 );
6eb5f6b9 1964 }
a0714e2c
SS
1965 else if (prog->anchored_substr != NULL
1966 || prog->anchored_utf8 != NULL
1967 || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
33b8afdf
JH
1968 && prog->float_max_offset < strend - s)) {
1969 SV *must;
1970 I32 back_max;
1971 I32 back_min;
1972 char *last;
6eb5f6b9 1973 char *last1; /* Last position checked before */
bf93d4cc
GS
1974#ifdef DEBUGGING
1975 int did_match = 0;
1976#endif
33b8afdf
JH
1977 if (prog->anchored_substr || prog->anchored_utf8) {
1978 if (!(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr))
1979 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
1980 must = do_utf8 ? prog->anchored_utf8 : prog->anchored_substr;
1981 back_max = back_min = prog->anchored_offset;
1982 } else {
1983 if (!(do_utf8 ? prog->float_utf8 : prog->float_substr))
1984 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
1985 must = do_utf8 ? prog->float_utf8 : prog->float_substr;
1986 back_max = prog->float_max_offset;
1987 back_min = prog->float_min_offset;
1988 }
1de06328
YO
1989
1990
33b8afdf
JH
1991 if (must == &PL_sv_undef)
1992 /* could not downgrade utf8 check substring, so must fail */
1993 goto phooey;
1994
1de06328
YO
1995 if (back_min<0) {
1996 last = strend;
1997 } else {
1998 last = HOP3c(strend, /* Cannot start after this */
1999 -(I32)(CHR_SVLEN(must)
2000 - (SvTAIL(must) != 0) + back_min), strbeg);
2001 }
6eb5f6b9
JH
2002 if (s > PL_bostr)
2003 last1 = HOPc(s, -1);
2004 else
2005 last1 = s - 1; /* bogus */
2006
a0288114 2007 /* XXXX check_substr already used to find "s", can optimize if
6eb5f6b9
JH
2008 check_substr==must. */
2009 scream_pos = -1;
2010 dontbother = end_shift;
2011 strend = HOPc(strend, -dontbother);
2012 while ( (s <= last) &&
9041c2e3 2013 ((flags & REXEC_SCREAM)
1de06328 2014 ? (s = screaminstr(sv, must, HOP3c(s, back_min, (back_min<0 ? strbeg : strend)) - strbeg,
6eb5f6b9 2015 end_shift, &scream_pos, 0))
1de06328 2016 : (s = fbm_instr((unsigned char*)HOP3(s, back_min, (back_min<0 ? strbeg : strend)),
9041c2e3 2017 (unsigned char*)strend, must,
7fba1cd6 2018 multiline ? FBMrf_MULTILINE : 0))) ) {
4addbd3b 2019 /* we may be pointing at the wrong string */
07bc277f 2020 if ((flags & REXEC_SCREAM) && RXp_MATCH_COPIED(prog))
3f7c398e 2021 s = strbeg + (s - SvPVX_const(sv));
a3621e74 2022 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH
2023 if (HOPc(s, -back_max) > last1) {
2024 last1 = HOPc(s, -back_min);
2025 s = HOPc(s, -back_max);
2026 }
2027 else {
52657f30 2028 char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
6eb5f6b9
JH
2029
2030 last1 = HOPc(s, -back_min);
52657f30 2031 s = t;
6eb5f6b9 2032 }
1aa99e6b 2033 if (do_utf8) {
6eb5f6b9 2034 while (s <= last1) {
24b23f37 2035 if (regtry(&reginfo, &s))
6eb5f6b9
JH
2036 goto got_it;
2037 s += UTF8SKIP(s);
2038 }
2039 }
2040 else {
2041 while (s <= last1) {
24b23f37 2042 if (regtry(&reginfo, &s))
6eb5f6b9
JH
2043 goto got_it;
2044 s++;
2045 }
2046 }
2047 }
ab3bbdeb
YO
2048 DEBUG_EXECUTE_r(if (!did_match) {
2049 RE_PV_QUOTED_DECL(quoted, do_utf8, PERL_DEBUG_PAD_ZERO(0),
2050 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
2051 PerlIO_printf(Perl_debug_log, "Did not find %s substr %s%s...\n",
33b8afdf 2052 ((must == prog->anchored_substr || must == prog->anchored_utf8)
bf93d4cc 2053 ? "anchored" : "floating"),
ab3bbdeb
YO
2054 quoted, RE_SV_TAIL(must));
2055 });
6eb5f6b9
JH
2056 goto phooey;
2057 }
f8fc2ecf 2058 else if ( (c = progi->regstclass) ) {
f14c76ed 2059 if (minlen) {
f8fc2ecf 2060 const OPCODE op = OP(progi->regstclass);
66e933ab 2061 /* don't bother with what can't match */
786e8c11 2062 if (PL_regkind[op] != EXACT && op != CANY && PL_regkind[op] != TRIE)
f14c76ed
RGS
2063 strend = HOPc(strend, -(minlen - 1));
2064 }
a3621e74 2065 DEBUG_EXECUTE_r({
be8e71aa 2066 SV * const prop = sv_newmortal();
32fc9b6a 2067 regprop(prog, prop, c);
0df25f3d 2068 {
02daf0ab 2069 RE_PV_QUOTED_DECL(quoted,do_utf8,PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb 2070 s,strend-s,60);
0df25f3d 2071 PerlIO_printf(Perl_debug_log,
ab3bbdeb 2072 "Matching stclass %.*s against %s (%d chars)\n",
e4f74956 2073 (int)SvCUR(prop), SvPVX_const(prop),
ab3bbdeb 2074 quoted, (int)(strend - s));
0df25f3d 2075 }
ffc61ed2 2076 });
3b0527fe 2077 if (find_byclass(prog, c, s, strend, &reginfo))
6eb5f6b9 2078 goto got_it;
07be1b83 2079 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass... [regexec_flags]\n"));
d6a28714
JH
2080 }
2081 else {
2082 dontbother = 0;
a0714e2c 2083 if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
33b8afdf 2084 /* Trim the end. */
d6a28714 2085 char *last;
33b8afdf
JH
2086 SV* float_real;
2087
2088 if (!(do_utf8 ? prog->float_utf8 : prog->float_substr))
2089 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
2090 float_real = do_utf8 ? prog->float_utf8 : prog->float_substr;
d6a28714
JH
2091
2092 if (flags & REXEC_SCREAM) {
33b8afdf 2093 last = screaminstr(sv, float_real, s - strbeg,
d6a28714
JH
2094 end_shift, &scream_pos, 1); /* last one */
2095 if (!last)
ffc61ed2 2096 last = scream_olds; /* Only one occurrence. */
4addbd3b 2097 /* we may be pointing at the wrong string */
07bc277f 2098 else if (RXp_MATCH_COPIED(prog))
3f7c398e 2099 s = strbeg + (s - SvPVX_const(sv));
b8c5462f 2100 }
d6a28714
JH
2101 else {
2102 STRLEN len;
cfd0369c 2103 const char * const little = SvPV_const(float_real, len);
d6a28714 2104
33b8afdf 2105 if (SvTAIL(float_real)) {
d6a28714
JH
2106 if (memEQ(strend - len + 1, little, len - 1))
2107 last = strend - len + 1;
7fba1cd6 2108 else if (!multiline)
9041c2e3 2109 last = memEQ(strend - len, little, len)
bd61b366 2110 ? strend - len : NULL;
b8c5462f 2111 else
d6a28714
JH
2112 goto find_last;
2113 } else {
2114 find_last:
9041c2e3 2115 if (len)
d6a28714 2116 last = rninstr(s, strend, little, little + len);
b8c5462f 2117 else
a0288114 2118 last = strend; /* matching "$" */
b8c5462f 2119 }
b8c5462f 2120 }
bf93d4cc 2121 if (last == NULL) {
6bda09f9
YO
2122 DEBUG_EXECUTE_r(
2123 PerlIO_printf(Perl_debug_log,
2124 "%sCan't trim the tail, match fails (should not happen)%s\n",
2125 PL_colors[4], PL_colors[5]));
bf93d4cc
GS
2126 goto phooey; /* Should not happen! */
2127 }
d6a28714
JH
2128 dontbother = strend - last + prog->float_min_offset;
2129 }
2130 if (minlen && (dontbother < minlen))
2131 dontbother = minlen - 1;
2132 strend -= dontbother; /* this one's always in bytes! */
2133 /* We don't know much -- general case. */
1aa99e6b 2134 if (do_utf8) {
d6a28714 2135 for (;;) {
24b23f37 2136 if (regtry(&reginfo, &s))
d6a28714
JH
2137 goto got_it;
2138 if (s >= strend)
2139 break;
b8c5462f 2140 s += UTF8SKIP(s);
d6a28714
JH
2141 };
2142 }
2143 else {
2144 do {
24b23f37 2145 if (regtry(&reginfo, &s))
d6a28714
JH
2146 goto got_it;
2147 } while (s++ < strend);
2148 }
2149 }
2150
2151 /* Failure. */
2152 goto phooey;
2153
2154got_it:
e9105d30 2155 Safefree(swap);
288b8c02 2156 RX_MATCH_TAINTED_set(rx, PL_reg_flags & RF_tainted);
d6a28714 2157
19b95bf0 2158 if (PL_reg_eval_set)
4f639d21 2159 restore_pos(aTHX_ prog);
5daac39c
NC
2160 if (RXp_PAREN_NAMES(prog))
2161 (void)hv_iterinit(RXp_PAREN_NAMES(prog));
d6a28714
JH
2162
2163 /* make sure $`, $&, $', and $digit will work later */
2164 if ( !(flags & REXEC_NOT_FIRST) ) {
288b8c02 2165 RX_MATCH_COPY_FREE(rx);
d6a28714 2166 if (flags & REXEC_COPY_STR) {
be8e71aa 2167 const I32 i = PL_regeol - startpos + (stringarg - strbeg);
f8c7b90f 2168#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC
2169 if ((SvIsCOW(sv)
2170 || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS)) {
2171 if (DEBUG_C_TEST) {
2172 PerlIO_printf(Perl_debug_log,
2173 "Copy on write: regexp capture, type %d\n",
2174 (int) SvTYPE(sv));
2175 }
2176 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
d5263905 2177 prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
ed252734
NC
2178 assert (SvPOKp(prog->saved_copy));
2179 } else
2180#endif
2181 {
288b8c02 2182 RX_MATCH_COPIED_on(rx);
ed252734
NC
2183 s = savepvn(strbeg, i);
2184 prog->subbeg = s;
2185 }
d6a28714 2186 prog->sublen = i;
d6a28714
JH
2187 }
2188 else {
2189 prog->subbeg = strbeg;
2190 prog->sublen = PL_regeol - strbeg; /* strend may have been modified */
2191 }
2192 }
9041c2e3 2193
d6a28714
JH
2194 return 1;
2195
2196phooey:
a3621e74 2197 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
e4584336 2198 PL_colors[4], PL_colors[5]));
d6a28714 2199 if (PL_reg_eval_set)
4f639d21 2200 restore_pos(aTHX_ prog);
e9105d30 2201 if (swap) {
c74340f9 2202 /* we failed :-( roll it back */
e9105d30
GG
2203 Safefree(prog->offs);
2204 prog->offs = swap;
2205 }
2206
d6a28714
JH
2207 return 0;
2208}
2209
6bda09f9 2210
d6a28714
JH
2211/*
2212 - regtry - try match at specific point
2213 */
2214STATIC I32 /* 0 failure, 1 success */
24b23f37 2215S_regtry(pTHX_ regmatch_info *reginfo, char **startpos)
d6a28714 2216{
97aff369 2217 dVAR;
d6a28714 2218 CHECKPOINT lastcp;
288b8c02
NC
2219 REGEXP *const rx = reginfo->prog;
2220 regexp *const prog = (struct regexp *)SvANY(rx);
f8fc2ecf 2221 RXi_GET_DECL(prog,progi);
a3621e74 2222 GET_RE_DEBUG_FLAGS_DECL;
7918f24d
NC
2223
2224 PERL_ARGS_ASSERT_REGTRY;
2225
24b23f37 2226 reginfo->cutpoint=NULL;
d6a28714 2227
bbe252da 2228 if ((prog->extflags & RXf_EVAL_SEEN) && !PL_reg_eval_set) {
d6a28714
JH
2229 MAGIC *mg;
2230
2231 PL_reg_eval_set = RS_init;
a3621e74 2232 DEBUG_EXECUTE_r(DEBUG_s(
b900a521
JH
2233 PerlIO_printf(Perl_debug_log, " setting stack tmpbase at %"IVdf"\n",
2234 (IV)(PL_stack_sp - PL_stack_base));
d6a28714 2235 ));
ea8d6ae1 2236 SAVESTACK_CXPOS();
d6a28714
JH
2237 cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
2238 /* Otherwise OP_NEXTSTATE will free whatever on stack now. */
2239 SAVETMPS;
2240 /* Apparently this is not needed, judging by wantarray. */
e8347627 2241 /* SAVEI8(cxstack[cxstack_ix].blk_gimme);
d6a28714
JH
2242 cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
2243
3b0527fe 2244 if (reginfo->sv) {
d6a28714 2245 /* Make $_ available to executed code. */
3b0527fe 2246 if (reginfo->sv != DEFSV) {
59f00321 2247 SAVE_DEFSV;
414bf5ae 2248 DEFSV_set(reginfo->sv);
b8c5462f 2249 }
d6a28714 2250
3b0527fe
DM
2251 if (!(SvTYPE(reginfo->sv) >= SVt_PVMG && SvMAGIC(reginfo->sv)
2252 && (mg = mg_find(reginfo->sv, PERL_MAGIC_regex_global)))) {
d6a28714 2253 /* prepare for quick setting of pos */
d300d9fa 2254#ifdef PERL_OLD_COPY_ON_WRITE
51a9ea20
NC
2255 if (SvIsCOW(reginfo->sv))
2256 sv_force_normal_flags(reginfo->sv, 0);
d300d9fa 2257#endif
3dab1dad 2258 mg = sv_magicext(reginfo->sv, NULL, PERL_MAGIC_regex_global,
d300d9fa 2259 &PL_vtbl_mglob, NULL, 0);
d6a28714 2260 mg->mg_len = -1;
b8c5462f 2261 }
d6a28714
JH
2262 PL_reg_magic = mg;
2263 PL_reg_oldpos = mg->mg_len;
4f639d21 2264 SAVEDESTRUCTOR_X(restore_pos, prog);
d6a28714 2265 }
09687e5a 2266 if (!PL_reg_curpm) {
a02a5408 2267 Newxz(PL_reg_curpm, 1, PMOP);
09687e5a
AB
2268#ifdef USE_ITHREADS
2269 {
14a49a24 2270 SV* const repointer = &PL_sv_undef;
92313705
NC
2271 /* this regexp is also owned by the new PL_reg_curpm, which
2272 will try to free it. */
d2ece331 2273 av_push(PL_regex_padav, repointer);
09687e5a
AB
2274 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
2275 PL_regex_pad = AvARRAY(PL_regex_padav);
2276 }
2277#endif
2278 }
86c29d75
NC
2279#ifdef USE_ITHREADS
2280 /* It seems that non-ithreads works both with and without this code.
2281 So for efficiency reasons it seems best not to have the code
2282 compiled when it is not needed. */
92313705
NC
2283 /* This is safe against NULLs: */
2284 ReREFCNT_dec(PM_GETRE(PL_reg_curpm));
2285 /* PM_reg_curpm owns a reference to this regexp. */
2286 ReREFCNT_inc(rx);
86c29d75 2287#endif
288b8c02 2288 PM_SETRE(PL_reg_curpm, rx);
d6a28714
JH
2289 PL_reg_oldcurpm = PL_curpm;
2290 PL_curpm = PL_reg_curpm;
07bc277f 2291 if (RXp_MATCH_COPIED(prog)) {
d6a28714
JH
2292 /* Here is a serious problem: we cannot rewrite subbeg,
2293 since it may be needed if this match fails. Thus
2294 $` inside (?{}) could fail... */
2295 PL_reg_oldsaved = prog->subbeg;
2296 PL_reg_oldsavedlen = prog->sublen;
f8c7b90f 2297#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC
2298 PL_nrs = prog->saved_copy;
2299#endif
07bc277f 2300 RXp_MATCH_COPIED_off(prog);
d6a28714
JH
2301 }
2302 else
bd61b366 2303 PL_reg_oldsaved = NULL;
d6a28714
JH
2304 prog->subbeg = PL_bostr;
2305 prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2306 }
24b23f37 2307 DEBUG_EXECUTE_r(PL_reg_starttry = *startpos);
f0ab9afb 2308 prog->offs[0].start = *startpos - PL_bostr;
24b23f37 2309 PL_reginput = *startpos;
d6a28714 2310 PL_reglastparen = &prog->lastparen;
a01268b5 2311 PL_reglastcloseparen = &prog->lastcloseparen;
d6a28714 2312 prog->lastparen = 0;
03994de8 2313 prog->lastcloseparen = 0;
d6a28714 2314 PL_regsize = 0;
f0ab9afb 2315 PL_regoffs = prog->offs;
d6a28714
JH
2316 if (PL_reg_start_tmpl <= prog->nparens) {
2317 PL_reg_start_tmpl = prog->nparens*3/2 + 3;
2318 if(PL_reg_start_tmp)
2319 Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2320 else
a02a5408 2321 Newx(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
d6a28714
JH
2322 }
2323
2324 /* XXXX What this code is doing here?!!! There should be no need
2325 to do this again and again, PL_reglastparen should take care of
3dd2943c 2326 this! --ilya*/
dafc8851
JH
2327
2328 /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2329 * Actually, the code in regcppop() (which Ilya may be meaning by
daf18116 2330 * PL_reglastparen), is not needed at all by the test suite
225593e1
DM
2331 * (op/regexp, op/pat, op/split), but that code is needed otherwise
2332 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
2333 * Meanwhile, this code *is* needed for the
daf18116
JH
2334 * above-mentioned test suite tests to succeed. The common theme
2335 * on those tests seems to be returning null fields from matches.
225593e1 2336 * --jhi updated by dapm */
dafc8851 2337#if 1
d6a28714 2338 if (prog->nparens) {
f0ab9afb 2339 regexp_paren_pair *pp = PL_regoffs;
097eb12c 2340 register I32 i;
eb160463 2341 for (i = prog->nparens; i > (I32)*PL_reglastparen; i--) {
f0ab9afb
NC
2342 ++pp;
2343 pp->start = -1;
2344 pp->end = -1;
d6a28714
JH
2345 }
2346 }
dafc8851 2347#endif
02db2b7b 2348 REGCP_SET(lastcp);
f8fc2ecf 2349 if (regmatch(reginfo, progi->program + 1)) {
f0ab9afb 2350 PL_regoffs[0].end = PL_reginput - PL_bostr;
d6a28714
JH
2351 return 1;
2352 }
24b23f37
YO
2353 if (reginfo->cutpoint)
2354 *startpos= reginfo->cutpoint;
02db2b7b 2355 REGCP_UNWIND(lastcp);
d6a28714
JH
2356 return 0;
2357}
2358
02db2b7b 2359
8ba1375e
MJD
2360#define sayYES goto yes
2361#define sayNO goto no
262b90c4 2362#define sayNO_SILENT goto no_silent
8ba1375e 2363
f9f4320a
YO
2364/* we dont use STMT_START/END here because it leads to
2365 "unreachable code" warnings, which are bogus, but distracting. */
2366#define CACHEsayNO \
c476f425
DM
2367 if (ST.cache_mask) \
2368 PL_reg_poscache[ST.cache_offset] |= ST.cache_mask; \
f9f4320a 2369 sayNO
3298f257 2370
a3621e74 2371/* this is used to determine how far from the left messages like
265c4333
YO
2372 'failed...' are printed. It should be set such that messages
2373 are inline with the regop output that created them.
a3621e74 2374*/
265c4333 2375#define REPORT_CODE_OFF 32
a3621e74
YO
2376
2377
2378/* Make sure there is a test for this +1 options in re_tests */
2379#define TRIE_INITAL_ACCEPT_BUFFLEN 4;
2380
40a82448
DM
2381#define CHRTEST_UNINIT -1001 /* c1/c2 haven't been calculated yet */
2382#define CHRTEST_VOID -1000 /* the c1/c2 "next char" test should be skipped */
9e137952 2383
86545054
DM
2384#define SLAB_FIRST(s) (&(s)->states[0])
2385#define SLAB_LAST(s) (&(s)->states[PERL_REGMATCH_SLAB_SLOTS-1])
2386
5d9a96ca
DM
2387/* grab a new slab and return the first slot in it */
2388
2389STATIC regmatch_state *
2390S_push_slab(pTHX)
2391{
a35a87e7 2392#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC
2393 dMY_CXT;
2394#endif
5d9a96ca
DM
2395 regmatch_slab *s = PL_regmatch_slab->next;
2396 if (!s) {
2397 Newx(s, 1, regmatch_slab);
2398 s->prev = PL_regmatch_slab;
2399 s->next = NULL;
2400 PL_regmatch_slab->next = s;
2401 }
2402 PL_regmatch_slab = s;
86545054 2403 return SLAB_FIRST(s);
5d9a96ca 2404}
5b47454d 2405
95b24440 2406
40a82448
DM
2407/* push a new state then goto it */
2408
2409#define PUSH_STATE_GOTO(state, node) \
2410 scan = node; \
2411 st->resume_state = state; \
2412 goto push_state;
2413
2414/* push a new state with success backtracking, then goto it */
2415
2416#define PUSH_YES_STATE_GOTO(state, node) \
2417 scan = node; \
2418 st->resume_state = state; \
2419 goto push_yes_state;
2420
aa283a38 2421
aa283a38 2422
d6a28714 2423/*
95b24440 2424
bf1f174e
DM
2425regmatch() - main matching routine
2426
2427This is basically one big switch statement in a loop. We execute an op,
2428set 'next' to point the next op, and continue. If we come to a point which
2429we may need to backtrack to on failure such as (A|B|C), we push a
2430backtrack state onto the backtrack stack. On failure, we pop the top
2431state, and re-enter the loop at the state indicated. If there are no more
2432states to pop, we return failure.
2433
2434Sometimes we also need to backtrack on success; for example /A+/, where
2435after successfully matching one A, we need to go back and try to
2436match another one; similarly for lookahead assertions: if the assertion
2437completes successfully, we backtrack to the state just before the assertion
2438and then carry on. In these cases, the pushed state is marked as
2439'backtrack on success too'. This marking is in fact done by a chain of
2440pointers, each pointing to the previous 'yes' state. On success, we pop to
2441the nearest yes state, discarding any intermediate failure-only states.
2442Sometimes a yes state is pushed just to force some cleanup code to be
2443called at the end of a successful match or submatch; e.g. (??{$re}) uses
2444it to free the inner regex.
2445
2446Note that failure backtracking rewinds the cursor position, while
2447success backtracking leaves it alone.
2448
2449A pattern is complete when the END op is executed, while a subpattern
2450such as (?=foo) is complete when the SUCCESS op is executed. Both of these
2451ops trigger the "pop to last yes state if any, otherwise return true"
2452behaviour.
2453
2454A common convention in this function is to use A and B to refer to the two
2455subpatterns (or to the first nodes thereof) in patterns like /A*B/: so A is
2456the subpattern to be matched possibly multiple times, while B is the entire
2457rest of the pattern. Variable and state names reflect this convention.
2458
2459The states in the main switch are the union of ops and failure/success of
2460substates associated with with that op. For example, IFMATCH is the op
2461that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
2462'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
2463successfully matched A and IFMATCH_A_fail is a state saying that we have
2464just failed to match A. Resume states always come in pairs. The backtrack
2465state we push is marked as 'IFMATCH_A', but when that is popped, we resume
2466at IFMATCH_A or IFMATCH_A_fail, depending on whether we are backtracking
2467on success or failure.
2468
2469The struct that holds a backtracking state is actually a big union, with
2470one variant for each major type of op. The variable st points to the
2471top-most backtrack struct. To make the code clearer, within each
2472block of code we #define ST to alias the relevant union.
2473
2474Here's a concrete example of a (vastly oversimplified) IFMATCH
2475implementation:
2476
2477 switch (state) {
2478 ....
2479
2480#define ST st->u.ifmatch
2481
2482 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
2483 ST.foo = ...; // some state we wish to save
95b24440 2484 ...
bf1f174e
DM
2485 // push a yes backtrack state with a resume value of
2486 // IFMATCH_A/IFMATCH_A_fail, then continue execution at the
2487 // first node of A:
2488 PUSH_YES_STATE_GOTO(IFMATCH_A, A);
2489 // NOTREACHED
2490
2491 case IFMATCH_A: // we have successfully executed A; now continue with B
2492 next = B;
2493 bar = ST.foo; // do something with the preserved value
2494 break;
2495
2496 case IFMATCH_A_fail: // A failed, so the assertion failed
2497 ...; // do some housekeeping, then ...
2498 sayNO; // propagate the failure
2499
2500#undef ST
95b24440 2501
bf1f174e
DM
2502 ...
2503 }
95b24440 2504
bf1f174e
DM
2505For any old-timers reading this who are familiar with the old recursive
2506approach, the code above is equivalent to:
95b24440 2507
bf1f174e
DM
2508 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
2509 {
2510 int foo = ...
95b24440 2511 ...
bf1f174e
DM
2512 if (regmatch(A)) {
2513 next = B;
2514 bar = foo;
2515 break;
95b24440 2516 }
bf1f174e
DM
2517 ...; // do some housekeeping, then ...
2518 sayNO; // propagate the failure
95b24440 2519 }
bf1f174e
DM
2520
2521The topmost backtrack state, pointed to by st, is usually free. If you
2522want to claim it, populate any ST.foo fields in it with values you wish to
2523save, then do one of
2524
2525 PUSH_STATE_GOTO(resume_state, node);
2526 PUSH_YES_STATE_GOTO(resume_state, node);
2527
2528which sets that backtrack state's resume value to 'resume_state', pushes a
2529new free entry to the top of the backtrack stack, then goes to 'node'.
2530On backtracking, the free slot is popped, and the saved state becomes the
2531new free state. An ST.foo field in this new top state can be temporarily
2532accessed to retrieve values, but once the main loop is re-entered, it
2533becomes available for reuse.
2534
2535Note that the depth of the backtrack stack constantly increases during the
2536left-to-right execution of the pattern, rather than going up and down with
2537the pattern nesting. For example the stack is at its maximum at Z at the
2538end of the pattern, rather than at X in the following:
2539
2540 /(((X)+)+)+....(Y)+....Z/
2541
2542The only exceptions to this are lookahead/behind assertions and the cut,
2543(?>A), which pop all the backtrack states associated with A before
2544continuing.
2545
2546Bascktrack state structs are allocated in slabs of about 4K in size.
2547PL_regmatch_state and st always point to the currently active state,
2548and PL_regmatch_slab points to the slab currently containing
2549PL_regmatch_state. The first time regmatch() is called, the first slab is
2550allocated, and is never freed until interpreter destruction. When the slab
2551is full, a new one is allocated and chained to the end. At exit from
2552regmatch(), slabs allocated since entry are freed.
2553
2554*/
95b24440 2555
40a82448 2556
5bc10b2c 2557#define DEBUG_STATE_pp(pp) \
265c4333 2558 DEBUG_STATE_r({ \
5bc10b2c
DM
2559 DUMP_EXEC_POS(locinput, scan, do_utf8); \
2560 PerlIO_printf(Perl_debug_log, \
5d458dd8 2561 " %*s"pp" %s%s%s%s%s\n", \
5bc10b2c 2562 depth*2, "", \
13d6edb4 2563 PL_reg_name[st->resume_state], \
5d458dd8
YO
2564 ((st==yes_state||st==mark_state) ? "[" : ""), \
2565 ((st==yes_state) ? "Y" : ""), \
2566 ((st==mark_state) ? "M" : ""), \
2567 ((st==yes_state||st==mark_state) ? "]" : "") \
2568 ); \
265c4333 2569 });
5bc10b2c 2570
40a82448 2571
3dab1dad 2572#define REG_NODE_NUM(x) ((x) ? (int)((x)-prog) : -1)
95b24440 2573
3df15adc 2574#ifdef DEBUGGING
5bc10b2c 2575
ab3bbdeb 2576STATIC void
efd26800 2577S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8,
ab3bbdeb
YO
2578 const char *start, const char *end, const char *blurb)
2579{
efd26800 2580 const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
7918f24d
NC
2581
2582 PERL_ARGS_ASSERT_DEBUG_START_MATCH;
2583
ab3bbdeb
YO
2584 if (!PL_colorset)
2585 reginitcolors();
2586 {
2587 RE_PV_QUOTED_DECL(s0, utf8_pat, PERL_DEBUG_PAD_ZERO(0),
d2c6dc5e 2588 RX_PRECOMP_const(prog), RX_PRELEN(prog), 60);
ab3bbdeb
YO
2589
2590 RE_PV_QUOTED_DECL(s1, do_utf8, PERL_DEBUG_PAD_ZERO(1),
2591 start, end - start, 60);
2592
2593 PerlIO_printf(Perl_debug_log,
2594 "%s%s REx%s %s against %s\n",
2595 PL_colors[4], blurb, PL_colors[5], s0, s1);
2596
2597 if (do_utf8||utf8_pat)
1de06328
YO
2598 PerlIO_printf(Perl_debug_log, "UTF-8 %s%s%s...\n",
2599 utf8_pat ? "pattern" : "",
2600 utf8_pat && do_utf8 ? " and " : "",
2601 do_utf8 ? "string" : ""
ab3bbdeb
YO
2602 );
2603 }
2604}
3df15adc
YO
2605
2606STATIC void
786e8c11
YO
2607S_dump_exec_pos(pTHX_ const char *locinput,
2608 const regnode *scan,
2609 const char *loc_regeol,
2610 const char *loc_bostr,
2611 const char *loc_reg_starttry,
2612 const bool do_utf8)
07be1b83 2613{
786e8c11 2614 const int docolor = *PL_colors[0] || *PL_colors[2] || *PL_colors[4];
07be1b83 2615 const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
786e8c11 2616 int l = (loc_regeol - locinput) > taill ? taill : (loc_regeol - locinput);
07be1b83
YO
2617 /* The part of the string before starttry has one color
2618 (pref0_len chars), between starttry and current
2619 position another one (pref_len - pref0_len chars),
2620 after the current position the third one.
2621 We assume that pref0_len <= pref_len, otherwise we
2622 decrease pref0_len. */
786e8c11
YO
2623 int pref_len = (locinput - loc_bostr) > (5 + taill) - l
2624 ? (5 + taill) - l : locinput - loc_bostr;
07be1b83
YO
2625 int pref0_len;
2626
7918f24d
NC
2627 PERL_ARGS_ASSERT_DUMP_EXEC_POS;
2628
07be1b83
YO
2629 while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
2630 pref_len++;
786e8c11
YO
2631 pref0_len = pref_len - (locinput - loc_reg_starttry);
2632 if (l + pref_len < (5 + taill) && l < loc_regeol - locinput)
2633 l = ( loc_regeol - locinput > (5 + taill) - pref_len
2634 ? (5 + taill) - pref_len : loc_regeol - locinput);
07be1b83
YO
2635 while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
2636 l--;
2637 if (pref0_len < 0)
2638 pref0_len = 0;
2639 if (pref0_len > pref_len)
2640 pref0_len = pref_len;
2641 {
3df15adc 2642 const int is_uni = (do_utf8 && OP(scan) != CANY) ? 1 : 0;
0df25f3d 2643
ab3bbdeb 2644 RE_PV_COLOR_DECL(s0,len0,is_uni,PERL_DEBUG_PAD(0),
1de06328 2645 (locinput - pref_len),pref0_len, 60, 4, 5);
0df25f3d 2646
ab3bbdeb 2647 RE_PV_COLOR_DECL(s1,len1,is_uni,PERL_DEBUG_PAD(1),
3df15adc 2648 (locinput - pref_len + pref0_len),
1de06328 2649 pref_len - pref0_len, 60, 2, 3);
0df25f3d 2650
ab3bbdeb 2651 RE_PV_COLOR_DECL(s2,len2,is_uni,PERL_DEBUG_PAD(2),
1de06328 2652 locinput, loc_regeol - locinput, 10, 0, 1);
0df25f3d 2653
1de06328 2654 const STRLEN tlen=len0+len1+len2;
3df15adc 2655 PerlIO_printf(Perl_debug_log,
ab3bbdeb 2656 "%4"IVdf" <%.*s%.*s%s%.*s>%*s|",
786e8c11 2657 (IV)(locinput - loc_bostr),
07be1b83 2658 len0, s0,
07be1b83 2659 len1, s1,
07be1b83 2660 (docolor ? "" : "> <"),
07be1b83 2661 len2, s2,
f9f4320a 2662 (int)(tlen > 19 ? 0 : 19 - tlen),
07be1b83
YO
2663 "");
2664 }
2665}
3df15adc 2666
07be1b83
YO
2667#endif
2668
0a4db386
YO
2669/* reg_check_named_buff_matched()
2670 * Checks to see if a named buffer has matched. The data array of
2671 * buffer numbers corresponding to the buffer is expected to reside
2672 * in the regexp->data->data array in the slot stored in the ARG() of
2673 * node involved. Note that this routine doesn't actually care about the
2674 * name, that information is not preserved from compilation to execution.
2675 * Returns the index of the leftmost defined buffer with the given name
2676 * or 0 if non of the buffers matched.
2677 */
2678STATIC I32
7918f24d
NC
2679S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
2680{
0a4db386 2681 I32 n;
f8fc2ecf 2682 RXi_GET_DECL(rex,rexi);
ad64d0ec 2683 SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
0a4db386 2684 I32 *nums=(I32*)SvPVX(sv_dat);
7918f24d
NC
2685
2686 PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
2687
0a4db386
YO
2688 for ( n=0; n<SvIVX(sv_dat); n++ ) {
2689 if ((I32)*PL_reglastparen >= nums[n] &&
f0ab9afb 2690 PL_regoffs[nums[n]].end != -1)
0a4db386
YO
2691 {
2692 return nums[n];
2693 }
2694 }
2695 return 0;
2696}
2697
2f554ef7
DM
2698
2699/* free all slabs above current one - called during LEAVE_SCOPE */
2700
2701STATIC void
2702S_clear_backtrack_stack(pTHX_ void *p)
2703{
2704 regmatch_slab *s = PL_regmatch_slab->next;
2705 PERL_UNUSED_ARG(p);
2706
2707 if (!s)
2708 return;
2709 PL_regmatch_slab->next = NULL;
2710 while (s) {
2711 regmatch_slab * const osl = s;
2712 s = s->next;
2713 Safefree(osl);
2714 }
2715}
2716
2717
28d8d7f4
YO
2718#define SETREX(Re1,Re2) \
2719 if (PL_reg_eval_set) PM_SETRE((PL_reg_curpm), (Re2)); \
2720 Re1 = (Re2)
2721
d6a28714 2722STATIC I32 /* 0 failure, 1 success */
24b23f37 2723S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
d6a28714 2724{
a35a87e7 2725#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC
2726 dMY_CXT;
2727#endif
27da23d5 2728 dVAR;
95b24440 2729 register const bool do_utf8 = PL_reg_match_utf8;
4ad0818d 2730 const U32 uniflags = UTF8_ALLOW_DEFAULT;
288b8c02
NC
2731 REGEXP *rex_sv = reginfo->prog;
2732 regexp *rex = (struct regexp *)SvANY(rex_sv);
f8fc2ecf 2733 RXi_GET_DECL(rex,rexi);
2f554ef7 2734 I32 oldsave;
5d9a96ca
DM
2735 /* the current state. This is a cached copy of PL_regmatch_state */
2736 register regmatch_state *st;
5d9a96ca
DM
2737 /* cache heavy used fields of st in registers */
2738 register regnode *scan;
2739 register regnode *next;
438e9bae 2740 register U32 n = 0; /* general value; init to avoid compiler warning */
24d3c4a9 2741 register I32 ln = 0; /* len or last; init to avoid compiler warning */
5d9a96ca 2742 register char *locinput = PL_reginput;
5d9a96ca 2743 register I32 nextchr; /* is always set to UCHARAT(locinput) */
24d3c4a9 2744
b69b0499 2745 bool result = 0; /* return value of S_regmatch */
24d3c4a9 2746 int depth = 0; /* depth of backtrack stack */
4b196cd4
YO
2747 U32 nochange_depth = 0; /* depth of GOSUB recursion with nochange */
2748 const U32 max_nochange_depth =
2749 (3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
2750 3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
77cb431f
DM
2751 regmatch_state *yes_state = NULL; /* state to pop to on success of
2752 subpattern */
e2e6a0f1
YO
2753 /* mark_state piggy backs on the yes_state logic so that when we unwind
2754 the stack on success we can update the mark_state as we go */
2755 regmatch_state *mark_state = NULL; /* last mark state we have seen */
faec1544 2756 regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
b8591aee 2757 struct regmatch_state *cur_curlyx = NULL; /* most recent curlyx */
40a82448 2758 U32 state_num;
5d458dd8
YO
2759 bool no_final = 0; /* prevent failure from backtracking? */
2760 bool do_cutgroup = 0; /* no_final only until next branch/trie entry */
e2e6a0f1 2761 char *startpoint = PL_reginput;
5d458dd8
YO
2762 SV *popmark = NULL; /* are we looking for a mark? */
2763 SV *sv_commit = NULL; /* last mark name seen in failure */
2764 SV *sv_yes_mark = NULL; /* last mark name we have seen
2765 during a successfull match */
2766 U32 lastopen = 0; /* last open we saw */
2767 bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;
19b95bf0 2768 SV* const oreplsv = GvSV(PL_replgv);
24d3c4a9
DM
2769 /* these three flags are set by various ops to signal information to
2770 * the very next op. They have a useful lifetime of exactly one loop
2771 * iteration, and are not preserved or restored by state pushes/pops
2772 */
2773 bool sw = 0; /* the condition value in (?(cond)a|b) */
2774 bool minmod = 0; /* the next "{n,m}" is a "{n,m}?" */
2775 int logical = 0; /* the following EVAL is:
2776 0: (?{...})
2777 1: (?(?{...})X|Y)
2778 2: (??{...})
2779 or the following IFMATCH/UNLESSM is:
2780 false: plain (?=foo)
2781 true: used as a condition: (?(?=foo))
2782 */
95b24440 2783#ifdef DEBUGGING
e68ec53f 2784 GET_RE_DEBUG_FLAGS_DECL;
d6a28714
JH
2785#endif
2786
7918f24d
NC
2787 PERL_ARGS_ASSERT_REGMATCH;
2788
3b57cd43 2789 DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
24b23f37 2790 PerlIO_printf(Perl_debug_log,"regmatch start\n");
3b57cd43 2791 }));
5d9a96ca
DM
2792 /* on first ever call to regmatch, allocate first slab */
2793 if (!PL_regmatch_slab) {
2794 Newx(PL_regmatch_slab, 1, regmatch_slab);
2795 PL_regmatch_slab->prev = NULL;
2796 PL_regmatch_slab->next = NULL;
86545054 2797 PL_regmatch_state = SLAB_FIRST(PL_regmatch_slab);
5d9a96ca
DM
2798 }
2799
2f554ef7
DM
2800 oldsave = PL_savestack_ix;
2801 SAVEDESTRUCTOR_X(S_clear_backtrack_stack, NULL);
2802 SAVEVPTR(PL_regmatch_slab);
2803 SAVEVPTR(PL_regmatch_state);
5d9a96ca
DM
2804
2805 /* grab next free state slot */
2806 st = ++PL_regmatch_state;
86545054 2807 if (st > SLAB_LAST(PL_regmatch_slab))
5d9a96ca
DM
2808 st = PL_regmatch_state = S_push_slab(aTHX);
2809
d6a28714
JH
2810 /* Note that nextchr is a byte even in UTF */
2811 nextchr = UCHARAT(locinput);
2812 scan = prog;
2813 while (scan != NULL) {
8ba1375e 2814
a3621e74 2815 DEBUG_EXECUTE_r( {
6136c704 2816 SV * const prop = sv_newmortal();
1de06328 2817 regnode *rnext=regnext(scan);
786e8c11 2818 DUMP_EXEC_POS( locinput, scan, do_utf8 );
32fc9b6a 2819 regprop(rex, prop, scan);
07be1b83
YO
2820
2821 PerlIO_printf(Perl_debug_log,
2822 "%3"IVdf":%*s%s(%"IVdf")\n",
f8fc2ecf 2823 (IV)(scan - rexi->program), depth*2, "",
07be1b83 2824 SvPVX_const(prop),
1de06328 2825 (PL_regkind[OP(scan)] == END || !rnext) ?
f8fc2ecf 2826 0 : (IV)(rnext - rexi->program));
2a782b5b 2827 });
d6a28714
JH
2828
2829 next = scan + NEXT_OFF(scan);
2830 if (next == scan)
2831 next = NULL;
40a82448 2832 state_num = OP(scan);
d6a28714 2833
40a82448 2834 reenter_switch:
34a81e2b
B
2835
2836 assert(PL_reglastparen == &rex->lastparen);
2837 assert(PL_reglastcloseparen == &rex->lastcloseparen);
2838 assert(PL_regoffs == rex->offs);
2839
40a82448 2840 switch (state_num) {
d6a28714 2841 case BOL:
7fba1cd6 2842 if (locinput == PL_bostr)
d6a28714 2843 {
3b0527fe 2844 /* reginfo->till = reginfo->bol; */
b8c5462f
JH
2845 break;
2846 }
d6a28714
JH
2847 sayNO;
2848 case MBOL:
12d33761
HS
2849 if (locinput == PL_bostr ||
2850 ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n'))
d6a28714 2851 {
b8c5462f
JH
2852 break;
2853 }
d6a28714
JH
2854 sayNO;
2855 case SBOL:
c2a73568 2856 if (locinput == PL_bostr)
b8c5462f 2857 break;
d6a28714
JH
2858 sayNO;
2859 case GPOS:
3b0527fe 2860 if (locinput == reginfo->ganch)
d6a28714
JH
2861 break;
2862 sayNO;
ee9b8eae
YO
2863
2864 case KEEPS:
2865 /* update the startpoint */
f0ab9afb 2866 st->u.keeper.val = PL_regoffs[0].start;
ee9b8eae 2867 PL_reginput = locinput;
f0ab9afb 2868 PL_regoffs[0].start = locinput - PL_bostr;
ee9b8eae
YO
2869 PUSH_STATE_GOTO(KEEPS_next, next);
2870 /*NOT-REACHED*/
2871 case KEEPS_next_fail:
2872 /* rollback the start point change */
f0ab9afb 2873 PL_regoffs[0].start = st->u.keeper.val;
ee9b8eae
YO
2874 sayNO_SILENT;
2875 /*NOT-REACHED*/
d6a28714 2876 case EOL:
d6a28714
JH
2877 goto seol;
2878 case MEOL:
d6a28714 2879 if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
b8c5462f 2880 sayNO;
b8c5462f 2881 break;
d6a28714
JH
2882 case SEOL:
2883 seol:
2884 if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
b8c5462f 2885 sayNO;
d6a28714 2886 if (PL_regeol - locinput > 1)
b8c5462f 2887 sayNO;
b8c5462f 2888 break;
d6a28714
JH
2889 case EOS:
2890 if (PL_regeol != locinput)
b8c5462f 2891 sayNO;
d6a28714 2892 break;
ffc61ed2 2893 case SANY:
d6a28714 2894 if (!nextchr && locinput >= PL_regeol)
4633a7c4 2895 sayNO;
f33976b4
DB
2896 if (do_utf8) {
2897 locinput += PL_utf8skip[nextchr];
2898 if (locinput > PL_regeol)
2899 sayNO;
2900 nextchr = UCHARAT(locinput);
2901 }
2902 else
2903 nextchr = UCHARAT(++locinput);
2904 break;
2905 case CANY:
2906 if (!nextchr && locinput >= PL_regeol)
2907 sayNO;
b8c5462f 2908 nextchr = UCHARAT(++locinput);
a0d0e21e 2909 break;
ffc61ed2 2910 case REG_ANY:
1aa99e6b
IH
2911 if ((!nextchr && locinput >= PL_regeol) || nextchr == '\n')
2912 sayNO;
2913 if (do_utf8) {
b8c5462f 2914 locinput += PL_utf8skip[nextchr];
d6a28714
JH
2915 if (locinput > PL_regeol)
2916 sayNO;
a0ed51b3 2917 nextchr = UCHARAT(locinput);
a0ed51b3 2918 }
1aa99e6b
IH
2919 else
2920 nextchr = UCHARAT(++locinput);
a0ed51b3 2921 break;
166ba7cd
DM
2922
2923#undef ST
2924#define ST st->u.trie
786e8c11
YO
2925 case TRIEC:
2926 /* In this case the charclass data is available inline so
2927 we can fail fast without a lot of extra overhead.
2928 */
2929 if (scan->flags == EXACT || !do_utf8) {
2930 if(!ANYOF_BITMAP_TEST(scan, *locinput)) {
2931 DEBUG_EXECUTE_r(
2932 PerlIO_printf(Perl_debug_log,
2933 "%*s %sfailed to match trie start class...%s\n",
5bc10b2c 2934 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
786e8c11
YO
2935 );
2936 sayNO_SILENT;
2937 /* NOTREACHED */
2938 }
2939 }
2940 /* FALL THROUGH */
5b47454d 2941 case TRIE:
3dab1dad 2942 {
07be1b83 2943 /* what type of TRIE am I? (utf8 makes this contextual) */
a0a388a1 2944 DECL_TRIE_TYPE(scan);
3dab1dad
YO
2945
2946 /* what trie are we using right now */
be8e71aa 2947 reg_trie_data * const trie
f8fc2ecf 2948 = (reg_trie_data*)rexi->data->data[ ARG( scan ) ];
85fbaab2 2949 HV * widecharmap = MUTABLE_HV(rexi->data->data[ ARG( scan ) + 1 ]);
3dab1dad 2950 U32 state = trie->startstate;
166ba7cd 2951
3dab1dad
YO
2952 if (trie->bitmap && trie_type != trie_utf8_fold &&
2953 !TRIE_BITMAP_TEST(trie,*locinput)
2954 ) {
2955 if (trie->states[ state ].wordnum) {
2956 DEBUG_EXECUTE_r(
2957 PerlIO_printf(Perl_debug_log,
2958 "%*s %smatched empty string...%s\n",
5bc10b2c 2959 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3dab1dad
YO
2960 );
2961 break;
2962 } else {
2963 DEBUG_EXECUTE_r(
2964 PerlIO_printf(Perl_debug_log,
786e8c11 2965 "%*s %sfailed to match trie start class...%s\n",
5bc10b2c 2966 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3dab1dad
YO
2967 );
2968 sayNO_SILENT;
2969 }
2970 }
166ba7cd 2971
786e8c11
YO
2972 {
2973 U8 *uc = ( U8* )locinput;
2974
2975 STRLEN len = 0;
2976 STRLEN foldlen = 0;
2977 U8 *uscan = (U8*)NULL;
2978 STRLEN bufflen=0;
2979 SV *sv_accept_buff = NULL;
2980 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
2981
2982 ST.accepted = 0; /* how many accepting states we have seen */
2983 ST.B = next;
2984 ST.jump = trie->jump;
786e8c11 2985 ST.me = scan;
07be1b83
YO
2986 /*
2987 traverse the TRIE keeping track of all accepting states
2988 we transition through until we get to a failing node.
2989 */
2990
a3621e74 2991 while ( state && uc <= (U8*)PL_regeol ) {
786e8c11 2992 U32 base = trie->states[ state ].trans.base;
f9f4320a 2993 UV uvc = 0;
786e8c11
YO
2994 U16 charid;
2995 /* We use charid to hold the wordnum as we don't use it
2996 for charid until after we have done the wordnum logic.
2997 We define an alias just so that the wordnum logic reads
2998 more naturally. */
2999
3000#define got_wordnum charid
3001 got_wordnum = trie->states[ state ].wordnum;
3002
3003 if ( got_wordnum ) {
3004 if ( ! ST.accepted ) {
5b47454d 3005 ENTER;
6962fb1a 3006 SAVETMPS; /* XXX is this necessary? dmq */
5b47454d
DM
3007 bufflen = TRIE_INITAL_ACCEPT_BUFFLEN;
3008 sv_accept_buff=newSV(bufflen *
3009 sizeof(reg_trie_accepted) - 1);
786e8c11 3010 SvCUR_set(sv_accept_buff, 0);
5b47454d
DM
3011 SvPOK_on(sv_accept_buff);
3012 sv_2mortal(sv_accept_buff);
166ba7cd
DM
3013 SAVETMPS;
3014 ST.accept_buff =
5b47454d
DM
3015 (reg_trie_accepted*)SvPV_nolen(sv_accept_buff );
3016 }
786e8c11 3017 do {
166ba7cd 3018 if (ST.accepted >= bufflen) {
5b47454d 3019 bufflen *= 2;
166ba7cd 3020 ST.accept_buff =(reg_trie_accepted*)
5b47454d
DM
3021 SvGROW(sv_accept_buff,
3022 bufflen * sizeof(reg_trie_accepted));
3023 }
3024 SvCUR_set(sv_accept_buff,SvCUR(sv_accept_buff)
3025 + sizeof(reg_trie_accepted));
a3621e74 3026
786e8c11
YO
3027
3028 ST.accept_buff[ST.accepted].wordnum = got_wordnum;
3029 ST.accept_buff[ST.accepted].endpos = uc;
3030 ++ST.accepted;
3031 } while (trie->nextword && (got_wordnum= trie->nextword[got_wordnum]));
3032 }
3033#undef got_wordnum
a3621e74 3034
07be1b83 3035 DEBUG_TRIE_EXECUTE_r({
786e8c11 3036 DUMP_EXEC_POS( (char *)uc, scan, do_utf8 );
a3621e74 3037 PerlIO_printf( Perl_debug_log,
786e8c11 3038 "%*s %sState: %4"UVxf" Accepted: %4"UVxf" ",
5bc10b2c 3039 2+depth * 2, "", PL_colors[4],
786e8c11 3040 (UV)state, (UV)ST.accepted );
07be1b83 3041 });
a3621e74
YO
3042
3043 if ( base ) {
55eed653
NC
3044 REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc,
3045 uscan, len, uvc, charid, foldlen,
3046 foldbuf, uniflags);
a3621e74 3047
5b47454d
DM
3048 if (charid &&
3049 (base + charid > trie->uniquecharcount )
3050 && (base + charid - 1 - trie->uniquecharcount
3051 < trie->lasttrans)
3052 && trie->trans[base + charid - 1 -
3053 trie->uniquecharcount].check == state)
3054 {
3055 state = trie->trans[base + charid - 1 -
3056 trie->uniquecharcount ].next;
3057 }
3058 else {
3059 state = 0;
3060 }
3061 uc += len;
3062
3063 }
3064 else {
a3621e74
YO
3065 state = 0;
3066 }
3067 DEBUG_TRIE_EXECUTE_r(
e4584336 3068 PerlIO_printf( Perl_debug_log,
786e8c11 3069 "Charid:%3x CP:%4"UVxf" After State: %4"UVxf"%s\n",
e4584336 3070 charid, uvc, (UV)state, PL_colors[5] );
a3621e74
YO
3071 );
3072 }
166ba7cd 3073 if (!ST.accepted )
a3621e74 3074 sayNO;
a3621e74 3075
166ba7cd
DM
3076 DEBUG_EXECUTE_r(
3077 PerlIO_printf( Perl_debug_log,
3078 "%*s %sgot %"IVdf" possible matches%s\n",
5bc10b2c 3079 REPORT_CODE_OFF + depth * 2, "",
166ba7cd
DM
3080 PL_colors[4], (IV)ST.accepted, PL_colors[5] );
3081 );
786e8c11 3082 }}
fae667d5
YO
3083 goto trie_first_try; /* jump into the fail handler */
3084 /* NOTREACHED */
166ba7cd 3085 case TRIE_next_fail: /* we failed - try next alterative */
fae667d5
YO
3086 if ( ST.jump) {
3087 REGCP_UNWIND(ST.cp);
3088 for (n = *PL_reglastparen; n > ST.lastparen; n--)
f0ab9afb 3089 PL_regoffs[n].end = -1;
fae667d5
YO
3090 *PL_reglastparen = n;
3091 }
3092 trie_first_try:
5d458dd8
YO
3093 if (do_cutgroup) {
3094 do_cutgroup = 0;
3095 no_final = 0;
3096 }
fae667d5
YO
3097
3098 if ( ST.jump) {
3099 ST.lastparen = *PL_reglastparen;
3100 REGCP_SET(ST.cp);
3101 }
166ba7cd
DM
3102 if ( ST.accepted == 1 ) {
3103 /* only one choice left - just continue */
3104 DEBUG_EXECUTE_r({
2b8b4781 3105 AV *const trie_words
502c6561 3106 = MUTABLE_AV(rexi->data->data[ARG(ST.me)+TRIE_WORDS_OFFSET]);
2b8b4781 3107 SV ** const tmp = av_fetch( trie_words,
5c9f2f80 3108 ST.accept_buff[ 0 ].wordnum-1, 0 );
de734bd5
A
3109 SV *sv= tmp ? sv_newmortal() : NULL;
3110
166ba7cd
DM
3111 PerlIO_printf( Perl_debug_log,
3112 "%*s %sonly one match left: #%d <%s>%s\n",
5bc10b2c 3113 REPORT_CODE_OFF+depth*2, "", PL_colors[4],
166ba7cd 3114 ST.accept_buff[ 0 ].wordnum,
de734bd5
A
3115 tmp ? pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 0,
3116 PL_colors[0], PL_colors[1],
3117 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)
3118 )
3119 : "not compiled under -Dr",
166ba7cd
DM
3120 PL_colors[5] );
3121 });
3122 PL_reginput = (char *)ST.accept_buff[ 0 ].endpos;
3123 /* in this case we free tmps/leave before we call regmatch
3124 as we wont be using accept_buff again. */
5d458dd8 3125
166ba7cd
DM
3126 locinput = PL_reginput;
3127 nextchr = UCHARAT(locinput);
5d458dd8
YO
3128 if ( !ST.jump || !ST.jump[ST.accept_buff[0].wordnum])
3129 scan = ST.B;
3130 else
3131 scan = ST.me + ST.jump[ST.accept_buff[0].wordnum];
3132 if (!has_cutgroup) {
3133 FREETMPS;
3134 LEAVE;
3135 } else {
3136 ST.accepted--;
3137 PUSH_YES_STATE_GOTO(TRIE_next, scan);
3138 }
786e8c11 3139
166ba7cd
DM
3140 continue; /* execute rest of RE */
3141 }
fae667d5
YO
3142
3143 if ( !ST.accepted-- ) {
5d458dd8
YO
3144 DEBUG_EXECUTE_r({
3145 PerlIO_printf( Perl_debug_log,
3146 "%*s %sTRIE failed...%s\n",
3147 REPORT_CODE_OFF+depth*2, "",
3148 PL_colors[4],
3149 PL_colors[5] );
3150 });
166ba7cd
DM
3151 FREETMPS;
3152 LEAVE;
5d458dd8 3153 sayNO_SILENT;
fae667d5
YO
3154 /*NOTREACHED*/
3155 }
166ba7cd 3156
a3621e74 3157 /*
166ba7cd
DM
3158 There are at least two accepting states left. Presumably
3159 the number of accepting states is going to be low,
3160 typically two. So we simply scan through to find the one
3161 with lowest wordnum. Once we find it, we swap the last
3162 state into its place and decrement the size. We then try to
3163 match the rest of the pattern at the point where the word
3164 ends. If we succeed, control just continues along the
3165 regex; if we fail we return here to try the next accepting
3166 state
3167 */
a3621e74 3168
166ba7cd
DM
3169 {
3170 U32 best = 0;
3171 U32 cur;
3172 for( cur = 1 ; cur <= ST.accepted ; cur++ ) {
3173 DEBUG_TRIE_EXECUTE_r(
f2278c82 3174 PerlIO_printf( Perl_debug_log,
166ba7cd 3175 "%*s %sgot %"IVdf" (%d) as best, looking at %"IVdf" (%d)%s\n",
5bc10b2c 3176 REPORT_CODE_OFF + depth * 2, "", PL_colors[4],
166ba7cd
DM
3177 (IV)best, ST.accept_buff[ best ].wordnum, (IV)cur,
3178 ST.accept_buff[ cur ].wordnum, PL_colors[5] );
3179 );
3180
3181 if (ST.accept_buff[cur].wordnum <
3182 ST.accept_buff[best].wordnum)
3183 best = cur;
a3621e74 3184 }
166ba7cd
DM
3185
3186 DEBUG_EXECUTE_r({
2b8b4781 3187 AV *const trie_words
502c6561 3188 = MUTABLE_AV(rexi->data->data[ARG(ST.me)+TRIE_WORDS_OFFSET]);
2b8b4781 3189 SV ** const tmp = av_fetch( trie_words,
5c9f2f80 3190 ST.accept_buff[ best ].wordnum - 1, 0 );
7f69552c 3191 regnode *nextop=(!ST.jump || !ST.jump[ST.accept_buff[best].wordnum]) ?
265c4333 3192 ST.B :
7f69552c 3193 ST.me + ST.jump[ST.accept_buff[best].wordnum];
de734bd5
A
3194 SV *sv= tmp ? sv_newmortal() : NULL;
3195
265c4333
YO
3196 PerlIO_printf( Perl_debug_log,
3197 "%*s %strying alternation #%d <%s> at node #%d %s\n",
5bc10b2c 3198 REPORT_CODE_OFF+depth*2, "", PL_colors[4],
166ba7cd 3199 ST.accept_buff[best].wordnum,
de734bd5
A
3200 tmp ? pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 0,
3201 PL_colors[0], PL_colors[1],
3202 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)
3203 ) : "not compiled under -Dr",
265c4333 3204 REG_NODE_NUM(nextop),
166ba7cd
DM
3205 PL_colors[5] );
3206 });
3207
3208 if ( best<ST.accepted ) {
3209 reg_trie_accepted tmp = ST.accept_buff[ best ];
3210 ST.accept_buff[ best ] = ST.accept_buff[ ST.accepted ];
3211 ST.accept_buff[ ST.accepted ] = tmp;
3212 best = ST.accepted;
a3621e74 3213 }
166ba7cd 3214 PL_reginput = (char *)ST.accept_buff[ best ].endpos;
7f69552c 3215 if ( !ST.jump || !ST.jump[ST.accept_buff[best].wordnum]) {
5d458dd8 3216 scan = ST.B;
786e8c11 3217 } else {
5d458dd8 3218 scan = ST.me + ST.jump[ST.accept_buff[best].wordnum];
5d458dd8 3219 }
6b173516 3220 PUSH_YES_STATE_GOTO(TRIE_next, scan);
786e8c11 3221 /* NOTREACHED */
166ba7cd 3222 }
166ba7cd 3223 /* NOTREACHED */
5d458dd8 3224 case TRIE_next:
6962fb1a
YO
3225 /* we dont want to throw this away, see bug 57042*/
3226 if (oreplsv != GvSV(PL_replgv))
3227 sv_setsv(oreplsv, GvSV(PL_replgv));
5d458dd8
YO
3228 FREETMPS;
3229 LEAVE;
3230 sayYES;
166ba7cd
DM
3231#undef ST
3232
95b24440
DM
3233 case EXACT: {
3234 char *s = STRING(scan);
24d3c4a9 3235 ln = STR_LEN(scan);
eb160463 3236 if (do_utf8 != UTF) {
bc517b45 3237 /* The target and the pattern have differing utf8ness. */
1aa99e6b 3238 char *l = locinput;
24d3c4a9 3239 const char * const e = s + ln;
a72c7584 3240
5ff6fc6d
JH
3241 if (do_utf8) {
3242 /* The target is utf8, the pattern is not utf8. */
1aa99e6b 3243 while (s < e) {
a3b680e6 3244 STRLEN ulen;
1aa99e6b 3245 if (l >= PL_regeol)
5ff6fc6d
JH
3246 sayNO;
3247 if (NATIVE_TO_UNI(*(U8*)s) !=
89ebb4a3 3248 utf8n_to_uvuni((U8*)l, UTF8_MAXBYTES, &ulen,
041457d9 3249 uniflags))
5ff6fc6d 3250 sayNO;
bc517b45 3251 l += ulen;
5ff6fc6d 3252 s ++;
1aa99e6b 3253 }
5ff6fc6d
JH
3254 }
3255 else {
3256 /* The target is not utf8, the pattern is utf8. */
1aa99e6b 3257 while (s < e) {
a3b680e6 3258 STRLEN ulen;
1aa99e6b
IH
3259 if (l >= PL_regeol)
3260 sayNO;
5ff6fc6d 3261 if (NATIVE_TO_UNI(*((U8*)l)) !=
89ebb4a3 3262 utf8n_to_uvuni((U8*)s, UTF8_MAXBYTES, &ulen,
041457d9 3263 uniflags))
1aa99e6b 3264 sayNO;
bc517b45 3265 s += ulen;
a72c7584 3266 l ++;
1aa99e6b 3267 }
5ff6fc6d 3268 }
1aa99e6b
IH
3269 locinput = l;
3270 nextchr = UCHARAT(locinput);
3271 break;
3272 }
bc517b45 3273 /* The target and the pattern have the same utf8ness. */
d6a28714
JH
3274 /* Inline the first character, for speed. */
3275 if (UCHARAT(s) != nextchr)
3276 sayNO;
24d3c4a9 3277 if (PL_regeol - locinput < ln)
d6a28714 3278 sayNO;
24d3c4a9 3279 if (ln > 1 && memNE(s, locinput, ln))
d6a28714 3280 sayNO;
24d3c4a9 3281 locinput += ln;
d6a28714
JH
3282 nextchr = UCHARAT(locinput);
3283 break;
95b24440 3284 }
d6a28714 3285 case EXACTFL:
b8c5462f
JH
3286 PL_reg_flags |= RF_tainted;
3287 /* FALL THROUGH */
95b24440 3288 case EXACTF: {
be8e71aa 3289 char * const s = STRING(scan);
24d3c4a9 3290 ln = STR_LEN(scan);
d6a28714 3291
d07ddd77
JH
3292 if (do_utf8 || UTF) {
3293 /* Either target or the pattern are utf8. */
be8e71aa 3294 const char * const l = locinput;
d07ddd77 3295 char *e = PL_regeol;
bc517b45 3296
24d3c4a9 3297 if (ibcmp_utf8(s, 0, ln, (bool)UTF,
1feea2c7 3298 l, &e, 0, do_utf8)) {
5486206c
JH
3299 /* One more case for the sharp s:
3300 * pack("U0U*", 0xDF) =~ /ss/i,
3301 * the 0xC3 0x9F are the UTF-8
3302 * byte sequence for the U+00DF. */
e1d1eefb 3303
5486206c 3304 if (!(do_utf8 &&
e1d1eefb 3305 toLOWER(s[0]) == 's' &&
24d3c4a9 3306 ln >= 2 &&
5486206c
JH
3307 toLOWER(s[1]) == 's' &&
3308 (U8)l[0] == 0xC3 &&
3309 e - l >= 2 &&
3310 (U8)l[1] == 0x9F))
3311 sayNO;
3312 }
d07ddd77
JH
3313 locinput = e;
3314 nextchr = UCHARAT(locinput);
3315 break;
a0ed51b3 3316 }
d6a28714 3317
bc517b45
JH
3318 /* Neither the target and the pattern are utf8. */
3319
d6a28714
JH
3320 /* Inline the first character, for speed. */
3321 if (UCHARAT(s) != nextchr &&
3322 UCHARAT(s) != ((OP(scan) == EXACTF)
3323 ? PL_fold : PL_fold_locale)[nextchr])
a0ed51b3 3324 sayNO;
24d3c4a9 3325 if (PL_regeol - locinput < ln)
b8c5462f 3326 sayNO;
24d3c4a9
DM
3327 if (ln > 1 && (OP(scan) == EXACTF
3328 ? ibcmp(s, locinput, ln)
3329 : ibcmp_locale(s, locinput, ln)))
4633a7c4 3330 sayNO;
24d3c4a9 3331 locinput += ln;
d6a28714 3332 nextchr = UCHARAT(locinput);
a0d0e21e 3333 break;
95b24440 3334 }
d6a28714 3335 case ANYOF:
ffc61ed2 3336 if (do_utf8) {
9e55ce06
JH
3337 STRLEN inclasslen = PL_regeol - locinput;
3338
32fc9b6a 3339 if (!reginclass(rex, scan, (U8*)locinput, &inclasslen, do_utf8))
262b90c4 3340 goto anyof_fail;
ffc61ed2
JH
3341 if (locinput >= PL_regeol)
3342 sayNO;
0f0076b4 3343 locinput += inclasslen ? inclasslen : UTF8SKIP(locinput);
b8c5462f 3344 nextchr = UCHARAT(locinput);
e0f9d4a8 3345 break;
ffc61ed2
JH
3346 }
3347 else {
3348 if (nextchr < 0)
3349 nextchr = UCHARAT(locinput);
32fc9b6a 3350 if (!REGINCLASS(rex, scan, (U8*)locinput))
262b90c4 3351 goto anyof_fail;
ffc61ed2
JH
3352 if (!nextchr && locinput >= PL_regeol)
3353 sayNO;
3354 nextchr = UCHARAT(++locinput);
e0f9d4a8
JH
3355 break;
3356 }
262b90c4 3357 anyof_fail:
e0f9d4a8
JH
3358 /* If we might have the case of the German sharp s
3359 * in a casefolding Unicode character class. */
3360
ebc501f0
JH
3361 if (ANYOF_FOLD_SHARP_S(scan, locinput, PL_regeol)) {
3362 locinput += SHARP_S_SKIP;
e0f9d4a8 3363 nextchr = UCHARAT(locinput);
ffc61ed2 3364 }
e0f9d4a8
JH
3365 else
3366 sayNO;
b8c5462f 3367 break;
d6a28714 3368 case ALNUML:
b8c5462f
JH
3369 PL_reg_flags |= RF_tainted;
3370 /* FALL THROUGH */
d6a28714 3371 case ALNUM:
b8c5462f 3372 if (!nextchr)
4633a7c4 3373 sayNO;
ffc61ed2 3374 if (do_utf8) {
1a4fad37 3375 LOAD_UTF8_CHARCLASS_ALNUM();
ffc61ed2 3376 if (!(OP(scan) == ALNUM
bb7a0f54 3377 ? (bool)swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
d6a28714 3378 : isALNUM_LC_utf8((U8*)locinput)))
b8c5462f
JH
3379 {
3380 sayNO;
a0ed51b3 3381 }