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