This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Re: regexp trie fails compile on VMS
[perl5.git] / regexec.c
CommitLineData
a0d0e21e
LW
1/* regexec.c
2 */
3
4/*
5 * "One Ring to rule them all, One Ring to find them..."
6 */
7
61296642
DM
8/* This file contains functions for executing a regular expression. See
9 * also regcomp.c which funnily enough, contains functions for compiling
166f8a29 10 * a regular expression.
e4a054ea
DM
11 *
12 * This file is also copied at build time to ext/re/re_exec.c, where
13 * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
14 * This causes the main functions to be compiled under new names and with
15 * debugging support added, which makes "use re 'debug'" work.
16
166f8a29
DM
17 */
18
a687059c
LW
19/* NOTE: this is derived from Henry Spencer's regexp code, and should not
20 * confused with the original package (see point 3 below). Thanks, Henry!
21 */
22
23/* Additional note: this code is very heavily munged from Henry's version
24 * in places. In some spots I've traded clarity for efficiency, so don't
25 * blame Henry for some of the lack of readability.
26 */
27
e50aee73
AD
28/* The names of the functions have been changed from regcomp and
29 * regexec to pregcomp and pregexec in order to avoid conflicts
30 * with the POSIX routines of the same names.
31*/
32
b9d5759e
AD
33#ifdef PERL_EXT_RE_BUILD
34/* need to replace pregcomp et al, so enable that */
35# ifndef PERL_IN_XSUB_RE
36# define PERL_IN_XSUB_RE
37# endif
38/* need access to debugger hooks */
cad2e5aa 39# if defined(PERL_EXT_RE_DEBUG) && !defined(DEBUGGING)
b9d5759e
AD
40# define DEBUGGING
41# endif
42#endif
43
44#ifdef PERL_IN_XSUB_RE
d06ea78c 45/* We *really* need to overwrite these symbols: */
56953603
IZ
46# define Perl_regexec_flags my_regexec
47# define Perl_regdump my_regdump
48# define Perl_regprop my_regprop
cad2e5aa 49# define Perl_re_intuit_start my_re_intuit_start
d06ea78c
GS
50/* *These* symbols are masked to allow static link. */
51# define Perl_pregexec my_pregexec
9041c2e3 52# define Perl_reginitcolors my_reginitcolors
490a3f88 53# define Perl_regclass_swash my_regclass_swash
c5be433b
GS
54
55# define PERL_NO_GET_CONTEXT
9041c2e3 56#endif
56953603 57
f0fcb552 58/*SUPPRESS 112*/
a687059c 59/*
e50aee73 60 * pregcomp and pregexec -- regsub and regerror are not used in perl
a687059c
LW
61 *
62 * Copyright (c) 1986 by University of Toronto.
63 * Written by Henry Spencer. Not derived from licensed software.
64 *
65 * Permission is granted to anyone to use this software for any
66 * purpose on any computer system, and to redistribute it freely,
67 * subject to the following restrictions:
68 *
69 * 1. The author is not responsible for the consequences of use of
70 * this software, no matter how awful, even if they arise
71 * from defects in it.
72 *
73 * 2. The origin of this software must not be misrepresented, either
74 * by explicit claim or by omission.
75 *
76 * 3. Altered versions must be plainly marked as such, and must not
77 * be misrepresented as being the original software.
78 *
79 **** Alterations to Henry's code are...
80 ****
4bb101f2 81 **** Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
f2b990bf 82 **** 2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
a687059c 83 ****
9ef589d8
LW
84 **** You may distribute under the terms of either the GNU General Public
85 **** License or the Artistic License, as specified in the README file.
a687059c
LW
86 *
87 * Beware that some of this code is subtly aware of the way operator
88 * precedence is structured in regular expressions. Serious changes in
89 * regular-expression syntax might require a total rethink.
90 */
91#include "EXTERN.h"
864dbfa3 92#define PERL_IN_REGEXEC_C
a687059c 93#include "perl.h"
0f5d15d6 94
a687059c
LW
95#include "regcomp.h"
96
c277df42
IZ
97#define RF_tainted 1 /* tainted information used? */
98#define RF_warned 2 /* warned about big count? */
ce862d02 99#define RF_evaled 4 /* Did an EVAL with setting? */
a0ed51b3
LW
100#define RF_utf8 8 /* String contains multibyte chars? */
101
eb160463 102#define UTF ((PL_reg_flags & RF_utf8) != 0)
ce862d02
IZ
103
104#define RS_init 1 /* eval environment created */
105#define RS_set 2 /* replsv value is set */
c277df42 106
a687059c
LW
107#ifndef STATIC
108#define STATIC static
109#endif
110
ba7b4546 111#define REGINCLASS(p,c) (ANYOF_FLAGS(p) ? reginclass(p,c,0,0) : ANYOF_BITMAP_TEST(p,*(c)))
7d3e948e 112
c277df42
IZ
113/*
114 * Forwards.
115 */
116
33b8afdf 117#define CHR_SVLEN(sv) (do_utf8 ? sv_len_utf8(sv) : SvCUR(sv))
53c4c00c 118#define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
a0ed51b3 119
dfe13c55
GS
120#define reghop_c(pos,off) ((char*)reghop((U8*)pos, off))
121#define reghopmaybe_c(pos,off) ((char*)reghopmaybe((U8*)pos, off))
53c4c00c
JH
122#define HOP(pos,off) (PL_reg_match_utf8 ? reghop((U8*)pos, off) : (U8*)(pos + off))
123#define HOPMAYBE(pos,off) (PL_reg_match_utf8 ? reghopmaybe((U8*)pos, off) : (U8*)(pos + off))
dfe13c55
GS
124#define HOPc(pos,off) ((char*)HOP(pos,off))
125#define HOPMAYBEc(pos,off) ((char*)HOPMAYBE(pos,off))
a0d0e21e 126
efb30f32 127#define HOPBACK(pos, off) ( \
e54858b0 128 (PL_reg_match_utf8) \
efb30f32
HS
129 ? reghopmaybe((U8*)pos, -off) \
130 : (pos - off >= PL_bostr) \
131 ? (U8*)(pos - off) \
132 : (U8*)NULL \
133)
134#define HOPBACKc(pos, off) (char*)HOPBACK(pos, off)
135
1aa99e6b
IH
136#define reghop3_c(pos,off,lim) ((char*)reghop3((U8*)pos, off, (U8*)lim))
137#define reghopmaybe3_c(pos,off,lim) ((char*)reghopmaybe3((U8*)pos, off, (U8*)lim))
53c4c00c
JH
138#define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
139#define HOPMAYBE3(pos,off,lim) (PL_reg_match_utf8 ? reghopmaybe3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
1aa99e6b
IH
140#define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
141#define HOPMAYBE3c(pos,off,lim) ((char*)HOPMAYBE3(pos,off,lim))
142
bfed75c6 143#define LOAD_UTF8_CHARCLASS(a,b) STMT_START { if (!CAT2(PL_utf8_,a)) { ENTER; save_re_context(); (void)CAT2(is_utf8_, a)((const U8*)b); LEAVE; } } STMT_END
51371543 144
5f80c4cf 145/* for use after a quantifier and before an EXACT-like node -- japhy */
e2d8ce26
JP
146#define JUMPABLE(rn) ( \
147 OP(rn) == OPEN || OP(rn) == CLOSE || OP(rn) == EVAL || \
cca55fe3
JP
148 OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
149 OP(rn) == PLUS || OP(rn) == MINMOD || \
150 (PL_regkind[(U8)OP(rn)] == CURLY && ARG1(rn) > 0) \
e2d8ce26
JP
151)
152
cca55fe3
JP
153#define HAS_TEXT(rn) ( \
154 PL_regkind[(U8)OP(rn)] == EXACT || PL_regkind[(U8)OP(rn)] == REF \
155)
e2d8ce26 156
a84d97b6
HS
157/*
158 Search for mandatory following text node; for lookahead, the text must
159 follow but for lookbehind (rn->flags != 0) we skip to the next step.
160*/
cca55fe3 161#define FIND_NEXT_IMPT(rn) STMT_START { \
e2d8ce26 162 while (JUMPABLE(rn)) \
a84d97b6 163 if (OP(rn) == SUSPEND || PL_regkind[(U8)OP(rn)] == CURLY) \
e2d8ce26 164 rn = NEXTOPER(NEXTOPER(rn)); \
cca55fe3
JP
165 else if (OP(rn) == PLUS) \
166 rn = NEXTOPER(rn); \
a84d97b6
HS
167 else if (OP(rn) == IFMATCH) \
168 rn = (rn->flags == 0) ? NEXTOPER(NEXTOPER(rn)) : rn + ARG(rn); \
e2d8ce26 169 else rn += NEXT_OFF(rn); \
5f80c4cf 170} STMT_END
74750237 171
acfe0abc 172static void restore_pos(pTHX_ void *arg);
51371543 173
76e3520e 174STATIC CHECKPOINT
cea2e8a9 175S_regcppush(pTHX_ I32 parenfloor)
a0d0e21e 176{
3280af22 177 int retval = PL_savestack_ix;
b1ce53c5
JH
178#define REGCP_PAREN_ELEMS 4
179 int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
a0d0e21e
LW
180 int p;
181
e49a9654
IH
182 if (paren_elems_to_push < 0)
183 Perl_croak(aTHX_ "panic: paren_elems_to_push < 0");
184
a01268b5 185#define REGCP_OTHER_ELEMS 6
4b3c1a47 186 SSGROW(paren_elems_to_push + REGCP_OTHER_ELEMS);
3280af22 187 for (p = PL_regsize; p > parenfloor; p--) {
b1ce53c5 188/* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
cf93c79d
IZ
189 SSPUSHINT(PL_regendp[p]);
190 SSPUSHINT(PL_regstartp[p]);
3280af22 191 SSPUSHPTR(PL_reg_start_tmp[p]);
a0d0e21e
LW
192 SSPUSHINT(p);
193 }
b1ce53c5 194/* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
3280af22
NIS
195 SSPUSHINT(PL_regsize);
196 SSPUSHINT(*PL_reglastparen);
a01268b5 197 SSPUSHINT(*PL_reglastcloseparen);
3280af22 198 SSPUSHPTR(PL_reginput);
41123dfd
JH
199#define REGCP_FRAME_ELEMS 2
200/* REGCP_FRAME_ELEMS are part of the REGCP_OTHER_ELEMS and
201 * are needed for the regexp context stack bookkeeping. */
202 SSPUSHINT(paren_elems_to_push + REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
b1ce53c5 203 SSPUSHINT(SAVEt_REGCONTEXT); /* Magic cookie. */
41123dfd 204
a0d0e21e
LW
205 return retval;
206}
207
c277df42 208/* These are needed since we do not localize EVAL nodes: */
a3621e74 209# define REGCP_SET(cp) DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, \
faccc32b 210 " Setting an EVAL scope, savestack=%"IVdf"\n", \
02db2b7b 211 (IV)PL_savestack_ix)); cp = PL_savestack_ix
c3464db5 212
a3621e74 213# define REGCP_UNWIND(cp) DEBUG_EXECUTE_r(cp != PL_savestack_ix ? \
c3464db5 214 PerlIO_printf(Perl_debug_log, \
faccc32b 215 " Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
02db2b7b 216 (IV)(cp), (IV)PL_savestack_ix) : 0); regcpblow(cp)
c277df42 217
76e3520e 218STATIC char *
cea2e8a9 219S_regcppop(pTHX)
a0d0e21e 220{
b1ce53c5 221 I32 i;
a0d0e21e
LW
222 U32 paren = 0;
223 char *input;
cf93c79d 224 I32 tmps;
b1ce53c5 225
a3621e74
YO
226 GET_RE_DEBUG_FLAGS_DECL;
227
b1ce53c5 228 /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
a0d0e21e 229 i = SSPOPINT;
b1ce53c5
JH
230 assert(i == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
231 i = SSPOPINT; /* Parentheses elements to pop. */
a0d0e21e 232 input = (char *) SSPOPPTR;
a01268b5 233 *PL_reglastcloseparen = SSPOPINT;
3280af22
NIS
234 *PL_reglastparen = SSPOPINT;
235 PL_regsize = SSPOPINT;
b1ce53c5
JH
236
237 /* Now restore the parentheses context. */
41123dfd
JH
238 for (i -= (REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
239 i > 0; i -= REGCP_PAREN_ELEMS) {
a0d0e21e 240 paren = (U32)SSPOPINT;
3280af22 241 PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
cf93c79d
IZ
242 PL_regstartp[paren] = SSPOPINT;
243 tmps = SSPOPINT;
3280af22
NIS
244 if (paren <= *PL_reglastparen)
245 PL_regendp[paren] = tmps;
a3621e74 246 DEBUG_EXECUTE_r(
c3464db5 247 PerlIO_printf(Perl_debug_log,
b900a521 248 " restoring \\%"UVuf" to %"IVdf"(%"IVdf")..%"IVdf"%s\n",
9041c2e3 249 (UV)paren, (IV)PL_regstartp[paren],
b900a521 250 (IV)(PL_reg_start_tmp[paren] - PL_bostr),
9041c2e3 251 (IV)PL_regendp[paren],
3280af22 252 (paren > *PL_reglastparen ? "(no)" : ""));
c277df42 253 );
a0d0e21e 254 }
a3621e74 255 DEBUG_EXECUTE_r(
eb160463 256 if ((I32)(*PL_reglastparen + 1) <= PL_regnpar) {
c3464db5 257 PerlIO_printf(Perl_debug_log,
faccc32b
JH
258 " restoring \\%"IVdf"..\\%"IVdf" to undef\n",
259 (IV)(*PL_reglastparen + 1), (IV)PL_regnpar);
c277df42
IZ
260 }
261 );
daf18116 262#if 1
dafc8851
JH
263 /* It would seem that the similar code in regtry()
264 * already takes care of this, and in fact it is in
265 * a better location to since this code can #if 0-ed out
266 * but the code in regtry() is needed or otherwise tests
267 * requiring null fields (pat.t#187 and split.t#{13,14}
daf18116
JH
268 * (as of patchlevel 7877) will fail. Then again,
269 * this code seems to be necessary or otherwise
270 * building DynaLoader will fail:
271 * "Error: '*' not in typemap in DynaLoader.xs, line 164"
272 * --jhi */
eb160463
GS
273 for (paren = *PL_reglastparen + 1; (I32)paren <= PL_regnpar; paren++) {
274 if ((I32)paren > PL_regsize)
cf93c79d
IZ
275 PL_regstartp[paren] = -1;
276 PL_regendp[paren] = -1;
a0d0e21e 277 }
dafc8851 278#endif
a0d0e21e
LW
279 return input;
280}
281
0f5d15d6 282STATIC char *
cea2e8a9 283S_regcp_set_to(pTHX_ I32 ss)
0f5d15d6
IZ
284{
285 I32 tmp = PL_savestack_ix;
286
287 PL_savestack_ix = ss;
288 regcppop();
289 PL_savestack_ix = tmp;
942e002e 290 return Nullch;
0f5d15d6
IZ
291}
292
293typedef struct re_cc_state
294{
295 I32 ss;
296 regnode *node;
297 struct re_cc_state *prev;
298 CURCUR *cc;
299 regexp *re;
300} re_cc_state;
301
02db2b7b 302#define regcpblow(cp) LEAVE_SCOPE(cp) /* Ignores regcppush()ed data. */
a0d0e21e 303
29d1e993
HS
304#define TRYPAREN(paren, n, input) { \
305 if (paren) { \
306 if (n) { \
307 PL_regstartp[paren] = HOPc(input, -1) - PL_bostr; \
308 PL_regendp[paren] = input - PL_bostr; \
309 } \
310 else \
311 PL_regendp[paren] = -1; \
312 } \
313 if (regmatch(next)) \
314 sayYES; \
315 if (paren && n) \
316 PL_regendp[paren] = -1; \
317}
318
319
a687059c 320/*
e50aee73 321 * pregexec and friends
a687059c
LW
322 */
323
324/*
c277df42 325 - pregexec - match a regexp against a string
a687059c 326 */
c277df42 327I32
864dbfa3 328Perl_pregexec(pTHX_ register regexp *prog, char *stringarg, register char *strend,
c3464db5 329 char *strbeg, I32 minend, SV *screamer, U32 nosave)
c277df42
IZ
330/* strend: pointer to null at end of string */
331/* strbeg: real beginning of string */
332/* minend: end of match must be >=minend after stringarg. */
333/* nosave: For optimizations. */
334{
335 return
9041c2e3 336 regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
c277df42
IZ
337 nosave ? 0 : REXEC_COPY_STR);
338}
0f5d15d6
IZ
339
340STATIC void
cea2e8a9 341S_cache_re(pTHX_ regexp *prog)
0f5d15d6
IZ
342{
343 PL_regprecomp = prog->precomp; /* Needed for FAIL. */
344#ifdef DEBUGGING
345 PL_regprogram = prog->program;
346#endif
347 PL_regnpar = prog->nparens;
9041c2e3
NIS
348 PL_regdata = prog->data;
349 PL_reg_re = prog;
0f5d15d6 350}
22e551b9 351
9041c2e3 352/*
cad2e5aa
JH
353 * Need to implement the following flags for reg_anch:
354 *
355 * USE_INTUIT_NOML - Useful to call re_intuit_start() first
356 * USE_INTUIT_ML
357 * INTUIT_AUTORITATIVE_NOML - Can trust a positive answer
358 * INTUIT_AUTORITATIVE_ML
359 * INTUIT_ONCE_NOML - Intuit can match in one location only.
360 * INTUIT_ONCE_ML
361 *
362 * Another flag for this function: SECOND_TIME (so that float substrs
363 * with giant delta may be not rechecked).
364 */
365
366/* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
367
2c2d71f5 368/* If SCREAM, then SvPVX(sv) should be compatible with strpos and strend.
cad2e5aa
JH
369 Otherwise, only SvCUR(sv) is used to get strbeg. */
370
371/* XXXX We assume that strpos is strbeg unless sv. */
372
6eb5f6b9
JH
373/* XXXX Some places assume that there is a fixed substring.
374 An update may be needed if optimizer marks as "INTUITable"
375 RExen without fixed substrings. Similarly, it is assumed that
376 lengths of all the strings are no more than minlen, thus they
377 cannot come from lookahead.
378 (Or minlen should take into account lookahead.) */
379
2c2d71f5
JH
380/* A failure to find a constant substring means that there is no need to make
381 an expensive call to REx engine, thus we celebrate a failure. Similarly,
382 finding a substring too deep into the string means that less calls to
30944b6d
IZ
383 regtry() should be needed.
384
385 REx compiler's optimizer found 4 possible hints:
386 a) Anchored substring;
387 b) Fixed substring;
388 c) Whether we are anchored (beginning-of-line or \G);
389 d) First node (of those at offset 0) which may distingush positions;
6eb5f6b9 390 We use a)b)d) and multiline-part of c), and try to find a position in the
30944b6d
IZ
391 string which does not contradict any of them.
392 */
2c2d71f5 393
6eb5f6b9
JH
394/* Most of decisions we do here should have been done at compile time.
395 The nodes of the REx which we used for the search should have been
396 deleted from the finite automaton. */
397
cad2e5aa
JH
398char *
399Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
400 char *strend, U32 flags, re_scream_pos_data *data)
401{
b7953727 402 register I32 start_shift = 0;
cad2e5aa 403 /* Should be nonnegative! */
b7953727 404 register I32 end_shift = 0;
2c2d71f5
JH
405 register char *s;
406 register SV *check;
a1933d95 407 char *strbeg;
cad2e5aa 408 char *t;
33b8afdf 409 int do_utf8 = sv ? SvUTF8(sv) : 0; /* if no sv we have to assume bytes */
cad2e5aa 410 I32 ml_anch;
6eb5f6b9 411 register char *other_last = Nullch; /* other substr checked before this */
b7953727 412 char *check_at = Nullch; /* check substr found at this pos */
7fba1cd6 413 I32 multiline = prog->reganch & PMf_MULTILINE;
30944b6d
IZ
414#ifdef DEBUGGING
415 char *i_strpos = strpos;
ce333219 416 SV *dsv = PERL_DEBUG_PAD_ZERO(0);
30944b6d 417#endif
a3621e74
YO
418
419 GET_RE_DEBUG_FLAGS_DECL;
420
a30b2f1f 421 RX_MATCH_UTF8_set(prog,do_utf8);
cad2e5aa 422
b8d68ded 423 if (prog->reganch & ROPT_UTF8) {
a3621e74 424 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
b8d68ded
JH
425 "UTF-8 regex...\n"));
426 PL_reg_flags |= RF_utf8;
427 }
428
a3621e74 429 DEBUG_EXECUTE_r({
b8d68ded 430 char *s = PL_reg_match_utf8 ?
c728cb41
JH
431 sv_uni_display(dsv, sv, 60, UNI_DISPLAY_REGEX) :
432 strpos;
b8d68ded
JH
433 int len = PL_reg_match_utf8 ?
434 strlen(s) : strend - strpos;
2a782b5b
JH
435 if (!PL_colorset)
436 reginitcolors();
b8d68ded 437 if (PL_reg_match_utf8)
a3621e74 438 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
b8d68ded 439 "UTF-8 target...\n"));
2a782b5b
JH
440 PerlIO_printf(Perl_debug_log,
441 "%sGuessing start of match, REx%s `%s%.60s%s%s' against `%s%.*s%s%s'...\n",
442 PL_colors[4],PL_colors[5],PL_colors[0],
443 prog->precomp,
444 PL_colors[1],
445 (strlen(prog->precomp) > 60 ? "..." : ""),
446 PL_colors[0],
447 (int)(len > 60 ? 60 : len),
448 s, PL_colors[1],
449 (len > 60 ? "..." : "")
450 );
451 });
cad2e5aa 452
c344f387
JH
453 /* CHR_DIST() would be more correct here but it makes things slow. */
454 if (prog->minlen > strend - strpos) {
a3621e74 455 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584 456 "String too short... [re_intuit_start]\n"));
cad2e5aa 457 goto fail;
2c2d71f5 458 }
a1933d95 459 strbeg = (sv && SvPOK(sv)) ? strend - SvCUR(sv) : strpos;
1aa99e6b 460 PL_regeol = strend;
33b8afdf
JH
461 if (do_utf8) {
462 if (!prog->check_utf8 && prog->check_substr)
463 to_utf8_substr(prog);
464 check = prog->check_utf8;
465 } else {
466 if (!prog->check_substr && prog->check_utf8)
467 to_byte_substr(prog);
468 check = prog->check_substr;
469 }
470 if (check == &PL_sv_undef) {
a3621e74 471 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf
JH
472 "Non-utf string cannot match utf check string\n"));
473 goto fail;
474 }
2c2d71f5 475 if (prog->reganch & ROPT_ANCH) { /* Match at beg-of-str or after \n */
cad2e5aa
JH
476 ml_anch = !( (prog->reganch & ROPT_ANCH_SINGLE)
477 || ( (prog->reganch & ROPT_ANCH_BOL)
7fba1cd6 478 && !multiline ) ); /* Check after \n? */
cad2e5aa 479
7e25d62c
JH
480 if (!ml_anch) {
481 if ( !(prog->reganch & (ROPT_ANCH_GPOS /* Checked by the caller */
482 | ROPT_IMPLICIT)) /* not a real BOL */
483 /* SvCUR is not set on references: SvRV and SvPVX overlap */
484 && sv && !SvROK(sv)
485 && (strpos != strbeg)) {
a3621e74 486 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
7e25d62c
JH
487 goto fail;
488 }
489 if (prog->check_offset_min == prog->check_offset_max &&
cce850e4 490 !(prog->reganch & ROPT_CANY_SEEN)) {
2c2d71f5 491 /* Substring at constant offset from beg-of-str... */
cad2e5aa
JH
492 I32 slen;
493
1aa99e6b 494 s = HOP3c(strpos, prog->check_offset_min, strend);
653099ff
GS
495 if (SvTAIL(check)) {
496 slen = SvCUR(check); /* >= 1 */
cad2e5aa 497
9041c2e3 498 if ( strend - s > slen || strend - s < slen - 1
2c2d71f5 499 || (strend - s == slen && strend[-1] != '\n')) {
a3621e74 500 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
2c2d71f5 501 goto fail_finish;
cad2e5aa
JH
502 }
503 /* Now should match s[0..slen-2] */
504 slen--;
653099ff 505 if (slen && (*SvPVX(check) != *s
cad2e5aa 506 || (slen > 1
653099ff 507 && memNE(SvPVX(check), s, slen)))) {
2c2d71f5 508 report_neq:
a3621e74 509 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
2c2d71f5
JH
510 goto fail_finish;
511 }
cad2e5aa 512 }
653099ff
GS
513 else if (*SvPVX(check) != *s
514 || ((slen = SvCUR(check)) > 1
515 && memNE(SvPVX(check), s, slen)))
2c2d71f5
JH
516 goto report_neq;
517 goto success_at_start;
7e25d62c 518 }
cad2e5aa 519 }
2c2d71f5 520 /* Match is anchored, but substr is not anchored wrt beg-of-str. */
cad2e5aa 521 s = strpos;
2c2d71f5 522 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
2c2d71f5 523 end_shift = prog->minlen - start_shift -
653099ff 524 CHR_SVLEN(check) + (SvTAIL(check) != 0);
2c2d71f5 525 if (!ml_anch) {
653099ff
GS
526 I32 end = prog->check_offset_max + CHR_SVLEN(check)
527 - (SvTAIL(check) != 0);
1aa99e6b 528 I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
2c2d71f5
JH
529
530 if (end_shift < eshift)
531 end_shift = eshift;
532 }
cad2e5aa 533 }
2c2d71f5 534 else { /* Can match at random position */
cad2e5aa
JH
535 ml_anch = 0;
536 s = strpos;
2c2d71f5
JH
537 start_shift = prog->check_offset_min; /* okay to underestimate on CC */
538 /* Should be nonnegative! */
539 end_shift = prog->minlen - start_shift -
653099ff 540 CHR_SVLEN(check) + (SvTAIL(check) != 0);
cad2e5aa
JH
541 }
542
2c2d71f5 543#ifdef DEBUGGING /* 7/99: reports of failure (with the older version) */
0033605d 544 if (end_shift < 0)
6bbae5e6 545 Perl_croak(aTHX_ "panic: end_shift");
2c2d71f5
JH
546#endif
547
2c2d71f5
JH
548 restart:
549 /* Find a possible match in the region s..strend by looking for
550 the "check" substring in the region corrected by start/end_shift. */
cad2e5aa 551 if (flags & REXEC_SCREAM) {
cad2e5aa
JH
552 I32 p = -1; /* Internal iterator of scream. */
553 I32 *pp = data ? data->scream_pos : &p;
554
2c2d71f5
JH
555 if (PL_screamfirst[BmRARE(check)] >= 0
556 || ( BmRARE(check) == '\n'
557 && (BmPREVIOUS(check) == SvCUR(check) - 1)
558 && SvTAIL(check) ))
9041c2e3 559 s = screaminstr(sv, check,
2c2d71f5 560 start_shift + (s - strbeg), end_shift, pp, 0);
cad2e5aa 561 else
2c2d71f5 562 goto fail_finish;
4addbd3b
HS
563 /* we may be pointing at the wrong string */
564 if (s && RX_MATCH_COPIED(prog))
7ef91622 565 s = strbeg + (s - SvPVX(sv));
cad2e5aa
JH
566 if (data)
567 *data->scream_olds = s;
568 }
f33976b4 569 else if (prog->reganch & ROPT_CANY_SEEN)
3baa4c62
JH
570 s = fbm_instr((U8*)(s + start_shift),
571 (U8*)(strend - end_shift),
7fba1cd6 572 check, multiline ? FBMrf_MULTILINE : 0);
cad2e5aa 573 else
1aa99e6b
IH
574 s = fbm_instr(HOP3(s, start_shift, strend),
575 HOP3(strend, -end_shift, strbeg),
7fba1cd6 576 check, multiline ? FBMrf_MULTILINE : 0);
cad2e5aa
JH
577
578 /* Update the count-of-usability, remove useless subpatterns,
579 unshift s. */
2c2d71f5 580
a3621e74 581 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s %s substr `%s%.*s%s'%s%s",
2c2d71f5 582 (s ? "Found" : "Did not find"),
33b8afdf 583 (check == (do_utf8 ? prog->anchored_utf8 : prog->anchored_substr) ? "anchored" : "floating"),
2c2d71f5 584 PL_colors[0],
7b0972df
JH
585 (int)(SvCUR(check) - (SvTAIL(check)!=0)),
586 SvPVX(check),
2c2d71f5
JH
587 PL_colors[1], (SvTAIL(check) ? "$" : ""),
588 (s ? " at offset " : "...\n") ) );
589
590 if (!s)
591 goto fail_finish;
592
6eb5f6b9
JH
593 check_at = s;
594
2c2d71f5 595 /* Finish the diagnostic message */
a3621e74 596 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
2c2d71f5
JH
597
598 /* Got a candidate. Check MBOL anchoring, and the *other* substr.
599 Start with the other substr.
600 XXXX no SCREAM optimization yet - and a very coarse implementation
601 XXXX /ttx+/ results in anchored=`ttx', floating=`x'. floating will
602 *always* match. Probably should be marked during compile...
603 Probably it is right to do no SCREAM here...
604 */
605
33b8afdf 606 if (do_utf8 ? (prog->float_utf8 && prog->anchored_utf8) : (prog->float_substr && prog->anchored_substr)) {
30944b6d 607 /* Take into account the "other" substring. */
2c2d71f5
JH
608 /* XXXX May be hopelessly wrong for UTF... */
609 if (!other_last)
6eb5f6b9 610 other_last = strpos;
33b8afdf 611 if (check == (do_utf8 ? prog->float_utf8 : prog->float_substr)) {
30944b6d
IZ
612 do_other_anchored:
613 {
1aa99e6b 614 char *last = HOP3c(s, -start_shift, strbeg), *last1, *last2;
2c2d71f5 615 char *s1 = s;
33b8afdf 616 SV* must;
2c2d71f5 617
2c2d71f5
JH
618 t = s - prog->check_offset_max;
619 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
1d86a7f9 620 && (!do_utf8
1aa99e6b 621 || ((t = reghopmaybe3_c(s, -(prog->check_offset_max), strpos))
2c2d71f5 622 && t > strpos)))
30944b6d 623 /* EMPTY */;
2c2d71f5
JH
624 else
625 t = strpos;
1aa99e6b 626 t = HOP3c(t, prog->anchored_offset, strend);
6eb5f6b9
JH
627 if (t < other_last) /* These positions already checked */
628 t = other_last;
1aa99e6b 629 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
2c2d71f5
JH
630 if (last < last1)
631 last1 = last;
632 /* XXXX It is not documented what units *_offsets are in. Assume bytes. */
633 /* On end-of-str: see comment below. */
33b8afdf
JH
634 must = do_utf8 ? prog->anchored_utf8 : prog->anchored_substr;
635 if (must == &PL_sv_undef) {
636 s = (char*)NULL;
a3621e74 637 DEBUG_EXECUTE_r(must = prog->anchored_utf8); /* for debug */
33b8afdf
JH
638 }
639 else
640 s = fbm_instr(
641 (unsigned char*)t,
642 HOP3(HOP3(last1, prog->anchored_offset, strend)
643 + SvCUR(must), -(SvTAIL(must)!=0), strbeg),
644 must,
7fba1cd6 645 multiline ? FBMrf_MULTILINE : 0
33b8afdf 646 );
a3621e74 647 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
1aa99e6b 648 "%s anchored substr `%s%.*s%s'%s",
2c2d71f5
JH
649 (s ? "Found" : "Contradicts"),
650 PL_colors[0],
33b8afdf
JH
651 (int)(SvCUR(must)
652 - (SvTAIL(must)!=0)),
653 SvPVX(must),
654 PL_colors[1], (SvTAIL(must) ? "$" : "")));
2c2d71f5
JH
655 if (!s) {
656 if (last1 >= last2) {
a3621e74 657 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5
JH
658 ", giving up...\n"));
659 goto fail_finish;
660 }
a3621e74 661 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2c2d71f5 662 ", trying floating at offset %ld...\n",
1aa99e6b
IH
663 (long)(HOP3c(s1, 1, strend) - i_strpos)));
664 other_last = HOP3c(last1, prog->anchored_offset+1, strend);
665 s = HOP3c(last, 1, strend);
2c2d71f5
JH
666 goto restart;
667 }
668 else {
a3621e74 669 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
30944b6d 670 (long)(s - i_strpos)));
1aa99e6b
IH
671 t = HOP3c(s, -prog->anchored_offset, strbeg);
672 other_last = HOP3c(s, 1, strend);
30944b6d 673 s = s1;
2c2d71f5
JH
674 if (t == strpos)
675 goto try_at_start;
2c2d71f5
JH
676 goto try_at_offset;
677 }
30944b6d 678 }
2c2d71f5
JH
679 }
680 else { /* Take into account the floating substring. */
33b8afdf
JH
681 char *last, *last1;
682 char *s1 = s;
683 SV* must;
684
685 t = HOP3c(s, -start_shift, strbeg);
686 last1 = last =
687 HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
688 if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
689 last = HOP3c(t, prog->float_max_offset, strend);
690 s = HOP3c(t, prog->float_min_offset, strend);
691 if (s < other_last)
692 s = other_last;
2c2d71f5 693 /* XXXX It is not documented what units *_offsets are in. Assume bytes. */
33b8afdf
JH
694 must = do_utf8 ? prog->float_utf8 : prog->float_substr;
695 /* fbm_instr() takes into account exact value of end-of-str
696 if the check is SvTAIL(ed). Since false positives are OK,
697 and end-of-str is not later than strend we are OK. */
698 if (must == &PL_sv_undef) {
699 s = (char*)NULL;
a3621e74 700 DEBUG_EXECUTE_r(must = prog->float_utf8); /* for debug message */
33b8afdf
JH
701 }
702 else
2c2d71f5 703 s = fbm_instr((unsigned char*)s,
33b8afdf
JH
704 (unsigned char*)last + SvCUR(must)
705 - (SvTAIL(must)!=0),
7fba1cd6 706 must, multiline ? FBMrf_MULTILINE : 0);
a3621e74 707 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s floating substr `%s%.*s%s'%s",
33b8afdf
JH
708 (s ? "Found" : "Contradicts"),
709 PL_colors[0],
710 (int)(SvCUR(must) - (SvTAIL(must)!=0)),
711 SvPVX(must),
712 PL_colors[1], (SvTAIL(must) ? "$" : "")));
713 if (!s) {
714 if (last1 == last) {
a3621e74 715 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf
JH
716 ", giving up...\n"));
717 goto fail_finish;
2c2d71f5 718 }
a3621e74 719 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
33b8afdf
JH
720 ", trying anchored starting at offset %ld...\n",
721 (long)(s1 + 1 - i_strpos)));
722 other_last = last;
723 s = HOP3c(t, 1, strend);
724 goto restart;
725 }
726 else {
a3621e74 727 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
33b8afdf
JH
728 (long)(s - i_strpos)));
729 other_last = s; /* Fix this later. --Hugo */
730 s = s1;
731 if (t == strpos)
732 goto try_at_start;
733 goto try_at_offset;
734 }
2c2d71f5 735 }
cad2e5aa 736 }
2c2d71f5
JH
737
738 t = s - prog->check_offset_max;
2c2d71f5 739 if (s - strpos > prog->check_offset_max /* signed-corrected t > strpos */
1d86a7f9 740 && (!do_utf8
1aa99e6b
IH
741 || ((t = reghopmaybe3_c(s, -prog->check_offset_max, strpos))
742 && t > strpos))) {
2c2d71f5
JH
743 /* Fixed substring is found far enough so that the match
744 cannot start at strpos. */
745 try_at_offset:
cad2e5aa 746 if (ml_anch && t[-1] != '\n') {
30944b6d
IZ
747 /* Eventually fbm_*() should handle this, but often
748 anchored_offset is not 0, so this check will not be wasted. */
749 /* XXXX In the code below we prefer to look for "^" even in
750 presence of anchored substrings. And we search even
751 beyond the found float position. These pessimizations
752 are historical artefacts only. */
753 find_anchor:
2c2d71f5 754 while (t < strend - prog->minlen) {
cad2e5aa 755 if (*t == '\n') {
4ee3650e 756 if (t < check_at - prog->check_offset_min) {
33b8afdf 757 if (do_utf8 ? prog->anchored_utf8 : prog->anchored_substr) {
4ee3650e
GS
758 /* Since we moved from the found position,
759 we definitely contradict the found anchored
30944b6d
IZ
760 substr. Due to the above check we do not
761 contradict "check" substr.
762 Thus we can arrive here only if check substr
763 is float. Redo checking for "other"=="fixed".
764 */
9041c2e3 765 strpos = t + 1;
a3621e74 766 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
30944b6d
IZ
767 PL_colors[0],PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
768 goto do_other_anchored;
769 }
4ee3650e
GS
770 /* We don't contradict the found floating substring. */
771 /* XXXX Why not check for STCLASS? */
cad2e5aa 772 s = t + 1;
a3621e74 773 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
30944b6d 774 PL_colors[0],PL_colors[1], (long)(s - i_strpos)));
cad2e5aa
JH
775 goto set_useful;
776 }
4ee3650e
GS
777 /* Position contradicts check-string */
778 /* XXXX probably better to look for check-string
779 than for "\n", so one should lower the limit for t? */
a3621e74 780 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
30944b6d 781 PL_colors[0],PL_colors[1], (long)(t + 1 - i_strpos)));
0e41cd87 782 other_last = strpos = s = t + 1;
cad2e5aa
JH
783 goto restart;
784 }
785 t++;
786 }
a3621e74 787 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
2c2d71f5
JH
788 PL_colors[0],PL_colors[1]));
789 goto fail_finish;
cad2e5aa 790 }
f5952150 791 else {
a3621e74 792 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
f5952150
GS
793 PL_colors[0],PL_colors[1]));
794 }
cad2e5aa
JH
795 s = t;
796 set_useful:
33b8afdf 797 ++BmUSEFUL(do_utf8 ? prog->check_utf8 : prog->check_substr); /* hooray/5 */
cad2e5aa
JH
798 }
799 else {
f5952150 800 /* The found string does not prohibit matching at strpos,
2c2d71f5 801 - no optimization of calling REx engine can be performed,
f5952150
GS
802 unless it was an MBOL and we are not after MBOL,
803 or a future STCLASS check will fail this. */
2c2d71f5
JH
804 try_at_start:
805 /* Even in this situation we may use MBOL flag if strpos is offset
806 wrt the start of the string. */
05b4157f 807 if (ml_anch && sv && !SvROK(sv) /* See prev comment on SvROK */
a1933d95 808 && (strpos != strbeg) && strpos[-1] != '\n'
d506a20d
IZ
809 /* May be due to an implicit anchor of m{.*foo} */
810 && !(prog->reganch & ROPT_IMPLICIT))
811 {
cad2e5aa
JH
812 t = strpos;
813 goto find_anchor;
814 }
a3621e74 815 DEBUG_EXECUTE_r( if (ml_anch)
f5952150
GS
816 PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
817 (long)(strpos - i_strpos), PL_colors[0],PL_colors[1]);
30944b6d 818 );
2c2d71f5 819 success_at_start:
30944b6d 820 if (!(prog->reganch & ROPT_NAUGHTY) /* XXXX If strpos moved? */
33b8afdf
JH
821 && (do_utf8 ? (
822 prog->check_utf8 /* Could be deleted already */
823 && --BmUSEFUL(prog->check_utf8) < 0
824 && (prog->check_utf8 == prog->float_utf8)
825 ) : (
826 prog->check_substr /* Could be deleted already */
827 && --BmUSEFUL(prog->check_substr) < 0
828 && (prog->check_substr == prog->float_substr)
829 )))
66e933ab 830 {
cad2e5aa 831 /* If flags & SOMETHING - do not do it many times on the same match */
a3621e74 832 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
33b8afdf
JH
833 SvREFCNT_dec(do_utf8 ? prog->check_utf8 : prog->check_substr);
834 if (do_utf8 ? prog->check_substr : prog->check_utf8)
835 SvREFCNT_dec(do_utf8 ? prog->check_substr : prog->check_utf8);
836 prog->check_substr = prog->check_utf8 = Nullsv; /* disable */
837 prog->float_substr = prog->float_utf8 = Nullsv; /* clear */
5e39e1e5 838 check = Nullsv; /* abort */
cad2e5aa 839 s = strpos;
3cf5c195
IZ
840 /* XXXX This is a remnant of the old implementation. It
841 looks wasteful, since now INTUIT can use many
6eb5f6b9 842 other heuristics. */
cad2e5aa
JH
843 prog->reganch &= ~RE_USE_INTUIT;
844 }
845 else
846 s = strpos;
847 }
848
6eb5f6b9
JH
849 /* Last resort... */
850 /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
851 if (prog->regstclass) {
852 /* minlen == 0 is possible if regstclass is \b or \B,
853 and the fixed substr is ''$.
854 Since minlen is already taken into account, s+1 is before strend;
855 accidentally, minlen >= 1 guaranties no false positives at s + 1
856 even for \b or \B. But (minlen? 1 : 0) below assumes that
857 regstclass does not come from lookahead... */
858 /* If regstclass takes bytelength more than 1: If charlength==1, OK.
859 This leaves EXACTF only, which is dealt with in find_byclass(). */
1aa99e6b 860 U8* str = (U8*)STRING(prog->regstclass);
66e933ab 861 int cl_l = (PL_regkind[(U8)OP(prog->regstclass)] == EXACT
1aa99e6b 862 ? CHR_DIST(str+STR_LEN(prog->regstclass), str)
66e933ab 863 : 1);
33b8afdf 864 char *endpos = (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1aa99e6b 865 ? HOP3c(s, (prog->minlen ? cl_l : 0), strend)
33b8afdf 866 : (prog->float_substr || prog->float_utf8
1aa99e6b
IH
867 ? HOP3c(HOP3c(check_at, -start_shift, strbeg),
868 cl_l, strend)
869 : strend);
a1933d95 870 char *startpos = strbeg;
6eb5f6b9
JH
871
872 t = s;
9926ca43 873 cache_re(prog);
f33976b4 874 s = find_byclass(prog, prog->regstclass, s, endpos, startpos, 1);
6eb5f6b9
JH
875 if (!s) {
876#ifdef DEBUGGING
b7953727 877 char *what = 0;
6eb5f6b9
JH
878#endif
879 if (endpos == strend) {
a3621e74 880 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
6eb5f6b9
JH
881 "Could not match STCLASS...\n") );
882 goto fail;
883 }
a3621e74 884 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab 885 "This position contradicts STCLASS...\n") );
653099ff
GS
886 if ((prog->reganch & ROPT_ANCH) && !ml_anch)
887 goto fail;
6eb5f6b9 888 /* Contradict one of substrings */
33b8afdf
JH
889 if (prog->anchored_substr || prog->anchored_utf8) {
890 if ((do_utf8 ? prog->anchored_utf8 : prog->anchored_substr) == check) {
a3621e74 891 DEBUG_EXECUTE_r( what = "anchored" );
6eb5f6b9 892 hop_and_restart:
1aa99e6b 893 s = HOP3c(t, 1, strend);
66e933ab
GS
894 if (s + start_shift + end_shift > strend) {
895 /* XXXX Should be taken into account earlier? */
a3621e74 896 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
66e933ab
GS
897 "Could not match STCLASS...\n") );
898 goto fail;
899 }
5e39e1e5
HS
900 if (!check)
901 goto giveup;
a3621e74 902 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 903 "Looking for %s substr starting at offset %ld...\n",
6eb5f6b9
JH
904 what, (long)(s + start_shift - i_strpos)) );
905 goto restart;
906 }
66e933ab 907 /* Have both, check_string is floating */
6eb5f6b9
JH
908 if (t + start_shift >= check_at) /* Contradicts floating=check */
909 goto retry_floating_check;
910 /* Recheck anchored substring, but not floating... */
9041c2e3 911 s = check_at;
5e39e1e5
HS
912 if (!check)
913 goto giveup;
a3621e74 914 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150 915 "Looking for anchored substr starting at offset %ld...\n",
6eb5f6b9
JH
916 (long)(other_last - i_strpos)) );
917 goto do_other_anchored;
918 }
60e71179
GS
919 /* Another way we could have checked stclass at the
920 current position only: */
921 if (ml_anch) {
922 s = t = t + 1;
5e39e1e5
HS
923 if (!check)
924 goto giveup;
a3621e74 925 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
f5952150
GS
926 "Looking for /%s^%s/m starting at offset %ld...\n",
927 PL_colors[0],PL_colors[1], (long)(t - i_strpos)) );
60e71179 928 goto try_at_offset;
66e933ab 929 }
33b8afdf 930 if (!(do_utf8 ? prog->float_utf8 : prog->float_substr)) /* Could have been deleted */
60e71179 931 goto fail;
6eb5f6b9
JH
932 /* Check is floating subtring. */
933 retry_floating_check:
934 t = check_at - start_shift;
a3621e74 935 DEBUG_EXECUTE_r( what = "floating" );
6eb5f6b9
JH
936 goto hop_and_restart;
937 }
b7953727 938 if (t != s) {
a3621e74 939 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
6eb5f6b9 940 "By STCLASS: moving %ld --> %ld\n",
b7953727
JH
941 (long)(t - i_strpos), (long)(s - i_strpos))
942 );
943 }
944 else {
a3621e74 945 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
b7953727
JH
946 "Does not contradict STCLASS...\n");
947 );
948 }
6eb5f6b9 949 }
5e39e1e5 950 giveup:
a3621e74 951 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
5e39e1e5
HS
952 PL_colors[4], (check ? "Guessed" : "Giving up"),
953 PL_colors[5], (long)(s - i_strpos)) );
cad2e5aa 954 return s;
2c2d71f5
JH
955
956 fail_finish: /* Substring not found */
33b8afdf
JH
957 if (prog->check_substr || prog->check_utf8) /* could be removed already */
958 BmUSEFUL(do_utf8 ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
cad2e5aa 959 fail:
a3621e74 960 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
cad2e5aa
JH
961 PL_colors[4],PL_colors[5]));
962 return Nullch;
963}
9661b544 964
6eb5f6b9 965/* We know what class REx starts with. Try to find this position... */
3c3eec57
GS
966STATIC char *
967S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *startpos, I32 norun)
a687059c 968{
6eb5f6b9
JH
969 I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
970 char *m;
d8093b23 971 STRLEN ln;
5dab1207 972 STRLEN lnc;
078c425b 973 register STRLEN uskip;
d8093b23
G
974 unsigned int c1;
975 unsigned int c2;
6eb5f6b9
JH
976 char *e;
977 register I32 tmp = 1; /* Scratch variable? */
53c4c00c 978 register bool do_utf8 = PL_reg_match_utf8;
cad2e5aa 979
6eb5f6b9
JH
980 /* We know what class it must start with. */
981 switch (OP(c)) {
6eb5f6b9 982 case ANYOF:
388cc4de 983 if (do_utf8) {
078c425b 984 while (s + (uskip = UTF8SKIP(s)) <= strend) {
388cc4de
HS
985 if ((ANYOF_FLAGS(c) & ANYOF_UNICODE) ||
986 !UTF8_IS_INVARIANT((U8)s[0]) ?
987 reginclass(c, (U8*)s, 0, do_utf8) :
988 REGINCLASS(c, (U8*)s)) {
989 if (tmp && (norun || regtry(prog, s)))
990 goto got_it;
991 else
992 tmp = doevery;
993 }
994 else
995 tmp = 1;
078c425b 996 s += uskip;
388cc4de
HS
997 }
998 }
999 else {
1000 while (s < strend) {
1001 STRLEN skip = 1;
1002
1003 if (REGINCLASS(c, (U8*)s) ||
1004 (ANYOF_FOLD_SHARP_S(c, s, strend) &&
1005 /* The assignment of 2 is intentional:
1006 * for the folded sharp s, the skip is 2. */
1007 (skip = SHARP_S_SKIP))) {
1008 if (tmp && (norun || regtry(prog, s)))
1009 goto got_it;
1010 else
1011 tmp = doevery;
1012 }
1013 else
1014 tmp = 1;
1015 s += skip;
1016 }
a0d0e21e 1017 }
6eb5f6b9 1018 break;
f33976b4
DB
1019 case CANY:
1020 while (s < strend) {
1021 if (tmp && (norun || regtry(prog, s)))
1022 goto got_it;
1023 else
1024 tmp = doevery;
1025 s++;
1026 }
1027 break;
6eb5f6b9 1028 case EXACTF:
5dab1207
NIS
1029 m = STRING(c);
1030 ln = STR_LEN(c); /* length to match in octets/bytes */
1031 lnc = (I32) ln; /* length to match in characters */
1aa99e6b 1032 if (UTF) {
a2a2844f 1033 STRLEN ulen1, ulen2;
5dab1207 1034 U8 *sm = (U8 *) m;
89ebb4a3
JH
1035 U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
1036 U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
a2a2844f
JH
1037
1038 to_utf8_lower((U8*)m, tmpbuf1, &ulen1);
1039 to_utf8_upper((U8*)m, tmpbuf2, &ulen2);
1040
89ebb4a3 1041 c1 = utf8n_to_uvchr(tmpbuf1, UTF8_MAXBYTES_CASE,
872c91ae 1042 0, ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY);
89ebb4a3 1043 c2 = utf8n_to_uvchr(tmpbuf2, UTF8_MAXBYTES_CASE,
872c91ae 1044 0, ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY);
5dab1207
NIS
1045 lnc = 0;
1046 while (sm < ((U8 *) m + ln)) {
1047 lnc++;
1048 sm += UTF8SKIP(sm);
1049 }
1aa99e6b
IH
1050 }
1051 else {
1052 c1 = *(U8*)m;
1053 c2 = PL_fold[c1];
1054 }
6eb5f6b9
JH
1055 goto do_exactf;
1056 case EXACTFL:
5dab1207
NIS
1057 m = STRING(c);
1058 ln = STR_LEN(c);
1059 lnc = (I32) ln;
d8093b23 1060 c1 = *(U8*)m;
6eb5f6b9
JH
1061 c2 = PL_fold_locale[c1];
1062 do_exactf:
db12adc6 1063 e = HOP3c(strend, -((I32)lnc), s);
b3c9acc1 1064
6eb5f6b9
JH
1065 if (norun && e < s)
1066 e = s; /* Due to minlen logic of intuit() */
1aa99e6b 1067
60a8b682
JH
1068 /* The idea in the EXACTF* cases is to first find the
1069 * first character of the EXACTF* node and then, if
1070 * necessary, case-insensitively compare the full
1071 * text of the node. The c1 and c2 are the first
1072 * characters (though in Unicode it gets a bit
1073 * more complicated because there are more cases
7f16dd3d
JH
1074 * than just upper and lower: one needs to use
1075 * the so-called folding case for case-insensitive
1076 * matching (called "loose matching" in Unicode).
1077 * ibcmp_utf8() will do just that. */
60a8b682 1078
1aa99e6b 1079 if (do_utf8) {
575cac57 1080 UV c, f;
89ebb4a3
JH
1081 U8 tmpbuf [UTF8_MAXBYTES+1];
1082 U8 foldbuf[UTF8_MAXBYTES_CASE+1];
575cac57 1083 STRLEN len, foldlen;
d7f013c8 1084
09091399 1085 if (c1 == c2) {
5dab1207
NIS
1086 /* Upper and lower of 1st char are equal -
1087 * probably not a "letter". */
1aa99e6b 1088 while (s <= e) {
89ebb4a3 1089 c = utf8n_to_uvchr((U8*)s, UTF8_MAXBYTES, &len,
872c91ae
JH
1090 ckWARN(WARN_UTF8) ?
1091 0 : UTF8_ALLOW_ANY);
80aecb99
JH
1092 if ( c == c1
1093 && (ln == len ||
66423254 1094 ibcmp_utf8(s, (char **)0, 0, do_utf8,
eb160463 1095 m, (char **)0, ln, (bool)UTF))
55da9344 1096 && (norun || regtry(prog, s)) )
1aa99e6b 1097 goto got_it;
80aecb99
JH
1098 else {
1099 uvchr_to_utf8(tmpbuf, c);
ac7e0132 1100 f = to_utf8_fold(tmpbuf, foldbuf, &foldlen);
80aecb99
JH
1101 if ( f != c
1102 && (f == c1 || f == c2)
1103 && (ln == foldlen ||
66423254
JH
1104 !ibcmp_utf8((char *) foldbuf,
1105 (char **)0, foldlen, do_utf8,
d07ddd77 1106 m,
eb160463 1107 (char **)0, ln, (bool)UTF))
80aecb99
JH
1108 && (norun || regtry(prog, s)) )
1109 goto got_it;
1110 }
1aa99e6b
IH
1111 s += len;
1112 }
09091399
JH
1113 }
1114 else {
1aa99e6b 1115 while (s <= e) {
89ebb4a3 1116 c = utf8n_to_uvchr((U8*)s, UTF8_MAXBYTES, &len,
872c91ae
JH
1117 ckWARN(WARN_UTF8) ?
1118 0 : UTF8_ALLOW_ANY);
80aecb99 1119
60a8b682 1120 /* Handle some of the three Greek sigmas cases.
8c01da3c
JH
1121 * Note that not all the possible combinations
1122 * are handled here: some of them are handled
1123 * by the standard folding rules, and some of
1124 * them (the character class or ANYOF cases)
1125 * are handled during compiletime in
1126 * regexec.c:S_regclass(). */
880bd946
JH
1127 if (c == (UV)UNICODE_GREEK_CAPITAL_LETTER_SIGMA ||
1128 c == (UV)UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA)
1129 c = (UV)UNICODE_GREEK_SMALL_LETTER_SIGMA;
80aecb99
JH
1130
1131 if ( (c == c1 || c == c2)
1132 && (ln == len ||
66423254 1133 ibcmp_utf8(s, (char **)0, 0, do_utf8,
eb160463 1134 m, (char **)0, ln, (bool)UTF))
55da9344 1135 && (norun || regtry(prog, s)) )
1aa99e6b 1136 goto got_it;
80aecb99
JH
1137 else {
1138 uvchr_to_utf8(tmpbuf, c);
ac7e0132 1139 f = to_utf8_fold(tmpbuf, foldbuf, &foldlen);
80aecb99
JH
1140 if ( f != c
1141 && (f == c1 || f == c2)
1142 && (ln == foldlen ||
a6872d42 1143 !ibcmp_utf8((char *) foldbuf,
66423254 1144 (char **)0, foldlen, do_utf8,
d07ddd77 1145 m,
eb160463 1146 (char **)0, ln, (bool)UTF))
80aecb99
JH
1147 && (norun || regtry(prog, s)) )
1148 goto got_it;
1149 }
1aa99e6b
IH
1150 s += len;
1151 }
09091399 1152 }
1aa99e6b
IH
1153 }
1154 else {
1155 if (c1 == c2)
1156 while (s <= e) {
1157 if ( *(U8*)s == c1
1158 && (ln == 1 || !(OP(c) == EXACTF
1159 ? ibcmp(s, m, ln)
1160 : ibcmp_locale(s, m, ln)))
1161 && (norun || regtry(prog, s)) )
1162 goto got_it;
1163 s++;
1164 }
1165 else
1166 while (s <= e) {
1167 if ( (*(U8*)s == c1 || *(U8*)s == c2)
1168 && (ln == 1 || !(OP(c) == EXACTF
1169 ? ibcmp(s, m, ln)
1170 : ibcmp_locale(s, m, ln)))
1171 && (norun || regtry(prog, s)) )
1172 goto got_it;
1173 s++;
1174 }
b3c9acc1
IZ
1175 }
1176 break;
bbce6d69 1177 case BOUNDL:
3280af22 1178 PL_reg_flags |= RF_tainted;
bbce6d69 1179 /* FALL THROUGH */
a0d0e21e 1180 case BOUND:
ffc61ed2 1181 if (do_utf8) {
12d33761 1182 if (s == PL_bostr)
ffc61ed2
JH
1183 tmp = '\n';
1184 else {
b4f7163a 1185 U8 *r = reghop3((U8*)s, -1, (U8*)PL_bostr);
9041c2e3 1186
b4f7163a 1187 tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
ffc61ed2
JH
1188 }
1189 tmp = ((OP(c) == BOUND ?
9041c2e3 1190 isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
8269fa76 1191 LOAD_UTF8_CHARCLASS(alnum,"a");
078c425b 1192 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2 1193 if (tmp == !(OP(c) == BOUND ?
3568d838 1194 swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8) :
ffc61ed2
JH
1195 isALNUM_LC_utf8((U8*)s)))
1196 {
1197 tmp = !tmp;
1198 if ((norun || regtry(prog, s)))
1199 goto got_it;
1200 }
078c425b 1201 s += uskip;
a687059c 1202 }
a0d0e21e 1203 }
667bb95a 1204 else {
12d33761 1205 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';
ffc61ed2
JH
1206 tmp = ((OP(c) == BOUND ? isALNUM(tmp) : isALNUM_LC(tmp)) != 0);
1207 while (s < strend) {
1208 if (tmp ==
1209 !(OP(c) == BOUND ? isALNUM(*s) : isALNUM_LC(*s))) {
1210 tmp = !tmp;
1211 if ((norun || regtry(prog, s)))
1212 goto got_it;
1213 }
1214 s++;
a0ed51b3 1215 }
a0ed51b3 1216 }
6eb5f6b9 1217 if ((!prog->minlen && tmp) && (norun || regtry(prog, s)))
a0ed51b3
LW
1218 goto got_it;
1219 break;
bbce6d69 1220 case NBOUNDL:
3280af22 1221 PL_reg_flags |= RF_tainted;
bbce6d69 1222 /* FALL THROUGH */
a0d0e21e 1223 case NBOUND:
ffc61ed2 1224 if (do_utf8) {
12d33761 1225 if (s == PL_bostr)
ffc61ed2
JH
1226 tmp = '\n';
1227 else {
b4f7163a 1228 U8 *r = reghop3((U8*)s, -1, (U8*)PL_bostr);
9041c2e3 1229
b4f7163a 1230 tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
ffc61ed2
JH
1231 }
1232 tmp = ((OP(c) == NBOUND ?
9041c2e3 1233 isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
8269fa76 1234 LOAD_UTF8_CHARCLASS(alnum,"a");
078c425b 1235 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2 1236 if (tmp == !(OP(c) == NBOUND ?
3568d838 1237 swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8) :
ffc61ed2
JH
1238 isALNUM_LC_utf8((U8*)s)))
1239 tmp = !tmp;
1240 else if ((norun || regtry(prog, s)))
1241 goto got_it;
078c425b 1242 s += uskip;
ffc61ed2 1243 }
a0d0e21e 1244 }
667bb95a 1245 else {
12d33761 1246 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';
ffc61ed2
JH
1247 tmp = ((OP(c) == NBOUND ?
1248 isALNUM(tmp) : isALNUM_LC(tmp)) != 0);
1249 while (s < strend) {
1250 if (tmp ==
1251 !(OP(c) == NBOUND ? isALNUM(*s) : isALNUM_LC(*s)))
1252 tmp = !tmp;
1253 else if ((norun || regtry(prog, s)))
1254 goto got_it;
1255 s++;
1256 }
a0ed51b3 1257 }
6eb5f6b9 1258 if ((!prog->minlen && !tmp) && (norun || regtry(prog, s)))
a0ed51b3
LW
1259 goto got_it;
1260 break;
a0d0e21e 1261 case ALNUM:
ffc61ed2 1262 if (do_utf8) {
8269fa76 1263 LOAD_UTF8_CHARCLASS(alnum,"a");
078c425b 1264 while (s + (uskip = UTF8SKIP(s)) <= strend) {
3568d838 1265 if (swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8)) {
ffc61ed2
JH
1266 if (tmp && (norun || regtry(prog, s)))
1267 goto got_it;
1268 else
1269 tmp = doevery;
1270 }
bbce6d69 1271 else
ffc61ed2 1272 tmp = 1;
078c425b 1273 s += uskip;
bbce6d69 1274 }
bbce6d69 1275 }
ffc61ed2
JH
1276 else {
1277 while (s < strend) {
1278 if (isALNUM(*s)) {
1279 if (tmp && (norun || regtry(prog, s)))
1280 goto got_it;
1281 else
1282 tmp = doevery;
1283 }
a0ed51b3 1284 else
ffc61ed2
JH
1285 tmp = 1;
1286 s++;
a0ed51b3 1287 }
a0ed51b3
LW
1288 }
1289 break;
bbce6d69 1290 case ALNUML:
3280af22 1291 PL_reg_flags |= RF_tainted;
ffc61ed2 1292 if (do_utf8) {
078c425b 1293 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2
JH
1294 if (isALNUM_LC_utf8((U8*)s)) {
1295 if (tmp && (norun || regtry(prog, s)))
1296 goto got_it;
1297 else
1298 tmp = doevery;
1299 }
a687059c 1300 else
ffc61ed2 1301 tmp = 1;
078c425b 1302 s += uskip;
a0d0e21e 1303 }
a0d0e21e 1304 }
ffc61ed2
JH
1305 else {
1306 while (s < strend) {
1307 if (isALNUM_LC(*s)) {
1308 if (tmp && (norun || regtry(prog, s)))
1309 goto got_it;
1310 else
1311 tmp = doevery;
1312 }
a0ed51b3 1313 else
ffc61ed2
JH
1314 tmp = 1;
1315 s++;
a0ed51b3 1316 }
a0ed51b3
LW
1317 }
1318 break;
a0d0e21e 1319 case NALNUM:
ffc61ed2 1320 if (do_utf8) {
8269fa76 1321 LOAD_UTF8_CHARCLASS(alnum,"a");
078c425b 1322 while (s + (uskip = UTF8SKIP(s)) <= strend) {
3568d838 1323 if (!swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8)) {
ffc61ed2
JH
1324 if (tmp && (norun || regtry(prog, s)))
1325 goto got_it;
1326 else
1327 tmp = doevery;
1328 }
bbce6d69 1329 else
ffc61ed2 1330 tmp = 1;
078c425b 1331 s += uskip;
bbce6d69 1332 }
bbce6d69 1333 }
ffc61ed2
JH
1334 else {
1335 while (s < strend) {
1336 if (!isALNUM(*s)) {
1337 if (tmp && (norun || regtry(prog, s)))
1338 goto got_it;
1339 else
1340 tmp = doevery;
1341 }
a0ed51b3 1342 else
ffc61ed2
JH
1343 tmp = 1;
1344 s++;
a0ed51b3 1345 }
a0ed51b3
LW
1346 }
1347 break;
bbce6d69 1348 case NALNUML:
3280af22 1349 PL_reg_flags |= RF_tainted;
ffc61ed2 1350 if (do_utf8) {
078c425b 1351 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2
JH
1352 if (!isALNUM_LC_utf8((U8*)s)) {
1353 if (tmp && (norun || regtry(prog, s)))
1354 goto got_it;
1355 else
1356 tmp = doevery;
1357 }
a687059c 1358 else
ffc61ed2 1359 tmp = 1;
078c425b 1360 s += uskip;
a687059c 1361 }
a0d0e21e 1362 }
ffc61ed2
JH
1363 else {
1364 while (s < strend) {
1365 if (!isALNUM_LC(*s)) {
1366 if (tmp && (norun || regtry(prog, s)))
1367 goto got_it;
1368 else
1369 tmp = doevery;
1370 }
a0ed51b3 1371 else
ffc61ed2
JH
1372 tmp = 1;
1373 s++;
a0ed51b3 1374 }
a0ed51b3
LW
1375 }
1376 break;
a0d0e21e 1377 case SPACE:
ffc61ed2 1378 if (do_utf8) {
8269fa76 1379 LOAD_UTF8_CHARCLASS(space," ");
078c425b 1380 while (s + (uskip = UTF8SKIP(s)) <= strend) {
3568d838 1381 if (*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, do_utf8)) {
ffc61ed2
JH
1382 if (tmp && (norun || regtry(prog, s)))
1383 goto got_it;
1384 else
1385 tmp = doevery;
1386 }
a0d0e21e 1387 else
ffc61ed2 1388 tmp = 1;
078c425b 1389 s += uskip;
2304df62 1390 }
a0d0e21e 1391 }
ffc61ed2
JH
1392 else {
1393 while (s < strend) {
1394 if (isSPACE(*s)) {
1395 if (tmp && (norun || regtry(prog, s)))
1396 goto got_it;
1397 else
1398 tmp = doevery;
1399 }
a0ed51b3 1400 else
ffc61ed2
JH
1401 tmp = 1;
1402 s++;
a0ed51b3 1403 }
a0ed51b3
LW
1404 }
1405 break;
bbce6d69 1406 case SPACEL:
3280af22 1407 PL_reg_flags |= RF_tainted;
ffc61ed2 1408 if (do_utf8) {
078c425b 1409 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2
JH
1410 if (*s == ' ' || isSPACE_LC_utf8((U8*)s)) {
1411 if (tmp && (norun || regtry(prog, s)))
1412 goto got_it;
1413 else
1414 tmp = doevery;
1415 }
bbce6d69 1416 else
ffc61ed2 1417 tmp = 1;
078c425b 1418 s += uskip;
bbce6d69 1419 }
bbce6d69 1420 }
ffc61ed2
JH
1421 else {
1422 while (s < strend) {
1423 if (isSPACE_LC(*s)) {
1424 if (tmp && (norun || regtry(prog, s)))
1425 goto got_it;
1426 else
1427 tmp = doevery;
1428 }
a0ed51b3 1429 else
ffc61ed2
JH
1430 tmp = 1;
1431 s++;
a0ed51b3 1432 }
a0ed51b3
LW
1433 }
1434 break;
a0d0e21e 1435 case NSPACE:
ffc61ed2 1436 if (do_utf8) {
8269fa76 1437 LOAD_UTF8_CHARCLASS(space," ");
078c425b 1438 while (s + (uskip = UTF8SKIP(s)) <= strend) {
3568d838 1439 if (!(*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, do_utf8))) {
ffc61ed2
JH
1440 if (tmp && (norun || regtry(prog, s)))
1441 goto got_it;
1442 else
1443 tmp = doevery;
1444 }
a0d0e21e 1445 else
ffc61ed2 1446 tmp = 1;
078c425b 1447 s += uskip;
a687059c 1448 }
a0d0e21e 1449 }
ffc61ed2
JH
1450 else {
1451 while (s < strend) {
1452 if (!isSPACE(*s)) {
1453 if (tmp && (norun || regtry(prog, s)))
1454 goto got_it;
1455 else
1456 tmp = doevery;
1457 }
a0ed51b3 1458 else
ffc61ed2
JH
1459 tmp = 1;
1460 s++;
a0ed51b3 1461 }
a0ed51b3
LW
1462 }
1463 break;
bbce6d69 1464 case NSPACEL:
3280af22 1465 PL_reg_flags |= RF_tainted;
ffc61ed2 1466 if (do_utf8) {
078c425b 1467 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2
JH
1468 if (!(*s == ' ' || isSPACE_LC_utf8((U8*)s))) {
1469 if (tmp && (norun || regtry(prog, s)))
1470 goto got_it;
1471 else
1472 tmp = doevery;
1473 }
bbce6d69 1474 else
ffc61ed2 1475 tmp = 1;
078c425b 1476 s += uskip;
bbce6d69 1477 }
bbce6d69 1478 }
ffc61ed2
JH
1479 else {
1480 while (s < strend) {
1481 if (!isSPACE_LC(*s)) {
1482 if (tmp && (norun || regtry(prog, s)))
1483 goto got_it;
1484 else
1485 tmp = doevery;
1486 }
a0ed51b3 1487 else
ffc61ed2
JH
1488 tmp = 1;
1489 s++;
a0ed51b3 1490 }
a0ed51b3
LW
1491 }
1492 break;
a0d0e21e 1493 case DIGIT:
ffc61ed2 1494 if (do_utf8) {
8269fa76 1495 LOAD_UTF8_CHARCLASS(digit,"0");
078c425b 1496 while (s + (uskip = UTF8SKIP(s)) <= strend) {
3568d838 1497 if (swash_fetch(PL_utf8_digit,(U8*)s, do_utf8)) {
ffc61ed2
JH
1498 if (tmp && (norun || regtry(prog, s)))
1499 goto got_it;
1500 else
1501 tmp = doevery;
1502 }
a0d0e21e 1503 else
ffc61ed2 1504 tmp = 1;
078c425b 1505 s += uskip;
2b69d0c2 1506 }
a0d0e21e 1507 }
ffc61ed2
JH
1508 else {
1509 while (s < strend) {
1510 if (isDIGIT(*s)) {
1511 if (tmp && (norun || regtry(prog, s)))
1512 goto got_it;
1513 else
1514 tmp = doevery;
1515 }
a0ed51b3 1516 else
ffc61ed2
JH
1517 tmp = 1;
1518 s++;
a0ed51b3 1519 }
a0ed51b3
LW
1520 }
1521 break;
b8c5462f
JH
1522 case DIGITL:
1523 PL_reg_flags |= RF_tainted;
ffc61ed2 1524 if (do_utf8) {
078c425b 1525 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2
JH
1526 if (isDIGIT_LC_utf8((U8*)s)) {
1527 if (tmp && (norun || regtry(prog, s)))
1528 goto got_it;
1529 else
1530 tmp = doevery;
1531 }
b8c5462f 1532 else
ffc61ed2 1533 tmp = 1;
078c425b 1534 s += uskip;
b8c5462f 1535 }
b8c5462f 1536 }
ffc61ed2
JH
1537 else {
1538 while (s < strend) {
1539 if (isDIGIT_LC(*s)) {
1540 if (tmp && (norun || regtry(prog, s)))
1541 goto got_it;
1542 else
1543 tmp = doevery;
1544 }
b8c5462f 1545 else
ffc61ed2
JH
1546 tmp = 1;
1547 s++;
b8c5462f 1548 }
b8c5462f
JH
1549 }
1550 break;
a0d0e21e 1551 case NDIGIT:
ffc61ed2 1552 if (do_utf8) {
8269fa76 1553 LOAD_UTF8_CHARCLASS(digit,"0");
078c425b 1554 while (s + (uskip = UTF8SKIP(s)) <= strend) {
3568d838 1555 if (!swash_fetch(PL_utf8_digit,(U8*)s, do_utf8)) {
ffc61ed2
JH
1556 if (tmp && (norun || regtry(prog, s)))
1557 goto got_it;
1558 else
1559 tmp = doevery;
1560 }
a0d0e21e 1561 else
ffc61ed2 1562 tmp = 1;
078c425b 1563 s += uskip;
a687059c 1564 }
a0d0e21e 1565 }
ffc61ed2
JH
1566 else {
1567 while (s < strend) {
1568 if (!isDIGIT(*s)) {
1569 if (tmp && (norun || regtry(prog, s)))
1570 goto got_it;
1571 else
1572 tmp = doevery;
1573 }
a0ed51b3 1574 else
ffc61ed2
JH
1575 tmp = 1;
1576 s++;
a0ed51b3 1577 }
a0ed51b3
LW
1578 }
1579 break;
b8c5462f
JH
1580 case NDIGITL:
1581 PL_reg_flags |= RF_tainted;
ffc61ed2 1582 if (do_utf8) {
078c425b 1583 while (s + (uskip = UTF8SKIP(s)) <= strend) {
ffc61ed2
JH
1584 if (!isDIGIT_LC_utf8((U8*)s)) {
1585 if (tmp && (norun || regtry(prog, s)))
1586 goto got_it;
1587 else
1588 tmp = doevery;
1589 }
b8c5462f 1590 else
ffc61ed2 1591 tmp = 1;
078c425b 1592 s += uskip;
b8c5462f 1593 }
a0ed51b3 1594 }
ffc61ed2
JH
1595 else {
1596 while (s < strend) {
1597 if (!isDIGIT_LC(*s)) {
1598 if (tmp && (norun || regtry(prog, s)))
1599 goto got_it;
1600 else
1601 tmp = doevery;
1602 }
cf93c79d 1603 else
ffc61ed2
JH
1604 tmp = 1;
1605 s++;
b8c5462f 1606 }
b8c5462f
JH
1607 }
1608 break;
b3c9acc1 1609 default:
3c3eec57
GS
1610 Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
1611 break;
d6a28714 1612 }
6eb5f6b9
JH
1613 return 0;
1614 got_it:
1615 return s;
1616}
1617
1618/*
1619 - regexec_flags - match a regexp against a string
1620 */
1621I32
1622Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *strend,
1623 char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
1624/* strend: pointer to null at end of string */
1625/* strbeg: real beginning of string */
1626/* minend: end of match must be >=minend after stringarg. */
1627/* data: May be used for some additional optimizations. */
1628/* nosave: For optimizations. */
1629{
6eb5f6b9
JH
1630 register char *s;
1631 register regnode *c;
1632 register char *startpos = stringarg;
6eb5f6b9
JH
1633 I32 minlen; /* must match at least this many chars */
1634 I32 dontbother = 0; /* how many characters not to try at end */
155aba94 1635 /* I32 start_shift = 0; */ /* Offset of the start to find
6eb5f6b9
JH
1636 constant substr. */ /* CC */
1637 I32 end_shift = 0; /* Same for the end. */ /* CC */
1638 I32 scream_pos = -1; /* Internal iterator of scream. */
1639 char *scream_olds;
1640 SV* oreplsv = GvSV(PL_replgv);
1aa99e6b 1641 bool do_utf8 = DO_UTF8(sv);
7fba1cd6 1642 I32 multiline = prog->reganch & PMf_MULTILINE;
2a782b5b 1643#ifdef DEBUGGING
9e55ce06
JH
1644 SV *dsv0 = PERL_DEBUG_PAD_ZERO(0);
1645 SV *dsv1 = PERL_DEBUG_PAD_ZERO(1);
2a782b5b 1646#endif
a3621e74
YO
1647
1648 GET_RE_DEBUG_FLAGS_DECL;
1649
a30b2f1f 1650 RX_MATCH_UTF8_set(prog,do_utf8);
6eb5f6b9
JH
1651
1652 PL_regcc = 0;
1653
1654 cache_re(prog);
1655#ifdef DEBUGGING
aea4f609 1656 PL_regnarrate = DEBUG_r_TEST;
6eb5f6b9
JH
1657#endif
1658
1659 /* Be paranoid... */
1660 if (prog == NULL || startpos == NULL) {
1661 Perl_croak(aTHX_ "NULL regexp parameter");
1662 return 0;
1663 }
1664
1665 minlen = prog->minlen;
61a36c01 1666 if (strend - startpos < minlen) {
a3621e74 1667 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
a72c7584
JH
1668 "String too short [regexec_flags]...\n"));
1669 goto phooey;
1aa99e6b 1670 }
6eb5f6b9 1671
6eb5f6b9
JH
1672 /* Check validity of program. */
1673 if (UCHARAT(prog->program) != REG_MAGIC) {
1674 Perl_croak(aTHX_ "corrupted regexp program");
1675 }
1676
1677 PL_reg_flags = 0;
1678 PL_reg_eval_set = 0;
1679 PL_reg_maxiter = 0;
1680
1681 if (prog->reganch & ROPT_UTF8)
1682 PL_reg_flags |= RF_utf8;
1683
1684 /* Mark beginning of line for ^ and lookbehind. */
1685 PL_regbol = startpos;
1686 PL_bostr = strbeg;
1687 PL_reg_sv = sv;
1688
1689 /* Mark end of line for $ (and such) */
1690 PL_regeol = strend;
1691
1692 /* see how far we have to get to not match where we matched before */
1693 PL_regtill = startpos+minend;
1694
1695 /* We start without call_cc context. */
1696 PL_reg_call_cc = 0;
1697
1698 /* If there is a "must appear" string, look for it. */
1699 s = startpos;
1700
1701 if (prog->reganch & ROPT_GPOS_SEEN) { /* Need to have PL_reg_ganch */
1702 MAGIC *mg;
1703
1704 if (flags & REXEC_IGNOREPOS) /* Means: check only at start */
1705 PL_reg_ganch = startpos;
1706 else if (sv && SvTYPE(sv) >= SVt_PVMG
1707 && SvMAGIC(sv)
14befaf4
DM
1708 && (mg = mg_find(sv, PERL_MAGIC_regex_global))
1709 && mg->mg_len >= 0) {
6eb5f6b9
JH
1710 PL_reg_ganch = strbeg + mg->mg_len; /* Defined pos() */
1711 if (prog->reganch & ROPT_ANCH_GPOS) {
f33976b4 1712 if (s > PL_reg_ganch)
6eb5f6b9
JH
1713 goto phooey;
1714 s = PL_reg_ganch;
1715 }
1716 }
1717 else /* pos() not defined */
1718 PL_reg_ganch = strbeg;
1719 }
1720
33b8afdf 1721 if (!(flags & REXEC_CHECKED) && (prog->check_substr != Nullsv || prog->check_utf8 != Nullsv)) {
6eb5f6b9
JH
1722 re_scream_pos_data d;
1723
1724 d.scream_olds = &scream_olds;
1725 d.scream_pos = &scream_pos;
1726 s = re_intuit_start(prog, sv, s, strend, flags, &d);
3fa9c3d7 1727 if (!s) {
a3621e74 1728 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
6eb5f6b9 1729 goto phooey; /* not present */
3fa9c3d7 1730 }
6eb5f6b9
JH
1731 }
1732
a3621e74 1733 DEBUG_EXECUTE_r({
9e55ce06
JH
1734 char *s0 = UTF ?
1735 pv_uni_display(dsv0, (U8*)prog->precomp, prog->prelen, 60,
c728cb41 1736 UNI_DISPLAY_REGEX) :
9e55ce06
JH
1737 prog->precomp;
1738 int len0 = UTF ? SvCUR(dsv0) : prog->prelen;
1739 char *s1 = do_utf8 ? sv_uni_display(dsv1, sv, 60,
c728cb41 1740 UNI_DISPLAY_REGEX) : startpos;
9e55ce06 1741 int len1 = do_utf8 ? SvCUR(dsv1) : strend - startpos;
2a782b5b
JH
1742 if (!PL_colorset)
1743 reginitcolors();
1744 PerlIO_printf(Perl_debug_log,
9e55ce06 1745 "%sMatching REx%s `%s%*.*s%s%s' against `%s%.*s%s%s'\n",
2a782b5b 1746 PL_colors[4],PL_colors[5],PL_colors[0],
9e55ce06 1747 len0, len0, s0,
2a782b5b 1748 PL_colors[1],
9e55ce06 1749 len0 > 60 ? "..." : "",
2a782b5b 1750 PL_colors[0],
9e55ce06
JH
1751 (int)(len1 > 60 ? 60 : len1),
1752 s1, PL_colors[1],
1753 (len1 > 60 ? "..." : "")
2a782b5b
JH
1754 );
1755 });
6eb5f6b9
JH
1756
1757 /* Simplest case: anchored match need be tried only once. */
1758 /* [unless only anchor is BOL and multiline is set] */
1759 if (prog->reganch & (ROPT_ANCH & ~ROPT_ANCH_GPOS)) {
1760 if (s == startpos && regtry(prog, startpos))
1761 goto got_it;
7fba1cd6 1762 else if (multiline || (prog->reganch & ROPT_IMPLICIT)
6eb5f6b9
JH
1763 || (prog->reganch & ROPT_ANCH_MBOL)) /* XXXX SBOL? */
1764 {
1765 char *end;
1766
1767 if (minlen)
1768 dontbother = minlen - 1;
1aa99e6b 1769 end = HOP3c(strend, -dontbother, strbeg) - 1;
6eb5f6b9 1770 /* for multiline we only have to try after newlines */
33b8afdf 1771 if (prog->check_substr || prog->check_utf8) {
6eb5f6b9
JH
1772 if (s == startpos)
1773 goto after_try;
1774 while (1) {
1775 if (regtry(prog, s))
1776 goto got_it;
1777 after_try:
1778 if (s >= end)
1779 goto phooey;
1780 if (prog->reganch & RE_USE_INTUIT) {
1781 s = re_intuit_start(prog, sv, s + 1, strend, flags, NULL);
1782 if (!s)
1783 goto phooey;
1784 }
1785 else
1786 s++;
1787 }
1788 } else {
1789 if (s > startpos)
1790 s--;
1791 while (s < end) {
1792 if (*s++ == '\n') { /* don't need PL_utf8skip here */
1793 if (regtry(prog, s))
1794 goto got_it;
1795 }
1796 }
1797 }
1798 }
1799 goto phooey;
1800 } else if (prog->reganch & ROPT_ANCH_GPOS) {
1801 if (regtry(prog, PL_reg_ganch))
1802 goto got_it;
1803 goto phooey;
1804 }
1805
1806 /* Messy cases: unanchored match. */
33b8afdf 1807 if ((prog->anchored_substr || prog->anchored_utf8) && prog->reganch & ROPT_SKIP) {
6eb5f6b9
JH
1808 /* we have /x+whatever/ */
1809 /* it must be a one character string (XXXX Except UTF?) */
33b8afdf 1810 char ch;
bf93d4cc
GS
1811#ifdef DEBUGGING
1812 int did_match = 0;
1813#endif
33b8afdf
JH
1814 if (!(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr))
1815 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
1816 ch = SvPVX(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr)[0];
bf93d4cc 1817
1aa99e6b 1818 if (do_utf8) {
6eb5f6b9
JH
1819 while (s < strend) {
1820 if (*s == ch) {
a3621e74 1821 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH
1822 if (regtry(prog, s)) goto got_it;
1823 s += UTF8SKIP(s);
1824 while (s < strend && *s == ch)
1825 s += UTF8SKIP(s);
1826 }
1827 s += UTF8SKIP(s);
1828 }
1829 }
1830 else {
1831 while (s < strend) {
1832 if (*s == ch) {
a3621e74 1833 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH
1834 if (regtry(prog, s)) goto got_it;
1835 s++;
1836 while (s < strend && *s == ch)
1837 s++;
1838 }
1839 s++;
1840 }
1841 }
a3621e74 1842 DEBUG_EXECUTE_r(if (!did_match)
bf93d4cc 1843 PerlIO_printf(Perl_debug_log,
b7953727
JH
1844 "Did not find anchored character...\n")
1845 );
6eb5f6b9
JH
1846 }
1847 /*SUPPRESS 560*/
33b8afdf
JH
1848 else if (prog->anchored_substr != Nullsv
1849 || prog->anchored_utf8 != Nullsv
1850 || ((prog->float_substr != Nullsv || prog->float_utf8 != Nullsv)
1851 && prog->float_max_offset < strend - s)) {
1852 SV *must;
1853 I32 back_max;
1854 I32 back_min;
1855 char *last;
6eb5f6b9 1856 char *last1; /* Last position checked before */
bf93d4cc
GS
1857#ifdef DEBUGGING
1858 int did_match = 0;
1859#endif
33b8afdf
JH
1860 if (prog->anchored_substr || prog->anchored_utf8) {
1861 if (!(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr))
1862 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
1863 must = do_utf8 ? prog->anchored_utf8 : prog->anchored_substr;
1864 back_max = back_min = prog->anchored_offset;
1865 } else {
1866 if (!(do_utf8 ? prog->float_utf8 : prog->float_substr))
1867 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
1868 must = do_utf8 ? prog->float_utf8 : prog->float_substr;
1869 back_max = prog->float_max_offset;
1870 back_min = prog->float_min_offset;
1871 }
1872 if (must == &PL_sv_undef)
1873 /* could not downgrade utf8 check substring, so must fail */
1874 goto phooey;
1875
1876 last = HOP3c(strend, /* Cannot start after this */
1877 -(I32)(CHR_SVLEN(must)
1878 - (SvTAIL(must) != 0) + back_min), strbeg);
6eb5f6b9
JH
1879
1880 if (s > PL_bostr)
1881 last1 = HOPc(s, -1);
1882 else
1883 last1 = s - 1; /* bogus */
1884
1885 /* XXXX check_substr already used to find `s', can optimize if
1886 check_substr==must. */
1887 scream_pos = -1;
1888 dontbother = end_shift;
1889 strend = HOPc(strend, -dontbother);
1890 while ( (s <= last) &&
9041c2e3 1891 ((flags & REXEC_SCREAM)
1aa99e6b 1892 ? (s = screaminstr(sv, must, HOP3c(s, back_min, strend) - strbeg,
6eb5f6b9 1893 end_shift, &scream_pos, 0))
1aa99e6b 1894 : (s = fbm_instr((unsigned char*)HOP3(s, back_min, strend),
9041c2e3 1895 (unsigned char*)strend, must,
7fba1cd6 1896 multiline ? FBMrf_MULTILINE : 0))) ) {
4addbd3b
HS
1897 /* we may be pointing at the wrong string */
1898 if ((flags & REXEC_SCREAM) && RX_MATCH_COPIED(prog))
7ef91622 1899 s = strbeg + (s - SvPVX(sv));
a3621e74 1900 DEBUG_EXECUTE_r( did_match = 1 );
6eb5f6b9
JH
1901 if (HOPc(s, -back_max) > last1) {
1902 last1 = HOPc(s, -back_min);
1903 s = HOPc(s, -back_max);
1904 }
1905 else {
1906 char *t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
1907
1908 last1 = HOPc(s, -back_min);
1909 s = t;
1910 }
1aa99e6b 1911 if (do_utf8) {
6eb5f6b9
JH
1912 while (s <= last1) {
1913 if (regtry(prog, s))
1914 goto got_it;
1915 s += UTF8SKIP(s);
1916 }
1917 }
1918 else {
1919 while (s <= last1) {
1920 if (regtry(prog, s))
1921 goto got_it;
1922 s++;
1923 }
1924 }
1925 }
a3621e74 1926 DEBUG_EXECUTE_r(if (!did_match)
b7953727
JH
1927 PerlIO_printf(Perl_debug_log,
1928 "Did not find %s substr `%s%.*s%s'%s...\n",
33b8afdf 1929 ((must == prog->anchored_substr || must == prog->anchored_utf8)
bf93d4cc
GS
1930 ? "anchored" : "floating"),
1931 PL_colors[0],
1932 (int)(SvCUR(must) - (SvTAIL(must)!=0)),
1933 SvPVX(must),
b7953727
JH
1934 PL_colors[1], (SvTAIL(must) ? "$" : ""))
1935 );
6eb5f6b9
JH
1936 goto phooey;
1937 }
155aba94 1938 else if ((c = prog->regstclass)) {
f14c76ed
RGS
1939 if (minlen) {
1940 I32 op = (U8)OP(prog->regstclass);
66e933ab 1941 /* don't bother with what can't match */
f14c76ed
RGS
1942 if (PL_regkind[op] != EXACT && op != CANY)
1943 strend = HOPc(strend, -(minlen - 1));
1944 }
a3621e74 1945 DEBUG_EXECUTE_r({
ffc61ed2 1946 SV *prop = sv_newmortal();
9e55ce06
JH
1947 char *s0;
1948 char *s1;
1949 int len0;
1950 int len1;
1951
ffc61ed2 1952 regprop(prop, c);
9e55ce06
JH
1953 s0 = UTF ?
1954 pv_uni_display(dsv0, (U8*)SvPVX(prop), SvCUR(prop), 60,
c728cb41 1955 UNI_DISPLAY_REGEX) :
9e55ce06
JH
1956 SvPVX(prop);
1957 len0 = UTF ? SvCUR(dsv0) : SvCUR(prop);
1958 s1 = UTF ?
c728cb41 1959 sv_uni_display(dsv1, sv, 60, UNI_DISPLAY_REGEX) : s;
9e55ce06
JH
1960 len1 = UTF ? SvCUR(dsv1) : strend - s;
1961 PerlIO_printf(Perl_debug_log,
1962 "Matching stclass `%*.*s' against `%*.*s'\n",
1963 len0, len0, s0,
1964 len1, len1, s1);
ffc61ed2 1965 });
6eb5f6b9
JH
1966 if (find_byclass(prog, c, s, strend, startpos, 0))
1967 goto got_it;
a3621e74 1968 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass...\n"));
d6a28714
JH
1969 }
1970 else {
1971 dontbother = 0;
33b8afdf
JH
1972 if (prog->float_substr != Nullsv || prog->float_utf8 != Nullsv) {
1973 /* Trim the end. */
d6a28714 1974 char *last;
33b8afdf
JH
1975 SV* float_real;
1976
1977 if (!(do_utf8 ? prog->float_utf8 : prog->float_substr))
1978 do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
1979 float_real = do_utf8 ? prog->float_utf8 : prog->float_substr;
d6a28714
JH
1980
1981 if (flags & REXEC_SCREAM) {
33b8afdf 1982 last = screaminstr(sv, float_real, s - strbeg,
d6a28714
JH
1983 end_shift, &scream_pos, 1); /* last one */
1984 if (!last)
ffc61ed2 1985 last = scream_olds; /* Only one occurrence. */
4addbd3b
HS
1986 /* we may be pointing at the wrong string */
1987 else if (RX_MATCH_COPIED(prog))
7ef91622 1988 s = strbeg + (s - SvPVX(sv));
b8c5462f 1989 }
d6a28714
JH
1990 else {
1991 STRLEN len;
33b8afdf 1992 char *little = SvPV(float_real, len);
d6a28714 1993
33b8afdf 1994 if (SvTAIL(float_real)) {
d6a28714
JH
1995 if (memEQ(strend - len + 1, little, len - 1))
1996 last = strend - len + 1;
7fba1cd6 1997 else if (!multiline)
9041c2e3 1998 last = memEQ(strend - len, little, len)
d6a28714 1999 ? strend - len : Nullch;
b8c5462f 2000 else
d6a28714
JH
2001 goto find_last;
2002 } else {
2003 find_last:
9041c2e3 2004 if (len)
d6a28714 2005 last = rninstr(s, strend, little, little + len);
b8c5462f 2006 else
d6a28714 2007 last = strend; /* matching `$' */
b8c5462f 2008 }
b8c5462f 2009 }
bf93d4cc 2010 if (last == NULL) {
a3621e74 2011 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
bf93d4cc
GS
2012 "%sCan't trim the tail, match fails (should not happen)%s\n",
2013 PL_colors[4],PL_colors[5]));
2014 goto phooey; /* Should not happen! */
2015 }
d6a28714
JH
2016 dontbother = strend - last + prog->float_min_offset;
2017 }
2018 if (minlen && (dontbother < minlen))
2019 dontbother = minlen - 1;
2020 strend -= dontbother; /* this one's always in bytes! */
2021 /* We don't know much -- general case. */
1aa99e6b 2022 if (do_utf8) {
d6a28714
JH
2023 for (;;) {
2024 if (regtry(prog, s))
2025 goto got_it;
2026 if (s >= strend)
2027 break;
b8c5462f 2028 s += UTF8SKIP(s);
d6a28714
JH
2029 };
2030 }
2031 else {
2032 do {
2033 if (regtry(prog, s))
2034 goto got_it;
2035 } while (s++ < strend);
2036 }
2037 }
2038
2039 /* Failure. */
2040 goto phooey;
2041
2042got_it:
2043 RX_MATCH_TAINTED_set(prog, PL_reg_flags & RF_tainted);
2044
2045 if (PL_reg_eval_set) {
2046 /* Preserve the current value of $^R */
2047 if (oreplsv != GvSV(PL_replgv))
2048 sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
2049 restored, the value remains
2050 the same. */
acfe0abc 2051 restore_pos(aTHX_ 0);
d6a28714
JH
2052 }
2053
2054 /* make sure $`, $&, $', and $digit will work later */
2055 if ( !(flags & REXEC_NOT_FIRST) ) {
ed252734 2056 RX_MATCH_COPY_FREE(prog);
d6a28714
JH
2057 if (flags & REXEC_COPY_STR) {
2058 I32 i = PL_regeol - startpos + (stringarg - strbeg);
ed252734
NC
2059#ifdef PERL_COPY_ON_WRITE
2060 if ((SvIsCOW(sv)
2061 || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS)) {
2062 if (DEBUG_C_TEST) {
2063 PerlIO_printf(Perl_debug_log,
2064 "Copy on write: regexp capture, type %d\n",
2065 (int) SvTYPE(sv));
2066 }
2067 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
2068 prog->subbeg = SvPVX(prog->saved_copy);
2069 assert (SvPOKp(prog->saved_copy));
2070 } else
2071#endif
2072 {
2073 RX_MATCH_COPIED_on(prog);
2074 s = savepvn(strbeg, i);
2075 prog->subbeg = s;
2076 }
d6a28714 2077 prog->sublen = i;
d6a28714
JH
2078 }
2079 else {
2080 prog->subbeg = strbeg;
2081 prog->sublen = PL_regeol - strbeg; /* strend may have been modified */
2082 }
2083 }
9041c2e3 2084
d6a28714
JH
2085 return 1;
2086
2087phooey:
a3621e74 2088 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
bf93d4cc 2089 PL_colors[4],PL_colors[5]));
d6a28714 2090 if (PL_reg_eval_set)
acfe0abc 2091 restore_pos(aTHX_ 0);
d6a28714
JH
2092 return 0;
2093}
2094
2095/*
2096 - regtry - try match at specific point
2097 */
2098STATIC I32 /* 0 failure, 1 success */
2099S_regtry(pTHX_ regexp *prog, char *startpos)
2100{
d6a28714
JH
2101 register I32 i;
2102 register I32 *sp;
2103 register I32 *ep;
2104 CHECKPOINT lastcp;
a3621e74 2105 GET_RE_DEBUG_FLAGS_DECL;
d6a28714 2106
02db2b7b
IZ
2107#ifdef DEBUGGING
2108 PL_regindent = 0; /* XXXX Not good when matches are reenterable... */
2109#endif
d6a28714
JH
2110 if ((prog->reganch & ROPT_EVAL_SEEN) && !PL_reg_eval_set) {
2111 MAGIC *mg;
2112
2113 PL_reg_eval_set = RS_init;
a3621e74 2114 DEBUG_EXECUTE_r(DEBUG_s(
b900a521
JH
2115 PerlIO_printf(Perl_debug_log, " setting stack tmpbase at %"IVdf"\n",
2116 (IV)(PL_stack_sp - PL_stack_base));
d6a28714 2117 ));
e8347627 2118 SAVEI32(cxstack[cxstack_ix].blk_oldsp);
d6a28714
JH
2119 cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
2120 /* Otherwise OP_NEXTSTATE will free whatever on stack now. */
2121 SAVETMPS;
2122 /* Apparently this is not needed, judging by wantarray. */
e8347627 2123 /* SAVEI8(cxstack[cxstack_ix].blk_gimme);
d6a28714
JH
2124 cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
2125
2126 if (PL_reg_sv) {
2127 /* Make $_ available to executed code. */
2128 if (PL_reg_sv != DEFSV) {
59f00321 2129 SAVE_DEFSV;
d6a28714 2130 DEFSV = PL_reg_sv;
b8c5462f 2131 }
d6a28714 2132
9041c2e3 2133 if (!(SvTYPE(PL_reg_sv) >= SVt_PVMG && SvMAGIC(PL_reg_sv)
14befaf4 2134 && (mg = mg_find(PL_reg_sv, PERL_MAGIC_regex_global)))) {
d6a28714 2135 /* prepare for quick setting of pos */
14befaf4
DM
2136 sv_magic(PL_reg_sv, (SV*)0,
2137 PERL_MAGIC_regex_global, Nullch, 0);
2138 mg = mg_find(PL_reg_sv, PERL_MAGIC_regex_global);
d6a28714 2139 mg->mg_len = -1;
b8c5462f 2140 }
d6a28714
JH
2141 PL_reg_magic = mg;
2142 PL_reg_oldpos = mg->mg_len;
c76ac1ee 2143 SAVEDESTRUCTOR_X(restore_pos, 0);
d6a28714 2144 }
09687e5a 2145 if (!PL_reg_curpm) {
0f79a09d 2146 Newz(22,PL_reg_curpm, 1, PMOP);
09687e5a
AB
2147#ifdef USE_ITHREADS
2148 {
2149 SV* repointer = newSViv(0);
577e12cc 2150 /* so we know which PL_regex_padav element is PL_reg_curpm */
35061a7e 2151 SvFLAGS(repointer) |= SVf_BREAK;
09687e5a
AB
2152 av_push(PL_regex_padav,repointer);
2153 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
2154 PL_regex_pad = AvARRAY(PL_regex_padav);
2155 }
2156#endif
2157 }
aaa362c4 2158 PM_SETRE(PL_reg_curpm, prog);
d6a28714
JH
2159 PL_reg_oldcurpm = PL_curpm;
2160 PL_curpm = PL_reg_curpm;
2161 if (RX_MATCH_COPIED(prog)) {
2162 /* Here is a serious problem: we cannot rewrite subbeg,
2163 since it may be needed if this match fails. Thus
2164 $` inside (?{}) could fail... */
2165 PL_reg_oldsaved = prog->subbeg;
2166 PL_reg_oldsavedlen = prog->sublen;
ed252734
NC
2167#ifdef PERL_COPY_ON_WRITE
2168 PL_nrs = prog->saved_copy;
2169#endif
d6a28714
JH
2170 RX_MATCH_COPIED_off(prog);
2171 }
2172 else
2173 PL_reg_oldsaved = Nullch;
2174 prog->subbeg = PL_bostr;
2175 prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2176 }
2177 prog->startp[0] = startpos - PL_bostr;
2178 PL_reginput = startpos;
2179 PL_regstartp = prog->startp;
2180 PL_regendp = prog->endp;
2181 PL_reglastparen = &prog->lastparen;
a01268b5 2182 PL_reglastcloseparen = &prog->lastcloseparen;
d6a28714 2183 prog->lastparen = 0;
03994de8 2184 prog->lastcloseparen = 0;
d6a28714 2185 PL_regsize = 0;
a3621e74 2186 DEBUG_EXECUTE_r(PL_reg_starttry = startpos);
d6a28714
JH
2187 if (PL_reg_start_tmpl <= prog->nparens) {
2188 PL_reg_start_tmpl = prog->nparens*3/2 + 3;
2189 if(PL_reg_start_tmp)
2190 Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2191 else
2192 New(22,PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2193 }
2194
2195 /* XXXX What this code is doing here?!!! There should be no need
2196 to do this again and again, PL_reglastparen should take care of
3dd2943c 2197 this! --ilya*/
dafc8851
JH
2198
2199 /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2200 * Actually, the code in regcppop() (which Ilya may be meaning by
daf18116
JH
2201 * PL_reglastparen), is not needed at all by the test suite
2202 * (op/regexp, op/pat, op/split), but that code is needed, oddly
2203 * enough, for building DynaLoader, or otherwise this
2204 * "Error: '*' not in typemap in DynaLoader.xs, line 164"
2205 * will happen. Meanwhile, this code *is* needed for the
2206 * above-mentioned test suite tests to succeed. The common theme
2207 * on those tests seems to be returning null fields from matches.
2208 * --jhi */
dafc8851 2209#if 1
d6a28714
JH
2210 sp = prog->startp;
2211 ep = prog->endp;
2212 if (prog->nparens) {
eb160463 2213 for (i = prog->nparens; i > (I32)*PL_reglastparen; i--) {
d6a28714
JH
2214 *++sp = -1;
2215 *++ep = -1;
2216 }
2217 }
dafc8851 2218#endif
02db2b7b 2219 REGCP_SET(lastcp);
d6a28714
JH
2220 if (regmatch(prog->program + 1)) {
2221 prog->endp[0] = PL_reginput - PL_bostr;
2222 return 1;
2223 }
02db2b7b 2224 REGCP_UNWIND(lastcp);
d6a28714
JH
2225 return 0;
2226}
2227
02db2b7b
IZ
2228#define RE_UNWIND_BRANCH 1
2229#define RE_UNWIND_BRANCHJ 2
2230
2231union re_unwind_t;
2232
2233typedef struct { /* XX: makes sense to enlarge it... */
2234 I32 type;
2235 I32 prev;
2236 CHECKPOINT lastcp;
2237} re_unwind_generic_t;
2238
2239typedef struct {
2240 I32 type;
2241 I32 prev;
2242 CHECKPOINT lastcp;
2243 I32 lastparen;
2244 regnode *next;
2245 char *locinput;
2246 I32 nextchr;
2247#ifdef DEBUGGING
2248 int regindent;
2249#endif
2250} re_unwind_branch_t;
2251
2252typedef union re_unwind_t {
2253 I32 type;
2254 re_unwind_generic_t generic;
2255 re_unwind_branch_t branch;
2256} re_unwind_t;
2257
8ba1375e
MJD
2258#define sayYES goto yes
2259#define sayNO goto no
e0f9d4a8 2260#define sayNO_ANYOF goto no_anyof
8ba1375e
MJD
2261#define sayYES_FINAL goto yes_final
2262#define sayYES_LOUD goto yes_loud
2263#define sayNO_FINAL goto no_final
2264#define sayNO_SILENT goto do_no
2265#define saySAME(x) if (x) goto yes; else goto no
2266
c689e61c
RGS
2267#define POSCACHE_SUCCESS 0 /* caching success rather than failure */
2268#define POSCACHE_SEEN 1 /* we know what we're caching */
2269#define POSCACHE_START 2 /* the real cache: this bit maps to pos 0 */
2270#define CACHEsayYES STMT_START { \
2271 if (PL_reg_poscache) { \
2272 if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
2273 PL_reg_poscache[0] |= (1<<POSCACHE_SUCCESS) || (1<<POSCACHE_SEEN); \
2274 else if (!(PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
2275 /* cache records failure, but this is success */ \
2276 I32 o = locinput - PL_bostr, b; \
2277 o = (scan->flags & 0xf) - 1 + POSCACHE_START + o * (scan->flags>>4); \
2278 b = o % 8; \
2279 o /= 8; \
2280 DEBUG_r( \
2281 PerlIO_printf(Perl_debug_log, \
2282 "%*s (remove success from failure cache)\n", \
2283 REPORT_CODE_OFF+PL_regindent*2, "") \
2284 ); \
2285 PL_reg_poscache[o] &= ~(1<<b); \
2286 } \
2287 } \
2288 sayYES; \
2289} STMT_END
2290#define CACHEsayNO STMT_START { \
2291 if (PL_reg_poscache) { \
2292 if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
2293 PL_reg_poscache[0] |= (1<<POSCACHE_SEEN); \
2294 else if ((PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
2295 /* cache records success, but this is failure */ \
2296 I32 o = locinput - PL_bostr, b; \
2297 o = (scan->flags & 0xf) - 1 + POSCACHE_START + o * (scan->flags>>4); \
2298 b = o % 8; \
2299 o /= 8; \
2300 DEBUG_r( \
2301 PerlIO_printf(Perl_debug_log, \
2302 "%*s (remove failure from success cache)\n", \
2303 REPORT_CODE_OFF+PL_regindent*2, "") \
2304 ); \
2305 PL_reg_poscache[o] &= ~(1<<b); \
2306 } \
2307 } \
2308 sayNO; \
2309} STMT_END
2310
a3621e74
YO
2311/* this is used to determine how far from the left messages like
2312 'failed...' are printed. Currently 29 makes these messages line
2313 up with the opcode they refer to. Earlier perls used 25 which
2314 left these messages outdented making reviewing a debug output
2315 quite difficult.
2316*/
2317#define REPORT_CODE_OFF 29
2318
2319
2320/* Make sure there is a test for this +1 options in re_tests */
2321#define TRIE_INITAL_ACCEPT_BUFFLEN 4;
2322
2323#define TRIE_CHECK_STATE_IS_ACCEPTING STMT_START { \
2324 if ( trie->states[ state ].wordnum ) { \
2325 if ( !accepted ) { \
2326 ENTER; \
2327 SAVETMPS; \
2328 bufflen = TRIE_INITAL_ACCEPT_BUFFLEN ; \
2329 sv_accept_buff=NEWSV( 1234, \
2330 bufflen * sizeof(reg_trie_accepted) - 1 ); \
2331 SvCUR_set( sv_accept_buff, sizeof(reg_trie_accepted) ); \
2332 SvPOK_on( sv_accept_buff ); \
2333 sv_2mortal( sv_accept_buff ); \
2334 accept_buff = (reg_trie_accepted*)SvPV_nolen( sv_accept_buff );\
2335 } else { \
2336 if ( accepted >= bufflen ) { \
2337 bufflen *= 2; \
2338 accept_buff =(reg_trie_accepted*)SvGROW( sv_accept_buff, \
2339 bufflen * sizeof(reg_trie_accepted) ); \
2340 } \
2341 SvCUR_set( sv_accept_buff,SvCUR( sv_accept_buff ) \
2342 + sizeof( reg_trie_accepted ) ); \
2343 } \
2344 accept_buff[ accepted ].wordnum = trie->states[ state ].wordnum; \
2345 accept_buff[ accepted ].endpos = uc; \
2346 ++accepted; \
2347 } } STMT_END
2348
2349#define TRIE_HANDLE_CHAR STMT_START { \
2350 if ( uvc < 256 ) { \
2351 charid = trie->charmap[ uvc ]; \
2352 } else { \
2353 charid = 0; \
2354 if( trie->widecharmap ) { \
2355 SV** svpp = (SV**)NULL; \
2356 svpp = hv_fetch( trie->widecharmap, (char*)&uvc, \
2357 sizeof( UV ), 0 ); \
2358 if ( svpp ) { \
2359 charid = (U16)SvIV( *svpp ); \
2360 } \
2361 } \
2362 } \
2363 if ( charid && \
cc601c31
YO
2364 ( base + charid > trie->uniquecharcount ) && \
2365 ( base + charid - 1 - trie->uniquecharcount < trie->lasttrans) && \
a3621e74
YO
2366 trie->trans[ base + charid - 1 - trie->uniquecharcount ].check == state ) \
2367 { \
2368 state = trie->trans[ base + charid - 1 - trie->uniquecharcount ].next; \
2369 } else { \
2370 state = 0; \
2371 } \
2372 uc += len; \
2373 } STMT_END
8ba1375e 2374
d6a28714
JH
2375/*
2376 - regmatch - main matching routine
2377 *
2378 * Conceptually the strategy is simple: check to see whether the current
2379 * node matches, call self recursively to see whether the rest matches,
2380 * and then act accordingly. In practice we make some effort to avoid
2381 * recursion, in particular by going through "ordinary" nodes (that don't
2382 * need to know whether the rest of the match failed) by a loop instead of
2383 * by recursion.
2384 */
2385/* [lwall] I've hoisted the register declarations to the outer block in order to
2386 * maybe save a little bit of pushing and popping on the stack. It also takes
2387 * advantage of machines that use a register save mask on subroutine entry.
2388 */
2389STATIC I32 /* 0 failure, 1 success */
2390S_regmatch(pTHX_ regnode *prog)
2391{
d6a28714
JH
2392 register regnode *scan; /* Current node. */
2393 regnode *next; /* Next node. */
2394 regnode *inner; /* Next node in internal branch. */
2395 register I32 nextchr; /* renamed nextchr - nextchar colides with
2396 function of same name */
2397 register I32 n; /* no or next */
b7953727
JH
2398 register I32 ln = 0; /* len or last */
2399 register char *s = Nullch; /* operand or save */
d6a28714 2400 register char *locinput = PL_reginput;
b7953727 2401 register I32 c1 = 0, c2 = 0, paren; /* case fold search, parenth */
d6a28714 2402 int minmod = 0, sw = 0, logical = 0;
02db2b7b 2403 I32 unwind = 0;
a3621e74
YO
2404
2405 /* used by the trie code */
2406 SV *sv_accept_buff; /* accepting states we have traversed */
2407 reg_trie_accepted *accept_buff; /* "" */
2408 reg_trie_data *trie; /* what trie are we using right now */
2409 U32 accepted = 0; /* how many accepting states we have seen*/
2410
b7953727 2411#if 0
02db2b7b 2412 I32 firstcp = PL_savestack_ix;
b7953727 2413#endif
53c4c00c 2414 register bool do_utf8 = PL_reg_match_utf8;
2a782b5b 2415#ifdef DEBUGGING
ce333219
JH
2416 SV *dsv0 = PERL_DEBUG_PAD_ZERO(0);
2417 SV *dsv1 = PERL_DEBUG_PAD_ZERO(1);
2418 SV *dsv2 = PERL_DEBUG_PAD_ZERO(2);
a3621e74
YO
2419
2420 SV *re_debug_flags;
2a782b5b 2421#endif
02db2b7b 2422
a3621e74
YO
2423 GET_RE_DEBUG_FLAGS;
2424
d6a28714
JH
2425#ifdef DEBUGGING
2426 PL_regindent++;
2427#endif
2428
a3621e74 2429
d6a28714
JH
2430 /* Note that nextchr is a byte even in UTF */
2431 nextchr = UCHARAT(locinput);
2432 scan = prog;
2433 while (scan != NULL) {
8ba1375e 2434
a3621e74 2435 DEBUG_EXECUTE_r( {
d6a28714
JH
2436 SV *prop = sv_newmortal();
2437 int docolor = *PL_colors[0];
2438 int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
1aa99e6b 2439 int l = (PL_regeol - locinput) > taill ? taill : (PL_regeol - locinput);
d6a28714
JH
2440 /* The part of the string before starttry has one color
2441 (pref0_len chars), between starttry and current
2442 position another one (pref_len - pref0_len chars),
2443 after the current position the third one.
2444 We assume that pref0_len <= pref_len, otherwise we
2445 decrease pref0_len. */
9041c2e3 2446 int pref_len = (locinput - PL_bostr) > (5 + taill) - l
1aa99e6b
IH
2447 ? (5 + taill) - l : locinput - PL_bostr;
2448 int pref0_len;
d6a28714 2449
df1ffd02 2450 while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
1aa99e6b
IH
2451 pref_len++;
2452 pref0_len = pref_len - (locinput - PL_reg_starttry);
d6a28714 2453 if (l + pref_len < (5 + taill) && l < PL_regeol - locinput)
9041c2e3 2454 l = ( PL_regeol - locinput > (5 + taill) - pref_len
d6a28714 2455 ? (5 + taill) - pref_len : PL_regeol - locinput);
df1ffd02 2456 while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
1aa99e6b 2457 l--;
d6a28714
JH
2458 if (pref0_len < 0)
2459 pref0_len = 0;
2460 if (pref0_len > pref_len)
2461 pref0_len = pref_len;
2462 regprop(prop, scan);
2a782b5b
JH
2463 {
2464 char *s0 =
f14c76ed 2465 do_utf8 && OP(scan) != CANY ?
2a782b5b 2466 pv_uni_display(dsv0, (U8*)(locinput - pref_len),
c728cb41 2467 pref0_len, 60, UNI_DISPLAY_REGEX) :
2a782b5b 2468 locinput - pref_len;
df1ffd02 2469 int len0 = do_utf8 ? strlen(s0) : pref0_len;
f14c76ed 2470 char *s1 = do_utf8 && OP(scan) != CANY ?
2a782b5b 2471 pv_uni_display(dsv1, (U8*)(locinput - pref_len + pref0_len),
c728cb41 2472 pref_len - pref0_len, 60, UNI_DISPLAY_REGEX) :
2a782b5b 2473 locinput - pref_len + pref0_len;
df1ffd02 2474 int len1 = do_utf8 ? strlen(s1) : pref_len - pref0_len;
f14c76ed 2475 char *s2 = do_utf8 && OP(scan) != CANY ?
2a782b5b 2476 pv_uni_display(dsv2, (U8*)locinput,
c728cb41 2477 PL_regeol - locinput, 60, UNI_DISPLAY_REGEX) :
2a782b5b 2478 locinput;
df1ffd02 2479 int len2 = do_utf8 ? strlen(s2) : l;
2a782b5b
JH
2480 PerlIO_printf(Perl_debug_log,
2481 "%4"IVdf" <%s%.*s%s%s%.*s%s%s%s%.*s%s>%*s|%3"IVdf":%*s%s\n",
2482 (IV)(locinput - PL_bostr),
2483 PL_colors[4],
2484 len0, s0,
2485 PL_colors[5],
2486 PL_colors[2],
2487 len1, s1,
2488 PL_colors[3],
2489 (docolor ? "" : "> <"),
2490 PL_colors[0],
2491 len2, s2,
2492 PL_colors[1],
2493 15 - l - pref_len + 1,
2494 "",
2495 (IV)(scan - PL_regprogram), PL_regindent*2, "",
2496 SvPVX(prop));
2497 }
2498 });
d6a28714
JH
2499
2500 next = scan + NEXT_OFF(scan);
2501 if (next == scan)
2502 next = NULL;
2503
2504 switch (OP(scan)) {
2505 case BOL:
7fba1cd6 2506 if (locinput == PL_bostr)
d6a28714
JH
2507 {
2508 /* regtill = regbol; */
b8c5462f
JH
2509 break;
2510 }
d6a28714
JH
2511 sayNO;
2512 case MBOL:
12d33761
HS
2513 if (locinput == PL_bostr ||
2514 ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n'))
d6a28714 2515 {
b8c5462f
JH
2516 break;
2517 }
d6a28714
JH
2518 sayNO;
2519 case SBOL:
c2a73568 2520 if (locinput == PL_bostr)
b8c5462f 2521 break;
d6a28714
JH
2522 sayNO;
2523 case GPOS:
2524 if (locinput == PL_reg_ganch)
2525 break;
2526 sayNO;
2527 case EOL:
d6a28714
JH
2528 goto seol;
2529 case MEOL:
d6a28714 2530 if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
b8c5462f 2531 sayNO;
b8c5462f 2532 break;
d6a28714
JH
2533 case SEOL:
2534 seol:
2535 if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
b8c5462f 2536 sayNO;
d6a28714 2537 if (PL_regeol - locinput > 1)
b8c5462f 2538 sayNO;
b8c5462f 2539 break;
d6a28714
JH
2540 case EOS:
2541 if (PL_regeol != locinput)
b8c5462f 2542 sayNO;
d6a28714 2543 break;
ffc61ed2 2544 case SANY:
d6a28714 2545 if (!nextchr && locinput >= PL_regeol)
4633a7c4 2546 sayNO;
f33976b4
DB
2547 if (do_utf8) {
2548 locinput += PL_utf8skip[nextchr];
2549 if (locinput > PL_regeol)
2550 sayNO;
2551 nextchr = UCHARAT(locinput);
2552 }
2553 else
2554 nextchr = UCHARAT(++locinput);
2555 break;
2556 case CANY:
2557 if (!nextchr && locinput >= PL_regeol)
2558 sayNO;
b8c5462f 2559 nextchr = UCHARAT(++locinput);
a0d0e21e 2560 break;
ffc61ed2 2561 case REG_ANY:
1aa99e6b
IH
2562 if ((!nextchr && locinput >= PL_regeol) || nextchr == '\n')
2563 sayNO;
2564 if (do_utf8) {
b8c5462f 2565 locinput += PL_utf8skip[nextchr];
d6a28714
JH
2566 if (locinput > PL_regeol)
2567 sayNO;
a0ed51b3 2568 nextchr = UCHARAT(locinput);
a0ed51b3 2569 }
1aa99e6b
IH
2570 else
2571 nextchr = UCHARAT(++locinput);
a0ed51b3 2572 break;
a3621e74
YO
2573
2574
2575
2576 /*
2577 traverse the TRIE keeping track of all accepting states
2578 we transition through until we get to a failing node.
2579
2580 we use two slightly different pieces of code to handle
2581 the traversal depending on whether its case sensitive or
2582 not. we reuse the accept code however. (this should probably
2583 be turned into a macro.)
2584
2585 */
2586 case TRIEF:
2587 case TRIEFL:
2588 {
2589
2590 U32 uniflags = ckWARN( WARN_UTF8 ) ? 0 : UTF8_ALLOW_ANY;
2591 U8 *uc = ( U8* )locinput;
2592 U32 state = 1;
2593 U16 charid = 0;
2594 U32 base = 0;
2595 UV uvc = 0;
2596 STRLEN len = 0;
2597 STRLEN foldlen = 0;
2598 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
2599 U8 *uscan = (U8*)NULL;
2600 STRLEN bufflen=0;
2601 accepted = 0;
2602
2603 trie = (reg_trie_data*)PL_regdata->data[ ARG( scan ) ];
2604
2605 while ( state && uc <= (U8*)PL_regeol ) {
2606
2607 TRIE_CHECK_STATE_IS_ACCEPTING;
2608
2609 base = trie->states[ state ].trans.base;
2610
2611 DEBUG_TRIE_EXECUTE_r(
2612 PerlIO_printf( Perl_debug_log,
2613 "%*s %sState: %4x, Base: %4x Accepted: %4x ",
2614 REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
2615 state, base, accepted );
2616 );
2617
2618 if ( base ) {
2619
2620 if ( do_utf8 || UTF ) {
2621 if ( foldlen>0 ) {
2622 uvc = utf8n_to_uvuni( uscan, UTF8_MAXLEN, &len, uniflags );
2623 foldlen -= len;
2624 uscan += len;
2625 len=0;
2626 } else {
2627 uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN, &len, uniflags );
2628 uvc = to_uni_fold( uvc, foldbuf, &foldlen );
2629 foldlen -= UNISKIP( uvc );
2630 uscan = foldbuf + UNISKIP( uvc );
2631 }
2632 } else {
2633 uvc = (U32)*uc;
2634 len = 1;
2635 }
2636
2637 TRIE_HANDLE_CHAR;
2638
2639 } else {
2640 state = 0;
2641 }
2642 DEBUG_TRIE_EXECUTE_r(
2643 PerlIO_printf( Perl_debug_log,
2644 "Charid:%3x CV:%4x After State: %4x%s\n",
2645 charid, uvc, state, PL_colors[5] );
2646 );
2647 }
2648 if ( !accepted ) {
2649 sayNO;
2650 } else {
2651 goto TrieAccept;
2652 }
2653 }
2654 /* unreached codepoint: we jump into the middle of the next case
2655 from previous if blocks */
2656 case TRIE:
2657 {
2658 U32 uniflags = ckWARN( WARN_UTF8 ) ? 0 : UTF8_ALLOW_ANY;
2659 U8 *uc = (U8*)locinput;
2660 U32 state = 1;
2661 U16 charid = 0;
2662 U32 base = 0;
2663 UV uvc = 0;
2664 STRLEN len = 0;
2665 STRLEN bufflen = 0;
2666 accepted = 0;
2667
2668 trie = (reg_trie_data*)PL_regdata->data[ ARG( scan ) ];
2669
2670 while ( state && uc <= (U8*)PL_regeol ) {
2671
2672 TRIE_CHECK_STATE_IS_ACCEPTING;
2673
2674 base = trie->states[ state ].trans.base;
2675
2676 DEBUG_TRIE_EXECUTE_r(
2677 PerlIO_printf( Perl_debug_log,
2678 "%*s %sState: %4x, Base: %4x Accepted: %4x ",
2679 REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
2680 state, base, accepted );
2681 );
2682
2683 if ( base ) {
2684
2685 if ( do_utf8 || UTF ) {
2686 uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN, &len, uniflags );
2687 } else {
2688 uvc = (U32)*uc;
2689 len = 1;
2690 }
2691
2692 TRIE_HANDLE_CHAR;
2693
2694 } else {
2695 state = 0;
2696 }
2697 DEBUG_TRIE_EXECUTE_r(
2698 PerlIO_printf( Perl_debug_log,
2699 "Charid:%3x CV:%4x After State: %4x%s\n",
2700 charid, uvc, state, PL_colors[5] );
2701 );
2702 }
2703 if ( !accepted ) {
2704 sayNO;
2705 }
2706 }
2707
2708
2709 /*
2710 There was at least one accepting state that we
2711 transitioned through. Presumably the number of accepting
2712 states is going to be low, typically one or two. So we
2713 simply scan through to find the one with lowest wordnum.
2714 Once we find it, we swap the last state into its place
2715 and decrement the size. We then try to match the rest of
2716 the pattern at the point where the word ends, if we
2717 succeed then we end the loop, otherwise the loop
2718 eventually terminates once all of the accepting states
2719 have been tried.
2720 */
2721 TrieAccept:
2722 {
2723 int gotit = 0;
2724
2725 if ( accepted == 1 ) {
2726 DEBUG_EXECUTE_r({
2727 SV **tmp = av_fetch( trie->words, accept_buff[ 0 ].wordnum-1, 0 );
2728 PerlIO_printf( Perl_debug_log,
2729 "%*s %sonly one match : #%d <%s>%s\n",
2730 REPORT_CODE_OFF+PL_regindent*2, "",PL_colors[4],
2731 accept_buff[ 0 ].wordnum,
2732 tmp ? SvPV_nolen( *tmp ) : "not compiled under -Dr",
2733 PL_colors[5] );
2734 });
cc601c31 2735 PL_reginput = (char *)accept_buff[ 0 ].endpos;
a3621e74
YO
2736 /* in this case we free tmps/leave before we call regmatch
2737 as we wont be using accept_buff again. */
2738 FREETMPS;
2739 LEAVE;
2740 gotit = regmatch( scan + NEXT_OFF( scan ) );
2741 } else {
2742 DEBUG_EXECUTE_r(
2743 PerlIO_printf( Perl_debug_log,"%*s %sgot %d possible matches%s\n",
2744 REPORT_CODE_OFF + PL_regindent * 2, "",PL_colors[4], accepted,
2745 PL_colors[5] );
2746 );
2747 while ( !gotit && accepted-- ) {
2748 U32 best = 0;
2749 U32 cur;
2750 for( cur = 1 ; cur <= accepted ; cur++ ) {
2751 DEBUG_TRIE_EXECUTE_r(
2752 PerlIO_printf( Perl_debug_log,
2753 "%*s %sgot %d (%d) as best, looking at %d (%d)%s\n",
2754 REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
2755 best, accept_buff[ best ].wordnum, cur,
2756 accept_buff[ cur ].wordnum, PL_colors[5] );
2757 );
2758
2759 if ( accept_buff[ cur ].wordnum < accept_buff[ best ].wordnum )
2760 best = cur;
2761 }
2762 DEBUG_EXECUTE_r({
2763 SV **tmp = av_fetch( trie->words, accept_buff[ best ].wordnum - 1, 0 );
2764 PerlIO_printf( Perl_debug_log, "%*s %strying alternation #%d <%s> at 0x%p%s\n",
2765 REPORT_CODE_OFF+PL_regindent*2, "",PL_colors[4],
2766 accept_buff[best].wordnum,
2767 tmp ? SvPV_nolen( *tmp ) : "not compiled under -Dr",scan,
2768 PL_colors[5] );
2769 });
2770 if ( best<accepted ) {
2771 reg_trie_accepted tmp = accept_buff[ best ];
2772 accept_buff[ best ] = accept_buff[ accepted ];
2773 accept_buff[ accepted ] = tmp;
2774 best = accepted;
2775 }
cc601c31 2776 PL_reginput = (char *)accept_buff[ best ].endpos;
a3621e74
YO
2777
2778 /*
2779 as far as I can tell we only need the SAVETMPS/FREETMPS
2780 for re's with EVAL in them but I'm leaving them in for
2781 all until I can be sure.
2782 */
2783 SAVETMPS;
2784 gotit = regmatch( scan + NEXT_OFF( scan ) ) ;
2785 FREETMPS;
2786 }
2787 FREETMPS;
2788 LEAVE;
2789 }
2790
2791 if ( gotit ) {
2792 sayYES;
2793 } else {
2794 sayNO;
2795 }
2796 }
2797 /* unreached codepoint */
d6a28714 2798 case EXACT:
cd439c50
IZ
2799 s = STRING(scan);
2800 ln = STR_LEN(scan);
eb160463 2801 if (do_utf8 != UTF) {
bc517b45 2802 /* The target and the pattern have differing utf8ness. */
1aa99e6b
IH
2803 char *l = locinput;
2804 char *e = s + ln;
bc517b45 2805 STRLEN ulen;
a72c7584 2806
5ff6fc6d
JH
2807 if (do_utf8) {
2808 /* The target is utf8, the pattern is not utf8. */
1aa99e6b
IH
2809 while (s < e) {
2810 if (l >= PL_regeol)
5ff6fc6d
JH
2811 sayNO;
2812 if (NATIVE_TO_UNI(*(U8*)s) !=
89ebb4a3 2813 utf8n_to_uvuni((U8*)l, UTF8_MAXBYTES, &ulen,
872c91ae
JH
2814 ckWARN(WARN_UTF8) ?
2815 0 : UTF8_ALLOW_ANY))
5ff6fc6d 2816 sayNO;
bc517b45 2817 l += ulen;
5ff6fc6d 2818 s ++;
1aa99e6b 2819 }
5ff6fc6d
JH
2820 }
2821 else {
2822 /* The target is not utf8, the pattern is utf8. */
1aa99e6b
IH
2823 while (s < e) {
2824 if (l >= PL_regeol)
2825 sayNO;
5ff6fc6d 2826 if (NATIVE_TO_UNI(*((U8*)l)) !=
89ebb4a3 2827 utf8n_to_uvuni((U8*)s, UTF8_MAXBYTES, &ulen,
872c91ae
JH
2828 ckWARN(WARN_UTF8) ?
2829 0 : UTF8_ALLOW_ANY))
1aa99e6b 2830 sayNO;
bc517b45 2831 s += ulen;
a72c7584 2832 l ++;
1aa99e6b 2833 }
5ff6fc6d 2834 }
1aa99e6b
IH
2835 locinput = l;
2836 nextchr = UCHARAT(locinput);
2837 break;
2838 }
bc517b45 2839 /* The target and the pattern have the same utf8ness. */
d6a28714
JH
2840 /* Inline the first character, for speed. */
2841 if (UCHARAT(s) != nextchr)
2842 sayNO;
2843 if (PL_regeol - locinput < ln)
2844 sayNO;
2845 if (ln > 1 && memNE(s, locinput, ln))
2846 sayNO;
2847 locinput += ln;
2848 nextchr = UCHARAT(locinput);
2849 break;
2850 case EXACTFL:
b8c5462f
JH
2851 PL_reg_flags |= RF_tainted;
2852 /* FALL THROUGH */
d6a28714 2853 case EXACTF:
cd439c50
IZ
2854 s = STRING(scan);
2855 ln = STR_LEN(scan);
d6a28714 2856
d07ddd77
JH
2857 if (do_utf8 || UTF) {
2858 /* Either target or the pattern are utf8. */
d6a28714 2859 char *l = locinput;
d07ddd77 2860 char *e = PL_regeol;
bc517b45 2861
eb160463 2862 if (ibcmp_utf8(s, 0, ln, (bool)UTF,
1feea2c7 2863 l, &e, 0, do_utf8)) {
5486206c
JH
2864 /* One more case for the sharp s:
2865 * pack("U0U*", 0xDF) =~ /ss/i,
2866 * the 0xC3 0x9F are the UTF-8
2867 * byte sequence for the U+00DF. */
2868 if (!(do_utf8 &&
2869 toLOWER(s[0]) == 's' &&
2870 ln >= 2 &&
2871 toLOWER(s[1]) == 's' &&
2872 (U8)l[0] == 0xC3 &&
2873 e - l >= 2 &&
2874 (U8)l[1] == 0x9F))
2875 sayNO;
2876 }
d07ddd77
JH
2877 locinput = e;
2878 nextchr = UCHARAT(locinput);
2879 break;
a0ed51b3 2880 }
d6a28714 2881
bc517b45
JH
2882 /* Neither the target and the pattern are utf8. */
2883
d6a28714
JH
2884 /* Inline the first character, for speed. */
2885 if (UCHARAT(s) != nextchr &&
2886 UCHARAT(s) != ((OP(scan) == EXACTF)
2887 ? PL_fold : PL_fold_locale)[nextchr])
a0ed51b3 2888 sayNO;
d6a28714 2889 if (PL_regeol - locinput < ln)
b8c5462f 2890 sayNO;
d6a28714
JH
2891 if (ln > 1 && (OP(scan) == EXACTF
2892 ? ibcmp(s, locinput, ln)
2893 : ibcmp_locale(s, locinput, ln)))
4633a7c4 2894 sayNO;
d6a28714
JH
2895 locinput += ln;
2896 nextchr = UCHARAT(locinput);
a0d0e21e 2897 break;
d6a28714 2898 case ANYOF:
ffc61ed2 2899 if (do_utf8) {
9e55ce06
JH
2900 STRLEN inclasslen = PL_regeol - locinput;
2901
ba7b4546 2902 if (!reginclass(scan, (U8*)locinput, &inclasslen, do_utf8))
e0f9d4a8 2903 sayNO_ANYOF;
ffc61ed2
JH
2904 if (locinput >= PL_regeol)
2905 sayNO;
0f0076b4 2906 locinput += inclasslen ? inclasslen : UTF8SKIP(locinput);
b8c5462f 2907 nextchr = UCHARAT(locinput);
e0f9d4a8 2908 break;
ffc61ed2
JH
2909 }
2910 else {
2911 if (nextchr < 0)
2912 nextchr = UCHARAT(locinput);
7d3e948e 2913 if (!REGINCLASS(scan, (U8*)locinput))
e0f9d4a8 2914 sayNO_ANYOF;
ffc61ed2
JH
2915 if (!nextchr && locinput >= PL_regeol)
2916 sayNO;
2917 nextchr = UCHARAT(++locinput);
e0f9d4a8
JH
2918 break;
2919 }
2920 no_anyof:
2921 /* If we might have the case of the German sharp s
2922 * in a casefolding Unicode character class. */
2923
ebc501f0
JH
2924 if (ANYOF_FOLD_SHARP_S(scan, locinput, PL_regeol)) {
2925 locinput += SHARP_S_SKIP;
e0f9d4a8 2926 nextchr = UCHARAT(locinput);
ffc61ed2 2927 }
e0f9d4a8
JH
2928 else
2929 sayNO;
b8c5462f 2930 break;
d6a28714 2931 case ALNUML:
b8c5462f
JH
2932 PL_reg_flags |= RF_tainted;
2933 /* FALL THROUGH */
d6a28714 2934 case ALNUM:
b8c5462f 2935 if (!nextchr)
4633a7c4 2936 sayNO;
ffc61ed2 2937 if (do_utf8) {
ad24be35 2938 LOAD_UTF8_CHARCLASS(alnum,"a");
ffc61ed2 2939 if (!(OP(scan) == ALNUM
3568d838 2940 ? swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
d6a28714 2941 : isALNUM_LC_utf8((U8*)locinput)))
b8c5462f
JH
2942 {
2943 sayNO;
a0ed51b3 2944 }
b8c5462f 2945 locinput += PL_utf8skip[nextchr];
a0ed51b3
LW
2946 nextchr = UCHARAT(locinput);
2947 break;
2948 }
ffc61ed2 2949 if (!(OP(scan) == ALNUM
d6a28714 2950 ? isALNUM(nextchr) : isALNUM_LC(nextchr)))
bbce6d69 2951 sayNO;
b8c5462f 2952 nextchr = UCHARAT(++locinput);
a0d0e21e 2953 break;
d6a28714 2954 case NALNUML:
b8c5462f
JH
2955 PL_reg_flags |= RF_tainted;
2956 /* FALL THROUGH */
d6a28714
JH
2957 case NALNUM:
2958 if (!nextchr && locinput >= PL_regeol)
a0ed51b3 2959 sayNO;
ffc61ed2 2960 if (do_utf8) {
8269fa76 2961 LOAD_UTF8_CHARCLASS(alnum,"a");
ffc61ed2 2962 if (OP(scan) == NALNUM
3568d838 2963 ? swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
d6a28714
JH
2964 : isALNUM_LC_utf8((U8*)locinput))
2965 {
b8c5462f 2966 sayNO;
d6a28714 2967 }
b8c5462f
JH
2968 locinput += PL_utf8skip[nextchr];
2969 nextchr = UCHARAT(locinput);
2970 break;
2971 }
ffc61ed2 2972 if (OP(scan) == NALNUM
d6a28714 2973 ? isALNUM(nextchr) : isALNUM_LC(nextchr))
b8c5462f 2974 sayNO;
76e3520e 2975 nextchr = UCHARAT(++locinput);
a0d0e21e 2976 break;
d6a28714
JH
2977 case BOUNDL:
2978 case NBOUNDL:
3280af22 2979 PL_reg_flags |= RF_tainted;
bbce6d69 2980 /* FALL THROUGH */
d6a28714
JH
2981 case BOUND:
2982 case NBOUND:
2983 /* was last char in word? */
ffc61ed2 2984 if (do_utf8) {
12d33761
HS
2985 if (locinput == PL_bostr)
2986 ln = '\n';
ffc61ed2 2987 else {
b4f7163a 2988 U8 *r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
9041c2e3 2989
b4f7163a 2990 ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
ffc61ed2
JH
2991 }
2992 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
2993 ln = isALNUM_uni(ln);
8269fa76 2994 LOAD_UTF8_CHARCLASS(alnum,"a");
3568d838 2995 n = swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8);
ffc61ed2
JH
2996 }
2997 else {
9041c2e3 2998 ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(ln));
ffc61ed2
JH
2999 n = isALNUM_LC_utf8((U8*)locinput);
3000 }
a0ed51b3 3001 }
d6a28714 3002 else {
12d33761
HS
3003 ln = (locinput != PL_bostr) ?
3004 UCHARAT(locinput - 1) : '\n';
ffc61ed2
JH
3005 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
3006 ln = isALNUM(ln);
3007 n = isALNUM(nextchr);
3008 }
3009 else {
3010 ln = isALNUM_LC(ln);
3011 n = isALNUM_LC(nextchr);
3012 }
d6a28714 3013 }
ffc61ed2
JH
3014 if (((!ln) == (!n)) == (OP(scan) == BOUND ||
3015 OP(scan) == BOUNDL))
3016 sayNO;
a0ed51b3 3017 break;
d6a28714 3018 case SPACEL:
3280af22 3019 PL_reg_flags |= RF_tainted;
bbce6d69 3020 /* FALL THROUGH */
d6a28714 3021 case SPACE:
9442cb0e 3022 if (!nextchr)
4633a7c4 3023 sayNO;
1aa99e6b 3024 if (do_utf8) {
fd400ab9 3025 if (UTF8_IS_CONTINUED(nextchr)) {
8269fa76 3026 LOAD_UTF8_CHARCLASS(space," ");
ffc61ed2 3027 if (!(OP(scan) == SPACE
3568d838 3028 ? swash_fetch(PL_utf8_space, (U8*)locinput, do_utf8)
ffc61ed2
JH
3029 : isSPACE_LC_utf8((U8*)locinput)))
3030 {
3031 sayNO;
3032 }
3033 locinput += PL_utf8skip[nextchr];
3034 nextchr = UCHARAT(locinput);
3035 break;
d6a28714 3036 }
ffc61ed2
JH
3037 if (!(OP(scan) == SPACE
3038 ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
3039 sayNO;
3040 nextchr = UCHARAT(++locinput);
3041 }
3042 else {
3043 if (!(OP(scan) == SPACE
3044 ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
3045 sayNO;
3046 nextchr = UCHARAT(++locinput);
a0ed51b3 3047 }
a0ed51b3 3048 break;
d6a28714 3049 case NSPACEL:
3280af22 3050 PL_reg_flags |= RF_tainted;
bbce6d69 3051 /* FALL THROUGH */
d6a28714 3052 case NSPACE:
9442cb0e 3053 if (!nextchr && locinput >= PL_regeol)
b8c5462f 3054 sayNO;
1aa99e6b 3055 if (do_utf8) {
8269fa76 3056 LOAD_UTF8_CHARCLASS(space," ");
ffc61ed2 3057 if (OP(scan) == NSPACE
3568d838 3058 ? swash_fetch(PL_utf8_space, (U8*)locinput, do_utf8)
d6a28714 3059 : isSPACE_LC_utf8((U8*)locinput))
b8c5462f
JH
3060 {
3061 sayNO;
3062 }
3063 locinput += PL_utf8skip[nextchr];
3064 nextchr = UCHARAT(locinput);
3065 break;
a0ed51b3 3066 }
ffc61ed2 3067 if (OP(scan) == NSPACE
d6a28714 3068 ? isSPACE(nextchr) : isSPACE_LC(nextchr))
4633a7c4 3069 sayNO;
76e3520e 3070 nextchr = UCHARAT(++locinput);
a0d0e21e 3071 break;
d6a28714 3072 case DIGITL:
a0ed51b3
LW
3073 PL_reg_flags |= RF_tainted;
3074 /* FALL THROUGH */
d6a28714 3075 case DIGIT:
9442cb0e 3076 if (!nextchr)
a0ed51b3 3077 sayNO;
1aa99e6b 3078 if (do_utf8) {
8269fa76 3079 LOAD_UTF8_CHARCLASS(digit,"0");
ffc61ed2 3080 if (!(OP(scan) == DIGIT
3568d838 3081 ? swash_fetch(PL_utf8_digit, (U8*)locinput, do_utf8)
9442cb0e 3082 : isDIGIT_LC_utf8((U8*)locinput)))
dfe13c55 3083 {
a0ed51b3 3084 sayNO;
dfe13c55 3085 }
6f06b55f 3086 locinput += PL_utf8skip[nextchr];
a0ed51b3
LW
3087 nextchr = UCHARAT(locinput);
3088 break;
3089 }
ffc61ed2 3090 if (!(OP(scan) == DIGIT
9442cb0e 3091 ? isDIGIT(nextchr) : isDIGIT_LC(nextchr)))
a0ed51b3
LW
3092 sayNO;
3093 nextchr = UCHARAT(++locinput);
3094 break;
d6a28714 3095 case NDIGITL:
b8c5462f
JH
3096 PL_reg_flags |= RF_tainted;
3097 /* FALL THROUGH */
d6a28714 3098 case NDIGIT:
9442cb0e 3099 if (!nextchr && locinput >= PL_regeol)
b8c5462f 3100 sayNO;
1aa99e6b 3101 if (do_utf8) {
8269fa76 3102 LOAD_UTF8_CHARCLASS(digit,"0");
ffc61ed2 3103 if (OP(scan) == NDIGIT
3568d838 3104 ? swash_fetch(PL_utf8_digit, (U8*)locinput, do_utf8)
9442cb0e
GS
3105 : isDIGIT_LC_utf8((U8*)locinput))
3106 {
a0ed51b3 3107 sayNO;
9442cb0e 3108 }
6f06b55f 3109 locinput += PL_utf8skip[nextchr];
a0ed51b3
LW
3110 nextchr = UCHARAT(locinput);
3111 break;
3112 }
ffc61ed2 3113 if (OP(scan) == NDIGIT
9442cb0e 3114 ? isDIGIT(nextchr) : isDIGIT_LC(nextchr))
a0ed51b3
LW
3115 sayNO;
3116 nextchr = UCHARAT(++locinput);
3117 break;
3118 case CLUMP:
b7c83a7e 3119 if (locinput >= PL_regeol)
a0ed51b3 3120 sayNO;
b7c83a7e
JH
3121 if (do_utf8) {
3122 LOAD_UTF8_CHARCLASS(mark,"~");
3123 if (swash_fetch(PL_utf8_mark,(U8*)locinput, do_utf8))
3124 sayNO;
3125 locinput += PL_utf8skip[nextchr];
3126 while (locinput < PL_regeol &&
3127 swash_fetch(PL_utf8_mark,(U8*)locinput, do_utf8))
3128 locinput += UTF8SKIP(locinput);
3129 if (locinput > PL_regeol)
3130 sayNO;
eb08e2da
JH
3131 }
3132 else
3133 locinput++;
a0ed51b3
LW
3134 nextchr = UCHARAT(locinput);
3135 break;
c8756f30 3136 case REFFL:
3280af22 3137 PL_reg_flags |= RF_tainted;
c8756f30 3138 /* FALL THROUGH */
c277df42 3139 case REF:
c8756f30 3140 case REFF:
c277df42 3141 n = ARG(scan); /* which paren pair */
cf93c79d 3142 ln = PL_regstartp[n];
2c2d71f5 3143 PL_reg_leftiter = PL_reg_maxiter; /* Void cache */
eb160463 3144 if ((I32)*PL_reglastparen < n || ln == -1)
af3f8c16 3145 sayNO; /* Do not match unless seen CLOSEn. */
cf93c79d 3146 if (ln == PL_regendp[n])
a0d0e21e 3147 break;
a0ed51b3 3148
cf93c79d 3149 s = PL_bostr + ln;
1aa99e6b 3150 if (do_utf8 && OP(scan) != REF) { /* REF can do byte comparison */
a0ed51b3 3151 char *l = locinput;
cf93c79d 3152 char *e = PL_bostr + PL_regendp[n];
a0ed51b3
LW
3153 /*
3154 * Note that we can't do the "other character" lookup trick as
3155 * in the 8-bit case (no pun intended) because in Unicode we
3156 * have to map both upper and title case to lower case.
3157 */
3158 if (OP(scan) == REFF) {
a2a2844f 3159 STRLEN ulen1, ulen2;
89ebb4a3
JH
3160 U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
3161 U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
a0ed51b3
LW
3162 while (s < e) {
3163 if (l >= PL_regeol)
3164 sayNO;
a2a2844f
JH
3165 toLOWER_utf8((U8*)s, tmpbuf1, &ulen1);
3166 toLOWER_utf8((U8*)l, tmpbuf2, &ulen2);
7114a2d2 3167 if (ulen1 != ulen2 || memNE((char *)tmpbuf1, (char *)tmpbuf2, ulen1))
a0ed51b3 3168 sayNO;
a2a2844f
JH
3169 s += ulen1;
3170 l += ulen2;
a0ed51b3
LW
3171 }
3172 }
3173 locinput = l;
3174 nextchr = UCHARAT(locinput);
3175 break;
3176 }
3177
a0d0e21e 3178 /* Inline the first character, for speed. */
76e3520e 3179 if (UCHARAT(s) != nextchr &&
c8756f30
AK
3180 (OP(scan) == REF ||
3181 (UCHARAT(s) != ((OP(scan) == REFF
22c35a8c 3182 ? PL_fold : PL_fold_locale)[nextchr]))))
4633a7c4 3183 sayNO;
cf93c79d 3184 ln = PL_regendp[n] - ln;
3280af22 3185 if (locinput + ln > PL_regeol)
4633a7c4 3186 sayNO;
c8756f30
AK
3187 if (ln > 1 && (OP(scan) == REF
3188 ? memNE(s, locinput, ln)
3189 : (OP(scan) == REFF
3190 ? ibcmp(s, locinput, ln)
3191 : ibcmp_locale(s, locinput, ln))))
4633a7c4 3192 sayNO;
a0d0e21e 3193 locinput += ln;
76e3520e 3194 nextchr = UCHARAT(locinput);
a0d0e21e
LW
3195 break;
3196
3197 case NOTHING:
c277df42 3198 case TAIL:
a0d0e21e
LW
3199 break;
3200 case BACK:
3201 break;
c277df42
IZ
3202 case EVAL:
3203 {
3204 dSP;
533c011a 3205 OP_4tree *oop = PL_op;
3280af22 3206 COP *ocurcop = PL_curcop;
f3548bdc 3207 PAD *old_comppad;
c277df42 3208 SV *ret;
080c2dec 3209 struct regexp *oreg = PL_reg_re;
9041c2e3 3210
c277df42 3211 n = ARG(scan);
533c011a 3212 PL_op = (OP_4tree*)PL_regdata->data[n];
a3621e74 3213 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log, " re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
f3548bdc 3214 PAD_SAVE_LOCAL(old_comppad, (PAD*)PL_regdata->data[n + 2]);
cf93c79d 3215 PL_regendp[0] = PL_reg_magic->mg_len = locinput - PL_bostr;
c277df42 3216
8e5e9ebe
RGS
3217 {
3218 SV **before = SP;
3219 CALLRUNOPS(aTHX); /* Scalar context. */
3220 SPAGAIN;
3221 if (SP == before)
075aa684 3222 ret = &PL_sv_undef; /* protect against empty (?{}) blocks. */
8e5e9ebe
RGS
3223 else {
3224 ret = POPs;
3225 PUTBACK;
3226 }
3227 }
3228
0f5d15d6 3229 PL_op = oop;
f3548bdc 3230 PAD_RESTORE_LOCAL(old_comppad);
0f5d15d6 3231 PL_curcop = ocurcop;
c277df42 3232 if (logical) {
0f5d15d6
IZ
3233 if (logical == 2) { /* Postponed subexpression. */
3234 regexp *re;
22c35a8c 3235 MAGIC *mg = Null(MAGIC*);
0f5d15d6 3236 re_cc_state state;
0f5d15d6 3237 CHECKPOINT cp, lastcp;
cb50f42d 3238 int toggleutf;
faf82a0b 3239 register SV *sv;
0f5d15d6 3240
faf82a0b
AE
3241 if(SvROK(ret) && SvSMAGICAL(sv = SvRV(ret)))
3242 mg = mg_find(sv, PERL_MAGIC_qr);
3243 else if (SvSMAGICAL(ret)) {
3244 if (SvGMAGICAL(ret))
3245 sv_unmagic(ret, PERL_MAGIC_qr);
3246 else
3247 mg = mg_find(ret, PERL_MAGIC_qr);
0f5d15d6 3248 }
faf82a0b 3249
0f5d15d6
IZ
3250 if (mg) {
3251 re = (regexp *)mg->mg_obj;
df0003d4 3252 (void)ReREFCNT_inc(re);
0f5d15d6
IZ
3253 }
3254 else {
3255 STRLEN len;
3256 char *t = SvPV(ret, len);
3257 PMOP pm;
3258 char *oprecomp = PL_regprecomp;
3259 I32 osize = PL_regsize;
3260 I32 onpar = PL_regnpar;
3261
5fcd1c1b 3262 Zero(&pm, 1, PMOP);
cb50f42d 3263 if (DO_UTF8(ret)) pm.op_pmdynflags |= PMdf_DYN_UTF8;
cea2e8a9 3264 re = CALLREGCOMP(aTHX_ t, t + len, &pm);
9041c2e3 3265 if (!(SvFLAGS(ret)
faf82a0b
AE
3266 & (SVs_TEMP | SVs_PADTMP | SVf_READONLY
3267 | SVs_GMG)))
14befaf4
DM
3268 sv_magic(ret,(SV*)ReREFCNT_inc(re),
3269 PERL_MAGIC_qr,0,0);
0f5d15d6
IZ
3270 PL_regprecomp = oprecomp;
3271 PL_regsize = osize;
3272 PL_regnpar = onpar;
3273 }
a3621e74 3274 DEBUG_EXECUTE_r(
9041c2e3 3275 PerlIO_printf(Perl_debug_log,
0f5d15d6
IZ
3276 "Entering embedded `%s%.60s%s%s'\n",
3277 PL_colors[0],
3278 re->precomp,
3279 PL_colors[1],
3280 (strlen(re->precomp) > 60 ? "..." : ""))
3281 );
3282 state.node = next;
3283 state.prev = PL_reg_call_cc;
3284 state.cc = PL_regcc;
3285 state.re = PL_reg_re;
3286
2ab05381 3287 PL_regcc = 0;
9041c2e3 3288
0f5d15d6 3289 cp = regcppush(0); /* Save *all* the positions. */
02db2b7b 3290 REGCP_SET(lastcp);
0f5d15d6
IZ
3291 cache_re(re);
3292 state.ss = PL_savestack_ix;
3293 *PL_reglastparen = 0;
a01268b5 3294 *PL_reglastcloseparen = 0;
0f5d15d6
IZ
3295 PL_reg_call_cc = &state;
3296 PL_reginput = locinput;
cb50f42d
YST
3297 toggleutf = ((PL_reg_flags & RF_utf8) != 0) ^
3298 ((re->reganch & ROPT_UTF8) != 0);
3299 if (toggleutf) PL_reg_flags ^= RF_utf8;
2c2d71f5
JH
3300
3301 /* XXXX This is too dramatic a measure... */
3302 PL_reg_maxiter = 0;
3303
0f5d15d6 3304 if (regmatch(re->program + 1)) {
2c914db6
IZ
3305 /* Even though we succeeded, we need to restore
3306 global variables, since we may be wrapped inside
3307 SUSPEND, thus the match may be not finished yet. */
3308
3309 /* XXXX Do this only if SUSPENDed? */
3310 PL_reg_call_cc = state.prev;
3311 PL_regcc = state.cc;
3312 PL_reg_re = state.re;
3313 cache_re(PL_reg_re);
cb50f42d 3314 if (toggleutf) PL_reg_flags ^= RF_utf8;
2c914db6
IZ
3315
3316 /* XXXX This is too dramatic a measure... */
3317 PL_reg_maxiter = 0;
3318
3319 /* These are needed even if not SUSPEND. */
0f5d15d6
IZ
3320 ReREFCNT_dec(re);
3321 regcpblow(cp);
3322 sayYES;
3323 }
0f5d15d6 3324 ReREFCNT_dec(re);
02db2b7b 3325 REGCP_UNWIND(lastcp);
0f5d15d6
IZ
3326 regcppop();
3327 PL_reg_call_cc = state.prev;
3328 PL_regcc = state.cc;
3329 PL_reg_re = state.re;
d3790889 3330 cache_re(PL_reg_re);
cb50f42d 3331 if (toggleutf) PL_reg_flags ^= RF_utf8;
2c2d71f5
JH
3332
3333 /* XXXX This is too dramatic a measure... */
3334 PL_reg_maxiter = 0;
3335
8e514ae6 3336 logical = 0;
0f5d15d6
IZ
3337 sayNO;
3338 }
c277df42 3339 sw = SvTRUE(ret);
0f5d15d6 3340 logical = 0;
a0ed51b3 3341 }
080c2dec 3342 else {
3280af22 3343 sv_setsv(save_scalar(PL_replgv), ret);
080c2dec
AE
3344 cache_re(oreg);
3345 }
c277df42
IZ
3346 break;
3347 }
a0d0e21e 3348 case OPEN:
c277df42 3349 n = ARG(scan); /* which paren pair */
3280af22
NIS
3350 PL_reg_start_tmp[n] = locinput;
3351 if (n > PL_regsize)
3352 PL_regsize = n;
a0d0e21e
LW
3353 break;
3354 case CLOSE:
c277df42 3355 n = ARG(scan); /* which paren pair */
cf93c79d
IZ
3356 PL_regstartp[n] = PL_reg_start_tmp[n] - PL_bostr;
3357 PL_regendp[n] = locinput - PL_bostr;
eb160463 3358 if (n > (I32)*PL_reglastparen)
3280af22 3359 *PL_reglastparen = n;
a01268b5 3360 *PL_reglastcloseparen = n;
a0d0e21e 3361 break;
c277df42
IZ
3362 case GROUPP:
3363 n = ARG(scan); /* which paren pair */
eb160463 3364 sw = ((I32)*PL_reglastparen >= n && PL_regendp[n] != -1);
c277df42
IZ
3365 break;
3366 case IFTHEN:
2c2d71f5 3367 PL_reg_leftiter = PL_reg_maxiter; /* Void cache */
c277df42
IZ
3368 if (sw)
3369 next = NEXTOPER(NEXTOPER(scan));
3370 else {
3371 next = scan + ARG(scan);
3372 if (OP(next) == IFTHEN) /* Fake one. */
3373 next = NEXTOPER(NEXTOPER(next));
3374 }
3375 break;
3376 case LOGICAL:
0f5d15d6 3377 logical = scan->flags;
c277df42 3378 break;
2ab05381
IZ
3379/*******************************************************************
3380 PL_regcc contains infoblock about the innermost (...)* loop, and
3381 a pointer to the next outer infoblock.
3382
3383 Here is how Y(A)*Z is processed (if it is compiled into CURLYX/WHILEM):
3384
3385 1) After matching X, regnode for CURLYX is processed;
3386
9041c2e3 3387 2) This regnode creates infoblock on the stack, and calls
2ab05381
IZ
3388 regmatch() recursively with the starting point at WHILEM node;
3389
3390 3) Each hit of WHILEM node tries to match A and Z (in the order
3391 depending on the current iteration, min/max of {min,max} and
3392 greediness). The information about where are nodes for "A"
3393 and "Z" is read from the infoblock, as is info on how many times "A"
3394 was already matched, and greediness.
3395
3396 4) After A matches, the same WHILEM node is hit again.
3397
3398 5) Each time WHILEM is hit, PL_regcc is the infoblock created by CURLYX
3399 of the same pair. Thus when WHILEM tries to match Z, it temporarily
3400 resets PL_regcc, since this Y(A)*Z can be a part of some other loop:
3401 as in (Y(A)*Z)*. If Z matches, the automaton will hit the WHILEM node
3402 of the external loop.
3403
3404 Currently present infoblocks form a tree with a stem formed by PL_curcc
3405 and whatever it mentions via ->next, and additional attached trees
3406 corresponding to temporarily unset infoblocks as in "5" above.
3407
9041c2e3 3408 In the following picture infoblocks for outer loop of
2ab05381
IZ
3409 (Y(A)*?Z)*?T are denoted O, for inner I. NULL starting block
3410 is denoted by x. The matched string is YAAZYAZT. Temporarily postponed
3411 infoblocks are drawn below the "reset" infoblock.
3412
3413 In fact in the picture below we do not show failed matches for Z and T
3414 by WHILEM blocks. [We illustrate minimal matches, since for them it is
3415 more obvious *why* one needs to *temporary* unset infoblocks.]
3416
3417 Matched REx position InfoBlocks Comment
3418 (Y(A)*?Z)*?T x
3419 Y(A)*?Z)*?T x <- O
3420 Y (A)*?Z)*?T x <- O
3421 Y A)*?Z)*?T x <- O <- I
3422 YA )*?Z)*?T x <- O <- I
3423 YA A)*?Z)*?T x <- O <- I
3424 YAA )*?Z)*?T x <- O <- I
3425 YAA Z)*?T x <- O # Temporary unset I
3426 I
3427
3428 YAAZ Y(A)*?Z)*?T x <- O
3429 I
3430
3431 YAAZY (A)*?Z)*?T x <- O
3432 I
3433
3434 YAAZY A)*?Z)*?T x <- O <- I
3435 I
3436
3437 YAAZYA )*?Z)*?T x <- O <- I
3438 I
3439
3440 YAAZYA Z)*?T x <- O # Temporary unset I
3441 I,I
3442
3443 YAAZYAZ )*?T x <- O
3444 I,I
3445
3446 YAAZYAZ T x # Temporary unset O
3447 O
3448 I,I
3449
3450 YAAZYAZT x
3451 O
3452 I,I
3453 *******************************************************************/
a0d0e21e
LW
3454 case CURLYX: {
3455 CURCUR cc;
3280af22 3456 CHECKPOINT cp = PL_savestack_ix;
cb434fcc
IZ
3457 /* No need to save/restore up to this paren */
3458 I32 parenfloor = scan->flags;
c277df42
IZ
3459
3460 if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
3461 next += ARG(next);
3280af22
NIS
3462 cc.oldcc = PL_regcc;
3463 PL_regcc = &cc;
cb434fcc
IZ
3464 /* XXXX Probably it is better to teach regpush to support
3465 parenfloor > PL_regsize... */
eb160463 3466 if (parenfloor > (I32)*PL_reglastparen)
cb434fcc
IZ
3467 parenfloor = *PL_reglastparen; /* Pessimization... */
3468 cc.parenfloor = parenfloor;
a0d0e21e
LW
3469 cc.cur = -1;
3470 cc.min = ARG1(scan);
3471 cc.max = ARG2(scan);
c277df42 3472 cc.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
a0d0e21e
LW
3473 cc.next = next;
3474 cc.minmod = minmod;
3475 cc.lastloc = 0;
3280af22 3476 PL_reginput = locinput;
a0d0e21e
LW
3477 n = regmatch(PREVOPER(next)); /* start on the WHILEM */
3478 regcpblow(cp);
3280af22 3479 PL_regcc = cc.oldcc;
4633a7c4 3480 saySAME(n);
a0d0e21e
LW
3481 }
3482 /* NOT REACHED */
3483 case WHILEM: {
3484 /*
3485 * This is really hard to understand, because after we match
3486 * what we're trying to match, we must make sure the rest of
2c2d71f5 3487 * the REx is going to match for sure, and to do that we have
a0d0e21e
LW
3488 * to go back UP the parse tree by recursing ever deeper. And
3489 * if it fails, we have to reset our parent's current state
3490 * that we can try again after backing off.
3491 */
3492
c277df42 3493 CHECKPOINT cp, lastcp;
3280af22 3494 CURCUR* cc = PL_regcc;
c277df42
IZ
3495 char *lastloc = cc->lastloc; /* Detection of 0-len. */
3496
4633a7c4 3497 n = cc->cur + 1; /* how many we know we matched */
3280af22 3498 PL_reginput = locinput;
a0d0e21e 3499
a3621e74 3500 DEBUG_EXECUTE_r(
9041c2e3 3501 PerlIO_printf(Perl_debug_log,
91f3b821 3502 "%*s %ld out of %ld..%ld cc=%"UVxf"\n",
3280af22 3503 REPORT_CODE_OFF+PL_regindent*2, "",
9041c2e3 3504 (long)n, (long)cc->min,
2797576d 3505 (long)cc->max, PTR2UV(cc))
c277df42 3506 );
4633a7c4 3507
a0d0e21e
LW
3508 /* If degenerate scan matches "", assume scan done. */
3509
579cf2c3 3510 if (locinput == cc->lastloc && n >= cc->min) {
3280af22 3511 PL_regcc = cc->oldcc;
2ab05381
IZ
3512 if (PL_regcc)
3513 ln = PL_regcc->cur;
a3621e74 3514 DEBUG_EXECUTE_r(
c3464db5
DD
3515 PerlIO_printf(Perl_debug_log,
3516 "%*s empty match detected, try continuation...\n",
3280af22 3517 REPORT_CODE_OFF+PL_regindent*2, "")
c277df42 3518 );
a0d0e21e 3519 if (regmatch(cc->next))
4633a7c4 3520 sayYES;
2ab05381
IZ
3521 if (PL_regcc)
3522 PL_regcc->cur = ln;
3280af22 3523 PL_regcc = cc;
4633a7c4 3524 sayNO;
a0d0e21e
LW
3525 }
3526
3527 /* First just match a string of min scans. */
3528
3529 if (n < cc->min) {
3530 cc->cur = n;
3531 cc->lastloc = locinput;
4633a7c4
LW
3532 if (regmatch(cc->scan))
3533 sayYES;
3534 cc->cur = n - 1;
c277df42 3535 cc->lastloc = lastloc;
4633a7c4 3536 sayNO;
a0d0e21e
LW
3537 }
3538
2c2d71f5
JH
3539 if (scan->flags) {
3540 /* Check whether we already were at this position.
3541 Postpone detection until we know the match is not
3542 *that* much linear. */
3543 if (!PL_reg_maxiter) {
3544 PL_reg_maxiter = (PL_regeol - PL_bostr + 1) * (scan->flags>>4);
3545 PL_reg_leftiter = PL_reg_maxiter;
3546 }
3547 if (PL_reg_leftiter-- == 0) {
c689e61c 3548 I32 size = (PL_reg_maxiter + 7 + POSCACHE_START)/8;
2c2d71f5 3549 if (PL_reg_poscache) {
eb160463 3550 if ((I32)PL_reg_poscache_size < size) {
2c2d71f5
JH
3551 Renew(PL_reg_poscache, size, char);
3552 PL_reg_poscache_size = size;
3553 }
3554 Zero(PL_reg_poscache, size, char);
3555 }
3556 else {
3557 PL_reg_poscache_size = size;
3558 Newz(29, PL_reg_poscache, size, char);
3559 }
a3621e74 3560 DEBUG_EXECUTE_r(