regexec.c

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