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