This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
make intuit_start() handle mixed utf8-ness
[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
7e0d5ad7
KW
40/* At least one required character in the target string is expressible only in
41 * UTF-8. */
991fc03a 42static const char* const non_utf8_target_but_utf8_required
7e0d5ad7
KW
43 = "Can't match, because target string needs to be in UTF-8\n";
44
6b54ddc5
YO
45#define NON_UTF8_TARGET_BUT_UTF8_REQUIRED(target) STMT_START { \
46 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s", non_utf8_target_but_utf8_required));\
47 goto target; \
48} STMT_END
49
a687059c 50/*
e50aee73 51 * pregcomp and pregexec -- regsub and regerror are not used in perl
a687059c
LW
52 *
53 * Copyright (c) 1986 by University of Toronto.
54 * Written by Henry Spencer. Not derived from licensed software.
55 *
56 * Permission is granted to anyone to use this software for any
57 * purpose on any computer system, and to redistribute it freely,
58 * subject to the following restrictions:
59 *
60 * 1. The author is not responsible for the consequences of use of
61 * this software, no matter how awful, even if they arise
62 * from defects in it.
63 *
64 * 2. The origin of this software must not be misrepresented, either
65 * by explicit claim or by omission.
66 *
67 * 3. Altered versions must be plainly marked as such, and must not
68 * be misrepresented as being the original software.
69 *
70 **** Alterations to Henry's code are...
71 ****
4bb101f2 72 **** Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
1129b882
NC
73 **** 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
74 **** by Larry Wall and others
a687059c 75 ****
9ef589d8
LW
76 **** You may distribute under the terms of either the GNU General Public
77 **** License or the Artistic License, as specified in the README file.
a687059c
LW
78 *
79 * Beware that some of this code is subtly aware of the way operator
80 * precedence is structured in regular expressions. Serious changes in
81 * regular-expression syntax might require a total rethink.
82 */
83#include "EXTERN.h"
864dbfa3 84#define PERL_IN_REGEXEC_C
a687059c 85#include "perl.h"
0f5d15d6 86
54df2634
NC
87#ifdef PERL_IN_XSUB_RE
88# include "re_comp.h"
89#else
90# include "regcomp.h"
91#endif
a687059c 92
81e983c1 93#include "inline_invlist.c"
1b0f46bf 94#include "unicode_constants.h"
81e983c1 95
c74f6de9
KW
96#define HAS_NONLATIN1_FOLD_CLOSURE(i) _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)
97
a687059c
LW
98#ifndef STATIC
99#define STATIC static
100#endif
101
e0193e47 102/* Valid for non-utf8 strings: avoids the reginclass
7e2509c1
KW
103 * call if there are no complications: i.e., if everything matchable is
104 * straight forward in the bitmap */
635cd5d4 105#define REGINCLASS(prog,p,c) (ANYOF_FLAGS(p) ? reginclass(prog,p,c,0) \
af364d03 106 : ANYOF_BITMAP_TEST(p,*(c)))
7d3e948e 107
c277df42
IZ
108/*
109 * Forwards.
110 */
111
f2ed9b32 112#define CHR_SVLEN(sv) (utf8_target ? sv_len_utf8(sv) : SvCUR(sv))
ba44c216 113#define CHR_DIST(a,b) (reginfo->is_utf8_target ? utf8_distance(a,b) : a - b)
a0ed51b3 114
3dab1dad 115#define HOPc(pos,off) \
ba44c216 116 (char *)(reginfo->is_utf8_target \
220db18a 117 ? reghop3((U8*)pos, off, \
9d9163fb 118 (U8*)(off >= 0 ? reginfo->strend : reginfo->strbeg)) \
3dab1dad
YO
119 : (U8*)(pos + off))
120#define HOPBACKc(pos, off) \
ba44c216 121 (char*)(reginfo->is_utf8_target \
9d9163fb
DM
122 ? reghopmaybe3((U8*)pos, -off, (U8*)(reginfo->strbeg)) \
123 : (pos - off >= reginfo->strbeg) \
8e11feef 124 ? (U8*)pos - off \
3dab1dad 125 : NULL)
efb30f32 126
ba44c216 127#define HOP3(pos,off,lim) (reginfo->is_utf8_target ? reghop3((U8*)(pos), off, (U8*)(lim)) : (U8*)(pos + off))
1aa99e6b 128#define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
1aa99e6b 129
7016d6eb
DM
130
131#define NEXTCHR_EOS -10 /* nextchr has fallen off the end */
132#define NEXTCHR_IS_EOS (nextchr < 0)
133
134#define SET_nextchr \
220db18a 135 nextchr = ((locinput < reginfo->strend) ? UCHARAT(locinput) : NEXTCHR_EOS)
7016d6eb
DM
136
137#define SET_locinput(p) \
138 locinput = (p); \
139 SET_nextchr
140
141
c7304fe2
KW
142#define LOAD_UTF8_CHARCLASS(swash_ptr, property_name) STMT_START { \
143 if (!swash_ptr) { \
144 U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST; \
c7304fe2
KW
145 swash_ptr = _core_swash_init("utf8", property_name, &PL_sv_undef, \
146 1, 0, NULL, &flags); \
147 assert(swash_ptr); \
148 } \
149 } STMT_END
150
151/* If in debug mode, we test that a known character properly matches */
152#ifdef DEBUGGING
153# define LOAD_UTF8_CHARCLASS_DEBUG_TEST(swash_ptr, \
154 property_name, \
155 utf8_char_in_property) \
156 LOAD_UTF8_CHARCLASS(swash_ptr, property_name); \
157 assert(swash_fetch(swash_ptr, (U8 *) utf8_char_in_property, TRUE));
158#else
159# define LOAD_UTF8_CHARCLASS_DEBUG_TEST(swash_ptr, \
160 property_name, \
161 utf8_char_in_property) \
162 LOAD_UTF8_CHARCLASS(swash_ptr, property_name)
163#endif
d1eb3177 164
c7304fe2
KW
165#define LOAD_UTF8_CHARCLASS_ALNUM() LOAD_UTF8_CHARCLASS_DEBUG_TEST( \
166 PL_utf8_swash_ptrs[_CC_WORDCHAR], \
167 swash_property_names[_CC_WORDCHAR], \
168 GREEK_SMALL_LETTER_IOTA_UTF8)
169
170#define LOAD_UTF8_CHARCLASS_GCB() /* Grapheme cluster boundaries */ \
171 STMT_START { \
172 LOAD_UTF8_CHARCLASS_DEBUG_TEST(PL_utf8_X_regular_begin, \
173 "_X_regular_begin", \
174 GREEK_SMALL_LETTER_IOTA_UTF8); \
175 LOAD_UTF8_CHARCLASS_DEBUG_TEST(PL_utf8_X_extend, \
176 "_X_extend", \
177 COMBINING_GRAVE_ACCENT_UTF8); \
178 } STMT_END
d1eb3177 179
c7304fe2 180#define PLACEHOLDER /* Something for the preprocessor to grab onto */
3dab1dad
YO
181/* TODO: Combine JUMPABLE and HAS_TEXT to cache OP(rn) */
182
5f80c4cf 183/* for use after a quantifier and before an EXACT-like node -- japhy */
c35dcbe2
YO
184/* it would be nice to rework regcomp.sym to generate this stuff. sigh
185 *
186 * NOTE that *nothing* that affects backtracking should be in here, specifically
187 * VERBS must NOT be included. JUMPABLE is used to determine if we can ignore a
188 * node that is in between two EXACT like nodes when ascertaining what the required
189 * "follow" character is. This should probably be moved to regex compile time
190 * although it may be done at run time beause of the REF possibility - more
191 * investigation required. -- demerphq
192*/
3e901dc0
YO
193#define JUMPABLE(rn) ( \
194 OP(rn) == OPEN || \
195 (OP(rn) == CLOSE && (!cur_eval || cur_eval->u.eval.close_paren != ARG(rn))) || \
196 OP(rn) == EVAL || \
cca55fe3
JP
197 OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
198 OP(rn) == PLUS || OP(rn) == MINMOD || \
d1c771f5 199 OP(rn) == KEEPS || \
3dab1dad 200 (PL_regkind[OP(rn)] == CURLY && ARG1(rn) > 0) \
e2d8ce26 201)
ee9b8eae 202#define IS_EXACT(rn) (PL_regkind[OP(rn)] == EXACT)
e2d8ce26 203
ee9b8eae
YO
204#define HAS_TEXT(rn) ( IS_EXACT(rn) || PL_regkind[OP(rn)] == REF )
205
206#if 0
207/* Currently these are only used when PL_regkind[OP(rn)] == EXACT so
208 we don't need this definition. */
209#define IS_TEXT(rn) ( OP(rn)==EXACT || OP(rn)==REF || OP(rn)==NREF )
fab2782b 210#define IS_TEXTF(rn) ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn)==EXACTFA || OP(rn)==EXACTF || OP(rn)==REFF || OP(rn)==NREFF )
ee9b8eae
YO
211#define IS_TEXTFL(rn) ( OP(rn)==EXACTFL || OP(rn)==REFFL || OP(rn)==NREFFL )
212
213#else
214/* ... so we use this as its faster. */
215#define IS_TEXT(rn) ( OP(rn)==EXACT )
fab2782b 216#define IS_TEXTFU(rn) ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn) == EXACTFA)
ee9b8eae
YO
217#define IS_TEXTF(rn) ( OP(rn)==EXACTF )
218#define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
219
220#endif
e2d8ce26 221
a84d97b6
HS
222/*
223 Search for mandatory following text node; for lookahead, the text must
224 follow but for lookbehind (rn->flags != 0) we skip to the next step.
225*/
cca55fe3 226#define FIND_NEXT_IMPT(rn) STMT_START { \
3dab1dad
YO
227 while (JUMPABLE(rn)) { \
228 const OPCODE type = OP(rn); \
229 if (type == SUSPEND || PL_regkind[type] == CURLY) \
e2d8ce26 230 rn = NEXTOPER(NEXTOPER(rn)); \
3dab1dad 231 else if (type == PLUS) \
cca55fe3 232 rn = NEXTOPER(rn); \
3dab1dad 233 else if (type == IFMATCH) \
a84d97b6 234 rn = (rn->flags == 0) ? NEXTOPER(NEXTOPER(rn)) : rn + ARG(rn); \
e2d8ce26 235 else rn += NEXT_OFF(rn); \
3dab1dad 236 } \
5f80c4cf 237} STMT_END
74750237 238
22913b96
KW
239/* These constants are for finding GCB=LV and GCB=LVT in the CLUMP regnode.
240 * These are for the pre-composed Hangul syllables, which are all in a
241 * contiguous block and arranged there in such a way so as to facilitate
242 * alorithmic determination of their characteristics. As such, they don't need
243 * a swash, but can be determined by simple arithmetic. Almost all are
244 * GCB=LVT, but every 28th one is a GCB=LV */
245#define SBASE 0xAC00 /* Start of block */
246#define SCount 11172 /* Length of block */
247#define TCount 28
c476f425 248
006f26b2
DM
249#define SLAB_FIRST(s) (&(s)->states[0])
250#define SLAB_LAST(s) (&(s)->states[PERL_REGMATCH_SLAB_SLOTS-1])
251
a75351a1 252static void S_setup_eval_state(pTHX_ regmatch_info *const reginfo);
bf2039a9 253static void S_cleanup_regmatch_info_aux(pTHX_ void *arg);
bf2039a9 254static regmatch_state * S_push_slab(pTHX);
51371543 255
87c0511b 256#define REGCP_PAREN_ELEMS 3
f067efbf 257#define REGCP_OTHER_ELEMS 3
e0fa7e2b 258#define REGCP_FRAME_ELEMS 1
620d5b66
NC
259/* REGCP_FRAME_ELEMS are not part of the REGCP_OTHER_ELEMS and
260 * are needed for the regexp context stack bookkeeping. */
261
76e3520e 262STATIC CHECKPOINT
92da3157 263S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen)
a0d0e21e 264{
97aff369 265 dVAR;
a3b680e6 266 const int retval = PL_savestack_ix;
92da3157
DM
267 const int paren_elems_to_push =
268 (maxopenparen - parenfloor) * REGCP_PAREN_ELEMS;
e0fa7e2b
NC
269 const UV total_elems = paren_elems_to_push + REGCP_OTHER_ELEMS;
270 const UV elems_shifted = total_elems << SAVE_TIGHT_SHIFT;
87c0511b 271 I32 p;
40a82448 272 GET_RE_DEBUG_FLAGS_DECL;
a0d0e21e 273
b93070ed
DM
274 PERL_ARGS_ASSERT_REGCPPUSH;
275
e49a9654 276 if (paren_elems_to_push < 0)
5637ef5b
NC
277 Perl_croak(aTHX_ "panic: paren_elems_to_push, %i < 0",
278 paren_elems_to_push);
e49a9654 279
e0fa7e2b
NC
280 if ((elems_shifted >> SAVE_TIGHT_SHIFT) != total_elems)
281 Perl_croak(aTHX_ "panic: paren_elems_to_push offset %"UVuf
5df417d0 282 " out of range (%lu-%ld)",
92da3157
DM
283 total_elems,
284 (unsigned long)maxopenparen,
285 (long)parenfloor);
e0fa7e2b 286
620d5b66 287 SSGROW(total_elems + REGCP_FRAME_ELEMS);
7f69552c 288
495f47a5 289 DEBUG_BUFFERS_r(
92da3157 290 if ((int)maxopenparen > (int)parenfloor)
495f47a5
DM
291 PerlIO_printf(Perl_debug_log,
292 "rex=0x%"UVxf" offs=0x%"UVxf": saving capture indices:\n",
293 PTR2UV(rex),
294 PTR2UV(rex->offs)
295 );
296 );
92da3157 297 for (p = parenfloor+1; p <= (I32)maxopenparen; p++) {
b1ce53c5 298/* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
b93070ed
DM
299 SSPUSHINT(rex->offs[p].end);
300 SSPUSHINT(rex->offs[p].start);
1ca2007e 301 SSPUSHINT(rex->offs[p].start_tmp);
e7707071 302 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
495f47a5
DM
303 " \\%"UVuf": %"IVdf"(%"IVdf")..%"IVdf"\n",
304 (UV)p,
305 (IV)rex->offs[p].start,
306 (IV)rex->offs[p].start_tmp,
307 (IV)rex->offs[p].end
40a82448 308 ));
a0d0e21e 309 }
b1ce53c5 310/* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
92da3157 311 SSPUSHINT(maxopenparen);
b93070ed
DM
312 SSPUSHINT(rex->lastparen);
313 SSPUSHINT(rex->lastcloseparen);
e0fa7e2b 314 SSPUSHUV(SAVEt_REGCONTEXT | elems_shifted); /* Magic cookie. */
41123dfd 315
a0d0e21e
LW
316 return retval;
317}
318
c277df42 319/* These are needed since we do not localize EVAL nodes: */
ab3bbdeb
YO
320#define REGCP_SET(cp) \
321 DEBUG_STATE_r( \
ab3bbdeb 322 PerlIO_printf(Perl_debug_log, \
e4f74956 323 " Setting an EVAL scope, savestack=%"IVdf"\n", \
ab3bbdeb
YO
324 (IV)PL_savestack_ix)); \
325 cp = PL_savestack_ix
c3464db5 326
ab3bbdeb 327#define REGCP_UNWIND(cp) \
e4f74956 328 DEBUG_STATE_r( \
ab3bbdeb 329 if (cp != PL_savestack_ix) \
e4f74956
YO
330 PerlIO_printf(Perl_debug_log, \
331 " Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
ab3bbdeb
YO
332 (IV)(cp), (IV)PL_savestack_ix)); \
333 regcpblow(cp)
c277df42 334
a8d1f4b4
DM
335#define UNWIND_PAREN(lp, lcp) \
336 for (n = rex->lastparen; n > lp; n--) \
337 rex->offs[n].end = -1; \
338 rex->lastparen = n; \
339 rex->lastcloseparen = lcp;
340
341
f067efbf 342STATIC void
92da3157 343S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p)
a0d0e21e 344{
97aff369 345 dVAR;
e0fa7e2b 346 UV i;
87c0511b 347 U32 paren;
a3621e74
YO
348 GET_RE_DEBUG_FLAGS_DECL;
349
7918f24d
NC
350 PERL_ARGS_ASSERT_REGCPPOP;
351
b1ce53c5 352 /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
c6bf6a65 353 i = SSPOPUV;
e0fa7e2b
NC
354 assert((i & SAVE_MASK) == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
355 i >>= SAVE_TIGHT_SHIFT; /* Parentheses elements to pop. */
b93070ed
DM
356 rex->lastcloseparen = SSPOPINT;
357 rex->lastparen = SSPOPINT;
92da3157 358 *maxopenparen_p = SSPOPINT;
b1ce53c5 359
620d5b66 360 i -= REGCP_OTHER_ELEMS;
b1ce53c5 361 /* Now restore the parentheses context. */
495f47a5
DM
362 DEBUG_BUFFERS_r(
363 if (i || rex->lastparen + 1 <= rex->nparens)
364 PerlIO_printf(Perl_debug_log,
365 "rex=0x%"UVxf" offs=0x%"UVxf": restoring capture indices to:\n",
366 PTR2UV(rex),
367 PTR2UV(rex->offs)
368 );
369 );
92da3157 370 paren = *maxopenparen_p;
620d5b66 371 for ( ; i > 0; i -= REGCP_PAREN_ELEMS) {
1df70142 372 I32 tmps;
1ca2007e 373 rex->offs[paren].start_tmp = SSPOPINT;
b93070ed 374 rex->offs[paren].start = SSPOPINT;
cf93c79d 375 tmps = SSPOPINT;
b93070ed
DM
376 if (paren <= rex->lastparen)
377 rex->offs[paren].end = tmps;
495f47a5
DM
378 DEBUG_BUFFERS_r( PerlIO_printf(Perl_debug_log,
379 " \\%"UVuf": %"IVdf"(%"IVdf")..%"IVdf"%s\n",
380 (UV)paren,
381 (IV)rex->offs[paren].start,
382 (IV)rex->offs[paren].start_tmp,
383 (IV)rex->offs[paren].end,
384 (paren > rex->lastparen ? "(skipped)" : ""));
c277df42 385 );
87c0511b 386 paren--;
a0d0e21e 387 }
daf18116 388#if 1
dafc8851
JH
389 /* It would seem that the similar code in regtry()
390 * already takes care of this, and in fact it is in
391 * a better location to since this code can #if 0-ed out
392 * but the code in regtry() is needed or otherwise tests
393 * requiring null fields (pat.t#187 and split.t#{13,14}
daf18116
JH
394 * (as of patchlevel 7877) will fail. Then again,
395 * this code seems to be necessary or otherwise
225593e1
DM
396 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
397 * --jhi updated by dapm */
b93070ed 398 for (i = rex->lastparen + 1; i <= rex->nparens; i++) {
92da3157 399 if (i > *maxopenparen_p)
b93070ed
DM
400 rex->offs[i].start = -1;
401 rex->offs[i].end = -1;
495f47a5
DM
402 DEBUG_BUFFERS_r( PerlIO_printf(Perl_debug_log,
403 " \\%"UVuf": %s ..-1 undeffing\n",
404 (UV)i,
92da3157 405 (i > *maxopenparen_p) ? "-1" : " "
495f47a5 406 ));
a0d0e21e 407 }
dafc8851 408#endif
a0d0e21e
LW
409}
410
74088413
DM
411/* restore the parens and associated vars at savestack position ix,
412 * but without popping the stack */
413
414STATIC void
92da3157 415S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p)
74088413
DM
416{
417 I32 tmpix = PL_savestack_ix;
418 PL_savestack_ix = ix;
92da3157 419 regcppop(rex, maxopenparen_p);
74088413
DM
420 PL_savestack_ix = tmpix;
421}
422
02db2b7b 423#define regcpblow(cp) LEAVE_SCOPE(cp) /* Ignores regcppush()ed data. */
a0d0e21e 424
31c7f561
KW
425STATIC bool
426S_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
427{
428 /* Returns a boolean as to whether or not 'character' is a member of the
429 * Posix character class given by 'classnum' that should be equivalent to a
430 * value in the typedef '_char_class_number'.
431 *
432 * Ideally this could be replaced by a just an array of function pointers
433 * to the C library functions that implement the macros this calls.
434 * However, to compile, the precise function signatures are required, and
435 * these may vary from platform to to platform. To avoid having to figure
436 * out what those all are on each platform, I (khw) am using this method,
7aee35ff
KW
437 * which adds an extra layer of function call overhead (unless the C
438 * optimizer strips it away). But we don't particularly care about
439 * performance with locales anyway. */
31c7f561
KW
440
441 switch ((_char_class_number) classnum) {
15861f94 442 case _CC_ENUM_ALPHANUMERIC: return isALPHANUMERIC_LC(character);
31c7f561 443 case _CC_ENUM_ALPHA: return isALPHA_LC(character);
e8d596e0
KW
444 case _CC_ENUM_ASCII: return isASCII_LC(character);
445 case _CC_ENUM_BLANK: return isBLANK_LC(character);
b0d691b2
KW
446 case _CC_ENUM_CASED: return isLOWER_LC(character)
447 || isUPPER_LC(character);
e8d596e0 448 case _CC_ENUM_CNTRL: return isCNTRL_LC(character);
31c7f561
KW
449 case _CC_ENUM_DIGIT: return isDIGIT_LC(character);
450 case _CC_ENUM_GRAPH: return isGRAPH_LC(character);
451 case _CC_ENUM_LOWER: return isLOWER_LC(character);
452 case _CC_ENUM_PRINT: return isPRINT_LC(character);
e8d596e0 453 case _CC_ENUM_PSXSPC: return isPSXSPC_LC(character);
31c7f561 454 case _CC_ENUM_PUNCT: return isPUNCT_LC(character);
e8d596e0 455 case _CC_ENUM_SPACE: return isSPACE_LC(character);
31c7f561
KW
456 case _CC_ENUM_UPPER: return isUPPER_LC(character);
457 case _CC_ENUM_WORDCHAR: return isWORDCHAR_LC(character);
31c7f561 458 case _CC_ENUM_XDIGIT: return isXDIGIT_LC(character);
31c7f561
KW
459 default: /* VERTSPACE should never occur in locales */
460 Perl_croak(aTHX_ "panic: isFOO_lc() has an unexpected character class '%d'", classnum);
461 }
462
463 assert(0); /* NOTREACHED */
464 return FALSE;
465}
466
3018b823
KW
467STATIC bool
468S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character)
469{
470 /* Returns a boolean as to whether or not the (well-formed) UTF-8-encoded
471 * 'character' is a member of the Posix character class given by 'classnum'
472 * that should be equivalent to a value in the typedef
473 * '_char_class_number'.
474 *
475 * This just calls isFOO_lc on the code point for the character if it is in
476 * the range 0-255. Outside that range, all characters avoid Unicode
477 * rules, ignoring any locale. So use the Unicode function if this class
478 * requires a swash, and use the Unicode macro otherwise. */
479
480 PERL_ARGS_ASSERT_ISFOO_UTF8_LC;
481
482 if (UTF8_IS_INVARIANT(*character)) {
483 return isFOO_lc(classnum, *character);
484 }
485 else if (UTF8_IS_DOWNGRADEABLE_START(*character)) {
486 return isFOO_lc(classnum,
487 TWO_BYTE_UTF8_TO_UNI(*character, *(character + 1)));
488 }
489
490 if (classnum < _FIRST_NON_SWASH_CC) {
491
492 /* Initialize the swash unless done already */
493 if (! PL_utf8_swash_ptrs[classnum]) {
494 U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
495 PL_utf8_swash_ptrs[classnum] = _core_swash_init("utf8",
496 swash_property_names[classnum], &PL_sv_undef, 1, 0, NULL, &flags);
497 }
498
92a2046b
KW
499 return cBOOL(swash_fetch(PL_utf8_swash_ptrs[classnum], (U8 *)
500 character,
501 TRUE /* is UTF */ ));
3018b823
KW
502 }
503
504 switch ((_char_class_number) classnum) {
505 case _CC_ENUM_SPACE:
506 case _CC_ENUM_PSXSPC: return is_XPERLSPACE_high(character);
507
508 case _CC_ENUM_BLANK: return is_HORIZWS_high(character);
509 case _CC_ENUM_XDIGIT: return is_XDIGIT_high(character);
510 case _CC_ENUM_VERTSPACE: return is_VERTWS_high(character);
511 default: return 0; /* Things like CNTRL are always
512 below 256 */
513 }
514
515 assert(0); /* NOTREACHED */
516 return FALSE;
517}
518
a687059c 519/*
e50aee73 520 * pregexec and friends
a687059c
LW
521 */
522
76234dfb 523#ifndef PERL_IN_XSUB_RE
a687059c 524/*
c277df42 525 - pregexec - match a regexp against a string
a687059c 526 */
c277df42 527I32
5aaab254 528Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char *strend,
c3464db5 529 char *strbeg, I32 minend, SV *screamer, U32 nosave)
8fd1a950
DM
530/* stringarg: the point in the string at which to begin matching */
531/* strend: pointer to null at end of string */
532/* strbeg: real beginning of string */
533/* minend: end of match must be >= minend bytes after stringarg. */
534/* screamer: SV being matched: only used for utf8 flag, pos() etc; string
535 * itself is accessed via the pointers above */
536/* nosave: For optimizations. */
c277df42 537{
7918f24d
NC
538 PERL_ARGS_ASSERT_PREGEXEC;
539
c277df42 540 return
9041c2e3 541 regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
c277df42
IZ
542 nosave ? 0 : REXEC_COPY_STR);
543}
76234dfb 544#endif
22e551b9 545
9041c2e3 546/*
cad2e5aa
JH
547 * Need to implement the following flags for reg_anch:
548 *
549 * USE_INTUIT_NOML - Useful to call re_intuit_start() first
550 * USE_INTUIT_ML
551 * INTUIT_AUTORITATIVE_NOML - Can trust a positive answer
552 * INTUIT_AUTORITATIVE_ML
553 * INTUIT_ONCE_NOML - Intuit can match in one location only.
554 * INTUIT_ONCE_ML
555 *
556 * Another flag for this function: SECOND_TIME (so that float substrs
557 * with giant delta may be not rechecked).
558 */
559
560/* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
561
3f7c398e 562/* If SCREAM, then SvPVX_const(sv) should be compatible with strpos and strend.
cad2e5aa
JH
563 Otherwise, only SvCUR(sv) is used to get strbeg. */
564
565/* XXXX We assume that strpos is strbeg unless sv. */
566
6eb5f6b9
JH
567/* XXXX Some places assume that there is a fixed substring.
568 An update may be needed if optimizer marks as "INTUITable"
569 RExen without fixed substrings. Similarly, it is assumed that
570 lengths of all the strings are no more than minlen, thus they
571 cannot come from lookahead.
40d049e4
YO
572 (Or minlen should take into account lookahead.)
573 NOTE: Some of this comment is not correct. minlen does now take account
574 of lookahead/behind. Further research is required. -- demerphq
575
576*/
6eb5f6b9 577
2c2d71f5
JH
578/* A failure to find a constant substring means that there is no need to make
579 an expensive call to REx engine, thus we celebrate a failure. Similarly,
d8da0584 580 finding a substring too deep into the string means that fewer calls to
30944b6d
IZ
581 regtry() should be needed.
582
583 REx compiler's optimizer found 4 possible hints:
584 a) Anchored substring;
585 b) Fixed substring;
586 c) Whether we are anchored (beginning-of-line or \G);
486ec47a 587 d) First node (of those at offset 0) which may distinguish positions;
6eb5f6b9 588 We use a)b)d) and multiline-part of c), and try to find a position in the
30944b6d
IZ
589 string which does not contradict any of them.
590 */
2c2d71f5 591
6eb5f6b9
JH
592/* Most of decisions we do here should have been done at compile time.
593 The nodes of the REx which we used for the search should have been
594 deleted from the finite automaton. */
595
52a21eb3
DM
596/* args:
597 * rx: the regex to match against
598 * sv: the SV being matched: only used for utf8 flag; the string
599 * itself is accessed via the pointers below. Note that on
600 * something like an overloaded SV, SvPOK(sv) may be false
601 * and the string pointers may point to something unrelated to
602 * the SV itself.
603 * strbeg: real beginning of string
604 * strpos: the point in the string at which to begin matching
605 * strend: pointer to the byte following the last char of the string
606 * flags currently unused; set to 0
607 * data: currently unused; set to NULL
608 */
609
cad2e5aa 610char *
52a21eb3
DM
611Perl_re_intuit_start(pTHX_
612 REGEXP * const rx,
613 SV *sv,
614 const char * const strbeg,
615 char *strpos,
616 char *strend,
617 const U32 flags,
618 re_scream_pos_data *data)
cad2e5aa 619{
97aff369 620 dVAR;
8d919b0a 621 struct regexp *const prog = ReANY(rx);
eb578fdb 622 I32 start_shift = 0;
cad2e5aa 623 /* Should be nonnegative! */
eb578fdb
KW
624 I32 end_shift = 0;
625 char *s;
626 SV *check;
cad2e5aa 627 char *t;
f2ed9b32 628 const bool utf8_target = (sv && SvUTF8(sv)) ? 1 : 0; /* if no sv we have to assume bytes */
cad2e5aa 629 I32 ml_anch;
eb578fdb 630 char *other_last = NULL; /* other substr checked before this */
bd61b366 631 char *check_at = NULL; /* check substr found at this pos */
d8080198 632 char *checked_upto = NULL; /* how far into the string we have already checked using find_byclass*/
bbe252da 633 const I32 multiline = prog->extflags & RXf_PMf_MULTILINE;
f8fc2ecf 634 RXi_GET_DECL(prog,progi);
02d5137b
DM
635 regmatch_info reginfo_buf; /* create some info to pass to find_byclass */
636 regmatch_info *const reginfo = &reginfo_buf;
30944b6d 637#ifdef DEBUGGING
890ce7af 638 const char * const i_strpos = strpos;
30944b6d 639#endif
a3621e74
YO
640 GET_RE_DEBUG_FLAGS_DECL;
641
7918f24d 642 PERL_ARGS_ASSERT_RE_INTUIT_START;
c33e64f0
FC
643 PERL_UNUSED_ARG(flags);
644 PERL_UNUSED_ARG(data);
7918f24d 645
c344f387
JH
646 /* CHR_DIST() would be more correct here but it makes things slow. */
647 if (prog->minlen > strend - strpos) {
a3621e74 648 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584 649 "String too short... [re_intuit_start]\n"));
cad2e5aa 650 goto fail;
2c2d71f5 651 }
d8da0584 652
6c3fea77 653 reginfo->is_utf8_target = cBOOL(utf8_target);
bf2039a9 654 reginfo->info_aux = NULL;
9d9163fb 655 reginfo->strbeg = strbeg;
220db18a 656 reginfo->strend = strend;
aed7b151 657 reginfo->is_utf8_pat = cBOOL(RX_UTF8(rx));
02d5137b 658 reginfo->intuit = 1;
1cb48e53
DM
659 /* not actually used within intuit, but zero for safety anyway */
660 reginfo->poscache_maxiter = 0;
02d5137b 661
f2ed9b32 662 if (utf8_target) {
33b8afdf
JH
663 if (!prog->check_utf8 && prog->check_substr)
664 to_utf8_substr(prog);
665 check = prog->check_utf8;
666 } else {
7e0d5ad7
KW
667 if (!prog->check_substr && prog->check_utf8) {
668 if (! to_byte_substr(prog)) {
6b54ddc5 669 NON_UTF8_TARGET_BUT_UTF8_REQUIRED(fail);
7e0d5ad7
KW
670 }
671 }
33b8afdf
JH
672 check = prog->check_substr;
673 }
bbe252da
YO
674 if (prog->extflags & RXf_ANCH) { /* Match at beg-of-str or after \n */
675 ml_anch = !( (prog->extflags & RXf_ANCH_SINGLE)
676 || ( (prog->extflags & RXf_ANCH_BOL)
7fba1cd6 677 && !multiline ) ); /* Check after \n? */
cad2e5aa 678
7e25d62c 679 if (!ml_anch) {
bbe252da
YO
680 if ( !(prog->extflags & RXf_ANCH_GPOS) /* Checked by the caller */
681 && !(prog->intflags & PREGf_IMPLICIT) /* not a real BOL */
7e25d62c 682 && (strpos != strbeg)) {
a3621e74 683 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
7e25d62c
JH
684 goto fail;
685 }
d46b78c6
KW
686 if (prog->check_offset_min == prog->check_offset_max
687 && !(prog->extflags & RXf_CANY_SEEN)
688 && ! multiline) /* /m can cause \n's to match that aren't
689 accounted for in the string max length.
690 See [perl #115242] */
691 {
2c2d71f5 692 /* Substring at constant offset from beg-of-str... */
cad2e5aa
JH
693 I32 slen;
694
1aa99e6b 695 s = HOP3c(strpos, prog->check_offset_min, strend);
1de06328 696
653099ff
GS
697 if (SvTAIL(check)) {
698 slen = SvCUR(check); /* >= 1 */
cad2e5aa 699
9041c2e3 700 if ( strend - s > slen || strend - s < slen - 1
2c2d71f5 701 || (strend - s == slen && strend[-1] != '\n')) {
a3621e74 702 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
2c2d71f5 703 goto fail_finish;
cad2e5aa
JH
704 }
705 /* Now should match s[0..slen-2] */
706 slen--;
3f7c398e 707 if (slen && (*SvPVX_const(check) != *s
cad2e5aa 708 || (slen > 1
3f7c398e 709 && memNE(SvPVX_const(check), s, slen)))) {
2c2d71f5 710 report_neq:
a3621e74 711 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
2c2d71f5
JH
712 goto fail_finish;
713 }
cad2e5aa 714 }
3f7c398e 715 else if (*SvPVX_const(check) != *s
653099ff 716 || ((slen = SvCUR(check)) > 1
3f7c398e 717 && memNE(SvPVX_const(check), s, slen)))
2c2d71f5 718 goto report_neq;
c315bfe8 719 check_at = s;
2c2d71f5 720 goto success_at_start;
7e25d62c 721 }
cad2e5aa 722 }
2c2d71f5 723 /* Match is anchored, but substr is not anchored wrt beg-of-str. */
cad2e5aa 724 s = strpos;
2c2d71f5 725 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
1de06328
YO
726 end_shift = prog->check_end_shift;
727
2c2d71f5 728 if (!ml_anch) {
a3b680e6 729 const I32 end = prog->check_offset_max + CHR_SVLEN(check)
653099ff 730 - (SvTAIL(check) != 0);
a3b680e6 731 const I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
2c2d71f5
JH
732
733 if (end_shift < eshift)
734 end_shift = eshift;
735 }
cad2e5aa 736 }
2c2d71f5 737 else { /* Can match at random position */
cad2e5aa
JH
738 ml_anch = 0;
739 s = strpos;
1de06328
YO
740 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
741 end_shift = prog->check_end_shift;
742
743 /* end shift should be non negative here */
cad2e5aa
JH
744 }
745
bcdf7404 746#ifdef QDEBUGGING /* 7/99: reports of failure (with the older version) */
0033605d 747 if (end_shift < 0)
1de06328 748 Perl_croak(aTHX_ "panic: end_shift: %"IVdf" pattern:\n%s\n ",
220fc49f 749 (IV)end_shift, RX_PRECOMP(prog));
2c2d71f5
JH
750#endif
751
2c2d71f5
JH
752 restart:
753 /* Find a possible match in the region s..strend by looking for
754 the "check" substring in the region corrected by start/end_shift. */
1de06328
YO
755
756 {
757 I32 srch_start_shift = start_shift;
758 I32 srch_end_shift = end_shift;
c33e64f0
FC
759 U8* start_point;
760 U8* end_point;
1de06328
YO
761 if (srch_start_shift < 0 && strbeg - s > srch_start_shift) {
762 srch_end_shift -= ((strbeg - s) - srch_start_shift);
763 srch_start_shift = strbeg - s;
764 }
6bda09f9 765 DEBUG_OPTIMISE_MORE_r({
1de06328
YO
766 PerlIO_printf(Perl_debug_log, "Check offset min: %"IVdf" Start shift: %"IVdf" End shift %"IVdf" Real End Shift: %"IVdf"\n",
767 (IV)prog->check_offset_min,
768 (IV)srch_start_shift,
769 (IV)srch_end_shift,
770 (IV)prog->check_end_shift);
771 });
772
bbe252da 773 if (prog->extflags & RXf_CANY_SEEN) {
1de06328
YO
774 start_point= (U8*)(s + srch_start_shift);
775 end_point= (U8*)(strend - srch_end_shift);
776 } else {
777 start_point= HOP3(s, srch_start_shift, srch_start_shift < 0 ? strbeg : strend);
778 end_point= HOP3(strend, -srch_end_shift, strbeg);
779 }
6bda09f9 780 DEBUG_OPTIMISE_MORE_r({
56570a2c 781 PerlIO_printf(Perl_debug_log, "fbm_instr len=%d str=<%.*s>\n",
1de06328 782 (int)(end_point - start_point),
fc8cd66c 783 (int)(end_point - start_point) > 20 ? 20 : (int)(end_point - start_point),
1de06328
YO
784 start_point);
785 });
786
787 s = fbm_instr( start_point, end_point,
7fba1cd6 788 check, multiline ? FBMrf_MULTILINE : 0);
1de06328 789 }
cad2e5aa
JH
790 /* Update the count-of-usability, remove useless subpatterns,
791 unshift s. */
2c2d71f5 792
ab3bbdeb 793 DEBUG_EXECUTE_r({
f2ed9b32 794 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
795 SvPVX_const(check), RE_SV_DUMPLEN(check), 30);
796 PerlIO_printf(Perl_debug_log, "%s %s substr %s%s%s",
2c2d71f5 797 (s ? "Found" : "Did not find"),
f2ed9b32 798 (check == (utf8_target ? prog->anchored_utf8 : prog->anchored_substr)
ab3bbdeb
YO
799 ? "anchored" : "floating"),
800 quoted,
801 RE_SV_TAIL(check),
802 (s ? " at offset " : "...\n") );
803 });
2c2d71f5
JH
804
805 if (!s)
806 goto fail_finish;
2c2d71f5 807 /* Finish the diagnostic message */
a3621e74 808 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
2c2d71f5 809
1de06328
YO
810 /* XXX dmq: first branch is for positive lookbehind...
811 Our check string is offset from the beginning of the pattern.
812 So we need to do any stclass tests offset forward from that
813 point. I think. :-(
814 */
815
816
817
818 check_at=s;
819
820
2c2d71f5
JH
821 /* Got a candidate. Check MBOL anchoring, and the *other* substr.
822 Start with the other substr.
823 XXXX no SCREAM optimization yet - and a very coarse implementation
a0288114 824 XXXX /ttx+/ results in anchored="ttx", floating="x". floating will
2c2d71f5
JH
825 *always* match. Probably should be marked during compile...
826 Probably it is right to do no SCREAM here...
827 */
828
f2ed9b32 829 if (utf8_target ? (prog->float_utf8 && prog->anchored_utf8)
1de06328
YO
830 : (prog->float_substr && prog->anchored_substr))
831 {
30944b6d 832 /* Take into account the "other" substring. */
2c2d71f5
JH
833 /* XXXX May be hopelessly wrong for UTF... */
834 if (!other_last)
6eb5f6b9 835 other_last = strpos;
f2ed9b32 836 if (check == (utf8_target ? prog->float_utf8 : prog->float_substr)) {
30944b6d
IZ
837 do_other_anchored:
838 {
890ce7af
AL
839 char * const last = HOP3c(s, -start_shift, strbeg);
840 char *last1, *last2;
be8e71aa 841 char * const saved_s = s;
33b8afdf 842 SV* must;
2c2d71f5 843
2c2d71f5
JH
844 t = s - prog->check_offset_max;
845 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
f2ed9b32 846 && (!utf8_target
0ce71af7 847 || ((t = (char*)reghopmaybe3((U8*)s, -(prog->check_offset_max), (U8*)strpos))
2c2d71f5 848 && t > strpos)))
6f207bd3 849 NOOP;
2c2d71f5
JH
850 else
851 t = strpos;
1aa99e6b 852 t = HOP3c(t, prog->anchored_offset, strend);
6eb5f6b9
JH
853 if (t < other_last) /* These positions already checked */
854 t = other_last;
1aa99e6b 855 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
2c2d71f5
JH
856 if (last < last1)
857 last1 = last;
1de06328
YO
858 /* XXXX It is not documented what units *_offsets are in.
859 We assume bytes, but this is clearly wrong.
860 Meaning this code needs to be carefully reviewed for errors.
861 dmq.
862 */
863
2c2d71f5 864 /* On end-of-str: see comment below. */
f2ed9b32 865 must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
33b8afdf
JH
866 if (must == &PL_sv_undef) {
867 s = (char*)NULL;
1de06328 868 DEBUG_r(must = prog->anchored_utf8); /* for debug */
33b8afdf
JH
869 }
870 else
871 s = fbm_instr(
872 (unsigned char*)t,
873 HOP3(HOP3(last1, prog->anchored_offset, strend)
874 + SvCUR(must), -(SvTAIL(must)!=0), strbeg),
875 must,
7fba1cd6 876 multiline ? FBMrf_MULTILINE : 0
33b8afdf 877 );
ab3bbdeb 878 DEBUG_EXECUTE_r({
f2ed9b32 879 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
880 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
881 PerlIO_printf(Perl_debug_log, "%s anchored substr %s%s",
2c2d71f5 882 (s ? "Found" : "Contradicts"),
ab3bbdeb
YO
883 quoted, RE_SV_TAIL(must));
884 });
885
886
2c2d71f5
JH
887 if (!s) {
888 if (last1 >= last2) {
a3621e74 889 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5
JH
890 ", giving up...\n"));
891 goto fail_finish;
892 }
a3621e74 893 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5 894 ", trying floating at offset %ld...\n",
be8e71aa 895 (long)(HOP3c(saved_s, 1, strend) - i_strpos)));
1aa99e6b
IH
896 other_last = HOP3c(last1, prog->anchored_offset+1, strend);
897 s = HOP3c(last, 1, strend);
2c2d71f5
JH
898 goto restart;
899 }
900 else {
a3621e74 901 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
30944b6d 902 (long)(s - i_strpos)));
1aa99e6b
IH
903 t = HOP3c(s, -prog->anchored_offset, strbeg);
904 other_last = HOP3c(s, 1, strend);
be8e71aa 905 s = saved_s;
2c2d71f5
JH
906 if (t == strpos)
907 goto try_at_start;
2c2d71f5
JH
908 goto try_at_offset;
909 }
30944b6d 910 }
2c2d71f5
JH
911 }
912 else { /* Take into account the floating substring. */
33b8afdf 913 char *last, *last1;
be8e71aa 914 char * const saved_s = s;
33b8afdf
JH
915 SV* must;
916
917 t = HOP3c(s, -start_shift, strbeg);
918 last1 = last =
919 HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
920 if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
921 last = HOP3c(t, prog->float_max_offset, strend);
922 s = HOP3c(t, prog->float_min_offset, strend);
923 if (s < other_last)
924 s = other_last;
2c2d71f5 925 /* XXXX It is not documented what units *_offsets are in. Assume bytes. */
f2ed9b32 926 must = utf8_target ? prog->float_utf8 : prog->float_substr;
33b8afdf
JH
927 /* fbm_instr() takes into account exact value of end-of-str
928 if the check is SvTAIL(ed). Since false positives are OK,
929 and end-of-str is not later than strend we are OK. */
930 if (must == &PL_sv_undef) {
931 s = (char*)NULL;
1de06328 932 DEBUG_r(must = prog->float_utf8); /* for debug message */
33b8afdf
JH
933 }
934 else
2c2d71f5 935 s = fbm_instr((unsigned char*)s,
33b8afdf
JH
936 (unsigned char*)last + SvCUR(must)
937 - (SvTAIL(must)!=0),
7fba1cd6 938 must, multiline ? FBMrf_MULTILINE : 0);
ab3bbdeb 939 DEBUG_EXECUTE_r({
f2ed9b32 940 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
941 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
942 PerlIO_printf(Perl_debug_log, "%s floating substr %s%s",
33b8afdf 943 (s ? "Found" : "Contradicts"),
ab3bbdeb
YO
944 quoted, RE_SV_TAIL(must));
945 });
33b8afdf
JH
946 if (!s) {
947 if (last1 == last) {
a3621e74 948 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf
JH
949 ", giving up...\n"));
950 goto fail_finish;
2c2d71f5 951 }
a3621e74 952 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf 953 ", trying anchored starting at offset %ld...\n",
be8e71aa 954 (long)(saved_s + 1 - i_strpos)));
33b8afdf
JH
955 other_last = last;
956 s = HOP3c(t, 1, strend);
957 goto restart;
958 }
959 else {
a3621e74 960 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
33b8afdf
JH
961 (long)(s - i_strpos)));
962 other_last = s; /* Fix this later. --Hugo */
be8e71aa 963 s = saved_s;
33b8afdf
JH
964 if (t == strpos)
965 goto try_at_start;
966 goto try_at_offset;
967 }
2c2d71f5 968 }
cad2e5aa 969 }
2c2d71f5 970
1de06328 971
9ef43ace 972 t= (char*)HOP3( s, -prog->check_offset_max, (prog->check_offset_max<0) ? strend : strpos);
1de06328 973
6bda09f9 974 DEBUG_OPTIMISE_MORE_r(
1de06328
YO
975 PerlIO_printf(Perl_debug_log,
976 "Check offset min:%"IVdf" max:%"IVdf" S:%"IVdf" t:%"IVdf" D:%"IVdf" end:%"IVdf"\n",
977 (IV)prog->check_offset_min,
978 (IV)prog->check_offset_max,
979 (IV)(s-strpos),
980 (IV)(t-strpos),
981 (IV)(t-s),
982 (IV)(strend-strpos)
983 )
984 );
985
2c2d71f5 986 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
f2ed9b32 987 && (!utf8_target
9ef43ace 988 || ((t = (char*)reghopmaybe3((U8*)s, -prog->check_offset_max, (U8*) ((prog->check_offset_max<0) ? strend : strpos)))
1de06328
YO
989 && t > strpos)))
990 {
2c2d71f5
JH
991 /* Fixed substring is found far enough so that the match
992 cannot start at strpos. */
993 try_at_offset:
cad2e5aa 994 if (ml_anch && t[-1] != '\n') {
30944b6d
IZ
995 /* Eventually fbm_*() should handle this, but often
996 anchored_offset is not 0, so this check will not be wasted. */
997 /* XXXX In the code below we prefer to look for "^" even in
998 presence of anchored substrings. And we search even
999 beyond the found float position. These pessimizations
1000 are historical artefacts only. */
1001 find_anchor:
2c2d71f5 1002 while (t < strend - prog->minlen) {
cad2e5aa 1003 if (*t == '\n') {
4ee3650e 1004 if (t < check_at - prog->check_offset_min) {
f2ed9b32 1005 if (utf8_target ? prog->anchored_utf8 : prog->anchored_substr) {
4ee3650e
GS
1006 /* Since we moved from the found position,
1007 we definitely contradict the found anchored
30944b6d
IZ
1008 substr. Due to the above check we do not
1009 contradict "check" substr.
1010 Thus we can arrive here only if check substr
1011 is float. Redo checking for "other"=="fixed".
1012 */
9041c2e3 1013 strpos = t + 1;
a3621e74 1014 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
e4584336 1015 PL_colors[0], PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
30944b6d
IZ
1016 goto do_other_anchored;
1017 }
4ee3650e
GS
1018 /* We don't contradict the found floating substring. */
1019 /* XXXX Why not check for STCLASS? */
cad2e5aa 1020 s = t + 1;
a3621e74 1021 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
e4584336 1022 PL_colors[0], PL_colors[1], (long)(s - i_strpos)));
cad2e5aa
JH
1023 goto set_useful;
1024 }
4ee3650e
GS
1025 /* Position contradicts check-string */
1026 /* XXXX probably better to look for check-string
1027 than for "\n", so one should lower the limit for t? */
a3621e74 1028 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
e4584336 1029 PL_colors[0], PL_colors[1], (long)(t + 1 - i_strpos)));
0e41cd87 1030 other_last = strpos = s = t + 1;
cad2e5aa
JH
1031 goto restart;
1032 }
1033 t++;
1034 }
a3621e74 1035 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
e4584336 1036 PL_colors[0], PL_colors[1]));
2c2d71f5 1037 goto fail_finish;
cad2e5aa 1038 }
f5952150 1039 else {
a3621e74 1040 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
e4584336 1041 PL_colors[0], PL_colors[1]));
f5952150 1042 }
cad2e5aa
JH
1043 s = t;
1044 set_useful:
f2ed9b32 1045 ++BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr); /* hooray/5 */
cad2e5aa
JH
1046 }
1047 else {
f5952150 1048 /* The found string does not prohibit matching at strpos,
2c2d71f5 1049 - no optimization of calling REx engine can be performed,
f5952150
GS
1050 unless it was an MBOL and we are not after MBOL,
1051 or a future STCLASS check will fail this. */
2c2d71f5
JH
1052 try_at_start:
1053 /* Even in this situation we may use MBOL flag if strpos is offset
1054 wrt the start of the string. */
52a21eb3 1055 if (ml_anch && (strpos != strbeg) && strpos[-1] != '\n'
d506a20d 1056 /* May be due to an implicit anchor of m{.*foo} */
bbe252da 1057 && !(prog->intflags & PREGf_IMPLICIT))
d506a20d 1058 {
cad2e5aa
JH
1059 t = strpos;
1060 goto find_anchor;
1061 }
a3621e74 1062 DEBUG_EXECUTE_r( if (ml_anch)
f5952150 1063 PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
70685ca0 1064 (long)(strpos - i_strpos), PL_colors[0], PL_colors[1]);
30944b6d 1065 );
2c2d71f5 1066 success_at_start:
bbe252da 1067 if (!(prog->intflags & PREGf_NAUGHTY) /* XXXX If strpos moved? */
f2ed9b32 1068 && (utf8_target ? (
33b8afdf
JH
1069 prog->check_utf8 /* Could be deleted already */
1070 && --BmUSEFUL(prog->check_utf8) < 0
1071 && (prog->check_utf8 == prog->float_utf8)
1072 ) : (
1073 prog->check_substr /* Could be deleted already */
1074 && --BmUSEFUL(prog->check_substr) < 0
1075 && (prog->check_substr == prog->float_substr)
1076 )))
66e933ab 1077 {
cad2e5aa 1078 /* If flags & SOMETHING - do not do it many times on the same match */
a3621e74 1079 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
f2ed9b32
KW
1080 /* XXX Does the destruction order has to change with utf8_target? */
1081 SvREFCNT_dec(utf8_target ? prog->check_utf8 : prog->check_substr);
1082 SvREFCNT_dec(utf8_target ? prog->check_substr : prog->check_utf8);
a0714e2c
SS
1083 prog->check_substr = prog->check_utf8 = NULL; /* disable */
1084 prog->float_substr = prog->float_utf8 = NULL; /* clear */
1085 check = NULL; /* abort */
cad2e5aa 1086 s = strpos;
486ec47a 1087 /* XXXX If the check string was an implicit check MBOL, then we need to unset the relevant flag
c9415951
YO
1088 see http://bugs.activestate.com/show_bug.cgi?id=87173 */
1089 if (prog->intflags & PREGf_IMPLICIT)
1090 prog->extflags &= ~RXf_ANCH_MBOL;
3cf5c195
IZ
1091 /* XXXX This is a remnant of the old implementation. It
1092 looks wasteful, since now INTUIT can use many
6eb5f6b9 1093 other heuristics. */
bbe252da 1094 prog->extflags &= ~RXf_USE_INTUIT;
c9415951 1095 /* XXXX What other flags might need to be cleared in this branch? */
cad2e5aa
JH
1096 }
1097 else
1098 s = strpos;
1099 }
1100
6eb5f6b9
JH
1101 /* Last resort... */
1102 /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
1de06328
YO
1103 /* trie stclasses are too expensive to use here, we are better off to
1104 leave it to regmatch itself */
f8fc2ecf 1105 if (progi->regstclass && PL_regkind[OP(progi->regstclass)]!=TRIE) {
6eb5f6b9
JH
1106 /* minlen == 0 is possible if regstclass is \b or \B,
1107 and the fixed substr is ''$.
1108 Since minlen is already taken into account, s+1 is before strend;
1109 accidentally, minlen >= 1 guaranties no false positives at s + 1
1110 even for \b or \B. But (minlen? 1 : 0) below assumes that
1111 regstclass does not come from lookahead... */
1112 /* If regstclass takes bytelength more than 1: If charlength==1, OK.
af944926 1113 This leaves EXACTF-ish only, which are dealt with in find_byclass(). */
f8fc2ecf 1114 const U8* const str = (U8*)STRING(progi->regstclass);
2c75e362 1115 /* XXX this value could be pre-computed */
f8fc2ecf 1116 const int cl_l = (PL_regkind[OP(progi->regstclass)] == EXACT
2c75e362
DM
1117 ? (reginfo->is_utf8_pat
1118 ? utf8_distance(str + STR_LEN(progi->regstclass), str)
1119 : STR_LEN(progi->regstclass))
66e933ab 1120 : 1);
1de06328
YO
1121 char * endpos;
1122 if (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1123 endpos= HOP3c(s, (prog->minlen ? cl_l : 0), strend);
1124 else if (prog->float_substr || prog->float_utf8)
1125 endpos= HOP3c(HOP3c(check_at, -start_shift, strbeg), cl_l, strend);
1126 else
1127 endpos= strend;
1128
d8080198
YO
1129 if (checked_upto < s)
1130 checked_upto = s;
1131 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" s: %"IVdf" endpos: %"IVdf" checked_upto: %"IVdf"\n",
1132 (IV)start_shift, (IV)(check_at - strbeg), (IV)(s - strbeg), (IV)(endpos - strbeg), (IV)(checked_upto- strbeg)));
1133
6eb5f6b9 1134 t = s;
984e6dd1 1135 s = find_byclass(prog, progi->regstclass, checked_upto, endpos,
f9176b44 1136 reginfo);
d8080198
YO
1137 if (s) {
1138 checked_upto = s;
1139 } else {
6eb5f6b9 1140#ifdef DEBUGGING
cbbf8932 1141 const char *what = NULL;
6eb5f6b9
JH
1142#endif
1143 if (endpos == strend) {
a3621e74 1144 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
6eb5f6b9
JH
1145 "Could not match STCLASS...\n") );
1146 goto fail;
1147 }
a3621e74 1148 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab 1149 "This position contradicts STCLASS...\n") );
bbe252da 1150 if ((prog->extflags & RXf_ANCH) && !ml_anch)
653099ff 1151 goto fail;
d8080198
YO
1152 checked_upto = HOPBACKc(endpos, start_shift);
1153 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" endpos: %"IVdf" checked_upto: %"IVdf"\n",
1154 (IV)start_shift, (IV)(check_at - strbeg), (IV)(endpos - strbeg), (IV)(checked_upto- strbeg)));
6eb5f6b9 1155 /* Contradict one of substrings */
33b8afdf 1156 if (prog->anchored_substr || prog->anchored_utf8) {
f2ed9b32 1157 if ((utf8_target ? prog->anchored_utf8 : prog->anchored_substr) == check) {
a3621e74 1158 DEBUG_EXECUTE_r( what = "anchored" );
6eb5f6b9 1159 hop_and_restart:
1aa99e6b 1160 s = HOP3c(t, 1, strend);
66e933ab
GS
1161 if (s + start_shift + end_shift > strend) {
1162 /* XXXX Should be taken into account earlier? */
a3621e74 1163 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab
GS
1164 "Could not match STCLASS...\n") );
1165 goto fail;
1166 }
5e39e1e5
HS
1167 if (!check)
1168 goto giveup;
a3621e74 1169 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1170 "Looking for %s substr starting at offset %ld...\n",
6eb5f6b9
JH
1171 what, (long)(s + start_shift - i_strpos)) );
1172 goto restart;
1173 }
66e933ab 1174 /* Have both, check_string is floating */
6eb5f6b9
JH
1175 if (t + start_shift >= check_at) /* Contradicts floating=check */
1176 goto retry_floating_check;
1177 /* Recheck anchored substring, but not floating... */
9041c2e3 1178 s = check_at;
5e39e1e5
HS
1179 if (!check)
1180 goto giveup;
a3621e74 1181 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1182 "Looking for anchored substr starting at offset %ld...\n",
6eb5f6b9
JH
1183 (long)(other_last - i_strpos)) );
1184 goto do_other_anchored;
1185 }
60e71179
GS
1186 /* Another way we could have checked stclass at the
1187 current position only: */
1188 if (ml_anch) {
1189 s = t = t + 1;
5e39e1e5
HS
1190 if (!check)
1191 goto giveup;
a3621e74 1192 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 1193 "Looking for /%s^%s/m starting at offset %ld...\n",
e4584336 1194 PL_colors[0], PL_colors[1], (long)(t - i_strpos)) );
60e71179 1195 goto try_at_offset;
66e933ab 1196 }
f2ed9b32 1197 if (!(utf8_target ? prog->float_utf8 : prog->float_substr)) /* Could have been deleted */
60e71179 1198 goto fail;
486ec47a 1199 /* Check is floating substring. */
6eb5f6b9
JH
1200 retry_floating_check:
1201 t = check_at - start_shift;
a3621e74 1202 DEBUG_EXECUTE_r( what = "floating" );
6eb5f6b9
JH
1203 goto hop_and_restart;
1204 }
b7953727 1205 if (t != s) {
a3621e74 1206 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
6eb5f6b9 1207 "By STCLASS: moving %ld --> %ld\n",
b7953727
JH
1208 (long)(t - i_strpos), (long)(s - i_strpos))
1209 );
1210 }
1211 else {
a3621e74 1212 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
b7953727
JH
1213 "Does not contradict STCLASS...\n");
1214 );
1215 }
6eb5f6b9 1216 }
5e39e1e5 1217 giveup:
a3621e74 1218 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
5e39e1e5
HS
1219 PL_colors[4], (check ? "Guessed" : "Giving up"),
1220 PL_colors[5], (long)(s - i_strpos)) );
cad2e5aa 1221 return s;
2c2d71f5
JH
1222
1223 fail_finish: /* Substring not found */
33b8afdf 1224 if (prog->check_substr || prog->check_utf8) /* could be removed already */
f2ed9b32 1225 BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
cad2e5aa 1226 fail:
a3621e74 1227 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
e4584336 1228 PL_colors[4], PL_colors[5]));
bd61b366 1229 return NULL;
cad2e5aa 1230}
9661b544 1231
a0a388a1
YO
1232#define DECL_TRIE_TYPE(scan) \
1233 const enum { trie_plain, trie_utf8, trie_utf8_fold, trie_latin_utf8_fold } \
fab2782b
YO
1234 trie_type = ((scan->flags == EXACT) \
1235 ? (utf8_target ? trie_utf8 : trie_plain) \
1236 : (utf8_target ? trie_utf8_fold : trie_latin_utf8_fold))
1237
fd3249ee
YO
1238#define REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc, uscan, len, uvc, charid, foldlen, foldbuf, uniflags) \
1239STMT_START { \
fab2782b
YO
1240 STRLEN skiplen; \
1241 switch (trie_type) { \
1242 case trie_utf8_fold: \
1243 if ( foldlen>0 ) { \
1244 uvc = utf8n_to_uvuni( (const U8*) uscan, UTF8_MAXLEN, &len, uniflags ); \
1245 foldlen -= len; \
1246 uscan += len; \
1247 len=0; \
1248 } else { \
1249 uvc = to_utf8_fold( (const U8*) uc, foldbuf, &foldlen ); \
1250 len = UTF8SKIP(uc); \
1251 skiplen = UNISKIP( uvc ); \
1252 foldlen -= skiplen; \
1253 uscan = foldbuf + skiplen; \
1254 } \
1255 break; \
1256 case trie_latin_utf8_fold: \
1257 if ( foldlen>0 ) { \
1258 uvc = utf8n_to_uvuni( (const U8*) uscan, UTF8_MAXLEN, &len, uniflags ); \
1259 foldlen -= len; \
1260 uscan += len; \
1261 len=0; \
1262 } else { \
1263 len = 1; \
51910141 1264 uvc = _to_fold_latin1( (U8) *uc, foldbuf, &foldlen, FOLD_FLAGS_FULL); \
fab2782b
YO
1265 skiplen = UNISKIP( uvc ); \
1266 foldlen -= skiplen; \
1267 uscan = foldbuf + skiplen; \
1268 } \
1269 break; \
1270 case trie_utf8: \
1271 uvc = utf8n_to_uvuni( (const U8*) uc, UTF8_MAXLEN, &len, uniflags ); \
1272 break; \
1273 case trie_plain: \
1274 uvc = (UV)*uc; \
1275 len = 1; \
1276 } \
1277 if (uvc < 256) { \
1278 charid = trie->charmap[ uvc ]; \
1279 } \
1280 else { \
1281 charid = 0; \
1282 if (widecharmap) { \
1283 SV** const svpp = hv_fetch(widecharmap, \
1284 (char*)&uvc, sizeof(UV), 0); \
1285 if (svpp) \
1286 charid = (U16)SvIV(*svpp); \
1287 } \
1288 } \
4cadc6a9
YO
1289} STMT_END
1290
4cadc6a9
YO
1291#define REXEC_FBC_EXACTISH_SCAN(CoNd) \
1292STMT_START { \
1293 while (s <= e) { \
1294 if ( (CoNd) \
fac1af77 1295 && (ln == 1 || folder(s, pat_string, ln)) \
02d5137b 1296 && (reginfo->intuit || regtry(reginfo, &s)) )\
4cadc6a9
YO
1297 goto got_it; \
1298 s++; \
1299 } \
1300} STMT_END
1301
1302#define REXEC_FBC_UTF8_SCAN(CoDe) \
1303STMT_START { \
9a902117 1304 while (s < strend) { \
4cadc6a9 1305 CoDe \
9a902117 1306 s += UTF8SKIP(s); \
4cadc6a9
YO
1307 } \
1308} STMT_END
1309
1310#define REXEC_FBC_SCAN(CoDe) \
1311STMT_START { \
1312 while (s < strend) { \
1313 CoDe \
1314 s++; \
1315 } \
1316} STMT_END
1317
1318#define REXEC_FBC_UTF8_CLASS_SCAN(CoNd) \
1319REXEC_FBC_UTF8_SCAN( \
1320 if (CoNd) { \
02d5137b 1321 if (tmp && (reginfo->intuit || regtry(reginfo, &s))) \
4cadc6a9
YO
1322 goto got_it; \
1323 else \
1324 tmp = doevery; \
1325 } \
1326 else \
1327 tmp = 1; \
1328)
1329
1330#define REXEC_FBC_CLASS_SCAN(CoNd) \
1331REXEC_FBC_SCAN( \
1332 if (CoNd) { \
02d5137b 1333 if (tmp && (reginfo->intuit || regtry(reginfo, &s))) \
4cadc6a9
YO
1334 goto got_it; \
1335 else \
1336 tmp = doevery; \
1337 } \
1338 else \
1339 tmp = 1; \
1340)
1341
1342#define REXEC_FBC_TRYIT \
02d5137b 1343if ((reginfo->intuit || regtry(reginfo, &s))) \
4cadc6a9
YO
1344 goto got_it
1345
e1d1eefb 1346#define REXEC_FBC_CSCAN(CoNdUtF8,CoNd) \
f2ed9b32 1347 if (utf8_target) { \
e1d1eefb
YO
1348 REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8); \
1349 } \
1350 else { \
1351 REXEC_FBC_CLASS_SCAN(CoNd); \
d981ef24 1352 }
e1d1eefb 1353
786e8c11 1354#define DUMP_EXEC_POS(li,s,doutf8) \
9d9163fb 1355 dump_exec_pos(li,s,(reginfo->strend),(reginfo->strbeg), \
6d59b646 1356 startpos, doutf8)
786e8c11 1357
cfaf538b
KW
1358
1359#define UTF8_NOLOAD(TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
9d9163fb 1360 tmp = (s != reginfo->strbeg) ? UCHARAT(s - 1) : '\n'; \
cfaf538b
KW
1361 tmp = TEST_NON_UTF8(tmp); \
1362 REXEC_FBC_UTF8_SCAN( \
1363 if (tmp == ! TEST_NON_UTF8((U8) *s)) { \
1364 tmp = !tmp; \
1365 IF_SUCCESS; \
1366 } \
1367 else { \
1368 IF_FAIL; \
1369 } \
1370 ); \
1371
1372#define UTF8_LOAD(TeSt1_UtF8, TeSt2_UtF8, IF_SUCCESS, IF_FAIL) \
9d9163fb 1373 if (s == reginfo->strbeg) { \
cfaf538b
KW
1374 tmp = '\n'; \
1375 } \
1376 else { \
9d9163fb 1377 U8 * const r = reghop3((U8*)s, -1, (U8*)reginfo->strbeg); \
cfaf538b
KW
1378 tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT); \
1379 } \
1380 tmp = TeSt1_UtF8; \
1381 LOAD_UTF8_CHARCLASS_ALNUM(); \
1382 REXEC_FBC_UTF8_SCAN( \
1383 if (tmp == ! (TeSt2_UtF8)) { \
1384 tmp = !tmp; \
1385 IF_SUCCESS; \
1386 } \
1387 else { \
1388 IF_FAIL; \
1389 } \
1390 ); \
1391
63ac0dad
KW
1392/* The only difference between the BOUND and NBOUND cases is that
1393 * REXEC_FBC_TRYIT is called when matched in BOUND, and when non-matched in
1394 * NBOUND. This is accomplished by passing it in either the if or else clause,
1395 * with the other one being empty */
1396#define FBC_BOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1397 FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
cfaf538b
KW
1398
1399#define FBC_BOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1400 FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
63ac0dad
KW
1401
1402#define FBC_NBOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1403 FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
cfaf538b
KW
1404
1405#define FBC_NBOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1dcf4a1b 1406 FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
cfaf538b 1407
63ac0dad
KW
1408
1409/* Common to the BOUND and NBOUND cases. Unfortunately the UTF8 tests need to
1410 * be passed in completely with the variable name being tested, which isn't
1411 * such a clean interface, but this is easier to read than it was before. We
1412 * are looking for the boundary (or non-boundary between a word and non-word
1413 * character. The utf8 and non-utf8 cases have the same logic, but the details
1414 * must be different. Find the "wordness" of the character just prior to this
1415 * one, and compare it with the wordness of this one. If they differ, we have
1416 * a boundary. At the beginning of the string, pretend that the previous
1417 * character was a new-line */
cfaf538b 1418#define FBC_BOUND_COMMON(UTF8_CODE, TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
63ac0dad 1419 if (utf8_target) { \
cfaf538b 1420 UTF8_CODE \
63ac0dad
KW
1421 } \
1422 else { /* Not utf8 */ \
9d9163fb 1423 tmp = (s != reginfo->strbeg) ? UCHARAT(s - 1) : '\n'; \
63ac0dad
KW
1424 tmp = TEST_NON_UTF8(tmp); \
1425 REXEC_FBC_SCAN( \
1426 if (tmp == ! TEST_NON_UTF8((U8) *s)) { \
1427 tmp = !tmp; \
1428 IF_SUCCESS; \
1429 } \
1430 else { \
1431 IF_FAIL; \
1432 } \
1433 ); \
1434 } \
02d5137b 1435 if ((!prog->minlen && tmp) && (reginfo->intuit || regtry(reginfo, &s))) \
63ac0dad
KW
1436 goto got_it;
1437
786e8c11 1438/* We know what class REx starts with. Try to find this position... */
02d5137b 1439/* if reginfo->intuit, its a dryrun */
786e8c11
YO
1440/* annoyingly all the vars in this routine have different names from their counterparts
1441 in regmatch. /grrr */
1442
3c3eec57 1443STATIC char *
07be1b83 1444S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
f9176b44 1445 const char *strend, regmatch_info *reginfo)
a687059c 1446{
73104a1b
KW
1447 dVAR;
1448 const I32 doevery = (prog->intflags & PREGf_SKIP) == 0;
1449 char *pat_string; /* The pattern's exactish string */
1450 char *pat_end; /* ptr to end char of pat_string */
1451 re_fold_t folder; /* Function for computing non-utf8 folds */
1452 const U8 *fold_array; /* array for folding ords < 256 */
1453 STRLEN ln;
1454 STRLEN lnc;
73104a1b
KW
1455 U8 c1;
1456 U8 c2;
1457 char *e;
1458 I32 tmp = 1; /* Scratch variable? */
ba44c216 1459 const bool utf8_target = reginfo->is_utf8_target;
73104a1b 1460 UV utf8_fold_flags = 0;
f9176b44 1461 const bool is_utf8_pat = reginfo->is_utf8_pat;
3018b823
KW
1462 bool to_complement = FALSE; /* Invert the result? Taking the xor of this
1463 with a result inverts that result, as 0^1 =
1464 1 and 1^1 = 0 */
1465 _char_class_number classnum;
1466
73104a1b 1467 RXi_GET_DECL(prog,progi);
2f7f8cb1 1468
73104a1b 1469 PERL_ARGS_ASSERT_FIND_BYCLASS;
2f7f8cb1 1470
73104a1b
KW
1471 /* We know what class it must start with. */
1472 switch (OP(c)) {
1473 case ANYOF:
9aa1e39f 1474 case ANYOF_SYNTHETIC:
954a2af6 1475 case ANYOF_WARN_SUPER:
73104a1b
KW
1476 if (utf8_target) {
1477 REXEC_FBC_UTF8_CLASS_SCAN(
1478 reginclass(prog, c, (U8*)s, utf8_target));
1479 }
1480 else {
1481 REXEC_FBC_CLASS_SCAN(REGINCLASS(prog, c, (U8*)s));
1482 }
1483 break;
1484 case CANY:
1485 REXEC_FBC_SCAN(
02d5137b 1486 if (tmp && (reginfo->intuit || regtry(reginfo, &s)))
73104a1b
KW
1487 goto got_it;
1488 else
1489 tmp = doevery;
1490 );
1491 break;
1492
1493 case EXACTFA:
984e6dd1 1494 if (is_utf8_pat || utf8_target) {
73104a1b
KW
1495 utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
1496 goto do_exactf_utf8;
1497 }
1498 fold_array = PL_fold_latin1; /* Latin1 folds are not affected by */
1499 folder = foldEQ_latin1; /* /a, except the sharp s one which */
1500 goto do_exactf_non_utf8; /* isn't dealt with by these */
77a6d856 1501
73104a1b
KW
1502 case EXACTF:
1503 if (utf8_target) {
16d951b7 1504
73104a1b
KW
1505 /* regcomp.c already folded this if pattern is in UTF-8 */
1506 utf8_fold_flags = 0;
1507 goto do_exactf_utf8;
1508 }
1509 fold_array = PL_fold;
1510 folder = foldEQ;
1511 goto do_exactf_non_utf8;
1512
1513 case EXACTFL:
984e6dd1 1514 if (is_utf8_pat || utf8_target) {
73104a1b
KW
1515 utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
1516 goto do_exactf_utf8;
1517 }
1518 fold_array = PL_fold_locale;
1519 folder = foldEQ_locale;
1520 goto do_exactf_non_utf8;
3c760661 1521
73104a1b 1522 case EXACTFU_SS:
984e6dd1 1523 if (is_utf8_pat) {
73104a1b
KW
1524 utf8_fold_flags = FOLDEQ_S2_ALREADY_FOLDED;
1525 }
1526 goto do_exactf_utf8;
16d951b7 1527
73104a1b
KW
1528 case EXACTFU_TRICKYFOLD:
1529 case EXACTFU:
984e6dd1
DM
1530 if (is_utf8_pat || utf8_target) {
1531 utf8_fold_flags = is_utf8_pat ? FOLDEQ_S2_ALREADY_FOLDED : 0;
73104a1b
KW
1532 goto do_exactf_utf8;
1533 }
fac1af77 1534
73104a1b
KW
1535 /* Any 'ss' in the pattern should have been replaced by regcomp,
1536 * so we don't have to worry here about this single special case
1537 * in the Latin1 range */
1538 fold_array = PL_fold_latin1;
1539 folder = foldEQ_latin1;
1540
1541 /* FALL THROUGH */
1542
1543 do_exactf_non_utf8: /* Neither pattern nor string are UTF8, and there
1544 are no glitches with fold-length differences
1545 between the target string and pattern */
1546
1547 /* The idea in the non-utf8 EXACTF* cases is to first find the
1548 * first character of the EXACTF* node and then, if necessary,
1549 * case-insensitively compare the full text of the node. c1 is the
1550 * first character. c2 is its fold. This logic will not work for
1551 * Unicode semantics and the german sharp ss, which hence should
1552 * not be compiled into a node that gets here. */
1553 pat_string = STRING(c);
1554 ln = STR_LEN(c); /* length to match in octets/bytes */
1555
1556 /* We know that we have to match at least 'ln' bytes (which is the
1557 * same as characters, since not utf8). If we have to match 3
1558 * characters, and there are only 2 availabe, we know without
1559 * trying that it will fail; so don't start a match past the
1560 * required minimum number from the far end */
1561 e = HOP3c(strend, -((I32)ln), s);
1562
02d5137b 1563 if (reginfo->intuit && e < s) {
73104a1b
KW
1564 e = s; /* Due to minlen logic of intuit() */
1565 }
fac1af77 1566
73104a1b
KW
1567 c1 = *pat_string;
1568 c2 = fold_array[c1];
1569 if (c1 == c2) { /* If char and fold are the same */
1570 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1);
1571 }
1572 else {
1573 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1 || *(U8*)s == c2);
1574 }
1575 break;
fac1af77 1576
73104a1b
KW
1577 do_exactf_utf8:
1578 {
1579 unsigned expansion;
1580
1581 /* If one of the operands is in utf8, we can't use the simpler folding
1582 * above, due to the fact that many different characters can have the
1583 * same fold, or portion of a fold, or different- length fold */
1584 pat_string = STRING(c);
1585 ln = STR_LEN(c); /* length to match in octets/bytes */
1586 pat_end = pat_string + ln;
984e6dd1 1587 lnc = is_utf8_pat /* length to match in characters */
73104a1b
KW
1588 ? utf8_length((U8 *) pat_string, (U8 *) pat_end)
1589 : ln;
1590
1591 /* We have 'lnc' characters to match in the pattern, but because of
1592 * multi-character folding, each character in the target can match
1593 * up to 3 characters (Unicode guarantees it will never exceed
1594 * this) if it is utf8-encoded; and up to 2 if not (based on the
1595 * fact that the Latin 1 folds are already determined, and the
1596 * only multi-char fold in that range is the sharp-s folding to
1597 * 'ss'. Thus, a pattern character can match as little as 1/3 of a
1598 * string character. Adjust lnc accordingly, rounding up, so that
1599 * if we need to match at least 4+1/3 chars, that really is 5. */
1600 expansion = (utf8_target) ? UTF8_MAX_FOLD_CHAR_EXPAND : 2;
1601 lnc = (lnc + expansion - 1) / expansion;
1602
1603 /* As in the non-UTF8 case, if we have to match 3 characters, and
1604 * only 2 are left, it's guaranteed to fail, so don't start a
1605 * match that would require us to go beyond the end of the string
1606 */
1607 e = HOP3c(strend, -((I32)lnc), s);
1608
02d5137b 1609 if (reginfo->intuit && e < s) {
73104a1b
KW
1610 e = s; /* Due to minlen logic of intuit() */
1611 }
0658cdde 1612
73104a1b
KW
1613 /* XXX Note that we could recalculate e to stop the loop earlier,
1614 * as the worst case expansion above will rarely be met, and as we
1615 * go along we would usually find that e moves further to the left.
1616 * This would happen only after we reached the point in the loop
1617 * where if there were no expansion we should fail. Unclear if
1618 * worth the expense */
1619
1620 while (s <= e) {
1621 char *my_strend= (char *)strend;
1622 if (foldEQ_utf8_flags(s, &my_strend, 0, utf8_target,
984e6dd1 1623 pat_string, NULL, ln, is_utf8_pat, utf8_fold_flags)
02d5137b 1624 && (reginfo->intuit || regtry(reginfo, &s)) )
73104a1b
KW
1625 {
1626 goto got_it;
1627 }
1628 s += (utf8_target) ? UTF8SKIP(s) : 1;
1629 }
1630 break;
1631 }
1632 case BOUNDL:
272d35c9 1633 RXp_MATCH_TAINTED_on(prog);
0eb30aeb
KW
1634 FBC_BOUND(isWORDCHAR_LC,
1635 isWORDCHAR_LC_uvchr(UNI_TO_NATIVE(tmp)),
1636 isWORDCHAR_LC_utf8((U8*)s));
73104a1b
KW
1637 break;
1638 case NBOUNDL:
272d35c9 1639 RXp_MATCH_TAINTED_on(prog);
0eb30aeb
KW
1640 FBC_NBOUND(isWORDCHAR_LC,
1641 isWORDCHAR_LC_uvchr(UNI_TO_NATIVE(tmp)),
1642 isWORDCHAR_LC_utf8((U8*)s));
73104a1b
KW
1643 break;
1644 case BOUND:
1645 FBC_BOUND(isWORDCHAR,
0eb30aeb 1646 isWORDCHAR_uni(tmp),
03940dc2 1647 cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
73104a1b
KW
1648 break;
1649 case BOUNDA:
1650 FBC_BOUND_NOLOAD(isWORDCHAR_A,
1651 isWORDCHAR_A(tmp),
1652 isWORDCHAR_A((U8*)s));
1653 break;
1654 case NBOUND:
1655 FBC_NBOUND(isWORDCHAR,
0eb30aeb 1656 isWORDCHAR_uni(tmp),
03940dc2 1657 cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
73104a1b
KW
1658 break;
1659 case NBOUNDA:
1660 FBC_NBOUND_NOLOAD(isWORDCHAR_A,
1661 isWORDCHAR_A(tmp),
1662 isWORDCHAR_A((U8*)s));
1663 break;
1664 case BOUNDU:
1665 FBC_BOUND(isWORDCHAR_L1,
0eb30aeb 1666 isWORDCHAR_uni(tmp),
03940dc2 1667 cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
73104a1b
KW
1668 break;
1669 case NBOUNDU:
1670 FBC_NBOUND(isWORDCHAR_L1,
0eb30aeb 1671 isWORDCHAR_uni(tmp),
03940dc2 1672 cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
73104a1b 1673 break;
73104a1b
KW
1674 case LNBREAK:
1675 REXEC_FBC_CSCAN(is_LNBREAK_utf8_safe(s, strend),
1676 is_LNBREAK_latin1_safe(s, strend)
1677 );
1678 break;
3018b823
KW
1679
1680 /* The argument to all the POSIX node types is the class number to pass to
1681 * _generic_isCC() to build a mask for searching in PL_charclass[] */
1682
1683 case NPOSIXL:
1684 to_complement = 1;
1685 /* FALLTHROUGH */
1686
1687 case POSIXL:
272d35c9 1688 RXp_MATCH_TAINTED_on(prog);
3018b823
KW
1689 REXEC_FBC_CSCAN(to_complement ^ cBOOL(isFOO_utf8_lc(FLAGS(c), (U8 *) s)),
1690 to_complement ^ cBOOL(isFOO_lc(FLAGS(c), *s)));
73104a1b 1691 break;
3018b823
KW
1692
1693 case NPOSIXD:
1694 to_complement = 1;
1695 /* FALLTHROUGH */
1696
1697 case POSIXD:
1698 if (utf8_target) {
1699 goto posix_utf8;
1700 }
1701 goto posixa;
1702
1703 case NPOSIXA:
1704 if (utf8_target) {
1705 /* The complement of something that matches only ASCII matches all
1706 * UTF-8 variant code points, plus everything in ASCII that isn't
1707 * in the class */
1708 REXEC_FBC_UTF8_CLASS_SCAN(! UTF8_IS_INVARIANT(*s)
1709 || ! _generic_isCC_A(*s, FLAGS(c)));
1710 break;
1711 }
1712
1713 to_complement = 1;
1714 /* FALLTHROUGH */
1715
73104a1b 1716 case POSIXA:
3018b823 1717 posixa:
73104a1b 1718 /* Don't need to worry about utf8, as it can match only a single
3018b823
KW
1719 * byte invariant character. */
1720 REXEC_FBC_CLASS_SCAN(
1721 to_complement ^ cBOOL(_generic_isCC_A(*s, FLAGS(c))));
73104a1b 1722 break;
3018b823
KW
1723
1724 case NPOSIXU:
1725 to_complement = 1;
1726 /* FALLTHROUGH */
1727
1728 case POSIXU:
1729 if (! utf8_target) {
1730 REXEC_FBC_CLASS_SCAN(to_complement ^ cBOOL(_generic_isCC(*s,
1731 FLAGS(c))));
1732 }
1733 else {
1734
1735 posix_utf8:
1736 classnum = (_char_class_number) FLAGS(c);
1737 if (classnum < _FIRST_NON_SWASH_CC) {
1738 while (s < strend) {
1739
1740 /* We avoid loading in the swash as long as possible, but
1741 * should we have to, we jump to a separate loop. This
1742 * extra 'if' statement is what keeps this code from being
1743 * just a call to REXEC_FBC_UTF8_CLASS_SCAN() */
1744 if (UTF8_IS_ABOVE_LATIN1(*s)) {
1745 goto found_above_latin1;
1746 }
1747 if ((UTF8_IS_INVARIANT(*s)
1748 && to_complement ^ cBOOL(_generic_isCC((U8) *s,
1749 classnum)))
1750 || (UTF8_IS_DOWNGRADEABLE_START(*s)
1751 && to_complement ^ cBOOL(
1752 _generic_isCC(TWO_BYTE_UTF8_TO_UNI(*s, *(s + 1)),
1753 classnum))))
1754 {
02d5137b 1755 if (tmp && (reginfo->intuit || regtry(reginfo, &s)))
3018b823
KW
1756 goto got_it;
1757 else {
1758 tmp = doevery;
1759 }
1760 }
1761 else {
1762 tmp = 1;
1763 }
1764 s += UTF8SKIP(s);
1765 }
1766 }
1767 else switch (classnum) { /* These classes are implemented as
1768 macros */
1769 case _CC_ENUM_SPACE: /* XXX would require separate code if we
1770 revert the change of \v matching this */
1771 /* FALL THROUGH */
1772
1773 case _CC_ENUM_PSXSPC:
1774 REXEC_FBC_UTF8_CLASS_SCAN(
1775 to_complement ^ cBOOL(isSPACE_utf8(s)));
1776 break;
1777
1778 case _CC_ENUM_BLANK:
1779 REXEC_FBC_UTF8_CLASS_SCAN(
1780 to_complement ^ cBOOL(isBLANK_utf8(s)));
1781 break;
1782
1783 case _CC_ENUM_XDIGIT:
1784 REXEC_FBC_UTF8_CLASS_SCAN(
1785 to_complement ^ cBOOL(isXDIGIT_utf8(s)));
1786 break;
1787
1788 case _CC_ENUM_VERTSPACE:
1789 REXEC_FBC_UTF8_CLASS_SCAN(
1790 to_complement ^ cBOOL(isVERTWS_utf8(s)));
1791 break;
1792
1793 case _CC_ENUM_CNTRL:
1794 REXEC_FBC_UTF8_CLASS_SCAN(
1795 to_complement ^ cBOOL(isCNTRL_utf8(s)));
1796 break;
1797
1798 default:
1799 Perl_croak(aTHX_ "panic: find_byclass() node %d='%s' has an unexpected character class '%d'", OP(c), PL_reg_name[OP(c)], classnum);
1800 assert(0); /* NOTREACHED */
1801 }
1802 }
1803 break;
1804
1805 found_above_latin1: /* Here we have to load a swash to get the result
1806 for the current code point */
1807 if (! PL_utf8_swash_ptrs[classnum]) {
1808 U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
1809 PL_utf8_swash_ptrs[classnum] =
1810 _core_swash_init("utf8", swash_property_names[classnum],
1811 &PL_sv_undef, 1, 0, NULL, &flags);
1812 }
1813
1814 /* This is a copy of the loop above for swash classes, though using the
1815 * FBC macro instead of being expanded out. Since we've loaded the
1816 * swash, we don't have to check for that each time through the loop */
1817 REXEC_FBC_UTF8_CLASS_SCAN(
1818 to_complement ^ cBOOL(_generic_utf8(
1819 classnum,
1820 s,
1821 swash_fetch(PL_utf8_swash_ptrs[classnum],
1822 (U8 *) s, TRUE))));
73104a1b
KW
1823 break;
1824
1825 case AHOCORASICKC:
1826 case AHOCORASICK:
1827 {
1828 DECL_TRIE_TYPE(c);
1829 /* what trie are we using right now */
1830 reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ARG( c ) ];
1831 reg_trie_data *trie = (reg_trie_data*)progi->data->data[ aho->trie ];
1832 HV *widecharmap = MUTABLE_HV(progi->data->data[ aho->trie + 1 ]);
1833
1834 const char *last_start = strend - trie->minlen;
6148ee25 1835#ifdef DEBUGGING
73104a1b 1836 const char *real_start = s;
6148ee25 1837#endif
73104a1b
KW
1838 STRLEN maxlen = trie->maxlen;
1839 SV *sv_points;
1840 U8 **points; /* map of where we were in the input string
1841 when reading a given char. For ASCII this
1842 is unnecessary overhead as the relationship
1843 is always 1:1, but for Unicode, especially
1844 case folded Unicode this is not true. */
1845 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1846 U8 *bitmap=NULL;
1847
1848
1849 GET_RE_DEBUG_FLAGS_DECL;
1850
1851 /* We can't just allocate points here. We need to wrap it in
1852 * an SV so it gets freed properly if there is a croak while
1853 * running the match */
1854 ENTER;
1855 SAVETMPS;
1856 sv_points=newSV(maxlen * sizeof(U8 *));
1857 SvCUR_set(sv_points,
1858 maxlen * sizeof(U8 *));
1859 SvPOK_on(sv_points);
1860 sv_2mortal(sv_points);
1861 points=(U8**)SvPV_nolen(sv_points );
1862 if ( trie_type != trie_utf8_fold
1863 && (trie->bitmap || OP(c)==AHOCORASICKC) )
1864 {
1865 if (trie->bitmap)
1866 bitmap=(U8*)trie->bitmap;
1867 else
1868 bitmap=(U8*)ANYOF_BITMAP(c);
1869 }
1870 /* this is the Aho-Corasick algorithm modified a touch
1871 to include special handling for long "unknown char" sequences.
1872 The basic idea being that we use AC as long as we are dealing
1873 with a possible matching char, when we encounter an unknown char
1874 (and we have not encountered an accepting state) we scan forward
1875 until we find a legal starting char.
1876 AC matching is basically that of trie matching, except that when
1877 we encounter a failing transition, we fall back to the current
1878 states "fail state", and try the current char again, a process
1879 we repeat until we reach the root state, state 1, or a legal
1880 transition. If we fail on the root state then we can either
1881 terminate if we have reached an accepting state previously, or
1882 restart the entire process from the beginning if we have not.
1883
1884 */
1885 while (s <= last_start) {
1886 const U32 uniflags = UTF8_ALLOW_DEFAULT;
1887 U8 *uc = (U8*)s;
1888 U16 charid = 0;
1889 U32 base = 1;
1890 U32 state = 1;
1891 UV uvc = 0;
1892 STRLEN len = 0;
1893 STRLEN foldlen = 0;
1894 U8 *uscan = (U8*)NULL;
1895 U8 *leftmost = NULL;
1896#ifdef DEBUGGING
1897 U32 accepted_word= 0;
786e8c11 1898#endif
73104a1b
KW
1899 U32 pointpos = 0;
1900
1901 while ( state && uc <= (U8*)strend ) {
1902 int failed=0;
1903 U32 word = aho->states[ state ].wordnum;
1904
1905 if( state==1 ) {
1906 if ( bitmap ) {
1907 DEBUG_TRIE_EXECUTE_r(
1908 if ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1909 dump_exec_pos( (char *)uc, c, strend, real_start,
1910 (char *)uc, utf8_target );
1911 PerlIO_printf( Perl_debug_log,
1912 " Scanning for legal start char...\n");
1913 }
1914 );
1915 if (utf8_target) {
1916 while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1917 uc += UTF8SKIP(uc);
1918 }
1919 } else {
1920 while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1921 uc++;
1922 }
786e8c11 1923 }
73104a1b 1924 s= (char *)uc;
07be1b83 1925 }
73104a1b
KW
1926 if (uc >(U8*)last_start) break;
1927 }
1928
1929 if ( word ) {
1930 U8 *lpos= points[ (pointpos - trie->wordinfo[word].len) % maxlen ];
1931 if (!leftmost || lpos < leftmost) {
1932 DEBUG_r(accepted_word=word);
1933 leftmost= lpos;
7016d6eb 1934 }
73104a1b 1935 if (base==0) break;
7016d6eb 1936
73104a1b
KW
1937 }
1938 points[pointpos++ % maxlen]= uc;
1939 if (foldlen || uc < (U8*)strend) {
1940 REXEC_TRIE_READ_CHAR(trie_type, trie,
1941 widecharmap, uc,
1942 uscan, len, uvc, charid, foldlen,
1943 foldbuf, uniflags);
1944 DEBUG_TRIE_EXECUTE_r({
1945 dump_exec_pos( (char *)uc, c, strend,
1946 real_start, s, utf8_target);
1947 PerlIO_printf(Perl_debug_log,
1948 " Charid:%3u CP:%4"UVxf" ",
1949 charid, uvc);
1950 });
1951 }
1952 else {
1953 len = 0;
1954 charid = 0;
1955 }
07be1b83 1956
73104a1b
KW
1957
1958 do {
6148ee25 1959#ifdef DEBUGGING
73104a1b 1960 word = aho->states[ state ].wordnum;
6148ee25 1961#endif
73104a1b
KW
1962 base = aho->states[ state ].trans.base;
1963
1964 DEBUG_TRIE_EXECUTE_r({
1965 if (failed)
1966 dump_exec_pos( (char *)uc, c, strend, real_start,
1967 s, utf8_target );
1968 PerlIO_printf( Perl_debug_log,
1969 "%sState: %4"UVxf", word=%"UVxf,
1970 failed ? " Fail transition to " : "",
1971 (UV)state, (UV)word);
1972 });
1973 if ( base ) {
1974 U32 tmp;
1975 I32 offset;
1976 if (charid &&
1977 ( ((offset = base + charid
1978 - 1 - trie->uniquecharcount)) >= 0)
1979 && ((U32)offset < trie->lasttrans)
1980 && trie->trans[offset].check == state
1981 && (tmp=trie->trans[offset].next))
1982 {
1983 DEBUG_TRIE_EXECUTE_r(
1984 PerlIO_printf( Perl_debug_log," - legal\n"));
1985 state = tmp;
1986 break;
07be1b83
YO
1987 }
1988 else {
786e8c11 1989 DEBUG_TRIE_EXECUTE_r(
73104a1b 1990 PerlIO_printf( Perl_debug_log," - fail\n"));
786e8c11 1991 failed = 1;
73104a1b 1992 state = aho->fail[state];
07be1b83 1993 }
07be1b83 1994 }
73104a1b
KW
1995 else {
1996 /* we must be accepting here */
1997 DEBUG_TRIE_EXECUTE_r(
1998 PerlIO_printf( Perl_debug_log," - accepting\n"));
1999 failed = 1;
2000 break;
786e8c11 2001 }
73104a1b
KW
2002 } while(state);
2003 uc += len;
2004 if (failed) {
2005 if (leftmost)
2006 break;
2007 if (!state) state = 1;
07be1b83 2008 }
73104a1b
KW
2009 }
2010 if ( aho->states[ state ].wordnum ) {
2011 U8 *lpos = points[ (pointpos - trie->wordinfo[aho->states[ state ].wordnum].len) % maxlen ];
2012 if (!leftmost || lpos < leftmost) {
2013 DEBUG_r(accepted_word=aho->states[ state ].wordnum);
2014 leftmost = lpos;
07be1b83
YO
2015 }
2016 }
73104a1b
KW
2017 if (leftmost) {
2018 s = (char*)leftmost;
2019 DEBUG_TRIE_EXECUTE_r({
2020 PerlIO_printf(
2021 Perl_debug_log,"Matches word #%"UVxf" at position %"IVdf". Trying full pattern...\n",
2022 (UV)accepted_word, (IV)(s - real_start)
2023 );
2024 });
02d5137b 2025 if (reginfo->intuit || regtry(reginfo, &s)) {
73104a1b
KW
2026 FREETMPS;
2027 LEAVE;
2028 goto got_it;
2029 }
2030 s = HOPc(s,1);
2031 DEBUG_TRIE_EXECUTE_r({
2032 PerlIO_printf( Perl_debug_log,"Pattern failed. Looking for new start point...\n");
2033 });
2034 } else {
2035 DEBUG_TRIE_EXECUTE_r(
2036 PerlIO_printf( Perl_debug_log,"No match.\n"));
2037 break;
2038 }
2039 }
2040 FREETMPS;
2041 LEAVE;
2042 }
2043 break;
2044 default:
2045 Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
2046 break;
2047 }
2048 return 0;
2049 got_it:
2050 return s;
6eb5f6b9
JH
2051}
2052
60165aa4
DM
2053/* set RX_SAVED_COPY, RX_SUBBEG etc.
2054 * flags have same meanings as with regexec_flags() */
2055
2056void
2057Perl_reg_set_capture_string(pTHX_ REGEXP * const rx,
2058 char *strbeg,
2059 char *strend,
2060 SV *sv,
2061 U32 flags,
2062 bool utf8_target)
2063{
2064 struct regexp *const prog = ReANY(rx);
2065
2066 PERL_ARGS_ASSERT_REG_SET_CAPTURE_STRING;
2067
2068 if (flags & REXEC_COPY_STR) {
2069#ifdef PERL_ANY_COW
2070 if (SvCANCOW(sv)) {
2071 if (DEBUG_C_TEST) {
2072 PerlIO_printf(Perl_debug_log,
2073 "Copy on write: regexp capture, type %d\n",
2074 (int) SvTYPE(sv));
2075 }
2076 RX_MATCH_COPY_FREE(rx);
2077 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
2078 prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
2079 assert (SvPOKp(prog->saved_copy));
2080 prog->sublen = strend - strbeg;
2081 prog->suboffset = 0;
2082 prog->subcoffset = 0;
2083 } else
2084#endif
2085 {
2086 I32 min = 0;
2087 I32 max = strend - strbeg;
2088 I32 sublen;
2089
2090 if ( (flags & REXEC_COPY_SKIP_POST)
2091 && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) /* //p */
2092 && !(PL_sawampersand & SAWAMPERSAND_RIGHT)
2093 ) { /* don't copy $' part of string */
2094 U32 n = 0;
2095 max = -1;
2096 /* calculate the right-most part of the string covered
2097 * by a capture. Due to look-ahead, this may be to
2098 * the right of $&, so we have to scan all captures */
2099 while (n <= prog->lastparen) {
2100 if (prog->offs[n].end > max)
2101 max = prog->offs[n].end;
2102 n++;
2103 }
2104 if (max == -1)
2105 max = (PL_sawampersand & SAWAMPERSAND_LEFT)
2106 ? prog->offs[0].start
2107 : 0;
2108 assert(max >= 0 && max <= strend - strbeg);
2109 }
2110
2111 if ( (flags & REXEC_COPY_SKIP_PRE)
2112 && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) /* //p */
2113 && !(PL_sawampersand & SAWAMPERSAND_LEFT)
2114 ) { /* don't copy $` part of string */
2115 U32 n = 0;
2116 min = max;
2117 /* calculate the left-most part of the string covered
2118 * by a capture. Due to look-behind, this may be to
2119 * the left of $&, so we have to scan all captures */
2120 while (min && n <= prog->lastparen) {
2121 if ( prog->offs[n].start != -1
2122 && prog->offs[n].start < min)
2123 {
2124 min = prog->offs[n].start;
2125 }
2126 n++;
2127 }
2128 if ((PL_sawampersand & SAWAMPERSAND_RIGHT)
2129 && min > prog->offs[0].end
2130 )
2131 min = prog->offs[0].end;
2132
2133 }
2134
2135 assert(min >= 0 && min <= max && min <= strend - strbeg);
2136 sublen = max - min;
2137
2138 if (RX_MATCH_COPIED(rx)) {
2139 if (sublen > prog->sublen)
2140 prog->subbeg =
2141 (char*)saferealloc(prog->subbeg, sublen+1);
2142 }
2143 else
2144 prog->subbeg = (char*)safemalloc(sublen+1);
2145 Copy(strbeg + min, prog->subbeg, sublen, char);
2146 prog->subbeg[sublen] = '\0';
2147 prog->suboffset = min;
2148 prog->sublen = sublen;
2149 RX_MATCH_COPIED_on(rx);
2150 }
2151 prog->subcoffset = prog->suboffset;
2152 if (prog->suboffset && utf8_target) {
2153 /* Convert byte offset to chars.
2154 * XXX ideally should only compute this if @-/@+
2155 * has been seen, a la PL_sawampersand ??? */
2156
2157 /* If there's a direct correspondence between the
2158 * string which we're matching and the original SV,
2159 * then we can use the utf8 len cache associated with
2160 * the SV. In particular, it means that under //g,
2161 * sv_pos_b2u() will use the previously cached
2162 * position to speed up working out the new length of
2163 * subcoffset, rather than counting from the start of
2164 * the string each time. This stops
2165 * $x = "\x{100}" x 1E6; 1 while $x =~ /(.)/g;
2166 * from going quadratic */
2167 if (SvPOKp(sv) && SvPVX(sv) == strbeg)
2168 sv_pos_b2u(sv, &(prog->subcoffset));
2169 else
2170 prog->subcoffset = utf8_length((U8*)strbeg,
2171 (U8*)(strbeg+prog->suboffset));
2172 }
2173 }
2174 else {
2175 RX_MATCH_COPY_FREE(rx);
2176 prog->subbeg = strbeg;
2177 prog->suboffset = 0;
2178 prog->subcoffset = 0;
2179 prog->sublen = strend - strbeg;
2180 }
2181}
2182
2183
2184
fae667d5 2185
6eb5f6b9
JH
2186/*
2187 - regexec_flags - match a regexp against a string
2188 */
2189I32
5aaab254 2190Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend,
6eb5f6b9 2191 char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
8fd1a950
DM
2192/* stringarg: the point in the string at which to begin matching */
2193/* strend: pointer to null at end of string */
2194/* strbeg: real beginning of string */
2195/* minend: end of match must be >= minend bytes after stringarg. */
2196/* sv: SV being matched: only used for utf8 flag, pos() etc; string
2197 * itself is accessed via the pointers above */
2198/* data: May be used for some additional optimizations.
2199 Currently its only used, with a U32 cast, for transmitting
2200 the ganch offset when doing a /g match. This will change */
2201/* nosave: For optimizations. */
2202
6eb5f6b9 2203{
97aff369 2204 dVAR;
8d919b0a 2205 struct regexp *const prog = ReANY(rx);
5aaab254 2206 char *s;
eb578fdb 2207 regnode *c;
5aaab254 2208 char *startpos = stringarg;
6eb5f6b9
JH
2209 I32 minlen; /* must match at least this many chars */
2210 I32 dontbother = 0; /* how many characters not to try at end */
6eb5f6b9
JH
2211 I32 end_shift = 0; /* Same for the end. */ /* CC */
2212 I32 scream_pos = -1; /* Internal iterator of scream. */
ccac19ea 2213 char *scream_olds = NULL;
f2ed9b32 2214 const bool utf8_target = cBOOL(DO_UTF8(sv));
2757e526 2215 I32 multiline;
f8fc2ecf 2216 RXi_GET_DECL(prog,progi);
02d5137b
DM
2217 regmatch_info reginfo_buf; /* create some info to pass to regtry etc */
2218 regmatch_info *const reginfo = &reginfo_buf;
e9105d30 2219 regexp_paren_pair *swap = NULL;
006f26b2 2220 I32 oldsave;
a3621e74
YO
2221 GET_RE_DEBUG_FLAGS_DECL;
2222
7918f24d 2223 PERL_ARGS_ASSERT_REGEXEC_FLAGS;
9d4ba2ae 2224 PERL_UNUSED_ARG(data);
6eb5f6b9
JH
2225
2226 /* Be paranoid... */
2227 if (prog == NULL || startpos == NULL) {
2228 Perl_croak(aTHX_ "NULL regexp parameter");
2229 return 0;
2230 }
2231
6c3fea77
DM
2232 DEBUG_EXECUTE_r(
2233 debug_start_match(rx, utf8_target, startpos, strend,
2234 "Matching");
2235 );
8adc0f72 2236
2757e526 2237
331b2dcc
DM
2238 /* at the end of this function, we'll do a LEAVE_SCOPE(oldsave),
2239 * which will call destuctors to reset PL_regmatch_state, free higher
2240 * PL_regmatch_slabs, and clean up regmatch_info_aux and
2241 * regmatch_info_aux_eval */
006f26b2 2242
006f26b2 2243 oldsave = PL_savestack_ix;
006f26b2 2244
6c3fea77 2245 multiline = prog->extflags & RXf_PMf_MULTILINE;
6eb5f6b9 2246 minlen = prog->minlen;
1de06328
YO
2247
2248 if (strend - startpos < (minlen+(prog->check_offset_min<0?prog->check_offset_min:0))) {
a3621e74 2249 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584
JH
2250 "String too short [regexec_flags]...\n"));
2251 goto phooey;
1aa99e6b 2252 }
1de06328 2253
6eb5f6b9 2254 /* Check validity of program. */
f8fc2ecf 2255 if (UCHARAT(progi->program) != REG_MAGIC) {
6eb5f6b9
JH
2256 Perl_croak(aTHX_ "corrupted regexp program");
2257 }
2258
272d35c9 2259 RX_MATCH_TAINTED_off(rx);
6eb5f6b9 2260
6c3fea77
DM
2261 reginfo->prog = rx; /* Yes, sorry that this is confusing. */
2262 reginfo->intuit = 0;
2263 reginfo->is_utf8_target = cBOOL(utf8_target);
02d5137b
DM
2264 reginfo->is_utf8_pat = cBOOL(RX_UTF8(rx));
2265 reginfo->warned = FALSE;
9d9163fb 2266 reginfo->strbeg = strbeg;
02d5137b 2267 reginfo->sv = sv;
1cb48e53 2268 reginfo->poscache_maxiter = 0; /* not yet started a countdown */
220db18a 2269 reginfo->strend = strend;
6eb5f6b9 2270 /* see how far we have to get to not match where we matched before */
02d5137b 2271 reginfo->till = startpos+minend;
6eb5f6b9 2272
82c23608
FC
2273 if (prog->extflags & RXf_EVAL_SEEN && SvPADTMP(sv) && !IS_PADGV(sv)) {
2274 /* SAVEFREESV, not sv_mortalcopy, as this SV must last until after
2275 S_cleanup_regmatch_info_aux has executed (registered by
2276 SAVEDESTRUCTOR_X below). S_cleanup_regmatch_info_aux modifies
2277 magic belonging to this SV.
2278 Not newSVsv, either, as it does not COW.
2279 */
2280 reginfo->sv = newSV(0);
2281 sv_setsv(reginfo->sv, sv);
2282 SAVEFREESV(reginfo->sv);
2283 }
2284
331b2dcc
DM
2285 /* reserve next 2 or 3 slots in PL_regmatch_state:
2286 * slot N+0: may currently be in use: skip it
2287 * slot N+1: use for regmatch_info_aux struct
2288 * slot N+2: use for regmatch_info_aux_eval struct if we have (?{})'s
2289 * slot N+3: ready for use by regmatch()
2290 */
bf2039a9 2291
331b2dcc
DM
2292 {
2293 regmatch_state *old_regmatch_state;
2294 regmatch_slab *old_regmatch_slab;
2295 int i, max = (prog->extflags & RXf_EVAL_SEEN) ? 2 : 1;
2296
2297 /* on first ever match, allocate first slab */
2298 if (!PL_regmatch_slab) {
2299 Newx(PL_regmatch_slab, 1, regmatch_slab);
2300 PL_regmatch_slab->prev = NULL;
2301 PL_regmatch_slab->next = NULL;
2302 PL_regmatch_state = SLAB_FIRST(PL_regmatch_slab);
2303 }
bf2039a9 2304
331b2dcc
DM
2305 old_regmatch_state = PL_regmatch_state;
2306 old_regmatch_slab = PL_regmatch_slab;
bf2039a9 2307
331b2dcc
DM
2308 for (i=0; i <= max; i++) {
2309 if (i == 1)
2310 reginfo->info_aux = &(PL_regmatch_state->u.info_aux);
2311 else if (i ==2)
2312 reginfo->info_aux_eval =
2313 reginfo->info_aux->info_aux_eval =
2314 &(PL_regmatch_state->u.info_aux_eval);
bf2039a9 2315
331b2dcc
DM
2316 if (++PL_regmatch_state > SLAB_LAST(PL_regmatch_slab))
2317 PL_regmatch_state = S_push_slab(aTHX);
2318 }
bf2039a9 2319
331b2dcc
DM
2320 /* note initial PL_regmatch_state position; at end of match we'll
2321 * pop back to there and free any higher slabs */
bf2039a9 2322
331b2dcc
DM
2323 reginfo->info_aux->old_regmatch_state = old_regmatch_state;
2324 reginfo->info_aux->old_regmatch_slab = old_regmatch_slab;
2ac8ff4b 2325 reginfo->info_aux->poscache = NULL;
bf2039a9 2326
331b2dcc 2327 SAVEDESTRUCTOR_X(S_cleanup_regmatch_info_aux, reginfo->info_aux);
bf2039a9 2328
331b2dcc
DM
2329 if ((prog->extflags & RXf_EVAL_SEEN))
2330 S_setup_eval_state(aTHX_ reginfo);
2331 else
2332 reginfo->info_aux_eval = reginfo->info_aux->info_aux_eval = NULL;
bf2039a9 2333 }
d3aa529c 2334
6eb5f6b9
JH
2335 /* If there is a "must appear" string, look for it. */
2336 s = startpos;
2337
bbe252da 2338 if (prog->extflags & RXf_GPOS_SEEN) { /* Need to set reginfo->ganch */
6eb5f6b9 2339 MAGIC *mg;
2c296965 2340 if (flags & REXEC_IGNOREPOS){ /* Means: check only at start */
02d5137b 2341 reginfo->ganch = startpos + prog->gofs;
2c296965 2342 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
02d5137b 2343 "GPOS IGNOREPOS: reginfo->ganch = startpos + %"UVxf"\n",(UV)prog->gofs));
96c2a8ff 2344 } else if (sv && (mg = mg_find_mglob(sv))
14befaf4 2345 && mg->mg_len >= 0) {
02d5137b 2346 reginfo->ganch = strbeg + mg->mg_len; /* Defined pos() */
2c296965 2347 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
02d5137b 2348 "GPOS MAGIC: reginfo->ganch = strbeg + %"IVdf"\n",(IV)mg->mg_len));
2c296965 2349
bbe252da 2350 if (prog->extflags & RXf_ANCH_GPOS) {
02d5137b 2351 if (s > reginfo->ganch)
6eb5f6b9 2352 goto phooey;
02d5137b 2353 s = reginfo->ganch - prog->gofs;
2c296965 2354 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
ed549f2e 2355 "GPOS ANCH_GPOS: s = ganch - %"UVxf"\n",(UV)prog->gofs));
c584a96e
YO
2356 if (s < strbeg)
2357 goto phooey;
6eb5f6b9
JH
2358 }
2359 }
58e23c8d 2360 else if (data) {
02d5137b 2361 reginfo->ganch = strbeg + PTR2UV(data);
2c296965 2362 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
02d5137b 2363 "GPOS DATA: reginfo->ganch= strbeg + %"UVxf"\n",PTR2UV(data)));
2c296965
YO
2364
2365 } else { /* pos() not defined */
02d5137b 2366 reginfo->ganch = strbeg;
2c296965 2367 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
02d5137b 2368 "GPOS: reginfo->ganch = strbeg\n"));
2c296965 2369 }
6eb5f6b9 2370 }
288b8c02 2371 if (PL_curpm && (PM_GETRE(PL_curpm) == rx)) {
e9105d30
GG
2372 /* We have to be careful. If the previous successful match
2373 was from this regex we don't want a subsequent partially
2374 successful match to clobber the old results.
2375 So when we detect this possibility we add a swap buffer
d8da0584
KW
2376 to the re, and switch the buffer each match. If we fail,
2377 we switch it back; otherwise we leave it swapped.
e9105d30
GG
2378 */
2379 swap = prog->offs;
2380 /* do we need a save destructor here for eval dies? */
2381 Newxz(prog->offs, (prog->nparens + 1), regexp_paren_pair);
495f47a5
DM
2382 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
2383 "rex=0x%"UVxf" saving offs: orig=0x%"UVxf" new=0x%"UVxf"\n",
2384 PTR2UV(prog),
2385 PTR2UV(swap),
2386 PTR2UV(prog->offs)
2387 ));
c74340f9 2388 }
a0714e2c 2389 if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
6eb5f6b9
JH
2390 re_scream_pos_data d;
2391
2392 d.scream_olds = &scream_olds;
2393 d.scream_pos = &scream_pos;
52a21eb3 2394 s = re_intuit_start(rx, sv, strbeg, s, strend, flags, &d);
3fa9c3d7 2395 if (!s) {
a3621e74 2396 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
6eb5f6b9 2397 goto phooey; /* not present */
3fa9c3d7 2398 }
6eb5f6b9
JH
2399 }
2400
1de06328 2401
6eb5f6b9
JH
2402
2403 /* Simplest case: anchored match need be tried only once. */
2404 /* [unless only anchor is BOL and multiline is set] */
bbe252da 2405 if (prog->extflags & (RXf_ANCH & ~RXf_ANCH_GPOS)) {
02d5137b 2406 if (s == startpos && regtry(reginfo, &startpos))
6eb5f6b9 2407 goto got_it;
bbe252da
YO
2408 else if (multiline || (prog->intflags & PREGf_IMPLICIT)
2409 || (prog->extflags & RXf_ANCH_MBOL)) /* XXXX SBOL? */
6eb5f6b9
JH
2410 {
2411 char *end;
2412
2413 if (minlen)
2414 dontbother = minlen - 1;
1aa99e6b 2415 end = HOP3c(strend, -dontbother, strbeg) - 1;
6eb5f6b9 2416 /* for multiline we only have to try after newlines */
33b8afdf 2417 if (prog->check_substr || prog->check_utf8) {
92f3d482
YO
2418 /* because of the goto we can not easily reuse the macros for bifurcating the
2419 unicode/non-unicode match modes here like we do elsewhere - demerphq */
2420 if (utf8_target) {
2421 if (s == startpos)
2422 goto after_try_utf8;
2423 while (1) {
02d5137b 2424 if (regtry(reginfo, &s)) {
92f3d482
YO
2425 goto got_it;
2426 }
2427 after_try_utf8:
2428 if (s > end) {
2429 goto phooey;
2430 }
2431 if (prog->extflags & RXf_USE_INTUIT) {
52a21eb3
DM
2432 s = re_intuit_start(rx, sv, strbeg,
2433 s + UTF8SKIP(s), strend, flags, NULL);
92f3d482
YO
2434 if (!s) {
2435 goto phooey;
2436 }
2437 }
2438 else {
2439 s += UTF8SKIP(s);
2440 }
2441 }
2442 } /* end search for check string in unicode */
2443 else {
2444 if (s == startpos) {
2445 goto after_try_latin;
2446 }
2447 while (1) {
02d5137b 2448 if (regtry(reginfo, &s)) {
92f3d482
YO
2449 goto got_it;
2450 }
2451 after_try_latin:
2452 if (s > end) {
2453 goto phooey;
2454 }
2455 if (prog->extflags & RXf_USE_INTUIT) {
52a21eb3
DM
2456 s = re_intuit_start(rx, sv, strbeg,
2457 s + 1, strend, flags, NULL);
92f3d482
YO
2458 if (!s) {
2459 goto phooey;
2460 }
2461 }
2462 else {
2463 s++;
2464 }
2465 }
2466 } /* end search for check string in latin*/
2467 } /* end search for check string */
2468 else { /* search for newline */
2469 if (s > startpos) {
2470 /*XXX: The s-- is almost definitely wrong here under unicode - demeprhq*/
6eb5f6b9 2471 s--;
92f3d482 2472 }
21eede78
YO
2473 /* We can use a more efficient search as newlines are the same in unicode as they are in latin */
2474 while (s <= end) { /* note it could be possible to match at the end of the string */
6eb5f6b9 2475 if (*s++ == '\n') { /* don't need PL_utf8skip here */
02d5137b 2476 if (regtry(reginfo, &s))
6eb5f6b9
JH
2477 goto got_it;
2478 }
92f3d482
YO
2479 }
2480 } /* end search for newline */
2481 } /* end anchored/multiline check string search */
6eb5f6b9 2482 goto phooey;
bbe252da 2483 } else if (RXf_GPOS_CHECK == (prog->extflags & RXf_GPOS_CHECK))
f9f4320a 2484 {
02d5137b 2485 /* the warning about reginfo->ganch being used without initialization
bbe252da 2486 is bogus -- we set it above, when prog->extflags & RXf_GPOS_SEEN
f9f4320a 2487 and we only enter this block when the same bit is set. */
02d5137b 2488 char *tmp_s = reginfo->ganch - prog->gofs;
c584a96e 2489
02d5137b 2490 if (tmp_s >= strbeg && regtry(reginfo, &tmp_s))
6eb5f6b9
JH
2491 goto got_it;
2492 goto phooey;
2493 }
2494
2495 /* Messy cases: unanchored match. */
bbe252da 2496 if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
6eb5f6b9 2497 /* we have /x+whatever/ */
984e6dd1 2498 /* it must be a one character string (XXXX Except is_utf8_pat?) */
33b8afdf 2499 char ch;
bf93d4cc
GS
2500#ifdef DEBUGGING
2501 int did_match = 0;
2502#endif
f2ed9b32 2503 if (utf8_target) {
7e0d5ad7
KW
2504 if (! prog->anchored_utf8) {
2505 to_utf8_substr(prog);
2506 }
2507 ch = SvPVX_const(prog->anchored_utf8)[0];
4cadc6a9 2508 REXEC_FBC_SCAN(
6eb5f6b9 2509 if (*s == ch) {
a3621e74 2510 DEBUG_EXECUTE_r( did_match = 1 );
02d5137b 2511 if (regtry(reginfo, &s)) goto got_it;
6eb5f6b9
JH
2512 s += UTF8SKIP(s);
2513 while (s < strend && *s == ch)
2514 s += UTF8SKIP(s);
2515 }
4cadc6a9 2516 );
7e0d5ad7 2517
6eb5f6b9
JH
2518 }
2519 else {
7e0d5ad7
KW
2520 if (! prog->anchored_substr) {
2521 if (! to_byte_substr(prog)) {
6b54ddc5 2522 NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
7e0d5ad7
KW
2523 }
2524 }
2525 ch = SvPVX_const(prog->anchored_substr)[0];
4cadc6a9 2526 REXEC_FBC_SCAN(
6eb5f6b9 2527 if (*s == ch) {
a3621e74 2528 DEBUG_EXECUTE_r( did_match = 1 );
02d5137b 2529 if (regtry(reginfo, &s)) goto got_it;
6eb5f6b9
JH
2530 s++;
2531 while (s < strend && *s == ch)
2532 s++;
2533 }
4cadc6a9 2534 );
6eb5f6b9 2535 }
a3621e74 2536 DEBUG_EXECUTE_r(if (!did_match)
bf93d4cc 2537 PerlIO_printf(Perl_debug_log,
b7953727
JH
2538 "Did not find anchored character...\n")
2539 );
6eb5f6b9 2540 }
a0714e2c
SS
2541 else if (prog->anchored_substr != NULL
2542 || prog->anchored_utf8 != NULL
2543 || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
33b8afdf
JH
2544 && prog->float_max_offset < strend - s)) {
2545 SV *must;
2546 I32 back_max;
2547 I32 back_min;
2548 char *last;
6eb5f6b9 2549 char *last1; /* Last position checked before */
bf93d4cc
GS
2550#ifdef DEBUGGING
2551 int did_match = 0;
2552#endif
33b8afdf 2553 if (prog->anchored_substr || prog->anchored_utf8) {
7e0d5ad7
KW
2554 if (utf8_target) {
2555 if (! prog->anchored_utf8) {
2556 to_utf8_substr(prog);
2557 }
2558 must = prog->anchored_utf8;
2559 }
2560 else {
2561 if (! prog->anchored_substr) {
2562 if (! to_byte_substr(prog)) {
6b54ddc5 2563 NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
7e0d5ad7
KW
2564 }
2565 }
2566 must = prog->anchored_substr;
2567 }
33b8afdf
JH
2568 back_max = back_min = prog->anchored_offset;
2569 } else {
7e0d5ad7
KW
2570 if (utf8_target) {
2571 if (! prog->float_utf8) {
2572 to_utf8_substr(prog);
2573 }
2574 must = prog->float_utf8;
2575 }
2576 else {
2577 if (! prog->float_substr) {
2578 if (! to_byte_substr(prog)) {
6b54ddc5 2579 NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
7e0d5ad7
KW
2580 }
2581 }
2582 must = prog->float_substr;
2583 }
33b8afdf
JH
2584 back_max = prog->float_max_offset;
2585 back_min = prog->float_min_offset;
2586 }
1de06328 2587
1de06328
YO
2588 if (back_min<0) {
2589 last = strend;
2590 } else {
2591 last = HOP3c(strend, /* Cannot start after this */
2592 -(I32)(CHR_SVLEN(must)
2593 - (SvTAIL(must) != 0) + back_min), strbeg);
2594 }
9d9163fb 2595 if (s > reginfo->strbeg)
6eb5f6b9
JH
2596 last1 = HOPc(s, -1);
2597 else
2598 last1 = s - 1; /* bogus */
2599
a0288114 2600 /* XXXX check_substr already used to find "s", can optimize if
6eb5f6b9
JH
2601 check_substr==must. */
2602 scream_pos = -1;
2603 dontbother = end_shift;
2604 strend = HOPc(strend, -dontbother);
2605 while ( (s <= last) &&
c33e64f0 2606 (s = fbm_instr((unsigned char*)HOP3(s, back_min, (back_min<0 ? strbeg : strend)),
9041c2e3 2607 (unsigned char*)strend, must,
c33e64f0 2608 multiline ? FBMrf_MULTILINE : 0)) ) {
a3621e74 2609 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH
2610 if (HOPc(s, -back_max) > last1) {
2611 last1 = HOPc(s, -back_min);
2612 s = HOPc(s, -back_max);
2613 }
2614 else {
9d9163fb
DM
2615 char * const t = (last1 >= reginfo->strbeg)
2616 ? HOPc(last1, 1) : last1 + 1;
6eb5f6b9
JH
2617
2618 last1 = HOPc(s, -back_min);
52657f30 2619 s = t;
6eb5f6b9 2620 }
f2ed9b32 2621 if (utf8_target) {
6eb5f6b9 2622 while (s <= last1) {
02d5137b 2623 if (regtry(reginfo, &s))
6eb5f6b9 2624 goto got_it;
7016d6eb
DM
2625 if (s >= last1) {
2626 s++; /* to break out of outer loop */
2627 break;
2628 }
2629 s += UTF8SKIP(s);
6eb5f6b9
JH
2630 }
2631 }
2632 else {
2633 while (s <= last1) {
02d5137b 2634 if (regtry(reginfo, &s))
6eb5f6b9
JH
2635 goto got_it;
2636 s++;
2637 }
2638 }
2639 }
ab3bbdeb 2640 DEBUG_EXECUTE_r(if (!did_match) {
f2ed9b32 2641 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
ab3bbdeb
YO
2642 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
2643 PerlIO_printf(Perl_debug_log, "Did not find %s substr %s%s...\n",
33b8afdf 2644 ((must == prog->anchored_substr || must == prog->anchored_utf8)
bf93d4cc 2645 ? "anchored" : "floating"),
ab3bbdeb
YO
2646 quoted, RE_SV_TAIL(must));
2647 });
6eb5f6b9
JH
2648 goto phooey;
2649 }
f8fc2ecf 2650 else if ( (c = progi->regstclass) ) {
f14c76ed 2651 if (minlen) {
f8fc2ecf 2652 const OPCODE op = OP(progi->regstclass);
66e933ab 2653 /* don't bother with what can't match */
786e8c11 2654 if (PL_regkind[op] != EXACT && op != CANY && PL_regkind[op] != TRIE)
f14c76ed
RGS
2655 strend = HOPc(strend, -(minlen - 1));
2656 }
a3621e74 2657 DEBUG_EXECUTE_r({
be8e71aa 2658 SV * const prop = sv_newmortal();
32fc9b6a 2659 regprop(prog, prop, c);
0df25f3d 2660 {
f2ed9b32 2661 RE_PV_QUOTED_DECL(quoted,utf8_target,PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb 2662 s,strend-s,60);
0df25f3d 2663 PerlIO_printf(Perl_debug_log,
1c8f8eb1 2664 "Matching stclass %.*s against %s (%d bytes)\n",
e4f74956 2665 (int)SvCUR(prop), SvPVX_const(prop),
ab3bbdeb 2666 quoted, (int)(strend - s));
0df25f3d 2667 }
ffc61ed2 2668 });
f9176b44 2669 if (find_byclass(prog, c, s, strend, reginfo))
6eb5f6b9 2670 goto got_it;
07be1b83 2671 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass... [regexec_flags]\n"));
d6a28714
JH
2672 }
2673 else {
2674 dontbother = 0;
a0714e2c 2675 if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
33b8afdf 2676 /* Trim the end. */
6af40bd7 2677 char *last= NULL;
33b8afdf 2678 SV* float_real;
c33e64f0
FC
2679 STRLEN len;
2680 const char *little;
33b8afdf 2681
7e0d5ad7
KW
2682 if (utf8_target) {
2683 if (! prog->float_utf8) {
2684 to_utf8_substr(prog);
2685 }
2686 float_real = prog->float_utf8;
2687 }
2688 else {
2689 if (! prog->float_substr) {
2690 if (! to_byte_substr(prog)) {
6b54ddc5 2691 NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
7e0d5ad7
KW
2692 }
2693 }
2694 float_real = prog->float_substr;
2695 }
d6a28714 2696
c33e64f0
FC
2697 little = SvPV_const(float_real, len);
2698 if (SvTAIL(float_real)) {
7f18ad16
KW
2699 /* This means that float_real contains an artificial \n on
2700 * the end due to the presence of something like this:
2701 * /foo$/ where we can match both "foo" and "foo\n" at the
2702 * end of the string. So we have to compare the end of the
2703 * string first against the float_real without the \n and
2704 * then against the full float_real with the string. We
2705 * have to watch out for cases where the string might be
2706 * smaller than the float_real or the float_real without
2707 * the \n. */
1a13b075
YO
2708 char *checkpos= strend - len;
2709 DEBUG_OPTIMISE_r(
2710 PerlIO_printf(Perl_debug_log,
2711 "%sChecking for float_real.%s\n",
2712 PL_colors[4], PL_colors[5]));
2713 if (checkpos + 1 < strbeg) {
7f18ad16
KW
2714 /* can't match, even if we remove the trailing \n
2715 * string is too short to match */
1a13b075
YO
2716 DEBUG_EXECUTE_r(
2717 PerlIO_printf(Perl_debug_log,
2718 "%sString shorter than required trailing substring, cannot match.%s\n",
2719 PL_colors[4], PL_colors[5]));
2720 goto phooey;
2721 } else if (memEQ(checkpos + 1, little, len - 1)) {
7f18ad16
KW
2722 /* can match, the end of the string matches without the
2723 * "\n" */
1a13b075
YO
2724 last = checkpos + 1;
2725 } else if (checkpos < strbeg) {
7f18ad16
KW
2726 /* cant match, string is too short when the "\n" is
2727 * included */
1a13b075
YO
2728 DEBUG_EXECUTE_r(
2729 PerlIO_printf(Perl_debug_log,
2730 "%sString does not contain required trailing substring, cannot match.%s\n",
2731 PL_colors[4], PL_colors[5]));
2732 goto phooey;
2733 } else if (!multiline) {
7f18ad16
KW
2734 /* non multiline match, so compare with the "\n" at the
2735 * end of the string */
1a13b075
YO
2736 if (memEQ(checkpos, little, len)) {
2737 last= checkpos;
2738 } else {
2739 DEBUG_EXECUTE_r(
2740 PerlIO_printf(Perl_debug_log,
2741 "%sString does not contain required trailing substring, cannot match.%s\n",
2742 PL_colors[4], PL_colors[5]));
2743 goto phooey;
2744 }
2745 } else {
7f18ad16
KW
2746 /* multiline match, so we have to search for a place
2747 * where the full string is located */
d6a28714 2748 goto find_last;
1a13b075 2749 }
c33e64f0 2750 } else {
d6a28714 2751 find_last:
9041c2e3 2752 if (len)
d6a28714 2753 last = rninstr(s, strend, little, little + len);
b8c5462f 2754 else
a0288114 2755 last = strend; /* matching "$" */
b8c5462f 2756 }
6af40bd7 2757 if (!last) {
7f18ad16
KW
2758 /* at one point this block contained a comment which was
2759 * probably incorrect, which said that this was a "should not
2760 * happen" case. Even if it was true when it was written I am
2761 * pretty sure it is not anymore, so I have removed the comment
2762 * and replaced it with this one. Yves */
6bda09f9
YO
2763 DEBUG_EXECUTE_r(
2764 PerlIO_printf(Perl_debug_log,
6af40bd7
YO
2765 "String does not contain required substring, cannot match.\n"
2766 ));
2767 goto phooey;
bf93d4cc 2768 }
d6a28714
JH
2769 dontbother = strend - last + prog->float_min_offset;
2770 }
2771 if (minlen && (dontbother < minlen))
2772 dontbother = minlen - 1;
2773 strend -= dontbother; /* this one's always in bytes! */
2774 /* We don't know much -- general case. */
f2ed9b32 2775 if (utf8_target) {
d6a28714 2776 for (;;) {
02d5137b 2777 if (regtry(reginfo, &s))
d6a28714
JH
2778 goto got_it;
2779 if (s >= strend)
2780 break;
b8c5462f 2781 s += UTF8SKIP(s);
d6a28714
JH
2782 };
2783 }
2784 else {
2785 do {
02d5137b 2786 if (regtry(reginfo, &s))
d6a28714
JH
2787 goto got_it;
2788 } while (s++ < strend);
2789 }
2790 }
2791
2792 /* Failure. */
2793 goto phooey;
2794
2795got_it:
495f47a5
DM
2796 DEBUG_BUFFERS_r(
2797 if (swap)
2798 PerlIO_printf(Perl_debug_log,
2799 "rex=0x%"UVxf" freeing offs: 0x%"UVxf"\n",
2800 PTR2UV(prog),
2801 PTR2UV(swap)
2802 );
2803 );
e9105d30 2804 Safefree(swap);
d6a28714 2805
bf2039a9
DM
2806 /* clean up; this will trigger destructors that will free all slabs
2807 * above the current one, and cleanup the regmatch_info_aux
2808 * and regmatch_info_aux_eval sructs */
8adc0f72 2809
006f26b2
DM
2810 LEAVE_SCOPE(oldsave);
2811
5daac39c
NC
2812 if (RXp_PAREN_NAMES(prog))
2813 (void)hv_iterinit(RXp_PAREN_NAMES(prog));
d6a28714 2814
0254aed9
DM
2815 RX_MATCH_UTF8_set(rx, utf8_target);
2816
d6a28714 2817 /* make sure $`, $&, $', and $digit will work later */
60165aa4
DM
2818 if ( !(flags & REXEC_NOT_FIRST) )
2819 Perl_reg_set_capture_string(aTHX_ rx,
2820 strbeg, reginfo->strend,
2821 sv, flags, utf8_target);
9041c2e3 2822
d6a28714
JH
2823 return 1;
2824
2825phooey:
a3621e74 2826 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
e4584336 2827 PL_colors[4], PL_colors[5]));
8adc0f72 2828
bf2039a9
DM
2829 /* clean up; this will trigger destructors that will free all slabs
2830 * above the current one, and cleanup the regmatch_info_aux
2831 * and regmatch_info_aux_eval sructs */
8adc0f72 2832
006f26b2
DM
2833 LEAVE_SCOPE(oldsave);
2834
e9105d30 2835 if (swap) {
c74340f9 2836 /* we failed :-( roll it back */
495f47a5
DM
2837 DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
2838 "rex=0x%"UVxf" rolling back offs: freeing=0x%"UVxf" restoring=0x%"UVxf"\n",
2839 PTR2UV(prog),
2840 PTR2UV(prog->offs),
2841 PTR2UV(swap)
2842 ));
e9105d30
GG
2843 Safefree(prog->offs);
2844 prog->offs = swap;
2845 }
d6a28714
JH
2846 return 0;
2847}
2848
6bda09f9 2849
b3d298be 2850/* Set which rex is pointed to by PL_reg_curpm, handling ref counting.
ec43f78b
DM
2851 * Do inc before dec, in case old and new rex are the same */
2852#define SET_reg_curpm(Re2) \
bf2039a9 2853 if (reginfo->info_aux_eval) { \
ec43f78b
DM
2854 (void)ReREFCNT_inc(Re2); \
2855 ReREFCNT_dec(PM_GETRE(PL_reg_curpm)); \
2856 PM_SETRE((PL_reg_curpm), (Re2)); \
2857 }
2858
2859
d6a28714
JH
2860/*
2861 - regtry - try match at specific point
2862 */
2863STATIC I32 /* 0 failure, 1 success */
f73aaa43 2864S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
d6a28714 2865{
97aff369 2866 dVAR;
d6a28714 2867 CHECKPOINT lastcp;
288b8c02 2868 REGEXP *const rx = reginfo->prog;
8d919b0a 2869 regexp *const prog = ReANY(rx);
f73aaa43 2870 I32 result;
f8fc2ecf 2871 RXi_GET_DECL(prog,progi);
a3621e74 2872 GET_RE_DEBUG_FLAGS_DECL;
7918f24d
NC
2873
2874 PERL_ARGS_ASSERT_REGTRY;
2875
24b23f37 2876 reginfo->cutpoint=NULL;
d6a28714 2877
9d9163fb 2878 prog->offs[0].start = *startposp - reginfo->strbeg;
d6a28714 2879 prog->lastparen = 0;
03994de8 2880 prog->lastcloseparen = 0;
d6a28714
JH
2881
2882 /* XXXX What this code is doing here?!!! There should be no need
b93070ed 2883 to do this again and again, prog->lastparen should take care of
3dd2943c 2884 this! --ilya*/
dafc8851
JH
2885
2886 /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2887 * Actually, the code in regcppop() (which Ilya may be meaning by
b93070ed 2888 * prog->lastparen), is not needed at all by the test suite
225593e1
DM
2889 * (op/regexp, op/pat, op/split), but that code is needed otherwise
2890 * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
2891 * Meanwhile, this code *is* needed for the
daf18116
JH
2892 * above-mentioned test suite tests to succeed. The common theme
2893 * on those tests seems to be returning null fields from matches.
225593e1 2894 * --jhi updated by dapm */
dafc8851 2895#if 1
d6a28714 2896 if (prog->nparens) {
b93070ed 2897 regexp_paren_pair *pp = prog->offs;
eb578fdb 2898 I32 i;
b93070ed 2899 for (i = prog->nparens; i > (I32)prog->lastparen; i--) {
f0ab9afb
NC
2900 ++pp;
2901 pp->start = -1;
2902 pp->end = -1;
d6a28714
JH
2903 }
2904 }
dafc8851 2905#endif
02db2b7b 2906 REGCP_SET(lastcp);
f73aaa43
DM
2907 result = regmatch(reginfo, *startposp, progi->program + 1);
2908 if (result != -1) {
2909 prog->offs[0].end = result;
d6a28714
JH
2910 return 1;
2911 }
24b23f37 2912 if (reginfo->cutpoint)
f73aaa43 2913 *startposp= reginfo->cutpoint;
02db2b7b 2914 REGCP_UNWIND(lastcp);
d6a28714
JH
2915 return 0;
2916}
2917
02db2b7b 2918
8ba1375e
MJD
2919#define sayYES goto yes
2920#define sayNO goto no
262b90c4 2921#define sayNO_SILENT goto no_silent
8ba1375e 2922
f9f4320a
YO
2923/* we dont use STMT_START/END here because it leads to
2924 "unreachable code" warnings, which are bogus, but distracting. */
2925#define CACHEsayNO \
c476f425 2926 if (ST.cache_mask) \
2ac8ff4b 2927 reginfo->info_aux->poscache[ST.cache_offset] |= ST.cache_mask; \
f9f4320a 2928 sayNO
3298f257 2929
a3621e74 2930/* this is used to determine how far from the left messages like
265c4333
YO
2931 'failed...' are printed. It should be set such that messages
2932 are inline with the regop output that created them.
a3621e74 2933*/
265c4333 2934#define REPORT_CODE_OFF 32
a3621e74
YO
2935
2936
40a82448
DM
2937#define CHRTEST_UNINIT -1001 /* c1/c2 haven't been calculated yet */
2938#define CHRTEST_VOID -1000 /* the c1/c2 "next char" test should be skipped */
79a2a0e8
KW
2939#define CHRTEST_NOT_A_CP_1 -999
2940#define CHRTEST_NOT_A_CP_2 -998
9e137952 2941
5d9a96ca
DM
2942/* grab a new slab and return the first slot in it */
2943
2944STATIC regmatch_state *
2945S_push_slab(pTHX)
2946{
a35a87e7 2947#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC
2948 dMY_CXT;
2949#endif
5d9a96ca
DM
2950 regmatch_slab *s = PL_regmatch_slab->next;
2951 if (!s) {
2952 Newx(s, 1, regmatch_slab);
2953 s->prev = PL_regmatch_slab;
2954 s->next = NULL;
2955 PL_regmatch_slab->next = s;
2956 }
2957 PL_regmatch_slab = s;
86545054 2958 return SLAB_FIRST(s);
5d9a96ca 2959}
5b47454d 2960
95b24440 2961
40a82448
DM
2962/* push a new state then goto it */
2963
4d5016e5
DM
2964#define PUSH_STATE_GOTO(state, node, input) \
2965 pushinput = input; \
40a82448
DM
2966 scan = node; \
2967 st->resume_state = state; \
2968 goto push_state;
2969
2970/* push a new state with success backtracking, then goto it */
2971
4d5016e5
DM
2972#define PUSH_YES_STATE_GOTO(state, node, input) \
2973 pushinput = input; \
40a82448
DM
2974 scan = node; \
2975 st->resume_state = state; \
2976 goto push_yes_state;
2977
aa283a38 2978
aa283a38 2979
4d5016e5 2980
d6a28714 2981/*
95b24440 2982
bf1f174e
DM
2983regmatch() - main matching routine
2984
2985This is basically one big switch statement in a loop. We execute an op,
2986set 'next' to point the next op, and continue. If we come to a point which
2987we may need to backtrack to on failure such as (A|B|C), we push a
2988backtrack state onto the backtrack stack. On failure, we pop the top
2989state, and re-enter the loop at the state indicated. If there are no more
2990states to pop, we return failure.
2991
2992Sometimes we also need to backtrack on success; for example /A+/, where
2993after successfully matching one A, we need to go back and try to
2994match another one; similarly for lookahead assertions: if the assertion
2995completes successfully, we backtrack to the state just before the assertion
2996and then carry on. In these cases, the pushed state is marked as
2997'backtrack on success too'. This marking is in fact done by a chain of
2998pointers, each pointing to the previous 'yes' state. On success, we pop to
2999the nearest yes state, discarding any intermediate failure-only states.
3000Sometimes a yes state is pushed just to force some cleanup code to be
3001called at the end of a successful match or submatch; e.g. (??{$re}) uses
3002it to free the inner regex.
3003
3004Note that failure backtracking rewinds the cursor position, while
3005success backtracking leaves it alone.
3006
3007A pattern is complete when the END op is executed, while a subpattern
3008such as (?=foo) is complete when the SUCCESS op is executed. Both of these
3009ops trigger the "pop to last yes state if any, otherwise return true"
3010behaviour.
3011
3012A common convention in this function is to use A and B to refer to the two
3013subpatterns (or to the first nodes thereof) in patterns like /A*B/: so A is
3014the subpattern to be matched possibly multiple times, while B is the entire
3015rest of the pattern. Variable and state names reflect this convention.
3016
3017The states in the main switch are the union of ops and failure/success of
3018substates associated with with that op. For example, IFMATCH is the op
3019that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
3020'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
3021successfully matched A and IFMATCH_A_fail is a state saying that we have
3022just failed to match A. Resume states always come in pairs. The backtrack
3023state we push is marked as 'IFMATCH_A', but when that is popped, we resume
3024at IFMATCH_A or IFMATCH_A_fail, depending on whether we are backtracking
3025on success or failure.
3026
3027The struct that holds a backtracking state is actually a big union, with
3028one variant for each major type of op. The variable st points to the
3029top-most backtrack struct. To make the code clearer, within each
3030block of code we #define ST to alias the relevant union.
3031
3032Here's a concrete example of a (vastly oversimplified) IFMATCH
3033implementation:
3034
3035 switch (state) {
3036 ....
3037
3038#define ST st->u.ifmatch
3039
3040 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
3041 ST.foo = ...; // some state we wish to save
95b24440 3042 ...
bf1f174e
DM
3043 // push a yes backtrack state with a resume value of
3044 // IFMATCH_A/IFMATCH_A_fail, then continue execution at the
3045 // first node of A:
4d5016e5 3046 PUSH_YES_STATE_GOTO(IFMATCH_A, A, newinput);
bf1f174e
DM
3047 // NOTREACHED
3048
3049 case IFMATCH_A: // we have successfully executed A; now continue with B
3050 next = B;
3051 bar = ST.foo; // do something with the preserved value
3052 break;
3053
3054 case IFMATCH_A_fail: // A failed, so the assertion failed
3055 ...; // do some housekeeping, then ...
3056 sayNO; // propagate the failure
3057
3058#undef ST
95b24440 3059
bf1f174e
DM
3060 ...
3061 }
95b24440 3062
bf1f174e
DM
3063For any old-timers reading this who are familiar with the old recursive
3064approach, the code above is equivalent to:
95b24440 3065
bf1f174e
DM
3066 case IFMATCH: // we are executing the IFMATCH op, (?=A)B
3067 {
3068 int foo = ...
95b24440 3069 ...
bf1f174e
DM
3070 if (regmatch(A)) {
3071 next = B;
3072 bar = foo;
3073 break;
95b24440 3074 }
bf1f174e
DM
3075 ...; // do some housekeeping, then ...
3076 sayNO; // propagate the failure
95b24440 3077 }
bf1f174e
DM
3078
3079The topmost backtrack state, pointed to by st, is usually free. If you
3080want to claim it, populate any ST.foo fields in it with values you wish to
3081save, then do one of
3082
4d5016e5
DM
3083 PUSH_STATE_GOTO(resume_state, node, newinput);
3084 PUSH_YES_STATE_GOTO(resume_state, node, newinput);
bf1f174e
DM
3085
3086which sets that backtrack state's resume value to 'resume_state', pushes a
3087new free entry to the top of the backtrack stack, then goes to 'node'.
3088On backtracking, the free slot is popped, and the saved state becomes the
3089new free state. An ST.foo field in this new top state can be temporarily
3090accessed to retrieve values, but once the main loop is re-entered, it
3091becomes available for reuse.
3092
3093Note that the depth of the backtrack stack constantly increases during the
3094left-to-right execution of the pattern, rather than going up and down with
3095the pattern nesting. For example the stack is at its maximum at Z at the
3096end of the pattern, rather than at X in the following:
3097
3098 /(((X)+)+)+....(Y)+....Z/
3099
3100The only exceptions to this are lookahead/behind assertions and the cut,
3101(?>A), which pop all the backtrack states associated with A before
3102continuing.
3103
486ec47a 3104Backtrack state structs are allocated in slabs of about 4K in size.
bf1f174e
DM
3105PL_regmatch_state and st always point to the currently active state,
3106and PL_regmatch_slab points to the slab currently containing
3107PL_regmatch_state. The first time regmatch() is called, the first slab is
3108allocated, and is never freed until interpreter destruction. When the slab
3109is full, a new one is allocated and chained to the end. At exit from
3110regmatch(), slabs allocated since entry are freed.
3111
3112*/
95b24440 3113
40a82448 3114
5bc10b2c 3115#define DEBUG_STATE_pp(pp) \
265c4333 3116 DEBUG_STATE_r({ \
f2ed9b32 3117 DUMP_EXEC_POS(locinput, scan, utf8_target); \
5bc10b2c 3118 PerlIO_printf(Perl_debug_log, \
5d458dd8 3119 " %*s"pp" %s%s%s%s%s\n", \
5bc10b2c 3120 depth*2, "", \
13d6edb4 3121 PL_reg_name[st->resume_state], \
5d458dd8
YO
3122 ((st==yes_state||st==mark_state) ? "[" : ""), \
3123 ((st==yes_state) ? "Y" : ""), \
3124 ((st==mark_state) ? "M" : ""), \
3125 ((st==yes_state||st==mark_state) ? "]" : "") \
3126 ); \
265c4333 3127 });
5bc10b2c 3128
40a82448 3129
3dab1dad 3130#define REG_NODE_NUM(x) ((x) ? (int)((x)-prog) : -1)
95b24440 3131
3df15adc 3132#ifdef DEBUGGING
5bc10b2c 3133
ab3bbdeb 3134STATIC void
f2ed9b32 3135S_debug_start_match(pTHX_ const REGEXP *prog, const bool utf8_target,
ab3bbdeb
YO
3136 const char *start, const char *end, const char *blurb)
3137{
efd26800 3138 const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
7918f24d
NC
3139
3140 PERL_ARGS_ASSERT_DEBUG_START_MATCH;
3141
ab3bbdeb
YO
3142 if (!PL_colorset)
3143 reginitcolors();
3144 {
3145 RE_PV_QUOTED_DECL(s0, utf8_pat, PERL_DEBUG_PAD_ZERO(0),
d2c6dc5e 3146 RX_PRECOMP_const(prog), RX_PRELEN(prog), 60);
ab3bbdeb 3147
f2ed9b32 3148 RE_PV_QUOTED_DECL(s1, utf8_target, PERL_DEBUG_PAD_ZERO(1),
ab3bbdeb
YO
3149 start, end - start, 60);
3150
3151 PerlIO_printf(Perl_debug_log,
3152 "%s%s REx%s %s against %s\n",
3153 PL_colors[4], blurb, PL_colors[5], s0, s1);
3154
f2ed9b32 3155 if (utf8_target||utf8_pat)
1de06328
YO
3156 PerlIO_printf(Perl_debug_log, "UTF-8 %s%s%s...\n",
3157 utf8_pat ? "pattern" : "",
f2ed9b32
KW
3158 utf8_pat && utf8_target ? " and " : "",
3159 utf8_target ? "string" : ""
ab3bbdeb
YO
3160 );
3161 }
3162}
3df15adc
YO
3163
3164STATIC void
786e8c11
YO
3165S_dump_exec_pos(pTHX_ const char *locinput,
3166 const regnode *scan,
3167 const char *loc_regeol,
3168 const char *loc_bostr,
3169 const char *loc_reg_starttry,
f2ed9b32 3170 const bool utf8_target)
07be1b83 3171{
786e8c11 3172 const int docolor = *PL_colors[0] || *PL_colors[2] || *PL_colors[4];
07be1b83 3173 const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
786e8c11 3174 int l = (loc_regeol - locinput) > taill ? taill : (loc_regeol - locinput);
07be1b83
YO
3175 /* The part of the string before starttry has one color
3176 (pref0_len chars), between starttry and current
3177 position another one (pref_len - pref0_len chars),
3178 after the current position the third one.
3179 We assume that pref0_len <= pref_len, otherwise we
3180 decrease pref0_len. */
786e8c11
YO
3181 int pref_len = (locinput - loc_bostr) > (5 + taill) - l
3182 ? (5 + taill) - l : locinput - loc_bostr;
07be1b83
YO
3183 int pref0_len;
3184
7918f24d
NC
3185 PERL_ARGS_ASSERT_DUMP_EXEC_POS;
3186
f2ed9b32 3187 while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
07be1b83 3188 pref_len++;
786e8c11
YO
3189 pref0_len = pref_len - (locinput - loc_reg_starttry);
3190 if (l + pref_len < (5 + taill) && l < loc_regeol - locinput)
3191 l = ( loc_regeol - locinput > (5 + taill) - pref_len
3192 ? (5 + taill) - pref_len : loc_regeol - locinput);
f2ed9b32 3193 while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
07be1b83
YO
3194 l--;
3195 if (pref0_len < 0)
3196 pref0_len = 0;
3197 if (pref0_len > pref_len)
3198 pref0_len = pref_len;
3199 {
f2ed9b32 3200 const int is_uni = (utf8_target && OP(scan) != CANY) ? 1 : 0;
0df25f3d 3201
ab3bbdeb 3202 RE_PV_COLOR_DECL(s0,len0,is_uni,PERL_DEBUG_PAD(0),
1de06328 3203 (locinput - pref_len),pref0_len, 60, 4, 5);
0df25f3d 3204
ab3bbdeb 3205 RE_PV_COLOR_DECL(s1,len1,is_uni,PERL_DEBUG_PAD(1),
3df15adc 3206 (locinput - pref_len + pref0_len),
1de06328 3207 pref_len - pref0_len, 60, 2, 3);
0df25f3d 3208
ab3bbdeb 3209 RE_PV_COLOR_DECL(s2,len2,is_uni,PERL_DEBUG_PAD(2),
1de06328 3210 locinput, loc_regeol - locinput, 10, 0, 1);
0df25f3d 3211
1de06328 3212 const STRLEN tlen=len0+len1+len2;
3df15adc 3213 PerlIO_printf(Perl_debug_log,
ab3bbdeb 3214 "%4"IVdf" <%.*s%.*s%s%.*s>%*s|",
786e8c11 3215 (IV)(locinput - loc_bostr),
07be1b83 3216 len0, s0,
07be1b83 3217 len1, s1,
07be1b83 3218 (docolor ? "" : "> <"),
07be1b83 3219 len2, s2,
f9f4320a 3220 (int)(tlen > 19 ? 0 : 19 - tlen),
07be1b83
YO
3221 "");
3222 }
3223}
3df15adc 3224
07be1b83
YO
3225#endif
3226
0a4db386
YO
3227/* reg_check_named_buff_matched()
3228 * Checks to see if a named buffer has matched. The data array of
3229 * buffer numbers corresponding to the buffer is expected to reside
3230 * in the regexp->data->data array in the slot stored in the ARG() of
3231 * node involved. Note that this routine doesn't actually care about the
3232 * name, that information is not preserved from compilation to execution.
3233 * Returns the index of the leftmost defined buffer with the given name
3234 * or 0 if non of the buffers matched.
3235 */
3236STATIC I32
7918f24d
NC
3237S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
3238{
0a4db386 3239 I32 n;
f8fc2ecf 3240 RXi_GET_DECL(rex,rexi);
ad64d0ec 3241 SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
0a4db386 3242 I32 *nums=(I32*)SvPVX(sv_dat);
7918f24d
NC
3243
3244 PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
3245
0a4db386 3246 for ( n=0; n<SvIVX(sv_dat); n++ ) {
b93070ed
DM
3247 if ((I32)rex->lastparen >= nums[n] &&
3248 rex->offs[nums[n]].end != -1)
0a4db386
YO
3249 {
3250 return nums[n];
3251 }
3252 }
3253 return 0;
3254}
3255
2f554ef7 3256
c74f6de9 3257static bool
984e6dd1 3258S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
aed7b151 3259 U8* c1_utf8, int *c2p, U8* c2_utf8, regmatch_info *reginfo)
c74f6de9 3260{
79a2a0e8
KW
3261 /* This function determines if there are one or two characters that match
3262 * the first character of the passed-in EXACTish node <text_node>, and if
3263 * so, returns them in the passed-in pointers.
c74f6de9 3264 *
79a2a0e8
KW
3265 * If it determines that no possible character in the target string can
3266 * match, it returns FALSE; otherwise TRUE. (The FALSE situation occurs if
3267 * the first character in <text_node> requires UTF-8 to represent, and the
3268 * target string isn't in UTF-8.)
c74f6de9 3269 *
79a2a0e8
KW
3270 * If there are more than two characters that could match the beginning of
3271 * <text_node>, or if more context is required to determine a match or not,
3272 * it sets both *<c1p> and *<c2p> to CHRTEST_VOID.
3273 *
3274 * The motiviation behind this function is to allow the caller to set up
3275 * tight loops for matching. If <text_node> is of type EXACT, there is
3276 * only one possible character that can match its first character, and so
3277 * the situation is quite simple. But things get much more complicated if
3278 * folding is involved. It may be that the first character of an EXACTFish
3279 * node doesn't participate in any possible fold, e.g., punctuation, so it
3280 * can be matched only by itself. The vast majority of characters that are
3281 * in folds match just two things, their lower and upper-case equivalents.
3282 * But not all are like that; some have multiple possible matches, or match
3283 * sequences of more than one character. This function sorts all that out.
3284 *
3285 * Consider the patterns A*B or A*?B where A and B are arbitrary. In a
3286 * loop of trying to match A*, we know we can't exit where the thing
3287 * following it isn't a B. And something can't be a B unless it is the
3288 * beginning of B. By putting a quick test for that beginning in a tight
3289 * loop, we can rule out things that can't possibly be B without having to
3290 * break out of the loop, thus avoiding work. Similarly, if A is a single
3291 * character, we can make a tight loop matching A*, using the outputs of
3292 * this function.
3293 *
3294 * If the target string to match isn't in UTF-8, and there aren't
3295 * complications which require CHRTEST_VOID, *<c1p> and *<c2p> are set to
3296 * the one or two possible octets (which are characters in this situation)
3297 * that can match. In all cases, if there is only one character that can
3298 * match, *<c1p> and *<c2p> will be identical.
3299 *
3300 * If the target string is in UTF-8, the buffers pointed to by <c1_utf8>
3301 * and <c2_utf8> will contain the one or two UTF-8 sequences of bytes that
3302 * can match the beginning of <text_node>. They should be declared with at
3303 * least length UTF8_MAXBYTES+1. (If the target string isn't in UTF-8, it is
3304 * undefined what these contain.) If one or both of the buffers are
3305 * invariant under UTF-8, *<c1p>, and *<c2p> will also be set to the
3306 * corresponding invariant. If variant, the corresponding *<c1p> and/or
3307 * *<c2p> will be set to a negative number(s) that shouldn't match any code
3308 * point (unless inappropriately coerced to unsigned). *<c1p> will equal
3309 * *<c2p> if and only if <c1_utf8> and <c2_utf8> are the same. */
c74f6de9 3310
ba44c216 3311 const bool utf8_target = reginfo->is_utf8_target;
79a2a0e8 3312
ddb0d839
KW
3313 UV c1 = CHRTEST_NOT_A_CP_1;
3314 UV c2 = CHRTEST_NOT_A_CP_2;
79a2a0e8 3315 bool use_chrtest_void = FALSE;
aed7b151 3316 const bool is_utf8_pat = reginfo->is_utf8_pat;
79a2a0e8
KW
3317
3318 /* Used when we have both utf8 input and utf8 output, to avoid converting
3319 * to/from code points */
3320 bool utf8_has_been_setup = FALSE;
3321
c74f6de9
KW
3322 dVAR;
3323
b4291290 3324 U8 *pat = (U8*)STRING(text_node);
c74f6de9 3325
79a2a0e8
KW
3326 if (OP(text_node) == EXACT) {
3327
3328 /* In an exact node, only one thing can be matched, that first
3329 * character. If both the pat and the target are UTF-8, we can just
3330 * copy the input to the output, avoiding finding the code point of
3331 * that character */
984e6dd1 3332 if (!is_utf8_pat) {
79a2a0e8
KW
3333 c2 = c1 = *pat;
3334 }
3335 else if (utf8_target) {
3336 Copy(pat, c1_utf8, UTF8SKIP(pat), U8);
3337 Copy(pat, c2_utf8, UTF8SKIP(pat), U8);
3338 utf8_has_been_setup = TRUE;
3339 }
3340 else {
3341 c2 = c1 = valid_utf8_to_uvchr(pat, NULL);
c74f6de9 3342 }
79a2a0e8
KW
3343 }
3344 else /* an EXACTFish node */
984e6dd1 3345 if ((is_utf8_pat
79a2a0e8
KW
3346 && is_MULTI_CHAR_FOLD_utf8_safe(pat,
3347 pat + STR_LEN(text_node)))
984e6dd1 3348 || (!is_utf8_pat
79a2a0e8
KW
3349 && is_MULTI_CHAR_FOLD_latin1_safe(pat,
3350 pat + STR_LEN(text_node))))
3351 {
3352 /* Multi-character folds require more context to sort out. Also
3353 * PL_utf8_foldclosures used below doesn't handle them, so have to be
3354 * handled outside this routine */
3355 use_chrtest_void = TRUE;
3356 }
3357 else { /* an EXACTFish node which doesn't begin with a multi-char fold */
984e6dd1 3358 c1 = is_utf8_pat ? valid_utf8_to_uvchr(pat, NULL) : *pat;
79a2a0e8
KW
3359 if (c1 > 256) {
3360 /* Load the folds hash, if not already done */
3361 SV** listp;
3362 if (! PL_utf8_foldclosures) {
3363 if (! PL_utf8_tofold) {
3364 U8 dummy[UTF8_MAXBYTES+1];
3365
3366 /* Force loading this by folding an above-Latin1 char */
3367 to_utf8_fold((U8*) HYPHEN_UTF8, dummy, NULL);
3368 assert(PL_utf8_tofold); /* Verify that worked */
3369 }
3370 PL_utf8_foldclosures = _swash_inversion_hash(PL_utf8_tofold);
3371 }
3372
3373 /* The fold closures data structure is a hash with the keys being
3374 * the UTF-8 of every character that is folded to, like 'k', and
3375 * the values each an array of all code points that fold to its
3376 * key. e.g. [ 'k', 'K', KELVIN_SIGN ]. Multi-character folds are
3377 * not included */
3378 if ((! (listp = hv_fetch(PL_utf8_foldclosures,
3379 (char *) pat,
3380 UTF8SKIP(pat),
3381 FALSE))))
3382 {
3383 /* Not found in the hash, therefore there are no folds
3384 * containing it, so there is only a single character that
3385 * could match */
3386 c2 = c1;
3387 }
3388 else { /* Does participate in folds */
3389 AV* list = (AV*) *listp;
3390 if (av_len(list) != 1) {
3391
3392 /* If there aren't exactly two folds to this, it is outside
3393 * the scope of this function */
3394 use_chrtest_void = TRUE;
3395 }
3396 else { /* There are two. Get them */
3397 SV** c_p = av_fetch(list, 0, FALSE);
3398 if (c_p == NULL) {
3399 Perl_croak(aTHX_ "panic: invalid PL_utf8_foldclosures structure");
3400 }
3401 c1 = SvUV(*c_p);
3402
3403 c_p = av_fetch(list, 1, FALSE);
3404 if (c_p == NULL) {
3405 Perl_croak(aTHX_ "panic: invalid PL_utf8_foldclosures structure");
3406 }
3407 c2 = SvUV(*c_p);
3408
3409 /* Folds that cross the 255/256 boundary are forbidden if
3410 * EXACTFL, or EXACTFA and one is ASCIII. Since the
3411 * pattern character is above 256, and its only other match
3412 * is below 256, the only legal match will be to itself.
3413 * We have thrown away the original, so have to compute
3414 * which is the one above 255 */
3415 if ((c1 < 256) != (c2 < 256)) {
3416 if (OP(text_node) == EXACTFL
3417 || (OP(text_node) == EXACTFA
3418 && (isASCII(c1) || isASCII(c2))))
3419 {
3420 if (c1 < 256) {
3421 c1 = c2;
3422 }
3423 else {
3424 c2 = c1;
3425 }
3426 }
3427 }
3428 }
3429 }
3430 }
3431 else /* Here, c1 is < 255 */
3432 if (utf8_target
3433 && HAS_NONLATIN1_FOLD_CLOSURE(c1)
3434 && OP(text_node) != EXACTFL
3435 && (OP(text_node) != EXACTFA || ! isASCII(c1)))
c74f6de9
KW
3436 {
3437 /* Here, there could be something above Latin1 in the target which
79a2a0e8
KW
3438 * folds to this character in the pattern. All such cases except
3439 * LATIN SMALL LETTER Y WITH DIAERESIS have more than two characters
3440 * involved in their folds, so are outside the scope of this
3441 * function */
3442 if (UNLIKELY(c1 == LATIN_SMALL_LETTER_Y_WITH_DIAERESIS)) {
3443 c2 = LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS;
3444 }
3445 else {
3446 use_chrtest_void = TRUE;
3447 }
c74f6de9
KW
3448 }
3449 else { /* Here nothing above Latin1 can fold to the pattern character */
3450 switch (OP(text_node)) {
3451
3452 case EXACTFL: /* /l rules */
79a2a0e8 3453 c2 = PL_fold_locale[c1];
c74f6de9
KW
3454 break;
3455
3456 case EXACTF:
3457 if (! utf8_target) { /* /d rules */
79a2a0e8 3458 c2 = PL_fold[c1];
c74f6de9
KW
3459 break;
3460 }
3461 /* FALLTHROUGH */
3462 /* /u rules for all these. This happens to work for
79a2a0e8 3463 * EXACTFA as nothing in Latin1 folds to ASCII */
c74f6de9
KW
3464 case EXACTFA:
3465 case EXACTFU_TRICKYFOLD:
79a2a0e8 3466 case EXACTFU_SS:
c74f6de9 3467 case EXACTFU:
79a2a0e8 3468 c2 = PL_fold_latin1[c1];
c74f6de9
KW
3469 break;
3470
878531d3
KW
3471 default:
3472 Perl_croak(aTHX_ "panic: Unexpected op %u", OP(text_node));
3473 assert(0); /* NOTREACHED */
c74f6de9
KW
3474 }
3475 }
3476 }
79a2a0e8
KW
3477
3478 /* Here have figured things out. Set up the returns */
3479 if (use_chrtest_void) {
3480 *c2p = *c1p = CHRTEST_VOID;
3481 }
3482 else if (utf8_target) {
3483 if (! utf8_has_been_setup) { /* Don't have the utf8; must get it */
3484 uvchr_to_utf8(c1_utf8, c1);
3485 uvchr_to_utf8(c2_utf8, c2);
c74f6de9 3486 }
c74f6de9 3487
79a2a0e8
KW
3488 /* Invariants are stored in both the utf8 and byte outputs; Use
3489 * negative numbers otherwise for the byte ones. Make sure that the
3490 * byte ones are the same iff the utf8 ones are the same */
3491 *c1p = (UTF8_IS_INVARIANT(*c1_utf8)) ? *c1_utf8 : CHRTEST_NOT_A_CP_1;
3492 *c2p = (UTF8_IS_INVARIANT(*c2_utf8))
3493 ? *c2_utf8
3494 : (c1 == c2)
3495 ? CHRTEST_NOT_A_CP_1
3496 : CHRTEST_NOT_A_CP_2;
3497 }
3498 else if (c1 > 255) {
3499 if (c2 > 255) { /* both possibilities are above what a non-utf8 string
3500 can represent */
3501 return FALSE;
3502 }
c74f6de9 3503
79a2a0e8
KW
3504 *c1p = *c2p = c2; /* c2 is the only representable value */
3505 }
3506 else { /* c1 is representable; see about c2 */
3507 *c1p = c1;
3508 *c2p = (c2 < 256) ? c2 : c1;
c74f6de9 3509 }
2f554ef7 3510
c74f6de9
KW
3511 return TRUE;
3512}
2f554ef7 3513
f73aaa43
DM
3514/* returns -1 on failure, $+[0] on success */
3515STATIC I32
3516S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
d6a28714 3517{
a35a87e7 3518#if PERL_VERSION < 9 && !defined(PERL_CORE)
54df2634
NC
3519 dMY_CXT;
3520#endif
27da23d5 3521 dVAR;
ba44c216 3522 const bool utf8_target = reginfo->is_utf8_target;
4ad0818d 3523 const U32 uniflags = UTF8_ALLOW_DEFAULT;
288b8c02 3524 REGEXP *rex_sv = reginfo->prog;
8d919b0a 3525 regexp *rex = ReANY(rex_sv);
f8fc2ecf 3526 RXi_GET_DECL(rex,rexi);
5d9a96ca 3527 /* the current state. This is a cached copy of PL_regmatch_state */
eb578fdb 3528 regmatch_state *st;
5d9a96ca 3529 /* cache heavy used fields of st in registers */
eb578fdb
KW
3530 regnode *scan;
3531 regnode *next;
3532 U32 n = 0; /* general value; init to avoid compiler warning */
3533 I32 ln = 0; /* len or last; init to avoid compiler warning */
d60de1d1 3534 char *locinput = startpos;
4d5016e5 3535 char *pushinput; /* where to continue after a PUSH */
eb578fdb 3536 I32 nextchr; /* is always set to UCHARAT(locinput) */
24d3c4a9 3537
b69b0499 3538 bool result = 0; /* return value of S_regmatch */
24d3c4a9