regexec.c

   1 /*    regexec.c
   2  */
   3
   4 /*
   5  * "One Ring to rule them all, One Ring to find them..."
   6  */
   7
   8 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
   9  * confused with the original package (see point 3 below).  Thanks, Henry!
  10  */
  11
  12 /* Additional note: this code is very heavily munged from Henry's version
  13  * in places.  In some spots I've traded clarity for efficiency, so don't
  14  * blame Henry for some of the lack of readability.
  15  */
  16
  17 /* The names of the functions have been changed from regcomp and
  18  * regexec to  pregcomp and pregexec in order to avoid conflicts
  19  * with the POSIX routines of the same names.
  20 */
  21
  22 #ifdef PERL_EXT_RE_BUILD
  23 /* need to replace pregcomp et al, so enable that */
  24 #  ifndef PERL_IN_XSUB_RE
  25 #    define PERL_IN_XSUB_RE
  26 #  endif
  27 /* need access to debugger hooks */
  28 #  if defined(PERL_EXT_RE_DEBUG) && !defined(DEBUGGING)
  29 #    define DEBUGGING
  30 #  endif
  31 #endif
  32
  33 #ifdef PERL_IN_XSUB_RE
  34 /* We *really* need to overwrite these symbols: */
  35 #  define Perl_regexec_flags my_regexec
  36 #  define Perl_regdump my_regdump
  37 #  define Perl_regprop my_regprop
  38 #  define Perl_re_intuit_start my_re_intuit_start
  39 /* *These* symbols are masked to allow static link. */
  40 #  define Perl_pregexec my_pregexec
  41 #  define Perl_reginitcolors my_reginitcolors
  42 #  define Perl_regclass_swash my_regclass_swash
  43
  44 #  define PERL_NO_GET_CONTEXT
  45 #endif
  46
  47 /*SUPPRESS 112*/
  48 /*
  49  * pregcomp and pregexec -- regsub and regerror are not used in perl
  50  *
  51  *      Copyright (c) 1986 by University of Toronto.
  52  *      Written by Henry Spencer.  Not derived from licensed software.
  53  *
  54  *      Permission is granted to anyone to use this software for any
  55  *      purpose on any computer system, and to redistribute it freely,
  56  *      subject to the following restrictions:
  57  *
  58  *      1. The author is not responsible for the consequences of use of
  59  *              this software, no matter how awful, even if they arise
  60  *              from defects in it.
  61  *
  62  *      2. The origin of this software must not be misrepresented, either
  63  *              by explicit claim or by omission.
  64  *
  65  *      3. Altered versions must be plainly marked as such, and must not
  66  *              be misrepresented as being the original software.
  67  *
  68  ****    Alterations to Henry's code are...
  69  ****
  70  ****    Copyright (c) 1991-2001, Larry Wall
  71  ****
  72  ****    You may distribute under the terms of either the GNU General Public
  73  ****    License or the Artistic License, as specified in the README file.
  74  *
  75  * Beware that some of this code is subtly aware of the way operator
  76  * precedence is structured in regular expressions.  Serious changes in
  77  * regular-expression syntax might require a total rethink.
  78  */
  79 #include "EXTERN.h"
  80 #define PERL_IN_REGEXEC_C
  81 #include "perl.h"
  82
  83 #include "regcomp.h"
  84
  85 #define RF_tainted      1               /* tainted information used? */
  86 #define RF_warned       2               /* warned about big count? */
  87 #define RF_evaled       4               /* Did an EVAL with setting? */
  88 #define RF_utf8         8               /* String contains multibyte chars? */
  89
  90 #define UTF (PL_reg_flags & RF_utf8)
  91
  92 #define RS_init         1               /* eval environment created */
  93 #define RS_set          2               /* replsv value is set */
  94
  95 #ifndef STATIC
  96 #define STATIC  static
  97 #endif
  98
  99 /*
 100  * Forwards.
 101  */
 102
 103 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
 104 #define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
 105
 106 #define reghop_c(pos,off) ((char*)reghop((U8*)pos, off))
 107 #define reghopmaybe_c(pos,off) ((char*)reghopmaybe((U8*)pos, off))
 108 #define HOP(pos,off) (PL_reg_match_utf8 ? reghop((U8*)pos, off) : (U8*)(pos + off))
 109 #define HOPMAYBE(pos,off) (PL_reg_match_utf8 ? reghopmaybe((U8*)pos, off) : (U8*)(pos + off))
 110 #define HOPc(pos,off) ((char*)HOP(pos,off))
 111 #define HOPMAYBEc(pos,off) ((char*)HOPMAYBE(pos,off))
 112
 113 #define HOPBACK(pos, off) (             \
 114     (UTF && PL_reg_match_utf8)          \
 115         ? reghopmaybe((U8*)pos, -off)   \
 116     : (pos - off >= PL_bostr)           \
 117         ? (U8*)(pos - off)              \
 118     : (U8*)NULL                         \
 119 )
 120 #define HOPBACKc(pos, off) (char*)HOPBACK(pos, off)
 121
 122 #define reghop3_c(pos,off,lim) ((char*)reghop3((U8*)pos, off, (U8*)lim))
 123 #define reghopmaybe3_c(pos,off,lim) ((char*)reghopmaybe3((U8*)pos, off, (U8*)lim))
 124 #define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
 125 #define HOPMAYBE3(pos,off,lim) (PL_reg_match_utf8 ? reghopmaybe3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
 126 #define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
 127 #define HOPMAYBE3c(pos,off,lim) ((char*)HOPMAYBE3(pos,off,lim))
 128
 129 #define LOAD_UTF8_CHARCLASS(a,b) STMT_START { if (!CAT2(PL_utf8_,a)) (void)CAT2(is_utf8_, a)((U8*)b); } STMT_END
 130
 131 /* for use after a quantifier and before an EXACT-like node -- japhy */
 132 #define JUMPABLE(rn) ( \
 133     OP(rn) == OPEN || OP(rn) == CLOSE || OP(rn) == EVAL || \
 134     OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
 135     OP(rn) == PLUS || OP(rn) == MINMOD || \
 136     (PL_regkind[(U8)OP(rn)] == CURLY && ARG1(rn) > 0) \
 137 )
 138
 139 #define HAS_TEXT(rn) ( \
 140     PL_regkind[(U8)OP(rn)] == EXACT || PL_regkind[(U8)OP(rn)] == REF \
 141 )
 142
 143 #define FIND_NEXT_IMPT(rn) STMT_START { \
 144     while (JUMPABLE(rn)) \
 145         if (OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
 146             PL_regkind[(U8)OP(rn)] == CURLY) \
 147             rn = NEXTOPER(NEXTOPER(rn)); \
 148         else if (OP(rn) == PLUS) \
 149             rn = NEXTOPER(rn); \
 150         else rn += NEXT_OFF(rn); \
 151 } STMT_END
 152
 153 static void restore_pos(pTHX_ void *arg);
 154
 155 STATIC CHECKPOINT
 156 S_regcppush(pTHX_ I32 parenfloor)
 157 {
 158     int retval = PL_savestack_ix;
 159 #define REGCP_PAREN_ELEMS 4
 160     int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
 161     int p;
 162
 163     if (paren_elems_to_push < 0)
 164         Perl_croak(aTHX_ "panic: paren_elems_to_push < 0");
 165
 166 #define REGCP_OTHER_ELEMS 6
 167     SSCHECK(paren_elems_to_push + REGCP_OTHER_ELEMS);
 168     for (p = PL_regsize; p > parenfloor; p--) {
 169 /* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
 170         SSPUSHINT(PL_regendp[p]);
 171         SSPUSHINT(PL_regstartp[p]);
 172         SSPUSHPTR(PL_reg_start_tmp[p]);
 173         SSPUSHINT(p);
 174     }
 175 /* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
 176     SSPUSHINT(PL_regsize);
 177     SSPUSHINT(*PL_reglastparen);
 178     SSPUSHINT(*PL_reglastcloseparen);
 179     SSPUSHPTR(PL_reginput);
 180 #define REGCP_FRAME_ELEMS 2
 181 /* REGCP_FRAME_ELEMS are part of the REGCP_OTHER_ELEMS and
 182  * are needed for the regexp context stack bookkeeping. */
 183     SSPUSHINT(paren_elems_to_push + REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
 184     SSPUSHINT(SAVEt_REGCONTEXT); /* Magic cookie. */
 185
 186     return retval;
 187 }
 188
 189 /* These are needed since we do not localize EVAL nodes: */
 190 #  define REGCP_SET(cp)  DEBUG_r(PerlIO_printf(Perl_debug_log,          \
 191                              "  Setting an EVAL scope, savestack=%"IVdf"\n",    \
 192                              (IV)PL_savestack_ix)); cp = PL_savestack_ix
 193
 194 #  define REGCP_UNWIND(cp)  DEBUG_r(cp != PL_savestack_ix ?             \
 195                                 PerlIO_printf(Perl_debug_log,           \
 196                                 "  Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
 197                                 (IV)(cp), (IV)PL_savestack_ix) : 0); regcpblow(cp)
 198
 199 STATIC char *
 200 S_regcppop(pTHX)
 201 {
 202     I32 i;
 203     U32 paren = 0;
 204     char *input;
 205     I32 tmps;
 206
 207     /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
 208     i = SSPOPINT;
 209     assert(i == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
 210     i = SSPOPINT; /* Parentheses elements to pop. */
 211     input = (char *) SSPOPPTR;
 212     *PL_reglastcloseparen = SSPOPINT;
 213     *PL_reglastparen = SSPOPINT;
 214     PL_regsize = SSPOPINT;
 215
 216     /* Now restore the parentheses context. */
 217     for (i -= (REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
 218          i > 0; i -= REGCP_PAREN_ELEMS) {
 219         paren = (U32)SSPOPINT;
 220         PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
 221         PL_regstartp[paren] = SSPOPINT;
 222         tmps = SSPOPINT;
 223         if (paren <= *PL_reglastparen)
 224             PL_regendp[paren] = tmps;
 225         DEBUG_r(
 226             PerlIO_printf(Perl_debug_log,
 227                           "     restoring \\%"UVuf" to %"IVdf"(%"IVdf")..%"IVdf"%s\n",
 228                           (UV)paren, (IV)PL_regstartp[paren],
 229                           (IV)(PL_reg_start_tmp[paren] - PL_bostr),
 230                           (IV)PL_regendp[paren],
 231                           (paren > *PL_reglastparen ? "(no)" : ""));
 232         );
 233     }
 234     DEBUG_r(
 235         if (*PL_reglastparen + 1 <= PL_regnpar) {
 236             PerlIO_printf(Perl_debug_log,
 237                           "     restoring \\%"IVdf"..\\%"IVdf" to undef\n",
 238                           (IV)(*PL_reglastparen + 1), (IV)PL_regnpar);
 239         }
 240     );
 241 #if 1
 242     /* It would seem that the similar code in regtry()
 243      * already takes care of this, and in fact it is in
 244      * a better location to since this code can #if 0-ed out
 245      * but the code in regtry() is needed or otherwise tests
 246      * requiring null fields (pat.t#187 and split.t#{13,14}
 247      * (as of patchlevel 7877)  will fail.  Then again,
 248      * this code seems to be necessary or otherwise
 249      * building DynaLoader will fail:
 250      * "Error: '*' not in typemap in DynaLoader.xs, line 164"
 251      * --jhi */
 252     for (paren = *PL_reglastparen + 1; paren <= PL_regnpar; paren++) {
 253         if (paren > PL_regsize)
 254             PL_regstartp[paren] = -1;
 255         PL_regendp[paren] = -1;
 256     }
 257 #endif
 258     return input;
 259 }
 260
 261 STATIC char *
 262 S_regcp_set_to(pTHX_ I32 ss)
 263 {
 264     I32 tmp = PL_savestack_ix;
 265
 266     PL_savestack_ix = ss;
 267     regcppop();
 268     PL_savestack_ix = tmp;
 269     return Nullch;
 270 }
 271
 272 typedef struct re_cc_state
 273 {
 274     I32 ss;
 275     regnode *node;
 276     struct re_cc_state *prev;
 277     CURCUR *cc;
 278     regexp *re;
 279 } re_cc_state;
 280
 281 #define regcpblow(cp) LEAVE_SCOPE(cp)   /* Ignores regcppush()ed data. */
 282
 283 #define TRYPAREN(paren, n, input) {                             \
 284     if (paren) {                                                \
 285         if (n) {                                                \
 286             PL_regstartp[paren] = HOPc(input, -1) - PL_bostr;   \
 287             PL_regendp[paren] = input - PL_bostr;               \
 288         }                                                       \
 289         else                                                    \
 290             PL_regendp[paren] = -1;                             \
 291     }                                                           \
 292     if (regmatch(next))                                         \
 293         sayYES;                                                 \
 294     if (paren && n)                                             \
 295         PL_regendp[paren] = -1;                                 \
 296 }
 297
 298
 299 /*
 300  * pregexec and friends
 301  */
 302
 303 /*
 304  - pregexec - match a regexp against a string
 305  */
 306 I32
 307 Perl_pregexec(pTHX_ register regexp *prog, char *stringarg, register char *strend,
 308          char *strbeg, I32 minend, SV *screamer, U32 nosave)
 309 /* strend: pointer to null at end of string */
 310 /* strbeg: real beginning of string */
 311 /* minend: end of match must be >=minend after stringarg. */
 312 /* nosave: For optimizations. */
 313 {
 314     return
 315         regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
 316                       nosave ? 0 : REXEC_COPY_STR);
 317 }
 318
 319 STATIC void
 320 S_cache_re(pTHX_ regexp *prog)
 321 {
 322     PL_regprecomp = prog->precomp;              /* Needed for FAIL. */
 323 #ifdef DEBUGGING
 324     PL_regprogram = prog->program;
 325 #endif
 326     PL_regnpar = prog->nparens;
 327     PL_regdata = prog->data;
 328     PL_reg_re = prog;
 329 }
 330
 331 /*
 332  * Need to implement the following flags for reg_anch:
 333  *
 334  * USE_INTUIT_NOML              - Useful to call re_intuit_start() first
 335  * USE_INTUIT_ML
 336  * INTUIT_AUTORITATIVE_NOML     - Can trust a positive answer
 337  * INTUIT_AUTORITATIVE_ML
 338  * INTUIT_ONCE_NOML             - Intuit can match in one location only.
 339  * INTUIT_ONCE_ML
 340  *
 341  * Another flag for this function: SECOND_TIME (so that float substrs
 342  * with giant delta may be not rechecked).
 343  */
 344
 345 /* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
 346
 347 /* If SCREAM, then SvPVX(sv) should be compatible with strpos and strend.
 348    Otherwise, only SvCUR(sv) is used to get strbeg. */
 349
 350 /* XXXX We assume that strpos is strbeg unless sv. */
 351
 352 /* XXXX Some places assume that there is a fixed substring.
 353         An update may be needed if optimizer marks as "INTUITable"
 354         RExen without fixed substrings.  Similarly, it is assumed that
 355         lengths of all the strings are no more than minlen, thus they
 356         cannot come from lookahead.
 357         (Or minlen should take into account lookahead.) */
 358
 359 /* A failure to find a constant substring means that there is no need to make
 360    an expensive call to REx engine, thus we celebrate a failure.  Similarly,
 361    finding a substring too deep into the string means that less calls to
 362    regtry() should be needed.
 363
 364    REx compiler's optimizer found 4 possible hints:
 365         a) Anchored substring;
 366         b) Fixed substring;
 367         c) Whether we are anchored (beginning-of-line or \G);
 368         d) First node (of those at offset 0) which may distingush positions;
 369    We use a)b)d) and multiline-part of c), and try to find a position in the
 370    string which does not contradict any of them.
 371  */
 372
 373 /* Most of decisions we do here should have been done at compile time.
 374    The nodes of the REx which we used for the search should have been
 375    deleted from the finite automaton. */
 376
 377 char *
 378 Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 379                      char *strend, U32 flags, re_scream_pos_data *data)
 380 {
 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     I32 ml_anch;
 389     register char *other_last = Nullch; /* other substr checked before this */
 390     char *check_at = Nullch;            /* check substr found at this pos */
 391 #ifdef DEBUGGING
 392     char *i_strpos = strpos;
 393     SV *dsv = PERL_DEBUG_PAD_ZERO(0);
 394 #endif
 395
 396     if (prog->reganch & ROPT_UTF8) {
 397         DEBUG_r(PerlIO_printf(Perl_debug_log,
 398                               "UTF-8 regex...\n"));
 399         PL_reg_flags |= RF_utf8;
 400     }
 401
 402     DEBUG_r({
 403          char *s   = PL_reg_match_utf8 ?
 404                          sv_uni_display(dsv, sv, 60, 0) : strpos;
 405          int   len = PL_reg_match_utf8 ?
 406                          strlen(s) : strend - strpos;
 407          if (!PL_colorset)
 408               reginitcolors();
 409          if (PL_reg_match_utf8)
 410              DEBUG_r(PerlIO_printf(Perl_debug_log,
 411                                    "UTF-8 target...\n"));
 412          PerlIO_printf(Perl_debug_log,
 413                        "%sGuessing start of match, REx%s `%s%.60s%s%s' against `%s%.*s%s%s'...\n",
 414                        PL_colors[4],PL_colors[5],PL_colors[0],
 415                        prog->precomp,
 416                        PL_colors[1],
 417                        (strlen(prog->precomp) > 60 ? "..." : ""),
 418                        PL_colors[0],
 419                        (int)(len > 60 ? 60 : len),
 420                        s, PL_colors[1],
 421                        (len > 60 ? "..." : "")
 422               );
 423     });
 424
 425     if (prog->minlen > CHR_DIST((U8*)strend, (U8*)strpos)) {
 426         DEBUG_r(PerlIO_printf(Perl_debug_log,
 427                               "String too short... [re_intuit_start]\n"));
 428         goto fail;
 429     }
 430     strbeg = (sv && SvPOK(sv)) ? strend - SvCUR(sv) : strpos;
 431     PL_regeol = strend;
 432     check = prog->check_substr;
 433     if (prog->reganch & ROPT_ANCH) {    /* Match at beg-of-str or after \n */
 434         ml_anch = !( (prog->reganch & ROPT_ANCH_SINGLE)
 435                      || ( (prog->reganch & ROPT_ANCH_BOL)
 436                           && !PL_multiline ) ); /* Check after \n? */
 437
 438         if (!ml_anch) {
 439           if ( !(prog->reganch & (ROPT_ANCH_GPOS /* Checked by the caller */
 440                                   | ROPT_IMPLICIT)) /* not a real BOL */
 441                /* SvCUR is not set on references: SvRV and SvPVX overlap */
 442                && sv && !SvROK(sv)
 443                && (strpos != strbeg)) {
 444               DEBUG_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
 445               goto fail;
 446           }
 447           if (prog->check_offset_min == prog->check_offset_max &&
 448               !(prog->reganch & ROPT_CANY_SEEN)) {
 449             /* Substring at constant offset from beg-of-str... */
 450             I32 slen;
 451
 452             s = HOP3c(strpos, prog->check_offset_min, strend);
 453             if (SvTAIL(check)) {
 454                 slen = SvCUR(check);    /* >= 1 */
 455
 456                 if ( strend - s > slen || strend - s < slen - 1
 457                      || (strend - s == slen && strend[-1] != '\n')) {
 458                     DEBUG_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
 459                     goto fail_finish;
 460                 }
 461                 /* Now should match s[0..slen-2] */
 462                 slen--;
 463                 if (slen && (*SvPVX(check) != *s
 464                              || (slen > 1
 465                                  && memNE(SvPVX(check), s, slen)))) {
 466                   report_neq:
 467                     DEBUG_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
 468                     goto fail_finish;
 469                 }
 470             }
 471             else if (*SvPVX(check) != *s
 472                      || ((slen = SvCUR(check)) > 1
 473                          && memNE(SvPVX(check), s, slen)))
 474                 goto report_neq;
 475             goto success_at_start;
 476           }
 477         }
 478         /* Match is anchored, but substr is not anchored wrt beg-of-str. */
 479         s = strpos;
 480         start_shift = prog->check_offset_min; /* okay to underestimate on CC */
 481         end_shift = prog->minlen - start_shift -
 482             CHR_SVLEN(check) + (SvTAIL(check) != 0);
 483         if (!ml_anch) {
 484             I32 end = prog->check_offset_max + CHR_SVLEN(check)
 485                                          - (SvTAIL(check) != 0);
 486             I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
 487
 488             if (end_shift < eshift)
 489                 end_shift = eshift;
 490         }
 491     }
 492     else {                              /* Can match at random position */
 493         ml_anch = 0;
 494         s = strpos;
 495         start_shift = prog->check_offset_min; /* okay to underestimate on CC */
 496         /* Should be nonnegative! */
 497         end_shift = prog->minlen - start_shift -
 498             CHR_SVLEN(check) + (SvTAIL(check) != 0);
 499     }
 500
 501 #ifdef DEBUGGING        /* 7/99: reports of failure (with the older version) */
 502     if (end_shift < 0)
 503         Perl_croak(aTHX_ "panic: end_shift");
 504 #endif
 505
 506   restart:
 507     /* Find a possible match in the region s..strend by looking for
 508        the "check" substring in the region corrected by start/end_shift. */
 509     if (flags & REXEC_SCREAM) {
 510         I32 p = -1;                     /* Internal iterator of scream. */
 511         I32 *pp = data ? data->scream_pos : &p;
 512
 513         if (PL_screamfirst[BmRARE(check)] >= 0
 514             || ( BmRARE(check) == '\n'
 515                  && (BmPREVIOUS(check) == SvCUR(check) - 1)
 516                  && SvTAIL(check) ))
 517             s = screaminstr(sv, check,
 518                             start_shift + (s - strbeg), end_shift, pp, 0);
 519         else
 520             goto fail_finish;
 521         if (data)
 522             *data->scream_olds = s;
 523     }
 524     else if (prog->reganch & ROPT_CANY_SEEN)
 525         s = fbm_instr((U8*)(s + start_shift),
 526                       (U8*)(strend - end_shift),
 527                       check, PL_multiline ? FBMrf_MULTILINE : 0);
 528     else
 529         s = fbm_instr(HOP3(s, start_shift, strend),
 530                       HOP3(strend, -end_shift, strbeg),
 531                       check, PL_multiline ? FBMrf_MULTILINE : 0);
 532
 533     /* Update the count-of-usability, remove useless subpatterns,
 534         unshift s.  */
 535
 536     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s %s substr `%s%.*s%s'%s%s",
 537                           (s ? "Found" : "Did not find"),
 538                           ((check == prog->anchored_substr) ? "anchored" : "floating"),
 539                           PL_colors[0],
 540                           (int)(SvCUR(check) - (SvTAIL(check)!=0)),
 541                           SvPVX(check),
 542                           PL_colors[1], (SvTAIL(check) ? "$" : ""),
 543                           (s ? " at offset " : "...\n") ) );
 544
 545     if (!s)
 546         goto fail_finish;
 547
 548     check_at = s;
 549
 550     /* Finish the diagnostic message */
 551     DEBUG_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
 552
 553     /* Got a candidate.  Check MBOL anchoring, and the *other* substr.
 554        Start with the other substr.
 555        XXXX no SCREAM optimization yet - and a very coarse implementation
 556        XXXX /ttx+/ results in anchored=`ttx', floating=`x'.  floating will
 557                 *always* match.  Probably should be marked during compile...
 558        Probably it is right to do no SCREAM here...
 559      */
 560
 561     if (prog->float_substr && prog->anchored_substr) {
 562         /* Take into account the "other" substring. */
 563         /* XXXX May be hopelessly wrong for UTF... */
 564         if (!other_last)
 565             other_last = strpos;
 566         if (check == prog->float_substr) {
 567           do_other_anchored:
 568             {
 569                 char *last = HOP3c(s, -start_shift, strbeg), *last1, *last2;
 570                 char *s1 = s;
 571
 572                 t = s - prog->check_offset_max;
 573                 if (s - strpos > prog->check_offset_max  /* signed-corrected t > strpos */
 574                     && (!(prog->reganch & ROPT_UTF8)
 575                         || ((t = reghopmaybe3_c(s, -(prog->check_offset_max), strpos))
 576                             && t > strpos)))
 577                     /* EMPTY */;
 578                 else
 579                     t = strpos;
 580                 t = HOP3c(t, prog->anchored_offset, strend);
 581                 if (t < other_last)     /* These positions already checked */
 582                     t = other_last;
 583                 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
 584                 if (last < last1)
 585                     last1 = last;
 586  /* XXXX It is not documented what units *_offsets are in.  Assume bytes.  */
 587                 /* On end-of-str: see comment below. */
 588                 s = fbm_instr((unsigned char*)t,
 589                               HOP3(HOP3(last1, prog->anchored_offset, strend)
 590                                    + SvCUR(prog->anchored_substr),
 591                                    -(SvTAIL(prog->anchored_substr)!=0), strbeg),
 592                               prog->anchored_substr,
 593                               PL_multiline ? FBMrf_MULTILINE : 0);
 594                 DEBUG_r(PerlIO_printf(Perl_debug_log,
 595                         "%s anchored substr `%s%.*s%s'%s",
 596                         (s ? "Found" : "Contradicts"),
 597                         PL_colors[0],
 598                           (int)(SvCUR(prog->anchored_substr)
 599                           - (SvTAIL(prog->anchored_substr)!=0)),
 600                           SvPVX(prog->anchored_substr),
 601                           PL_colors[1], (SvTAIL(prog->anchored_substr) ? "$" : "")));
 602                 if (!s) {
 603                     if (last1 >= last2) {
 604                         DEBUG_r(PerlIO_printf(Perl_debug_log,
 605                                                 ", giving up...\n"));
 606                         goto fail_finish;
 607                     }
 608                     DEBUG_r(PerlIO_printf(Perl_debug_log,
 609                         ", trying floating at offset %ld...\n",
 610                         (long)(HOP3c(s1, 1, strend) - i_strpos)));
 611                     other_last = HOP3c(last1, prog->anchored_offset+1, strend);
 612                     s = HOP3c(last, 1, strend);
 613                     goto restart;
 614                 }
 615                 else {
 616                     DEBUG_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
 617                           (long)(s - i_strpos)));
 618                     t = HOP3c(s, -prog->anchored_offset, strbeg);
 619                     other_last = HOP3c(s, 1, strend);
 620                     s = s1;
 621                     if (t == strpos)
 622                         goto try_at_start;
 623                     goto try_at_offset;
 624                 }
 625             }
 626         }
 627         else {          /* Take into account the floating substring. */
 628                 char *last, *last1;
 629                 char *s1 = s;
 630
 631                 t = HOP3c(s, -start_shift, strbeg);
 632                 last1 = last =
 633                     HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
 634                 if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
 635                     last = HOP3c(t, prog->float_max_offset, strend);
 636                 s = HOP3c(t, prog->float_min_offset, strend);
 637                 if (s < other_last)
 638                     s = other_last;
 639  /* XXXX It is not documented what units *_offsets are in.  Assume bytes.  */
 640                 /* fbm_instr() takes into account exact value of end-of-str
 641                    if the check is SvTAIL(ed).  Since false positives are OK,
 642                    and end-of-str is not later than strend we are OK. */
 643                 s = fbm_instr((unsigned char*)s,
 644                               (unsigned char*)last + SvCUR(prog->float_substr)
 645                                   - (SvTAIL(prog->float_substr)!=0),
 646                               prog->float_substr, PL_multiline ? FBMrf_MULTILINE : 0);
 647                 DEBUG_r(PerlIO_printf(Perl_debug_log, "%s floating substr `%s%.*s%s'%s",
 648                         (s ? "Found" : "Contradicts"),
 649                         PL_colors[0],
 650                           (int)(SvCUR(prog->float_substr)
 651                           - (SvTAIL(prog->float_substr)!=0)),
 652                           SvPVX(prog->float_substr),
 653                           PL_colors[1], (SvTAIL(prog->float_substr) ? "$" : "")));
 654                 if (!s) {
 655                     if (last1 == last) {
 656                         DEBUG_r(PerlIO_printf(Perl_debug_log,
 657                                                 ", giving up...\n"));
 658                         goto fail_finish;
 659                     }
 660                     DEBUG_r(PerlIO_printf(Perl_debug_log,
 661                         ", trying anchored starting at offset %ld...\n",
 662                         (long)(s1 + 1 - i_strpos)));
 663                     other_last = last;
 664                     s = HOP3c(t, 1, strend);
 665                     goto restart;
 666                 }
 667                 else {
 668                     DEBUG_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
 669                           (long)(s - i_strpos)));
 670                     other_last = s; /* Fix this later. --Hugo */
 671                     s = s1;
 672                     if (t == strpos)
 673                         goto try_at_start;
 674                     goto try_at_offset;
 675                 }
 676         }
 677     }
 678
 679     t = s - prog->check_offset_max;
 680     if (s - strpos > prog->check_offset_max  /* signed-corrected t > strpos */
 681         && (!(prog->reganch & ROPT_UTF8)
 682             || ((t = reghopmaybe3_c(s, -prog->check_offset_max, strpos))
 683                  && t > strpos))) {
 684         /* Fixed substring is found far enough so that the match
 685            cannot start at strpos. */
 686       try_at_offset:
 687         if (ml_anch && t[-1] != '\n') {
 688             /* Eventually fbm_*() should handle this, but often
 689                anchored_offset is not 0, so this check will not be wasted. */
 690             /* XXXX In the code below we prefer to look for "^" even in
 691                presence of anchored substrings.  And we search even
 692                beyond the found float position.  These pessimizations
 693                are historical artefacts only.  */
 694           find_anchor:
 695             while (t < strend - prog->minlen) {
 696                 if (*t == '\n') {
 697                     if (t < check_at - prog->check_offset_min) {
 698                         if (prog->anchored_substr) {
 699                             /* Since we moved from the found position,
 700                                we definitely contradict the found anchored
 701                                substr.  Due to the above check we do not
 702                                contradict "check" substr.
 703                                Thus we can arrive here only if check substr
 704                                is float.  Redo checking for "other"=="fixed".
 705                              */
 706                             strpos = t + 1;
 707                             DEBUG_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
 708                                 PL_colors[0],PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
 709                             goto do_other_anchored;
 710                         }
 711                         /* We don't contradict the found floating substring. */
 712                         /* XXXX Why not check for STCLASS? */
 713                         s = t + 1;
 714                         DEBUG_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
 715                             PL_colors[0],PL_colors[1], (long)(s - i_strpos)));
 716                         goto set_useful;
 717                     }
 718                     /* Position contradicts check-string */
 719                     /* XXXX probably better to look for check-string
 720                        than for "\n", so one should lower the limit for t? */
 721                     DEBUG_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
 722                         PL_colors[0],PL_colors[1], (long)(t + 1 - i_strpos)));
 723                     other_last = strpos = s = t + 1;
 724                     goto restart;
 725                 }
 726                 t++;
 727             }
 728             DEBUG_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
 729                         PL_colors[0],PL_colors[1]));
 730             goto fail_finish;
 731         }
 732         else {
 733             DEBUG_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
 734                         PL_colors[0],PL_colors[1]));
 735         }
 736         s = t;
 737       set_useful:
 738         ++BmUSEFUL(prog->check_substr); /* hooray/5 */
 739     }
 740     else {
 741         /* The found string does not prohibit matching at strpos,
 742            - no optimization of calling REx engine can be performed,
 743            unless it was an MBOL and we are not after MBOL,
 744            or a future STCLASS check will fail this. */
 745       try_at_start:
 746         /* Even in this situation we may use MBOL flag if strpos is offset
 747            wrt the start of the string. */
 748         if (ml_anch && sv && !SvROK(sv) /* See prev comment on SvROK */
 749             && (strpos != strbeg) && strpos[-1] != '\n'
 750             /* May be due to an implicit anchor of m{.*foo}  */
 751             && !(prog->reganch & ROPT_IMPLICIT))
 752         {
 753             t = strpos;
 754             goto find_anchor;
 755         }
 756         DEBUG_r( if (ml_anch)
 757             PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
 758                         (long)(strpos - i_strpos), PL_colors[0],PL_colors[1]);
 759         );
 760       success_at_start:
 761         if (!(prog->reganch & ROPT_NAUGHTY)     /* XXXX If strpos moved? */
 762             && prog->check_substr               /* Could be deleted already */
 763             && --BmUSEFUL(prog->check_substr) < 0
 764             && prog->check_substr == prog->float_substr)
 765         {
 766             /* If flags & SOMETHING - do not do it many times on the same match */
 767             DEBUG_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
 768             SvREFCNT_dec(prog->check_substr);
 769             prog->check_substr = Nullsv;        /* disable */
 770             prog->float_substr = Nullsv;        /* clear */
 771             check = Nullsv;                     /* abort */
 772             s = strpos;
 773             /* XXXX This is a remnant of the old implementation.  It
 774                     looks wasteful, since now INTUIT can use many
 775                     other heuristics. */
 776             prog->reganch &= ~RE_USE_INTUIT;
 777         }
 778         else
 779             s = strpos;
 780     }
 781
 782     /* Last resort... */
 783     /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
 784     if (prog->regstclass) {
 785         /* minlen == 0 is possible if regstclass is \b or \B,
 786            and the fixed substr is ''$.
 787            Since minlen is already taken into account, s+1 is before strend;
 788            accidentally, minlen >= 1 guaranties no false positives at s + 1
 789            even for \b or \B.  But (minlen? 1 : 0) below assumes that
 790            regstclass does not come from lookahead...  */
 791         /* If regstclass takes bytelength more than 1: If charlength==1, OK.
 792            This leaves EXACTF only, which is dealt with in find_byclass().  */
 793         U8* str = (U8*)STRING(prog->regstclass);
 794         int cl_l = (PL_regkind[(U8)OP(prog->regstclass)] == EXACT
 795                     ? CHR_DIST(str+STR_LEN(prog->regstclass), str)
 796                     : 1);
 797         char *endpos = (prog->anchored_substr || ml_anch)
 798                 ? HOP3c(s, (prog->minlen ? cl_l : 0), strend)
 799                 : (prog->float_substr
 800                    ? HOP3c(HOP3c(check_at, -start_shift, strbeg),
 801                            cl_l, strend)
 802                    : strend);
 803         char *startpos = strbeg;
 804
 805         t = s;
 806         if (prog->reganch & ROPT_UTF8) {
 807             PL_regdata = prog->data;
 808             PL_bostr = startpos;
 809         }
 810         s = find_byclass(prog, prog->regstclass, s, endpos, startpos, 1);
 811         if (!s) {
 812 #ifdef DEBUGGING
 813             char *what = 0;
 814 #endif
 815             if (endpos == strend) {
 816                 DEBUG_r( PerlIO_printf(Perl_debug_log,
 817                                 "Could not match STCLASS...\n") );
 818                 goto fail;
 819             }
 820             DEBUG_r( PerlIO_printf(Perl_debug_log,
 821                                    "This position contradicts STCLASS...\n") );
 822             if ((prog->reganch & ROPT_ANCH) && !ml_anch)
 823                 goto fail;
 824             /* Contradict one of substrings */
 825             if (prog->anchored_substr) {
 826                 if (prog->anchored_substr == check) {
 827                     DEBUG_r( what = "anchored" );
 828                   hop_and_restart:
 829                     s = HOP3c(t, 1, strend);
 830                     if (s + start_shift + end_shift > strend) {
 831                         /* XXXX Should be taken into account earlier? */
 832                         DEBUG_r( PerlIO_printf(Perl_debug_log,
 833                                                "Could not match STCLASS...\n") );
 834                         goto fail;
 835                     }
 836                     if (!check)
 837                         goto giveup;
 838                     DEBUG_r( PerlIO_printf(Perl_debug_log,
 839                                 "Looking for %s substr starting at offset %ld...\n",
 840                                  what, (long)(s + start_shift - i_strpos)) );
 841                     goto restart;
 842                 }
 843                 /* Have both, check_string is floating */
 844                 if (t + start_shift >= check_at) /* Contradicts floating=check */
 845                     goto retry_floating_check;
 846                 /* Recheck anchored substring, but not floating... */
 847                 s = check_at;
 848                 if (!check)
 849                     goto giveup;
 850                 DEBUG_r( PerlIO_printf(Perl_debug_log,
 851                           "Looking for anchored substr starting at offset %ld...\n",
 852                           (long)(other_last - i_strpos)) );
 853                 goto do_other_anchored;
 854             }
 855             /* Another way we could have checked stclass at the
 856                current position only: */
 857             if (ml_anch) {
 858                 s = t = t + 1;
 859                 if (!check)
 860                     goto giveup;
 861                 DEBUG_r( PerlIO_printf(Perl_debug_log,
 862                           "Looking for /%s^%s/m starting at offset %ld...\n",
 863                           PL_colors[0],PL_colors[1], (long)(t - i_strpos)) );
 864                 goto try_at_offset;
 865             }
 866             if (!prog->float_substr)    /* Could have been deleted */
 867                 goto fail;
 868             /* Check is floating subtring. */
 869           retry_floating_check:
 870             t = check_at - start_shift;
 871             DEBUG_r( what = "floating" );
 872             goto hop_and_restart;
 873         }
 874         if (t != s) {
 875             DEBUG_r(PerlIO_printf(Perl_debug_log,
 876                         "By STCLASS: moving %ld --> %ld\n",
 877                                   (long)(t - i_strpos), (long)(s - i_strpos))
 878                    );
 879         }
 880         else {
 881             DEBUG_r(PerlIO_printf(Perl_debug_log,
 882                                   "Does not contradict STCLASS...\n");
 883                    );
 884         }
 885     }
 886   giveup:
 887     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
 888                           PL_colors[4], (check ? "Guessed" : "Giving up"),
 889                           PL_colors[5], (long)(s - i_strpos)) );
 890     return s;
 891
 892   fail_finish:                          /* Substring not found */
 893     if (prog->check_substr)             /* could be removed already */
 894         BmUSEFUL(prog->check_substr) += 5; /* hooray */
 895   fail:
 896     DEBUG_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
 897                           PL_colors[4],PL_colors[5]));
 898     return Nullch;
 899 }
 900
 901 /* We know what class REx starts with.  Try to find this position... */
 902 STATIC char *
 903 S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *startpos, I32 norun)
 904 {
 905         I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
 906         char *m;
 907         STRLEN ln;
 908         unsigned int c1;
 909         unsigned int c2;
 910         char *e;
 911         register I32 tmp = 1;   /* Scratch variable? */
 912         register bool do_utf8 = PL_reg_match_utf8;
 913
 914         /* We know what class it must start with. */
 915         switch (OP(c)) {
 916         case ANYOF:
 917             while (s < strend) {
 918                 if (reginclass(c, (U8*)s, do_utf8)) {
 919                     if (tmp && (norun || regtry(prog, s)))
 920                         goto got_it;
 921                     else
 922                         tmp = doevery;
 923                 }
 924                 else
 925                     tmp = 1;
 926                 s += do_utf8 ? UTF8SKIP(s) : 1;
 927             }
 928             break;
 929         case CANY:
 930             while (s < strend) {
 931                 if (tmp && (norun || regtry(prog, s)))
 932                     goto got_it;
 933                 else
 934                     tmp = doevery;
 935                 s++;
 936             }
 937             break;
 938         case EXACTF:
 939             m = STRING(c);
 940             ln = STR_LEN(c);
 941             if (UTF) {
 942                 STRLEN ulen1, ulen2;
 943                 U8 tmpbuf1[UTF8_MAXLEN_UCLC+1];
 944                 U8 tmpbuf2[UTF8_MAXLEN_UCLC+1];
 945
 946                 to_utf8_lower((U8*)m, tmpbuf1, &ulen1);
 947                 to_utf8_upper((U8*)m, tmpbuf2, &ulen2);
 948
 949                 c1 = utf8_to_uvuni(tmpbuf1, 0);
 950                 c2 = utf8_to_uvuni(tmpbuf2, 0);
 951             }
 952             else {
 953                 c1 = *(U8*)m;
 954                 c2 = PL_fold[c1];
 955             }
 956             goto do_exactf;
 957         case EXACTFL:
 958             m = STRING(c);
 959             ln = STR_LEN(c);
 960             c1 = *(U8*)m;
 961             c2 = PL_fold_locale[c1];
 962           do_exactf:
 963             e = do_utf8 ? s + ln - 1 : strend - ln;
 964
 965             if (norun && e < s)
 966                 e = s;                  /* Due to minlen logic of intuit() */
 967
 968             /* The idea in the EXACTF* cases is to first find the
 969              * first character of the EXACTF* node and then, if
 970              * necessary, case-insensitively compare the full
 971              * text of the node.  The c1 and c2 are the first
 972              * characters (though in Unicode it gets a bit
 973              * more complicated because there are more cases
 974              * than just upper and lower: one is really supposed
 975              * to use the so-called folding case for case-insensitive
 976              * matching (called "loose matching" in Unicode).  */
 977
 978             if (do_utf8) {
 979                 UV c, f;
 980                 U8 tmpbuf [UTF8_MAXLEN+1];
 981                 U8 foldbuf[UTF8_MAXLEN_FOLD+1];
 982                 STRLEN len, foldlen;
 983
 984                 /* The ibcmp_utf8() uses to_uni_fold() which is more
 985                  * correct folding for Unicode than using lowercase.
 986                  * However, it doesn't work quite fully since the folding
 987                  * is a one-to-many mapping and the regex optimizer is
 988                  * unaware of this, so it may throw out good matches.
 989                  * Fortunately, not getting this right is allowed
 990                  * for Unicode Regular Expression Support level 1,
 991                  * only one-to-one matching is required. --jhi */
 992
 993                 if (c1 == c2) {
 994                     while (s <= e) {
 995                         c = utf8_to_uvchr((U8*)s, &len);
 996                         if ( c == c1
 997                              && (ln == len ||
 998                                  !ibcmp_utf8(s, do_utf8,
 999                                              strend - s > ln ? ln : strend - s,
1000                                              m, UTF, ln))
1001                              && (norun || regtry(prog, s)) )
1002                             goto got_it;
1003                         else {
1004                              uvchr_to_utf8(tmpbuf, c);
1005                              f = to_utf8_fold(tmpbuf, foldbuf, &foldlen);
1006                              if ( f != c
1007                                   && (f == c1 || f == c2)
1008                                   && (ln == foldlen ||
1009                                       !ibcmp_utf8((char *)foldbuf,
1010                                                   do_utf8,
1011                                                   foldlen > ln ? ln : foldlen,
1012                                                   m, UTF, ln))
1013                                   && (norun || regtry(prog, s)) )
1014                                   goto got_it;
1015                         }
1016                         s += len;
1017                     }
1018                 }
1019                 else {
1020                     while (s <= e) {
1021                         c = utf8_to_uvchr((U8*)s, &len);
1022
1023                         /* Handle some of the three Greek sigmas cases.
1024                           * Note that not all the possible combinations
1025                           * are handled here: some of them are handled
1026                           * handled by the standard folding rules, and
1027                           * some of them (the character class or ANYOF
1028                           * cases) are handled during compiletime in
1029                           * regexec.c:S_regclass(). */
1030                         if (c == (UV)UNICODE_GREEK_CAPITAL_LETTER_SIGMA ||
1031                             c == (UV)UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA)
1032                             c = (UV)UNICODE_GREEK_SMALL_LETTER_SIGMA;
1033
1034                         if ( (c == c1 || c == c2)
1035                              && (ln == len ||
1036                                  !ibcmp_utf8(s, do_utf8,
1037                                              strend - s > ln ? ln : strend - s,
1038                                              m, UTF, ln))
1039                              && (norun || regtry(prog, s)) )
1040                             goto got_it;
1041                         else {
1042                              uvchr_to_utf8(tmpbuf, c);
1043                              f = to_utf8_fold(tmpbuf, foldbuf, &foldlen);
1044                              if ( f != c
1045                                   && (f == c1 || f == c2)
1046                                   && (ln == foldlen ||
1047                                       !ibcmp_utf8((char *)foldbuf,
1048                                                   do_utf8,
1049                                                   foldlen > ln ? ln : foldlen,
1050                                                   m, UTF, ln))
1051                                   && (norun || regtry(prog, s)) )
1052                                   goto got_it;
1053                         }
1054                         s += len;
1055                     }
1056                 }
1057             }
1058             else {
1059                 if (c1 == c2)
1060                     while (s <= e) {
1061                         if ( *(U8*)s == c1
1062                              && (ln == 1 || !(OP(c) == EXACTF
1063                                               ? ibcmp(s, m, ln)
1064                                               : ibcmp_locale(s, m, ln)))
1065                              && (norun || regtry(prog, s)) )
1066                             goto got_it;
1067                         s++;
1068                     }
1069                 else
1070                     while (s <= e) {
1071                         if ( (*(U8*)s == c1 || *(U8*)s == c2)
1072                              && (ln == 1 || !(OP(c) == EXACTF
1073                                               ? ibcmp(s, m, ln)
1074                                               : ibcmp_locale(s, m, ln)))
1075                              && (norun || regtry(prog, s)) )
1076                             goto got_it;
1077                         s++;
1078                     }
1079             }
1080             break;
1081         case BOUNDL:
1082             PL_reg_flags |= RF_tainted;
1083             /* FALL THROUGH */
1084         case BOUND:
1085             if (do_utf8) {
1086                 if (s == PL_bostr)
1087                     tmp = '\n';
1088                 else {
1089                     U8 *r = reghop3((U8*)s, -1, (U8*)startpos);
1090
1091                     if (s > (char*)r)
1092                         tmp = (I32)utf8n_to_uvchr(r, s - (char*)r, 0, 0);
1093                 }
1094                 tmp = ((OP(c) == BOUND ?
1095                         isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
1096                 LOAD_UTF8_CHARCLASS(alnum,"a");
1097                 while (s < strend) {
1098                     if (tmp == !(OP(c) == BOUND ?
1099                                  swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8) :
1100                                  isALNUM_LC_utf8((U8*)s)))
1101                     {
1102                         tmp = !tmp;
1103                         if ((norun || regtry(prog, s)))
1104                             goto got_it;
1105                     }
1106                     s += UTF8SKIP(s);
1107                 }
1108             }
1109             else {
1110                 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';
1111                 tmp = ((OP(c) == BOUND ? isALNUM(tmp) : isALNUM_LC(tmp)) != 0);
1112                 while (s < strend) {
1113                     if (tmp ==
1114                         !(OP(c) == BOUND ? isALNUM(*s) : isALNUM_LC(*s))) {
1115                         tmp = !tmp;
1116                         if ((norun || regtry(prog, s)))
1117                             goto got_it;
1118                     }
1119                     s++;
1120                 }
1121             }
1122             if ((!prog->minlen && tmp) && (norun || regtry(prog, s)))
1123                 goto got_it;
1124             break;
1125         case NBOUNDL:
1126             PL_reg_flags |= RF_tainted;
1127             /* FALL THROUGH */
1128         case NBOUND:
1129             if (do_utf8) {
1130                 if (s == PL_bostr)
1131                     tmp = '\n';
1132                 else {
1133                     U8 *r = reghop3((U8*)s, -1, (U8*)startpos);
1134
1135                     if (s > (char*)r)
1136                         tmp = (I32)utf8n_to_uvchr(r, s - (char*)r, 0, 0);
1137                 }
1138                 tmp = ((OP(c) == NBOUND ?
1139                         isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
1140                 LOAD_UTF8_CHARCLASS(alnum,"a");
1141                 while (s < strend) {
1142                     if (tmp == !(OP(c) == NBOUND ?
1143                                  swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8) :
1144                                  isALNUM_LC_utf8((U8*)s)))
1145                         tmp = !tmp;
1146                     else if ((norun || regtry(prog, s)))
1147                         goto got_it;
1148                     s += UTF8SKIP(s);
1149                 }
1150             }
1151             else {
1152                 tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';
1153                 tmp = ((OP(c) == NBOUND ?
1154                         isALNUM(tmp) : isALNUM_LC(tmp)) != 0);
1155                 while (s < strend) {
1156                     if (tmp ==
1157                         !(OP(c) == NBOUND ? isALNUM(*s) : isALNUM_LC(*s)))
1158                         tmp = !tmp;
1159                     else if ((norun || regtry(prog, s)))
1160                         goto got_it;
1161                     s++;
1162                 }
1163             }
1164             if ((!prog->minlen && !tmp) && (norun || regtry(prog, s)))
1165                 goto got_it;
1166             break;
1167         case ALNUM:
1168             if (do_utf8) {
1169                 LOAD_UTF8_CHARCLASS(alnum,"a");
1170                 while (s < strend) {
1171                     if (swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8)) {
1172                         if (tmp && (norun || regtry(prog, s)))
1173                             goto got_it;
1174                         else
1175                             tmp = doevery;
1176                     }
1177                     else
1178                         tmp = 1;
1179                     s += UTF8SKIP(s);
1180                 }
1181             }
1182             else {
1183                 while (s < strend) {
1184                     if (isALNUM(*s)) {
1185                         if (tmp && (norun || regtry(prog, s)))
1186                             goto got_it;
1187                         else
1188                             tmp = doevery;
1189                     }
1190                     else
1191                         tmp = 1;
1192                     s++;
1193                 }
1194             }
1195             break;
1196         case ALNUML:
1197             PL_reg_flags |= RF_tainted;
1198             if (do_utf8) {
1199                 while (s < strend) {
1200                     if (isALNUM_LC_utf8((U8*)s)) {
1201                         if (tmp && (norun || regtry(prog, s)))
1202                             goto got_it;
1203                         else
1204                             tmp = doevery;
1205                     }
1206                     else
1207                         tmp = 1;
1208                     s += UTF8SKIP(s);
1209                 }
1210             }
1211             else {
1212                 while (s < strend) {
1213                     if (isALNUM_LC(*s)) {
1214                         if (tmp && (norun || regtry(prog, s)))
1215                             goto got_it;
1216                         else
1217                             tmp = doevery;
1218                     }
1219                     else
1220                         tmp = 1;
1221                     s++;
1222                 }
1223             }
1224             break;
1225         case NALNUM:
1226             if (do_utf8) {
1227                 LOAD_UTF8_CHARCLASS(alnum,"a");
1228                 while (s < strend) {
1229                     if (!swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8)) {
1230                         if (tmp && (norun || regtry(prog, s)))
1231                             goto got_it;
1232                         else
1233                             tmp = doevery;
1234                     }
1235                     else
1236                         tmp = 1;
1237                     s += UTF8SKIP(s);
1238                 }
1239             }
1240             else {
1241                 while (s < strend) {
1242                     if (!isALNUM(*s)) {
1243                         if (tmp && (norun || regtry(prog, s)))
1244                             goto got_it;
1245                         else
1246                             tmp = doevery;
1247                     }
1248                     else
1249                         tmp = 1;
1250                     s++;
1251                 }
1252             }
1253             break;
1254         case NALNUML:
1255             PL_reg_flags |= RF_tainted;
1256             if (do_utf8) {
1257                 while (s < strend) {
1258                     if (!isALNUM_LC_utf8((U8*)s)) {
1259                         if (tmp && (norun || regtry(prog, s)))
1260                             goto got_it;
1261                         else
1262                             tmp = doevery;
1263                     }
1264                     else
1265                         tmp = 1;
1266                     s += UTF8SKIP(s);
1267                 }
1268             }
1269             else {
1270                 while (s < strend) {
1271                     if (!isALNUM_LC(*s)) {
1272                         if (tmp && (norun || regtry(prog, s)))
1273                             goto got_it;
1274                         else
1275                             tmp = doevery;
1276                     }
1277                     else
1278                         tmp = 1;
1279                     s++;
1280                 }
1281             }
1282             break;
1283         case SPACE:
1284             if (do_utf8) {
1285                 LOAD_UTF8_CHARCLASS(space," ");
1286                 while (s < strend) {
1287                     if (*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, do_utf8)) {
1288                         if (tmp && (norun || regtry(prog, s)))
1289                             goto got_it;
1290                         else
1291                             tmp = doevery;
1292                     }
1293                     else
1294                         tmp = 1;
1295                     s += UTF8SKIP(s);
1296                 }
1297             }
1298             else {
1299                 while (s < strend) {
1300                     if (isSPACE(*s)) {
1301                         if (tmp && (norun || regtry(prog, s)))
1302                             goto got_it;
1303                         else
1304                             tmp = doevery;
1305                     }
1306                     else
1307                         tmp = 1;
1308                     s++;
1309                 }
1310             }
1311             break;
1312         case SPACEL:
1313             PL_reg_flags |= RF_tainted;
1314             if (do_utf8) {
1315                 while (s < strend) {
1316                     if (*s == ' ' || isSPACE_LC_utf8((U8*)s)) {
1317                         if (tmp && (norun || regtry(prog, s)))
1318                             goto got_it;
1319                         else
1320                             tmp = doevery;
1321                     }
1322                     else
1323                         tmp = 1;
1324                     s += UTF8SKIP(s);
1325                 }
1326             }
1327             else {
1328                 while (s < strend) {
1329                     if (isSPACE_LC(*s)) {
1330                         if (tmp && (norun || regtry(prog, s)))
1331                             goto got_it;
1332                         else
1333                             tmp = doevery;
1334                     }
1335                     else
1336                         tmp = 1;
1337                     s++;
1338                 }
1339             }
1340             break;
1341         case NSPACE:
1342             if (do_utf8) {
1343                 LOAD_UTF8_CHARCLASS(space," ");
1344                 while (s < strend) {
1345                     if (!(*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, do_utf8))) {
1346                         if (tmp && (norun || regtry(prog, s)))
1347                             goto got_it;
1348                         else
1349                             tmp = doevery;
1350                     }
1351                     else
1352                         tmp = 1;
1353                     s += UTF8SKIP(s);
1354                 }
1355             }
1356             else {
1357                 while (s < strend) {
1358                     if (!isSPACE(*s)) {
1359                         if (tmp && (norun || regtry(prog, s)))
1360                             goto got_it;
1361                         else
1362                             tmp = doevery;
1363                     }
1364                     else
1365                         tmp = 1;
1366                     s++;
1367                 }
1368             }
1369             break;
1370         case NSPACEL:
1371             PL_reg_flags |= RF_tainted;
1372             if (do_utf8) {
1373                 while (s < strend) {
1374                     if (!(*s == ' ' || isSPACE_LC_utf8((U8*)s))) {
1375                         if (tmp && (norun || regtry(prog, s)))
1376                             goto got_it;
1377                         else
1378                             tmp = doevery;
1379                     }
1380                     else
1381                         tmp = 1;
1382                     s += UTF8SKIP(s);
1383                 }
1384             }
1385             else {
1386                 while (s < strend) {
1387                     if (!isSPACE_LC(*s)) {
1388                         if (tmp && (norun || regtry(prog, s)))
1389                             goto got_it;
1390                         else
1391                             tmp = doevery;
1392                     }
1393                     else
1394                         tmp = 1;
1395                     s++;
1396                 }
1397             }
1398             break;
1399         case DIGIT:
1400             if (do_utf8) {
1401                 LOAD_UTF8_CHARCLASS(digit,"0");
1402                 while (s < strend) {
1403                     if (swash_fetch(PL_utf8_digit,(U8*)s, do_utf8)) {
1404                         if (tmp && (norun || regtry(prog, s)))
1405                             goto got_it;
1406                         else
1407                             tmp = doevery;
1408                     }
1409                     else
1410                         tmp = 1;
1411                     s += UTF8SKIP(s);
1412                 }
1413             }
1414             else {
1415                 while (s < strend) {
1416                     if (isDIGIT(*s)) {
1417                         if (tmp && (norun || regtry(prog, s)))
1418                             goto got_it;
1419                         else
1420                             tmp = doevery;
1421                     }
1422                     else
1423                         tmp = 1;
1424                     s++;
1425                 }
1426             }
1427             break;
1428         case DIGITL:
1429             PL_reg_flags |= RF_tainted;
1430             if (do_utf8) {
1431                 while (s < strend) {
1432                     if (isDIGIT_LC_utf8((U8*)s)) {
1433                         if (tmp && (norun || regtry(prog, s)))
1434                             goto got_it;
1435                         else
1436                             tmp = doevery;
1437                     }
1438                     else
1439                         tmp = 1;
1440                     s += UTF8SKIP(s);
1441                 }
1442             }
1443             else {
1444                 while (s < strend) {
1445                     if (isDIGIT_LC(*s)) {
1446                         if (tmp && (norun || regtry(prog, s)))
1447                             goto got_it;
1448                         else
1449                             tmp = doevery;
1450                     }
1451                     else
1452                         tmp = 1;
1453                     s++;
1454                 }
1455             }
1456             break;
1457         case NDIGIT:
1458             if (do_utf8) {
1459                 LOAD_UTF8_CHARCLASS(digit,"0");
1460                 while (s < strend) {
1461                     if (!swash_fetch(PL_utf8_digit,(U8*)s, do_utf8)) {
1462                         if (tmp && (norun || regtry(prog, s)))
1463                             goto got_it;
1464                         else
1465                             tmp = doevery;
1466                     }
1467                     else
1468                         tmp = 1;
1469                     s += UTF8SKIP(s);
1470                 }
1471             }
1472             else {
1473                 while (s < strend) {
1474                     if (!isDIGIT(*s)) {
1475                         if (tmp && (norun || regtry(prog, s)))
1476                             goto got_it;
1477                         else
1478                             tmp = doevery;
1479                     }
1480                     else
1481                         tmp = 1;
1482                     s++;
1483                 }
1484             }
1485             break;
1486         case NDIGITL:
1487             PL_reg_flags |= RF_tainted;
1488             if (do_utf8) {
1489                 while (s < strend) {
1490                     if (!isDIGIT_LC_utf8((U8*)s)) {
1491                         if (tmp && (norun || regtry(prog, s)))
1492                             goto got_it;
1493                         else
1494                             tmp = doevery;
1495                     }
1496                     else
1497                         tmp = 1;
1498                     s += UTF8SKIP(s);
1499                 }
1500             }
1501             else {
1502                 while (s < strend) {
1503                     if (!isDIGIT_LC(*s)) {
1504                         if (tmp && (norun || regtry(prog, s)))
1505                             goto got_it;
1506                         else
1507                             tmp = doevery;
1508                     }
1509                     else
1510                         tmp = 1;
1511                     s++;
1512                 }
1513             }
1514             break;
1515         default:
1516             Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
1517             break;
1518         }
1519         return 0;
1520       got_it:
1521         return s;
1522 }
1523
1524 /*
1525  - regexec_flags - match a regexp against a string
1526  */
1527 I32
1528 Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *strend,
1529               char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
1530 /* strend: pointer to null at end of string */
1531 /* strbeg: real beginning of string */
1532 /* minend: end of match must be >=minend after stringarg. */
1533 /* data: May be used for some additional optimizations. */
1534 /* nosave: For optimizations. */
1535 {
1536     register char *s;
1537     register regnode *c;
1538     register char *startpos = stringarg;
1539     I32 minlen;         /* must match at least this many chars */
1540     I32 dontbother = 0; /* how many characters not to try at end */
1541     /* I32 start_shift = 0; */          /* Offset of the start to find
1542                                          constant substr. */            /* CC */
1543     I32 end_shift = 0;                  /* Same for the end. */         /* CC */
1544     I32 scream_pos = -1;                /* Internal iterator of scream. */
1545     char *scream_olds;
1546     SV* oreplsv = GvSV(PL_replgv);
1547     bool do_utf8 = DO_UTF8(sv);
1548 #ifdef DEBUGGING
1549     SV *dsv = PERL_DEBUG_PAD_ZERO(0);
1550 #endif
1551
1552     PL_regcc = 0;
1553
1554     cache_re(prog);
1555 #ifdef DEBUGGING
1556     PL_regnarrate = DEBUG_r_TEST;
1557 #endif
1558
1559     /* Be paranoid... */
1560     if (prog == NULL || startpos == NULL) {
1561         Perl_croak(aTHX_ "NULL regexp parameter");
1562         return 0;
1563     }
1564
1565     minlen = prog->minlen;
1566     if (strend - startpos < minlen) {
1567         DEBUG_r(PerlIO_printf(Perl_debug_log,
1568                               "String too short [regexec_flags]...\n"));
1569         goto phooey;
1570     }
1571
1572     /* Check validity of program. */
1573     if (UCHARAT(prog->program) != REG_MAGIC) {
1574         Perl_croak(aTHX_ "corrupted regexp program");
1575     }
1576
1577     PL_reg_flags = 0;
1578     PL_reg_eval_set = 0;
1579     PL_reg_maxiter = 0;
1580
1581     if (prog->reganch & ROPT_UTF8)
1582         PL_reg_flags |= RF_utf8;
1583
1584     /* Mark beginning of line for ^ and lookbehind. */
1585     PL_regbol = startpos;
1586     PL_bostr  = strbeg;
1587     PL_reg_sv = sv;
1588
1589     /* Mark end of line for $ (and such) */
1590     PL_regeol = strend;
1591
1592     /* see how far we have to get to not match where we matched before */
1593     PL_regtill = startpos+minend;
1594
1595     /* We start without call_cc context.  */
1596     PL_reg_call_cc = 0;
1597
1598     /* If there is a "must appear" string, look for it. */
1599     s = startpos;
1600
1601     if (prog->reganch & ROPT_GPOS_SEEN) { /* Need to have PL_reg_ganch */
1602         MAGIC *mg;
1603
1604         if (flags & REXEC_IGNOREPOS)    /* Means: check only at start */
1605             PL_reg_ganch = startpos;
1606         else if (sv && SvTYPE(sv) >= SVt_PVMG
1607                   && SvMAGIC(sv)
1608                   && (mg = mg_find(sv, PERL_MAGIC_regex_global))
1609                   && mg->mg_len >= 0) {
1610             PL_reg_ganch = strbeg + mg->mg_len; /* Defined pos() */
1611             if (prog->reganch & ROPT_ANCH_GPOS) {
1612                 if (s > PL_reg_ganch)
1613                     goto phooey;
1614                 s = PL_reg_ganch;
1615             }
1616         }
1617         else                            /* pos() not defined */
1618             PL_reg_ganch = strbeg;
1619     }
1620
1621     if (do_utf8 == (UTF!=0) &&
1622         !(flags & REXEC_CHECKED) && prog->check_substr != Nullsv) {
1623         re_scream_pos_data d;
1624
1625         d.scream_olds = &scream_olds;
1626         d.scream_pos = &scream_pos;
1627         s = re_intuit_start(prog, sv, s, strend, flags, &d);
1628         if (!s) {
1629             DEBUG_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
1630             goto phooey;        /* not present */
1631         }
1632     }
1633
1634     DEBUG_r({
1635          char *s   = do_utf8 ? sv_uni_display(dsv, sv, 60, 0) : startpos;
1636          int   len = do_utf8 ? strlen(s) : strend - startpos;
1637          if (!PL_colorset)
1638              reginitcolors();
1639          PerlIO_printf(Perl_debug_log,
1640                        "%sMatching REx%s `%s%.60s%s%s' against `%s%.*s%s%s'\n",
1641                        PL_colors[4],PL_colors[5],PL_colors[0],
1642                        prog->precomp,
1643                        PL_colors[1],
1644                        (strlen(prog->precomp) > 60 ? "..." : ""),
1645                        PL_colors[0],
1646                        (int)(len > 60 ? 60 : len),
1647                        s, PL_colors[1],
1648                        (len > 60 ? "..." : "")
1649               );
1650     });
1651
1652     /* Simplest case:  anchored match need be tried only once. */
1653     /*  [unless only anchor is BOL and multiline is set] */
1654     if (prog->reganch & (ROPT_ANCH & ~ROPT_ANCH_GPOS)) {
1655         if (s == startpos && regtry(prog, startpos))
1656             goto got_it;
1657         else if (PL_multiline || (prog->reganch & ROPT_IMPLICIT)
1658                  || (prog->reganch & ROPT_ANCH_MBOL)) /* XXXX SBOL? */
1659         {
1660             char *end;
1661
1662             if (minlen)
1663                 dontbother = minlen - 1;
1664             end = HOP3c(strend, -dontbother, strbeg) - 1;
1665             /* for multiline we only have to try after newlines */
1666             if (prog->check_substr) {
1667                 if (s == startpos)
1668                     goto after_try;
1669                 while (1) {
1670                     if (regtry(prog, s))
1671                         goto got_it;
1672                   after_try:
1673                     if (s >= end)
1674                         goto phooey;
1675                     if (prog->reganch & RE_USE_INTUIT) {
1676                         s = re_intuit_start(prog, sv, s + 1, strend, flags, NULL);
1677                         if (!s)
1678                             goto phooey;
1679                     }
1680                     else
1681                         s++;
1682                 }
1683             } else {
1684                 if (s > startpos)
1685                     s--;
1686                 while (s < end) {
1687                     if (*s++ == '\n') { /* don't need PL_utf8skip here */
1688                         if (regtry(prog, s))
1689                             goto got_it;
1690                     }
1691                 }
1692             }
1693         }
1694         goto phooey;
1695     } else if (prog->reganch & ROPT_ANCH_GPOS) {
1696         if (regtry(prog, PL_reg_ganch))
1697             goto got_it;
1698         goto phooey;
1699     }
1700
1701     /* Messy cases:  unanchored match. */
1702     if (prog->anchored_substr && prog->reganch & ROPT_SKIP) {
1703         /* we have /x+whatever/ */
1704         /* it must be a one character string (XXXX Except UTF?) */
1705         char ch = SvPVX(prog->anchored_substr)[0];
1706 #ifdef DEBUGGING
1707         int did_match = 0;
1708 #endif
1709
1710         if (do_utf8) {
1711             while (s < strend) {
1712                 if (*s == ch) {
1713                     DEBUG_r( did_match = 1 );
1714                     if (regtry(prog, s)) goto got_it;
1715                     s += UTF8SKIP(s);
1716                     while (s < strend && *s == ch)
1717                         s += UTF8SKIP(s);
1718                 }
1719                 s += UTF8SKIP(s);
1720             }
1721         }
1722         else {
1723             while (s < strend) {
1724                 if (*s == ch) {
1725                     DEBUG_r( did_match = 1 );
1726                     if (regtry(prog, s)) goto got_it;
1727                     s++;
1728                     while (s < strend && *s == ch)
1729                         s++;
1730                 }
1731                 s++;
1732             }
1733         }
1734         DEBUG_r(if (!did_match)
1735                 PerlIO_printf(Perl_debug_log,
1736                                   "Did not find anchored character...\n")
1737                );
1738     }
1739     /*SUPPRESS 560*/
1740     else if (do_utf8 == (UTF!=0) &&
1741              (prog->anchored_substr != Nullsv
1742               || (prog->float_substr != Nullsv
1743                   && prog->float_max_offset < strend - s))) {
1744         SV *must = prog->anchored_substr
1745             ? prog->anchored_substr : prog->float_substr;
1746         I32 back_max =
1747             prog->anchored_substr ? prog->anchored_offset : prog->float_max_offset;
1748         I32 back_min =
1749             prog->anchored_substr ? prog->anchored_offset : prog->float_min_offset;
1750         char *last = HOP3c(strend,      /* Cannot start after this */
1751                           -(I32)(CHR_SVLEN(must)
1752                                  - (SvTAIL(must) != 0) + back_min), strbeg);
1753         char *last1;            /* Last position checked before */
1754 #ifdef DEBUGGING
1755         int did_match = 0;
1756 #endif
1757
1758         if (s > PL_bostr)
1759             last1 = HOPc(s, -1);
1760         else
1761             last1 = s - 1;      /* bogus */
1762
1763         /* XXXX check_substr already used to find `s', can optimize if
1764            check_substr==must. */
1765         scream_pos = -1;
1766         dontbother = end_shift;
1767         strend = HOPc(strend, -dontbother);
1768         while ( (s <= last) &&
1769                 ((flags & REXEC_SCREAM)
1770                  ? (s = screaminstr(sv, must, HOP3c(s, back_min, strend) - strbeg,
1771                                     end_shift, &scream_pos, 0))
1772                  : (s = fbm_instr((unsigned char*)HOP3(s, back_min, strend),
1773                                   (unsigned char*)strend, must,
1774                                   PL_multiline ? FBMrf_MULTILINE : 0))) ) {
1775             DEBUG_r( did_match = 1 );
1776             if (HOPc(s, -back_max) > last1) {
1777                 last1 = HOPc(s, -back_min);
1778                 s = HOPc(s, -back_max);
1779             }
1780             else {
1781                 char *t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
1782
1783                 last1 = HOPc(s, -back_min);
1784                 s = t;
1785             }
1786             if (do_utf8) {
1787                 while (s <= last1) {
1788                     if (regtry(prog, s))
1789                         goto got_it;
1790                     s += UTF8SKIP(s);
1791                 }
1792             }
1793             else {
1794                 while (s <= last1) {
1795                     if (regtry(prog, s))
1796                         goto got_it;
1797                     s++;
1798                 }
1799             }
1800         }
1801         DEBUG_r(if (!did_match)
1802                     PerlIO_printf(Perl_debug_log,
1803                                   "Did not find %s substr `%s%.*s%s'%s...\n",
1804                               ((must == prog->anchored_substr)
1805                                ? "anchored" : "floating"),
1806                               PL_colors[0],
1807                               (int)(SvCUR(must) - (SvTAIL(must)!=0)),
1808                               SvPVX(must),
1809                                   PL_colors[1], (SvTAIL(must) ? "$" : ""))
1810                );
1811         goto phooey;
1812     }
1813     else if ((c = prog->regstclass)) {
1814         if (minlen && PL_regkind[(U8)OP(prog->regstclass)] != EXACT)
1815             /* don't bother with what can't match */
1816             strend = HOPc(strend, -(minlen - 1));
1817         DEBUG_r({
1818             SV *prop = sv_newmortal();
1819             regprop(prop, c);
1820             PerlIO_printf(Perl_debug_log, "Matching stclass `%s' against `%s'\n", SvPVX(prop), UTF ? sv_uni_display(dsv, sv, 60, 0) : s);
1821         });
1822         if (find_byclass(prog, c, s, strend, startpos, 0))
1823             goto got_it;
1824         DEBUG_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass...\n"));
1825     }
1826     else {
1827         dontbother = 0;
1828         if (prog->float_substr != Nullsv) {     /* Trim the end. */
1829             char *last;
1830
1831             if (flags & REXEC_SCREAM) {
1832                 last = screaminstr(sv, prog->float_substr, s - strbeg,
1833                                    end_shift, &scream_pos, 1); /* last one */
1834                 if (!last)
1835                     last = scream_olds; /* Only one occurrence. */
1836             }
1837             else {
1838                 STRLEN len;
1839                 char *little = SvPV(prog->float_substr, len);
1840
1841                 if (SvTAIL(prog->float_substr)) {
1842                     if (memEQ(strend - len + 1, little, len - 1))
1843                         last = strend - len + 1;
1844                     else if (!PL_multiline)
1845                         last = memEQ(strend - len, little, len)
1846                             ? strend - len : Nullch;
1847                     else
1848                         goto find_last;
1849                 } else {
1850                   find_last:
1851                     if (len)
1852                         last = rninstr(s, strend, little, little + len);
1853                     else
1854                         last = strend;  /* matching `$' */
1855                 }
1856             }
1857             if (last == NULL) {
1858                 DEBUG_r(PerlIO_printf(Perl_debug_log,
1859                                       "%sCan't trim the tail, match fails (should not happen)%s\n",
1860                                       PL_colors[4],PL_colors[5]));
1861                 goto phooey; /* Should not happen! */
1862             }
1863             dontbother = strend - last + prog->float_min_offset;
1864         }
1865         if (minlen && (dontbother < minlen))
1866             dontbother = minlen - 1;
1867         strend -= dontbother;              /* this one's always in bytes! */
1868         /* We don't know much -- general case. */
1869         if (do_utf8) {
1870             for (;;) {
1871                 if (regtry(prog, s))
1872                     goto got_it;
1873                 if (s >= strend)
1874                     break;
1875                 s += UTF8SKIP(s);
1876             };
1877         }
1878         else {
1879             do {
1880                 if (regtry(prog, s))
1881                     goto got_it;
1882             } while (s++ < strend);
1883         }
1884     }
1885
1886     /* Failure. */
1887     goto phooey;
1888
1889 got_it:
1890     RX_MATCH_TAINTED_set(prog, PL_reg_flags & RF_tainted);
1891
1892     if (PL_reg_eval_set) {
1893         /* Preserve the current value of $^R */
1894         if (oreplsv != GvSV(PL_replgv))
1895             sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
1896                                                   restored, the value remains
1897                                                   the same. */
1898         restore_pos(aTHX_ 0);
1899     }
1900
1901     /* make sure $`, $&, $', and $digit will work later */
1902     if ( !(flags & REXEC_NOT_FIRST) ) {
1903         if (RX_MATCH_COPIED(prog)) {
1904             Safefree(prog->subbeg);
1905             RX_MATCH_COPIED_off(prog);
1906         }
1907         if (flags & REXEC_COPY_STR) {
1908             I32 i = PL_regeol - startpos + (stringarg - strbeg);
1909
1910             s = savepvn(strbeg, i);
1911             prog->subbeg = s;
1912             prog->sublen = i;
1913             RX_MATCH_COPIED_on(prog);
1914         }
1915         else {
1916             prog->subbeg = strbeg;
1917             prog->sublen = PL_regeol - strbeg;  /* strend may have been modified */
1918         }
1919     }
1920
1921     return 1;
1922
1923 phooey:
1924     DEBUG_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
1925                           PL_colors[4],PL_colors[5]));
1926     if (PL_reg_eval_set)
1927         restore_pos(aTHX_ 0);
1928     return 0;
1929 }
1930
1931 /*
1932  - regtry - try match at specific point
1933  */
1934 STATIC I32                      /* 0 failure, 1 success */
1935 S_regtry(pTHX_ regexp *prog, char *startpos)
1936 {
1937     register I32 i;
1938     register I32 *sp;
1939     register I32 *ep;
1940     CHECKPOINT lastcp;
1941
1942 #ifdef DEBUGGING
1943     PL_regindent = 0;   /* XXXX Not good when matches are reenterable... */
1944 #endif
1945     if ((prog->reganch & ROPT_EVAL_SEEN) && !PL_reg_eval_set) {
1946         MAGIC *mg;
1947
1948         PL_reg_eval_set = RS_init;
1949         DEBUG_r(DEBUG_s(
1950             PerlIO_printf(Perl_debug_log, "  setting stack tmpbase at %"IVdf"\n",
1951                           (IV)(PL_stack_sp - PL_stack_base));
1952             ));
1953         SAVEI32(cxstack[cxstack_ix].blk_oldsp);
1954         cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
1955         /* Otherwise OP_NEXTSTATE will free whatever on stack now.  */
1956         SAVETMPS;
1957         /* Apparently this is not needed, judging by wantarray. */
1958         /* SAVEI8(cxstack[cxstack_ix].blk_gimme);
1959            cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
1960
1961         if (PL_reg_sv) {
1962             /* Make $_ available to executed code. */
1963             if (PL_reg_sv != DEFSV) {
1964                 /* SAVE_DEFSV does *not* suffice here for USE_5005THREADS */
1965                 SAVESPTR(DEFSV);
1966                 DEFSV = PL_reg_sv;
1967             }
1968
1969             if (!(SvTYPE(PL_reg_sv) >= SVt_PVMG && SvMAGIC(PL_reg_sv)
1970                   && (mg = mg_find(PL_reg_sv, PERL_MAGIC_regex_global)))) {
1971                 /* prepare for quick setting of pos */
1972                 sv_magic(PL_reg_sv, (SV*)0,
1973                         PERL_MAGIC_regex_global, Nullch, 0);
1974                 mg = mg_find(PL_reg_sv, PERL_MAGIC_regex_global);
1975                 mg->mg_len = -1;
1976             }
1977             PL_reg_magic    = mg;
1978             PL_reg_oldpos   = mg->mg_len;
1979             SAVEDESTRUCTOR_X(restore_pos, 0);
1980         }
1981         if (!PL_reg_curpm) {
1982             Newz(22,PL_reg_curpm, 1, PMOP);
1983 #ifdef USE_ITHREADS
1984             {
1985                 SV* repointer = newSViv(0);
1986                 /* so we know which PL_regex_padav element is PL_reg_curpm */
1987                 SvFLAGS(repointer) |= SVf_BREAK;
1988                 av_push(PL_regex_padav,repointer);
1989                 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
1990                 PL_regex_pad = AvARRAY(PL_regex_padav);
1991             }
1992 #endif
1993         }
1994         PM_SETRE(PL_reg_curpm, prog);
1995         PL_reg_oldcurpm = PL_curpm;
1996         PL_curpm = PL_reg_curpm;
1997         if (RX_MATCH_COPIED(prog)) {
1998             /*  Here is a serious problem: we cannot rewrite subbeg,
1999                 since it may be needed if this match fails.  Thus
2000                 $` inside (?{}) could fail... */
2001             PL_reg_oldsaved = prog->subbeg;
2002             PL_reg_oldsavedlen = prog->sublen;
2003             RX_MATCH_COPIED_off(prog);
2004         }
2005         else
2006             PL_reg_oldsaved = Nullch;
2007         prog->subbeg = PL_bostr;
2008         prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2009     }
2010     prog->startp[0] = startpos - PL_bostr;
2011     PL_reginput = startpos;
2012     PL_regstartp = prog->startp;
2013     PL_regendp = prog->endp;
2014     PL_reglastparen = &prog->lastparen;
2015     PL_reglastcloseparen = &prog->lastcloseparen;
2016     prog->lastparen = 0;
2017     PL_regsize = 0;
2018     DEBUG_r(PL_reg_starttry = startpos);
2019     if (PL_reg_start_tmpl <= prog->nparens) {
2020         PL_reg_start_tmpl = prog->nparens*3/2 + 3;
2021         if(PL_reg_start_tmp)
2022             Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2023         else
2024             New(22,PL_reg_start_tmp, PL_reg_start_tmpl, char*);
2025     }
2026
2027 #ifdef DEBUGGING
2028     sv_setpvn(PERL_DEBUG_PAD(0), "", 0);
2029     sv_setpvn(PERL_DEBUG_PAD(1), "", 0);
2030     sv_setpvn(PERL_DEBUG_PAD(2), "", 0);
2031 #endif
2032
2033     /* XXXX What this code is doing here?!!!  There should be no need
2034        to do this again and again, PL_reglastparen should take care of
2035        this!  --ilya*/
2036
2037     /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2038      * Actually, the code in regcppop() (which Ilya may be meaning by
2039      * PL_reglastparen), is not needed at all by the test suite
2040      * (op/regexp, op/pat, op/split), but that code is needed, oddly
2041      * enough, for building DynaLoader, or otherwise this
2042      * "Error: '*' not in typemap in DynaLoader.xs, line 164"
2043      * will happen.  Meanwhile, this code *is* needed for the
2044      * above-mentioned test suite tests to succeed.  The common theme
2045      * on those tests seems to be returning null fields from matches.
2046      * --jhi */
2047 #if 1
2048     sp = prog->startp;
2049     ep = prog->endp;
2050     if (prog->nparens) {
2051         for (i = prog->nparens; i > *PL_reglastparen; i--) {
2052             *++sp = -1;
2053             *++ep = -1;
2054         }
2055     }
2056 #endif
2057     REGCP_SET(lastcp);
2058     if (regmatch(prog->program + 1)) {
2059         prog->endp[0] = PL_reginput - PL_bostr;
2060         return 1;
2061     }
2062     REGCP_UNWIND(lastcp);
2063     return 0;
2064 }
2065
2066 #define RE_UNWIND_BRANCH        1
2067 #define RE_UNWIND_BRANCHJ       2
2068
2069 union re_unwind_t;
2070
2071 typedef struct {                /* XX: makes sense to enlarge it... */
2072     I32 type;
2073     I32 prev;
2074     CHECKPOINT lastcp;
2075 } re_unwind_generic_t;
2076
2077 typedef struct {
2078     I32 type;
2079     I32 prev;
2080     CHECKPOINT lastcp;
2081     I32 lastparen;
2082     regnode *next;
2083     char *locinput;
2084     I32 nextchr;
2085 #ifdef DEBUGGING
2086     int regindent;
2087 #endif
2088 } re_unwind_branch_t;
2089
2090 typedef union re_unwind_t {
2091     I32 type;
2092     re_unwind_generic_t generic;
2093     re_unwind_branch_t branch;
2094 } re_unwind_t;
2095
2096 #define sayYES goto yes
2097 #define sayNO goto no
2098 #define sayYES_FINAL goto yes_final
2099 #define sayYES_LOUD  goto yes_loud
2100 #define sayNO_FINAL  goto no_final
2101 #define sayNO_SILENT goto do_no
2102 #define saySAME(x) if (x) goto yes; else goto no
2103
2104 #define REPORT_CODE_OFF 24
2105
2106 /*
2107  - regmatch - main matching routine
2108  *
2109  * Conceptually the strategy is simple:  check to see whether the current
2110  * node matches, call self recursively to see whether the rest matches,
2111  * and then act accordingly.  In practice we make some effort to avoid
2112  * recursion, in particular by going through "ordinary" nodes (that don't
2113  * need to know whether the rest of the match failed) by a loop instead of
2114  * by recursion.
2115  */
2116 /* [lwall] I've hoisted the register declarations to the outer block in order to
2117  * maybe save a little bit of pushing and popping on the stack.  It also takes
2118  * advantage of machines that use a register save mask on subroutine entry.
2119  */
2120 STATIC I32                      /* 0 failure, 1 success */
2121 S_regmatch(pTHX_ regnode *prog)
2122 {
2123     register regnode *scan;     /* Current node. */
2124     regnode *next;              /* Next node. */
2125     regnode *inner;             /* Next node in internal branch. */
2126     register I32 nextchr;       /* renamed nextchr - nextchar colides with
2127                                    function of same name */
2128     register I32 n;             /* no or next */
2129     register I32 ln = 0;        /* len or last */
2130     register char *s = Nullch;  /* operand or save */
2131     register char *locinput = PL_reginput;
2132     register I32 c1 = 0, c2 = 0, paren; /* case fold search, parenth */
2133     int minmod = 0, sw = 0, logical = 0;
2134     I32 unwind = 0;
2135 #if 0
2136     I32 firstcp = PL_savestack_ix;
2137 #endif
2138     register bool do_utf8 = PL_reg_match_utf8;
2139 #ifdef DEBUGGING
2140     SV *dsv0 = PERL_DEBUG_PAD_ZERO(0);
2141     SV *dsv1 = PERL_DEBUG_PAD_ZERO(1);
2142     SV *dsv2 = PERL_DEBUG_PAD_ZERO(2);
2143 #endif
2144
2145 #ifdef DEBUGGING
2146     PL_regindent++;
2147 #endif
2148
2149     /* Note that nextchr is a byte even in UTF */
2150     nextchr = UCHARAT(locinput);
2151     scan = prog;
2152     while (scan != NULL) {
2153
2154         DEBUG_r( {
2155             SV *prop = sv_newmortal();
2156             int docolor = *PL_colors[0];
2157             int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
2158             int l = (PL_regeol - locinput) > taill ? taill : (PL_regeol - locinput);
2159             /* The part of the string before starttry has one color
2160                (pref0_len chars), between starttry and current
2161                position another one (pref_len - pref0_len chars),
2162                after the current position the third one.
2163                We assume that pref0_len <= pref_len, otherwise we
2164                decrease pref0_len.  */
2165             int pref_len = (locinput - PL_bostr) > (5 + taill) - l
2166                 ? (5 + taill) - l : locinput - PL_bostr;
2167             int pref0_len;
2168
2169             while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
2170                 pref_len++;
2171             pref0_len = pref_len  - (locinput - PL_reg_starttry);
2172             if (l + pref_len < (5 + taill) && l < PL_regeol - locinput)
2173                 l = ( PL_regeol - locinput > (5 + taill) - pref_len
2174                       ? (5 + taill) - pref_len : PL_regeol - locinput);
2175             while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
2176                 l--;
2177             if (pref0_len < 0)
2178                 pref0_len = 0;
2179             if (pref0_len > pref_len)
2180                 pref0_len = pref_len;
2181             regprop(prop, scan);
2182             {
2183               char *s0 =
2184                 do_utf8 ?
2185                 pv_uni_display(dsv0, (U8*)(locinput - pref_len),
2186                                pref0_len, 60, 0) :
2187                 locinput - pref_len;
2188               int len0 = do_utf8 ? strlen(s0) : pref0_len;
2189               char *s1 = do_utf8 ?
2190                 pv_uni_display(dsv1, (U8*)(locinput - pref_len + pref0_len),
2191                                pref_len - pref0_len, 60, 0) :
2192                 locinput - pref_len + pref0_len;
2193               int len1 = do_utf8 ? strlen(s1) : pref_len - pref0_len;
2194               char *s2 = do_utf8 ?
2195                 pv_uni_display(dsv2, (U8*)locinput,
2196                                PL_regeol - locinput, 60, 0) :
2197                 locinput;
2198               int len2 = do_utf8 ? strlen(s2) : l;
2199               PerlIO_printf(Perl_debug_log,
2200                             "%4"IVdf" <%s%.*s%s%s%.*s%s%s%s%.*s%s>%*s|%3"IVdf":%*s%s\n",
2201                             (IV)(locinput - PL_bostr),
2202                             PL_colors[4],
2203                             len0, s0,
2204                             PL_colors[5],
2205                             PL_colors[2],
2206                             len1, s1,
2207                             PL_colors[3],
2208                             (docolor ? "" : "> <"),
2209                             PL_colors[0],
2210                             len2, s2,
2211                             PL_colors[1],
2212                             15 - l - pref_len + 1,
2213                             "",
2214                             (IV)(scan - PL_regprogram), PL_regindent*2, "",
2215                             SvPVX(prop));
2216             }
2217         });
2218
2219         next = scan + NEXT_OFF(scan);
2220         if (next == scan)
2221             next = NULL;
2222
2223         switch (OP(scan)) {
2224         case BOL:
2225             if (locinput == PL_bostr || (PL_multiline &&
2226                 (nextchr || locinput < PL_regeol) && locinput[-1] == '\n') )
2227             {
2228                 /* regtill = regbol; */
2229                 break;
2230             }
2231             sayNO;
2232         case MBOL:
2233             if (locinput == PL_bostr ||
2234                 ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n'))
2235             {
2236                 break;
2237             }
2238             sayNO;
2239         case SBOL:
2240             if (locinput == PL_bostr)
2241                 break;
2242             sayNO;
2243         case GPOS:
2244             if (locinput == PL_reg_ganch)
2245                 break;
2246             sayNO;
2247         case EOL:
2248             if (PL_multiline)
2249                 goto meol;
2250             else
2251                 goto seol;
2252         case MEOL:
2253           meol:
2254             if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
2255                 sayNO;
2256             break;
2257         case SEOL:
2258           seol:
2259             if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
2260                 sayNO;
2261             if (PL_regeol - locinput > 1)
2262                 sayNO;
2263             break;
2264         case EOS:
2265             if (PL_regeol != locinput)
2266                 sayNO;
2267             break;
2268         case SANY:
2269             if (!nextchr && locinput >= PL_regeol)
2270                 sayNO;
2271             if (do_utf8) {
2272                 locinput += PL_utf8skip[nextchr];
2273                 if (locinput > PL_regeol)
2274                     sayNO;
2275                 nextchr = UCHARAT(locinput);
2276             }
2277             else
2278                 nextchr = UCHARAT(++locinput);
2279             break;
2280         case CANY:
2281             if (!nextchr && locinput >= PL_regeol)
2282                 sayNO;
2283             nextchr = UCHARAT(++locinput);
2284             break;
2285         case REG_ANY:
2286             if ((!nextchr && locinput >= PL_regeol) || nextchr == '\n')
2287                 sayNO;
2288             if (do_utf8) {
2289                 locinput += PL_utf8skip[nextchr];
2290                 if (locinput > PL_regeol)
2291                     sayNO;
2292                 nextchr = UCHARAT(locinput);
2293             }
2294             else
2295                 nextchr = UCHARAT(++locinput);
2296             break;
2297         case EXACT:
2298             s = STRING(scan);
2299             ln = STR_LEN(scan);
2300             if (do_utf8 != (UTF!=0)) {
2301                 /* The target and the pattern have differing utf8ness. */
2302                 char *l = locinput;
2303                 char *e = s + ln;
2304                 STRLEN ulen;
2305
2306                 if (do_utf8) {
2307                     /* The target is utf8, the pattern is not utf8. */
2308                     while (s < e) {
2309                         if (l >= PL_regeol)
2310                              sayNO;
2311                         if (NATIVE_TO_UNI(*(U8*)s) !=
2312                             utf8_to_uvchr((U8*)l, &ulen))
2313                              sayNO;
2314                         l += ulen;
2315                         s ++;
2316                     }
2317                 }
2318                 else {
2319                     /* The target is not utf8, the pattern is utf8. */
2320                     while (s < e) {
2321                         if (l >= PL_regeol)
2322                             sayNO;
2323                         if (NATIVE_TO_UNI(*((U8*)l)) !=
2324                             utf8_to_uvchr((U8*)s, &ulen))
2325                             sayNO;
2326                         s += ulen;
2327                         l ++;
2328                     }
2329                 }
2330                 locinput = l;
2331                 nextchr = UCHARAT(locinput);
2332                 break;
2333             }
2334             /* The target and the pattern have the same utf8ness. */
2335             /* Inline the first character, for speed. */
2336             if (UCHARAT(s) != nextchr)
2337                 sayNO;
2338             if (PL_regeol - locinput < ln)
2339                 sayNO;
2340             if (ln > 1 && memNE(s, locinput, ln))
2341                 sayNO;
2342             locinput += ln;
2343             nextchr = UCHARAT(locinput);
2344             break;
2345         case EXACTFL:
2346             PL_reg_flags |= RF_tainted;
2347             /* FALL THROUGH */
2348         case EXACTF:
2349             s = STRING(scan);
2350             ln = STR_LEN(scan);
2351
2352             {
2353                 char *l = locinput;
2354                 char *e = s + ln;
2355
2356                 if (do_utf8 != (UTF!=0)) {
2357                      /* The target and the pattern have differing utf8ness. */
2358                      STRLEN ulen1, ulen2;
2359                      UV cs, cl;
2360
2361                      if (do_utf8) {
2362                           /* The target is utf8, the pattern is not utf8. */
2363                           while (s < e) {
2364                                if (l >= PL_regeol)
2365                                     sayNO;
2366
2367                                cs = to_uni_fold(NATIVE_TO_UNI(*(U8*)s),
2368                                                 (U8*)s, &ulen1);
2369                                cl = utf8_to_uvchr((U8*)l, &ulen2);
2370
2371                                if (cs != cl) {
2372                                     cl = to_uni_fold(cl, (U8*)l, &ulen2);
2373                                     if (ulen1 != ulen2 || cs != cl)
2374                                          sayNO;
2375                                }
2376                                l += ulen1;
2377                                s ++;
2378                           }
2379                      }
2380                      else {
2381                           /* The target is not utf8, the pattern is utf8. */
2382                           while (s < e) {
2383                                if (l >= PL_regeol)
2384                                     sayNO;
2385
2386                                cs = utf8_to_uvchr((U8*)s, &ulen1);
2387
2388                                cl = to_uni_fold(NATIVE_TO_UNI(*(U8*)l),
2389                                                 (U8*)l, &ulen2);
2390
2391                                if (cs != cl) {
2392                                     cs = to_uni_fold(cs, (U8*)s, &ulen1);
2393                                     if (ulen1 != ulen2 || cs != cl)
2394                                          sayNO;
2395                                }
2396                                l ++;
2397                                s += ulen1;
2398                           }
2399                      }
2400                      locinput = l;
2401                      nextchr = UCHARAT(locinput);
2402                      break;
2403                 }
2404
2405                 if (do_utf8 && UTF) {
2406                      /* Both the target and the pattern are utf8. */
2407                      U8 lfoldbuf[UTF8_MAXLEN_FOLD+1], *lf;
2408                      U8 sfoldbuf[UTF8_MAXLEN_FOLD+1], *sf;
2409                      STRLEN lfoldlen, sfoldlen;
2410                      STRLEN llen = 0;
2411                      STRLEN slen = 0;
2412
2413                      while (s < e) {
2414                           /* Fold them and walk them characterwise.  */
2415
2416                           if (llen == 0) {
2417                                to_utf8_fold((U8*)l, lfoldbuf, &lfoldlen);
2418                                lf   = lfoldbuf;
2419                                llen = lfoldlen;
2420                           }
2421
2422                           if (slen == 0) {
2423                                to_utf8_fold((U8*)s, sfoldbuf, &sfoldlen);
2424                                sf   = sfoldbuf;
2425                                slen = sfoldlen;
2426                           }
2427
2428                           while (llen && slen) {
2429                                if (UTF8SKIP(lf) != UTF8SKIP(sf) ||
2430                                    memNE((char*)lf, (char*)sf, UTF8SKIP(lf)))
2431                                     sayNO;
2432                                llen -= UTF8SKIP(lf);
2433                                lf   += UTF8SKIP(lf);
2434                                slen -= UTF8SKIP(sf);
2435                                sf   += UTF8SKIP(sf);
2436                           }
2437
2438                           l += UTF8SKIP(l);
2439                           s += UTF8SKIP(s);
2440                      }
2441                      locinput = l;
2442                      nextchr = UCHARAT(locinput);
2443                      break;
2444                 }
2445             }
2446
2447             /* Neither the target and the pattern are utf8. */
2448
2449             /* Inline the first character, for speed. */
2450             if (UCHARAT(s) != nextchr &&
2451                 UCHARAT(s) != ((OP(scan) == EXACTF)
2452                                ? PL_fold : PL_fold_locale)[nextchr])
2453                 sayNO;
2454             if (PL_regeol - locinput < ln)
2455                 sayNO;
2456             if (ln > 1 && (OP(scan) == EXACTF
2457                            ? ibcmp(s, locinput, ln)
2458                            : ibcmp_locale(s, locinput, ln)))
2459                 sayNO;
2460             locinput += ln;
2461             nextchr = UCHARAT(locinput);
2462             break;
2463         case ANYOF:
2464             if (do_utf8) {
2465                 if (!reginclass(scan, (U8*)locinput, do_utf8))
2466                     sayNO;
2467                 if (locinput >= PL_regeol)
2468                     sayNO;
2469                 locinput += PL_utf8skip[nextchr];
2470                 nextchr = UCHARAT(locinput);
2471             }
2472             else {
2473                 if (nextchr < 0)
2474                     nextchr = UCHARAT(locinput);
2475                 if (!reginclass(scan, (U8*)locinput, do_utf8))
2476                     sayNO;
2477                 if (!nextchr && locinput >= PL_regeol)
2478                     sayNO;
2479                 nextchr = UCHARAT(++locinput);
2480             }
2481             break;
2482         case ALNUML:
2483             PL_reg_flags |= RF_tainted;
2484             /* FALL THROUGH */
2485         case ALNUM:
2486             if (!nextchr)
2487                 sayNO;
2488             if (do_utf8) {
2489                 LOAD_UTF8_CHARCLASS(alnum,"a");
2490                 if (!(OP(scan) == ALNUM
2491                       ? swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
2492                       : isALNUM_LC_utf8((U8*)locinput)))
2493                 {
2494                     sayNO;
2495                 }
2496                 locinput += PL_utf8skip[nextchr];
2497                 nextchr = UCHARAT(locinput);
2498                 break;
2499             }
2500             if (!(OP(scan) == ALNUM
2501                   ? isALNUM(nextchr) : isALNUM_LC(nextchr)))
2502                 sayNO;
2503             nextchr = UCHARAT(++locinput);
2504             break;
2505         case NALNUML:
2506             PL_reg_flags |= RF_tainted;
2507             /* FALL THROUGH */
2508         case NALNUM:
2509             if (!nextchr && locinput >= PL_regeol)
2510                 sayNO;
2511             if (do_utf8) {
2512                 LOAD_UTF8_CHARCLASS(alnum,"a");
2513                 if (OP(scan) == NALNUM
2514                     ? swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
2515                     : isALNUM_LC_utf8((U8*)locinput))
2516                 {
2517                     sayNO;
2518                 }
2519                 locinput += PL_utf8skip[nextchr];
2520                 nextchr = UCHARAT(locinput);
2521                 break;
2522             }
2523             if (OP(scan) == NALNUM
2524                 ? isALNUM(nextchr) : isALNUM_LC(nextchr))
2525                 sayNO;
2526             nextchr = UCHARAT(++locinput);
2527             break;
2528         case BOUNDL:
2529         case NBOUNDL:
2530             PL_reg_flags |= RF_tainted;
2531             /* FALL THROUGH */
2532         case BOUND:
2533         case NBOUND:
2534             /* was last char in word? */
2535             if (do_utf8) {
2536                 if (locinput == PL_bostr)
2537                     ln = '\n';
2538                 else {
2539                     U8 *r = reghop((U8*)locinput, -1);
2540
2541                     ln = utf8n_to_uvchr(r, s - (char*)r, 0, 0);
2542                 }
2543                 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
2544                     ln = isALNUM_uni(ln);
2545                     LOAD_UTF8_CHARCLASS(alnum,"a");
2546                     n = swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8);
2547                 }
2548                 else {
2549                     ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(ln));
2550                     n = isALNUM_LC_utf8((U8*)locinput);
2551                 }
2552             }
2553             else {
2554                 ln = (locinput != PL_bostr) ?
2555                     UCHARAT(locinput - 1) : '\n';
2556                 if (OP(scan) == BOUND || OP(scan) == NBOUND) {
2557                     ln = isALNUM(ln);
2558                     n = isALNUM(nextchr);
2559                 }
2560                 else {
2561                     ln = isALNUM_LC(ln);
2562                     n = isALNUM_LC(nextchr);
2563                 }
2564             }
2565             if (((!ln) == (!n)) == (OP(scan) == BOUND ||
2566                                     OP(scan) == BOUNDL))
2567                     sayNO;
2568             break;
2569         case SPACEL:
2570             PL_reg_flags |= RF_tainted;
2571             /* FALL THROUGH */
2572         case SPACE:
2573             if (!nextchr)
2574                 sayNO;
2575             if (do_utf8) {
2576                 if (UTF8_IS_CONTINUED(nextchr)) {
2577                     LOAD_UTF8_CHARCLASS(space," ");
2578                     if (!(OP(scan) == SPACE
2579                           ? swash_fetch(PL_utf8_space, (U8*)locinput, do_utf8)
2580                           : isSPACE_LC_utf8((U8*)locinput)))
2581                     {
2582                         sayNO;
2583                     }
2584                     locinput += PL_utf8skip[nextchr];
2585                     nextchr = UCHARAT(locinput);
2586                     break;
2587                 }
2588                 if (!(OP(scan) == SPACE
2589                       ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
2590                     sayNO;
2591                 nextchr = UCHARAT(++locinput);
2592             }
2593             else {
2594                 if (!(OP(scan) == SPACE
2595                       ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
2596                     sayNO;
2597                 nextchr = UCHARAT(++locinput);
2598             }
2599             break;
2600         case NSPACEL:
2601             PL_reg_flags |= RF_tainted;
2602             /* FALL THROUGH */
2603         case NSPACE:
2604             if (!nextchr && locinput >= PL_regeol)
2605                 sayNO;
2606             if (do_utf8) {
2607                 LOAD_UTF8_CHARCLASS(space," ");
2608                 if (OP(scan) == NSPACE
2609                     ? swash_fetch(PL_utf8_space, (U8*)locinput, do_utf8)
2610                     : isSPACE_LC_utf8((U8*)locinput))
2611                 {
2612                     sayNO;
2613                 }
2614                 locinput += PL_utf8skip[nextchr];
2615                 nextchr = UCHARAT(locinput);
2616                 break;
2617             }
2618             if (OP(scan) == NSPACE
2619                 ? isSPACE(nextchr) : isSPACE_LC(nextchr))
2620                 sayNO;
2621             nextchr = UCHARAT(++locinput);
2622             break;
2623         case DIGITL:
2624             PL_reg_flags |= RF_tainted;
2625             /* FALL THROUGH */
2626         case DIGIT:
2627             if (!nextchr)
2628                 sayNO;
2629             if (do_utf8) {
2630                 LOAD_UTF8_CHARCLASS(digit,"0");
2631                 if (!(OP(scan) == DIGIT
2632                       ? swash_fetch(PL_utf8_digit, (U8*)locinput, do_utf8)
2633                       : isDIGIT_LC_utf8((U8*)locinput)))
2634                 {
2635                     sayNO;
2636                 }
2637                 locinput += PL_utf8skip[nextchr];
2638                 nextchr = UCHARAT(locinput);
2639                 break;
2640             }
2641             if (!(OP(scan) == DIGIT
2642                   ? isDIGIT(nextchr) : isDIGIT_LC(nextchr)))
2643                 sayNO;
2644             nextchr = UCHARAT(++locinput);
2645             break;
2646         case NDIGITL:
2647             PL_reg_flags |= RF_tainted;
2648             /* FALL THROUGH */
2649         case NDIGIT:
2650             if (!nextchr && locinput >= PL_regeol)
2651                 sayNO;
2652             if (do_utf8) {
2653                 LOAD_UTF8_CHARCLASS(digit,"0");
2654                 if (OP(scan) == NDIGIT
2655                     ? swash_fetch(PL_utf8_digit, (U8*)locinput, do_utf8)
2656                     : isDIGIT_LC_utf8((U8*)locinput))
2657                 {
2658                     sayNO;
2659                 }
2660                 locinput += PL_utf8skip[nextchr];
2661                 nextchr = UCHARAT(locinput);
2662                 break;
2663             }
2664             if (OP(scan) == NDIGIT
2665                 ? isDIGIT(nextchr) : isDIGIT_LC(nextchr))
2666                 sayNO;
2667             nextchr = UCHARAT(++locinput);
2668             break;
2669         case CLUMP:
2670             if (locinput >= PL_regeol)
2671                 sayNO;
2672             if  (do_utf8) {
2673                 LOAD_UTF8_CHARCLASS(mark,"~");
2674                 if (swash_fetch(PL_utf8_mark,(U8*)locinput, do_utf8))
2675                     sayNO;
2676                 locinput += PL_utf8skip[nextchr];
2677                 while (locinput < PL_regeol &&
2678                        swash_fetch(PL_utf8_mark,(U8*)locinput, do_utf8))
2679                     locinput += UTF8SKIP(locinput);
2680                 if (locinput > PL_regeol)
2681                     sayNO;
2682             }
2683             else
2684                locinput++;
2685             nextchr = UCHARAT(locinput);
2686             break;
2687         case REFFL:
2688             PL_reg_flags |= RF_tainted;
2689             /* FALL THROUGH */
2690         case REF:
2691         case REFF:
2692             n = ARG(scan);  /* which paren pair */
2693             ln = PL_regstartp[n];
2694             PL_reg_leftiter = PL_reg_maxiter;           /* Void cache */
2695             if (*PL_reglastparen < n || ln == -1)
2696                 sayNO;                  /* Do not match unless seen CLOSEn. */
2697             if (ln == PL_regendp[n])
2698                 break;
2699
2700             s = PL_bostr + ln;
2701             if (do_utf8 && OP(scan) != REF) {   /* REF can do byte comparison */
2702                 char *l = locinput;
2703                 char *e = PL_bostr + PL_regendp[n];
2704                 /*
2705                  * Note that we can't do the "other character" lookup trick as
2706                  * in the 8-bit case (no pun intended) because in Unicode we
2707                  * have to map both upper and title case to lower case.
2708                  */
2709                 if (OP(scan) == REFF) {
2710                     STRLEN ulen1, ulen2;
2711                     U8 tmpbuf1[UTF8_MAXLEN_UCLC+1];
2712                     U8 tmpbuf2[UTF8_MAXLEN_UCLC+1];
2713                     while (s < e) {
2714                         if (l >= PL_regeol)
2715                             sayNO;
2716                         toLOWER_utf8((U8*)s, tmpbuf1, &ulen1);
2717                         toLOWER_utf8((U8*)l, tmpbuf2, &ulen2);
2718                         if (ulen1 != ulen2 || memNE((char *)tmpbuf1, (char *)tmpbuf2, ulen1))
2719                             sayNO;
2720                         s += ulen1;
2721                         l += ulen2;
2722                     }
2723                 }
2724                 locinput = l;
2725                 nextchr = UCHARAT(locinput);
2726                 break;
2727             }
2728
2729             /* Inline the first character, for speed. */
2730             if (UCHARAT(s) != nextchr &&
2731                 (OP(scan) == REF ||
2732                  (UCHARAT(s) != ((OP(scan) == REFF
2733                                   ? PL_fold : PL_fold_locale)[nextchr]))))
2734                 sayNO;
2735             ln = PL_regendp[n] - ln;
2736             if (locinput + ln > PL_regeol)
2737                 sayNO;
2738             if (ln > 1 && (OP(scan) == REF
2739                            ? memNE(s, locinput, ln)
2740                            : (OP(scan) == REFF
2741                               ? ibcmp(s, locinput, ln)
2742                               : ibcmp_locale(s, locinput, ln))))
2743                 sayNO;
2744             locinput += ln;
2745             nextchr = UCHARAT(locinput);
2746             break;
2747
2748         case NOTHING:
2749         case TAIL:
2750             break;
2751         case BACK:
2752             break;
2753         case EVAL:
2754         {
2755             dSP;
2756             OP_4tree *oop = PL_op;
2757             COP *ocurcop = PL_curcop;
2758             SV **ocurpad = PL_curpad;
2759             SV *ret;
2760
2761             n = ARG(scan);
2762             PL_op = (OP_4tree*)PL_regdata->data[n];
2763             DEBUG_r( PerlIO_printf(Perl_debug_log, "  re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
2764             PL_curpad = AvARRAY((AV*)PL_regdata->data[n + 2]);
2765             PL_regendp[0] = PL_reg_magic->mg_len = locinput - PL_bostr;
2766
2767             {
2768                 SV **before = SP;
2769                 CALLRUNOPS(aTHX);                       /* Scalar context. */
2770                 SPAGAIN;
2771                 if (SP == before)
2772                     ret = Nullsv;   /* protect against empty (?{}) blocks. */
2773                 else {
2774                     ret = POPs;
2775                     PUTBACK;
2776                 }
2777             }
2778
2779             PL_op = oop;
2780             PL_curpad = ocurpad;
2781             PL_curcop = ocurcop;
2782             if (logical) {
2783                 if (logical == 2) {     /* Postponed subexpression. */
2784                     regexp *re;
2785                     MAGIC *mg = Null(MAGIC*);
2786                     re_cc_state state;
2787                     CHECKPOINT cp, lastcp;
2788
2789                     if(SvROK(ret) || SvRMAGICAL(ret)) {
2790                         SV *sv = SvROK(ret) ? SvRV(ret) : ret;
2791
2792                         if(SvMAGICAL(sv))
2793                             mg = mg_find(sv, PERL_MAGIC_qr);
2794                     }
2795                     if (mg) {
2796                         re = (regexp *)mg->mg_obj;
2797                         (void)ReREFCNT_inc(re);
2798                     }
2799                     else {
2800                         STRLEN len;
2801                         char *t = SvPV(ret, len);
2802                         PMOP pm;
2803                         char *oprecomp = PL_regprecomp;
2804                         I32 osize = PL_regsize;
2805                         I32 onpar = PL_regnpar;
2806
2807                         Zero(&pm, 1, PMOP);
2808                         re = CALLREGCOMP(aTHX_ t, t + len, &pm);
2809                         if (!(SvFLAGS(ret)
2810                               & (SVs_TEMP | SVs_PADTMP | SVf_READONLY)))
2811                             sv_magic(ret,(SV*)ReREFCNT_inc(re),
2812                                         PERL_MAGIC_qr,0,0);
2813                         PL_regprecomp = oprecomp;
2814                         PL_regsize = osize;
2815                         PL_regnpar = onpar;
2816                     }
2817                     DEBUG_r(
2818                         PerlIO_printf(Perl_debug_log,
2819                                       "Entering embedded `%s%.60s%s%s'\n",
2820                                       PL_colors[0],
2821                                       re->precomp,
2822                                       PL_colors[1],
2823                                       (strlen(re->precomp) > 60 ? "..." : ""))
2824                         );
2825                     state.node = next;
2826                     state.prev = PL_reg_call_cc;
2827                     state.cc = PL_regcc;
2828                     state.re = PL_reg_re;
2829
2830                     PL_regcc = 0;
2831
2832                     cp = regcppush(0);  /* Save *all* the positions. */
2833                     REGCP_SET(lastcp);
2834                     cache_re(re);
2835                     state.ss = PL_savestack_ix;
2836                     *PL_reglastparen = 0;
2837                     *PL_reglastcloseparen = 0;
2838                     PL_reg_call_cc = &state;
2839                     PL_reginput = locinput;
2840
2841                     /* XXXX This is too dramatic a measure... */
2842                     PL_reg_maxiter = 0;
2843
2844                     if (regmatch(re->program + 1)) {
2845                         /* Even though we succeeded, we need to restore
2846                            global variables, since we may be wrapped inside
2847                            SUSPEND, thus the match may be not finished yet. */
2848
2849                         /* XXXX Do this only if SUSPENDed? */
2850                         PL_reg_call_cc = state.prev;
2851                         PL_regcc = state.cc;
2852                         PL_reg_re = state.re;
2853                         cache_re(PL_reg_re);
2854
2855                         /* XXXX This is too dramatic a measure... */
2856                         PL_reg_maxiter = 0;
2857
2858                         /* These are needed even if not SUSPEND. */
2859                         ReREFCNT_dec(re);
2860                         regcpblow(cp);
2861                         sayYES;
2862                     }
2863                     ReREFCNT_dec(re);
2864                     REGCP_UNWIND(lastcp);
2865                     regcppop();
2866                     PL_reg_call_cc = state.prev;
2867                     PL_regcc = state.cc;
2868                     PL_reg_re = state.re;
2869                     cache_re(PL_reg_re);
2870
2871                     /* XXXX This is too dramatic a measure... */
2872                     PL_reg_maxiter = 0;
2873
2874                     logical = 0;
2875                     sayNO;
2876                 }
2877                 sw = SvTRUE(ret);
2878                 logical = 0;
2879             }
2880             else
2881                 sv_setsv(save_scalar(PL_replgv), ret);
2882             break;
2883         }
2884         case OPEN:
2885             n = ARG(scan);  /* which paren pair */
2886             PL_reg_start_tmp[n] = locinput;
2887             if (n > PL_regsize)
2888                 PL_regsize = n;
2889             break;
2890         case CLOSE:
2891             n = ARG(scan);  /* which paren pair */
2892             PL_regstartp[n] = PL_reg_start_tmp[n] - PL_bostr;
2893             PL_regendp[n] = locinput - PL_bostr;
2894             if (n > *PL_reglastparen)
2895                 *PL_reglastparen = n;
2896             *PL_reglastcloseparen = n;
2897             break;
2898         case GROUPP:
2899             n = ARG(scan);  /* which paren pair */
2900             sw = (*PL_reglastparen >= n && PL_regendp[n] != -1);
2901             break;
2902         case IFTHEN:
2903             PL_reg_leftiter = PL_reg_maxiter;           /* Void cache */
2904             if (sw)
2905                 next = NEXTOPER(NEXTOPER(scan));
2906             else {
2907                 next = scan + ARG(scan);
2908                 if (OP(next) == IFTHEN) /* Fake one. */
2909                     next = NEXTOPER(NEXTOPER(next));
2910             }
2911             break;
2912         case LOGICAL:
2913             logical = scan->flags;
2914             break;
2915 /*******************************************************************
2916  PL_regcc contains infoblock about the innermost (...)* loop, and
2917  a pointer to the next outer infoblock.
2918
2919  Here is how Y(A)*Z is processed (if it is compiled into CURLYX/WHILEM):
2920
2921    1) After matching X, regnode for CURLYX is processed;
2922
2923    2) This regnode creates infoblock on the stack, and calls
2924       regmatch() recursively with the starting point at WHILEM node;
2925
2926    3) Each hit of WHILEM node tries to match A and Z (in the order
2927       depending on the current iteration, min/max of {min,max} and
2928       greediness).  The information about where are nodes for "A"
2929       and "Z" is read from the infoblock, as is info on how many times "A"
2930       was already matched, and greediness.
2931
2932    4) After A matches, the same WHILEM node is hit again.
2933
2934    5) Each time WHILEM is hit, PL_regcc is the infoblock created by CURLYX
2935       of the same pair.  Thus when WHILEM tries to match Z, it temporarily
2936       resets PL_regcc, since this Y(A)*Z can be a part of some other loop:
2937       as in (Y(A)*Z)*.  If Z matches, the automaton will hit the WHILEM node
2938       of the external loop.
2939
2940  Currently present infoblocks form a tree with a stem formed by PL_curcc
2941  and whatever it mentions via ->next, and additional attached trees
2942  corresponding to temporarily unset infoblocks as in "5" above.
2943
2944  In the following picture infoblocks for outer loop of
2945  (Y(A)*?Z)*?T are denoted O, for inner I.  NULL starting block
2946  is denoted by x.  The matched string is YAAZYAZT.  Temporarily postponed
2947  infoblocks are drawn below the "reset" infoblock.
2948
2949  In fact in the picture below we do not show failed matches for Z and T
2950  by WHILEM blocks.  [We illustrate minimal matches, since for them it is
2951  more obvious *why* one needs to *temporary* unset infoblocks.]
2952
2953   Matched       REx position    InfoBlocks      Comment
2954                 (Y(A)*?Z)*?T    x
2955                 Y(A)*?Z)*?T     x <- O
2956   Y             (A)*?Z)*?T      x <- O
2957   Y             A)*?Z)*?T       x <- O <- I
2958   YA            )*?Z)*?T        x <- O <- I
2959   YA            A)*?Z)*?T       x <- O <- I
2960   YAA           )*?Z)*?T        x <- O <- I
2961   YAA           Z)*?T           x <- O          # Temporary unset I
2962                                      I
2963
2964   YAAZ          Y(A)*?Z)*?T     x <- O
2965                                      I
2966
2967   YAAZY         (A)*?Z)*?T      x <- O
2968                                      I
2969
2970   YAAZY         A)*?Z)*?T       x <- O <- I
2971                                      I
2972
2973   YAAZYA        )*?Z)*?T        x <- O <- I
2974                                      I
2975
2976   YAAZYA        Z)*?T           x <- O          # Temporary unset I
2977                                      I,I
2978
2979   YAAZYAZ       )*?T            x <- O
2980                                      I,I
2981
2982   YAAZYAZ       T               x               # Temporary unset O
2983                                 O
2984                                 I,I
2985
2986   YAAZYAZT                      x
2987                                 O
2988                                 I,I
2989  *******************************************************************/
2990         case CURLYX: {
2991                 CURCUR cc;
2992                 CHECKPOINT cp = PL_savestack_ix;
2993                 /* No need to save/restore up to this paren */
2994                 I32 parenfloor = scan->flags;
2995
2996                 if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
2997                     next += ARG(next);
2998                 cc.oldcc = PL_regcc;
2999                 PL_regcc = &cc;
3000                 /* XXXX Probably it is better to teach regpush to support
3001                    parenfloor > PL_regsize... */
3002                 if (parenfloor > *PL_reglastparen)
3003                     parenfloor = *PL_reglastparen; /* Pessimization... */
3004                 cc.parenfloor = parenfloor;
3005                 cc.cur = -1;
3006                 cc.min = ARG1(scan);
3007                 cc.max  = ARG2(scan);
3008                 cc.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
3009                 cc.next = next;
3010                 cc.minmod = minmod;
3011                 cc.lastloc = 0;
3012                 PL_reginput = locinput;
3013                 n = regmatch(PREVOPER(next));   /* start on the WHILEM */
3014                 regcpblow(cp);
3015                 PL_regcc = cc.oldcc;
3016                 saySAME(n);
3017             }
3018             /* NOT REACHED */
3019         case WHILEM: {
3020                 /*
3021                  * This is really hard to understand, because after we match
3022                  * what we're trying to match, we must make sure the rest of
3023                  * the REx is going to match for sure, and to do that we have
3024                  * to go back UP the parse tree by recursing ever deeper.  And
3025                  * if it fails, we have to reset our parent's current state
3026                  * that we can try again after backing off.
3027                  */
3028
3029                 CHECKPOINT cp, lastcp;
3030                 CURCUR* cc = PL_regcc;
3031                 char *lastloc = cc->lastloc; /* Detection of 0-len. */
3032
3033                 n = cc->cur + 1;        /* how many we know we matched */
3034                 PL_reginput = locinput;
3035
3036                 DEBUG_r(
3037                     PerlIO_printf(Perl_debug_log,
3038                                   "%*s  %ld out of %ld..%ld  cc=%lx\n",
3039                                   REPORT_CODE_OFF+PL_regindent*2, "",
3040                                   (long)n, (long)cc->min,
3041                                   (long)cc->max, (long)cc)
3042                     );
3043
3044                 /* If degenerate scan matches "", assume scan done. */
3045
3046                 if (locinput == cc->lastloc && n >= cc->min) {
3047                     PL_regcc = cc->oldcc;
3048                     if (PL_regcc)
3049                         ln = PL_regcc->cur;
3050                     DEBUG_r(
3051                         PerlIO_printf(Perl_debug_log,
3052                            "%*s  empty match detected, try continuation...\n",
3053                            REPORT_CODE_OFF+PL_regindent*2, "")
3054                         );
3055                     if (regmatch(cc->next))
3056                         sayYES;
3057                     if (PL_regcc)
3058                         PL_regcc->cur = ln;
3059                     PL_regcc = cc;
3060                     sayNO;
3061                 }
3062
3063                 /* First just match a string of min scans. */
3064
3065                 if (n < cc->min) {
3066                     cc->cur = n;
3067                     cc->lastloc = locinput;
3068                     if (regmatch(cc->scan))
3069                         sayYES;
3070                     cc->cur = n - 1;
3071                     cc->lastloc = lastloc;
3072                     sayNO;
3073                 }
3074
3075                 if (scan->flags) {
3076                     /* Check whether we already were at this position.
3077                         Postpone detection until we know the match is not
3078                         *that* much linear. */
3079                 if (!PL_reg_maxiter) {
3080                     PL_reg_maxiter = (PL_regeol - PL_bostr + 1) * (scan->flags>>4);
3081                     PL_reg_leftiter = PL_reg_maxiter;
3082                 }
3083                 if (PL_reg_leftiter-- == 0) {
3084                     I32 size = (PL_reg_maxiter + 7)/8;
3085                     if (PL_reg_poscache) {
3086                         if (PL_reg_poscache_size < size) {
3087                             Renew(PL_reg_poscache, size, char);
3088                             PL_reg_poscache_size = size;
3089                         }
3090                         Zero(PL_reg_poscache, size, char);
3091                     }
3092                     else {
3093                         PL_reg_poscache_size = size;
3094                         Newz(29, PL_reg_poscache, size, char);
3095                     }
3096                     DEBUG_r(
3097                         PerlIO_printf(Perl_debug_log,
3098               "%sDetected a super-linear match, switching on caching%s...\n",
3099                                       PL_colors[4], PL_colors[5])
3100                         );
3101                 }
3102                 if (PL_reg_leftiter < 0) {
3103                     I32 o = locinput - PL_bostr, b;
3104
3105                     o = (scan->flags & 0xf) - 1 + o * (scan->flags>>4);
3106                     b = o % 8;
3107                     o /= 8;
3108                     if (PL_reg_poscache[o] & (1<<b)) {
3109                     DEBUG_r(
3110                         PerlIO_printf(Perl_debug_log,
3111                                       "%*s  already tried at this position...\n",
3112                                       REPORT_CODE_OFF+PL_regindent*2, "")
3113                         );
3114                         sayNO_SILENT;
3115                     }
3116                     PL_reg_poscache[o] |= (1<<b);
3117                 }
3118                 }
3119
3120                 /* Prefer next over scan for minimal matching. */
3121
3122                 if (cc->minmod) {
3123                     PL_regcc = cc->oldcc;
3124                     if (PL_regcc)
3125                         ln = PL_regcc->cur;
3126                     cp = regcppush(cc->parenfloor);
3127                     REGCP_SET(lastcp);
3128                     if (regmatch(cc->next)) {
3129                         regcpblow(cp);
3130                         sayYES; /* All done. */
3131                     }
3132                     REGCP_UNWIND(lastcp);
3133                     regcppop();
3134                     if (PL_regcc)
3135                         PL_regcc->cur = ln;
3136                     PL_regcc = cc;
3137
3138                     if (n >= cc->max) { /* Maximum greed exceeded? */
3139                         if (ckWARN(WARN_REGEXP) && n >= REG_INFTY
3140                             && !(PL_reg_flags & RF_warned)) {
3141                             PL_reg_flags |= RF_warned;
3142                             Perl_warner(aTHX_ WARN_REGEXP, "%s limit (%d) exceeded",
3143                                  "Complex regular subexpression recursion",
3144                                  REG_INFTY - 1);
3145                         }
3146                         sayNO;
3147                     }
3148
3149                     DEBUG_r(
3150                         PerlIO_printf(Perl_debug_log,
3151                                       "%*s  trying longer...\n",
3152                                       REPORT_CODE_OFF+PL_regindent*2, "")
3153                         );
3154                     /* Try scanning more and see if it helps. */
3155                     PL_reginput = locinput;
3156                     cc->cur = n;
3157                     cc->lastloc = locinput;
3158                     cp = regcppush(cc->parenfloor);
3159                     REGCP_SET(lastcp);
3160                     if (regmatch(cc->scan)) {
3161                         regcpblow(cp);
3162                         sayYES;
3163                     }
3164                     REGCP_UNWIND(lastcp);
3165                     regcppop();
3166                     cc->cur = n - 1;
3167                     cc->lastloc = lastloc;
3168                     sayNO;
3169                 }
3170
3171                 /* Prefer scan over next for maximal matching. */
3172
3173                 if (n < cc->max) {      /* More greed allowed? */
3174                     cp = regcppush(cc->parenfloor);
3175                     cc->cur = n;
3176                     cc->lastloc = locinput;
3177                     REGCP_SET(lastcp);
3178                     if (regmatch(cc->scan)) {
3179                         regcpblow(cp);
3180                         sayYES;
3181                     }
3182                     REGCP_UNWIND(lastcp);
3183                     regcppop();         /* Restore some previous $<digit>s? */
3184                     PL_reginput = locinput;
3185                     DEBUG_r(
3186                         PerlIO_printf(Perl_debug_log,
3187                                       "%*s  failed, try continuation...\n",
3188                                       REPORT_CODE_OFF+PL_regindent*2, "")
3189                         );
3190                 }
3191                 if (ckWARN(WARN_REGEXP) && n >= REG_INFTY
3192                         && !(PL_reg_flags & RF_warned)) {
3193                     PL_reg_flags |= RF_warned;
3194                     Perl_warner(aTHX_ WARN_REGEXP, "%s limit (%d) exceeded",
3195                          "Complex regular subexpression recursion",
3196                          REG_INFTY - 1);
3197                 }
3198
3199                 /* Failed deeper matches of scan, so see if this one works. */
3200                 PL_regcc = cc->oldcc;
3201                 if (PL_regcc)
3202                     ln = PL_regcc->cur;
3203                 if (regmatch(cc->next))
3204                     sayYES;
3205                 if (PL_regcc)
3206                     PL_regcc->cur = ln;
3207                 PL_regcc = cc;
3208                 cc->cur = n - 1;
3209                 cc->lastloc = lastloc;
3210                 sayNO;
3211             }
3212             /* NOT REACHED */
3213         case BRANCHJ:
3214             next = scan + ARG(scan);
3215             if (next == scan)
3216                 next = NULL;
3217             inner = NEXTOPER(NEXTOPER(scan));
3218             goto do_branch;
3219         case BRANCH:
3220             inner = NEXTOPER(scan);
3221           do_branch:
3222             {
3223                 c1 = OP(scan);
3224                 if (OP(next) != c1)     /* No choice. */
3225                     next = inner;       /* Avoid recursion. */
3226                 else {
3227                     I32 lastparen = *PL_reglastparen;
3228                     I32 unwind1;
3229                     re_unwind_branch_t *uw;
3230
3231                     /* Put unwinding data on stack */
3232                     unwind1 = SSNEWt(1,re_unwind_branch_t);
3233                     uw = SSPTRt(unwind1,re_unwind_branch_t);
3234                     uw->prev = unwind;
3235                     unwind = unwind1;
3236                     uw->type = ((c1 == BRANCH)
3237                                 ? RE_UNWIND_BRANCH
3238                                 : RE_UNWIND_BRANCHJ);
3239                     uw->lastparen = lastparen;
3240                     uw->next = next;
3241                     uw->locinput = locinput;
3242                     uw->nextchr = nextchr;
3243 #ifdef DEBUGGING
3244                     uw->regindent = ++PL_regindent;
3245 #endif
3246
3247                     REGCP_SET(uw->lastcp);
3248
3249                     /* Now go into the first branch */
3250                     next = inner;
3251                 }
3252             }
3253             break;
3254         case MINMOD:
3255             minmod = 1;
3256             break;
3257         case CURLYM:
3258         {
3259             I32 l = 0;
3260             CHECKPOINT lastcp;
3261
3262             /* We suppose that the next guy does not need
3263                backtracking: in particular, it is of constant length,
3264                and has no parenths to influence future backrefs. */
3265             ln = ARG1(scan);  /* min to match */
3266             n  = ARG2(scan);  /* max to match */
3267             paren = scan->flags;
3268             if (paren) {
3269                 if (paren > PL_regsize)
3270                     PL_regsize = paren;
3271                 if (paren > *PL_reglastparen)
3272                     *PL_reglastparen = paren;
3273             }
3274             scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
3275             if (paren)
3276                 scan += NEXT_OFF(scan); /* Skip former OPEN. */
3277             PL_reginput = locinput;
3278             if (minmod) {
3279                 minmod = 0;
3280                 if (ln && regrepeat_hard(scan, ln, &l) < ln)
3281                     sayNO;
3282                 /* if we matched something zero-length we don't need to
3283                    backtrack - capturing parens are already defined, so
3284                    the caveat in the maximal case doesn't apply
3285
3286                    XXXX if ln == 0, we can redo this check first time
3287                    through the following loop
3288                 */
3289                 if (ln && l == 0)
3290                     n = ln;     /* don't backtrack */
3291                 locinput = PL_reginput;
3292                 if (HAS_TEXT(next) || JUMPABLE(next)) {
3293                     regnode *text_node = next;
3294
3295                     if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
3296
3297                     if (! HAS_TEXT(text_node)) c1 = c2 = -1000;
3298                     else {
3299                         if (PL_regkind[(U8)OP(text_node)] == REF) {
3300                             I32 n, ln;
3301                             n = ARG(text_node);  /* which paren pair */
3302                             ln = PL_regstartp[n];
3303                             /* assume yes if we haven't seen CLOSEn */
3304                             if (
3305                                 *PL_reglastparen < n ||
3306                                 ln == -1 ||
3307                                 ln == PL_regendp[n]
3308                             ) {
3309                                 c1 = c2 = -1000;
3310                                 goto assume_ok_MM;
3311                             }
3312                             c1 = *(PL_bostr + ln);
3313                         }
3314                         else { c1 = (U8)*STRING(text_node); }
3315                         if (OP(text_node) == EXACTF || OP(text_node) == REFF)
3316                             c2 = PL_fold[c1];
3317                         else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
3318                             c2 = PL_fold_locale[c1];
3319                         else
3320                             c2 = c1;
3321                     }
3322                 }
3323                 else
3324                     c1 = c2 = -1000;
3325             assume_ok_MM:
3326                 REGCP_SET(lastcp);
3327                 /* This may be improved if l == 0.  */
3328                 while (n >= ln || (n == REG_INFTY && ln > 0 && l)) { /* ln overflow ? */
3329                     /* If it could work, try it. */
3330                     if (c1 == -1000 ||
3331                         UCHARAT(PL_reginput) == c1 ||
3332                         UCHARAT(PL_reginput) == c2)
3333                     {
3334                         if (paren) {
3335                             if (ln) {
3336                                 PL_regstartp[paren] =
3337                                     HOPc(PL_reginput, -l) - PL_bostr;
3338                                 PL_regendp[paren] = PL_reginput - PL_bostr;
3339                             }
3340                             else
3341                                 PL_regendp[paren] = -1;
3342                         }
3343                         if (regmatch(next))
3344                             sayYES;
3345                         REGCP_UNWIND(lastcp);
3346                     }
3347                     /* Couldn't or didn't -- move forward. */
3348                     PL_reginput = locinput;
3349                     if (regrepeat_hard(scan, 1, &l)) {
3350                         ln++;
3351                         locinput = PL_reginput;
3352                     }
3353                     else
3354                         sayNO;
3355                 }
3356             }
3357             else {
3358                 n = regrepeat_hard(scan, n, &l);
3359                 /* if we matched something zero-length we don't need to
3360                    backtrack, unless the minimum count is zero and we
3361                    are capturing the result - in that case the capture
3362                    being defined or not may affect later execution
3363                 */
3364                 if (n != 0 && l == 0 && !(paren && ln == 0))
3365                     ln = n;     /* don't backtrack */
3366                 locinput = PL_reginput;
3367                 DEBUG_r(
3368                     PerlIO_printf(Perl_debug_log,
3369                                   "%*s  matched %"IVdf" times, len=%"IVdf"...\n",
3370                                   (int)(REPORT_CODE_OFF+PL_regindent*2), "",
3371                                   (IV) n, (IV)l)
3372                     );
3373                 if (n >= ln) {
3374                     if (HAS_TEXT(next) || JUMPABLE(next)) {
3375                         regnode *text_node = next;
3376
3377                         if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
3378
3379                         if (! HAS_TEXT(text_node)) c1 = c2 = -1000;
3380                         else {
3381                             if (PL_regkind[(U8)OP(text_node)] == REF) {
3382                                 I32 n, ln;
3383                                 n = ARG(text_node);  /* which paren pair */
3384                                 ln = PL_regstartp[n];
3385                                 /* assume yes if we haven't seen CLOSEn */
3386                                 if (
3387                                     *PL_reglastparen < n ||
3388                                     ln == -1 ||
3389                                     ln == PL_regendp[n]
3390                                 ) {
3391                                     c1 = c2 = -1000;
3392                                     goto assume_ok_REG;
3393                                 }
3394                                 c1 = *(PL_bostr + ln);
3395                             }
3396                             else { c1 = (U8)*STRING(text_node); }
3397
3398                             if (OP(text_node) == EXACTF || OP(text_node) == REFF)
3399                                 c2 = PL_fold[c1];
3400                             else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
3401                                 c2 = PL_fold_locale[c1];
3402                             else
3403                                 c2 = c1;
3404                         }
3405                     }
3406                     else
3407                         c1 = c2 = -1000;
3408                 }
3409             assume_ok_REG:
3410                 REGCP_SET(lastcp);
3411                 while (n >= ln) {
3412                     /* If it could work, try it. */
3413                     if (c1 == -1000 ||
3414                         UCHARAT(PL_reginput) == c1 ||
3415                         UCHARAT(PL_reginput) == c2)
3416                     {
3417                         DEBUG_r(
3418                                 PerlIO_printf(Perl_debug_log,
3419                                               "%*s  trying tail with n=%"IVdf"...\n",
3420                                               (int)(REPORT_CODE_OFF+PL_regindent*2), "", (IV)n)
3421                             );
3422                         if (paren) {
3423                             if (n) {
3424                                 PL_regstartp[paren] = HOPc(PL_reginput, -l) - PL_bostr;
3425                                 PL_regendp[paren] = PL_reginput - PL_bostr;
3426                             }
3427                             else
3428                                 PL_regendp[paren] = -1;
3429                         }
3430                         if (regmatch(next))
3431                             sayYES;
3432                         REGCP_UNWIND(lastcp);
3433                     }
3434                     /* Couldn't or didn't -- back up. */
3435                     n--;
3436                     locinput = HOPc(locinput, -l);
3437                     PL_reginput = locinput;
3438                 }
3439             }
3440             sayNO;
3441             break;
3442         }
3443         case CURLYN:
3444             paren = scan->flags;        /* Which paren to set */
3445             if (paren > PL_regsize)
3446                 PL_regsize = paren;
3447             if (paren > *PL_reglastparen)
3448                 *PL_reglastparen = paren;
3449             ln = ARG1(scan);  /* min to match */
3450             n  = ARG2(scan);  /* max to match */
3451             scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
3452             goto repeat;
3453         case CURLY:
3454             paren = 0;
3455             ln = ARG1(scan);  /* min to match */
3456             n  = ARG2(scan);  /* max to match */
3457             scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
3458             goto repeat;
3459         case STAR:
3460             ln = 0;
3461             n = REG_INFTY;
3462             scan = NEXTOPER(scan);
3463             paren = 0;
3464             goto repeat;
3465         case PLUS:
3466             ln = 1;
3467             n = REG_INFTY;
3468             scan = NEXTOPER(scan);
3469             paren = 0;
3470           repeat:
3471             /*
3472             * Lookahead to avoid useless match attempts
3473             * when we know what character comes next.
3474             */
3475
3476             /*
3477             * Used to only do .*x and .*?x, but now it allows
3478             * for )'s, ('s and (?{ ... })'s to be in the way
3479             * of the quantifier and the EXACT-like node.  -- japhy
3480             */
3481
3482             if (HAS_TEXT(next) || JUMPABLE(next)) {
3483                 U8 *s;
3484                 regnode *text_node = next;
3485
3486                 if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
3487
3488                 if (! HAS_TEXT(text_node)) c1 = c2 = -1000;
3489                 else {
3490                     if (PL_regkind[(U8)OP(text_node)] == REF) {
3491                         I32 n, ln;
3492                         n = ARG(text_node);  /* which paren pair */
3493                         ln = PL_regstartp[n];
3494                         /* assume yes if we haven't seen CLOSEn */
3495                         if (
3496                             *PL_reglastparen < n ||
3497                             ln == -1 ||
3498                             ln == PL_regendp[n]
3499                         ) {
3500                             c1 = c2 = -1000;
3501                             goto assume_ok_easy;
3502                         }
3503                         s = (U8*)PL_bostr + ln;
3504                     }
3505                     else { s = (U8*)STRING(text_node); }
3506
3507                     if (!UTF) {
3508                         c2 = c1 = *s;
3509                         if (OP(text_node) == EXACTF || OP(text_node) == REFF)
3510                             c2 = PL_fold[c1];
3511                         else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
3512                             c2 = PL_fold_locale[c1];
3513                     }
3514                     else { /* UTF */
3515                         if (OP(text_node) == EXACTF || OP(text_node) == REFF) {
3516                              STRLEN ulen1, ulen2;
3517                              U8 tmpbuf1[UTF8_MAXLEN_UCLC+1];
3518                              U8 tmpbuf2[UTF8_MAXLEN_UCLC+1];
3519
3520                              to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
3521                              to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
3522
3523                              c1 = utf8_to_uvuni(tmpbuf1, 0);
3524                              c2 = utf8_to_uvuni(tmpbuf2, 0);
3525                         }
3526                         else {
3527                             c2 = c1 = utf8_to_uvchr(s, NULL);
3528                         }
3529                     }
3530                 }
3531             }
3532             else
3533                 c1 = c2 = -1000;
3534         assume_ok_easy:
3535             PL_reginput = locinput;
3536             if (minmod) {
3537                 CHECKPOINT lastcp;
3538                 minmod = 0;
3539                 if (ln && regrepeat(scan, ln) < ln)
3540                     sayNO;
3541                 locinput = PL_reginput;
3542                 REGCP_SET(lastcp);
3543                 if (c1 != -1000) {
3544                     char *e; /* Should not check after this */
3545                     char *old = locinput;
3546
3547                     if  (n == REG_INFTY) {
3548                         e = PL_regeol - 1;
3549                         if (do_utf8)
3550                             while (UTF8_IS_CONTINUATION(*(U8*)e))
3551                                 e--;
3552                     }
3553                     else if (do_utf8) {
3554                         int m = n - ln;
3555                         for (e = locinput;
3556                              m >0 && e + UTF8SKIP(e) <= PL_regeol; m--)
3557                             e += UTF8SKIP(e);
3558                     }
3559                     else {
3560                         e = locinput + n - ln;
3561                         if (e >= PL_regeol)
3562                             e = PL_regeol - 1;
3563                     }
3564                     while (1) {
3565                         int count;
3566                         /* Find place 'next' could work */
3567                         if (!do_utf8) {
3568                             if (c1 == c2) {
3569                                 while (locinput <= e &&
3570                                        UCHARAT(locinput) != c1)
3571                                     locinput++;
3572                             } else {
3573                                 while (locinput <= e
3574                                        && UCHARAT(locinput) != c1
3575                                        && UCHARAT(locinput) != c2)
3576                                     locinput++;
3577                             }
3578                             count = locinput - old;
3579                         }
3580                         else {
3581                             STRLEN len;
3582                             if (c1 == c2) {
3583                                 for (count = 0;
3584                                      locinput <= e &&
3585                                          utf8_to_uvchr((U8*)locinput, &len) != c1;
3586                                      count++)
3587                                     locinput += len;
3588
3589                             } else {
3590                                 for (count = 0; locinput <= e; count++) {
3591                                     UV c = utf8_to_uvchr((U8*)locinput, &len);
3592                                     if (c == c1 || c == c2)
3593                                         break;
3594                                     locinput += len;
3595                                 }
3596                             }
3597                         }
3598                         if (locinput > e)
3599                             sayNO;
3600                         /* PL_reginput == old now */
3601                         if (locinput != old) {
3602                             ln = 1;     /* Did some */
3603                             if (regrepeat(scan, count) < count)
3604                                 sayNO;
3605                         }
3606                         /* PL_reginput == locinput now */
3607                         TRYPAREN(paren, ln, locinput);
3608                         PL_reginput = locinput; /* Could be reset... */
3609                         REGCP_UNWIND(lastcp);
3610                         /* Couldn't or didn't -- move forward. */
3611                         old = locinput;
3612                         if (do_utf8)
3613                             locinput += UTF8SKIP(locinput);
3614                         else
3615                             locinput++;
3616                     }
3617                 }
3618                 else
3619                 while (n >= ln || (n == REG_INFTY && ln > 0)) { /* ln overflow ? */
3620                     UV c;
3621                     if (c1 != -1000) {
3622                         if (do_utf8)
3623                             c = utf8_to_uvchr((U8*)PL_reginput, NULL);
3624                         else
3625                             c = UCHARAT(PL_reginput);
3626                         /* If it could work, try it. */
3627                         if (c == c1 || c == c2)
3628                         {
3629                             TRYPAREN(paren, n, PL_reginput);
3630                             REGCP_UNWIND(lastcp);
3631                         }
3632                     }
3633                     /* If it could work, try it. */
3634                     else if (c1 == -1000)
3635                     {
3636                         TRYPAREN(paren, n, PL_reginput);
3637                         REGCP_UNWIND(lastcp);
3638                     }
3639                     /* Couldn't or didn't -- move forward. */
3640                     PL_reginput = locinput;
3641                     if (regrepeat(scan, 1)) {
3642                         ln++;
3643                         locinput = PL_reginput;
3644                     }
3645                     else
3646                         sayNO;
3647                 }
3648             }
3649             else {
3650                 CHECKPOINT lastcp;
3651                 n = regrepeat(scan, n);
3652                 locinput = PL_reginput;
3653                 if (ln < n && PL_regkind[(U8)OP(next)] == EOL &&
3654                     (!PL_multiline  || OP(next) == SEOL || OP(next) == EOS)) {
3655                     ln = n;                     /* why back off? */
3656                     /* ...because $ and \Z can match before *and* after
3657                        newline at the end.  Consider "\n\n" =~ /\n+\Z\n/.
3658                        We should back off by one in this case. */
3659                     if (UCHARAT(PL_reginput - 1) == '\n' && OP(next) != EOS)
3660                         ln--;
3661                 }
3662                 REGCP_SET(lastcp);
3663                 if (paren) {
3664                     UV c = 0;
3665                     while (n >= ln) {
3666                         if (c1 != -1000) {
3667                             if (do_utf8)
3668                                 c = utf8_to_uvchr((U8*)PL_reginput, NULL);
3669                             else
3670                                 c = UCHARAT(PL_reginput);
3671                         }
3672                         /* If it could work, try it. */
3673                         if (c1 == -1000 || c == c1 || c == c2)
3674                             {
3675                                 TRYPAREN(paren, n, PL_reginput);
3676                                 REGCP_UNWIND(lastcp);
3677                             }
3678                         /* Couldn't or didn't -- back up. */
3679                         n--;
3680                         PL_reginput = locinput = HOPc(locinput, -1);
3681                     }
3682                 }
3683                 else {
3684                     UV c = 0;
3685                     while (n >= ln) {
3686                         if (c1 != -1000) {
3687                             if (do_utf8)
3688                                 c = utf8_to_uvchr((U8*)PL_reginput, NULL);
3689                             else
3690                                 c = UCHARAT(PL_reginput);
3691                         }
3692                         /* If it could work, try it. */
3693                         if (c1 == -1000 || c == c1 || c == c2)
3694                             {
3695                                 TRYPAREN(paren, n, PL_reginput);
3696                                 REGCP_UNWIND(lastcp);
3697                             }
3698                         /* Couldn't or didn't -- back up. */
3699                         n--;
3700                         PL_reginput = locinput = HOPc(locinput, -1);
3701                     }
3702                 }
3703             }
3704             sayNO;
3705             break;
3706         case END:
3707             if (PL_reg_call_cc) {
3708                 re_cc_state *cur_call_cc = PL_reg_call_cc;
3709                 CURCUR *cctmp = PL_regcc;
3710                 regexp *re = PL_reg_re;
3711                 CHECKPOINT cp, lastcp;
3712
3713                 cp = regcppush(0);      /* Save *all* the positions. */
3714                 REGCP_SET(lastcp);
3715                 regcp_set_to(PL_reg_call_cc->ss); /* Restore parens of
3716                                                     the caller. */
3717                 PL_reginput = locinput; /* Make position available to
3718                                            the callcc. */
3719                 cache_re(PL_reg_call_cc->re);
3720                 PL_regcc = PL_reg_call_cc->cc;
3721                 PL_reg_call_cc = PL_reg_call_cc->prev;
3722                 if (regmatch(cur_call_cc->node)) {
3723                     PL_reg_call_cc = cur_call_cc;
3724                     regcpblow(cp);
3725                     sayYES;
3726                 }
3727                 REGCP_UNWIND(lastcp);
3728                 regcppop();
3729                 PL_reg_call_cc = cur_call_cc;
3730                 PL_regcc = cctmp;
3731                 PL_reg_re = re;
3732                 cache_re(re);
3733
3734                 DEBUG_r(
3735                     PerlIO_printf(Perl_debug_log,
3736                                   "%*s  continuation failed...\n",
3737                                   REPORT_CODE_OFF+PL_regindent*2, "")
3738                     );
3739                 sayNO_SILENT;
3740             }
3741             if (locinput < PL_regtill) {
3742                 DEBUG_r(PerlIO_printf(Perl_debug_log,
3743                                       "%sMatch possible, but length=%ld is smaller than requested=%ld, failing!%s\n",
3744                                       PL_colors[4],
3745                                       (long)(locinput - PL_reg_starttry),
3746                                       (long)(PL_regtill - PL_reg_starttry),
3747                                       PL_colors[5]));
3748                 sayNO_FINAL;            /* Cannot match: too short. */
3749             }
3750             PL_reginput = locinput;     /* put where regtry can find it */
3751             sayYES_FINAL;               /* Success! */
3752         case SUCCEED:
3753             PL_reginput = locinput;     /* put where regtry can find it */
3754             sayYES_LOUD;                /* Success! */
3755         case SUSPEND:
3756             n = 1;
3757             PL_reginput = locinput;
3758             goto do_ifmatch;
3759         case UNLESSM:
3760             n = 0;
3761             if (scan->flags) {
3762                 s = HOPBACKc(locinput, scan->flags);
3763                 if (!s)
3764                     goto say_yes;
3765                 PL_reginput = s;
3766             }
3767             else
3768                 PL_reginput = locinput;
3769             goto do_ifmatch;
3770         case IFMATCH:
3771             n = 1;
3772             if (scan->flags) {
3773                 s = HOPBACKc(locinput, scan->flags);
3774                 if (!s)
3775                     goto say_no;
3776                 PL_reginput = s;
3777             }
3778             else
3779                 PL_reginput = locinput;
3780
3781           do_ifmatch:
3782             inner = NEXTOPER(NEXTOPER(scan));
3783             if (regmatch(inner) != n) {
3784               say_no:
3785                 if (logical) {
3786                     logical = 0;
3787                     sw = 0;
3788                     goto do_longjump;
3789                 }
3790                 else
3791                     sayNO;
3792             }
3793           say_yes:
3794             if (logical) {
3795                 logical = 0;
3796                 sw = 1;
3797             }
3798             if (OP(scan) == SUSPEND) {
3799                 locinput = PL_reginput;
3800                 nextchr = UCHARAT(locinput);
3801             }
3802             /* FALL THROUGH. */
3803         case LONGJMP:
3804           do_longjump:
3805             next = scan + ARG(scan);
3806             if (next == scan)
3807                 next = NULL;
3808             break;
3809         default:
3810             PerlIO_printf(Perl_error_log, "%"UVxf" %d\n",
3811                           PTR2UV(scan), OP(scan));
3812             Perl_croak(aTHX_ "regexp memory corruption");
3813         }
3814       reenter:
3815         scan = next;
3816     }
3817
3818     /*
3819     * We get here only if there's trouble -- normally "case END" is
3820     * the terminating point.
3821     */
3822     Perl_croak(aTHX_ "corrupted regexp pointers");
3823     /*NOTREACHED*/
3824     sayNO;
3825
3826 yes_loud:
3827     DEBUG_r(
3828         PerlIO_printf(Perl_debug_log,
3829                       "%*s  %scould match...%s\n",
3830                       REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],PL_colors[5])
3831         );
3832     goto yes;
3833 yes_final:
3834     DEBUG_r(PerlIO_printf(Perl_debug_log, "%sMatch successful!%s\n",
3835                           PL_colors[4],PL_colors[5]));
3836 yes:
3837 #ifdef DEBUGGING
3838     PL_regindent--;
3839 #endif
3840
3841 #if 0                                   /* Breaks $^R */
3842     if (unwind)
3843         regcpblow(firstcp);
3844 #endif
3845     return 1;
3846
3847 no:
3848     DEBUG_r(
3849         PerlIO_printf(Perl_debug_log,
3850                       "%*s  %sfailed...%s\n",
3851                       REPORT_CODE_OFF+PL_regindent*2, "",PL_colors[4],PL_colors[5])
3852         );
3853     goto do_no;
3854 no_final:
3855 do_no:
3856     if (unwind) {
3857         re_unwind_t *uw = SSPTRt(unwind,re_unwind_t);
3858
3859         switch (uw->type) {
3860         case RE_UNWIND_BRANCH:
3861         case RE_UNWIND_BRANCHJ:
3862         {
3863             re_unwind_branch_t *uwb = &(uw->branch);
3864             I32 lastparen = uwb->lastparen;
3865
3866             REGCP_UNWIND(uwb->lastcp);
3867             for (n = *PL_reglastparen; n > lastparen; n--)
3868                 PL_regendp[n] = -1;
3869             *PL_reglastparen = n;
3870             scan = next = uwb->next;
3871             if ( !scan ||
3872                  OP(scan) != (uwb->type == RE_UNWIND_BRANCH
3873                               ? BRANCH : BRANCHJ) ) {           /* Failure */
3874                 unwind = uwb->prev;
3875 #ifdef DEBUGGING
3876                 PL_regindent--;
3877 #endif
3878                 goto do_no;
3879             }
3880             /* Have more choice yet.  Reuse the same uwb.  */
3881             /*SUPPRESS 560*/
3882             if ((n = (uwb->type == RE_UNWIND_BRANCH
3883                       ? NEXT_OFF(next) : ARG(next))))
3884                 next += n;
3885             else
3886                 next = NULL;    /* XXXX Needn't unwinding in this case... */
3887             uwb->next = next;
3888             next = NEXTOPER(scan);
3889             if (uwb->type == RE_UNWIND_BRANCHJ)
3890                 next = NEXTOPER(next);
3891             locinput = uwb->locinput;
3892             nextchr = uwb->nextchr;
3893 #ifdef DEBUGGING
3894             PL_regindent = uwb->regindent;
3895 #endif
3896
3897             goto reenter;
3898         }
3899         /* NOT REACHED */
3900         default:
3901             Perl_croak(aTHX_ "regexp unwind memory corruption");
3902         }
3903         /* NOT REACHED */
3904     }
3905 #ifdef DEBUGGING
3906     PL_regindent--;
3907 #endif
3908     return 0;
3909 }
3910
3911 /*
3912  - regrepeat - repeatedly match something simple, report how many
3913  */
3914 /*
3915  * [This routine now assumes that it will only match on things of length 1.
3916  * That was true before, but now we assume scan - reginput is the count,
3917  * rather than incrementing count on every character.  [Er, except utf8.]]
3918  */
3919 STATIC I32
3920 S_regrepeat(pTHX_ regnode *p, I32 max)
3921 {
3922     register char *scan;
3923     register I32 c;
3924     register char *loceol = PL_regeol;
3925     register I32 hardcount = 0;
3926     register bool do_utf8 = PL_reg_match_utf8;
3927
3928     scan = PL_reginput;
3929     if (max != REG_INFTY && max < loceol - scan)
3930       loceol = scan + max;
3931     switch (OP(p)) {
3932     case REG_ANY:
3933         if (do_utf8) {
3934             loceol = PL_regeol;
3935             while (scan < loceol && hardcount < max && *scan != '\n') {
3936                 scan += UTF8SKIP(scan);
3937                 hardcount++;
3938             }
3939         } else {
3940             while (scan < loceol && *scan != '\n')
3941                 scan++;
3942         }
3943         break;
3944     case SANY:
3945         scan = loceol;
3946         break;
3947     case CANY:
3948         scan = loceol;
3949         break;
3950     case EXACT:         /* length of string is 1 */
3951         c = (U8)*STRING(p);
3952         while (scan < loceol && UCHARAT(scan) == c)
3953             scan++;
3954         break;
3955     case EXACTF:        /* length of string is 1 */
3956         c = (U8)*STRING(p);
3957         while (scan < loceol &&
3958                (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold[c]))
3959             scan++;
3960         break;
3961     case EXACTFL:       /* length of string is 1 */
3962         PL_reg_flags |= RF_tainted;
3963         c = (U8)*STRING(p);
3964         while (scan < loceol &&
3965                (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold_locale[c]))
3966             scan++;
3967         break;
3968     case ANYOF:
3969         if (do_utf8) {
3970             loceol = PL_regeol;
3971             while (hardcount < max && scan < loceol &&
3972                    reginclass(p, (U8*)scan, do_utf8)) {
3973                 scan += UTF8SKIP(scan);
3974                 hardcount++;
3975             }
3976         } else {
3977             while (scan < loceol && reginclass(p, (U8*)scan, do_utf8))
3978                 scan++;
3979         }
3980         break;
3981     case ALNUM:
3982         if (do_utf8) {
3983             loceol = PL_regeol;
3984             LOAD_UTF8_CHARCLASS(alnum,"a");
3985             while (hardcount < max && scan < loceol &&
3986                    swash_fetch(PL_utf8_alnum, (U8*)scan, do_utf8)) {
3987                 scan += UTF8SKIP(scan);
3988                 hardcount++;
3989             }
3990         } else {
3991             while (scan < loceol && isALNUM(*scan))
3992                 scan++;
3993         }
3994         break;
3995     case ALNUML:
3996         PL_reg_flags |= RF_tainted;
3997         if (do_utf8) {
3998             loceol = PL_regeol;
3999             while (hardcount < max && scan < loceol &&
4000                    isALNUM_LC_utf8((U8*)scan)) {
4001                 scan += UTF8SKIP(scan);
4002                 hardcount++;
4003             }
4004         } else {
4005             while (scan < loceol && isALNUM_LC(*scan))
4006                 scan++;
4007         }
4008         break;
4009     case NALNUM:
4010         if (do_utf8) {
4011             loceol = PL_regeol;
4012             LOAD_UTF8_CHARCLASS(alnum,"a");
4013             while (hardcount < max && scan < loceol &&
4014                    !swash_fetch(PL_utf8_alnum, (U8*)scan, do_utf8)) {
4015                 scan += UTF8SKIP(scan);
4016                 hardcount++;
4017             }
4018         } else {
4019             while (scan < loceol && !isALNUM(*scan))
4020                 scan++;
4021         }
4022         break;
4023     case NALNUML:
4024         PL_reg_flags |= RF_tainted;
4025         if (do_utf8) {
4026             loceol = PL_regeol;
4027             while (hardcount < max && scan < loceol &&
4028                    !isALNUM_LC_utf8((U8*)scan)) {
4029                 scan += UTF8SKIP(scan);
4030                 hardcount++;
4031             }
4032         } else {
4033             while (scan < loceol && !isALNUM_LC(*scan))
4034                 scan++;
4035         }
4036         break;
4037     case SPACE:
4038         if (do_utf8) {
4039             loceol = PL_regeol;
4040             LOAD_UTF8_CHARCLASS(space," ");
4041             while (hardcount < max && scan < loceol &&
4042                    (*scan == ' ' ||
4043                     swash_fetch(PL_utf8_space,(U8*)scan, do_utf8))) {
4044                 scan += UTF8SKIP(scan);
4045                 hardcount++;
4046             }
4047         } else {
4048             while (scan < loceol && isSPACE(*scan))
4049                 scan++;
4050         }
4051         break;
4052     case SPACEL:
4053         PL_reg_flags |= RF_tainted;
4054         if (do_utf8) {
4055             loceol = PL_regeol;
4056             while (hardcount < max && scan < loceol &&
4057                    (*scan == ' ' || isSPACE_LC_utf8((U8*)scan))) {
4058                 scan += UTF8SKIP(scan);
4059                 hardcount++;
4060             }
4061         } else {
4062             while (scan < loceol && isSPACE_LC(*scan))
4063                 scan++;
4064         }
4065         break;
4066     case NSPACE:
4067         if (do_utf8) {
4068             loceol = PL_regeol;
4069             LOAD_UTF8_CHARCLASS(space," ");
4070             while (hardcount < max && scan < loceol &&
4071                    !(*scan == ' ' ||
4072                      swash_fetch(PL_utf8_space,(U8*)scan, do_utf8))) {
4073                 scan += UTF8SKIP(scan);
4074                 hardcount++;
4075             }
4076         } else {
4077             while (scan < loceol && !isSPACE(*scan))
4078                 scan++;
4079             break;
4080         }
4081     case NSPACEL:
4082         PL_reg_flags |= RF_tainted;
4083         if (do_utf8) {
4084             loceol = PL_regeol;
4085             while (hardcount < max && scan < loceol &&
4086                    !(*scan == ' ' || isSPACE_LC_utf8((U8*)scan))) {
4087                 scan += UTF8SKIP(scan);
4088                 hardcount++;
4089             }
4090         } else {
4091             while (scan < loceol && !isSPACE_LC(*scan))
4092                 scan++;
4093         }
4094         break;
4095     case DIGIT:
4096         if (do_utf8) {
4097             loceol = PL_regeol;
4098             LOAD_UTF8_CHARCLASS(digit,"0");
4099             while (hardcount < max && scan < loceol &&
4100                    swash_fetch(PL_utf8_digit, (U8*)scan, do_utf8)) {
4101                 scan += UTF8SKIP(scan);
4102                 hardcount++;
4103             }
4104         } else {
4105             while (scan < loceol && isDIGIT(*scan))
4106                 scan++;
4107         }
4108         break;
4109     case NDIGIT:
4110         if (do_utf8) {
4111             loceol = PL_regeol;
4112             LOAD_UTF8_CHARCLASS(digit,"0");
4113             while (hardcount < max && scan < loceol &&
4114                    !swash_fetch(PL_utf8_digit, (U8*)scan, do_utf8)) {
4115                 scan += UTF8SKIP(scan);
4116                 hardcount++;
4117             }
4118         } else {
4119             while (scan < loceol && !isDIGIT(*scan))
4120                 scan++;
4121         }
4122         break;
4123     default:            /* Called on something of 0 width. */
4124         break;          /* So match right here or not at all. */
4125     }
4126
4127     if (hardcount)
4128         c = hardcount;
4129     else
4130         c = scan - PL_reginput;
4131     PL_reginput = scan;
4132
4133     DEBUG_r(
4134         {
4135                 SV *prop = sv_newmortal();
4136
4137                 regprop(prop, p);
4138                 PerlIO_printf(Perl_debug_log,
4139                               "%*s  %s can match %"IVdf" times out of %"IVdf"...\n",
4140                               REPORT_CODE_OFF+1, "", SvPVX(prop),(IV)c,(IV)max);
4141         });
4142
4143     return(c);
4144 }
4145
4146 /*
4147  - regrepeat_hard - repeatedly match something, report total lenth and length
4148  *
4149  * The repeater is supposed to have constant length.
4150  */
4151
4152 STATIC I32
4153 S_regrepeat_hard(pTHX_ regnode *p, I32 max, I32 *lp)
4154 {
4155     register char *scan = Nullch;
4156     register char *start;
4157     register char *loceol = PL_regeol;
4158     I32 l = 0;
4159     I32 count = 0, res = 1;
4160
4161     if (!max)
4162         return 0;
4163
4164     start = PL_reginput;
4165     if (PL_reg_match_utf8) {
4166         while (PL_reginput < loceol && (scan = PL_reginput, res = regmatch(p))) {
4167             if (!count++) {
4168                 l = 0;
4169                 while (start < PL_reginput) {
4170                     l++;
4171                     start += UTF8SKIP(start);
4172                 }
4173                 *lp = l;
4174                 if (l == 0)
4175                     return max;
4176             }
4177             if (count == max)
4178                 return count;
4179         }
4180     }
4181     else {
4182         while (PL_reginput < loceol && (scan = PL_reginput, res = regmatch(p))) {
4183             if (!count++) {
4184                 *lp = l = PL_reginput - start;
4185                 if (max != REG_INFTY && l*max < loceol - scan)
4186                     loceol = scan + l*max;
4187                 if (l == 0)
4188                     return max;
4189             }
4190         }
4191     }
4192     if (!res)
4193         PL_reginput = scan;
4194
4195     return count;
4196 }
4197
4198 /*
4199 - regclass_swash - prepare the utf8 swash
4200 */
4201
4202 SV *
4203 Perl_regclass_swash(pTHX_ register regnode* node, bool doinit, SV** initsvp)
4204 {
4205     SV *sw = NULL;
4206     SV *si = NULL;
4207
4208     if (PL_regdata && PL_regdata->count) {
4209         U32 n = ARG(node);
4210
4211         if (PL_regdata->what[n] == 's') {
4212             SV *rv = (SV*)PL_regdata->data[n];
4213             AV *av = (AV*)SvRV((SV*)rv);
4214             SV **a;
4215
4216             si = *av_fetch(av, 0, FALSE);
4217             a  =  av_fetch(av, 1, FALSE);
4218
4219             if (a)
4220                 sw = *a;
4221             else if (si && doinit) {
4222                 sw = swash_init("utf8", "", si, 1, 0);
4223                 (void)av_store(av, 1, sw);
4224             }
4225         }
4226     }
4227
4228     if (initsvp)
4229         *initsvp = si;
4230
4231     return sw;
4232 }
4233
4234 /*
4235  - reginclass - determine if a character falls into a character class
4236  */
4237
4238 STATIC bool
4239 S_reginclass(pTHX_ register regnode *n, register U8* p, register bool do_utf8)
4240 {
4241     char flags = ANYOF_FLAGS(n);
4242     bool match = FALSE;
4243     UV c;
4244     STRLEN len = 0;
4245
4246     c = do_utf8 ? utf8_to_uvchr(p, &len) : *p;
4247
4248     if (do_utf8 || (flags & ANYOF_UNICODE)) {
4249         if (do_utf8 && !ANYOF_RUNTIME(n)) {
4250             if (len != (STRLEN)-1 && c < 256 && ANYOF_BITMAP_TEST(n, c))
4251                 match = TRUE;
4252         }
4253         if (!match && do_utf8 && (flags & ANYOF_UNICODE_ALL) && c >= 256)
4254             match = TRUE;
4255         if (!match) {
4256             SV *sw = regclass_swash(n, TRUE, 0);
4257
4258             if (sw) {
4259                 if (swash_fetch(sw, p, do_utf8))
4260                     match = TRUE;
4261                 else if (flags & ANYOF_FOLD) {
4262                     STRLEN ulen;
4263                     U8 tmpbuf[UTF8_MAXLEN_FOLD+1];
4264
4265                     to_utf8_fold(p, tmpbuf, &ulen);
4266                     if (swash_fetch(sw, tmpbuf, do_utf8))
4267                         match = TRUE;
4268                     to_utf8_upper(p, tmpbuf, &ulen);
4269                     if (swash_fetch(sw, tmpbuf, do_utf8))
4270                         match = TRUE;
4271                 }
4272             }
4273         }
4274     }
4275     if (!match && c < 256) {
4276         if (ANYOF_BITMAP_TEST(n, c))
4277             match = TRUE;
4278         else if (flags & ANYOF_FOLD) {
4279           I32 f;
4280
4281             if (flags & ANYOF_LOCALE) {
4282                 PL_reg_flags |= RF_tainted;
4283                 f = PL_fold_locale[c];
4284             }
4285             else
4286                 f = PL_fold[c];
4287             if (f != c && ANYOF_BITMAP_TEST(n, f))
4288                 match = TRUE;
4289         }
4290
4291         if (!match && (flags & ANYOF_CLASS)) {
4292             PL_reg_flags |= RF_tainted;
4293             if (
4294                 (ANYOF_CLASS_TEST(n, ANYOF_ALNUM)   &&  isALNUM_LC(c))  ||
4295                 (ANYOF_CLASS_TEST(n, ANYOF_NALNUM)  && !isALNUM_LC(c))  ||
4296                 (ANYOF_CLASS_TEST(n, ANYOF_SPACE)   &&  isSPACE_LC(c))  ||
4297                 (ANYOF_CLASS_TEST(n, ANYOF_NSPACE)  && !isSPACE_LC(c))  ||
4298                 (ANYOF_CLASS_TEST(n, ANYOF_DIGIT)   &&  isDIGIT_LC(c))  ||
4299                 (ANYOF_CLASS_TEST(n, ANYOF_NDIGIT)  && !isDIGIT_LC(c))  ||
4300                 (ANYOF_CLASS_TEST(n, ANYOF_ALNUMC)  &&  isALNUMC_LC(c)) ||
4301                 (ANYOF_CLASS_TEST(n, ANYOF_NALNUMC) && !isALNUMC_LC(c)) ||
4302                 (ANYOF_CLASS_TEST(n, ANYOF_ALPHA)   &&  isALPHA_LC(c))  ||
4303                 (ANYOF_CLASS_TEST(n, ANYOF_NALPHA)  && !isALPHA_LC(c))  ||
4304                 (ANYOF_CLASS_TEST(n, ANYOF_ASCII)   &&  isASCII(c))     ||
4305                 (ANYOF_CLASS_TEST(n, ANYOF_NASCII)  && !isASCII(c))     ||
4306                 (ANYOF_CLASS_TEST(n, ANYOF_CNTRL)   &&  isCNTRL_LC(c))  ||
4307                 (ANYOF_CLASS_TEST(n, ANYOF_NCNTRL)  && !isCNTRL_LC(c))  ||
4308                 (ANYOF_CLASS_TEST(n, ANYOF_GRAPH)   &&  isGRAPH_LC(c))  ||
4309                 (ANYOF_CLASS_TEST(n, ANYOF_NGRAPH)  && !isGRAPH_LC(c))  ||
4310                 (ANYOF_CLASS_TEST(n, ANYOF_LOWER)   &&  isLOWER_LC(c))  ||
4311                 (ANYOF_CLASS_TEST(n, ANYOF_NLOWER)  && !isLOWER_LC(c))  ||
4312                 (ANYOF_CLASS_TEST(n, ANYOF_PRINT)   &&  isPRINT_LC(c))  ||
4313                 (ANYOF_CLASS_TEST(n, ANYOF_NPRINT)  && !isPRINT_LC(c))  ||
4314                 (ANYOF_CLASS_TEST(n, ANYOF_PUNCT)   &&  isPUNCT_LC(c))  ||
4315                 (ANYOF_CLASS_TEST(n, ANYOF_NPUNCT)  && !isPUNCT_LC(c))  ||
4316                 (ANYOF_CLASS_TEST(n, ANYOF_UPPER)   &&  isUPPER_LC(c))  ||
4317                 (ANYOF_CLASS_TEST(n, ANYOF_NUPPER)  && !isUPPER_LC(c))  ||
4318                 (ANYOF_CLASS_TEST(n, ANYOF_XDIGIT)  &&  isXDIGIT(c))    ||
4319                 (ANYOF_CLASS_TEST(n, ANYOF_NXDIGIT) && !isXDIGIT(c))    ||
4320                 (ANYOF_CLASS_TEST(n, ANYOF_PSXSPC)  &&  isPSXSPC(c))    ||
4321                 (ANYOF_CLASS_TEST(n, ANYOF_NPSXSPC) && !isPSXSPC(c))    ||
4322                 (ANYOF_CLASS_TEST(n, ANYOF_BLANK)   &&  isBLANK(c))     ||
4323                 (ANYOF_CLASS_TEST(n, ANYOF_NBLANK)  && !isBLANK(c))
4324                 ) /* How's that for a conditional? */
4325             {
4326                 match = TRUE;
4327             }
4328         }
4329     }
4330
4331     return (flags & ANYOF_INVERT) ? !match : match;
4332 }
4333
4334 STATIC U8 *
4335 S_reghop(pTHX_ U8 *s, I32 off)
4336 {
4337     return S_reghop3(aTHX_ s, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr));
4338 }
4339
4340 STATIC U8 *
4341 S_reghop3(pTHX_ U8 *s, I32 off, U8* lim)
4342 {
4343     if (off >= 0) {
4344         while (off-- && s < lim) {
4345             /* XXX could check well-formedness here */
4346             s += UTF8SKIP(s);
4347         }
4348     }
4349     else {
4350         while (off++) {
4351             if (s > lim) {
4352                 s--;
4353                 if (UTF8_IS_CONTINUED(*s)) {
4354                     while (s > (U8*)lim && UTF8_IS_CONTINUATION(*s))
4355                         s--;
4356                 }
4357                 /* XXX could check well-formedness here */
4358             }
4359         }
4360     }
4361     return s;
4362 }
4363
4364 STATIC U8 *
4365 S_reghopmaybe(pTHX_ U8 *s, I32 off)
4366 {
4367     return S_reghopmaybe3(aTHX_ s, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr));
4368 }
4369
4370 STATIC U8 *
4371 S_reghopmaybe3(pTHX_ U8* s, I32 off, U8* lim)
4372 {
4373     if (off >= 0) {
4374         while (off-- && s < lim) {
4375             /* XXX could check well-formedness here */
4376             s += UTF8SKIP(s);
4377         }
4378         if (off >= 0)
4379             return 0;
4380     }
4381     else {
4382         while (off++) {
4383             if (s > lim) {
4384                 s--;
4385                 if (UTF8_IS_CONTINUED(*s)) {
4386                     while (s > (U8*)lim && UTF8_IS_CONTINUATION(*s))
4387                         s--;
4388                 }
4389                 /* XXX could check well-formedness here */
4390             }
4391             else
4392                 break;
4393         }
4394         if (off <= 0)
4395             return 0;
4396     }
4397     return s;
4398 }
4399
4400 static void
4401 restore_pos(pTHX_ void *arg)
4402 {
4403     if (PL_reg_eval_set) {
4404         if (PL_reg_oldsaved) {
4405             PL_reg_re->subbeg = PL_reg_oldsaved;
4406             PL_reg_re->sublen = PL_reg_oldsavedlen;
4407             RX_MATCH_COPIED_on(PL_reg_re);
4408         }
4409         PL_reg_magic->mg_len = PL_reg_oldpos;
4410         PL_reg_eval_set = 0;
4411         PL_curpm = PL_reg_oldcurpm;
4412     }
4413 }