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