src/5015006/regexec.c

   1 /*    regexec.c
   2  */
   3
   4 /*
   5  *      One Ring to rule them all, One Ring to find them
   6  &
   7  *     [p.v of _The Lord of the Rings_, opening poem]
   8  *     [p.50 of _The Lord of the Rings_, I/iii: "The Shadow of the Past"]
   9  *     [p.254 of _The Lord of the Rings_, II/ii: "The Council of Elrond"]
  10  */
  11
  12 /* This file contains functions for executing a regular expression.  See
  13  * also regcomp.c which funnily enough, contains functions for compiling
  14  * a regular expression.
  15  *
  16  * This file is also copied at build time to ext/re/re_exec.c, where
  17  * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
  18  * This causes the main functions to be compiled under new names and with
  19  * debugging support added, which makes "use re 'debug'" work.
  20  */
  21
  22 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
  23  * confused with the original package (see point 3 below).  Thanks, Henry!
  24  */
  25
  26 /* Additional note: this code is very heavily munged from Henry's version
  27  * in places.  In some spots I've traded clarity for efficiency, so don't
  28  * blame Henry for some of the lack of readability.
  29  */
  30
  31 /* The names of the functions have been changed from regcomp and
  32  * regexec to  pregcomp and pregexec in order to avoid conflicts
  33  * with the POSIX routines of the same names.
  34 */
  35
  36 #ifdef PERL_EXT_RE_BUILD
  37 #include "re_top.h"
  38 #endif
  39
  40 /*
  41  * pregcomp and pregexec -- regsub and regerror are not used in perl
  42  *
  43  *      Copyright (c) 1986 by University of Toronto.
  44  *      Written by Henry Spencer.  Not derived from licensed software.
  45  *
  46  *      Permission is granted to anyone to use this software for any
  47  *      purpose on any computer system, and to redistribute it freely,
  48  *      subject to the following restrictions:
  49  *
  50  *      1. The author is not responsible for the consequences of use of
  51  *              this software, no matter how awful, even if they arise
  52  *              from defects in it.
  53  *
  54  *      2. The origin of this software must not be misrepresented, either
  55  *              by explicit claim or by omission.
  56  *
  57  *      3. Altered versions must be plainly marked as such, and must not
  58  *              be misrepresented as being the original software.
  59  *
  60  ****    Alterations to Henry's code are...
  61  ****
  62  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
  63  ****    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
  64  ****    by Larry Wall and others
  65  ****
  66  ****    You may distribute under the terms of either the GNU General Public
  67  ****    License or the Artistic License, as specified in the README file.
  68  *
  69  * Beware that some of this code is subtly aware of the way operator
  70  * precedence is structured in regular expressions.  Serious changes in
  71  * regular-expression syntax might require a total rethink.
  72  */
  73 #include "EXTERN.h"
  74 #define PERL_IN_REGEXEC_C
  75 #include "perl.h"
  76 #include "re_defs.h"
  77
  78 #ifdef PERL_IN_XSUB_RE
  79 #  include "re_comp.h"
  80 #else
  81 #  include "regcomp.h"
  82 #endif
  83
  84 #define RF_tainted      1       /* tainted information used? e.g. locale */
  85 #define RF_warned       2               /* warned about big count? */
  86
  87 #define RF_utf8         8               /* Pattern contains multibyte chars? */
  88
  89 #define UTF_PATTERN ((PL_reg_flags & RF_utf8) != 0)
  90
  91 #define RS_init         1               /* eval environment created */
  92 #define RS_set          2               /* replsv value is set */
  93
  94 #ifndef STATIC
  95 #define STATIC  static
  96 #endif
  97
  98 /* Valid for non-utf8 strings, non-ANYOFV nodes only: avoids the reginclass
  99  * call if there are no complications: i.e., if everything matchable is
 100  * straight forward in the bitmap */
 101 #define REGINCLASS(prog,p,c)  (ANYOF_FLAGS(p) ? reginclass(prog,p,c,0,0)   \
 102                                               : ANYOF_BITMAP_TEST(p,*(c)))
 103
 104 /*
 105  * Forwards.
 106  */
 107
 108 #define CHR_SVLEN(sv) (utf8_target ? sv_len_utf8(sv) : SvCUR(sv))
 109 #define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
 110
 111 #define HOPc(pos,off) \
 112         (char *)(PL_reg_match_utf8 \
 113             ? reghop3((U8*)pos, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr)) \
 114             : (U8*)(pos + off))
 115 #define HOPBACKc(pos, off) \
 116         (char*)(PL_reg_match_utf8\
 117             ? reghopmaybe3((U8*)pos, -off, (U8*)PL_bostr) \
 118             : (pos - off >= PL_bostr)           \
 119                 ? (U8*)pos - off                \
 120                 : NULL)
 121
 122 #define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)(pos), off, (U8*)(lim)) : (U8*)(pos + off))
 123 #define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
 124
 125 /* these are unrolled below in the CCC_TRY_XXX defined */
 126 #ifdef EBCDIC
 127     /* Often 'str' is a hard-coded utf8 string instead of utfebcdic. so just
 128      * skip the check on EBCDIC platforms */
 129 #   define LOAD_UTF8_CHARCLASS(class,str) LOAD_UTF8_CHARCLASS_NO_CHECK(class)
 130 #else
 131 #   define LOAD_UTF8_CHARCLASS(class,str) STMT_START { \
 132     if (!CAT2(PL_utf8_,class)) { \
 133         bool ok; \
 134         ENTER; save_re_context(); \
 135         ok=CAT2(is_utf8_,class)((const U8*)str); \
 136         assert(ok); assert(CAT2(PL_utf8_,class)); LEAVE; } } STMT_END
 137 #endif
 138
 139 /* Doesn't do an assert to verify that is correct */
 140 #define LOAD_UTF8_CHARCLASS_NO_CHECK(class) STMT_START { \
 141     if (!CAT2(PL_utf8_,class)) { \
 142         bool throw_away PERL_UNUSED_DECL; \
 143         ENTER; save_re_context(); \
 144         throw_away = CAT2(is_utf8_,class)((const U8*)" "); \
 145         LEAVE; } } STMT_END
 146
 147 #define LOAD_UTF8_CHARCLASS_ALNUM() LOAD_UTF8_CHARCLASS(alnum,"a")
 148 #define LOAD_UTF8_CHARCLASS_DIGIT() LOAD_UTF8_CHARCLASS(digit,"0")
 149 #define LOAD_UTF8_CHARCLASS_SPACE() LOAD_UTF8_CHARCLASS(space," ")
 150
 151 #define LOAD_UTF8_CHARCLASS_GCB()  /* Grapheme cluster boundaries */        \
 152         LOAD_UTF8_CHARCLASS(X_begin, " ");                                  \
 153         LOAD_UTF8_CHARCLASS(X_non_hangul, "A");                             \
 154         /* These are utf8 constants, and not utf-ebcdic constants, so the   \
 155             * assert should likely and hopefully fail on an EBCDIC machine */ \
 156         LOAD_UTF8_CHARCLASS(X_extend, "\xcc\x80"); /* U+0300 */             \
 157                                                                             \
 158         /* No asserts are done for these, in case called on an early        \
 159             * Unicode version in which they map to nothing */               \
 160         LOAD_UTF8_CHARCLASS_NO_CHECK(X_prepend);/* U+0E40 "\xe0\xb9\x80" */ \
 161         LOAD_UTF8_CHARCLASS_NO_CHECK(X_L);          /* U+1100 "\xe1\x84\x80" */ \
 162         LOAD_UTF8_CHARCLASS_NO_CHECK(X_LV);     /* U+AC00 "\xea\xb0\x80" */ \
 163         LOAD_UTF8_CHARCLASS_NO_CHECK(X_LVT);    /* U+AC01 "\xea\xb0\x81" */ \
 164         LOAD_UTF8_CHARCLASS_NO_CHECK(X_LV_LVT_V);/* U+AC01 "\xea\xb0\x81" */\
 165         LOAD_UTF8_CHARCLASS_NO_CHECK(X_T);      /* U+11A8 "\xe1\x86\xa8" */ \
 166         LOAD_UTF8_CHARCLASS_NO_CHECK(X_V)       /* U+1160 "\xe1\x85\xa0" */
 167
 168 #define PLACEHOLDER     /* Something for the preprocessor to grab onto */
 169
 170 /* The actual code for CCC_TRY, which uses several variables from the routine
 171  * it's callable from.  It is designed to be the bulk of a case statement.
 172  * FUNC is the macro or function to call on non-utf8 targets that indicate if
 173  *      nextchr matches the class.
 174  * UTF8_TEST is the whole test string to use for utf8 targets
 175  * LOAD is what to use to test, and if not present to load in the swash for the
 176  *      class
 177  * POS_OR_NEG is either empty or ! to complement the results of FUNC or
 178  *      UTF8_TEST test.
 179  * The logic is: Fail if we're at the end-of-string; otherwise if the target is
 180  * utf8 and a variant, load the swash if necessary and test using the utf8
 181  * test.  Advance to the next character if test is ok, otherwise fail; If not
 182  * utf8 or an invariant under utf8, use the non-utf8 test, and fail if it
 183  * fails, or advance to the next character */
 184
 185 #define _CCC_TRY_CODE(POS_OR_NEG, FUNC, UTF8_TEST, CLASS, STR)                \
 186     if (locinput >= PL_regeol) {                                              \
 187         sayNO;                                                                \
 188     }                                                                         \
 189     if (utf8_target && UTF8_IS_CONTINUED(nextchr)) {                          \
 190         LOAD_UTF8_CHARCLASS(CLASS, STR);                                      \
 191         if (POS_OR_NEG (UTF8_TEST)) {                                         \
 192             sayNO;                                                            \
 193         }                                                                     \
 194         locinput += PL_utf8skip[nextchr];                                     \
 195         nextchr = UCHARAT(locinput);                                          \
 196         break;                                                                \
 197     }                                                                         \
 198     if (POS_OR_NEG (FUNC(nextchr))) {                                         \
 199         sayNO;                                                                \
 200     }                                                                         \
 201     nextchr = UCHARAT(++locinput);                                            \
 202     break;
 203
 204 /* Handle the non-locale cases for a character class and its complement.  It
 205  * calls _CCC_TRY_CODE with a ! to complement the test for the character class.
 206  * This is because that code fails when the test succeeds, so we want to have
 207  * the test fail so that the code succeeds.  The swash is stored in a
 208  * predictable PL_ place */
 209 #define _CCC_TRY_NONLOCALE(NAME,  NNAME,  FUNC,                               \
 210                            CLASS, STR)                                        \
 211     case NAME:                                                                \
 212         _CCC_TRY_CODE( !, FUNC,                                               \
 213                           cBOOL(swash_fetch(CAT2(PL_utf8_,CLASS),             \
 214                                             (U8*)locinput, TRUE)),            \
 215                           CLASS, STR)                                         \
 216     case NNAME:                                                               \
 217         _CCC_TRY_CODE(  PLACEHOLDER , FUNC,                                   \
 218                           cBOOL(swash_fetch(CAT2(PL_utf8_,CLASS),             \
 219                                             (U8*)locinput, TRUE)),            \
 220                           CLASS, STR)                                         \
 221
 222 /* Generate the case statements for both locale and non-locale character
 223  * classes in regmatch for classes that don't have special unicode semantics.
 224  * Locales don't use an immediate swash, but an intermediary special locale
 225  * function that is called on the pointer to the current place in the input
 226  * string.  That function will resolve to needing the same swash.  One might
 227  * think that because we don't know what the locale will match, we shouldn't
 228  * check with the swash loading function that it loaded properly; ie, that we
 229  * should use LOAD_UTF8_CHARCLASS_NO_CHECK for those, but what is passed to the
 230  * regular LOAD_UTF8_CHARCLASS is in non-locale terms, and so locale is
 231  * irrelevant here */
 232 #define CCC_TRY(NAME,  NNAME,  FUNC,                                          \
 233                 NAMEL, NNAMEL, LCFUNC, LCFUNC_utf8,                           \
 234                 NAMEA, NNAMEA, FUNCA,                                         \
 235                 CLASS, STR)                                                   \
 236     case NAMEL:                                                               \
 237         PL_reg_flags |= RF_tainted;                                           \
 238         _CCC_TRY_CODE( !, LCFUNC, LCFUNC_utf8((U8*)locinput), CLASS, STR)     \
 239     case NNAMEL:                                                              \
 240         PL_reg_flags |= RF_tainted;                                           \
 241         _CCC_TRY_CODE( PLACEHOLDER, LCFUNC, LCFUNC_utf8((U8*)locinput),       \
 242                        CLASS, STR)                                            \
 243     case NAMEA:                                                               \
 244         if (locinput >= PL_regeol || ! FUNCA(nextchr)) {                      \
 245             sayNO;                                                            \
 246         }                                                                     \
 247         /* Matched a utf8-invariant, so don't have to worry about utf8 */     \
 248         nextchr = UCHARAT(++locinput);                                        \
 249         break;                                                                \
 250     case NNAMEA:                                                              \
 251         if (locinput >= PL_regeol || FUNCA(nextchr)) {                        \
 252             sayNO;                                                            \
 253         }                                                                     \
 254         if (utf8_target) {                                                    \
 255             locinput += PL_utf8skip[nextchr];                                 \
 256             nextchr = UCHARAT(locinput);                                      \
 257         }                                                                     \
 258         else {                                                                \
 259             nextchr = UCHARAT(++locinput);                                    \
 260         }                                                                     \
 261         break;                                                                \
 262     /* Generate the non-locale cases */                                       \
 263     _CCC_TRY_NONLOCALE(NAME, NNAME, FUNC, CLASS, STR)
 264
 265 /* This is like CCC_TRY, but has an extra set of parameters for generating case
 266  * statements to handle separate Unicode semantics nodes */
 267 #define CCC_TRY_U(NAME,  NNAME,  FUNC,                                         \
 268                   NAMEL, NNAMEL, LCFUNC, LCFUNC_utf8,                          \
 269                   NAMEU, NNAMEU, FUNCU,                                        \
 270                   NAMEA, NNAMEA, FUNCA,                                        \
 271                   CLASS, STR)                                                  \
 272     CCC_TRY(NAME, NNAME, FUNC,                                                 \
 273             NAMEL, NNAMEL, LCFUNC, LCFUNC_utf8,                                \
 274             NAMEA, NNAMEA, FUNCA,                                              \
 275             CLASS, STR)                                                        \
 276     _CCC_TRY_NONLOCALE(NAMEU, NNAMEU, FUNCU, CLASS, STR)
 277
 278 /* TODO: Combine JUMPABLE and HAS_TEXT to cache OP(rn) */
 279
 280 /* for use after a quantifier and before an EXACT-like node -- japhy */
 281 /* it would be nice to rework regcomp.sym to generate this stuff. sigh
 282  *
 283  * NOTE that *nothing* that affects backtracking should be in here, specifically
 284  * VERBS must NOT be included. JUMPABLE is used to determine  if we can ignore a
 285  * node that is in between two EXACT like nodes when ascertaining what the required
 286  * "follow" character is. This should probably be moved to regex compile time
 287  * although it may be done at run time beause of the REF possibility - more
 288  * investigation required. -- demerphq
 289 */
 290 #define JUMPABLE(rn) (      \
 291     OP(rn) == OPEN ||       \
 292     (OP(rn) == CLOSE && (!cur_eval || cur_eval->u.eval.close_paren != ARG(rn))) || \
 293     OP(rn) == EVAL ||   \
 294     OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
 295     OP(rn) == PLUS || OP(rn) == MINMOD || \
 296     OP(rn) == KEEPS || \
 297     (PL_regkind[OP(rn)] == CURLY && ARG1(rn) > 0) \
 298 )
 299 #define IS_EXACT(rn) (PL_regkind[OP(rn)] == EXACT)
 300
 301 #define HAS_TEXT(rn) ( IS_EXACT(rn) || PL_regkind[OP(rn)] == REF )
 302
 303 #if 0
 304 /* Currently these are only used when PL_regkind[OP(rn)] == EXACT so
 305    we don't need this definition. */
 306 #define IS_TEXT(rn)   ( OP(rn)==EXACT   || OP(rn)==REF   || OP(rn)==NREF   )
 307 #define IS_TEXTF(rn)  ( (OP(rn)==EXACTFU || OP(rn)==EXACTFA ||  OP(rn)==EXACTF)  || OP(rn)==REFF  || OP(rn)==NREFF )
 308 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL || OP(rn)==REFFL || OP(rn)==NREFFL )
 309
 310 #else
 311 /* ... so we use this as its faster. */
 312 #define IS_TEXT(rn)   ( OP(rn)==EXACT   )
 313 #define IS_TEXTFU(rn)  ( OP(rn)==EXACTFU || OP(rn) == EXACTFA)
 314 #define IS_TEXTF(rn)  ( OP(rn)==EXACTF  )
 315 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
 316
 317 #endif
 318
 319 /*
 320   Search for mandatory following text node; for lookahead, the text must
 321   follow but for lookbehind (rn->flags != 0) we skip to the next step.
 322 */
 323 #define FIND_NEXT_IMPT(rn) STMT_START { \
 324     while (JUMPABLE(rn)) { \
 325         const OPCODE type = OP(rn); \
 326         if (type == SUSPEND || PL_regkind[type] == CURLY) \
 327             rn = NEXTOPER(NEXTOPER(rn)); \
 328         else if (type == PLUS) \
 329             rn = NEXTOPER(rn); \
 330         else if (type == IFMATCH) \
 331             rn = (rn->flags == 0) ? NEXTOPER(NEXTOPER(rn)) : rn + ARG(rn); \
 332         else rn += NEXT_OFF(rn); \
 333     } \
 334 } STMT_END
 335
 336
 337 static void restore_pos(pTHX_ void *arg);
 338
 339 #define REGCP_PAREN_ELEMS 4
 340 #define REGCP_OTHER_ELEMS 5
 341 #define REGCP_FRAME_ELEMS 1
 342 /* REGCP_FRAME_ELEMS are not part of the REGCP_OTHER_ELEMS and
 343  * are needed for the regexp context stack bookkeeping. */
 344
 345 STATIC CHECKPOINT
 346 S_regcppush(pTHX_ I32 parenfloor)
 347 {
 348     dVAR;
 349     const int retval = PL_savestack_ix;
 350     const int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
 351     const UV total_elems = paren_elems_to_push + REGCP_OTHER_ELEMS;
 352     const UV elems_shifted = total_elems << SAVE_TIGHT_SHIFT;
 353     int p;
 354     GET_RE_DEBUG_FLAGS_DECL;
 355
 356     if (paren_elems_to_push < 0)
 357         Perl_croak(aTHX_ "panic: paren_elems_to_push < 0");
 358
 359     if ((elems_shifted >> SAVE_TIGHT_SHIFT) != total_elems)
 360         Perl_croak(aTHX_ "panic: paren_elems_to_push offset %"UVuf
 361                    " out of range (%lu-%ld)",
 362                    total_elems, (unsigned long)PL_regsize, (long)parenfloor);
 363
 364     SSGROW(total_elems + REGCP_FRAME_ELEMS);
 365
 366     for (p = PL_regsize; p > parenfloor; p--) {
 367 /* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
 368         SSPUSHINT(PL_regoffs[p].end);
 369         SSPUSHINT(PL_regoffs[p].start);
 370         SSPUSHPTR(PL_reg_start_tmp[p]);
 371         SSPUSHINT(p);
 372         DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
 373           "     saving \\%"UVuf" %"IVdf"(%"IVdf")..%"IVdf"\n",
 374                       (UV)p, (IV)PL_regoffs[p].start,
 375                       (IV)(PL_reg_start_tmp[p] - PL_bostr),
 376                       (IV)PL_regoffs[p].end
 377         ));
 378     }
 379 /* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
 380     SSPUSHPTR(PL_regoffs);
 381     SSPUSHINT(PL_regsize);
 382     SSPUSHINT(*PL_reglastparen);
 383     SSPUSHINT(*PL_reglastcloseparen);
 384     SSPUSHPTR(PL_reginput);
 385     SSPUSHUV(SAVEt_REGCONTEXT | elems_shifted); /* Magic cookie. */
 386
 387     return retval;
 388 }
 389
 390 /* These are needed since we do not localize EVAL nodes: */
 391 #define REGCP_SET(cp)                                           \
 392     DEBUG_STATE_r(                                              \
 393             PerlIO_printf(Perl_debug_log,                       \
 394                 "  Setting an EVAL scope, savestack=%"IVdf"\n", \
 395                 (IV)PL_savestack_ix));                          \
 396     cp = PL_savestack_ix
 397
 398 #define REGCP_UNWIND(cp)                                        \
 399     DEBUG_STATE_r(                                              \
 400         if (cp != PL_savestack_ix)                              \
 401             PerlIO_printf(Perl_debug_log,                       \
 402                 "  Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
 403                 (IV)(cp), (IV)PL_savestack_ix));                \
 404     regcpblow(cp)
 405
 406 STATIC char *
 407 S_regcppop(pTHX_ const regexp *rex)
 408 {
 409     dVAR;
 410     UV i;
 411     char *input;
 412     GET_RE_DEBUG_FLAGS_DECL;
 413
 414     PERL_ARGS_ASSERT_REGCPPOP;
 415
 416     /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
 417     i = SSPOPUV;
 418     assert((i & SAVE_MASK) == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
 419     i >>= SAVE_TIGHT_SHIFT; /* Parentheses elements to pop. */
 420     input = (char *) SSPOPPTR;
 421     *PL_reglastcloseparen = SSPOPINT;
 422     *PL_reglastparen = SSPOPINT;
 423     PL_regsize = SSPOPINT;
 424     PL_regoffs=(regexp_paren_pair *) SSPOPPTR;
 425
 426     i -= REGCP_OTHER_ELEMS;
 427     /* Now restore the parentheses context. */
 428     for ( ; i > 0; i -= REGCP_PAREN_ELEMS) {
 429         I32 tmps;
 430         U32 paren = (U32)SSPOPINT;
 431         PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
 432         PL_regoffs[paren].start = SSPOPINT;
 433         tmps = SSPOPINT;
 434         if (paren <= *PL_reglastparen)
 435             PL_regoffs[paren].end = tmps;
 436         DEBUG_BUFFERS_r(
 437             PerlIO_printf(Perl_debug_log,
 438                           "     restoring \\%"UVuf" to %"IVdf"(%"IVdf")..%"IVdf"%s\n",
 439                           (UV)paren, (IV)PL_regoffs[paren].start,
 440                           (IV)(PL_reg_start_tmp[paren] - PL_bostr),
 441                           (IV)PL_regoffs[paren].end,
 442                           (paren > *PL_reglastparen ? "(no)" : ""));
 443         );
 444     }
 445     DEBUG_BUFFERS_r(
 446         if (*PL_reglastparen + 1 <= rex->nparens) {
 447             PerlIO_printf(Perl_debug_log,
 448                           "     restoring \\%"IVdf"..\\%"IVdf" to undef\n",
 449                           (IV)(*PL_reglastparen + 1), (IV)rex->nparens);
 450         }
 451     );
 452 #if 1
 453     /* It would seem that the similar code in regtry()
 454      * already takes care of this, and in fact it is in
 455      * a better location to since this code can #if 0-ed out
 456      * but the code in regtry() is needed or otherwise tests
 457      * requiring null fields (pat.t#187 and split.t#{13,14}
 458      * (as of patchlevel 7877)  will fail.  Then again,
 459      * this code seems to be necessary or otherwise
 460      * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
 461      * --jhi updated by dapm */
 462     for (i = *PL_reglastparen + 1; i <= rex->nparens; i++) {
 463         if (i > PL_regsize)
 464             PL_regoffs[i].start = -1;
 465         PL_regoffs[i].end = -1;
 466     }
 467 #endif
 468     return input;
 469 }
 470
 471 #define regcpblow(cp) LEAVE_SCOPE(cp)   /* Ignores regcppush()ed data. */
 472
 473 /*
 474  * pregexec and friends
 475  */
 476
 477 #ifndef PERL_IN_XSUB_RE
 478 /*
 479  - pregexec - match a regexp against a string
 480  */
 481 I32
 482 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, register char *strend,
 483          char *strbeg, I32 minend, SV *screamer, U32 nosave)
 484 /* strend: pointer to null at end of string */
 485 /* strbeg: real beginning of string */
 486 /* minend: end of match must be >=minend after stringarg. */
 487 /* nosave: For optimizations. */
 488 {
 489     PERL_ARGS_ASSERT_PREGEXEC;
 490
 491     return
 492         regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
 493                       nosave ? 0 : REXEC_COPY_STR);
 494 }
 495 #endif
 496
 497 /*
 498  * Need to implement the following flags for reg_anch:
 499  *
 500  * USE_INTUIT_NOML              - Useful to call re_intuit_start() first
 501  * USE_INTUIT_ML
 502  * INTUIT_AUTORITATIVE_NOML     - Can trust a positive answer
 503  * INTUIT_AUTORITATIVE_ML
 504  * INTUIT_ONCE_NOML             - Intuit can match in one location only.
 505  * INTUIT_ONCE_ML
 506  *
 507  * Another flag for this function: SECOND_TIME (so that float substrs
 508  * with giant delta may be not rechecked).
 509  */
 510
 511 /* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
 512
 513 /* If SCREAM, then SvPVX_const(sv) should be compatible with strpos and strend.
 514    Otherwise, only SvCUR(sv) is used to get strbeg. */
 515
 516 /* XXXX We assume that strpos is strbeg unless sv. */
 517
 518 /* XXXX Some places assume that there is a fixed substring.
 519         An update may be needed if optimizer marks as "INTUITable"
 520         RExen without fixed substrings.  Similarly, it is assumed that
 521         lengths of all the strings are no more than minlen, thus they
 522         cannot come from lookahead.
 523         (Or minlen should take into account lookahead.)
 524   NOTE: Some of this comment is not correct. minlen does now take account
 525   of lookahead/behind. Further research is required. -- demerphq
 526
 527 */
 528
 529 /* A failure to find a constant substring means that there is no need to make
 530    an expensive call to REx engine, thus we celebrate a failure.  Similarly,
 531    finding a substring too deep into the string means that less calls to
 532    regtry() should be needed.
 533
 534    REx compiler's optimizer found 4 possible hints:
 535         a) Anchored substring;
 536         b) Fixed substring;
 537         c) Whether we are anchored (beginning-of-line or \G);
 538         d) First node (of those at offset 0) which may distinguish positions;
 539    We use a)b)d) and multiline-part of c), and try to find a position in the
 540    string which does not contradict any of them.
 541  */
 542
 543 /* Most of decisions we do here should have been done at compile time.
 544    The nodes of the REx which we used for the search should have been
 545    deleted from the finite automaton. */
 546
 547 char *
 548 Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
 549                      char *strend, const U32 flags, re_scream_pos_data *data)
 550 {
 551     dVAR;
 552     struct regexp *const prog = (struct regexp *)SvANY(rx);
 553     register I32 start_shift = 0;
 554     /* Should be nonnegative! */
 555     register I32 end_shift   = 0;
 556     register char *s;
 557     register SV *check;
 558     char *strbeg;
 559     char *t;
 560     const bool utf8_target = (sv && SvUTF8(sv)) ? 1 : 0; /* if no sv we have to assume bytes */
 561     I32 ml_anch;
 562     register char *other_last = NULL;   /* other substr checked before this */
 563     char *check_at = NULL;              /* check substr found at this pos */
 564     const I32 multiline = prog->extflags & RXf_PMf_MULTILINE;
 565     RXi_GET_DECL(prog,progi);
 566 #ifdef DEBUGGING
 567     const char * const i_strpos = strpos;
 568 #endif
 569     GET_RE_DEBUG_FLAGS_DECL;
 570
 571     PERL_ARGS_ASSERT_RE_INTUIT_START;
 572
 573     RX_MATCH_UTF8_set(rx,utf8_target);
 574
 575     if (RX_UTF8(rx)) {
 576         PL_reg_flags |= RF_utf8;
 577     }
 578     DEBUG_EXECUTE_r(
 579         debug_start_match(rx, utf8_target, strpos, strend,
 580             sv ? "Guessing start of match in sv for"
 581                : "Guessing start of match in string for");
 582               );
 583
 584     /* CHR_DIST() would be more correct here but it makes things slow. */
 585     if (prog->minlen > strend - strpos) {
 586         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 587                               "String too short... [re_intuit_start]\n"));
 588         goto fail;
 589     }
 590
 591     strbeg = (sv && SvPOK(sv)) ? strend - SvCUR(sv) : strpos;
 592     PL_regeol = strend;
 593     if (utf8_target) {
 594         if (!prog->check_utf8 && prog->check_substr)
 595             to_utf8_substr(prog);
 596         check = prog->check_utf8;
 597     } else {
 598         if (!prog->check_substr && prog->check_utf8)
 599             to_byte_substr(prog);
 600         check = prog->check_substr;
 601     }
 602     if (check == &PL_sv_undef) {
 603         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 604                 "Non-utf8 string cannot match utf8 check string\n"));
 605         goto fail;
 606     }
 607     if (prog->extflags & RXf_ANCH) {    /* Match at beg-of-str or after \n */
 608         ml_anch = !( (prog->extflags & RXf_ANCH_SINGLE)
 609                      || ( (prog->extflags & RXf_ANCH_BOL)
 610                           && !multiline ) );    /* Check after \n? */
 611
 612         if (!ml_anch) {
 613           if ( !(prog->extflags & RXf_ANCH_GPOS) /* Checked by the caller */
 614                 && !(prog->intflags & PREGf_IMPLICIT) /* not a real BOL */
 615                /* SvCUR is not set on references: SvRV and SvPVX_const overlap */
 616                && sv && !SvROK(sv)
 617                && (strpos != strbeg)) {
 618               DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
 619               goto fail;
 620           }
 621           if (prog->check_offset_min == prog->check_offset_max &&
 622               !(prog->extflags & RXf_CANY_SEEN)) {
 623             /* Substring at constant offset from beg-of-str... */
 624             I32 slen;
 625
 626             s = HOP3c(strpos, prog->check_offset_min, strend);
 627
 628             if (SvTAIL(check)) {
 629                 slen = SvCUR(check);    /* >= 1 */
 630
 631                 if ( strend - s > slen || strend - s < slen - 1
 632                      || (strend - s == slen && strend[-1] != '\n')) {
 633                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
 634                     goto fail_finish;
 635                 }
 636                 /* Now should match s[0..slen-2] */
 637                 slen--;
 638                 if (slen && (*SvPVX_const(check) != *s
 639                              || (slen > 1
 640                                  && memNE(SvPVX_const(check), s, slen)))) {
 641                   report_neq:
 642                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
 643                     goto fail_finish;
 644                 }
 645             }
 646             else if (*SvPVX_const(check) != *s
 647                      || ((slen = SvCUR(check)) > 1
 648                          && memNE(SvPVX_const(check), s, slen)))
 649                 goto report_neq;
 650             check_at = s;
 651             goto success_at_start;
 652           }
 653         }
 654         /* Match is anchored, but substr is not anchored wrt beg-of-str. */
 655         s = strpos;
 656         start_shift = prog->check_offset_min; /* okay to underestimate on CC */
 657         end_shift = prog->check_end_shift;
 658
 659         if (!ml_anch) {
 660             const I32 end = prog->check_offset_max + CHR_SVLEN(check)
 661                                          - (SvTAIL(check) != 0);
 662             const I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
 663
 664             if (end_shift < eshift)
 665                 end_shift = eshift;
 666         }
 667     }
 668     else {                              /* Can match at random position */
 669         ml_anch = 0;
 670         s = strpos;
 671         start_shift = prog->check_offset_min;  /* okay to underestimate on CC */
 672         end_shift = prog->check_end_shift;
 673
 674         /* end shift should be non negative here */
 675     }
 676
 677 #ifdef QDEBUGGING       /* 7/99: reports of failure (with the older version) */
 678     if (end_shift < 0)
 679         Perl_croak(aTHX_ "panic: end_shift: %"IVdf" pattern:\n%s\n ",
 680                    (IV)end_shift, RX_PRECOMP(prog));
 681 #endif
 682
 683   restart:
 684     /* Find a possible match in the region s..strend by looking for
 685        the "check" substring in the region corrected by start/end_shift. */
 686
 687     {
 688         I32 srch_start_shift = start_shift;
 689         I32 srch_end_shift = end_shift;
 690         if (srch_start_shift < 0 && strbeg - s > srch_start_shift) {
 691             srch_end_shift -= ((strbeg - s) - srch_start_shift);
 692             srch_start_shift = strbeg - s;
 693         }
 694     DEBUG_OPTIMISE_MORE_r({
 695         PerlIO_printf(Perl_debug_log, "Check offset min: %"IVdf" Start shift: %"IVdf" End shift %"IVdf" Real End Shift: %"IVdf"\n",
 696             (IV)prog->check_offset_min,
 697             (IV)srch_start_shift,
 698             (IV)srch_end_shift,
 699             (IV)prog->check_end_shift);
 700     });
 701
 702     if ((flags & REXEC_SCREAM) && SvSCREAM(sv)) {
 703         I32 p = -1;                     /* Internal iterator of scream. */
 704         I32 * const pp = data ? data->scream_pos : &p;
 705         const MAGIC *mg;
 706         bool found = FALSE;
 707
 708         assert(SvMAGICAL(sv));
 709         mg = mg_find(sv, PERL_MAGIC_study);
 710         assert(mg);
 711
 712         if (mg->mg_private == 1) {
 713             found = ((U8 *)mg->mg_ptr)[BmRARE(check)] != (U8)~0;
 714         } else if (mg->mg_private == 2) {
 715             found = ((U16 *)mg->mg_ptr)[BmRARE(check)] != (U16)~0;
 716         } else {
 717             assert (mg->mg_private == 4);
 718             found = ((U32 *)mg->mg_ptr)[BmRARE(check)] != (U32)~0;
 719         }
 720
 721         if (found
 722             || ( BmRARE(check) == '\n'
 723                  && (BmPREVIOUS(check) == SvCUR(check) - 1)
 724                  && SvTAIL(check) ))
 725             s = screaminstr(sv, check,
 726                             srch_start_shift + (s - strbeg), srch_end_shift, pp, 0);
 727         else
 728             goto fail_finish;
 729         /* we may be pointing at the wrong string */
 730         if (s && RXp_MATCH_COPIED(prog))
 731             s = strbeg + (s - SvPVX_const(sv));
 732         if (data)
 733             *data->scream_olds = s;
 734     }
 735     else {
 736         U8* start_point;
 737         U8* end_point;
 738         if (prog->extflags & RXf_CANY_SEEN) {
 739             start_point= (U8*)(s + srch_start_shift);
 740             end_point= (U8*)(strend - srch_end_shift);
 741         } else {
 742             start_point= HOP3(s, srch_start_shift, srch_start_shift < 0 ? strbeg : strend);
 743             end_point= HOP3(strend, -srch_end_shift, strbeg);
 744         }
 745         DEBUG_OPTIMISE_MORE_r({
 746             PerlIO_printf(Perl_debug_log, "fbm_instr len=%d str=<%.*s>\n",
 747                 (int)(end_point - start_point),
 748                 (int)(end_point - start_point) > 20 ? 20 : (int)(end_point - start_point),
 749                 start_point);
 750         });
 751
 752         s = fbm_instr( start_point, end_point,
 753                       check, multiline ? FBMrf_MULTILINE : 0);
 754     }
 755     }
 756     /* Update the count-of-usability, remove useless subpatterns,
 757         unshift s.  */
 758
 759     DEBUG_EXECUTE_r({
 760         RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
 761             SvPVX_const(check), RE_SV_DUMPLEN(check), 30);
 762         PerlIO_printf(Perl_debug_log, "%s %s substr %s%s%s",
 763                           (s ? "Found" : "Did not find"),
 764             (check == (utf8_target ? prog->anchored_utf8 : prog->anchored_substr)
 765                 ? "anchored" : "floating"),
 766             quoted,
 767             RE_SV_TAIL(check),
 768             (s ? " at offset " : "...\n") );
 769     });
 770
 771     if (!s)
 772         goto fail_finish;
 773     /* Finish the diagnostic message */
 774     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
 775
 776     /* XXX dmq: first branch is for positive lookbehind...
 777        Our check string is offset from the beginning of the pattern.
 778        So we need to do any stclass tests offset forward from that
 779        point. I think. :-(
 780      */
 781
 782
 783
 784     check_at=s;
 785
 786
 787     /* Got a candidate.  Check MBOL anchoring, and the *other* substr.
 788        Start with the other substr.
 789        XXXX no SCREAM optimization yet - and a very coarse implementation
 790        XXXX /ttx+/ results in anchored="ttx", floating="x".  floating will
 791                 *always* match.  Probably should be marked during compile...
 792        Probably it is right to do no SCREAM here...
 793      */
 794
 795     if (utf8_target ? (prog->float_utf8 && prog->anchored_utf8)
 796                 : (prog->float_substr && prog->anchored_substr))
 797     {
 798         /* Take into account the "other" substring. */
 799         /* XXXX May be hopelessly wrong for UTF... */
 800         if (!other_last)
 801             other_last = strpos;
 802         if (check == (utf8_target ? prog->float_utf8 : prog->float_substr)) {
 803           do_other_anchored:
 804             {
 805                 char * const last = HOP3c(s, -start_shift, strbeg);
 806                 char *last1, *last2;
 807                 char * const saved_s = s;
 808                 SV* must;
 809
 810                 t = s - prog->check_offset_max;
 811                 if (s - strpos > prog->check_offset_max  /* signed-corrected t > strpos */
 812                     && (!utf8_target
 813                         || ((t = (char*)reghopmaybe3((U8*)s, -(prog->check_offset_max), (U8*)strpos))
 814                             && t > strpos)))
 815                     NOOP;
 816                 else
 817                     t = strpos;
 818                 t = HOP3c(t, prog->anchored_offset, strend);
 819                 if (t < other_last)     /* These positions already checked */
 820                     t = other_last;
 821                 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
 822                 if (last < last1)
 823                     last1 = last;
 824                 /* XXXX It is not documented what units *_offsets are in.
 825                    We assume bytes, but this is clearly wrong.
 826                    Meaning this code needs to be carefully reviewed for errors.
 827                    dmq.
 828                   */
 829
 830                 /* On end-of-str: see comment below. */
 831                 must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
 832                 if (must == &PL_sv_undef) {
 833                     s = (char*)NULL;
 834                     DEBUG_r(must = prog->anchored_utf8);        /* for debug */
 835                 }
 836                 else
 837                     s = fbm_instr(
 838                         (unsigned char*)t,
 839                         HOP3(HOP3(last1, prog->anchored_offset, strend)
 840                                 + SvCUR(must), -(SvTAIL(must)!=0), strbeg),
 841                         must,
 842                         multiline ? FBMrf_MULTILINE : 0
 843                     );
 844                 DEBUG_EXECUTE_r({
 845                     RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
 846                         SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
 847                     PerlIO_printf(Perl_debug_log, "%s anchored substr %s%s",
 848                         (s ? "Found" : "Contradicts"),
 849                         quoted, RE_SV_TAIL(must));
 850                 });
 851
 852
 853                 if (!s) {
 854                     if (last1 >= last2) {
 855                         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 856                                                 ", giving up...\n"));
 857                         goto fail_finish;
 858                     }
 859                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 860                         ", trying floating at offset %ld...\n",
 861                         (long)(HOP3c(saved_s, 1, strend) - i_strpos)));
 862                     other_last = HOP3c(last1, prog->anchored_offset+1, strend);
 863                     s = HOP3c(last, 1, strend);
 864                     goto restart;
 865                 }
 866                 else {
 867                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
 868                           (long)(s - i_strpos)));
 869                     t = HOP3c(s, -prog->anchored_offset, strbeg);
 870                     other_last = HOP3c(s, 1, strend);
 871                     s = saved_s;
 872                     if (t == strpos)
 873                         goto try_at_start;
 874                     goto try_at_offset;
 875                 }
 876             }
 877         }
 878         else {          /* Take into account the floating substring. */
 879             char *last, *last1;
 880             char * const saved_s = s;
 881             SV* must;
 882
 883             t = HOP3c(s, -start_shift, strbeg);
 884             last1 = last =
 885                 HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
 886             if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
 887                 last = HOP3c(t, prog->float_max_offset, strend);
 888             s = HOP3c(t, prog->float_min_offset, strend);
 889             if (s < other_last)
 890                 s = other_last;
 891  /* XXXX It is not documented what units *_offsets are in.  Assume bytes.  */
 892             must = utf8_target ? prog->float_utf8 : prog->float_substr;
 893             /* fbm_instr() takes into account exact value of end-of-str
 894                if the check is SvTAIL(ed).  Since false positives are OK,
 895                and end-of-str is not later than strend we are OK. */
 896             if (must == &PL_sv_undef) {
 897                 s = (char*)NULL;
 898                 DEBUG_r(must = prog->float_utf8);       /* for debug message */
 899             }
 900             else
 901                 s = fbm_instr((unsigned char*)s,
 902                               (unsigned char*)last + SvCUR(must)
 903                                   - (SvTAIL(must)!=0),
 904                               must, multiline ? FBMrf_MULTILINE : 0);
 905             DEBUG_EXECUTE_r({
 906                 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
 907                     SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
 908                 PerlIO_printf(Perl_debug_log, "%s floating substr %s%s",
 909                     (s ? "Found" : "Contradicts"),
 910                     quoted, RE_SV_TAIL(must));
 911             });
 912             if (!s) {
 913                 if (last1 == last) {
 914                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 915                                             ", giving up...\n"));
 916                     goto fail_finish;
 917                 }
 918                 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 919                     ", trying anchored starting at offset %ld...\n",
 920                     (long)(saved_s + 1 - i_strpos)));
 921                 other_last = last;
 922                 s = HOP3c(t, 1, strend);
 923                 goto restart;
 924             }
 925             else {
 926                 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
 927                       (long)(s - i_strpos)));
 928                 other_last = s; /* Fix this later. --Hugo */
 929                 s = saved_s;
 930                 if (t == strpos)
 931                     goto try_at_start;
 932                 goto try_at_offset;
 933             }
 934         }
 935     }
 936
 937
 938     t= (char*)HOP3( s, -prog->check_offset_max, (prog->check_offset_max<0) ? strend : strpos);
 939
 940     DEBUG_OPTIMISE_MORE_r(
 941         PerlIO_printf(Perl_debug_log,
 942             "Check offset min:%"IVdf" max:%"IVdf" S:%"IVdf" t:%"IVdf" D:%"IVdf" end:%"IVdf"\n",
 943             (IV)prog->check_offset_min,
 944             (IV)prog->check_offset_max,
 945             (IV)(s-strpos),
 946             (IV)(t-strpos),
 947             (IV)(t-s),
 948             (IV)(strend-strpos)
 949         )
 950     );
 951
 952     if (s - strpos > prog->check_offset_max  /* signed-corrected t > strpos */
 953         && (!utf8_target
 954             || ((t = (char*)reghopmaybe3((U8*)s, -prog->check_offset_max, (U8*) ((prog->check_offset_max<0) ? strend : strpos)))
 955                  && t > strpos)))
 956     {
 957         /* Fixed substring is found far enough so that the match
 958            cannot start at strpos. */
 959       try_at_offset:
 960         if (ml_anch && t[-1] != '\n') {
 961             /* Eventually fbm_*() should handle this, but often
 962                anchored_offset is not 0, so this check will not be wasted. */
 963             /* XXXX In the code below we prefer to look for "^" even in
 964                presence of anchored substrings.  And we search even
 965                beyond the found float position.  These pessimizations
 966                are historical artefacts only.  */
 967           find_anchor:
 968             while (t < strend - prog->minlen) {
 969                 if (*t == '\n') {
 970                     if (t < check_at - prog->check_offset_min) {
 971                         if (utf8_target ? prog->anchored_utf8 : prog->anchored_substr) {
 972                             /* Since we moved from the found position,
 973                                we definitely contradict the found anchored
 974                                substr.  Due to the above check we do not
 975                                contradict "check" substr.
 976                                Thus we can arrive here only if check substr
 977                                is float.  Redo checking for "other"=="fixed".
 978                              */
 979                             strpos = t + 1;
 980                             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
 981                                 PL_colors[0], PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
 982                             goto do_other_anchored;
 983                         }
 984                         /* We don't contradict the found floating substring. */
 985                         /* XXXX Why not check for STCLASS? */
 986                         s = t + 1;
 987                         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
 988                             PL_colors[0], PL_colors[1], (long)(s - i_strpos)));
 989                         goto set_useful;
 990                     }
 991                     /* Position contradicts check-string */
 992                     /* XXXX probably better to look for check-string
 993                        than for "\n", so one should lower the limit for t? */
 994                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
 995                         PL_colors[0], PL_colors[1], (long)(t + 1 - i_strpos)));
 996                     other_last = strpos = s = t + 1;
 997                     goto restart;
 998                 }
 999                 t++;
1000             }
1001             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
1002                         PL_colors[0], PL_colors[1]));
1003             goto fail_finish;
1004         }
1005         else {
1006             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
1007                         PL_colors[0], PL_colors[1]));
1008         }
1009         s = t;
1010       set_useful:
1011         ++BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr);        /* hooray/5 */
1012     }
1013     else {
1014         /* The found string does not prohibit matching at strpos,
1015            - no optimization of calling REx engine can be performed,
1016            unless it was an MBOL and we are not after MBOL,
1017            or a future STCLASS check will fail this. */
1018       try_at_start:
1019         /* Even in this situation we may use MBOL flag if strpos is offset
1020            wrt the start of the string. */
1021         if (ml_anch && sv && !SvROK(sv) /* See prev comment on SvROK */
1022             && (strpos != strbeg) && strpos[-1] != '\n'
1023             /* May be due to an implicit anchor of m{.*foo}  */
1024             && !(prog->intflags & PREGf_IMPLICIT))
1025         {
1026             t = strpos;
1027             goto find_anchor;
1028         }
1029         DEBUG_EXECUTE_r( if (ml_anch)
1030             PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
1031                           (long)(strpos - i_strpos), PL_colors[0], PL_colors[1]);
1032         );
1033       success_at_start:
1034         if (!(prog->intflags & PREGf_NAUGHTY)   /* XXXX If strpos moved? */
1035             && (utf8_target ? (
1036                 prog->check_utf8                /* Could be deleted already */
1037                 && --BmUSEFUL(prog->check_utf8) < 0
1038                 && (prog->check_utf8 == prog->float_utf8)
1039             ) : (
1040                 prog->check_substr              /* Could be deleted already */
1041                 && --BmUSEFUL(prog->check_substr) < 0
1042                 && (prog->check_substr == prog->float_substr)
1043             )))
1044         {
1045             /* If flags & SOMETHING - do not do it many times on the same match */
1046             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
1047             /* XXX Does the destruction order has to change with utf8_target? */
1048             SvREFCNT_dec(utf8_target ? prog->check_utf8 : prog->check_substr);
1049             SvREFCNT_dec(utf8_target ? prog->check_substr : prog->check_utf8);
1050             prog->check_substr = prog->check_utf8 = NULL;       /* disable */
1051             prog->float_substr = prog->float_utf8 = NULL;       /* clear */
1052             check = NULL;                       /* abort */
1053             s = strpos;
1054             /* XXXX If the check string was an implicit check MBOL, then we need to unset the relevant flag
1055                     see http://bugs.activestate.com/show_bug.cgi?id=87173 */
1056             if (prog->intflags & PREGf_IMPLICIT)
1057                 prog->extflags &= ~RXf_ANCH_MBOL;
1058             /* XXXX This is a remnant of the old implementation.  It
1059                     looks wasteful, since now INTUIT can use many
1060                     other heuristics. */
1061             prog->extflags &= ~RXf_USE_INTUIT;
1062             /* XXXX What other flags might need to be cleared in this branch? */
1063         }
1064         else
1065             s = strpos;
1066     }
1067
1068     /* Last resort... */
1069     /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
1070     /* trie stclasses are too expensive to use here, we are better off to
1071        leave it to regmatch itself */
1072     if (progi->regstclass && PL_regkind[OP(progi->regstclass)]!=TRIE) {
1073         /* minlen == 0 is possible if regstclass is \b or \B,
1074            and the fixed substr is ''$.
1075            Since minlen is already taken into account, s+1 is before strend;
1076            accidentally, minlen >= 1 guaranties no false positives at s + 1
1077            even for \b or \B.  But (minlen? 1 : 0) below assumes that
1078            regstclass does not come from lookahead...  */
1079         /* If regstclass takes bytelength more than 1: If charlength==1, OK.
1080            This leaves EXACTF-ish only, which are dealt with in find_byclass().  */
1081         const U8* const str = (U8*)STRING(progi->regstclass);
1082         const int cl_l = (PL_regkind[OP(progi->regstclass)] == EXACT
1083                     ? CHR_DIST(str+STR_LEN(progi->regstclass), str)
1084                     : 1);
1085         char * endpos;
1086         if (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1087             endpos= HOP3c(s, (prog->minlen ? cl_l : 0), strend);
1088         else if (prog->float_substr || prog->float_utf8)
1089             endpos= HOP3c(HOP3c(check_at, -start_shift, strbeg), cl_l, strend);
1090         else
1091             endpos= strend;
1092
1093         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" s: %"IVdf" endpos: %"IVdf"\n",
1094                                       (IV)start_shift, (IV)(check_at - strbeg), (IV)(s - strbeg), (IV)(endpos - strbeg)));
1095
1096         t = s;
1097         s = find_byclass(prog, progi->regstclass, s, endpos, NULL);
1098         if (!s) {
1099 #ifdef DEBUGGING
1100             const char *what = NULL;
1101 #endif
1102             if (endpos == strend) {
1103                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1104                                 "Could not match STCLASS...\n") );
1105                 goto fail;
1106             }
1107             DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1108                                    "This position contradicts STCLASS...\n") );
1109             if ((prog->extflags & RXf_ANCH) && !ml_anch)
1110                 goto fail;
1111             /* Contradict one of substrings */
1112             if (prog->anchored_substr || prog->anchored_utf8) {
1113                 if ((utf8_target ? prog->anchored_utf8 : prog->anchored_substr) == check) {
1114                     DEBUG_EXECUTE_r( what = "anchored" );
1115                   hop_and_restart:
1116                     s = HOP3c(t, 1, strend);
1117                     if (s + start_shift + end_shift > strend) {
1118                         /* XXXX Should be taken into account earlier? */
1119                         DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1120                                                "Could not match STCLASS...\n") );
1121                         goto fail;
1122                     }
1123                     if (!check)
1124                         goto giveup;
1125                     DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1126                                 "Looking for %s substr starting at offset %ld...\n",
1127                                  what, (long)(s + start_shift - i_strpos)) );
1128                     goto restart;
1129                 }
1130                 /* Have both, check_string is floating */
1131                 if (t + start_shift >= check_at) /* Contradicts floating=check */
1132                     goto retry_floating_check;
1133                 /* Recheck anchored substring, but not floating... */
1134                 s = check_at;
1135                 if (!check)
1136                     goto giveup;
1137                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1138                           "Looking for anchored substr starting at offset %ld...\n",
1139                           (long)(other_last - i_strpos)) );
1140                 goto do_other_anchored;
1141             }
1142             /* Another way we could have checked stclass at the
1143                current position only: */
1144             if (ml_anch) {
1145                 s = t = t + 1;
1146                 if (!check)
1147                     goto giveup;
1148                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1149                           "Looking for /%s^%s/m starting at offset %ld...\n",
1150                           PL_colors[0], PL_colors[1], (long)(t - i_strpos)) );
1151                 goto try_at_offset;
1152             }
1153             if (!(utf8_target ? prog->float_utf8 : prog->float_substr)) /* Could have been deleted */
1154                 goto fail;
1155             /* Check is floating substring. */
1156           retry_floating_check:
1157             t = check_at - start_shift;
1158             DEBUG_EXECUTE_r( what = "floating" );
1159             goto hop_and_restart;
1160         }
1161         if (t != s) {
1162             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
1163                         "By STCLASS: moving %ld --> %ld\n",
1164                                   (long)(t - i_strpos), (long)(s - i_strpos))
1165                    );
1166         }
1167         else {
1168             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
1169                                   "Does not contradict STCLASS...\n");
1170                    );
1171         }
1172     }
1173   giveup:
1174     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
1175                           PL_colors[4], (check ? "Guessed" : "Giving up"),
1176                           PL_colors[5], (long)(s - i_strpos)) );
1177     return s;
1178
1179   fail_finish:                          /* Substring not found */
1180     if (prog->check_substr || prog->check_utf8)         /* could be removed already */
1181         BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
1182   fail:
1183     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
1184                           PL_colors[4], PL_colors[5]));
1185     return NULL;
1186 }
1187
1188 #define DECL_TRIE_TYPE(scan) \
1189     const enum { trie_plain, trie_utf8, trie_utf8_fold, trie_latin_utf8_fold } \
1190                     trie_type = (scan->flags != EXACT) \
1191                               ? (utf8_target ? trie_utf8_fold : (UTF_PATTERN ? trie_latin_utf8_fold : trie_plain)) \
1192                               : (utf8_target ? trie_utf8 : trie_plain)
1193
1194 #define REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc, uscan, len,  \
1195 uvc, charid, foldlen, foldbuf, uniflags) STMT_START {                       \
1196     switch (trie_type) {                                                    \
1197     case trie_utf8_fold:                                                    \
1198         if ( foldlen>0 ) {                                                  \
1199             uvc = utf8n_to_uvuni( uscan, UTF8_MAXLEN, &len, uniflags ); \
1200             foldlen -= len;                                                 \
1201             uscan += len;                                                   \
1202             len=0;                                                          \
1203         } else {                                                            \
1204             uvc = to_utf8_fold( (U8 *) uc, foldbuf, &foldlen );             \
1205             len = UTF8SKIP(uc); \
1206             foldlen -= UNISKIP( uvc );                                      \
1207             uscan = foldbuf + UNISKIP( uvc );                               \
1208         }                                                                   \
1209         break;                                                              \
1210     case trie_latin_utf8_fold:                                              \
1211         if ( foldlen>0 ) {                                                  \
1212             uvc = utf8n_to_uvuni( uscan, UTF8_MAXLEN, &len, uniflags );     \
1213             foldlen -= len;                                                 \
1214             uscan += len;                                                   \
1215             len=0;                                                          \
1216         } else {                                                            \
1217             len = 1;                                                        \
1218             uvc = to_uni_fold( *(U8*)uc, foldbuf, &foldlen );               \
1219             foldlen -= UNISKIP( uvc );                                      \
1220             uscan = foldbuf + UNISKIP( uvc );                               \
1221         }                                                                   \
1222         break;                                                              \
1223     case trie_utf8:                                                         \
1224         uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN, &len, uniflags );       \
1225         break;                                                              \
1226     case trie_plain:                                                        \
1227         uvc = (UV)*uc;                                                      \
1228         len = 1;                                                            \
1229     }                                                                       \
1230     if (uvc < 256) {                                                        \
1231         charid = trie->charmap[ uvc ];                                      \
1232     }                                                                       \
1233     else {                                                                  \
1234         charid = 0;                                                         \
1235         if (widecharmap) {                                                  \
1236             SV** const svpp = hv_fetch(widecharmap,                         \
1237                         (char*)&uvc, sizeof(UV), 0);                        \
1238             if (svpp)                                                       \
1239                 charid = (U16)SvIV(*svpp);                                  \
1240         }                                                                   \
1241     }                                                                       \
1242 } STMT_END
1243
1244 #define REXEC_FBC_EXACTISH_SCAN(CoNd)                     \
1245 STMT_START {                                              \
1246     while (s <= e) {                                      \
1247         if ( (CoNd)                                       \
1248              && (ln == 1 || folder(s, pat_string, ln))    \
1249              && (!reginfo || regtry(reginfo, &s)) )       \
1250             goto got_it;                                  \
1251         s++;                                              \
1252     }                                                     \
1253 } STMT_END
1254
1255 #define REXEC_FBC_UTF8_SCAN(CoDe)                     \
1256 STMT_START {                                          \
1257     while (s + (uskip = UTF8SKIP(s)) <= strend) {     \
1258         CoDe                                          \
1259         s += uskip;                                   \
1260     }                                                 \
1261 } STMT_END
1262
1263 #define REXEC_FBC_SCAN(CoDe)                          \
1264 STMT_START {                                          \
1265     while (s < strend) {                              \
1266         CoDe                                          \
1267         s++;                                          \
1268     }                                                 \
1269 } STMT_END
1270
1271 #define REXEC_FBC_UTF8_CLASS_SCAN(CoNd)               \
1272 REXEC_FBC_UTF8_SCAN(                                  \
1273     if (CoNd) {                                       \
1274         if (tmp && (!reginfo || regtry(reginfo, &s)))  \
1275             goto got_it;                              \
1276         else                                          \
1277             tmp = doevery;                            \
1278     }                                                 \
1279     else                                              \
1280         tmp = 1;                                      \
1281 )
1282
1283 #define REXEC_FBC_CLASS_SCAN(CoNd)                    \
1284 REXEC_FBC_SCAN(                                       \
1285     if (CoNd) {                                       \
1286         if (tmp && (!reginfo || regtry(reginfo, &s)))  \
1287             goto got_it;                              \
1288         else                                          \
1289             tmp = doevery;                            \
1290     }                                                 \
1291     else                                              \
1292         tmp = 1;                                      \
1293 )
1294
1295 #define REXEC_FBC_TRYIT               \
1296 if ((!reginfo || regtry(reginfo, &s))) \
1297     goto got_it
1298
1299 #define REXEC_FBC_CSCAN(CoNdUtF8,CoNd)                         \
1300     if (utf8_target) {                                             \
1301         REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8);                   \
1302     }                                                          \
1303     else {                                                     \
1304         REXEC_FBC_CLASS_SCAN(CoNd);                            \
1305     }
1306
1307 #define REXEC_FBC_CSCAN_PRELOAD(UtFpReLoAd,CoNdUtF8,CoNd)      \
1308     if (utf8_target) {                                             \
1309         UtFpReLoAd;                                            \
1310         REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8);                   \
1311     }                                                          \
1312     else {                                                     \
1313         REXEC_FBC_CLASS_SCAN(CoNd);                            \
1314     }
1315
1316 #define REXEC_FBC_CSCAN_TAINT(CoNdUtF8,CoNd)                   \
1317     PL_reg_flags |= RF_tainted;                                \
1318     if (utf8_target) {                                             \
1319         REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8);                   \
1320     }                                                          \
1321     else {                                                     \
1322         REXEC_FBC_CLASS_SCAN(CoNd);                            \
1323     }
1324
1325 #define DUMP_EXEC_POS(li,s,doutf8) \
1326     dump_exec_pos(li,s,(PL_regeol),(PL_bostr),(PL_reg_starttry),doutf8)
1327
1328
1329 #define UTF8_NOLOAD(TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
1330         tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';                         \
1331         tmp = TEST_NON_UTF8(tmp);                                              \
1332         REXEC_FBC_UTF8_SCAN(                                                   \
1333             if (tmp == ! TEST_NON_UTF8((U8) *s)) { \
1334                 tmp = !tmp;                                                    \
1335                 IF_SUCCESS;                                                    \
1336             }                                                                  \
1337             else {                                                             \
1338                 IF_FAIL;                                                       \
1339             }                                                                  \
1340         );                                                                     \
1341
1342 #define UTF8_LOAD(TeSt1_UtF8, TeSt2_UtF8, IF_SUCCESS, IF_FAIL) \
1343         if (s == PL_bostr) {                                                   \
1344             tmp = '\n';                                                        \
1345         }                                                                      \
1346         else {                                                                 \
1347             U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);                 \
1348             tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);       \
1349         }                                                                      \
1350         tmp = TeSt1_UtF8;                                                      \
1351         LOAD_UTF8_CHARCLASS_ALNUM();                                                                \
1352         REXEC_FBC_UTF8_SCAN(                                                   \
1353             if (tmp == ! (TeSt2_UtF8)) { \
1354                 tmp = !tmp;                                                    \
1355                 IF_SUCCESS;                                                    \
1356             }                                                                  \
1357             else {                                                             \
1358                 IF_FAIL;                                                       \
1359             }                                                                  \
1360         );                                                                     \
1361
1362 /* The only difference between the BOUND and NBOUND cases is that
1363  * REXEC_FBC_TRYIT is called when matched in BOUND, and when non-matched in
1364  * NBOUND.  This is accomplished by passing it in either the if or else clause,
1365  * with the other one being empty */
1366 #define FBC_BOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1367     FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
1368
1369 #define FBC_BOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1370     FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
1371
1372 #define FBC_NBOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1373     FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
1374
1375 #define FBC_NBOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1376     FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
1377
1378
1379 /* Common to the BOUND and NBOUND cases.  Unfortunately the UTF8 tests need to
1380  * be passed in completely with the variable name being tested, which isn't
1381  * such a clean interface, but this is easier to read than it was before.  We
1382  * are looking for the boundary (or non-boundary between a word and non-word
1383  * character.  The utf8 and non-utf8 cases have the same logic, but the details
1384  * must be different.  Find the "wordness" of the character just prior to this
1385  * one, and compare it with the wordness of this one.  If they differ, we have
1386  * a boundary.  At the beginning of the string, pretend that the previous
1387  * character was a new-line */
1388 #define FBC_BOUND_COMMON(UTF8_CODE, TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
1389     if (utf8_target) {                                                         \
1390                 UTF8_CODE \
1391     }                                                                          \
1392     else {  /* Not utf8 */                                                     \
1393         tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';                         \
1394         tmp = TEST_NON_UTF8(tmp);                                              \
1395         REXEC_FBC_SCAN(                                                        \
1396             if (tmp == ! TEST_NON_UTF8((U8) *s)) {                             \
1397                 tmp = !tmp;                                                    \
1398                 IF_SUCCESS;                                                    \
1399             }                                                                  \
1400             else {                                                             \
1401                 IF_FAIL;                                                       \
1402             }                                                                  \
1403         );                                                                     \
1404     }                                                                          \
1405     if ((!prog->minlen && tmp) && (!reginfo || regtry(reginfo, &s)))           \
1406         goto got_it;
1407
1408 /* We know what class REx starts with.  Try to find this position... */
1409 /* if reginfo is NULL, its a dryrun */
1410 /* annoyingly all the vars in this routine have different names from their counterparts
1411    in regmatch. /grrr */
1412
1413 STATIC char *
1414 S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
1415     const char *strend, regmatch_info *reginfo)
1416 {
1417         dVAR;
1418         const I32 doevery = (prog->intflags & PREGf_SKIP) == 0;
1419         char *pat_string;   /* The pattern's exactish string */
1420         char *pat_end;      /* ptr to end char of pat_string */
1421         re_fold_t folder;       /* Function for computing non-utf8 folds */
1422         const U8 *fold_array;   /* array for folding ords < 256 */
1423         STRLEN ln;
1424         STRLEN lnc;
1425         register STRLEN uskip;
1426         U8 c1;
1427         U8 c2;
1428         char *e;
1429         register I32 tmp = 1;   /* Scratch variable? */
1430         register const bool utf8_target = PL_reg_match_utf8;
1431         UV utf8_fold_flags = 0;
1432         RXi_GET_DECL(prog,progi);
1433
1434         PERL_ARGS_ASSERT_FIND_BYCLASS;
1435
1436         /* We know what class it must start with. */
1437         switch (OP(c)) {
1438         case ANYOFV:
1439         case ANYOF:
1440             if (utf8_target || OP(c) == ANYOFV) {
1441                 STRLEN inclasslen = strend - s;
1442                 REXEC_FBC_UTF8_CLASS_SCAN(
1443                           reginclass(prog, c, (U8*)s, &inclasslen, utf8_target));
1444             }
1445             else {
1446                 REXEC_FBC_CLASS_SCAN(REGINCLASS(prog, c, (U8*)s));
1447             }
1448             break;
1449         case CANY:
1450             REXEC_FBC_SCAN(
1451                 if (tmp && (!reginfo || regtry(reginfo, &s)))
1452                     goto got_it;
1453                 else
1454                     tmp = doevery;
1455             );
1456             break;
1457
1458         case EXACTFA:
1459             if (UTF_PATTERN || utf8_target) {
1460                 utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
1461                 goto do_exactf_utf8;
1462             }
1463             fold_array = PL_fold_latin1;    /* Latin1 folds are not affected by */
1464             folder = foldEQ_latin1;         /* /a, except the sharp s one which */
1465             goto do_exactf_non_utf8;        /* isn't dealt with by these */
1466
1467         case EXACTF:
1468             if (UTF_PATTERN || utf8_target) {
1469
1470                 /* regcomp.c already folded this if pattern is in UTF-8 */
1471                 utf8_fold_flags = (UTF_PATTERN) ? FOLDEQ_S2_ALREADY_FOLDED : 0;
1472                 goto do_exactf_utf8;
1473             }
1474             fold_array = PL_fold;
1475             folder = foldEQ;
1476             goto do_exactf_non_utf8;
1477
1478         case EXACTFL:
1479             if (UTF_PATTERN || utf8_target) {
1480                 utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
1481                 goto do_exactf_utf8;
1482             }
1483             fold_array = PL_fold_locale;
1484             folder = foldEQ_locale;
1485             goto do_exactf_non_utf8;
1486
1487         case EXACTFU:
1488             if (UTF_PATTERN || utf8_target) {
1489                 utf8_fold_flags = (UTF_PATTERN) ? FOLDEQ_S2_ALREADY_FOLDED : 0;
1490                 goto do_exactf_utf8;
1491             }
1492
1493             /* Any 'ss' in the pattern should have been replaced by regcomp,
1494              * so we don't have to worry here about this single special case
1495              * in the Latin1 range */
1496             fold_array = PL_fold_latin1;
1497             folder = foldEQ_latin1;
1498
1499             /* FALL THROUGH */
1500
1501         do_exactf_non_utf8: /* Neither pattern nor string are UTF8 */
1502
1503             /* The idea in the non-utf8 EXACTF* cases is to first find the
1504              * first character of the EXACTF* node and then, if necessary,
1505              * case-insensitively compare the full text of the node.  c1 is the
1506              * first character.  c2 is its fold.  This logic will not work for
1507              * Unicode semantics and the german sharp ss, which hence should
1508              * not be compiled into a node that gets here. */
1509             pat_string = STRING(c);
1510             ln  = STR_LEN(c);   /* length to match in octets/bytes */
1511
1512             /* We know that we have to match at least 'ln' bytes (which is the
1513              * same as characters, since not utf8).  If we have to match 3
1514              * characters, and there are only 2 availabe, we know without
1515              * trying that it will fail; so don't start a match past the
1516              * required minimum number from the far end */
1517             e = HOP3c(strend, -((I32)ln), s);
1518
1519             if (!reginfo && e < s) {
1520                 e = s;                  /* Due to minlen logic of intuit() */
1521             }
1522
1523             c1 = *pat_string;
1524             c2 = fold_array[c1];
1525             if (c1 == c2) { /* If char and fold are the same */
1526                 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1);
1527             }
1528             else {
1529                 REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1 || *(U8*)s == c2);
1530             }
1531             break;
1532
1533         do_exactf_utf8:
1534         {
1535             unsigned expansion;
1536
1537
1538             /* If one of the operands is in utf8, we can't use the simpler
1539              * folding above, due to the fact that many different characters
1540              * can have the same fold, or portion of a fold, or different-
1541              * length fold */
1542             pat_string = STRING(c);
1543             ln  = STR_LEN(c);   /* length to match in octets/bytes */
1544             pat_end = pat_string + ln;
1545             lnc = (UTF_PATTERN) /* length to match in characters */
1546                     ? utf8_length((U8 *) pat_string, (U8 *) pat_end)
1547                     : ln;
1548
1549             /* We have 'lnc' characters to match in the pattern, but because of
1550              * multi-character folding, each character in the target can match
1551              * up to 3 characters (Unicode guarantees it will never exceed
1552              * this) if it is utf8-encoded; and up to 2 if not (based on the
1553              * fact that the Latin 1 folds are already determined, and the
1554              * only multi-char fold in that range is the sharp-s folding to
1555              * 'ss'.  Thus, a pattern character can match as little as 1/3 of a
1556              * string character.  Adjust lnc accordingly, rounding up, so that
1557              * if we need to match at least 4+1/3 chars, that really is 5. */
1558             expansion = (utf8_target) ? UTF8_MAX_FOLD_CHAR_EXPAND : 2;
1559             lnc = (lnc + expansion - 1) / expansion;
1560
1561             /* As in the non-UTF8 case, if we have to match 3 characters, and
1562              * only 2 are left, it's guaranteed to fail, so don't start a
1563              * match that would require us to go beyond the end of the string
1564              */
1565             e = HOP3c(strend, -((I32)lnc), s);
1566
1567             if (!reginfo && e < s) {
1568                 e = s;                  /* Due to minlen logic of intuit() */
1569             }
1570
1571             /* XXX Note that we could recalculate e to stop the loop earlier,
1572              * as the worst case expansion above will rarely be met, and as we
1573              * go along we would usually find that e moves further to the left.
1574              * This would happen only after we reached the point in the loop
1575              * where if there were no expansion we should fail.  Unclear if
1576              * worth the expense */
1577
1578             while (s <= e) {
1579                 char *my_strend= (char *)strend;
1580                 if (foldEQ_utf8_flags(s, &my_strend, 0,  utf8_target,
1581                       pat_string, NULL, ln, cBOOL(UTF_PATTERN), utf8_fold_flags)
1582                     && (!reginfo || regtry(reginfo, &s)) )
1583                 {
1584                     goto got_it;
1585                 }
1586                 s += (utf8_target) ? UTF8SKIP(s) : 1;
1587             }
1588             break;
1589         }
1590         case BOUNDL:
1591             PL_reg_flags |= RF_tainted;
1592             FBC_BOUND(isALNUM_LC,
1593                       isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp)),
1594                       isALNUM_LC_utf8((U8*)s));
1595             break;
1596         case NBOUNDL:
1597             PL_reg_flags |= RF_tainted;
1598             FBC_NBOUND(isALNUM_LC,
1599                        isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp)),
1600                        isALNUM_LC_utf8((U8*)s));
1601             break;
1602         case BOUND:
1603             FBC_BOUND(isWORDCHAR,
1604                       isALNUM_uni(tmp),
1605                       cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1606             break;
1607         case BOUNDA:
1608             FBC_BOUND_NOLOAD(isWORDCHAR_A,
1609                              isWORDCHAR_A(tmp),
1610                              isWORDCHAR_A((U8*)s));
1611             break;
1612         case NBOUND:
1613             FBC_NBOUND(isWORDCHAR,
1614                        isALNUM_uni(tmp),
1615                        cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1616             break;
1617         case NBOUNDA:
1618             FBC_NBOUND_NOLOAD(isWORDCHAR_A,
1619                               isWORDCHAR_A(tmp),
1620                               isWORDCHAR_A((U8*)s));
1621             break;
1622         case BOUNDU:
1623             FBC_BOUND(isWORDCHAR_L1,
1624                       isALNUM_uni(tmp),
1625                       cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1626             break;
1627         case NBOUNDU:
1628             FBC_NBOUND(isWORDCHAR_L1,
1629                        isALNUM_uni(tmp),
1630                        cBOOL(swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target)));
1631             break;
1632         case ALNUML:
1633             REXEC_FBC_CSCAN_TAINT(
1634                 isALNUM_LC_utf8((U8*)s),
1635                 isALNUM_LC(*s)
1636             );
1637             break;
1638         case ALNUMU:
1639             REXEC_FBC_CSCAN_PRELOAD(
1640                 LOAD_UTF8_CHARCLASS_ALNUM(),
1641                 swash_fetch(PL_utf8_alnum,(U8*)s, utf8_target),
1642                 isWORDCHAR_L1((U8) *s)
1643             );
1644             break;
1645         case ALNUM:
1646             REXEC_FBC_CSCAN_PRELOAD(
1647                 LOAD_UTF8_CHARCLASS_ALNUM(),
1648                 swash_fetch(PL_utf8_alnum,(U8*)s, utf8_target),
1649                 isWORDCHAR((U8) *s)
1650             );
1651             break;
1652         case ALNUMA:
1653             /* Don't need to worry about utf8, as it can match only a single
1654              * byte invariant character */
1655             REXEC_FBC_CLASS_SCAN( isWORDCHAR_A(*s));
1656             break;
1657         case NALNUMU:
1658             REXEC_FBC_CSCAN_PRELOAD(
1659                 LOAD_UTF8_CHARCLASS_ALNUM(),
1660                 !swash_fetch(PL_utf8_alnum,(U8*)s, utf8_target),
1661                 ! isWORDCHAR_L1((U8) *s)
1662             );
1663             break;
1664         case NALNUM:
1665             REXEC_FBC_CSCAN_PRELOAD(
1666                 LOAD_UTF8_CHARCLASS_ALNUM(),
1667                 !swash_fetch(PL_utf8_alnum, (U8*)s, utf8_target),
1668                 ! isALNUM(*s)
1669             );
1670             break;
1671         case NALNUMA:
1672             REXEC_FBC_CSCAN(
1673                 !isWORDCHAR_A(*s),
1674                 !isWORDCHAR_A(*s)
1675             );
1676             break;
1677         case NALNUML:
1678             REXEC_FBC_CSCAN_TAINT(
1679                 !isALNUM_LC_utf8((U8*)s),
1680                 !isALNUM_LC(*s)
1681             );
1682             break;
1683         case SPACEU:
1684             REXEC_FBC_CSCAN_PRELOAD(
1685                 LOAD_UTF8_CHARCLASS_SPACE(),
1686                 *s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target),
1687                 isSPACE_L1((U8) *s)
1688             );
1689             break;
1690         case SPACE:
1691             REXEC_FBC_CSCAN_PRELOAD(
1692                 LOAD_UTF8_CHARCLASS_SPACE(),
1693                 *s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target),
1694                 isSPACE((U8) *s)
1695             );
1696             break;
1697         case SPACEA:
1698             /* Don't need to worry about utf8, as it can match only a single
1699              * byte invariant character */
1700             REXEC_FBC_CLASS_SCAN( isSPACE_A(*s));
1701             break;
1702         case SPACEL:
1703             REXEC_FBC_CSCAN_TAINT(
1704                 isSPACE_LC_utf8((U8*)s),
1705                 isSPACE_LC(*s)
1706             );
1707             break;
1708         case NSPACEU:
1709             REXEC_FBC_CSCAN_PRELOAD(
1710                 LOAD_UTF8_CHARCLASS_SPACE(),
1711                 !( *s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target)),
1712                 ! isSPACE_L1((U8) *s)
1713             );
1714             break;
1715         case NSPACE:
1716             REXEC_FBC_CSCAN_PRELOAD(
1717                 LOAD_UTF8_CHARCLASS_SPACE(),
1718                 !(*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, utf8_target)),
1719                 ! isSPACE((U8) *s)
1720             );
1721             break;
1722         case NSPACEA:
1723             REXEC_FBC_CSCAN(
1724                 !isSPACE_A(*s),
1725                 !isSPACE_A(*s)
1726             );
1727             break;
1728         case NSPACEL:
1729             REXEC_FBC_CSCAN_TAINT(
1730                 !isSPACE_LC_utf8((U8*)s),
1731                 !isSPACE_LC(*s)
1732             );
1733             break;
1734         case DIGIT:
1735             REXEC_FBC_CSCAN_PRELOAD(
1736                 LOAD_UTF8_CHARCLASS_DIGIT(),
1737                 swash_fetch(PL_utf8_digit,(U8*)s, utf8_target),
1738                 isDIGIT(*s)
1739             );
1740             break;
1741         case DIGITA:
1742             /* Don't need to worry about utf8, as it can match only a single
1743              * byte invariant character */
1744             REXEC_FBC_CLASS_SCAN( isDIGIT_A(*s));
1745             break;
1746         case DIGITL:
1747             REXEC_FBC_CSCAN_TAINT(
1748                 isDIGIT_LC_utf8((U8*)s),
1749                 isDIGIT_LC(*s)
1750             );
1751             break;
1752         case NDIGIT:
1753             REXEC_FBC_CSCAN_PRELOAD(
1754                 LOAD_UTF8_CHARCLASS_DIGIT(),
1755                 !swash_fetch(PL_utf8_digit,(U8*)s, utf8_target),
1756                 !isDIGIT(*s)
1757             );
1758             break;
1759         case NDIGITA:
1760             REXEC_FBC_CSCAN(
1761                 !isDIGIT_A(*s),
1762                 !isDIGIT_A(*s)
1763             );
1764             break;
1765         case NDIGITL:
1766             REXEC_FBC_CSCAN_TAINT(
1767                 !isDIGIT_LC_utf8((U8*)s),
1768                 !isDIGIT_LC(*s)
1769             );
1770             break;
1771         case LNBREAK:
1772             REXEC_FBC_CSCAN(
1773                 is_LNBREAK_utf8(s),
1774                 is_LNBREAK_latin1(s)
1775             );
1776             break;
1777         case VERTWS:
1778             REXEC_FBC_CSCAN(
1779                 is_VERTWS_utf8(s),
1780                 is_VERTWS_latin1(s)
1781             );
1782             break;
1783         case NVERTWS:
1784             REXEC_FBC_CSCAN(
1785                 !is_VERTWS_utf8(s),
1786                 !is_VERTWS_latin1(s)
1787             );
1788             break;
1789         case HORIZWS:
1790             REXEC_FBC_CSCAN(
1791                 is_HORIZWS_utf8(s),
1792                 is_HORIZWS_latin1(s)
1793             );
1794             break;
1795         case NHORIZWS:
1796             REXEC_FBC_CSCAN(
1797                 !is_HORIZWS_utf8(s),
1798                 !is_HORIZWS_latin1(s)
1799             );
1800             break;
1801         case AHOCORASICKC:
1802         case AHOCORASICK:
1803             {
1804                 DECL_TRIE_TYPE(c);
1805                 /* what trie are we using right now */
1806                 reg_ac_data *aho
1807                     = (reg_ac_data*)progi->data->data[ ARG( c ) ];
1808                 reg_trie_data *trie
1809                     = (reg_trie_data*)progi->data->data[ aho->trie ];
1810                 HV *widecharmap = MUTABLE_HV(progi->data->data[ aho->trie + 1 ]);
1811
1812                 const char *last_start = strend - trie->minlen;
1813 #ifdef DEBUGGING
1814                 const char *real_start = s;
1815 #endif
1816                 STRLEN maxlen = trie->maxlen;
1817                 SV *sv_points;
1818                 U8 **points; /* map of where we were in the input string
1819                                 when reading a given char. For ASCII this
1820                                 is unnecessary overhead as the relationship
1821                                 is always 1:1, but for Unicode, especially
1822                                 case folded Unicode this is not true. */
1823                 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1824                 U8 *bitmap=NULL;
1825
1826
1827                 GET_RE_DEBUG_FLAGS_DECL;
1828
1829                 /* We can't just allocate points here. We need to wrap it in
1830                  * an SV so it gets freed properly if there is a croak while
1831                  * running the match */
1832                 ENTER;
1833                 SAVETMPS;
1834                 sv_points=newSV(maxlen * sizeof(U8 *));
1835                 SvCUR_set(sv_points,
1836                     maxlen * sizeof(U8 *));
1837                 SvPOK_on(sv_points);
1838                 sv_2mortal(sv_points);
1839                 points=(U8**)SvPV_nolen(sv_points );
1840                 if ( trie_type != trie_utf8_fold
1841                      && (trie->bitmap || OP(c)==AHOCORASICKC) )
1842                 {
1843                     if (trie->bitmap)
1844                         bitmap=(U8*)trie->bitmap;
1845                     else
1846                         bitmap=(U8*)ANYOF_BITMAP(c);
1847                 }
1848                 /* this is the Aho-Corasick algorithm modified a touch
1849                    to include special handling for long "unknown char"
1850                    sequences. The basic idea being that we use AC as long
1851                    as we are dealing with a possible matching char, when
1852                    we encounter an unknown char (and we have not encountered
1853                    an accepting state) we scan forward until we find a legal
1854                    starting char.
1855                    AC matching is basically that of trie matching, except
1856                    that when we encounter a failing transition, we fall back
1857                    to the current states "fail state", and try the current char
1858                    again, a process we repeat until we reach the root state,
1859                    state 1, or a legal transition. If we fail on the root state
1860                    then we can either terminate if we have reached an accepting
1861                    state previously, or restart the entire process from the beginning
1862                    if we have not.
1863
1864                  */
1865                 while (s <= last_start) {
1866                     const U32 uniflags = UTF8_ALLOW_DEFAULT;
1867                     U8 *uc = (U8*)s;
1868                     U16 charid = 0;
1869                     U32 base = 1;
1870                     U32 state = 1;
1871                     UV uvc = 0;
1872                     STRLEN len = 0;
1873                     STRLEN foldlen = 0;
1874                     U8 *uscan = (U8*)NULL;
1875                     U8 *leftmost = NULL;
1876 #ifdef DEBUGGING
1877                     U32 accepted_word= 0;
1878 #endif
1879                     U32 pointpos = 0;
1880
1881                     while ( state && uc <= (U8*)strend ) {
1882                         int failed=0;
1883                         U32 word = aho->states[ state ].wordnum;
1884
1885                         if( state==1 ) {
1886                             if ( bitmap ) {
1887                                 DEBUG_TRIE_EXECUTE_r(
1888                                     if ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1889                                         dump_exec_pos( (char *)uc, c, strend, real_start,
1890                                             (char *)uc, utf8_target );
1891                                         PerlIO_printf( Perl_debug_log,
1892                                             " Scanning for legal start char...\n");
1893                                     }
1894                                 );
1895                                 if (utf8_target) {
1896                                     while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1897                                         uc += UTF8SKIP(uc);
1898                                     }
1899                                 } else {
1900                                     while ( uc <= (U8*)last_start  && !BITMAP_TEST(bitmap,*uc) ) {
1901                                         uc++;
1902                                     }
1903                                 }
1904                                 s= (char *)uc;
1905                             }
1906                             if (uc >(U8*)last_start) break;
1907                         }
1908
1909                         if ( word ) {
1910                             U8 *lpos= points[ (pointpos - trie->wordinfo[word].len) % maxlen ];
1911                             if (!leftmost || lpos < leftmost) {
1912                                 DEBUG_r(accepted_word=word);
1913                                 leftmost= lpos;
1914                             }
1915                             if (base==0) break;
1916
1917                         }
1918                         points[pointpos++ % maxlen]= uc;
1919                         REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc,
1920                                              uscan, len, uvc, charid, foldlen,
1921                                              foldbuf, uniflags);
1922                         DEBUG_TRIE_EXECUTE_r({
1923                             dump_exec_pos( (char *)uc, c, strend, real_start,
1924                                 s,   utf8_target );
1925                             PerlIO_printf(Perl_debug_log,
1926                                 " Charid:%3u CP:%4"UVxf" ",
1927                                  charid, uvc);
1928                         });
1929
1930                         do {
1931 #ifdef DEBUGGING
1932                             word = aho->states[ state ].wordnum;
1933 #endif
1934                             base = aho->states[ state ].trans.base;
1935
1936                             DEBUG_TRIE_EXECUTE_r({
1937                                 if (failed)
1938                                     dump_exec_pos( (char *)uc, c, strend, real_start,
1939                                         s,   utf8_target );
1940                                 PerlIO_printf( Perl_debug_log,
1941                                     "%sState: %4"UVxf", word=%"UVxf,
1942                                     failed ? " Fail transition to " : "",
1943                                     (UV)state, (UV)word);
1944                             });
1945                             if ( base ) {
1946                                 U32 tmp;
1947                                 I32 offset;
1948                                 if (charid &&
1949                                      ( ((offset = base + charid
1950                                         - 1 - trie->uniquecharcount)) >= 0)
1951                                      && ((U32)offset < trie->lasttrans)
1952                                      && trie->trans[offset].check == state
1953                                      && (tmp=trie->trans[offset].next))
1954                                 {
1955                                     DEBUG_TRIE_EXECUTE_r(
1956                                         PerlIO_printf( Perl_debug_log," - legal\n"));
1957                                     state = tmp;
1958                                     break;
1959                                 }
1960                                 else {
1961                                     DEBUG_TRIE_EXECUTE_r(
1962                                         PerlIO_printf( Perl_debug_log," - fail\n"));
1963                                     failed = 1;
1964                                     state = aho->fail[state];
1965                                 }
1966                             }
1967                             else {
1968                                 /* we must be accepting here */
1969                                 DEBUG_TRIE_EXECUTE_r(
1970                                         PerlIO_printf( Perl_debug_log," - accepting\n"));
1971                                 failed = 1;
1972                                 break;
1973                             }
1974                         } while(state);
1975                         uc += len;
1976                         if (failed) {
1977                             if (leftmost)
1978                                 break;
1979                             if (!state) state = 1;
1980                         }
1981                     }
1982                     if ( aho->states[ state ].wordnum ) {
1983                         U8 *lpos = points[ (pointpos - trie->wordinfo[aho->states[ state ].wordnum].len) % maxlen ];
1984                         if (!leftmost || lpos < leftmost) {
1985                             DEBUG_r(accepted_word=aho->states[ state ].wordnum);
1986                             leftmost = lpos;
1987                         }
1988                     }
1989                     if (leftmost) {
1990                         s = (char*)leftmost;
1991                         DEBUG_TRIE_EXECUTE_r({
1992                             PerlIO_printf(
1993                                 Perl_debug_log,"Matches word #%"UVxf" at position %"IVdf". Trying full pattern...\n",
1994                                 (UV)accepted_word, (IV)(s - real_start)
1995                             );
1996                         });
1997                         if (!reginfo || regtry(reginfo, &s)) {
1998                             FREETMPS;
1999                             LEAVE;
2000                             goto got_it;
2001                         }
2002                         s = HOPc(s,1);
2003                         DEBUG_TRIE_EXECUTE_r({
2004                             PerlIO_printf( Perl_debug_log,"Pattern failed. Looking for new start point...\n");
2005                         });
2006                     } else {
2007                         DEBUG_TRIE_EXECUTE_r(
2008                             PerlIO_printf( Perl_debug_log,"No match.\n"));
2009                         break;
2010                     }
2011                 }
2012                 FREETMPS;
2013                 LEAVE;
2014             }
2015             break;
2016         default:
2017             Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
2018             break;
2019         }
2020         return 0;
2021       got_it:
2022         return s;
2023 }
2024
2025
2026 /*
2027  - regexec_flags - match a regexp against a string
2028  */
2029 I32
2030 Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, register char *strend,
2031               char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
2032 /* strend: pointer to null at end of string */
2033 /* strbeg: real beginning of string */
2034 /* minend: end of match must be >=minend after stringarg. */
2035 /* data: May be used for some additional optimizations.
2036          Currently its only used, with a U32 cast, for transmitting
2037          the ganch offset when doing a /g match. This will change */
2038 /* nosave: For optimizations. */
2039 {
2040     dVAR;
2041     struct regexp *const prog = (struct regexp *)SvANY(rx);
2042     /*register*/ char *s;
2043     register regnode *c;
2044     /*register*/ char *startpos = stringarg;
2045     I32 minlen;         /* must match at least this many chars */
2046     I32 dontbother = 0; /* how many characters not to try at end */
2047     I32 end_shift = 0;                  /* Same for the end. */         /* CC */
2048     I32 scream_pos = -1;                /* Internal iterator of scream. */
2049     char *scream_olds = NULL;
2050     const bool utf8_target = cBOOL(DO_UTF8(sv));
2051     I32 multiline;
2052     RXi_GET_DECL(prog,progi);
2053     regmatch_info reginfo;  /* create some info to pass to regtry etc */
2054     regexp_paren_pair *swap = NULL;
2055     GET_RE_DEBUG_FLAGS_DECL;
2056
2057     PERL_ARGS_ASSERT_REGEXEC_FLAGS;
2058     PERL_UNUSED_ARG(data);
2059
2060     /* Be paranoid... */
2061     if (prog == NULL || startpos == NULL) {
2062         Perl_croak(aTHX_ "NULL regexp parameter");
2063         return 0;
2064     }
2065
2066     multiline = prog->extflags & RXf_PMf_MULTILINE;
2067     reginfo.prog = rx;   /* Yes, sorry that this is confusing.  */
2068
2069     RX_MATCH_UTF8_set(rx, utf8_target);
2070     DEBUG_EXECUTE_r(
2071         debug_start_match(rx, utf8_target, startpos, strend,
2072         "Matching");
2073     );
2074
2075     minlen = prog->minlen;
2076
2077     if (strend - startpos < (minlen+(prog->check_offset_min<0?prog->check_offset_min:0))) {
2078         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2079                               "String too short [regexec_flags]...\n"));
2080         goto phooey;
2081     }
2082
2083
2084     /* Check validity of program. */
2085     if (UCHARAT(progi->program) != REG_MAGIC) {
2086         Perl_croak(aTHX_ "corrupted regexp program");
2087     }
2088
2089     PL_reg_flags = 0;
2090     PL_reg_eval_set = 0;
2091     PL_reg_maxiter = 0;
2092
2093     if (RX_UTF8(rx))
2094         PL_reg_flags |= RF_utf8;
2095
2096     /* Mark beginning of line for ^ and lookbehind. */
2097     reginfo.bol = startpos; /* XXX not used ??? */
2098     PL_bostr  = strbeg;
2099     reginfo.sv = sv;
2100
2101     /* Mark end of line for $ (and such) */
2102     PL_regeol = strend;
2103
2104     /* see how far we have to get to not match where we matched before */
2105     reginfo.till = startpos+minend;
2106
2107     /* If there is a "must appear" string, look for it. */
2108     s = startpos;
2109
2110     if (prog->extflags & RXf_GPOS_SEEN) { /* Need to set reginfo->ganch */
2111         MAGIC *mg;
2112         if (flags & REXEC_IGNOREPOS){   /* Means: check only at start */
2113             reginfo.ganch = startpos + prog->gofs;
2114             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2115               "GPOS IGNOREPOS: reginfo.ganch = startpos + %"UVxf"\n",(UV)prog->gofs));
2116         } else if (sv && SvTYPE(sv) >= SVt_PVMG
2117                   && SvMAGIC(sv)
2118                   && (mg = mg_find(sv, PERL_MAGIC_regex_global))
2119                   && mg->mg_len >= 0) {
2120             reginfo.ganch = strbeg + mg->mg_len;        /* Defined pos() */
2121             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2122                 "GPOS MAGIC: reginfo.ganch = strbeg + %"IVdf"\n",(IV)mg->mg_len));
2123
2124             if (prog->extflags & RXf_ANCH_GPOS) {
2125                 if (s > reginfo.ganch)
2126                     goto phooey;
2127                 s = reginfo.ganch - prog->gofs;
2128                 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2129                      "GPOS ANCH_GPOS: s = ganch - %"UVxf"\n",(UV)prog->gofs));
2130                 if (s < strbeg)
2131                     goto phooey;
2132             }
2133         }
2134         else if (data) {
2135             reginfo.ganch = strbeg + PTR2UV(data);
2136             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2137                  "GPOS DATA: reginfo.ganch= strbeg + %"UVxf"\n",PTR2UV(data)));
2138
2139         } else {                                /* pos() not defined */
2140             reginfo.ganch = strbeg;
2141             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2142                  "GPOS: reginfo.ganch = strbeg\n"));
2143         }
2144     }
2145     if (PL_curpm && (PM_GETRE(PL_curpm) == rx)) {
2146         /* We have to be careful. If the previous successful match
2147            was from this regex we don't want a subsequent partially
2148            successful match to clobber the old results.
2149            So when we detect this possibility we add a swap buffer
2150            to the re, and switch the buffer each match. If we fail
2151            we switch it back, otherwise we leave it swapped.
2152         */
2153         swap = prog->offs;
2154         /* do we need a save destructor here for eval dies? */
2155         Newxz(prog->offs, (prog->nparens + 1), regexp_paren_pair);
2156     }
2157     if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
2158         re_scream_pos_data d;
2159
2160         d.scream_olds = &scream_olds;
2161         d.scream_pos = &scream_pos;
2162         s = re_intuit_start(rx, sv, s, strend, flags, &d);
2163         if (!s) {
2164             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
2165             goto phooey;        /* not present */
2166         }
2167     }
2168
2169
2170
2171     /* Simplest case:  anchored match need be tried only once. */
2172     /*  [unless only anchor is BOL and multiline is set] */
2173     if (prog->extflags & (RXf_ANCH & ~RXf_ANCH_GPOS)) {
2174         if (s == startpos && regtry(&reginfo, &startpos))
2175             goto got_it;
2176         else if (multiline || (prog->intflags & PREGf_IMPLICIT)
2177                  || (prog->extflags & RXf_ANCH_MBOL)) /* XXXX SBOL? */
2178         {
2179             char *end;
2180
2181             if (minlen)
2182                 dontbother = minlen - 1;
2183             end = HOP3c(strend, -dontbother, strbeg) - 1;
2184             /* for multiline we only have to try after newlines */
2185             if (prog->check_substr || prog->check_utf8) {
2186                 /* because of the goto we can not easily reuse the macros for bifurcating the
2187                    unicode/non-unicode match modes here like we do elsewhere - demerphq */
2188                 if (utf8_target) {
2189                     if (s == startpos)
2190                         goto after_try_utf8;
2191                     while (1) {
2192                         if (regtry(&reginfo, &s)) {
2193                             goto got_it;
2194                         }
2195                       after_try_utf8:
2196                         if (s > end) {
2197                             goto phooey;
2198                         }
2199                         if (prog->extflags & RXf_USE_INTUIT) {
2200                             s = re_intuit_start(rx, sv, s + UTF8SKIP(s), strend, flags, NULL);
2201                             if (!s) {
2202                                 goto phooey;
2203                             }
2204                         }
2205                         else {
2206                             s += UTF8SKIP(s);
2207                         }
2208                     }
2209                 } /* end search for check string in unicode */
2210                 else {
2211                     if (s == startpos) {
2212                         goto after_try_latin;
2213                     }
2214                     while (1) {
2215                         if (regtry(&reginfo, &s)) {
2216                             goto got_it;
2217                         }
2218                       after_try_latin:
2219                         if (s > end) {
2220                             goto phooey;
2221                         }
2222                         if (prog->extflags & RXf_USE_INTUIT) {
2223                             s = re_intuit_start(rx, sv, s + 1, strend, flags, NULL);
2224                             if (!s) {
2225                                 goto phooey;
2226                             }
2227                         }
2228                         else {
2229                             s++;
2230                         }
2231                     }
2232                 } /* end search for check string in latin*/
2233             } /* end search for check string */
2234             else { /* search for newline */
2235                 if (s > startpos) {
2236                     /*XXX: The s-- is almost definitely wrong here under unicode - demeprhq*/
2237                     s--;
2238                 }
2239                 /* We can use a more efficient search as newlines are the same in unicode as they are in latin */
2240                 while (s < end) {
2241                     if (*s++ == '\n') { /* don't need PL_utf8skip here */
2242                         if (regtry(&reginfo, &s))
2243                             goto got_it;
2244                     }
2245                 }
2246             } /* end search for newline */
2247         } /* end anchored/multiline check string search */
2248         goto phooey;
2249     } else if (RXf_GPOS_CHECK == (prog->extflags & RXf_GPOS_CHECK))
2250     {
2251         /* the warning about reginfo.ganch being used without initialization
2252            is bogus -- we set it above, when prog->extflags & RXf_GPOS_SEEN
2253            and we only enter this block when the same bit is set. */
2254         char *tmp_s = reginfo.ganch - prog->gofs;
2255
2256         if (tmp_s >= strbeg && regtry(&reginfo, &tmp_s))
2257             goto got_it;
2258         goto phooey;
2259     }
2260
2261     /* Messy cases:  unanchored match. */
2262     if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
2263         /* we have /x+whatever/ */
2264         /* it must be a one character string (XXXX Except UTF_PATTERN?) */
2265         char ch;
2266 #ifdef DEBUGGING
2267         int did_match = 0;
2268 #endif
2269         if (!(utf8_target ? prog->anchored_utf8 : prog->anchored_substr))
2270             utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2271         ch = SvPVX_const(utf8_target ? prog->anchored_utf8 : prog->anchored_substr)[0];
2272
2273         if (utf8_target) {
2274             REXEC_FBC_SCAN(
2275                 if (*s == ch) {
2276                     DEBUG_EXECUTE_r( did_match = 1 );
2277                     if (regtry(&reginfo, &s)) goto got_it;
2278                     s += UTF8SKIP(s);
2279                     while (s < strend && *s == ch)
2280                         s += UTF8SKIP(s);
2281                 }
2282             );
2283         }
2284         else {
2285             REXEC_FBC_SCAN(
2286                 if (*s == ch) {
2287                     DEBUG_EXECUTE_r( did_match = 1 );
2288                     if (regtry(&reginfo, &s)) goto got_it;
2289                     s++;
2290                     while (s < strend && *s == ch)
2291                         s++;
2292                 }
2293             );
2294         }
2295         DEBUG_EXECUTE_r(if (!did_match)
2296                 PerlIO_printf(Perl_debug_log,
2297                                   "Did not find anchored character...\n")
2298                );
2299     }
2300     else if (prog->anchored_substr != NULL
2301               || prog->anchored_utf8 != NULL
2302               || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
2303                   && prog->float_max_offset < strend - s)) {
2304         SV *must;
2305         I32 back_max;
2306         I32 back_min;
2307         char *last;
2308         char *last1;            /* Last position checked before */
2309 #ifdef DEBUGGING
2310         int did_match = 0;
2311 #endif
2312         if (prog->anchored_substr || prog->anchored_utf8) {
2313             if (!(utf8_target ? prog->anchored_utf8 : prog->anchored_substr))
2314                 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2315             must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
2316             back_max = back_min = prog->anchored_offset;
2317         } else {
2318             if (!(utf8_target ? prog->float_utf8 : prog->float_substr))
2319                 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2320             must = utf8_target ? prog->float_utf8 : prog->float_substr;
2321             back_max = prog->float_max_offset;
2322             back_min = prog->float_min_offset;
2323         }
2324
2325
2326         if (must == &PL_sv_undef)
2327             /* could not downgrade utf8 check substring, so must fail */
2328             goto phooey;
2329
2330         if (back_min<0) {
2331             last = strend;
2332         } else {
2333             last = HOP3c(strend,        /* Cannot start after this */
2334                   -(I32)(CHR_SVLEN(must)
2335                          - (SvTAIL(must) != 0) + back_min), strbeg);
2336         }
2337         if (s > PL_bostr)
2338             last1 = HOPc(s, -1);
2339         else
2340             last1 = s - 1;      /* bogus */
2341
2342         /* XXXX check_substr already used to find "s", can optimize if
2343            check_substr==must. */
2344         scream_pos = -1;
2345         dontbother = end_shift;
2346         strend = HOPc(strend, -dontbother);
2347         while ( (s <= last) &&
2348                 ((flags & REXEC_SCREAM) && SvSCREAM(sv)
2349                  ? (s = screaminstr(sv, must, HOP3c(s, back_min, (back_min<0 ? strbeg : strend)) - strbeg,
2350                                     end_shift, &scream_pos, 0))
2351                  : (s = fbm_instr((unsigned char*)HOP3(s, back_min, (back_min<0 ? strbeg : strend)),
2352                                   (unsigned char*)strend, must,
2353                                   multiline ? FBMrf_MULTILINE : 0))) ) {
2354             /* we may be pointing at the wrong string */
2355             if ((flags & REXEC_SCREAM) && RXp_MATCH_COPIED(prog))
2356                 s = strbeg + (s - SvPVX_const(sv));
2357             DEBUG_EXECUTE_r( did_match = 1 );
2358             if (HOPc(s, -back_max) > last1) {
2359                 last1 = HOPc(s, -back_min);
2360                 s = HOPc(s, -back_max);
2361             }
2362             else {
2363                 char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
2364
2365                 last1 = HOPc(s, -back_min);
2366                 s = t;
2367             }
2368             if (utf8_target) {
2369                 while (s <= last1) {
2370                     if (regtry(&reginfo, &s))
2371                         goto got_it;
2372                     s += UTF8SKIP(s);
2373                 }
2374             }
2375             else {
2376                 while (s <= last1) {
2377                     if (regtry(&reginfo, &s))
2378                         goto got_it;
2379                     s++;
2380                 }
2381             }
2382         }
2383         DEBUG_EXECUTE_r(if (!did_match) {
2384             RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
2385                 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
2386             PerlIO_printf(Perl_debug_log, "Did not find %s substr %s%s...\n",
2387                               ((must == prog->anchored_substr || must == prog->anchored_utf8)
2388                                ? "anchored" : "floating"),
2389                 quoted, RE_SV_TAIL(must));
2390         });
2391         goto phooey;
2392     }
2393     else if ( (c = progi->regstclass) ) {
2394         if (minlen) {
2395             const OPCODE op = OP(progi->regstclass);
2396             /* don't bother with what can't match */
2397             if (PL_regkind[op] != EXACT && op != CANY && PL_regkind[op] != TRIE)
2398                 strend = HOPc(strend, -(minlen - 1));
2399         }
2400         DEBUG_EXECUTE_r({
2401             SV * const prop = sv_newmortal();
2402             regprop(prog, prop, c);
2403             {
2404                 RE_PV_QUOTED_DECL(quoted,utf8_target,PERL_DEBUG_PAD_ZERO(1),
2405                     s,strend-s,60);
2406                 PerlIO_printf(Perl_debug_log,
2407                     "Matching stclass %.*s against %s (%d bytes)\n",
2408                     (int)SvCUR(prop), SvPVX_const(prop),
2409                      quoted, (int)(strend - s));
2410             }
2411         });
2412         if (find_byclass(prog, c, s, strend, &reginfo))
2413             goto got_it;
2414         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass... [regexec_flags]\n"));
2415     }
2416     else {
2417         dontbother = 0;
2418         if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
2419             /* Trim the end. */
2420             char *last;
2421             SV* float_real;
2422
2423             if (!(utf8_target ? prog->float_utf8 : prog->float_substr))
2424                 utf8_target ? to_utf8_substr(prog) : to_byte_substr(prog);
2425             float_real = utf8_target ? prog->float_utf8 : prog->float_substr;
2426
2427             if ((flags & REXEC_SCREAM) && SvSCREAM(sv)) {
2428                 last = screaminstr(sv, float_real, s - strbeg,
2429                                    end_shift, &scream_pos, 1); /* last one */
2430                 if (!last)
2431                     last = scream_olds; /* Only one occurrence. */
2432                 /* we may be pointing at the wrong string */
2433                 else if (RXp_MATCH_COPIED(prog))
2434                     s = strbeg + (s - SvPVX_const(sv));
2435             }
2436             else {
2437                 STRLEN len;
2438                 const char * const little = SvPV_const(float_real, len);
2439
2440                 if (SvTAIL(float_real)) {
2441                     if (memEQ(strend - len + 1, little, len - 1))
2442                         last = strend - len + 1;
2443                     else if (!multiline)
2444                         last = memEQ(strend - len, little, len)
2445                             ? strend - len : NULL;
2446                     else
2447                         goto find_last;
2448                 } else {
2449                   find_last:
2450                     if (len)
2451                         last = rninstr(s, strend, little, little + len);
2452                     else
2453                         last = strend;  /* matching "$" */
2454                 }
2455             }
2456             if (last == NULL) {
2457                 DEBUG_EXECUTE_r(
2458                     PerlIO_printf(Perl_debug_log,
2459                         "%sCan't trim the tail, match fails (should not happen)%s\n",
2460                         PL_colors[4], PL_colors[5]));
2461                 goto phooey; /* Should not happen! */
2462             }
2463             dontbother = strend - last + prog->float_min_offset;
2464         }
2465         if (minlen && (dontbother < minlen))
2466             dontbother = minlen - 1;
2467         strend -= dontbother;              /* this one's always in bytes! */
2468         /* We don't know much -- general case. */
2469         if (utf8_target) {
2470             for (;;) {
2471                 if (regtry(&reginfo, &s))
2472                     goto got_it;
2473                 if (s >= strend)
2474                     break;
2475                 s += UTF8SKIP(s);
2476             };
2477         }
2478         else {
2479             do {
2480                 if (regtry(&reginfo, &s))
2481                     goto got_it;
2482             } while (s++ < strend);
2483         }
2484     }
2485
2486     /* Failure. */
2487     goto phooey;
2488
2489 got_it:
2490     Safefree(swap);
2491     RX_MATCH_TAINTED_set(rx, PL_reg_flags & RF_tainted);
2492
2493     if (PL_reg_eval_set)
2494         restore_pos(aTHX_ prog);
2495     if (RXp_PAREN_NAMES(prog))
2496         (void)hv_iterinit(RXp_PAREN_NAMES(prog));
2497
2498     /* make sure $`, $&, $', and $digit will work later */
2499     if ( !(flags & REXEC_NOT_FIRST) ) {
2500         RX_MATCH_COPY_FREE(rx);
2501         if (flags & REXEC_COPY_STR) {
2502             const I32 i = PL_regeol - startpos + (stringarg - strbeg);
2503 #ifdef PERL_OLD_COPY_ON_WRITE
2504             if ((SvIsCOW(sv)
2505                  || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS)) {
2506                 if (DEBUG_C_TEST) {
2507                     PerlIO_printf(Perl_debug_log,
2508                                   "Copy on write: regexp capture, type %d\n",
2509                                   (int) SvTYPE(sv));
2510                 }
2511                 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
2512                 prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
2513                 assert (SvPOKp(prog->saved_copy));
2514             } else
2515 #endif
2516             {
2517                 RX_MATCH_COPIED_on(rx);
2518                 s = savepvn(strbeg, i);
2519                 prog->subbeg = s;
2520             }
2521             prog->sublen = i;
2522         }
2523         else {
2524             prog->subbeg = strbeg;
2525             prog->sublen = PL_regeol - strbeg;  /* strend may have been modified */
2526         }
2527     }
2528
2529     return 1;
2530
2531 phooey:
2532     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
2533                           PL_colors[4], PL_colors[5]));
2534     if (PL_reg_eval_set)
2535         restore_pos(aTHX_ prog);
2536     if (swap) {
2537         /* we failed :-( roll it back */
2538         Safefree(prog->offs);
2539         prog->offs = swap;
2540     }
2541
2542     return 0;
2543 }
2544
2545
2546 /*
2547  - regtry - try match at specific point
2548  */
2549 STATIC I32                      /* 0 failure, 1 success */
2550 S_regtry(pTHX_ regmatch_info *reginfo, char **startpos)
2551 {
2552     dVAR;
2553     CHECKPOINT lastcp;
2554     REGEXP *const rx = reginfo->prog;
2555     regexp *const prog = (struct regexp *)SvANY(rx);
2556     RXi_GET_DECL(prog,progi);
2557     GET_RE_DEBUG_FLAGS_DECL;
2558
2559     PERL_ARGS_ASSERT_REGTRY;
2560
2561     reginfo->cutpoint=NULL;
2562
2563     if ((prog->extflags & RXf_EVAL_SEEN) && !PL_reg_eval_set) {
2564         MAGIC *mg;
2565
2566         PL_reg_eval_set = RS_init;
2567         DEBUG_EXECUTE_r(DEBUG_s(
2568             PerlIO_printf(Perl_debug_log, "  setting stack tmpbase at %"IVdf"\n",
2569                           (IV)(PL_stack_sp - PL_stack_base));
2570             ));
2571         SAVESTACK_CXPOS();
2572         cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
2573         /* Otherwise OP_NEXTSTATE will free whatever on stack now.  */
2574         SAVETMPS;
2575         /* Apparently this is not needed, judging by wantarray. */
2576         /* SAVEI8(cxstack[cxstack_ix].blk_gimme);
2577            cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
2578
2579         if (reginfo->sv) {
2580             /* Make $_ available to executed code. */
2581             if (reginfo->sv != DEFSV) {
2582                 SAVE_DEFSV;
2583                 DEFSV_set(reginfo->sv);
2584             }
2585
2586             if (!(SvTYPE(reginfo->sv) >= SVt_PVMG && SvMAGIC(reginfo->sv)
2587                   && (mg = mg_find(reginfo->sv, PERL_MAGIC_regex_global)))) {
2588                 /* prepare for quick setting of pos */
2589 #ifdef PERL_OLD_COPY_ON_WRITE
2590                 if (SvIsCOW(reginfo->sv))
2591                     sv_force_normal_flags(reginfo->sv, 0);
2592 #endif
2593                 mg = sv_magicext(reginfo->sv, NULL, PERL_MAGIC_regex_global,
2594                                  &PL_vtbl_mglob, NULL, 0);
2595                 mg->mg_len = -1;
2596             }
2597             PL_reg_magic    = mg;
2598             PL_reg_oldpos   = mg->mg_len;
2599             SAVEDESTRUCTOR_X(restore_pos, prog);
2600         }
2601         if (!PL_reg_curpm) {
2602             Newxz(PL_reg_curpm, 1, PMOP);
2603 #ifdef USE_ITHREADS
2604             {
2605                 SV* const repointer = &PL_sv_undef;
2606                 /* this regexp is also owned by the new PL_reg_curpm, which
2607                    will try to free it.  */
2608                 av_push(PL_regex_padav, repointer);
2609                 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
2610                 PL_regex_pad = AvARRAY(PL_regex_padav);
2611             }
2612 #endif
2613         }
2614 #ifdef USE_ITHREADS
2615         /* It seems that non-ithreads works both with and without this code.
2616            So for efficiency reasons it seems best not to have the code
2617            compiled when it is not needed.  */
2618         /* This is safe against NULLs: */
2619         ReREFCNT_dec(PM_GETRE(PL_reg_curpm));
2620         /* PM_reg_curpm owns a reference to this regexp.  */
2621         (void)ReREFCNT_inc(rx);
2622 #endif
2623         PM_SETRE(PL_reg_curpm, rx);
2624         PL_reg_oldcurpm = PL_curpm;
2625         PL_curpm = PL_reg_curpm;
2626         if (RXp_MATCH_COPIED(prog)) {
2627             /*  Here is a serious problem: we cannot rewrite subbeg,
2628                 since it may be needed if this match fails.  Thus
2629                 $` inside (?{}) could fail... */
2630             PL_reg_oldsaved = prog->subbeg;
2631             PL_reg_oldsavedlen = prog->sublen;
2632 #ifdef PERL_OLD_COPY_ON_WRITE
2633             PL_nrs = prog->saved_copy;
2634 #endif
2635             RXp_MATCH_COPIED_off(prog);
2636         }
2637         else
2638             PL_reg_oldsaved = NULL;
2639         prog->subbeg = PL_bostr;
2640         prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2641     }
2642     DEBUG_EXECUTE_r(PL_reg_starttry = *startpos);
2643     prog->offs[0].start = *startpos - PL_bostr;
2644     PL_reginput = *startpos;
2645     PL_reglastparen = &prog->lastparen;
2646     PL_reglastcloseparen = &prog->lastcloseparen;
2647     prog->lastparen = 0;
2648     prog->lastcloseparen = 0;
2649     PL_regsize = 0;
2650     PL_regoffs = prog->offs;
2651     if (PL_reg_start_tmpl <= prog->nparens) {
2652         PL_reg_start_tmpl = prog->nparens*3/2 + 3;
2653         if(PL_reg_start_tmp)
2654             Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2655         else
2656             Newx(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2657     }
2658
2659     /* XXXX What this code is doing here?!!!  There should be no need
2660        to do this again and again, PL_reglastparen should take care of
2661        this!  --ilya*/
2662
2663     /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2664      * Actually, the code in regcppop() (which Ilya may be meaning by
2665      * PL_reglastparen), is not needed at all by the test suite
2666      * (op/regexp, op/pat, op/split), but that code is needed otherwise
2667      * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
2668      * Meanwhile, this code *is* needed for the
2669      * above-mentioned test suite tests to succeed.  The common theme
2670      * on those tests seems to be returning null fields from matches.
2671      * --jhi updated by dapm */
2672 #if 1
2673     if (prog->nparens) {
2674         regexp_paren_pair *pp = PL_regoffs;
2675         register I32 i;
2676         for (i = prog->nparens; i > (I32)*PL_reglastparen; i--) {
2677             ++pp;
2678             pp->start = -1;
2679             pp->end = -1;
2680         }
2681     }
2682 #endif
2683     REGCP_SET(lastcp);
2684     if (regmatch(reginfo, progi->program + 1)) {
2685         PL_regoffs[0].end = PL_reginput - PL_bostr;
2686         return 1;
2687     }
2688     if (reginfo->cutpoint)
2689         *startpos= reginfo->cutpoint;
2690     REGCP_UNWIND(lastcp);
2691     return 0;
2692 }
2693
2694
2695 #define sayYES goto yes
2696 #define sayNO goto no
2697 #define sayNO_SILENT goto no_silent
2698
2699 /* we dont use STMT_START/END here because it leads to
2700    "unreachable code" warnings, which are bogus, but distracting. */
2701 #define CACHEsayNO \
2702     if (ST.cache_mask) \
2703        PL_reg_poscache[ST.cache_offset] |= ST.cache_mask; \
2704     sayNO
2705
2706 /* this is used to determine how far from the left messages like
2707    'failed...' are printed. It should be set such that messages
2708    are inline with the regop output that created them.
2709 */
2710 #define REPORT_CODE_OFF 32
2711
2712
2713 #define CHRTEST_UNINIT -1001 /* c1/c2 haven't been calculated yet */
2714 #define CHRTEST_VOID   -1000 /* the c1/c2 "next char" test should be skipped */
2715
2716 #define SLAB_FIRST(s) (&(s)->states[0])
2717 #define SLAB_LAST(s)  (&(s)->states[PERL_REGMATCH_SLAB_SLOTS-1])
2718
2719 /* grab a new slab and return the first slot in it */
2720
2721 STATIC regmatch_state *
2722 S_push_slab(pTHX)
2723 {
2724 #if PERL_VERSION < 9 && !defined(PERL_CORE)
2725     dMY_CXT;
2726 #endif
2727     regmatch_slab *s = PL_regmatch_slab->next;
2728     if (!s) {
2729         Newx(s, 1, regmatch_slab);
2730         s->prev = PL_regmatch_slab;
2731         s->next = NULL;
2732         PL_regmatch_slab->next = s;
2733     }
2734     PL_regmatch_slab = s;
2735     return SLAB_FIRST(s);
2736 }
2737
2738
2739 /* push a new state then goto it */
2740
2741 #define PUSH_STATE_GOTO(state, node) \
2742     scan = node; \
2743     st->resume_state = state; \
2744     goto push_state;
2745
2746 /* push a new state with success backtracking, then goto it */
2747
2748 #define PUSH_YES_STATE_GOTO(state, node) \
2749     scan = node; \
2750     st->resume_state = state; \
2751     goto push_yes_state;
2752
2753
2754
2755 /*
2756
2757 regmatch() - main matching routine
2758
2759 This is basically one big switch statement in a loop. We execute an op,
2760 set 'next' to point the next op, and continue. If we come to a point which
2761 we may need to backtrack to on failure such as (A|B|C), we push a
2762 backtrack state onto the backtrack stack. On failure, we pop the top
2763 state, and re-enter the loop at the state indicated. If there are no more
2764 states to pop, we return failure.
2765
2766 Sometimes we also need to backtrack on success; for example /A+/, where
2767 after successfully matching one A, we need to go back and try to
2768 match another one; similarly for lookahead assertions: if the assertion
2769 completes successfully, we backtrack to the state just before the assertion
2770 and then carry on.  In these cases, the pushed state is marked as
2771 'backtrack on success too'. This marking is in fact done by a chain of
2772 pointers, each pointing to the previous 'yes' state. On success, we pop to
2773 the nearest yes state, discarding any intermediate failure-only states.
2774 Sometimes a yes state is pushed just to force some cleanup code to be
2775 called at the end of a successful match or submatch; e.g. (??{$re}) uses
2776 it to free the inner regex.
2777
2778 Note that failure backtracking rewinds the cursor position, while
2779 success backtracking leaves it alone.
2780
2781 A pattern is complete when the END op is executed, while a subpattern
2782 such as (?=foo) is complete when the SUCCESS op is executed. Both of these
2783 ops trigger the "pop to last yes state if any, otherwise return true"
2784 behaviour.
2785
2786 A common convention in this function is to use A and B to refer to the two
2787 subpatterns (or to the first nodes thereof) in patterns like /A*B/: so A is
2788 the subpattern to be matched possibly multiple times, while B is the entire
2789 rest of the pattern. Variable and state names reflect this convention.
2790
2791 The states in the main switch are the union of ops and failure/success of
2792 substates associated with with that op.  For example, IFMATCH is the op
2793 that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
2794 'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
2795 successfully matched A and IFMATCH_A_fail is a state saying that we have
2796 just failed to match A. Resume states always come in pairs. The backtrack
2797 state we push is marked as 'IFMATCH_A', but when that is popped, we resume
2798 at IFMATCH_A or IFMATCH_A_fail, depending on whether we are backtracking
2799 on success or failure.
2800
2801 The struct that holds a backtracking state is actually a big union, with
2802 one variant for each major type of op. The variable st points to the
2803 top-most backtrack struct. To make the code clearer, within each
2804 block of code we #define ST to alias the relevant union.
2805
2806 Here's a concrete example of a (vastly oversimplified) IFMATCH
2807 implementation:
2808
2809     switch (state) {
2810     ....
2811
2812 #define ST st->u.ifmatch
2813
2814     case IFMATCH: // we are executing the IFMATCH op, (?=A)B
2815         ST.foo = ...; // some state we wish to save
2816         ...
2817         // push a yes backtrack state with a resume value of
2818         // IFMATCH_A/IFMATCH_A_fail, then continue execution at the
2819         // first node of A:
2820         PUSH_YES_STATE_GOTO(IFMATCH_A, A);
2821         // NOTREACHED
2822
2823     case IFMATCH_A: // we have successfully executed A; now continue with B
2824         next = B;
2825         bar = ST.foo; // do something with the preserved value
2826         break;
2827
2828     case IFMATCH_A_fail: // A failed, so the assertion failed
2829         ...;   // do some housekeeping, then ...
2830         sayNO; // propagate the failure
2831
2832 #undef ST
2833
2834     ...
2835     }
2836
2837 For any old-timers reading this who are familiar with the old recursive
2838 approach, the code above is equivalent to:
2839
2840     case IFMATCH: // we are executing the IFMATCH op, (?=A)B
2841     {
2842         int foo = ...
2843         ...
2844         if (regmatch(A)) {
2845             next = B;
2846             bar = foo;
2847             break;
2848         }
2849         ...;   // do some housekeeping, then ...
2850         sayNO; // propagate the failure
2851     }
2852
2853 The topmost backtrack state, pointed to by st, is usually free. If you
2854 want to claim it, populate any ST.foo fields in it with values you wish to
2855 save, then do one of
2856
2857         PUSH_STATE_GOTO(resume_state, node);
2858         PUSH_YES_STATE_GOTO(resume_state, node);
2859
2860 which sets that backtrack state's resume value to 'resume_state', pushes a
2861 new free entry to the top of the backtrack stack, then goes to 'node'.
2862 On backtracking, the free slot is popped, and the saved state becomes the
2863 new free state. An ST.foo field in this new top state can be temporarily
2864 accessed to retrieve values, but once the main loop is re-entered, it
2865 becomes available for reuse.
2866
2867 Note that the depth of the backtrack stack constantly increases during the
2868 left-to-right execution of the pattern, rather than going up and down with
2869 the pattern nesting. For example the stack is at its maximum at Z at the
2870 end of the pattern, rather than at X in the following:
2871
2872     /(((X)+)+)+....(Y)+....Z/
2873
2874 The only exceptions to this are lookahead/behind assertions and the cut,
2875 (?>A), which pop all the backtrack states associated with A before
2876 continuing.
2877
2878 Backtrack state structs are allocated in slabs of about 4K in size.
2879 PL_regmatch_state and st always point to the currently active state,
2880 and PL_regmatch_slab points to the slab currently containing
2881 PL_regmatch_state.  The first time regmatch() is called, the first slab is
2882 allocated, and is never freed until interpreter destruction. When the slab
2883 is full, a new one is allocated and chained to the end. At exit from
2884 regmatch(), slabs allocated since entry are freed.
2885
2886 */
2887
2888
2889 #define DEBUG_STATE_pp(pp)                                  \
2890     DEBUG_STATE_r({                                         \
2891         DUMP_EXEC_POS(locinput, scan, utf8_target);                 \
2892         PerlIO_printf(Perl_debug_log,                       \
2893             "    %*s"pp" %s%s%s%s%s\n",                     \
2894             depth*2, "",                                    \
2895             PL_reg_name[st->resume_state],                     \
2896             ((st==yes_state||st==mark_state) ? "[" : ""),   \
2897             ((st==yes_state) ? "Y" : ""),                   \
2898             ((st==mark_state) ? "M" : ""),                  \
2899             ((st==yes_state||st==mark_state) ? "]" : "")    \
2900         );                                                  \
2901     });
2902
2903
2904 #define REG_NODE_NUM(x) ((x) ? (int)((x)-prog) : -1)
2905
2906 #ifdef DEBUGGING
2907
2908 STATIC void
2909 S_debug_start_match(pTHX_ const REGEXP *prog, const bool utf8_target,
2910     const char *start, const char *end, const char *blurb)
2911 {
2912     const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
2913
2914     PERL_ARGS_ASSERT_DEBUG_START_MATCH;
2915
2916     if (!PL_colorset)
2917             reginitcolors();
2918     {
2919         RE_PV_QUOTED_DECL(s0, utf8_pat, PERL_DEBUG_PAD_ZERO(0),
2920             RX_PRECOMP_const(prog), RX_PRELEN(prog), 60);
2921
2922         RE_PV_QUOTED_DECL(s1, utf8_target, PERL_DEBUG_PAD_ZERO(1),
2923             start, end - start, 60);
2924
2925         PerlIO_printf(Perl_debug_log,
2926             "%s%s REx%s %s against %s\n",
2927                        PL_colors[4], blurb, PL_colors[5], s0, s1);
2928
2929         if (utf8_target||utf8_pat)
2930             PerlIO_printf(Perl_debug_log, "UTF-8 %s%s%s...\n",
2931                 utf8_pat ? "pattern" : "",
2932                 utf8_pat && utf8_target ? " and " : "",
2933                 utf8_target ? "string" : ""
2934             );
2935     }
2936 }
2937
2938 STATIC void
2939 S_dump_exec_pos(pTHX_ const char *locinput,
2940                       const regnode *scan,
2941                       const char *loc_regeol,
2942                       const char *loc_bostr,
2943                       const char *loc_reg_starttry,
2944                       const bool utf8_target)
2945 {
2946     const int docolor = *PL_colors[0] || *PL_colors[2] || *PL_colors[4];
2947     const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
2948     int l = (loc_regeol - locinput) > taill ? taill : (loc_regeol - locinput);
2949     /* The part of the string before starttry has one color
2950        (pref0_len chars), between starttry and current
2951        position another one (pref_len - pref0_len chars),
2952        after the current position the third one.
2953        We assume that pref0_len <= pref_len, otherwise we
2954        decrease pref0_len.  */
2955     int pref_len = (locinput - loc_bostr) > (5 + taill) - l
2956         ? (5 + taill) - l : locinput - loc_bostr;
2957     int pref0_len;
2958
2959     PERL_ARGS_ASSERT_DUMP_EXEC_POS;
2960
2961     while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
2962         pref_len++;
2963     pref0_len = pref_len  - (locinput - loc_reg_starttry);
2964     if (l + pref_len < (5 + taill) && l < loc_regeol - locinput)
2965         l = ( loc_regeol - locinput > (5 + taill) - pref_len
2966               ? (5 + taill) - pref_len : loc_regeol - locinput);
2967     while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
2968         l--;
2969     if (pref0_len < 0)
2970         pref0_len = 0;
2971     if (pref0_len > pref_len)
2972         pref0_len = pref_len;
2973     {
2974         const int is_uni = (utf8_target && OP(scan) != CANY) ? 1 : 0;
2975
2976         RE_PV_COLOR_DECL(s0,len0,is_uni,PERL_DEBUG_PAD(0),
2977             (locinput - pref_len),pref0_len, 60, 4, 5);
2978
2979         RE_PV_COLOR_DECL(s1,len1,is_uni,PERL_DEBUG_PAD(1),
2980                     (locinput - pref_len + pref0_len),
2981                     pref_len - pref0_len, 60, 2, 3);
2982
2983         RE_PV_COLOR_DECL(s2,len2,is_uni,PERL_DEBUG_PAD(2),
2984                     locinput, loc_regeol - locinput, 10, 0, 1);
2985
2986         const STRLEN tlen=len0+len1+len2;
2987         PerlIO_printf(Perl_debug_log,
2988                     "%4"IVdf" <%.*s%.*s%s%.*s>%*s|",
2989                     (IV)(locinput - loc_bostr),
2990                     len0, s0,
2991                     len1, s1,
2992                     (docolor ? "" : "> <"),
2993                     len2, s2,
2994                     (int)(tlen > 19 ? 0 :  19 - tlen),
2995                     "");
2996     }
2997 }
2998
2999 #endif
3000
3001 /* reg_check_named_buff_matched()
3002  * Checks to see if a named buffer has matched. The data array of
3003  * buffer numbers corresponding to the buffer is expected to reside
3004  * in the regexp->data->data array in the slot stored in the ARG() of
3005  * node involved. Note that this routine doesn't actually care about the
3006  * name, that information is not preserved from compilation to execution.
3007  * Returns the index of the leftmost defined buffer with the given name
3008  * or 0 if non of the buffers matched.
3009  */
3010 STATIC I32
3011 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
3012 {
3013     I32 n;
3014     RXi_GET_DECL(rex,rexi);
3015     SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
3016     I32 *nums=(I32*)SvPVX(sv_dat);
3017
3018     PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
3019
3020     for ( n=0; n<SvIVX(sv_dat); n++ ) {
3021         if ((I32)*PL_reglastparen >= nums[n] &&
3022             PL_regoffs[nums[n]].end != -1)
3023         {
3024             return nums[n];
3025         }
3026     }
3027     return 0;
3028 }
3029
3030
3031 /* free all slabs above current one  - called during LEAVE_SCOPE */
3032
3033 STATIC void
3034 S_clear_backtrack_stack(pTHX_ void *p)
3035 {
3036     regmatch_slab *s = PL_regmatch_slab->next;
3037     PERL_UNUSED_ARG(p);
3038
3039     if (!s)
3040         return;
3041     PL_regmatch_slab->next = NULL;
3042     while (s) {
3043         regmatch_slab * const osl = s;
3044         s = s->next;
3045         Safefree(osl);
3046     }
3047 }
3048
3049
3050 #define SETREX(Re1,Re2) \
3051     if (PL_reg_eval_set) PM_SETRE((PL_reg_curpm), (Re2)); \
3052     Re1 = (Re2)
3053
3054 STATIC I32                      /* 0 failure, 1 success */
3055 S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
3056 {
3057 #if PERL_VERSION < 9 && !defined(PERL_CORE)
3058     dMY_CXT;
3059 #endif
3060     dVAR;
3061     register const bool utf8_target = PL_reg_match_utf8;
3062     const U32 uniflags = UTF8_ALLOW_DEFAULT;
3063     REGEXP *rex_sv = reginfo->prog;
3064     regexp *rex = (struct regexp *)SvANY(rex_sv);
3065     RXi_GET_DECL(rex,rexi);
3066     I32 oldsave;
3067     /* the current state. This is a cached copy of PL_regmatch_state */
3068     register regmatch_state *st;
3069     /* cache heavy used fields of st in registers */
3070     register regnode *scan;
3071     register regnode *next;
3072     register U32 n = 0; /* general value; init to avoid compiler warning */
3073     register I32 ln = 0; /* len or last;  init to avoid compiler warning */
3074     register char *locinput = PL_reginput;
3075     register I32 nextchr;   /* is always set to UCHARAT(locinput) */
3076
3077     bool result = 0;        /* return value of S_regmatch */
3078     int depth = 0;          /* depth of backtrack stack */
3079     U32 nochange_depth = 0; /* depth of GOSUB recursion with nochange */
3080     const U32 max_nochange_depth =
3081         (3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
3082         3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
3083     regmatch_state *yes_state = NULL; /* state to pop to on success of
3084                                                             subpattern */
3085     /* mark_state piggy backs on the yes_state logic so that when we unwind
3086        the stack on success we can update the mark_state as we go */
3087     regmatch_state *mark_state = NULL; /* last mark state we have seen */
3088     regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
3089     struct regmatch_state  *cur_curlyx = NULL; /* most recent curlyx */
3090     U32 state_num;
3091     bool no_final = 0;      /* prevent failure from backtracking? */
3092     bool do_cutgroup = 0;   /* no_final only until next branch/trie entry */
3093     char *startpoint = PL_reginput;
3094     SV *popmark = NULL;     /* are we looking for a mark? */
3095     SV *sv_commit = NULL;   /* last mark name seen in failure */
3096     SV *sv_yes_mark = NULL; /* last mark name we have seen
3097                                during a successful match */
3098     U32 lastopen = 0;       /* last open we saw */
3099     bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;
3100     SV* const oreplsv = GvSV(PL_replgv);
3101     /* these three flags are set by various ops to signal information to
3102      * the very next op. They have a useful lifetime of exactly one loop
3103      * iteration, and are not preserved or restored by state pushes/pops
3104      */
3105     bool sw = 0;            /* the condition value in (?(cond)a|b) */
3106     bool minmod = 0;        /* the next "{n,m}" is a "{n,m}?" */
3107     int logical = 0;        /* the following EVAL is:
3108                                 0: (?{...})
3109                                 1: (?(?{...})X|Y)
3110                                 2: (??{...})
3111                                or the following IFMATCH/UNLESSM is:
3112                                 false: plain (?=foo)
3113                                 true:  used as a condition: (?(?=foo))
3114                             */
3115 #ifdef DEBUGGING
3116     GET_RE_DEBUG_FLAGS_DECL;
3117 #endif
3118
3119     PERL_ARGS_ASSERT_REGMATCH;
3120
3121     DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
3122             PerlIO_printf(Perl_debug_log,"regmatch start\n");
3123     }));
3124     /* on first ever call to regmatch, allocate first slab */
3125     if (!PL_regmatch_slab) {
3126         Newx(PL_regmatch_slab, 1, regmatch_slab);
3127         PL_regmatch_slab->prev = NULL;
3128         PL_regmatch_slab->next = NULL;
3129         PL_regmatch_state = SLAB_FIRST(PL_regmatch_slab);
3130     }
3131
3132     oldsave = PL_savestack_ix;
3133     SAVEDESTRUCTOR_X(S_clear_backtrack_stack, NULL);
3134     SAVEVPTR(PL_regmatch_slab);
3135     SAVEVPTR(PL_regmatch_state);
3136
3137     /* grab next free state slot */
3138     st = ++PL_regmatch_state;
3139     if (st >  SLAB_LAST(PL_regmatch_slab))
3140         st = PL_regmatch_state = S_push_slab(aTHX);
3141
3142     /* Note that nextchr is a byte even in UTF */
3143     nextchr = UCHARAT(locinput);
3144     scan = prog;
3145     while (scan != NULL) {
3146
3147         DEBUG_EXECUTE_r( {
3148             SV * const prop = sv_newmortal();
3149             regnode *rnext=regnext(scan);
3150             DUMP_EXEC_POS( locinput, scan, utf8_target );
3151             regprop(rex, prop, scan);
3152
3153             PerlIO_printf(Perl_debug_log,
3154                     "%3"IVdf":%*s%s(%"IVdf")\n",
3155                     (IV)(scan - rexi->program), depth*2, "",
3156                     SvPVX_const(prop),
3157                     (PL_regkind[OP(scan)] == END || !rnext) ?
3158                         0 : (IV)(rnext - rexi->program));
3159         });
3160
3161         next = scan + NEXT_OFF(scan);
3162         if (next == scan)
3163             next = NULL;
3164         state_num = OP(scan);
3165
3166         REH_CALL_REGEXEC_HOOK(rex, scan, reginfo, st);
3167       reenter_switch:
3168
3169         assert(PL_reglastparen == &rex->lastparen);
3170         assert(PL_reglastcloseparen == &rex->lastcloseparen);
3171         assert(PL_regoffs == rex->offs);
3172
3173         switch (state_num) {
3174         case BOL:
3175             if (locinput == PL_bostr)
3176             {
3177                 /* reginfo->till = reginfo->bol; */
3178                 break;
3179             }
3180             sayNO;
3181         case MBOL:
3182             if (locinput == PL_bostr ||
3183                 ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n'))
3184             {
3185                 break;
3186             }
3187             sayNO;
3188         case SBOL:
3189             if (locinput == PL_bostr)
3190                 break;
3191             sayNO;
3192         case GPOS:
3193             if (locinput == reginfo->ganch)
3194                 break;
3195             sayNO;
3196
3197         case KEEPS:
3198             /* update the startpoint */
3199             st->u.keeper.val = PL_regoffs[0].start;
3200             PL_reginput = locinput;
3201             PL_regoffs[0].start = locinput - PL_bostr;
3202             PUSH_STATE_GOTO(KEEPS_next, next);
3203             /*NOT-REACHED*/
3204         case KEEPS_next_fail:
3205             /* rollback the start point change */
3206             PL_regoffs[0].start = st->u.keeper.val;
3207             sayNO_SILENT;
3208             /*NOT-REACHED*/
3209         case EOL:
3210                 goto seol;
3211         case MEOL:
3212             if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
3213                 sayNO;
3214             break;
3215         case SEOL:
3216           seol:
3217             if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
3218                 sayNO;
3219             if (PL_regeol - locinput > 1)
3220                 sayNO;
3221             break;
3222         case EOS:
3223             if (PL_regeol != locinput)
3224                 sayNO;
3225             break;
3226         case SANY:
3227             if (!nextchr && locinput >= PL_regeol)
3228                 sayNO;
3229             if (utf8_target) {
3230                 locinput += PL_utf8skip[nextchr];
3231                 if (locinput > PL_regeol)
3232                     sayNO;
3233                 nextchr = UCHARAT(locinput);
3234             }
3235             else
3236                 nextchr = UCHARAT(++locinput);
3237             break;
3238         case CANY:
3239             if (!nextchr && locinput >= PL_regeol)
3240                 sayNO;
3241             nextchr = UCHARAT(++locinput);
3242             break;
3243         case REG_ANY:
3244             if ((!nextchr && locinput >= PL_regeol) || nextchr == '\n')
3245                 sayNO;
3246             if (utf8_target) {
3247                 locinput += PL_utf8skip[nextchr];
3248                 if (locinput > PL_regeol)
3249                     sayNO;
3250                 nextchr = UCHARAT(locinput);
3251             }
3252             else
3253                 nextchr = UCHARAT(++locinput);
3254             break;
3255
3256 #undef  ST
3257 #define ST st->u.trie
3258         case TRIEC:
3259             /* In this case the charclass data is available inline so
3260                we can fail fast without a lot of extra overhead.
3261              */
3262             if (scan->flags == EXACT || !utf8_target) {
3263                 if(!ANYOF_BITMAP_TEST(scan, *locinput)) {
3264                     DEBUG_EXECUTE_r(
3265                         PerlIO_printf(Perl_debug_log,
3266                                   "%*s  %sfailed to match trie start class...%s\n",
3267                                   REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3268                     );
3269                     sayNO_SILENT;
3270                     /* NOTREACHED */
3271                 }
3272             }
3273             /* FALL THROUGH */
3274         case TRIE:
3275             /* the basic plan of execution of the trie is:
3276              * At the beginning, run though all the states, and
3277              * find the longest-matching word. Also remember the position
3278              * of the shortest matching word. For example, this pattern:
3279              *    1  2 3 4    5
3280              *    ab|a|x|abcd|abc
3281              * when matched against the string "abcde", will generate
3282              * accept states for all words except 3, with the longest
3283              * matching word being 4, and the shortest being 1 (with
3284              * the position being after char 1 of the string).
3285              *
3286              * Then for each matching word, in word order (i.e. 1,2,4,5),
3287              * we run the remainder of the pattern; on each try setting
3288              * the current position to the character following the word,
3289              * returning to try the next word on failure.
3290              *
3291              * We avoid having to build a list of words at runtime by
3292              * using a compile-time structure, wordinfo[].prev, which
3293              * gives, for each word, the previous accepting word (if any).
3294              * In the case above it would contain the mappings 1->2, 2->0,
3295              * 3->0, 4->5, 5->1.  We can use this table to generate, from
3296              * the longest word (4 above), a list of all words, by
3297              * following the list of prev pointers; this gives us the
3298              * unordered list 4,5,1,2. Then given the current word we have
3299              * just tried, we can go through the list and find the
3300              * next-biggest word to try (so if we just failed on word 2,
3301              * the next in the list is 4).
3302              *
3303              * Since at runtime we don't record the matching position in
3304              * the string for each word, we have to work that out for
3305              * each word we're about to process. The wordinfo table holds
3306              * the character length of each word; given that we recorded
3307              * at the start: the position of the shortest word and its
3308              * length in chars, we just need to move the pointer the
3309              * difference between the two char lengths. Depending on
3310              * Unicode status and folding, that's cheap or expensive.
3311              *
3312              * This algorithm is optimised for the case where are only a
3313              * small number of accept states, i.e. 0,1, or maybe 2.
3314              * With lots of accepts states, and having to try all of them,
3315              * it becomes quadratic on number of accept states to find all
3316              * the next words.
3317              */
3318
3319             {
3320                 /* what type of TRIE am I? (utf8 makes this contextual) */
3321                 DECL_TRIE_TYPE(scan);
3322
3323                 /* what trie are we using right now */
3324                 reg_trie_data * const trie
3325                     = (reg_trie_data*)rexi->data->data[ ARG( scan ) ];
3326                 HV * widecharmap = MUTABLE_HV(rexi->data->data[ ARG( scan ) + 1 ]);
3327                 U32 state = trie->startstate;
3328
3329                 if (trie->bitmap && trie_type != trie_utf8_fold &&
3330                     !TRIE_BITMAP_TEST(trie,*locinput)
3331                 ) {
3332                     if (trie->states[ state ].wordnum) {
3333                          DEBUG_EXECUTE_r(
3334                             PerlIO_printf(Perl_debug_log,
3335                                           "%*s  %smatched empty string...%s\n",
3336                                           REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3337                         );
3338                         if (!trie->jump)
3339                             break;
3340                     } else {
3341                         DEBUG_EXECUTE_r(
3342                             PerlIO_printf(Perl_debug_log,
3343                                           "%*s  %sfailed to match trie start class...%s\n",
3344                                           REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3345                         );
3346                         sayNO_SILENT;
3347                    }
3348                 }
3349
3350             {
3351                 U8 *uc = ( U8* )locinput;
3352
3353                 STRLEN len = 0;
3354                 STRLEN foldlen = 0;
3355                 U8 *uscan = (U8*)NULL;
3356                 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
3357                 U32 charcount = 0; /* how many input chars we have matched */
3358                 U32 accepted = 0; /* have we seen any accepting states? */
3359
3360                 ST.B = next;
3361                 ST.jump = trie->jump;
3362                 ST.me = scan;
3363                 ST.firstpos = NULL;
3364                 ST.longfold = FALSE; /* char longer if folded => it's harder */
3365                 ST.nextword = 0;
3366
3367                 /* fully traverse the TRIE; note the position of the
3368                    shortest accept state and the wordnum of the longest
3369                    accept state */
3370
3371                 while ( state && uc <= (U8*)PL_regeol ) {
3372                     U32 base = trie->states[ state ].trans.base;
3373                     UV uvc = 0;
3374                     U16 charid = 0;
3375                     U16 wordnum;
3376                     wordnum = trie->states[ state ].wordnum;
3377
3378                     if (wordnum) { /* it's an accept state */
3379                         if (!accepted) {
3380                             accepted = 1;
3381                             /* record first match position */
3382                             if (ST.longfold) {
3383                                 ST.firstpos = (U8*)locinput;
3384                                 ST.firstchars = 0;
3385                             }
3386                             else {
3387                                 ST.firstpos = uc;
3388                                 ST.firstchars = charcount;
3389                             }
3390                         }
3391                         if (!ST.nextword || wordnum < ST.nextword)
3392                             ST.nextword = wordnum;
3393                         ST.topword = wordnum;
3394                     }
3395
3396                     DEBUG_TRIE_EXECUTE_r({
3397                                 DUMP_EXEC_POS( (char *)uc, scan, utf8_target );
3398                                 PerlIO_printf( Perl_debug_log,
3399                                     "%*s  %sState: %4"UVxf" Accepted: %c ",
3400                                     2+depth * 2, "", PL_colors[4],
3401                                     (UV)state, (accepted ? 'Y' : 'N'));
3402                     });
3403
3404                     /* read a char and goto next state */
3405                     if ( base ) {
3406                         I32 offset;
3407                         REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc,
3408                                              uscan, len, uvc, charid, foldlen,
3409                                              foldbuf, uniflags);
3410                         charcount++;
3411                         if (foldlen>0)
3412                             ST.longfold = TRUE;
3413                         if (charid &&
3414                              ( ((offset =
3415                               base + charid - 1 - trie->uniquecharcount)) >= 0)
3416
3417                              && ((U32)offset < trie->lasttrans)
3418                              && trie->trans[offset].check == state)
3419                         {
3420                             state = trie->trans[offset].next;
3421                         }
3422                         else {
3423                             state = 0;
3424                         }
3425                         uc += len;
3426
3427                     }
3428                     else {
3429                         state = 0;
3430                     }
3431                     DEBUG_TRIE_EXECUTE_r(
3432                         PerlIO_printf( Perl_debug_log,
3433                             "Charid:%3x CP:%4"UVxf" After State: %4"UVxf"%s\n",
3434                             charid, uvc, (UV)state, PL_colors[5] );
3435                     );
3436                 }
3437                 if (!accepted)
3438                    sayNO;
3439
3440                 /* calculate total number of accept states */
3441                 {
3442                     U16 w = ST.topword;
3443                     accepted = 0;
3444                     while (w) {
3445                         w = trie->wordinfo[w].prev;
3446                         accepted++;
3447                     }
3448                     ST.accepted = accepted;
3449                 }
3450
3451                 DEBUG_EXECUTE_r(
3452                     PerlIO_printf( Perl_debug_log,
3453                         "%*s  %sgot %"IVdf" possible matches%s\n",
3454                         REPORT_CODE_OFF + depth * 2, "",
3455                         PL_colors[4], (IV)ST.accepted, PL_colors[5] );
3456                 );
3457                 goto trie_first_try; /* jump into the fail handler */
3458             }}
3459             /* NOTREACHED */
3460
3461         case TRIE_next_fail: /* we failed - try next alternative */
3462             if ( ST.jump) {
3463                 REGCP_UNWIND(ST.cp);
3464                 for (n = *PL_reglastparen; n > ST.lastparen; n--)
3465                     PL_regoffs[n].end = -1;
3466                 *PL_reglastparen = n;
3467             }
3468             if (!--ST.accepted) {
3469                 DEBUG_EXECUTE_r({
3470                     PerlIO_printf( Perl_debug_log,
3471                         "%*s  %sTRIE failed...%s\n",
3472                         REPORT_CODE_OFF+depth*2, "",
3473                         PL_colors[4],
3474                         PL_colors[5] );
3475                 });
3476                 sayNO_SILENT;
3477             }
3478             {
3479                 /* Find next-highest word to process.  Note that this code
3480                  * is O(N^2) per trie run (O(N) per branch), so keep tight */
3481                 register U16 min = 0;
3482                 register U16 word;
3483                 register U16 const nextword = ST.nextword;
3484                 register reg_trie_wordinfo * const wordinfo
3485                     = ((reg_trie_data*)rexi->data->data[ARG(ST.me)])->wordinfo;
3486                 for (word=ST.topword; word; word=wordinfo[word].prev) {
3487                     if (word > nextword && (!min || word < min))
3488                         min = word;
3489                 }
3490                 ST.nextword = min;
3491             }
3492
3493           trie_first_try:
3494             if (do_cutgroup) {
3495                 do_cutgroup = 0;
3496                 no_final = 0;
3497             }
3498
3499             if ( ST.jump) {
3500                 ST.lastparen = *PL_reglastparen;
3501                 REGCP_SET(ST.cp);
3502             }
3503
3504             /* find start char of end of current word */
3505             {
3506                 U32 chars; /* how many chars to skip */
3507                 U8 *uc = ST.firstpos;
3508                 reg_trie_data * const trie
3509                     = (reg_trie_data*)rexi->data->data[ARG(ST.me)];
3510
3511                 assert((trie->wordinfo[ST.nextword].len - trie->prefixlen)
3512                             >=  ST.firstchars);
3513                 chars = (trie->wordinfo[ST.nextword].len - trie->prefixlen)
3514                             - ST.firstchars;
3515
3516                 if (ST.longfold) {
3517                     /* the hard option - fold each char in turn and find
3518                      * its folded length (which may be different */
3519                     U8 foldbuf[UTF8_MAXBYTES_CASE + 1];
3520                     STRLEN foldlen;
3521                     STRLEN len;
3522                     UV uvc;
3523                     U8 *uscan;
3524
3525                     while (chars) {
3526                         if (utf8_target) {
3527                             uvc = utf8n_to_uvuni((U8*)uc, UTF8_MAXLEN, &len,
3528                                                     uniflags);
3529                             uc += len;
3530                         }
3531                         else {
3532                             uvc = *uc;
3533                             uc++;
3534                         }
3535                         uvc = to_uni_fold(uvc, foldbuf, &foldlen);
3536                         uscan = foldbuf;
3537                         while (foldlen) {
3538                             if (!--chars)
3539                                 break;
3540                             uvc = utf8n_to_uvuni(uscan, UTF8_MAXLEN, &len,
3541                                             uniflags);
3542                             uscan += len;
3543                             foldlen -= len;
3544                         }
3545                     }
3546                 }
3547                 else {
3548                     if (utf8_target)
3549                         while (chars--)
3550                             uc += UTF8SKIP(uc);
3551                     else
3552                         uc += chars;
3553                 }
3554                 PL_reginput = (char *)uc;
3555             }
3556
3557             scan = (ST.jump && ST.jump[ST.nextword])
3558                         ? ST.me + ST.jump[ST.nextword]
3559                         : ST.B;
3560
3561             DEBUG_EXECUTE_r({
3562                 PerlIO_printf( Perl_debug_log,
3563                     "%*s  %sTRIE matched word #%d, continuing%s\n",
3564                     REPORT_CODE_OFF+depth*2, "",
3565                     PL_colors[4],
3566                     ST.nextword,
3567                     PL_colors[5]
3568                     );
3569             });
3570
3571             if (ST.accepted > 1 || has_cutgroup) {
3572                 PUSH_STATE_GOTO(TRIE_next, scan);
3573                 /* NOTREACHED */
3574             }
3575             /* only one choice left - just continue */
3576             DEBUG_EXECUTE_r({
3577                 AV *const trie_words
3578                     = MUTABLE_AV(rexi->data->data[ARG(ST.me)+TRIE_WORDS_OFFSET]);
3579                 SV ** const tmp = av_fetch( trie_words,
3580                     ST.nextword-1, 0 );
3581                 SV *sv= tmp ? sv_newmortal() : NULL;
3582
3583                 PerlIO_printf( Perl_debug_log,
3584                     "%*s  %sonly one match left, short-circuiting: #%d <%s>%s\n",
3585                     REPORT_CODE_OFF+depth*2, "", PL_colors[4],
3586                     ST.nextword,
3587                     tmp ? pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 0,
3588                             PL_colors[0], PL_colors[1],
3589                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)|PERL_PV_ESCAPE_NONASCII
3590                         )
3591                     : "not compiled under -Dr",
3592                     PL_colors[5] );
3593             });
3594
3595             locinput = PL_reginput;
3596             nextchr = UCHARAT(locinput);
3597             continue; /* execute rest of RE */
3598             /* NOTREACHED */
3599 #undef  ST
3600
3601         case EXACT: {
3602             char *s = STRING(scan);
3603             ln = STR_LEN(scan);
3604             if (utf8_target != UTF_PATTERN) {
3605                 /* The target and the pattern have differing utf8ness. */
3606                 char *l = locinput;
3607                 const char * const e = s + ln;
3608
3609                 if (utf8_target) {
3610                     /* The target is utf8, the pattern is not utf8. */
3611                     while (s < e) {
3612                         STRLEN ulen;
3613                         if (l >= PL_regeol)
3614                              sayNO;
3615                         if (NATIVE_TO_UNI(*(U8*)s) !=
3616                             utf8n_to_uvuni((U8*)l, UTF8_MAXBYTES, &ulen,
3617                                             uniflags))
3618                              sayNO;
3619                         l += ulen;
3620                         s ++;
3621                     }
3622                 }
3623                 else {
3624                     /* The target is not utf8, the pattern is utf8. */
3625                     while (s < e) {
3626                         STRLEN ulen;
3627                         if (l >= PL_regeol)
3628                             sayNO;
3629                         if (NATIVE_TO_UNI(*((U8*)l)) !=
3630                             utf8n_to_uvuni((U8*)s, UTF8_MAXBYTES, &ulen,
3631                                            uniflags))
3632                             sayNO;
3633                         s += ulen;
3634                         l ++;
3635                     }
3636                 }
3637                 locinput = l;
3638                 nextchr = UCHARAT(locinput);
3639                 break;
3640             }
3641             /* The target and the pattern have the same utf8ness. */
3642             /* Inline the first character, for speed. */
3643             if (UCHARAT(s) != nextchr)
3644                 sayNO;
3645             if (PL_regeol - locinput < ln)
3646                 sayNO;
3647             if (ln > 1 && memNE(s, locinput, ln))
3648                 sayNO;
3649             locinput += ln;
3650             nextchr = UCHARAT(locinput);
3651             break;
3652             }
3653         case EXACTFL: {
3654             re_fold_t folder;
3655             const U8 * fold_array;
3656             const char * s;
3657             U32 fold_utf8_flags;
3658
3659             PL_reg_flags |= RF_tainted;
3660             folder = foldEQ_locale;
3661             fold_array = PL_fold_locale;
3662             fold_utf8_flags = FOLDEQ_UTF8_LOCALE;
3663             goto do_exactf;
3664
3665         case EXACTFU:
3666             folder = foldEQ_latin1;
3667             fold_array = PL_fold_latin1;
3668             fold_utf8_flags = (UTF_PATTERN) ? FOLDEQ_S1_ALREADY_FOLDED : 0;
3669             goto do_exactf;
3670
3671         case EXACTFA:
3672             folder = foldEQ_latin1;
3673             fold_array = PL_fold_latin1;
3674             fold_utf8_flags = FOLDEQ_UTF8_NOMIX_ASCII;
3675             goto do_exactf;
3676
3677         case EXACTF:
3678             folder = foldEQ;
3679             fold_array = PL_fold;
3680             fold_utf8_flags = (UTF_PATTERN) ? FOLDEQ_S1_ALREADY_FOLDED : 0;
3681
3682           do_exactf:
3683             s = STRING(scan);
3684             ln = STR_LEN(scan);
3685
3686             if (utf8_target || UTF_PATTERN) {
3687               /* Either target or the pattern are utf8. */
3688                 const char * const l = locinput;
3689                 char *e = PL_regeol;
3690
3691                 if (! foldEQ_utf8_flags(s, 0,  ln, cBOOL(UTF_PATTERN),
3692                                l, &e, 0,  utf8_target, fold_utf8_flags))
3693                 {
3694                     sayNO;
3695                 }
3696                 locinput = e;
3697                 nextchr = UCHARAT(locinput);
3698                 break;
3699             }
3700
3701             /* Neither the target nor the pattern are utf8 */
3702             if (UCHARAT(s) != nextchr &&
3703                 UCHARAT(s) != fold_array[nextchr])
3704             {
3705                 sayNO;
3706             }
3707             if (PL_regeol - locinput < ln)
3708                 sayNO;
3709             if (ln > 1 && ! folder(s, locinput, ln))
3710                 sayNO;
3711             locinput += ln;
3712             nextchr = UCHARAT(locinput);
3713             break;
3714         }
3715
3716         /* XXX Could improve efficiency by separating these all out using a
3717          * macro or in-line function.  At that point regcomp.c would no longer
3718          * have to set the FLAGS fields of these */
3719         case BOUNDL:
3720         case NBOUNDL:
3721             PL_reg_flags |= RF_tainted;
3722             /* FALL THROUGH */
3723         case BOUND:
3724         case BOUNDU:
3725         case BOUNDA:
3726         case NBOUND:
3727         case NBOUNDU:
3728         case NBOUNDA:
3729             /* was last char in word? */
3730             if (utf8_target
3731                 && FLAGS(scan) != REGEX_ASCII_RESTRICTED_CHARSET
3732                 && FLAGS(scan) != REGEX_ASCII_MORE_RESTRICTED_CHARSET)
3733             {
3734                 if (locinput == PL_bostr)
3735                     ln = '\n';
3736                 else {
3737                     const U8 * const r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
3738
3739                     ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, uniflags);
3740                 }
3741                 if (FLAGS(scan) != REGEX_LOCALE_CHARSET) {
3742                     ln = isALNUM_uni(ln);
3743                     LOAD_UTF8_CHARCLASS_ALNUM();
3744                     n = swash_fetch(PL_utf8_alnum, (U8*)locinput, utf8_target);
3745                 }
3746                 else {
3747                     ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(ln));
3748                     n = isALNUM_LC_utf8((U8*)locinput);
3749                 }
3750             }
3751             else {
3752
3753                 /* Here the string isn't utf8, or is utf8 and only ascii
3754                  * characters are to match \w.  In the latter case looking at
3755                  * the byte just prior to the current one may be just the final
3756                  * byte of a multi-byte character.  This is ok.  There are two
3757                  * cases:
3758                  * 1) it is a single byte character, and then the test is doing
3759                  *      just what it's supposed to.
3760                  * 2) it is a multi-byte character, in which case the final
3761                  *      byte is never mistakable for ASCII, and so the test
3762                  *      will say it is not a word character, which is the
3763                  *      correct answer. */
3764                 ln = (locinput != PL_bostr) ?
3765                     UCHARAT(locinput - 1) : '\n';
3766                 switch (FLAGS(scan)) {
3767                     case REGEX_UNICODE_CHARSET:
3768                         ln = isWORDCHAR_L1(ln);
3769                         n = isWORDCHAR_L1(nextchr);
3770                         break;
3771                     case REGEX_LOCALE_CHARSET:
3772                         ln = isALNUM_LC(ln);
3773                         n = isALNUM_LC(nextchr);
3774                         break;
3775                     case REGEX_DEPENDS_CHARSET:
3776                         ln = isALNUM(ln);
3777                         n = isALNUM(nextchr);
3778                         break;
3779                     case REGEX_ASCII_RESTRICTED_CHARSET:
3780                     case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
3781                         ln = isWORDCHAR_A(ln);
3782                         n = isWORDCHAR_A(nextchr);
3783                         break;
3784                     default:
3785                         Perl_croak(aTHX_ "panic: Unexpected FLAGS %u in op %u", FLAGS(scan), OP(scan));
3786                         break;
3787                 }
3788             }
3789             /* Note requires that all BOUNDs be lower than all NBOUNDs in
3790              * regcomp.sym */
3791             if (((!ln) == (!n)) == (OP(scan) < NBOUND))
3792                     sayNO;
3793             break;
3794         case ANYOFV:
3795         case ANYOF:
3796             if (utf8_target || state_num == ANYOFV) {
3797                 STRLEN inclasslen = PL_regeol - locinput;
3798                 if (locinput >= PL_regeol)
3799                     sayNO;
3800
3801                 if (!reginclass(rex, scan, (U8*)locinput, &inclasslen, utf8_target))
3802                     sayNO;
3803                 locinput += inclasslen;
3804                 nextchr = UCHARAT(locinput);
3805                 break;
3806             }
3807             else {
3808                 if (nextchr < 0)
3809                     nextchr = UCHARAT(locinput);
3810                 if (!nextchr && locinput >= PL_regeol)
3811                     sayNO;
3812                 if (!REGINCLASS(rex, scan, (U8*)locinput))
3813                     sayNO;
3814                 nextchr = UCHARAT(++locinput);
3815                 break;
3816             }
3817             break;
3818         /* Special char classes - The defines start on line 129 or so */
3819         CCC_TRY_U(ALNUM,  NALNUM,  isWORDCHAR,
3820                   ALNUML, NALNUML, isALNUM_LC, isALNUM_LC_utf8,
3821                   ALNUMU, NALNUMU, isWORDCHAR_L1,
3822                   ALNUMA, NALNUMA, isWORDCHAR_A,
3823                   alnum, "a");
3824
3825         CCC_TRY_U(SPACE,  NSPACE,  isSPACE,
3826                   SPACEL, NSPACEL, isSPACE_LC, isSPACE_LC_utf8,
3827                   SPACEU, NSPACEU, isSPACE_L1,
3828                   SPACEA, NSPACEA, isSPACE_A,
3829                   space, " ");
3830
3831         CCC_TRY(DIGIT,  NDIGIT,  isDIGIT,
3832                 DIGITL, NDIGITL, isDIGIT_LC, isDIGIT_LC_utf8,
3833                 DIGITA, NDIGITA, isDIGIT_A,
3834                 digit, "0");
3835
3836         case CLUMP: /* Match \X: logical Unicode character.  This is defined as
3837                        a Unicode extended Grapheme Cluster */
3838             /* From http://www.unicode.org/reports/tr29 (5.2 version).  An
3839               extended Grapheme Cluster is:
3840
3841                CR LF
3842                | Prepend* Begin Extend*
3843                | .
3844
3845                Begin is (Hangul-syllable | ! Control)
3846                Extend is (Grapheme_Extend | Spacing_Mark)
3847                Control is [ GCB_Control CR LF ]
3848
3849                The discussion below shows how the code for CLUMP is derived
3850                from this regex.  Note that most of these concepts are from
3851                property values of the Grapheme Cluster Boundary (GCB) property.
3852                No code point can have multiple property values for a given
3853                property.  Thus a code point in Prepend can't be in Control, but
3854                it must be in !Control.  This is why Control above includes
3855                GCB_Control plus CR plus LF.  The latter two are used in the GCB
3856                property separately, and so can't be in GCB_Control, even though
3857                they logically are controls.  Control is not the same as gc=cc,
3858                but includes format and other characters as well.
3859
3860                The Unicode definition of Hangul-syllable is:
3861                    L+
3862                    | (L* ( ( V | LV ) V* | LVT ) T*)
3863                    | T+
3864                   )
3865                Each of these is a value for the GCB property, and hence must be
3866                disjoint, so the order they are tested is immaterial, so the
3867                above can safely be changed to
3868                    T+
3869                    | L+
3870                    | (L* ( LVT | ( V | LV ) V*) T*)
3871
3872                The last two terms can be combined like this:
3873                    L* ( L
3874                         | (( LVT | ( V | LV ) V*) T*))
3875
3876                And refactored into this:
3877                    L* (L | LVT T* | V  V* T* | LV  V* T*)
3878
3879                That means that if we have seen any L's at all we can quit
3880                there, but if the next character is an LVT, a V, or an LV we
3881                should keep going.
3882
3883                There is a subtlety with Prepend* which showed up in testing.
3884                Note that the Begin, and only the Begin is required in:
3885                 | Prepend* Begin Extend*
3886                Also, Begin contains '! Control'.  A Prepend must be a
3887                '!  Control', which means it must also be a Begin.  What it
3888                comes down to is that if we match Prepend* and then find no
3889                suitable Begin afterwards, that if we backtrack the last
3890                Prepend, that one will be a suitable Begin.
3891             */
3892
3893             if (locinput >= PL_regeol)
3894                 sayNO;
3895             if  (! utf8_target) {
3896
3897                 /* Match either CR LF  or '.', as all the other possibilities
3898                  * require utf8 */
3899                 locinput++;         /* Match the . or CR */
3900                 if (nextchr == '\r' /* And if it was CR, and the next is LF,
3901                                        match the LF */
3902                     && locinput < PL_regeol
3903                     && UCHARAT(locinput) == '\n') locinput++;
3904             }
3905             else {
3906
3907                 /* Utf8: See if is ( CR LF ); already know that locinput <
3908                  * PL_regeol, so locinput+1 is in bounds */
3909                 if (nextchr == '\r' && UCHARAT(locinput + 1) == '\n') {
3910                     locinput += 2;
3911                 }
3912                 else {
3913                     /* In case have to backtrack to beginning, then match '.' */
3914                     char *starting = locinput;
3915
3916                     /* In case have to backtrack the last prepend */
3917                     char *previous_prepend = 0;
3918
3919                     LOAD_UTF8_CHARCLASS_GCB();
3920
3921                     /* Match (prepend)* */
3922                     while (locinput < PL_regeol
3923                            && swash_fetch(PL_utf8_X_prepend,
3924                                           (U8*)locinput, utf8_target))
3925                     {
3926                         previous_prepend = locinput;
3927                         locinput += UTF8SKIP(locinput);
3928                     }
3929
3930                     /* As noted above, if we matched a prepend character, but
3931                      * the next thing won't match, back off the last prepend we
3932                      * matched, as it is guaranteed to match the begin */
3933                     if (previous_prepend
3934                         && (locinput >=  PL_regeol
3935                             || ! swash_fetch(PL_utf8_X_begin,
3936                                              (U8*)locinput, utf8_target)))
3937                     {
3938                         locinput = previous_prepend;
3939                     }
3940
3941                     /* Note that here we know PL_regeol > locinput, as we
3942                      * tested that upon input to this switch case, and if we
3943                      * moved locinput forward, we tested the result just above
3944                      * and it either passed, or we backed off so that it will
3945                      * now pass */
3946                     if (! swash_fetch(PL_utf8_X_begin, (U8*)locinput, utf8_target)) {
3947
3948                         /* Here did not match the required 'Begin' in the
3949                          * second term.  So just match the very first
3950                          * character, the '.' of the final term of the regex */
3951                         locinput = starting + UTF8SKIP(starting);
3952                     } else {
3953
3954                         /* Here is the beginning of a character that can have
3955                          * an extender.  It is either a hangul syllable, or a
3956                          * non-control */
3957                         if (swash_fetch(PL_utf8_X_non_hangul,
3958                                         (U8*)locinput, utf8_target))
3959                         {
3960
3961                             /* Here not a Hangul syllable, must be a
3962                              * ('!  * Control') */
3963                             locinput += UTF8SKIP(locinput);
3964                         } else {
3965
3966                             /* Here is a Hangul syllable.  It can be composed
3967                              * of several individual characters.  One
3968                              * possibility is T+ */
3969                             if (swash_fetch(PL_utf8_X_T,
3970                                             (U8*)locinput, utf8_target))
3971                             {
3972                                 while (locinput < PL_regeol
3973                                         && swash_fetch(PL_utf8_X_T,
3974                                                         (U8*)locinput, utf8_target))
3975                                 {
3976                                     locinput += UTF8SKIP(locinput);
3977                                 }
3978                             } else {
3979
3980                                 /* Here, not T+, but is a Hangul.  That means
3981                                  * it is one of the others: L, LV, LVT or V,
3982                                  * and matches:
3983                                  * L* (L | LVT T* | V  V* T* | LV  V* T*) */
3984
3985                                 /* Match L*           */
3986                                 while (locinput < PL_regeol
3987                                         && swash_fetch(PL_utf8_X_L,
3988                                                         (U8*)locinput, utf8_target))
3989                                 {
3990                                     locinput += UTF8SKIP(locinput);
3991                                 }
3992
3993                                 /* Here, have exhausted L*.  If the next
3994                                  * character is not an LV, LVT nor V, it means
3995                                  * we had to have at least one L, so matches L+
3996                                  * in the original equation, we have a complete
3997                                  * hangul syllable.  Are done. */
3998
3999                                 if (locinput < PL_regeol
4000                                     && swash_fetch(PL_utf8_X_LV_LVT_V,
4001                                                     (U8*)locinput, utf8_target))
4002                                 {
4003
4004                                     /* Otherwise keep going.  Must be LV, LVT
4005                                      * or V.  See if LVT */
4006                                     if (swash_fetch(PL_utf8_X_LVT,
4007                                                     (U8*)locinput, utf8_target))
4008                                     {
4009                                         locinput += UTF8SKIP(locinput);
4010                                     } else {
4011
4012                                         /* Must be  V or LV.  Take it, then
4013                                          * match V*     */
4014                                         locinput += UTF8SKIP(locinput);
4015                                         while (locinput < PL_regeol
4016                                                 && swash_fetch(PL_utf8_X_V,
4017                                                          (U8*)locinput, utf8_target))
4018                                         {
4019                                             locinput += UTF8SKIP(locinput);
4020                                         }
4021                                     }
4022
4023                                     /* And any of LV, LVT, or V can be followed
4024                                      * by T*            */
4025                                     while (locinput < PL_regeol
4026                                            && swash_fetch(PL_utf8_X_T,
4027                                                            (U8*)locinput,
4028                                                            utf8_target))
4029                                     {
4030                                         locinput += UTF8SKIP(locinput);
4031                                     }
4032                                 }
4033                             }
4034                         }
4035
4036                         /* Match any extender */
4037                         while (locinput < PL_regeol
4038                                 && swash_fetch(PL_utf8_X_extend,
4039                                                 (U8*)locinput, utf8_target))
4040                         {
4041                             locinput += UTF8SKIP(locinput);
4042                         }
4043                     }
4044                 }
4045                 if (locinput > PL_regeol) sayNO;
4046             }
4047             nextchr = UCHARAT(locinput);
4048             break;
4049
4050         case NREFFL:
4051         {   /* The capture buffer cases.  The ones beginning with N for the
4052                named buffers just convert to the equivalent numbered and
4053                pretend they were called as the corresponding numbered buffer
4054                op.  */
4055             /* don't initialize these in the declaration, it makes C++
4056                unhappy */
4057             char *s;
4058             char type;
4059             re_fold_t folder;
4060             const U8 *fold_array;
4061             UV utf8_fold_flags;
4062
4063             PL_reg_flags |= RF_tainted;
4064             folder = foldEQ_locale;
4065             fold_array = PL_fold_locale;
4066             type = REFFL;
4067             utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
4068             goto do_nref;
4069
4070         case NREFFA:
4071             folder = foldEQ_latin1;
4072             fold_array = PL_fold_latin1;
4073             type = REFFA;
4074             utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
4075             goto do_nref;
4076
4077         case NREFFU:
4078             folder = foldEQ_latin1;
4079             fold_array = PL_fold_latin1;
4080             type = REFFU;
4081             utf8_fold_flags = 0;
4082             goto do_nref;
4083
4084         case NREFF:
4085             folder = foldEQ;
4086             fold_array = PL_fold;
4087             type = REFF;
4088             utf8_fold_flags = 0;
4089             goto do_nref;
4090
4091         case NREF:
4092             type = REF;
4093             folder = NULL;
4094             fold_array = NULL;
4095             utf8_fold_flags = 0;
4096           do_nref:
4097
4098             /* For the named back references, find the corresponding buffer
4099              * number */
4100             n = reg_check_named_buff_matched(rex,scan);
4101
4102             if ( ! n ) {
4103                 sayNO;
4104             }
4105             goto do_nref_ref_common;
4106
4107         case REFFL:
4108             PL_reg_flags |= RF_tainted;
4109             folder = foldEQ_locale;
4110             fold_array = PL_fold_locale;
4111             utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
4112             goto do_ref;
4113
4114         case REFFA:
4115             folder = foldEQ_latin1;
4116             fold_array = PL_fold_latin1;
4117             utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
4118             goto do_ref;
4119
4120         case REFFU:
4121             folder = foldEQ_latin1;
4122             fold_array = PL_fold_latin1;
4123             utf8_fold_flags = 0;
4124             goto do_ref;
4125
4126         case REFF:
4127             folder = foldEQ;
4128             fold_array = PL_fold;
4129             utf8_fold_flags = 0;
4130             goto do_ref;
4131
4132         case REF:
4133             folder = NULL;
4134             fold_array = NULL;
4135             utf8_fold_flags = 0;
4136
4137           do_ref:
4138             type = OP(scan);
4139             n = ARG(scan);  /* which paren pair */
4140
4141           do_nref_ref_common:
4142             ln = PL_regoffs[n].start;
4143             PL_reg_leftiter = PL_reg_maxiter;           /* Void cache */
4144             if (*PL_reglastparen < n || ln == -1)
4145                 sayNO;                  /* Do not match unless seen CLOSEn. */
4146             if (ln == PL_regoffs[n].end)
4147                 break;
4148
4149             s = PL_bostr + ln;
4150             if (type != REF     /* REF can do byte comparison */
4151                 && (utf8_target || type == REFFU))
4152             { /* XXX handle REFFL better */
4153                 char * limit = PL_regeol;
4154
4155                 /* This call case insensitively compares the entire buffer
4156                     * at s, with the current input starting at locinput, but
4157                     * not going off the end given by PL_regeol, and returns in
4158                     * limit upon success, how much of the current input was
4159                     * matched */
4160                 if (! foldEQ_utf8_flags(s, NULL, PL_regoffs[n].end - ln, utf8_target,
4161                                     locinput, &limit, 0, utf8_target, utf8_fold_flags))
4162                 {
4163                     sayNO;
4164                 }
4165                 locinput = limit;
4166                 nextchr = UCHARAT(locinput);
4167                 break;
4168             }
4169
4170             /* Not utf8:  Inline the first character, for speed. */
4171             if (UCHARAT(s) != nextchr &&
4172                 (type == REF ||
4173                  UCHARAT(s) != fold_array[nextchr]))
4174                 sayNO;
4175             ln = PL_regoffs[n].end - ln;
4176             if (locinput + ln > PL_regeol)
4177                 sayNO;
4178             if (ln > 1 && (type == REF
4179                            ? memNE(s, locinput, ln)
4180                            : ! folder(s, locinput, ln)))
4181                 sayNO;
4182             locinput += ln;
4183             nextchr = UCHARAT(locinput);
4184             break;
4185         }
4186         case NOTHING:
4187         case TAIL:
4188             break;
4189         case BACK:
4190             break;
4191
4192 #undef  ST
4193 #define ST st->u.eval
4194         {
4195             SV *ret;
4196             REGEXP *re_sv;
4197             regexp *re;
4198             regexp_internal *rei;
4199             regnode *startpoint;
4200
4201         case GOSTART:
4202         case GOSUB: /*    /(...(?1))/   /(...(?&foo))/   */
4203             if (cur_eval && cur_eval->locinput==locinput) {
4204                 if (cur_eval->u.eval.close_paren == (U32)ARG(scan))
4205                     Perl_croak(aTHX_ "Infinite recursion in regex");
4206                 if ( ++nochange_depth > max_nochange_depth )
4207                     Perl_croak(aTHX_
4208                         "Pattern subroutine nesting without pos change"
4209                         " exceeded limit in regex");
4210             } else {
4211                 nochange_depth = 0;
4212             }
4213             re_sv = rex_sv;
4214             re = rex;
4215             rei = rexi;
4216             (void)ReREFCNT_inc(rex_sv);
4217             if (OP(scan)==GOSUB) {
4218                 startpoint = scan + ARG2L(scan);
4219                 ST.close_paren = ARG(scan);
4220             } else {
4221                 startpoint = rei->program+1;
4222                 ST.close_paren = 0;
4223             }
4224             goto eval_recurse_doit;
4225             /* NOTREACHED */
4226         case EVAL:  /*   /(?{A})B/   /(??{A})B/  and /(?(?{A})X|Y)B/   */
4227             if (cur_eval && cur_eval->locinput==locinput) {
4228                 if ( ++nochange_depth > max_nochange_depth )
4229                     Perl_croak(aTHX_ "EVAL without pos change exceeded limit in regex");
4230             } else {
4231                 nochange_depth = 0;
4232             }
4233             {
4234                 /* execute the code in the {...} */
4235                 dSP;
4236                 SV ** const before = SP;
4237                 OP_4tree * const oop = PL_op;
4238                 COP * const ocurcop = PL_curcop;
4239                 PAD *old_comppad;
4240                 char *saved_regeol = PL_regeol;
4241                 struct re_save_state saved_state;
4242
4243                 /* To not corrupt the existing regex state while executing the
4244                  * eval we would normally put it on the save stack, like with
4245                  * save_re_context. However, re-evals have a weird scoping so we
4246                  * can't just add ENTER/LEAVE here. With that, things like
4247                  *
4248                  *    (?{$a=2})(a(?{local$a=$a+1}))*aak*c(?{$b=$a})
4249                  *
4250                  * would break, as they expect the localisation to be unwound
4251                  * only when the re-engine backtracks through the bit that
4252                  * localised it.
4253                  *
4254                  * What we do instead is just saving the state in a local c
4255                  * variable.
4256                  */
4257                 Copy(&PL_reg_state, &saved_state, 1, struct re_save_state);
4258
4259                 n = ARG(scan);
4260                 PL_op = (OP_4tree*)rexi->data->data[n];
4261                 DEBUG_STATE_r( PerlIO_printf(Perl_debug_log,
4262                     "  re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
4263                 /* wrap the call in two SAVECOMPPADs. This ensures that
4264                  * when the save stack is eventually unwound, all the
4265                  * accumulated SAVEt_CLEARSV's will be processed with
4266                  * interspersed SAVEt_COMPPAD's to ensure that lexicals
4267                  * are cleared in the right pad */
4268                 SAVECOMPPAD();
4269                 PAD_SAVE_LOCAL(old_comppad, (PAD*)rexi->data->data[n + 2]);
4270                 PL_regoffs[0].end = PL_reg_magic->mg_len = locinput - PL_bostr;
4271
4272                 if (sv_yes_mark) {
4273                     SV *sv_mrk = get_sv("REGMARK", 1);
4274                     sv_setsv(sv_mrk, sv_yes_mark);
4275                 }
4276
4277                 CALLRUNOPS(aTHX);                       /* Scalar context. */
4278                 SPAGAIN;
4279                 if (SP == before)
4280                     ret = &PL_sv_undef;   /* protect against empty (?{}) blocks. */
4281                 else {
4282                     ret = POPs;
4283                     PUTBACK;
4284                 }
4285
4286                 Copy(&saved_state, &PL_reg_state, 1, struct re_save_state);
4287
4288                 PL_op = oop;
4289                 SAVECOMPPAD();
4290                 PAD_RESTORE_LOCAL(old_comppad);
4291                 PL_curcop = ocurcop;
4292                 PL_regeol = saved_regeol;
4293                 if (!logical) {
4294                     /* /(?{...})/ */
4295                     sv_setsv(save_scalar(PL_replgv), ret);
4296                     break;
4297                 }
4298             }
4299             if (logical == 2) { /* Postponed subexpression: /(??{...})/ */
4300                 logical = 0;
4301                 {
4302                     /* extract RE object from returned value; compiling if
4303                      * necessary */
4304                     MAGIC *mg = NULL;
4305                     REGEXP *rx = NULL;
4306
4307                     if (SvROK(ret)) {
4308                         SV *const sv = SvRV(ret);
4309
4310                         if (SvTYPE(sv) == SVt_REGEXP) {
4311                             rx = (REGEXP*) sv;
4312                         } else if (SvSMAGICAL(sv)) {
4313                             mg = mg_find(sv, PERL_MAGIC_qr);
4314                             assert(mg);
4315                         }
4316                     } else if (SvTYPE(ret) == SVt_REGEXP) {
4317                         rx = (REGEXP*) ret;
4318                     } else if (SvSMAGICAL(ret)) {
4319                         if (SvGMAGICAL(ret)) {
4320                             /* I don't believe that there is ever qr magic
4321                                here.  */
4322                             assert(!mg_find(ret, PERL_MAGIC_qr));
4323                             sv_unmagic(ret, PERL_MAGIC_qr);
4324                         }
4325                         else {
4326                             mg = mg_find(ret, PERL_MAGIC_qr);
4327                             /* testing suggests mg only ends up non-NULL for
4328                                scalars who were upgraded and compiled in the
4329                                else block below. In turn, this is only
4330                                triggered in the "postponed utf8 string" tests
4331                                in t/op/pat.t  */
4332                         }
4333                     }
4334
4335                     if (mg) {
4336                         rx = (REGEXP *) mg->mg_obj; /*XXX:dmq*/
4337                         assert(rx);
4338                     }
4339                     if (rx) {
4340                         rx = reg_temp_copy(NULL, rx);
4341                     }
4342                     else {
4343                         U32 pm_flags = 0;
4344                         const I32 osize = PL_regsize;
4345
4346                         if (DO_UTF8(ret)) {
4347                             assert (SvUTF8(ret));
4348                         } else if (SvUTF8(ret)) {
4349                             /* Not doing UTF-8, despite what the SV says. Is
4350                                this only if we're trapped in use 'bytes'?  */
4351                             /* Make a copy of the octet sequence, but without
4352                                the flag on, as the compiler now honours the
4353                                SvUTF8 flag on ret.  */
4354                             STRLEN len;
4355                             const char *const p = SvPV(ret, len);
4356                             ret = newSVpvn_flags(p, len, SVs_TEMP);
4357                         }
4358                         rx = CALLREGCOMP(ret, pm_flags);
4359                         if (!(SvFLAGS(ret)
4360                               & (SVs_TEMP | SVs_PADTMP | SVf_READONLY
4361                                  | SVs_GMG))) {
4362                             /* This isn't a first class regexp. Instead, it's
4363                                caching a regexp onto an existing, Perl visible
4364                                scalar.  */
4365                             sv_magic(ret, MUTABLE_SV(rx), PERL_MAGIC_qr, 0, 0);
4366                         }
4367                         PL_regsize = osize;
4368                     }
4369                     re_sv = rx;
4370                     re = (struct regexp *)SvANY(rx);
4371                 }
4372                 RXp_MATCH_COPIED_off(re);
4373                 re->subbeg = rex->subbeg;
4374                 re->sublen = rex->sublen;
4375                 rei = RXi_GET(re);
4376                 DEBUG_EXECUTE_r(
4377                     debug_start_match(re_sv, utf8_target, locinput, PL_regeol,
4378                         "Matching embedded");
4379                 );
4380                 startpoint = rei->program + 1;
4381                 ST.close_paren = 0; /* only used for GOSUB */
4382                 /* borrowed from regtry */
4383                 if (PL_reg_start_tmpl <= re->nparens) {
4384                     PL_reg_start_tmpl = re->nparens*3/2 + 3;
4385                     if(PL_reg_start_tmp)
4386                         Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
4387                     else
4388                         Newx(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
4389                 }
4390
4391         eval_recurse_doit: /* Share code with GOSUB below this line */
4392                 /* run the pattern returned from (??{...}) */
4393                 ST.cp = regcppush(0);   /* Save *all* the positions. */
4394                 REGCP_SET(ST.lastcp);
4395
4396                 PL_regoffs = re->offs; /* essentially NOOP on GOSUB */
4397
4398                 /* see regtry, specifically PL_reglast(?:close)?paren is a pointer! (i dont know why) :dmq */
4399                 PL_reglastparen = &re->lastparen;
4400                 PL_reglastcloseparen = &re->lastcloseparen;
4401                 re->lastparen = 0;
4402                 re->lastcloseparen = 0;
4403
4404                 PL_reginput = locinput;
4405                 PL_regsize = 0;
4406
4407                 /* XXXX This is too dramatic a measure... */
4408                 PL_reg_maxiter = 0;
4409
4410                 ST.toggle_reg_flags = PL_reg_flags;
4411                 if (RX_UTF8(re_sv))
4412                     PL_reg_flags |= RF_utf8;
4413                 else
4414                     PL_reg_flags &= ~RF_utf8;
4415                 ST.toggle_reg_flags ^= PL_reg_flags; /* diff of old and new */
4416
4417                 ST.prev_rex = rex_sv;
4418                 ST.prev_curlyx = cur_curlyx;
4419                 SETREX(rex_sv,re_sv);
4420                 rex = re;
4421                 rexi = rei;
4422                 cur_curlyx = NULL;
4423                 ST.B = next;
4424                 ST.prev_eval = cur_eval;
4425                 cur_eval = st;
4426                 /* now continue from first node in postoned RE */
4427                 PUSH_YES_STATE_GOTO(EVAL_AB, startpoint);
4428                 /* NOTREACHED */
4429             }
4430             /* logical is 1,   /(?(?{...})X|Y)/ */
4431             sw = cBOOL(SvTRUE(ret));
4432             logical = 0;
4433             break;
4434         }
4435
4436         case EVAL_AB: /* cleanup after a successful (??{A})B */
4437             /* note: this is called twice; first after popping B, then A */
4438             PL_reg_flags ^= ST.toggle_reg_flags;
4439             ReREFCNT_dec(rex_sv);
4440             SETREX(rex_sv,ST.prev_rex);
4441             rex = (struct regexp *)SvANY(rex_sv);
4442             rexi = RXi_GET(rex);
4443             regcpblow(ST.cp);
4444             cur_eval = ST.prev_eval;
4445             cur_curlyx = ST.prev_curlyx;
4446
4447             /* rex was changed so update the pointer in PL_reglastparen and PL_reglastcloseparen */
4448             PL_reglastparen = &rex->lastparen;
4449             PL_reglastcloseparen = &rex->lastcloseparen;
4450             /* also update PL_regoffs */
4451             PL_regoffs = rex->offs;
4452
4453             /* XXXX This is too dramatic a measure... */
4454             PL_reg_maxiter = 0;
4455             if ( nochange_depth )
4456                 nochange_depth--;
4457             sayYES;
4458
4459
4460         case EVAL_AB_fail: /* unsuccessfully ran A or B in (??{A})B */
4461             /* note: this is called twice; first after popping B, then A */
4462             PL_reg_flags ^= ST.toggle_reg_flags;
4463             ReREFCNT_dec(rex_sv);
4464             SETREX(rex_sv,ST.prev_rex);
4465             rex = (struct regexp *)SvANY(rex_sv);
4466             rexi = RXi_GET(rex);
4467             /* rex was changed so update the pointer in PL_reglastparen and PL_reglastcloseparen */
4468             PL_reglastparen = &rex->lastparen;
4469             PL_reglastcloseparen = &rex->lastcloseparen;
4470
4471             PL_reginput = locinput;
4472             REGCP_UNWIND(ST.lastcp);
4473             regcppop(rex);
4474             cur_eval = ST.prev_eval;
4475             cur_curlyx = ST.prev_curlyx;
4476             /* XXXX This is too dramatic a measure... */
4477             PL_reg_maxiter = 0;
4478             if ( nochange_depth )
4479                 nochange_depth--;
4480             sayNO_SILENT;
4481 #undef ST
4482
4483         case OPEN:
4484             n = ARG(scan);  /* which paren pair */
4485             PL_reg_start_tmp[n] = locinput;
4486             if (n > PL_regsize)
4487                 PL_regsize = n;
4488             lastopen = n;
4489             break;
4490         case CLOSE:
4491             n = ARG(scan);  /* which paren pair */
4492             PL_regoffs[n].start = PL_reg_start_tmp[n] - PL_bostr;
4493             PL_regoffs[n].end = locinput - PL_bostr;
4494             /*if (n > PL_regsize)
4495                 PL_regsize = n;*/
4496             if (n > *PL_reglastparen)
4497                 *PL_reglastparen = n;
4498             *PL_reglastcloseparen = n;
4499             if (cur_eval && cur_eval->u.eval.close_paren == n) {
4500                 goto fake_end;
4501             }
4502             break;
4503         case ACCEPT:
4504             if (ARG(scan)){
4505                 regnode *cursor;
4506                 for (cursor=scan;
4507                      cursor && OP(cursor)!=END;
4508                      cursor=regnext(cursor))
4509                 {
4510                     if ( OP(cursor)==CLOSE ){
4511                         n = ARG(cursor);
4512                         if ( n <= lastopen ) {
4513                             PL_regoffs[n].start
4514                                 = PL_reg_start_tmp[n] - PL_bostr;
4515                             PL_regoffs[n].end = locinput - PL_bostr;
4516                             /*if (n > PL_regsize)
4517                             PL_regsize = n;*/
4518                             if (n > *PL_reglastparen)
4519                                 *PL_reglastparen = n;
4520                             *PL_reglastcloseparen = n;
4521                             if ( n == ARG(scan) || (cur_eval &&
4522                                 cur_eval->u.eval.close_paren == n))
4523                                 break;
4524                         }
4525                     }
4526                 }
4527             }
4528             goto fake_end;
4529             /*NOTREACHED*/
4530         case GROUPP:
4531             n = ARG(scan);  /* which paren pair */
4532             sw = cBOOL(*PL_reglastparen >= n && PL_regoffs[n].end != -1);
4533             break;
4534         case NGROUPP:
4535             /* reg_check_named_buff_matched returns 0 for no match */
4536             sw = cBOOL(0 < reg_check_named_buff_matched(rex,scan));
4537             break;
4538         case INSUBP:
4539             n = ARG(scan);
4540             sw = (cur_eval && (!n || cur_eval->u.eval.close_paren == n));
4541             break;
4542         case DEFINEP:
4543             sw = 0;
4544             break;
4545         case IFTHEN:
4546             PL_reg_leftiter = PL_reg_maxiter;           /* Void cache */
4547             if (sw)
4548                 next = NEXTOPER(NEXTOPER(scan));
4549             else {
4550                 next = scan + ARG(scan);
4551                 if (OP(next) == IFTHEN) /* Fake one. */
4552                     next = NEXTOPER(NEXTOPER(next));
4553             }
4554             break;
4555         case LOGICAL:
4556             logical = scan->flags;
4557             break;
4558
4559 /*******************************************************************
4560
4561 The CURLYX/WHILEM pair of ops handle the most generic case of the /A*B/
4562 pattern, where A and B are subpatterns. (For simple A, CURLYM or
4563 STAR/PLUS/CURLY/CURLYN are used instead.)
4564
4565 A*B is compiled as <CURLYX><A><WHILEM><B>
4566
4567 On entry to the subpattern, CURLYX is called. This pushes a CURLYX
4568 state, which contains the current count, initialised to -1. It also sets
4569 cur_curlyx to point to this state, with any previous value saved in the
4570 state block.
4571
4572 CURLYX then jumps straight to the WHILEM op, rather than executing A,
4573 since the pattern may possibly match zero times (i.e. it's a while {} loop
4574 rather than a do {} while loop).
4575
4576 Each entry to WHILEM represents a successful match of A. The count in the
4577 CURLYX block is incremented, another WHILEM state is pushed, and execution
4578 passes to A or B depending on greediness and the current count.
4579
4580 For example, if matching against the string a1a2a3b (where the aN are
4581 substrings that match /A/), then the match progresses as follows: (the
4582 pushed states are interspersed with the bits of strings matched so far):
4583
4584     <CURLYX cnt=-1>
4585     <CURLYX cnt=0><WHILEM>
4586     <CURLYX cnt=1><WHILEM> a1 <WHILEM>
4587     <CURLYX cnt=2><WHILEM> a1 <WHILEM> a2 <WHILEM>
4588     <CURLYX cnt=3><WHILEM> a1 <WHILEM> a2 <WHILEM> a3 <WHILEM>
4589     <CURLYX cnt=3><WHILEM> a1 <WHILEM> a2 <WHILEM> a3 <WHILEM> b
4590
4591 (Contrast this with something like CURLYM, which maintains only a single
4592 backtrack state:
4593
4594     <CURLYM cnt=0> a1
4595     a1 <CURLYM cnt=1> a2
4596     a1 a2 <CURLYM cnt=2> a3
4597     a1 a2 a3 <CURLYM cnt=3> b
4598 )
4599
4600 Each WHILEM state block marks a point to backtrack to upon partial failure
4601 of A or B, and also contains some minor state data related to that
4602 iteration.  The CURLYX block, pointed to by cur_curlyx, contains the
4603 overall state, such as the count, and pointers to the A and B ops.
4604
4605 This is complicated slightly by nested CURLYX/WHILEM's. Since cur_curlyx
4606 must always point to the *current* CURLYX block, the rules are:
4607
4608 When executing CURLYX, save the old cur_curlyx in the CURLYX state block,
4609 and set cur_curlyx to point the new block.
4610
4611 When popping the CURLYX block after a successful or unsuccessful match,
4612 restore the previous cur_curlyx.
4613
4614 When WHILEM is about to execute B, save the current cur_curlyx, and set it
4615 to the outer one saved in the CURLYX block.
4616
4617 When popping the WHILEM block after a successful or unsuccessful B match,
4618 restore the previous cur_curlyx.
4619
4620 Here's an example for the pattern (AI* BI)*BO
4621 I and O refer to inner and outer, C and W refer to CURLYX and WHILEM:
4622
4623 cur_
4624 curlyx backtrack stack
4625 ------ ---------------
4626 NULL
4627 CO     <CO prev=NULL> <WO>
4628 CI     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai
4629 CO     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi
4630 NULL   <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi <WO prev=CO> bo
4631
4632 At this point the pattern succeeds, and we work back down the stack to
4633 clean up, restoring as we go:
4634
4635 CO     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi
4636 CI     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai
4637 CO     <CO prev=NULL> <WO>
4638 NULL
4639
4640 *******************************************************************/
4641
4642 #define ST st->u.curlyx
4643
4644         case CURLYX:    /* start of /A*B/  (for complex A) */
4645         {
4646             /* No need to save/restore up to this paren */
4647             I32 parenfloor = scan->flags;
4648
4649             assert(next); /* keep Coverity happy */
4650             if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
4651                 next += ARG(next);
4652
4653             /* XXXX Probably it is better to teach regpush to support
4654                parenfloor > PL_regsize... */
4655             if (parenfloor > (I32)*PL_reglastparen)
4656                 parenfloor = *PL_reglastparen; /* Pessimization... */
4657
4658             ST.prev_curlyx= cur_curlyx;
4659             cur_curlyx = st;
4660             ST.cp = PL_savestack_ix;
4661
4662             /* these fields contain the state of the current curly.
4663              * they are accessed by subsequent WHILEMs */
4664             ST.parenfloor = parenfloor;
4665             ST.me = scan;
4666             ST.B = next;
4667             ST.minmod = minmod;
4668             minmod = 0;
4669             ST.count = -1;      /* this will be updated by WHILEM */
4670             ST.lastloc = NULL;  /* this will be updated by WHILEM */
4671
4672             PL_reginput = locinput;
4673             PUSH_YES_STATE_GOTO(CURLYX_end, PREVOPER(next));
4674             /* NOTREACHED */
4675         }
4676
4677         case CURLYX_end: /* just finished matching all of A*B */
4678             cur_curlyx = ST.prev_curlyx;
4679             sayYES;
4680             /* NOTREACHED */
4681
4682         case CURLYX_end_fail: /* just failed to match all of A*B */
4683             regcpblow(ST.cp);
4684             cur_curlyx = ST.prev_curlyx;
4685             sayNO;
4686             /* NOTREACHED */
4687
4688
4689 #undef ST
4690 #define ST st->u.whilem
4691
4692         case WHILEM:     /* just matched an A in /A*B/  (for complex A) */
4693         {
4694             /* see the discussion above about CURLYX/WHILEM */
4695             I32 n;
4696             int min = ARG1(cur_curlyx->u.curlyx.me);
4697             int max = ARG2(cur_curlyx->u.curlyx.me);
4698             regnode *A = NEXTOPER(cur_curlyx->u.curlyx.me) + EXTRA_STEP_2ARGS;
4699
4700             assert(cur_curlyx); /* keep Coverity happy */
4701             n = ++cur_curlyx->u.curlyx.count; /* how many A's matched */
4702             ST.save_lastloc = cur_curlyx->u.curlyx.lastloc;
4703             ST.cache_offset = 0;
4704             ST.cache_mask = 0;
4705
4706             PL_reginput = locinput;
4707
4708             DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4709                   "%*s  whilem: matched %ld out of %d..%d\n",
4710                   REPORT_CODE_OFF+depth*2, "", (long)n, min, max)
4711             );
4712
4713             /* First just match a string of min A's. */
4714
4715             if (n < min) {
4716                 ST.cp = regcppush(cur_curlyx->u.curlyx.parenfloor);
4717                 cur_curlyx->u.curlyx.lastloc = locinput;
4718                 REGCP_SET(ST.lastcp);
4719
4720                 PUSH_STATE_GOTO(WHILEM_A_pre, A);
4721                 /* NOTREACHED */
4722             }
4723
4724             /* If degenerate A matches "", assume A done. */
4725
4726             if (locinput == cur_curlyx->u.curlyx.lastloc) {
4727                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4728                    "%*s  whilem: empty match detected, trying continuation...\n",
4729                    REPORT_CODE_OFF+depth*2, "")
4730                 );
4731                 goto do_whilem_B_max;
4732             }
4733
4734             /* super-linear cache processing */
4735
4736             if (scan->flags) {
4737
4738                 if (!PL_reg_maxiter) {
4739                     /* start the countdown: Postpone detection until we
4740                      * know the match is not *that* much linear. */
4741                     PL_reg_maxiter = (PL_regeol - PL_bostr + 1) * (scan->flags>>4);
4742                     /* possible overflow for long strings and many CURLYX's */
4743                     if (PL_reg_maxiter < 0)
4744                         PL_reg_maxiter = I32_MAX;
4745                     PL_reg_leftiter = PL_reg_maxiter;
4746                 }
4747
4748                 if (PL_reg_leftiter-- == 0) {
4749                     /* initialise cache */
4750                     const I32 size = (PL_reg_maxiter + 7)/8;
4751                     if (PL_reg_poscache) {
4752                         if ((I32)PL_reg_poscache_size < size) {
4753                             Renew(PL_reg_poscache, size, char);
4754                             PL_reg_poscache_size = size;
4755                         }
4756                         Zero(PL_reg_poscache, size, char);
4757                     }
4758                     else {
4759                         PL_reg_poscache_size = size;
4760                         Newxz(PL_reg_poscache, size, char);
4761                     }
4762                     DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4763       "%swhilem: Detected a super-linear match, switching on caching%s...\n",
4764                               PL_colors[4], PL_colors[5])
4765                     );
4766                 }
4767
4768                 if (PL_reg_leftiter < 0) {
4769                     /* have we already failed at this position? */
4770                     I32 offset, mask;
4771                     offset  = (scan->flags & 0xf) - 1
4772                                 + (locinput - PL_bostr)  * (scan->flags>>4);
4773                     mask    = 1 << (offset % 8);
4774                     offset /= 8;
4775                     if (PL_reg_poscache[offset] & mask) {
4776                         DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
4777                             "%*s  whilem: (cache) already tried at this position...\n",
4778                             REPORT_CODE_OFF+depth*2, "")
4779                         );
4780                         sayNO; /* cache records failure */
4781                     }
4782                     ST.cache_offset = offset;
4783                     ST.cache_mask   = mask;
4784                 }
4785             }
4786
4787             /* Prefer B over A for minimal matching. */
4788
4789             if (cur_curlyx->u.curlyx.minmod) {
4790                 ST.save_curlyx = cur_curlyx;
4791                 cur_curlyx = cur_curlyx->u.curlyx.prev_curlyx;
4792                 ST.cp = regcppush(ST.save_curlyx->u.curlyx.parenfloor);
4793                 REGCP_SET(ST.lastcp);
4794                 PUSH_YES_STATE_GOTO(WHILEM_B_min, ST.save_curlyx->u.curlyx.B);
4795                 /* NOTREACHED */
4796             }
4797
4798             /* Prefer A over B for maximal matching. */
4799
4800             if (n < max) { /* More greed allowed? */
4801                 ST.cp = regcppush(cur_curlyx->u.curlyx.parenfloor);
4802                 cur_curlyx->u.curlyx.lastloc = locinput;
4803                 REGCP_SET(ST.lastcp);
4804                 PUSH_STATE_GOTO(WHILEM_A_max, A);
4805                 /* NOTREACHED */
4806             }
4807             goto do_whilem_B_max;
4808         }
4809         /* NOTREACHED */
4810
4811         case WHILEM_B_min: /* just matched B in a minimal match */
4812         case WHILEM_B_max: /* just matched B in a maximal match */
4813             cur_curlyx = ST.save_curlyx;
4814             sayYES;
4815             /* NOTREACHED */
4816
4817         case WHILEM_B_max_fail: /* just failed to match B in a maximal match */
4818             cur_curlyx = ST.save_curlyx;
4819             cur_curlyx->u.curlyx.lastloc = ST.save_lastloc;
4820             cur_curlyx->u.curlyx.count--;
4821             CACHEsayNO;
4822             /* NOTREACHED */
4823
4824         case WHILEM_A_min_fail: /* just failed to match A in a minimal match */
4825             /* FALL THROUGH */
4826         case WHILEM_A_pre_fail: /* just failed to match even minimal A */
4827             REGCP_UNWIND(ST.lastcp);
4828             regcppop(rex);
4829             cur_curlyx->u.curlyx.lastloc = ST.save_lastloc;
4830             cur_curlyx->u.curlyx.count--;
4831             CACHEsayNO;
4832             /* NOTREACHED */
4833
4834         case WHILEM_A_max_fail: /* just failed to match A in a maximal match */
4835             REGCP_UNWIND(ST.lastcp);
4836             regcppop(rex);      /* Restore some previous $<digit>s? */
4837             PL_reginput = locinput;
4838             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
4839                 "%*s  whilem: failed, trying continuation...\n",
4840                 REPORT_CODE_OFF+depth*2, "")
4841             );
4842           do_whilem_B_max:
4843             if (cur_curlyx->u.curlyx.count >= REG_INFTY
4844                 && ckWARN(WARN_REGEXP)
4845                 && !(PL_reg_flags & RF_warned))
4846             {
4847                 PL_reg_flags |= RF_warned;
4848                 Perl_warner(aTHX_ packWARN(WARN_REGEXP), "%s limit (%d) exceeded",
4849                      "Complex regular subexpression recursion",
4850                      REG_INFTY - 1);
4851             }
4852
4853             /* now try B */
4854             ST.save_curlyx = cur_curlyx;
4855             cur_curlyx = cur_curlyx->u.curlyx.prev_curlyx;
4856             PUSH_YES_STATE_GOTO(WHILEM_B_max, ST.save_curlyx->u.curlyx.B);
4857             /* NOTREACHED */
4858
4859         case WHILEM_B_min_fail: /* just failed to match B in a minimal match */
4860             cur_curlyx = ST.save_curlyx;
4861             REGCP_UNWIND(ST.lastcp);
4862             regcppop(rex);
4863
4864             if (cur_curlyx->u.curlyx.count >= /*max*/ARG2(cur_curlyx->u.curlyx.me)) {
4865                 /* Maximum greed exceeded */
4866                 if (cur_curlyx->u.curlyx.count >= REG_INFTY
4867                     && ckWARN(WARN_REGEXP)
4868                     && !(PL_reg_flags & RF_warned))
4869                 {
4870                     PL_reg_flags |= RF_warned;
4871                     Perl_warner(aTHX_ packWARN(WARN_REGEXP),
4872                         "%s limit (%d) exceeded",
4873                         "Complex regular subexpression recursion",
4874                         REG_INFTY - 1);
4875                 }
4876                 cur_curlyx->u.curlyx.count--;
4877                 CACHEsayNO;
4878             }
4879
4880             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
4881                 "%*s  trying longer...\n", REPORT_CODE_OFF+depth*2, "")
4882             );
4883             /* Try grabbing another A and see if it helps. */
4884             PL_reginput = locinput;
4885             cur_curlyx->u.curlyx.lastloc = locinput;
4886             ST.cp = regcppush(cur_curlyx->u.curlyx.parenfloor);
4887             REGCP_SET(ST.lastcp);
4888             PUSH_STATE_GOTO(WHILEM_A_min,
4889                 /*A*/ NEXTOPER(ST.save_curlyx->u.curlyx.me) + EXTRA_STEP_2ARGS);
4890             /* NOTREACHED */
4891
4892 #undef  ST
4893 #define ST st->u.branch
4894
4895         case BRANCHJ:       /*  /(...|A|...)/ with long next pointer */
4896             next = scan + ARG(scan);
4897             if (next == scan)
4898                 next = NULL;
4899             scan = NEXTOPER(scan);
4900             /* FALL THROUGH */
4901
4902         case BRANCH:        /*  /(...|A|...)/ */
4903             scan = NEXTOPER(scan); /* scan now points to inner node */
4904             ST.lastparen = *PL_reglastparen;
4905             ST.next_branch = next;
4906             REGCP_SET(ST.cp);
4907             PL_reginput = locinput;
4908
4909             /* Now go into the branch */
4910             if (has_cutgroup) {
4911                 PUSH_YES_STATE_GOTO(BRANCH_next, scan);
4912             } else {
4913                 PUSH_STATE_GOTO(BRANCH_next, scan);
4914             }
4915             /* NOTREACHED */
4916         case CUTGROUP:
4917             PL_reginput = locinput;
4918             sv_yes_mark = st->u.mark.mark_name = scan->flags ? NULL :
4919                 MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
4920             PUSH_STATE_GOTO(CUTGROUP_next,next);
4921             /* NOTREACHED */
4922         case CUTGROUP_next_fail:
4923             do_cutgroup = 1;
4924             no_final = 1;
4925             if (st->u.mark.mark_name)
4926                 sv_commit = st->u.mark.mark_name;
4927             sayNO;
4928             /* NOTREACHED */
4929         case BRANCH_next:
4930             sayYES;
4931             /* NOTREACHED */
4932         case BRANCH_next_fail: /* that branch failed; try the next, if any */
4933             if (do_cutgroup) {
4934                 do_cutgroup = 0;
4935                 no_final = 0;
4936             }
4937             REGCP_UNWIND(ST.cp);
4938             for (n = *PL_reglastparen; n > ST.lastparen; n--)
4939                 PL_regoffs[n].end = -1;
4940             *PL_reglastparen = n;
4941             /*dmq: *PL_reglastcloseparen = n; */
4942             scan = ST.next_branch;
4943             /* no more branches? */
4944             if (!scan || (OP(scan) != BRANCH && OP(scan) != BRANCHJ)) {
4945                 DEBUG_EXECUTE_r({
4946                     PerlIO_printf( Perl_debug_log,
4947                         "%*s  %sBRANCH failed...%s\n",
4948                         REPORT_CODE_OFF+depth*2, "",
4949                         PL_colors[4],
4950                         PL_colors[5] );
4951                 });
4952                 sayNO_SILENT;
4953             }
4954             continue; /* execute next BRANCH[J] op */
4955             /* NOTREACHED */
4956
4957         case MINMOD:
4958             minmod = 1;
4959             break;
4960
4961 #undef  ST
4962 #define ST st->u.curlym
4963
4964         case CURLYM:    /* /A{m,n}B/ where A is fixed-length */
4965
4966             /* This is an optimisation of CURLYX that enables us to push
4967              * only a single backtracking state, no matter how many matches
4968              * there are in {m,n}. It relies on the pattern being constant
4969              * length, with no parens to influence future backrefs
4970              */
4971
4972             ST.me = scan;
4973             scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
4974
4975             /* if paren positive, emulate an OPEN/CLOSE around A */
4976             if (ST.me->flags) {
4977                 U32 paren = ST.me->flags;
4978                 if (paren > PL_regsize)
4979                     PL_regsize = paren;
4980                 if (paren > *PL_reglastparen)
4981                     *PL_reglastparen = paren;
4982                 scan += NEXT_OFF(scan); /* Skip former OPEN. */
4983             }
4984             ST.A = scan;
4985             ST.B = next;
4986             ST.alen = 0;
4987             ST.count = 0;
4988             ST.minmod = minmod;
4989             minmod = 0;
4990             ST.c1 = CHRTEST_UNINIT;
4991             REGCP_SET(ST.cp);
4992
4993             if (!(ST.minmod ? ARG1(ST.me) : ARG2(ST.me))) /* min/max */
4994                 goto curlym_do_B;
4995
4996           curlym_do_A: /* execute the A in /A{m,n}B/  */
4997             PL_reginput = locinput;
4998             PUSH_YES_STATE_GOTO(CURLYM_A, ST.A); /* match A */
4999             /* NOTREACHED */
5000
5001         case CURLYM_A: /* we've just matched an A */
5002             locinput = st->locinput;
5003             nextchr = UCHARAT(locinput);
5004
5005             ST.count++;
5006             /* after first match, determine A's length: u.curlym.alen */
5007             if (ST.count == 1) {
5008                 if (PL_reg_match_utf8) {
5009                     char *s = locinput;
5010                     while (s < PL_reginput) {
5011                         ST.alen++;
5012                         s += UTF8SKIP(s);
5013                     }
5014                 }
5015                 else {
5016                     ST.alen = PL_reginput - locinput;
5017                 }
5018                 if (ST.alen == 0)
5019                     ST.count = ST.minmod ? ARG1(ST.me) : ARG2(ST.me);
5020             }
5021             DEBUG_EXECUTE_r(
5022                 PerlIO_printf(Perl_debug_log,
5023                           "%*s  CURLYM now matched %"IVdf" times, len=%"IVdf"...\n",
5024                           (int)(REPORT_CODE_OFF+(depth*2)), "",
5025                           (IV) ST.count, (IV)ST.alen)
5026             );
5027
5028             locinput = PL_reginput;
5029
5030             if (cur_eval && cur_eval->u.eval.close_paren &&
5031                 cur_eval->u.eval.close_paren == (U32)ST.me->flags)
5032                 goto fake_end;
5033
5034             {
5035                 I32 max = (ST.minmod ? ARG1(ST.me) : ARG2(ST.me));
5036                 if ( max == REG_INFTY || ST.count < max )
5037                     goto curlym_do_A; /* try to match another A */
5038             }
5039             goto curlym_do_B; /* try to match B */
5040
5041         case CURLYM_A_fail: /* just failed to match an A */
5042             REGCP_UNWIND(ST.cp);
5043
5044             if (ST.minmod || ST.count < ARG1(ST.me) /* min*/
5045                 || (cur_eval && cur_eval->u.eval.close_paren &&
5046                     cur_eval->u.eval.close_paren == (U32)ST.me->flags))
5047                 sayNO;
5048
5049           curlym_do_B: /* execute the B in /A{m,n}B/  */
5050             PL_reginput = locinput;
5051             if (ST.c1 == CHRTEST_UNINIT) {
5052                 /* calculate c1 and c2 for possible match of 1st char
5053                  * following curly */
5054                 ST.c1 = ST.c2 = CHRTEST_VOID;
5055                 if (HAS_TEXT(ST.B) || JUMPABLE(ST.B)) {
5056                     regnode *text_node = ST.B;
5057                     if (! HAS_TEXT(text_node))
5058                         FIND_NEXT_IMPT(text_node);
5059                     /* this used to be
5060
5061                         (HAS_TEXT(text_node) && PL_regkind[OP(text_node)] == EXACT)
5062
5063                         But the former is redundant in light of the latter.
5064
5065                         if this changes back then the macro for
5066                         IS_TEXT and friends need to change.
5067                      */
5068                     if (PL_regkind[OP(text_node)] == EXACT)
5069                     {
5070
5071                         ST.c1 = (U8)*STRING(text_node);
5072                         switch (OP(text_node)) {
5073                             case EXACTF: ST.c2 = PL_fold[ST.c1]; break;
5074                             case EXACTFA:
5075                             case EXACTFU: ST.c2 = PL_fold_latin1[ST.c1]; break;
5076                             case EXACTFL: ST.c2 = PL_fold_locale[ST.c1]; break;
5077                             default: ST.c2 = ST.c1;
5078                         }
5079                     }
5080                 }
5081             }
5082
5083             DEBUG_EXECUTE_r(
5084                 PerlIO_printf(Perl_debug_log,
5085                     "%*s  CURLYM trying tail with matches=%"IVdf"...\n",
5086                     (int)(REPORT_CODE_OFF+(depth*2)),
5087                     "", (IV)ST.count)
5088                 );
5089             if (ST.c1 != CHRTEST_VOID
5090                     && UCHARAT(PL_reginput) != ST.c1
5091                     && UCHARAT(PL_reginput) != ST.c2)
5092             {
5093                 /* simulate B failing */
5094                 DEBUG_OPTIMISE_r(
5095                     PerlIO_printf(Perl_debug_log,
5096                         "%*s  CURLYM Fast bail c1=%"IVdf" c2=%"IVdf"\n",
5097                         (int)(REPORT_CODE_OFF+(depth*2)),"",
5098                         (IV)ST.c1,(IV)ST.c2
5099                 ));
5100                 state_num = CURLYM_B_fail;
5101                 goto reenter_switch;
5102             }
5103
5104             if (ST.me->flags) {
5105                 /* mark current A as captured */
5106                 I32 paren = ST.me->flags;
5107                 if (ST.count) {
5108                     PL_regoffs[paren].start
5109                         = HOPc(PL_reginput, -ST.alen) - PL_bostr;
5110                     PL_regoffs[paren].end = PL_reginput - PL_bostr;
5111                     /*dmq: *PL_reglastcloseparen = paren; */
5112                 }
5113                 else
5114                     PL_regoffs[paren].end = -1;
5115                 if (cur_eval && cur_eval->u.eval.close_paren &&
5116                     cur_eval->u.eval.close_paren == (U32)ST.me->flags)
5117                 {
5118                     if (ST.count)
5119                         goto fake_end;
5120                     else
5121                         sayNO;
5122                 }
5123             }
5124
5125             PUSH_STATE_GOTO(CURLYM_B, ST.B); /* match B */
5126             /* NOTREACHED */
5127
5128         case CURLYM_B_fail: /* just failed to match a B */
5129             REGCP_UNWIND(ST.cp);
5130             if (ST.minmod) {
5131                 I32 max = ARG2(ST.me);
5132                 if (max != REG_INFTY && ST.count == max)
5133                     sayNO;
5134                 goto curlym_do_A; /* try to match a further A */
5135             }
5136             /* backtrack one A */
5137             if (ST.count == ARG1(ST.me) /* min */)
5138                 sayNO;
5139             ST.count--;
5140             locinput = HOPc(locinput, -ST.alen);
5141             goto curlym_do_B; /* try to match B */
5142
5143 #undef ST
5144 #define ST st->u.curly
5145
5146 #define CURLY_SETPAREN(paren, success) \
5147     if (paren) { \
5148         if (success) { \
5149             PL_regoffs[paren].start = HOPc(locinput, -1) - PL_bostr; \
5150             PL_regoffs[paren].end = locinput - PL_bostr; \
5151             *PL_reglastcloseparen = paren; \
5152         } \
5153         else \
5154             PL_regoffs[paren].end = -1; \
5155     }
5156
5157         case STAR:              /*  /A*B/ where A is width 1 */
5158             ST.paren = 0;
5159             ST.min = 0;
5160             ST.max = REG_INFTY;
5161             scan = NEXTOPER(scan);
5162             goto repeat;
5163         case PLUS:              /*  /A+B/ where A is width 1 */
5164             ST.paren = 0;
5165             ST.min = 1;
5166             ST.max = REG_INFTY;
5167             scan = NEXTOPER(scan);
5168             goto repeat;
5169         case CURLYN:            /*  /(A){m,n}B/ where A is width 1 */
5170             ST.paren = scan->flags;     /* Which paren to set */
5171             if (ST.paren > PL_regsize)
5172                 PL_regsize = ST.paren;
5173             if (ST.paren > *PL_reglastparen)
5174                 *PL_reglastparen = ST.paren;
5175             ST.min = ARG1(scan);  /* min to match */
5176             ST.max = ARG2(scan);  /* max to match */
5177             if (cur_eval && cur_eval->u.eval.close_paren &&
5178                 cur_eval->u.eval.close_paren == (U32)ST.paren) {
5179                 ST.min=1;
5180                 ST.max=1;
5181             }
5182             scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
5183             goto repeat;
5184         case CURLY:             /*  /A{m,n}B/ where A is width 1 */
5185             ST.paren = 0;
5186             ST.min = ARG1(scan);  /* min to match */
5187             ST.max = ARG2(scan);  /* max to match */
5188             scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
5189           repeat:
5190             /*
5191             * Lookahead to avoid useless match attempts
5192             * when we know what character comes next.
5193             *
5194             * Used to only do .*x and .*?x, but now it allows
5195             * for )'s, ('s and (?{ ... })'s to be in the way
5196             * of the quantifier and the EXACT-like node.  -- japhy
5197             */
5198
5199             if (ST.min > ST.max) /* XXX make this a compile-time check? */
5200                 sayNO;
5201             if (HAS_TEXT(next) || JUMPABLE(next)) {
5202                 U8 *s;
5203                 regnode *text_node = next;
5204
5205                 if (! HAS_TEXT(text_node))
5206                     FIND_NEXT_IMPT(text_node);
5207
5208                 if (! HAS_TEXT(text_node))
5209                     ST.c1 = ST.c2 = CHRTEST_VOID;
5210                 else {
5211                     if ( PL_regkind[OP(text_node)] != EXACT ) {
5212                         ST.c1 = ST.c2 = CHRTEST_VOID;
5213                         goto assume_ok_easy;
5214                     }
5215                     else
5216                         s = (U8*)STRING(text_node);
5217
5218                     /*  Currently we only get here when
5219
5220                         PL_rekind[OP(text_node)] == EXACT
5221
5222                         if this changes back then the macro for IS_TEXT and
5223                         friends need to change. */
5224                     if (!UTF_PATTERN) {
5225                         ST.c1 = *s;
5226                         switch (OP(text_node)) {
5227                             case EXACTF: ST.c2 = PL_fold[ST.c1]; break;
5228                             case EXACTFA:
5229                             case EXACTFU: ST.c2 = PL_fold_latin1[ST.c1]; break;
5230                             case EXACTFL: ST.c2 = PL_fold_locale[ST.c1]; break;
5231                             default: ST.c2 = ST.c1; break;
5232                         }
5233                     }
5234                     else { /* UTF_PATTERN */
5235                         if (IS_TEXTFU(text_node) || IS_TEXTF(text_node)) {
5236                              STRLEN ulen1, ulen2;
5237                              U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
5238                              U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
5239
5240                              to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
5241                              to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
5242 #ifdef EBCDIC
5243                              ST.c1 = utf8n_to_uvchr(tmpbuf1, UTF8_MAXLEN, 0,
5244                                                     ckWARN(WARN_UTF8) ?
5245                                                     0 : UTF8_ALLOW_ANY);
5246                              ST.c2 = utf8n_to_uvchr(tmpbuf2, UTF8_MAXLEN, 0,
5247                                                     ckWARN(WARN_UTF8) ?
5248                                                     0 : UTF8_ALLOW_ANY);
5249 #else
5250                              ST.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
5251                                                     uniflags);
5252                              ST.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
5253                                                     uniflags);
5254 #endif
5255                         }
5256                         else {
5257                             ST.c2 = ST.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
5258                                                      uniflags);
5259                         }
5260                     }
5261                 }
5262             }
5263             else
5264                 ST.c1 = ST.c2 = CHRTEST_VOID;
5265         assume_ok_easy:
5266
5267             ST.A = scan;
5268             ST.B = next;
5269             PL_reginput = locinput;
5270             if (minmod) {
5271                 minmod = 0;
5272                 if (ST.min && regrepeat(rex, ST.A, ST.min, depth) < ST.min)
5273                     sayNO;
5274                 ST.count = ST.min;
5275                 locinput = PL_reginput;
5276                 REGCP_SET(ST.cp);
5277                 if (ST.c1 == CHRTEST_VOID)
5278                     goto curly_try_B_min;
5279
5280                 ST.oldloc = locinput;
5281
5282                 /* set ST.maxpos to the furthest point along the
5283                  * string that could possibly match */
5284                 if  (ST.max == REG_INFTY) {
5285                     ST.maxpos = PL_regeol - 1;
5286                     if (utf8_target)
5287                         while (UTF8_IS_CONTINUATION(*(U8*)ST.maxpos))
5288                             ST.maxpos--;
5289                 }
5290                 else if (utf8_target) {
5291                     int m = ST.max - ST.min;
5292                     for (ST.maxpos = locinput;
5293                          m >0 && ST.maxpos + UTF8SKIP(ST.maxpos) <= PL_regeol; m--)
5294                         ST.maxpos += UTF8SKIP(ST.maxpos);
5295                 }
5296                 else {
5297                     ST.maxpos = locinput + ST.max - ST.min;
5298                     if (ST.maxpos >= PL_regeol)
5299                         ST.maxpos = PL_regeol - 1;
5300                 }
5301                 goto curly_try_B_min_known;
5302
5303             }
5304             else {
5305                 ST.count = regrepeat(rex, ST.A, ST.max, depth);
5306                 locinput = PL_reginput;
5307                 if (ST.count < ST.min)
5308                     sayNO;
5309                 if ((ST.count > ST.min)
5310                     && (PL_regkind[OP(ST.B)] == EOL) && (OP(ST.B) != MEOL))
5311                 {
5312                     /* A{m,n} must come at the end of the string, there's
5313                      * no point in backing off ... */
5314                     ST.min = ST.count;
5315                     /* ...except that $ and \Z can match before *and* after
5316                        newline at the end.  Consider "\n\n" =~ /\n+\Z\n/.
5317                        We may back off by one in this case. */
5318                     if (UCHARAT(PL_reginput - 1) == '\n' && OP(ST.B) != EOS)
5319                         ST.min--;
5320                 }
5321                 REGCP_SET(ST.cp);
5322                 goto curly_try_B_max;
5323             }
5324             /* NOTREACHED */
5325
5326
5327         case CURLY_B_min_known_fail:
5328             /* failed to find B in a non-greedy match where c1,c2 valid */
5329             if (ST.paren && ST.count)
5330                 PL_regoffs[ST.paren].end = -1;
5331
5332             PL_reginput = locinput;     /* Could be reset... */
5333             REGCP_UNWIND(ST.cp);
5334             /* Couldn't or didn't -- move forward. */
5335             ST.oldloc = locinput;
5336             if (utf8_target)
5337                 locinput += UTF8SKIP(locinput);
5338             else
5339                 locinput++;
5340             ST.count++;
5341           curly_try_B_min_known:
5342              /* find the next place where 'B' could work, then call B */
5343             {
5344                 int n;
5345                 if (utf8_target) {
5346                     n = (ST.oldloc == locinput) ? 0 : 1;
5347                     if (ST.c1 == ST.c2) {
5348                         STRLEN len;
5349                         /* set n to utf8_distance(oldloc, locinput) */
5350                         while (locinput <= ST.maxpos &&
5351                                utf8n_to_uvchr((U8*)locinput,
5352                                               UTF8_MAXBYTES, &len,
5353                                               uniflags) != (UV)ST.c1) {
5354                             locinput += len;
5355                             n++;
5356                         }
5357                     }
5358                     else {
5359                         /* set n to utf8_distance(oldloc, locinput) */
5360                         while (locinput <= ST.maxpos) {
5361                             STRLEN len;
5362                             const UV c = utf8n_to_uvchr((U8*)locinput,
5363                                                   UTF8_MAXBYTES, &len,
5364                                                   uniflags);
5365                             if (c == (UV)ST.c1 || c == (UV)ST.c2)
5366                                 break;
5367                             locinput += len;
5368                             n++;
5369                         }
5370                     }
5371                 }
5372                 else {
5373                     if (ST.c1 == ST.c2) {
5374                         while (locinput <= ST.maxpos &&
5375                                UCHARAT(locinput) != ST.c1)
5376                             locinput++;
5377                     }
5378                     else {
5379                         while (locinput <= ST.maxpos
5380                                && UCHARAT(locinput) != ST.c1
5381                                && UCHARAT(locinput) != ST.c2)
5382                             locinput++;
5383                     }
5384                     n = locinput - ST.oldloc;
5385                 }
5386                 if (locinput > ST.maxpos)
5387                     sayNO;
5388                 /* PL_reginput == oldloc now */
5389                 if (n) {
5390                     ST.count += n;
5391                     if (regrepeat(rex, ST.A, n, depth) < n)
5392                         sayNO;
5393                 }
5394                 PL_reginput = locinput;
5395                 CURLY_SETPAREN(ST.paren, ST.count);
5396                 if (cur_eval && cur_eval->u.eval.close_paren &&
5397                     cur_eval->u.eval.close_paren == (U32)ST.paren) {
5398                     goto fake_end;
5399                 }
5400                 PUSH_STATE_GOTO(CURLY_B_min_known, ST.B);
5401             }
5402             /* NOTREACHED */
5403
5404
5405         case CURLY_B_min_fail:
5406             /* failed to find B in a non-greedy match where c1,c2 invalid */
5407             if (ST.paren && ST.count)
5408                 PL_regoffs[ST.paren].end = -1;
5409
5410             REGCP_UNWIND(ST.cp);
5411             /* failed -- move forward one */
5412             PL_reginput = locinput;
5413             if (regrepeat(rex, ST.A, 1, depth)) {
5414                 ST.count++;
5415                 locinput = PL_reginput;
5416                 if (ST.count <= ST.max || (ST.max == REG_INFTY &&
5417                         ST.count > 0)) /* count overflow ? */
5418                 {
5419                   curly_try_B_min:
5420                     CURLY_SETPAREN(ST.paren, ST.count);
5421                     if (cur_eval && cur_eval->u.eval.close_paren &&
5422                         cur_eval->u.eval.close_paren == (U32)ST.paren) {
5423                         goto fake_end;
5424                     }
5425                     PUSH_STATE_GOTO(CURLY_B_min, ST.B);
5426                 }
5427             }
5428             sayNO;
5429             /* NOTREACHED */
5430
5431
5432         curly_try_B_max:
5433             /* a successful greedy match: now try to match B */
5434             if (cur_eval && cur_eval->u.eval.close_paren &&
5435                 cur_eval->u.eval.close_paren == (U32)ST.paren) {
5436                 goto fake_end;
5437             }
5438             {
5439                 UV c = 0;
5440                 if (ST.c1 != CHRTEST_VOID)
5441                     c = utf8_target ? utf8n_to_uvchr((U8*)PL_reginput,
5442                                            UTF8_MAXBYTES, 0, uniflags)
5443                                 : (UV) UCHARAT(PL_reginput);
5444                 /* If it could work, try it. */
5445                 if (ST.c1 == CHRTEST_VOID || c == (UV)ST.c1 || c == (UV)ST.c2) {
5446                     CURLY_SETPAREN(ST.paren, ST.count);
5447                     PUSH_STATE_GOTO(CURLY_B_max, ST.B);
5448                     /* NOTREACHED */
5449                 }
5450             }
5451             /* FALL THROUGH */
5452         case CURLY_B_max_fail:
5453             /* failed to find B in a greedy match */
5454             if (ST.paren && ST.count)
5455                 PL_regoffs[ST.paren].end = -1;
5456
5457             REGCP_UNWIND(ST.cp);
5458             /*  back up. */
5459             if (--ST.count < ST.min)
5460                 sayNO;
5461             PL_reginput = locinput = HOPc(locinput, -1);
5462             goto curly_try_B_max;
5463
5464 #undef ST
5465
5466         case END:
5467             fake_end:
5468             if (cur_eval) {
5469                 /* we've just finished A in /(??{A})B/; now continue with B */
5470                 I32 tmpix;
5471                 st->u.eval.toggle_reg_flags
5472                             = cur_eval->u.eval.toggle_reg_flags;
5473                 PL_reg_flags ^= st->u.eval.toggle_reg_flags;
5474
5475                 st->u.eval.prev_rex = rex_sv;           /* inner */
5476                 SETREX(rex_sv,cur_eval->u.eval.prev_rex);
5477                 rex = (struct regexp *)SvANY(rex_sv);
5478                 rexi = RXi_GET(rex);
5479                 cur_curlyx = cur_eval->u.eval.prev_curlyx;
5480                 (void)ReREFCNT_inc(rex_sv);
5481                 st->u.eval.cp = regcppush(0);   /* Save *all* the positions. */
5482
5483                 /* rex was changed so update the pointer in PL_reglastparen and PL_reglastcloseparen */
5484                 PL_reglastparen = &rex->lastparen;
5485                 PL_reglastcloseparen = &rex->lastcloseparen;
5486
5487                 REGCP_SET(st->u.eval.lastcp);
5488                 PL_reginput = locinput;
5489
5490                 /* Restore parens of the outer rex without popping the
5491                  * savestack */
5492                 tmpix = PL_savestack_ix;
5493                 PL_savestack_ix = cur_eval->u.eval.lastcp;
5494                 regcppop(rex);
5495                 PL_savestack_ix = tmpix;
5496
5497                 st->u.eval.prev_eval = cur_eval;
5498                 cur_eval = cur_eval->u.eval.prev_eval;
5499                 DEBUG_EXECUTE_r(
5500                     PerlIO_printf(Perl_debug_log, "%*s  EVAL trying tail ... %"UVxf"\n",
5501                                       REPORT_CODE_OFF+depth*2, "",PTR2UV(cur_eval)););
5502                 if ( nochange_depth )
5503                     nochange_depth--;
5504
5505                 PUSH_YES_STATE_GOTO(EVAL_AB,
5506                         st->u.eval.prev_eval->u.eval.B); /* match B */
5507             }
5508
5509             if (locinput < reginfo->till) {
5510                 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
5511                                       "%sMatch possible, but length=%ld is smaller than requested=%ld, failing!%s\n",
5512                                       PL_colors[4],
5513                                       (long)(locinput - PL_reg_starttry),
5514                                       (long)(reginfo->till - PL_reg_starttry),
5515                                       PL_colors[5]));
5516
5517                 sayNO_SILENT;           /* Cannot match: too short. */
5518             }
5519             PL_reginput = locinput;     /* put where regtry can find it */
5520             sayYES;                     /* Success! */
5521
5522         case SUCCEED: /* successful SUSPEND/UNLESSM/IFMATCH/CURLYM */
5523             DEBUG_EXECUTE_r(
5524             PerlIO_printf(Perl_debug_log,
5525                 "%*s  %ssubpattern success...%s\n",
5526                 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5]));
5527             PL_reginput = locinput;     /* put where regtry can find it */
5528             sayYES;                     /* Success! */
5529
5530 #undef  ST
5531 #define ST st->u.ifmatch
5532
5533         case SUSPEND:   /* (?>A) */
5534             ST.wanted = 1;
5535             PL_reginput = locinput;
5536             goto do_ifmatch;
5537
5538         case UNLESSM:   /* -ve lookaround: (?!A), or with flags, (?<!A) */
5539             ST.wanted = 0;
5540             goto ifmatch_trivial_fail_test;
5541
5542         case IFMATCH:   /* +ve lookaround: (?=A), or with flags, (?<=A) */
5543             ST.wanted = 1;
5544           ifmatch_trivial_fail_test:
5545             if (scan->flags) {
5546                 char * const s = HOPBACKc(locinput, scan->flags);
5547                 if (!s) {
5548                     /* trivial fail */
5549                     if (logical) {
5550                         logical = 0;
5551                         sw = 1 - cBOOL(ST.wanted);
5552                     }
5553                     else if (ST.wanted)
5554                         sayNO;
5555                     next = scan + ARG(scan);
5556                     if (next == scan)
5557                         next = NULL;
5558                     break;
5559                 }
5560                 PL_reginput = s;
5561             }
5562             else
5563                 PL_reginput = locinput;
5564
5565           do_ifmatch:
5566             ST.me = scan;
5567             ST.logical = logical;
5568             logical = 0; /* XXX: reset state of logical once it has been saved into ST */
5569
5570             /* execute body of (?...A) */
5571             PUSH_YES_STATE_GOTO(IFMATCH_A, NEXTOPER(NEXTOPER(scan)));
5572             /* NOTREACHED */
5573
5574         case IFMATCH_A_fail: /* body of (?...A) failed */
5575             ST.wanted = !ST.wanted;
5576             /* FALL THROUGH */
5577
5578         case IFMATCH_A: /* body of (?...A) succeeded */
5579             if (ST.logical) {
5580                 sw = cBOOL(ST.wanted);
5581             }
5582             else if (!ST.wanted)
5583                 sayNO;
5584
5585             if (OP(ST.me) == SUSPEND)
5586                 locinput = PL_reginput;
5587             else {
5588                 locinput = PL_reginput = st->locinput;
5589                 nextchr = UCHARAT(locinput);
5590             }
5591             scan = ST.me + ARG(ST.me);
5592             if (scan == ST.me)
5593                 scan = NULL;
5594             continue; /* execute B */
5595
5596 #undef ST
5597
5598         case LONGJMP:
5599             next = scan + ARG(scan);
5600             if (next == scan)
5601                 next = NULL;
5602             break;
5603         case COMMIT:
5604             reginfo->cutpoint = PL_regeol;
5605             /* FALLTHROUGH */
5606         case PRUNE:
5607             PL_reginput = locinput;
5608             if (!scan->flags)
5609                 sv_yes_mark = sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
5610             PUSH_STATE_GOTO(COMMIT_next,next);
5611             /* NOTREACHED */
5612         case COMMIT_next_fail:
5613             no_final = 1;
5614             /* FALLTHROUGH */
5615         case OPFAIL:
5616             sayNO;
5617             /* NOTREACHED */
5618
5619 #define ST st->u.mark
5620         case MARKPOINT:
5621             ST.prev_mark = mark_state;
5622             ST.mark_name = sv_commit = sv_yes_mark
5623                 = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
5624             mark_state = st;
5625             ST.mark_loc = PL_reginput = locinput;
5626             PUSH_YES_STATE_GOTO(MARKPOINT_next,next);
5627             /* NOTREACHED */
5628         case MARKPOINT_next:
5629             mark_state = ST.prev_mark;
5630             sayYES;
5631             /* NOTREACHED */
5632         case MARKPOINT_next_fail:
5633             if (popmark && sv_eq(ST.mark_name,popmark))
5634             {
5635                 if (ST.mark_loc > startpoint)
5636                     reginfo->cutpoint = HOPBACKc(ST.mark_loc, 1);
5637                 popmark = NULL; /* we found our mark */
5638                 sv_commit = ST.mark_name;
5639
5640                 DEBUG_EXECUTE_r({
5641                         PerlIO_printf(Perl_debug_log,
5642                             "%*s  %ssetting cutpoint to mark:%"SVf"...%s\n",
5643                             REPORT_CODE_OFF+depth*2, "",
5644                             PL_colors[4], SVfARG(sv_commit), PL_colors[5]);
5645                 });
5646             }
5647             mark_state = ST.prev_mark;
5648             sv_yes_mark = mark_state ?
5649                 mark_state->u.mark.mark_name : NULL;
5650             sayNO;
5651             /* NOTREACHED */
5652         case SKIP:
5653             PL_reginput = locinput;
5654             if (scan->flags) {
5655                 /* (*SKIP) : if we fail we cut here*/
5656                 ST.mark_name = NULL;
5657                 ST.mark_loc = locinput;
5658                 PUSH_STATE_GOTO(SKIP_next,next);
5659             } else {
5660                 /* (*SKIP:NAME) : if there is a (*MARK:NAME) fail where it was,
5661                    otherwise do nothing.  Meaning we need to scan
5662                  */
5663                 regmatch_state *cur = mark_state;
5664                 SV *find = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
5665
5666                 while (cur) {
5667                     if ( sv_eq( cur->u.mark.mark_name,
5668                                 find ) )
5669                     {
5670                         ST.mark_name = find;
5671                         PUSH_STATE_GOTO( SKIP_next, next );
5672                     }
5673                     cur = cur->u.mark.prev_mark;
5674                 }
5675             }
5676             /* Didn't find our (*MARK:NAME) so ignore this (*SKIP:NAME) */
5677             break;
5678         case SKIP_next_fail:
5679             if (ST.mark_name) {
5680                 /* (*CUT:NAME) - Set up to search for the name as we
5681                    collapse the stack*/
5682                 popmark = ST.mark_name;
5683             } else {
5684                 /* (*CUT) - No name, we cut here.*/
5685                 if (ST.mark_loc > startpoint)
5686                     reginfo->cutpoint = HOPBACKc(ST.mark_loc, 1);
5687                 /* but we set sv_commit to latest mark_name if there
5688                    is one so they can test to see how things lead to this
5689                    cut */
5690                 if (mark_state)
5691                     sv_commit=mark_state->u.mark.mark_name;
5692             }
5693             no_final = 1;
5694             sayNO;
5695             /* NOTREACHED */
5696 #undef ST
5697         case FOLDCHAR:
5698             n = ARG(scan);
5699             if ( n == (U32)what_len_TRICKYFOLD(locinput,utf8_target,ln) ) {
5700                 locinput += ln;
5701             } else if ( LATIN_SMALL_LETTER_SHARP_S == n && !utf8_target && !UTF_PATTERN ) {
5702                 sayNO;
5703             } else  {
5704                 U8 folded[UTF8_MAXBYTES_CASE+1];
5705                 STRLEN foldlen;
5706                 const char * const l = locinput;
5707                 char *e = PL_regeol;
5708                 to_uni_fold(n, folded, &foldlen);
5709
5710                 if (! foldEQ_utf8((const char*) folded, 0,  foldlen, 1,
5711                                l, &e, 0,  utf8_target)) {
5712                         sayNO;
5713                 }
5714                 locinput = e;
5715             }
5716             nextchr = UCHARAT(locinput);
5717             break;
5718         case LNBREAK:
5719             if ((n=is_LNBREAK(locinput,utf8_target))) {
5720                 locinput += n;
5721                 nextchr = UCHARAT(locinput);
5722             } else
5723                 sayNO;
5724             break;
5725
5726 #define CASE_CLASS(nAmE)                              \
5727         case nAmE:                                    \
5728             if (locinput >= PL_regeol)                \
5729                 sayNO;                                \
5730             if ((n=is_##nAmE(locinput,utf8_target))) {    \
5731                 locinput += n;                        \
5732                 nextchr = UCHARAT(locinput);          \
5733             } else                                    \
5734                 sayNO;                                \
5735             break;                                    \
5736         case N##nAmE:                                 \
5737             if (locinput >= PL_regeol)                \
5738                 sayNO;                                \
5739             if ((n=is_##nAmE(locinput,utf8_target))) {    \
5740                 sayNO;                                \
5741             } else {                                  \
5742                 locinput += UTF8SKIP(locinput);       \
5743                 nextchr = UCHARAT(locinput);          \
5744             }                                         \
5745             break
5746
5747         CASE_CLASS(VERTWS);
5748         CASE_CLASS(HORIZWS);
5749 #undef CASE_CLASS
5750
5751         default:
5752             PerlIO_printf(Perl_error_log, "%"UVxf" %d\n",
5753                           PTR2UV(scan), OP(scan));
5754             Perl_croak(aTHX_ "regexp memory corruption");
5755
5756         } /* end switch */
5757
5758         /* switch break jumps here */
5759         scan = next; /* prepare to execute the next op and ... */
5760         continue;    /* ... jump back to the top, reusing st */
5761         /* NOTREACHED */
5762
5763       push_yes_state:
5764         /* push a state that backtracks on success */
5765         st->u.yes.prev_yes_state = yes_state;
5766         yes_state = st;
5767         /* FALL THROUGH */
5768       push_state:
5769         /* push a new regex state, then continue at scan  */
5770         {
5771             regmatch_state *newst;
5772
5773             DEBUG_STACK_r({
5774                 regmatch_state *cur = st;
5775                 regmatch_state *curyes = yes_state;
5776                 int curd = depth;
5777                 regmatch_slab *slab = PL_regmatch_slab;
5778                 for (;curd > -1;cur--,curd--) {
5779                     if (cur < SLAB_FIRST(slab)) {
5780                         slab = slab->prev;
5781                         cur = SLAB_LAST(slab);
5782                     }
5783                     PerlIO_printf(Perl_error_log, "%*s#%-3d %-10s %s\n",
5784                         REPORT_CODE_OFF + 2 + depth * 2,"",
5785                         curd, PL_reg_name[cur->resume_state],
5786                         (curyes == cur) ? "yes" : ""
5787                     );
5788                     if (curyes == cur)
5789                         curyes = cur->u.yes.prev_yes_state;
5790                 }
5791             } else
5792                 DEBUG_STATE_pp("push")
5793             );
5794             depth++;
5795             st->locinput = locinput;
5796             newst = st+1;
5797             if (newst >  SLAB_LAST(PL_regmatch_slab))
5798                 newst = S_push_slab(aTHX);
5799             PL_regmatch_state = newst;
5800
5801             locinput = PL_reginput;
5802             nextchr = UCHARAT(locinput);
5803             st = newst;
5804             continue;
5805             /* NOTREACHED */
5806         }
5807     }
5808
5809     /*
5810     * We get here only if there's trouble -- normally "case END" is
5811     * the terminating point.
5812     */
5813     Perl_croak(aTHX_ "corrupted regexp pointers");
5814     /*NOTREACHED*/
5815     sayNO;
5816
5817 yes:
5818     if (yes_state) {
5819         /* we have successfully completed a subexpression, but we must now
5820          * pop to the state marked by yes_state and continue from there */
5821         assert(st != yes_state);
5822 #ifdef DEBUGGING
5823         while (st != yes_state) {
5824             st--;
5825             if (st < SLAB_FIRST(PL_regmatch_slab)) {
5826                 PL_regmatch_slab = PL_regmatch_slab->prev;
5827                 st = SLAB_LAST(PL_regmatch_slab);
5828             }
5829             DEBUG_STATE_r({
5830                 if (no_final) {
5831                     DEBUG_STATE_pp("pop (no final)");
5832                 } else {
5833                     DEBUG_STATE_pp("pop (yes)");
5834                 }
5835             });
5836             depth--;
5837         }
5838 #else
5839         while (yes_state < SLAB_FIRST(PL_regmatch_slab)
5840             || yes_state > SLAB_LAST(PL_regmatch_slab))
5841         {
5842             /* not in this slab, pop slab */
5843             depth -= (st - SLAB_FIRST(PL_regmatch_slab) + 1);
5844             PL_regmatch_slab = PL_regmatch_slab->prev;
5845             st = SLAB_LAST(PL_regmatch_slab);
5846         }
5847         depth -= (st - yes_state);
5848 #endif
5849         st = yes_state;
5850         yes_state = st->u.yes.prev_yes_state;
5851         PL_regmatch_state = st;
5852
5853         if (no_final) {
5854             locinput= st->locinput;
5855             nextchr = UCHARAT(locinput);
5856         }
5857         state_num = st->resume_state + no_final;
5858         goto reenter_switch;
5859     }
5860
5861     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch successful!%s\n",
5862                           PL_colors[4], PL_colors[5]));
5863
5864     if (PL_reg_eval_set) {
5865         /* each successfully executed (?{...}) block does the equivalent of
5866          *   local $^R = do {...}
5867          * When popping the save stack, all these locals would be undone;
5868          * bypass this by setting the outermost saved $^R to the latest
5869          * value */
5870         if (oreplsv != GvSV(PL_replgv))
5871             sv_setsv(oreplsv, GvSV(PL_replgv));
5872     }
5873     result = 1;
5874     goto final_exit;
5875
5876 no:
5877     DEBUG_EXECUTE_r(
5878         PerlIO_printf(Perl_debug_log,
5879             "%*s  %sfailed...%s\n",
5880             REPORT_CODE_OFF+depth*2, "",
5881             PL_colors[4], PL_colors[5])
5882         );
5883
5884 no_silent:
5885     if (no_final) {
5886         if (yes_state) {
5887             goto yes;
5888         } else {
5889             goto final_exit;
5890         }
5891     }
5892     if (depth) {
5893         /* there's a previous state to backtrack to */
5894         st--;
5895         if (st < SLAB_FIRST(PL_regmatch_slab)) {
5896             PL_regmatch_slab = PL_regmatch_slab->prev;
5897             st = SLAB_LAST(PL_regmatch_slab);
5898         }
5899         PL_regmatch_state = st;
5900         locinput= st->locinput;
5901         nextchr = UCHARAT(locinput);
5902
5903         DEBUG_STATE_pp("pop");
5904         depth--;
5905         if (yes_state == st)
5906             yes_state = st->u.yes.prev_yes_state;
5907
5908         state_num = st->resume_state + 1; /* failure = success + 1 */
5909         goto reenter_switch;
5910     }
5911     result = 0;
5912
5913   final_exit:
5914     if (rex->intflags & PREGf_VERBARG_SEEN) {
5915         SV *sv_err = get_sv("REGERROR", 1);
5916         SV *sv_mrk = get_sv("REGMARK", 1);
5917         if (result) {
5918             sv_commit = &PL_sv_no;
5919             if (!sv_yes_mark)
5920                 sv_yes_mark = &PL_sv_yes;
5921         } else {
5922             if (!sv_commit)
5923                 sv_commit = &PL_sv_yes;
5924             sv_yes_mark = &PL_sv_no;
5925         }
5926         sv_setsv(sv_err, sv_commit);
5927         sv_setsv(sv_mrk, sv_yes_mark);
5928     }
5929
5930     /* clean up; in particular, free all slabs above current one */
5931     LEAVE_SCOPE(oldsave);
5932
5933     return result;
5934 }
5935
5936 /*
5937  - regrepeat - repeatedly match something simple, report how many
5938  */
5939 /*
5940  * [This routine now assumes that it will only match on things of length 1.
5941  * That was true before, but now we assume scan - reginput is the count,
5942  * rather than incrementing count on every character.  [Er, except utf8.]]
5943  */
5944 STATIC I32
5945 S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth)
5946 {
5947     dVAR;
5948     register char *scan;
5949     register I32 c;
5950     register char *loceol = PL_regeol;
5951     register I32 hardcount = 0;
5952     register bool utf8_target = PL_reg_match_utf8;
5953     UV utf8_flags;
5954 #ifndef DEBUGGING
5955     PERL_UNUSED_ARG(depth);
5956 #endif
5957
5958     PERL_ARGS_ASSERT_REGREPEAT;
5959
5960     scan = PL_reginput;
5961     if (max == REG_INFTY)
5962         max = I32_MAX;
5963     else if (max < loceol - scan)
5964         loceol = scan + max;
5965     switch (OP(p)) {
5966     case REG_ANY:
5967         if (utf8_target) {
5968             loceol = PL_regeol;
5969             while (scan < loceol && hardcount < max && *scan != '\n') {
5970                 scan += UTF8SKIP(scan);
5971                 hardcount++;
5972             }
5973         } else {
5974             while (scan < loceol && *scan != '\n')
5975                 scan++;
5976         }
5977         break;
5978     case SANY:
5979         if (utf8_target) {
5980             loceol = PL_regeol;
5981             while (scan < loceol && hardcount < max) {
5982                 scan += UTF8SKIP(scan);
5983                 hardcount++;
5984             }
5985         }
5986         else
5987             scan = loceol;
5988         break;
5989     case CANY:
5990         scan = loceol;
5991         break;
5992     case EXACT:
5993         /* To get here, EXACTish nodes must have *byte* length == 1.  That
5994          * means they match only characters in the string that can be expressed
5995          * as a single byte.  For non-utf8 strings, that means a simple match.
5996          * For utf8 strings, the character matched must be an invariant, or
5997          * downgradable to a single byte.  The pattern's utf8ness is
5998          * irrelevant, as since it's a single byte, it either isn't utf8, or if
5999          * it is, it's an invariant */
6000
6001         c = (U8)*STRING(p);
6002         assert(! UTF_PATTERN || UNI_IS_INVARIANT(c));
6003
6004         if (! utf8_target || UNI_IS_INVARIANT(c)) {
6005             while (scan < loceol && UCHARAT(scan) == c) {
6006                 scan++;
6007             }
6008         }
6009         else {
6010
6011             /* Here, the string is utf8, and the pattern char is different
6012              * in utf8 than not, so can't compare them directly.  Outside the
6013              * loop, find the two utf8 bytes that represent c, and then
6014              * look for those in sequence in the utf8 string */
6015             U8 high = UTF8_TWO_BYTE_HI(c);
6016             U8 low = UTF8_TWO_BYTE_LO(c);
6017             loceol = PL_regeol;
6018
6019             while (hardcount < max
6020                     && scan + 1 < loceol
6021                     && UCHARAT(scan) == high
6022                     && UCHARAT(scan + 1) == low)
6023             {
6024                 scan += 2;
6025                 hardcount++;
6026             }
6027         }
6028         break;
6029     case EXACTFA:
6030         utf8_flags = FOLDEQ_UTF8_NOMIX_ASCII;
6031         goto do_exactf;
6032
6033     case EXACTFL:
6034         PL_reg_flags |= RF_tainted;
6035         utf8_flags = FOLDEQ_UTF8_LOCALE;
6036         goto do_exactf;
6037
6038     case EXACTF:
6039     case EXACTFU:
6040         utf8_flags = (UTF_PATTERN) ? FOLDEQ_S2_ALREADY_FOLDED : 0;
6041
6042         /* The comments for the EXACT case above apply as well to these fold
6043          * ones */
6044
6045     do_exactf:
6046         c = (U8)*STRING(p);
6047         assert(! UTF_PATTERN || UNI_IS_INVARIANT(c));
6048
6049         if (utf8_target) { /* Use full Unicode fold matching */
6050             char *tmpeol = loceol;
6051             while (hardcount < max
6052                     && foldEQ_utf8_flags(scan, &tmpeol, 0, utf8_target,
6053                                    STRING(p), NULL, 1, cBOOL(UTF_PATTERN), utf8_flags))
6054             {
6055                 scan = tmpeol;
6056                 tmpeol = loceol;
6057                 hardcount++;
6058             }
6059
6060             /* XXX Note that the above handles properly the German sharp s in
6061              * the pattern matching ss in the string.  But it doesn't handle
6062              * properly cases where the string contains say 'LIGATURE ff' and
6063              * the pattern is 'f+'.  This would require, say, a new function or
6064              * revised interface to foldEQ_utf8(), in which the maximum number
6065              * of characters to match could be passed and it would return how
6066              * many actually did.  This is just one of many cases where
6067              * multi-char folds don't work properly, and so the fix is being
6068              * deferred */
6069         }
6070         else {
6071             U8 folded;
6072
6073             /* Here, the string isn't utf8 and c is a single byte; and either
6074              * the pattern isn't utf8 or c is an invariant, so its utf8ness
6075              * doesn't affect c.  Can just do simple comparisons for exact or
6076              * fold matching. */
6077             switch (OP(p)) {
6078                 case EXACTF: folded = PL_fold[c]; break;
6079                 case EXACTFA:
6080                 case EXACTFU: folded = PL_fold_latin1[c]; break;
6081                 case EXACTFL: folded = PL_fold_locale[c]; break;
6082                 default: Perl_croak(aTHX_ "panic: Unexpected op %u", OP(p));
6083             }
6084             while (scan < loceol &&
6085                    (UCHARAT(scan) == c || UCHARAT(scan) == folded))
6086             {
6087                 scan++;
6088             }
6089         }
6090         break;
6091     case ANYOFV:
6092     case ANYOF:
6093         if (utf8_target || OP(p) == ANYOFV) {
6094             STRLEN inclasslen;
6095             loceol = PL_regeol;
6096             inclasslen = loceol - scan;
6097             while (hardcount < max
6098                    && ((inclasslen = loceol - scan) > 0)
6099                    && reginclass(prog, p, (U8*)scan, &inclasslen, utf8_target))
6100             {
6101                 scan += inclasslen;
6102                 hardcount++;
6103             }
6104         } else {
6105             while (scan < loceol && REGINCLASS(prog, p, (U8*)scan))
6106                 scan++;
6107         }
6108         break;
6109     case ALNUMU:
6110         if (utf8_target) {
6111     utf8_wordchar:
6112             loceol = PL_regeol;
6113             LOAD_UTF8_CHARCLASS_ALNUM();
6114             while (hardcount < max && scan < loceol &&
6115                    swash_fetch(PL_utf8_alnum, (U8*)scan, utf8_target))
6116             {
6117                 scan += UTF8SKIP(scan);
6118                 hardcount++;
6119             }
6120         } else {
6121             while (scan < loceol && isWORDCHAR_L1((U8) *scan)) {
6122                 scan++;
6123             }
6124         }
6125         break;
6126     case ALNUM:
6127         if (utf8_target)
6128             goto utf8_wordchar;
6129         while (scan < loceol && isALNUM((U8) *scan)) {
6130             scan++;
6131         }
6132         break;
6133     case ALNUMA:
6134         while (scan < loceol && isWORDCHAR_A((U8) *scan)) {
6135             scan++;
6136         }
6137         break;
6138     case ALNUML:
6139         PL_reg_flags |= RF_tainted;
6140         if (utf8_target) {
6141             loceol = PL_regeol;
6142             while (hardcount < max && scan < loceol &&
6143                    isALNUM_LC_utf8((U8*)scan)) {
6144                 scan += UTF8SKIP(scan);
6145                 hardcount++;
6146             }
6147         } else {
6148             while (scan < loceol && isALNUM_LC(*scan))
6149                 scan++;
6150         }
6151         break;
6152     case NALNUMU:
6153         if (utf8_target) {
6154
6155     utf8_Nwordchar:
6156
6157             loceol = PL_regeol;
6158             LOAD_UTF8_CHARCLASS_ALNUM();
6159             while (hardcount < max && scan < loceol &&
6160                    ! swash_fetch(PL_utf8_alnum, (U8*)scan, utf8_target))
6161             {
6162                 scan += UTF8SKIP(scan);
6163                 hardcount++;
6164             }
6165         } else {
6166             while (scan < loceol && ! isWORDCHAR_L1((U8) *scan)) {
6167                 scan++;
6168             }
6169         }
6170         break;
6171     case NALNUM:
6172         if (utf8_target)
6173             goto utf8_Nwordchar;
6174         while (scan < loceol && ! isALNUM((U8) *scan)) {
6175             scan++;
6176         }
6177         break;
6178     case NALNUMA:
6179         if (utf8_target) {
6180             while (scan < loceol && ! isWORDCHAR_A((U8) *scan)) {
6181                 scan += UTF8SKIP(scan);
6182             }
6183         }
6184         else {
6185             while (scan < loceol && ! isWORDCHAR_A((U8) *scan)) {
6186                 scan++;
6187             }
6188         }
6189         break;
6190     case NALNUML:
6191         PL_reg_flags |= RF_tainted;
6192         if (utf8_target) {
6193             loceol = PL_regeol;
6194             while (hardcount < max && scan < loceol &&
6195                    !isALNUM_LC_utf8((U8*)scan)) {
6196                 scan += UTF8SKIP(scan);
6197                 hardcount++;
6198             }
6199         } else {
6200             while (scan < loceol && !isALNUM_LC(*scan))
6201                 scan++;
6202         }
6203         break;
6204     case SPACEU:
6205         if (utf8_target) {
6206
6207     utf8_space:
6208
6209             loceol = PL_regeol;
6210             LOAD_UTF8_CHARCLASS_SPACE();
6211             while (hardcount < max && scan < loceol &&
6212                    (*scan == ' ' ||
6213                     swash_fetch(PL_utf8_space,(U8*)scan, utf8_target)))
6214             {
6215                 scan += UTF8SKIP(scan);
6216                 hardcount++;
6217             }
6218             break;
6219         }
6220         else {
6221             while (scan < loceol && isSPACE_L1((U8) *scan)) {
6222                 scan++;
6223             }
6224             break;
6225         }
6226     case SPACE:
6227         if (utf8_target)
6228             goto utf8_space;
6229
6230         while (scan < loceol && isSPACE((U8) *scan)) {
6231             scan++;
6232         }
6233         break;
6234     case SPACEA:
6235         while (scan < loceol && isSPACE_A((U8) *scan)) {
6236             scan++;
6237         }
6238         break;
6239     case SPACEL:
6240         PL_reg_flags |= RF_tainted;
6241         if (utf8_target) {
6242             loceol = PL_regeol;
6243             while (hardcount < max && scan < loceol &&
6244                    isSPACE_LC_utf8((U8*)scan)) {
6245                 scan += UTF8SKIP(scan);
6246                 hardcount++;
6247             }
6248         } else {
6249             while (scan < loceol && isSPACE_LC(*scan))
6250                 scan++;
6251         }
6252         break;
6253     case NSPACEU:
6254         if (utf8_target) {
6255
6256     utf8_Nspace:
6257
6258             loceol = PL_regeol;
6259             LOAD_UTF8_CHARCLASS_SPACE();
6260             while (hardcount < max && scan < loceol &&
6261                    ! (*scan == ' ' ||
6262                       swash_fetch(PL_utf8_space,(U8*)scan, utf8_target)))
6263             {
6264                 scan += UTF8SKIP(scan);
6265                 hardcount++;
6266             }
6267             break;
6268         }
6269         else {
6270             while (scan < loceol && ! isSPACE_L1((U8) *scan)) {
6271                 scan++;
6272             }
6273         }
6274         break;
6275     case NSPACE:
6276         if (utf8_target)
6277             goto utf8_Nspace;
6278
6279         while (scan < loceol && ! isSPACE((U8) *scan)) {
6280             scan++;
6281         }
6282         break;
6283     case NSPACEA:
6284         if (utf8_target) {
6285             while (scan < loceol && ! isSPACE_A((U8) *scan)) {
6286                 scan += UTF8SKIP(scan);
6287             }
6288         }
6289         else {
6290             while (scan < loceol && ! isSPACE_A((U8) *scan)) {
6291                 scan++;
6292             }
6293         }
6294         break;
6295     case NSPACEL:
6296         PL_reg_flags |= RF_tainted;
6297         if (utf8_target) {
6298             loceol = PL_regeol;
6299             while (hardcount < max && scan < loceol &&
6300                    !isSPACE_LC_utf8((U8*)scan)) {
6301                 scan += UTF8SKIP(scan);
6302                 hardcount++;
6303             }
6304         } else {
6305             while (scan < loceol && !isSPACE_LC(*scan))
6306                 scan++;
6307         }
6308         break;
6309     case DIGIT:
6310         if (utf8_target) {
6311             loceol = PL_regeol;
6312             LOAD_UTF8_CHARCLASS_DIGIT();
6313             while (hardcount < max && scan < loceol &&
6314                    swash_fetch(PL_utf8_digit, (U8*)scan, utf8_target)) {
6315                 scan += UTF8SKIP(scan);
6316                 hardcount++;
6317             }
6318         } else {
6319             while (scan < loceol && isDIGIT(*scan))
6320                 scan++;
6321         }
6322         break;
6323     case DIGITA:
6324         while (scan < loceol && isDIGIT_A((U8) *scan)) {
6325             scan++;
6326         }
6327         break;
6328     case DIGITL:
6329         PL_reg_flags |= RF_tainted;
6330         if (utf8_target) {
6331             loceol = PL_regeol;
6332             while (hardcount < max && scan < loceol &&
6333                    isDIGIT_LC_utf8((U8*)scan)) {
6334                 scan += UTF8SKIP(scan);
6335                 hardcount++;
6336             }
6337         } else {
6338             while (scan < loceol && isDIGIT_LC(*scan))
6339                 scan++;
6340         }
6341         break;
6342     case NDIGIT:
6343         if (utf8_target) {
6344             loceol = PL_regeol;
6345             LOAD_UTF8_CHARCLASS_DIGIT();
6346             while (hardcount < max && scan < loceol &&
6347                    !swash_fetch(PL_utf8_digit, (U8*)scan, utf8_target)) {
6348                 scan += UTF8SKIP(scan);
6349                 hardcount++;
6350             }
6351         } else {
6352             while (scan < loceol && !isDIGIT(*scan))
6353                 scan++;
6354         }
6355         break;
6356     case NDIGITA:
6357         if (utf8_target) {
6358             while (scan < loceol && ! isDIGIT_A((U8) *scan)) {
6359                 scan += UTF8SKIP(scan);
6360             }
6361         }
6362         else {
6363             while (scan < loceol && ! isDIGIT_A((U8) *scan)) {
6364                 scan++;
6365             }
6366         }
6367         break;
6368     case NDIGITL:
6369         PL_reg_flags |= RF_tainted;
6370         if (utf8_target) {
6371             loceol = PL_regeol;
6372             while (hardcount < max && scan < loceol &&
6373                    !isDIGIT_LC_utf8((U8*)scan)) {
6374                 scan += UTF8SKIP(scan);
6375                 hardcount++;
6376             }
6377         } else {
6378             while (scan < loceol && !isDIGIT_LC(*scan))
6379                 scan++;
6380         }
6381         break;
6382     case LNBREAK:
6383         if (utf8_target) {
6384             loceol = PL_regeol;
6385             while (hardcount < max && scan < loceol && (c=is_LNBREAK_utf8(scan))) {
6386                 scan += c;
6387                 hardcount++;
6388             }
6389         } else {
6390             /*
6391               LNBREAK can match two latin chars, which is ok,
6392               because we have a null terminated string, but we
6393               have to use hardcount in this situation
6394             */
6395             while (scan < loceol && (c=is_LNBREAK_latin1(scan)))  {
6396                 scan+=c;
6397                 hardcount++;
6398             }
6399         }
6400         break;
6401     case HORIZWS:
6402         if (utf8_target) {
6403             loceol = PL_regeol;
6404             while (hardcount < max && scan < loceol && (c=is_HORIZWS_utf8(scan))) {
6405                 scan += c;
6406                 hardcount++;
6407             }
6408         } else {
6409             while (scan < loceol && is_HORIZWS_latin1(scan))
6410                 scan++;
6411         }
6412         break;
6413     case NHORIZWS:
6414         if (utf8_target) {
6415             loceol = PL_regeol;
6416             while (hardcount < max && scan < loceol && !is_HORIZWS_utf8(scan)) {
6417                 scan += UTF8SKIP(scan);
6418                 hardcount++;
6419             }
6420         } else {
6421             while (scan < loceol && !is_HORIZWS_latin1(scan))
6422                 scan++;
6423
6424         }
6425         break;
6426     case VERTWS:
6427         if (utf8_target) {
6428             loceol = PL_regeol;
6429             while (hardcount < max && scan < loceol && (c=is_VERTWS_utf8(scan))) {
6430                 scan += c;
6431                 hardcount++;
6432             }
6433         } else {
6434             while (scan < loceol && is_VERTWS_latin1(scan))
6435                 scan++;
6436
6437         }
6438         break;
6439     case NVERTWS:
6440         if (utf8_target) {
6441             loceol = PL_regeol;
6442             while (hardcount < max && scan < loceol && !is_VERTWS_utf8(scan)) {
6443                 scan += UTF8SKIP(scan);
6444                 hardcount++;
6445             }
6446         } else {
6447             while (scan < loceol && !is_VERTWS_latin1(scan))
6448                 scan++;
6449
6450         }
6451         break;
6452
6453     default:            /* Called on something of 0 width. */
6454         break;          /* So match right here or not at all. */
6455     }
6456
6457     if (hardcount)
6458         c = hardcount;
6459     else
6460         c = scan - PL_reginput;
6461     PL_reginput = scan;
6462
6463     DEBUG_r({
6464         GET_RE_DEBUG_FLAGS_DECL;
6465         DEBUG_EXECUTE_r({
6466             SV * const prop = sv_newmortal();
6467             regprop(prog, prop, p);
6468             PerlIO_printf(Perl_debug_log,
6469                         "%*s  %s can match %"IVdf" times out of %"IVdf"...\n",
6470                         REPORT_CODE_OFF + depth*2, "", SvPVX_const(prop),(IV)c,(IV)max);
6471         });
6472     });
6473
6474     return(c);
6475 }
6476
6477
6478 #if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
6479 /*
6480 - regclass_swash - prepare the utf8 swash
6481 */
6482
6483 SV *
6484 Perl_regclass_swash(pTHX_ const regexp *prog, register const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
6485 {
6486     dVAR;
6487     SV *sw  = NULL;
6488     SV *si  = NULL;
6489     SV *alt = NULL;
6490     RXi_GET_DECL(prog,progi);
6491     const struct reg_data * const data = prog ? progi->data : NULL;
6492
6493     PERL_ARGS_ASSERT_REGCLASS_SWASH;
6494
6495     assert(ANYOF_NONBITMAP(node));
6496
6497     if (data && data->count) {
6498         const U32 n = ARG(node);
6499
6500         if (data->what[n] == 's') {
6501             SV * const rv = MUTABLE_SV(data->data[n]);
6502             AV * const av = MUTABLE_AV(SvRV(rv));
6503             SV **const ary = AvARRAY(av);
6504             SV **a, **b;
6505
6506             /* See the end of regcomp.c:S_regclass() for
6507              * documentation of these array elements. */
6508
6509             si = *ary;
6510             a  = SvROK(ary[1]) ? &ary[1] : NULL;
6511             b  = SvTYPE(ary[2]) == SVt_PVAV ? &ary[2] : NULL;
6512
6513             if (a)
6514                 sw = *a;
6515             else if (si && doinit) {
6516                 sw = swash_init("utf8", "", si, 1, 0);
6517                 (void)av_store(av, 1, sw);
6518             }
6519             if (b)
6520                 alt = *b;
6521         }
6522     }
6523
6524     if (listsvp)
6525         *listsvp = si;
6526     if (altsvp)
6527         *altsvp  = alt;
6528
6529     return sw;
6530 }
6531 #endif
6532
6533 /*
6534  - reginclass - determine if a character falls into a character class
6535
6536   n is the ANYOF regnode
6537   p is the target string
6538   lenp is pointer to the maximum number of bytes of how far to go in p
6539     (This is assumed wthout checking to always be at least the current
6540     character's size)
6541   utf8_target tells whether p is in UTF-8.
6542
6543   Returns true if matched; false otherwise.  If lenp is not NULL, on return
6544   from a successful match, the value it points to will be updated to how many
6545   bytes in p were matched.  If there was no match, the value is undefined,
6546   possibly changed from the input.
6547
6548   Note that this can be a synthetic start class, a combination of various
6549   nodes, so things you think might be mutually exclusive, such as locale,
6550   aren't.  It can match both locale and non-locale
6551
6552  */
6553
6554 STATIC bool
6555 S_reginclass(pTHX_ const regexp * const prog, register const regnode * const n, register const U8* const p, STRLEN* lenp, register const bool utf8_target)
6556 {
6557     dVAR;
6558     const char flags = ANYOF_FLAGS(n);
6559     bool match = FALSE;
6560     UV c = *p;
6561     STRLEN c_len = 0;
6562     STRLEN maxlen;
6563
6564     PERL_ARGS_ASSERT_REGINCLASS;
6565
6566     /* If c is not already the code point, get it */
6567     if (utf8_target && !UTF8_IS_INVARIANT(c)) {
6568         c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &c_len,
6569                 (UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV)
6570                 | UTF8_ALLOW_FFFF | UTF8_CHECK_ONLY);
6571                 /* see [perl #37836] for UTF8_ALLOW_ANYUV; [perl #38293] for
6572                  * UTF8_ALLOW_FFFF */
6573         if (c_len == (STRLEN)-1)
6574             Perl_croak(aTHX_ "Malformed UTF-8 character (fatal)");
6575     }
6576     else {
6577         c_len = 1;
6578     }
6579
6580     /* Use passed in max length, or one character if none passed in or less
6581      * than one character.  And assume will match just one character.  This is
6582      * overwritten later if matched more. */
6583     if (lenp) {
6584         maxlen = (*lenp > c_len) ? *lenp : c_len;
6585         *lenp = c_len;
6586
6587     }
6588     else {
6589         maxlen = c_len;
6590     }
6591
6592     /* If this character is potentially in the bitmap, check it */
6593     if (c < 256) {
6594         if (ANYOF_BITMAP_TEST(n, c))
6595             match = TRUE;
6596         else if (flags & ANYOF_NON_UTF8_LATIN1_ALL
6597                 && ! utf8_target
6598                 && ! isASCII(c))
6599         {
6600             match = TRUE;
6601         }
6602
6603         else if (flags & ANYOF_LOCALE) {
6604             PL_reg_flags |= RF_tainted;
6605
6606             if ((flags & ANYOF_LOC_NONBITMAP_FOLD)
6607                  && ANYOF_BITMAP_TEST(n, PL_fold_locale[c]))
6608             {
6609                 match = TRUE;
6610             }
6611             else if (ANYOF_CLASS_TEST_ANY_SET(n) &&
6612                      ((ANYOF_CLASS_TEST(n, ANYOF_ALNUM)   &&  isALNUM_LC(c))  ||
6613                       (ANYOF_CLASS_TEST(n, ANYOF_NALNUM)  && !isALNUM_LC(c))  ||
6614                       (ANYOF_CLASS_TEST(n, ANYOF_SPACE)   &&  isSPACE_LC(c))  ||
6615                       (ANYOF_CLASS_TEST(n, ANYOF_NSPACE)  && !isSPACE_LC(c))  ||
6616                       (ANYOF_CLASS_TEST(n, ANYOF_DIGIT)   &&  isDIGIT_LC(c))  ||
6617                       (ANYOF_CLASS_TEST(n, ANYOF_NDIGIT)  && !isDIGIT_LC(c))  ||
6618                       (ANYOF_CLASS_TEST(n, ANYOF_ALNUMC)  &&  isALNUMC_LC(c)) ||
6619                       (ANYOF_CLASS_TEST(n, ANYOF_NALNUMC) && !isALNUMC_LC(c)) ||
6620                       (ANYOF_CLASS_TEST(n, ANYOF_ALPHA)   &&  isALPHA_LC(c))  ||
6621                       (ANYOF_CLASS_TEST(n, ANYOF_NALPHA)  && !isALPHA_LC(c))  ||
6622                       (ANYOF_CLASS_TEST(n, ANYOF_ASCII)   &&  isASCII(c))     ||
6623                       (ANYOF_CLASS_TEST(n, ANYOF_NASCII)  && !isASCII(c))     ||
6624                       (ANYOF_CLASS_TEST(n, ANYOF_CNTRL)   &&  isCNTRL_LC(c))  ||
6625                       (ANYOF_CLASS_TEST(n, ANYOF_NCNTRL)  && !isCNTRL_LC(c))  ||
6626                       (ANYOF_CLASS_TEST(n, ANYOF_GRAPH)   &&  isGRAPH_LC(c))  ||
6627                       (ANYOF_CLASS_TEST(n, ANYOF_NGRAPH)  && !isGRAPH_LC(c))  ||
6628                       (ANYOF_CLASS_TEST(n, ANYOF_LOWER)   &&  isLOWER_LC(c))  ||
6629                       (ANYOF_CLASS_TEST(n, ANYOF_NLOWER)  && !isLOWER_LC(c))  ||
6630                       (ANYOF_CLASS_TEST(n, ANYOF_PRINT)   &&  isPRINT_LC(c))  ||
6631                       (ANYOF_CLASS_TEST(n, ANYOF_NPRINT)  && !isPRINT_LC(c))  ||
6632                       (ANYOF_CLASS_TEST(n, ANYOF_PUNCT)   &&  isPUNCT_LC(c))  ||
6633                       (ANYOF_CLASS_TEST(n, ANYOF_NPUNCT)  && !isPUNCT_LC(c))  ||
6634                       (ANYOF_CLASS_TEST(n, ANYOF_UPPER)   &&  isUPPER_LC(c))  ||
6635                       (ANYOF_CLASS_TEST(n, ANYOF_NUPPER)  && !isUPPER_LC(c))  ||
6636                       (ANYOF_CLASS_TEST(n, ANYOF_XDIGIT)  &&  isXDIGIT(c))    ||
6637                       (ANYOF_CLASS_TEST(n, ANYOF_NXDIGIT) && !isXDIGIT(c))    ||
6638                       (ANYOF_CLASS_TEST(n, ANYOF_PSXSPC)  &&  isPSXSPC(c))    ||
6639                       (ANYOF_CLASS_TEST(n, ANYOF_NPSXSPC) && !isPSXSPC(c))    ||
6640                       (ANYOF_CLASS_TEST(n, ANYOF_BLANK)   &&  isBLANK(c))     ||
6641                       (ANYOF_CLASS_TEST(n, ANYOF_NBLANK)  && !isBLANK(c))
6642                      ) /* How's that for a conditional? */
6643             ) {
6644                 match = TRUE;
6645             }
6646         }
6647     }
6648
6649     /* If the bitmap didn't (or couldn't) match, and something outside the
6650      * bitmap could match, try that.  Locale nodes specifiy completely the
6651      * behavior of code points in the bit map (otherwise, a utf8 target would
6652      * cause them to be treated as Unicode and not locale), except in
6653      * the very unlikely event when this node is a synthetic start class, which
6654      * could be a combination of locale and non-locale nodes.  So allow locale
6655      * to match for the synthetic start class, which will give a false
6656      * positive that will be resolved when the match is done again as not part
6657      * of the synthetic start class */
6658     if (!match) {
6659         if (utf8_target && (flags & ANYOF_UNICODE_ALL) && c >= 256) {
6660             match = TRUE;       /* Everything above 255 matches */
6661         }
6662         else if (ANYOF_NONBITMAP(n)
6663                  && ((flags & ANYOF_NONBITMAP_NON_UTF8)
6664                      || (utf8_target
6665                          && (c >=256
6666                              || (! (flags & ANYOF_LOCALE))
6667                              || (flags & ANYOF_IS_SYNTHETIC)))))
6668         {
6669             AV *av;
6670             SV * const sw = regclass_swash(prog, n, TRUE, 0, (SV**)&av);
6671
6672             if (sw) {
6673                 U8 * utf8_p;
6674                 if (utf8_target) {
6675                     utf8_p = (U8 *) p;
6676                 } else {
6677
6678                     /* Not utf8.  Convert as much of the string as available up
6679                      * to the limit of how far the (single) character in the
6680                      * pattern can possibly match (no need to go further).  If
6681                      * the node is a straight ANYOF or not folding, it can't
6682                      * match more than one.  Otherwise, It can match up to how
6683                      * far a single char can fold to.  Since not utf8, each
6684                      * character is a single byte, so the max it can be in
6685                      * bytes is the same as the max it can be in characters */
6686                     STRLEN len = (OP(n) == ANYOF
6687                                   || ! (flags & ANYOF_LOC_NONBITMAP_FOLD))
6688                                   ? 1
6689                                   : (maxlen < UTF8_MAX_FOLD_CHAR_EXPAND)
6690                                     ? maxlen
6691                                     : UTF8_MAX_FOLD_CHAR_EXPAND;
6692                     utf8_p = bytes_to_utf8(p, &len);
6693                 }
6694
6695                 if (swash_fetch(sw, utf8_p, TRUE))
6696                     match = TRUE;
6697                 else if (flags & ANYOF_LOC_NONBITMAP_FOLD) {
6698
6699                     /* Here, we need to test if the fold of the target string
6700                      * matches.  The non-multi char folds have all been moved to
6701                      * the compilation phase, and the multi-char folds have
6702                      * been stored by regcomp into 'av'; we linearly check to
6703                      * see if any match the target string (folded).   We know
6704                      * that the originals were each one character, but we don't
6705                      * currently know how many characters/bytes each folded to,
6706                      * except we do know that there are small limits imposed by
6707                      * Unicode.  XXX A performance enhancement would be to have
6708                      * regcomp.c store the max number of chars/bytes that are
6709                      * in an av entry, as, say the 0th element.  Even better
6710                      * would be to have a hash of the few characters that can
6711                      * start a multi-char fold to the max number of chars of
6712                      * those folds.
6713                      *
6714                      * If there is a match, we will need to advance (if lenp is
6715                      * specified) the match pointer in the target string.  But
6716                      * what we are comparing here isn't that string directly,
6717                      * but its fold, whose length may differ from the original.
6718                      * As we go along in constructing the fold, therefore, we
6719                      * create a map so that we know how many bytes in the
6720                      * source to advance given that we have matched a certain
6721                      * number of bytes in the fold.  This map is stored in
6722                      * 'map_fold_len_back'.  Let n mean the number of bytes in
6723                      * the fold of the first character that we are folding.
6724                      * Then map_fold_len_back[n] is set to the number of bytes
6725                      * in that first character.  Similarly let m be the
6726                      * corresponding number for the second character to be
6727                      * folded.  Then map_fold_len_back[n+m] is set to the
6728                      * number of bytes occupied by the first two source
6729                      * characters. ... */
6730                     U8 map_fold_len_back[UTF8_MAXBYTES_CASE+1] = { 0 };
6731                     U8 folded[UTF8_MAXBYTES_CASE+1];
6732                     STRLEN foldlen = 0; /* num bytes in fold of 1st char */
6733                     STRLEN total_foldlen = 0; /* num bytes in fold of all
6734                                                   chars */
6735
6736                     if (OP(n) == ANYOF || maxlen == 1 || ! lenp || ! av) {
6737
6738                         /* Here, only need to fold the first char of the target
6739                          * string.  It the source wasn't utf8, is 1 byte long */
6740                         to_utf8_fold(utf8_p, folded, &foldlen);
6741                         total_foldlen = foldlen;
6742                         map_fold_len_back[foldlen] = (utf8_target)
6743                                                      ? UTF8SKIP(utf8_p)
6744                                                      : 1;
6745                     }
6746                     else {
6747
6748                         /* Here, need to fold more than the first char.  Do so
6749                          * up to the limits */
6750                         U8* source_ptr = utf8_p;    /* The source for the fold
6751                                                        is the regex target
6752                                                        string */
6753                         U8* folded_ptr = folded;
6754                         U8* e = utf8_p + maxlen;    /* Can't go beyond last
6755                                                        available byte in the
6756                                                        target string */
6757                         U8 i;
6758                         for (i = 0;
6759                              i < UTF8_MAX_FOLD_CHAR_EXPAND && source_ptr < e;
6760                              i++)
6761                         {
6762
6763                             /* Fold the next character */
6764                             U8 this_char_folded[UTF8_MAXBYTES_CASE+1];
6765                             STRLEN this_char_foldlen;
6766                             to_utf8_fold(source_ptr,
6767                                          this_char_folded,
6768                                          &this_char_foldlen);
6769
6770                             /* Bail if it would exceed the byte limit for
6771                              * folding a single char. */
6772                             if (this_char_foldlen + folded_ptr - folded >
6773                                                             UTF8_MAXBYTES_CASE)
6774                             {
6775                                 break;
6776                             }
6777
6778                             /* Add the fold of this character */
6779                             Copy(this_char_folded,
6780                                  folded_ptr,
6781                                  this_char_foldlen,
6782                                  U8);
6783                             source_ptr += UTF8SKIP(source_ptr);
6784                             folded_ptr += this_char_foldlen;
6785                             total_foldlen = folded_ptr - folded;
6786
6787                             /* Create map from the number of bytes in the fold
6788                              * back to the number of bytes in the source.  If
6789                              * the source isn't utf8, the byte count is just
6790                              * the number of characters so far */
6791                             map_fold_len_back[total_foldlen]
6792                                                       = (utf8_target)
6793                                                         ? source_ptr - utf8_p
6794                                                         : i + 1;
6795                         }
6796                         *folded_ptr = '\0';
6797                     }
6798
6799
6800                     /* Do the linear search to see if the fold is in the list
6801                      * of multi-char folds. */
6802                     if (av) {
6803                         I32 i;
6804                         for (i = 0; i <= av_len(av); i++) {
6805                             SV* const sv = *av_fetch(av, i, FALSE);
6806                             STRLEN len;
6807                             const char * const s = SvPV_const(sv, len);
6808
6809                             if (len <= total_foldlen
6810                                 && memEQ(s, (char*)folded, len)
6811
6812                                    /* If 0, means matched a partial char. See
6813                                     * [perl #90536] */
6814                                 && map_fold_len_back[len])
6815                             {
6816
6817                                 /* Advance the target string ptr to account for
6818                                  * this fold, but have to translate from the
6819                                  * folded length to the corresponding source
6820                                  * length. */
6821                                 if (lenp) {
6822                                     *lenp = map_fold_len_back[len];
6823                                 }
6824                                 match = TRUE;
6825                                 break;
6826                             }
6827                         }
6828                     }
6829                 }
6830
6831                 /* If we allocated a string above, free it */
6832                 if (! utf8_target) Safefree(utf8_p);
6833             }
6834         }
6835     }
6836
6837     return (flags & ANYOF_INVERT) ? !match : match;
6838 }
6839
6840 STATIC U8 *
6841 S_reghop3(U8 *s, I32 off, const U8* lim)
6842 {
6843     /* return the position 'off' UTF-8 characters away from 's', forward if
6844      * 'off' >= 0, backwards if negative.  But don't go outside of position
6845      * 'lim', which better be < s  if off < 0 */
6846
6847     dVAR;
6848
6849     PERL_ARGS_ASSERT_REGHOP3;
6850
6851     if (off >= 0) {
6852         while (off-- && s < lim) {
6853             /* XXX could check well-formedness here */
6854             s += UTF8SKIP(s);
6855         }
6856     }
6857     else {
6858         while (off++ && s > lim) {
6859             s--;
6860             if (UTF8_IS_CONTINUED(*s)) {
6861                 while (s > lim && UTF8_IS_CONTINUATION(*s))
6862                     s--;
6863             }
6864             /* XXX could check well-formedness here */
6865         }
6866     }
6867     return s;
6868 }
6869
6870 #ifdef XXX_dmq
6871 /* there are a bunch of places where we use two reghop3's that should
6872    be replaced with this routine. but since thats not done yet
6873    we ifdef it out - dmq
6874 */
6875 STATIC U8 *
6876 S_reghop4(U8 *s, I32 off, const U8* llim, const U8* rlim)
6877 {
6878     dVAR;
6879
6880     PERL_ARGS_ASSERT_REGHOP4;
6881
6882     if (off >= 0) {
6883         while (off-- && s < rlim) {
6884             /* XXX could check well-formedness here */
6885             s += UTF8SKIP(s);
6886         }
6887     }
6888     else {
6889         while (off++ && s > llim) {
6890             s--;
6891             if (UTF8_IS_CONTINUED(*s)) {
6892                 while (s > llim && UTF8_IS_CONTINUATION(*s))
6893                     s--;
6894             }
6895             /* XXX could check well-formedness here */
6896         }
6897     }
6898     return s;
6899 }
6900 #endif
6901
6902 STATIC U8 *
6903 S_reghopmaybe3(U8* s, I32 off, const U8* lim)
6904 {
6905     dVAR;
6906
6907     PERL_ARGS_ASSERT_REGHOPMAYBE3;
6908
6909     if (off >= 0) {
6910         while (off-- && s < lim) {
6911             /* XXX could check well-formedness here */
6912             s += UTF8SKIP(s);
6913         }
6914         if (off >= 0)
6915             return NULL;
6916     }
6917     else {
6918         while (off++ && s > lim) {
6919             s--;
6920             if (UTF8_IS_CONTINUED(*s)) {
6921                 while (s > lim && UTF8_IS_CONTINUATION(*s))
6922                     s--;
6923             }
6924             /* XXX could check well-formedness here */
6925         }
6926         if (off <= 0)
6927             return NULL;
6928     }
6929     return s;
6930 }
6931
6932 static void
6933 restore_pos(pTHX_ void *arg)
6934 {
6935     dVAR;
6936     regexp * const rex = (regexp *)arg;
6937     if (PL_reg_eval_set) {
6938         if (PL_reg_oldsaved) {
6939             rex->subbeg = PL_reg_oldsaved;
6940             rex->sublen = PL_reg_oldsavedlen;
6941 #ifdef PERL_OLD_COPY_ON_WRITE
6942             rex->saved_copy = PL_nrs;
6943 #endif
6944             RXp_MATCH_COPIED_on(rex);
6945         }
6946         PL_reg_magic->mg_len = PL_reg_oldpos;
6947         PL_reg_eval_set = 0;
6948         PL_curpm = PL_reg_oldcurpm;
6949     }
6950 }
6951
6952 STATIC void
6953 S_to_utf8_substr(pTHX_ register regexp *prog)
6954 {
6955     int i = 1;
6956
6957     PERL_ARGS_ASSERT_TO_UTF8_SUBSTR;
6958
6959     do {
6960         if (prog->substrs->data[i].substr
6961             && !prog->substrs->data[i].utf8_substr) {
6962             SV* const sv = newSVsv(prog->substrs->data[i].substr);
6963             prog->substrs->data[i].utf8_substr = sv;
6964             sv_utf8_upgrade(sv);
6965             if (SvVALID(prog->substrs->data[i].substr)) {
6966                 if (SvTAIL(prog->substrs->data[i].substr)) {
6967                     /* Trim the trailing \n that fbm_compile added last
6968                        time.  */
6969                     SvCUR_set(sv, SvCUR(sv) - 1);
6970                     /* Whilst this makes the SV technically "invalid" (as its
6971                        buffer is no longer followed by "\0") when fbm_compile()
6972                        adds the "\n" back, a "\0" is restored.  */
6973                     fbm_compile(sv, FBMcf_TAIL);
6974                 } else
6975                     fbm_compile(sv, 0);
6976             }
6977             if (prog->substrs->data[i].substr == prog->check_substr)
6978                 prog->check_utf8 = sv;
6979         }
6980     } while (i--);
6981 }
6982
6983 STATIC void
6984 S_to_byte_substr(pTHX_ register regexp *prog)
6985 {
6986     dVAR;
6987     int i = 1;
6988
6989     PERL_ARGS_ASSERT_TO_BYTE_SUBSTR;
6990
6991     do {
6992         if (prog->substrs->data[i].utf8_substr
6993             && !prog->substrs->data[i].substr) {
6994             SV* sv = newSVsv(prog->substrs->data[i].utf8_substr);
6995             if (sv_utf8_downgrade(sv, TRUE)) {
6996                 if (SvVALID(prog->substrs->data[i].utf8_substr)) {
6997                     if (SvTAIL(prog->substrs->data[i].utf8_substr)) {
6998                         /* Trim the trailing \n that fbm_compile added last
6999                            time.  */
7000                         SvCUR_set(sv, SvCUR(sv) - 1);
7001                         fbm_compile(sv, FBMcf_TAIL);
7002                     } else
7003                         fbm_compile(sv, 0);
7004                 }
7005             } else {
7006                 SvREFCNT_dec(sv);
7007                 sv = &PL_sv_undef;
7008             }
7009             prog->substrs->data[i].substr = sv;
7010             if (prog->substrs->data[i].utf8_substr == prog->check_utf8)
7011                 prog->check_substr = sv;
7012         }
7013     } while (i--);
7014 }
7015
7016 /*
7017  * Local variables:
7018  * c-indentation-style: bsd
7019  * c-basic-offset: 4
7020  * indent-tabs-mode: t
7021  * End:
7022  *
7023  * ex: set ts=8 sts=4 sw=4 noet:
7024  */