This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
integrate cfgperl contents into mainline
[perl5.git] / regexec.c
index b464a40..9a7e91b 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -1322,1772 +1322,475 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
                s += UTF8SKIP(s);
            }
            break;
-       case ALNUMC:
-           while (s < strend) {
-               if (isALNUMC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case ALNUMCUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_alnumc, (U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case ALNUMCL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isALNUMC_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case ALNUMCLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isALNUMC_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NALNUMC:
-           while (s < strend) {
-               if (!isALNUMC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
+       }
+    }
+    else {
+       dontbother = 0;
+       if (prog->float_substr != Nullsv) {     /* Trim the end. */
+           char *last;
+           I32 oldpos = scream_pos;
+
+           if (flags & REXEC_SCREAM) {
+               last = screaminstr(sv, prog->float_substr, s - strbeg,
+                                  end_shift, &scream_pos, 1); /* last one */
+               if (!last)
+                   last = scream_olds; /* Only one occurence. */
            }
-           break;
-       case NALNUMCUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_alnumc, (U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
+           else {
+               STRLEN len;
+               char *little = SvPV(prog->float_substr, len);
+
+               if (SvTAIL(prog->float_substr)) {
+                   if (memEQ(strend - len + 1, little, len - 1))
+                       last = strend - len + 1;
+                   else if (!PL_multiline)
+                       last = memEQ(strend - len, little, len) 
+                           ? strend - len : Nullch;
                    else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NALNUMCL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isALNUMC_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
+                       goto find_last;
+               } else {
+                 find_last:
+                   if (len) 
+                       last = rninstr(s, strend, little, little + len);
                    else
-                       tmp = doevery;
+                       last = strend;  /* matching `$' */
                }
-               else
-                   tmp = 1;
-               s++;
            }
-           break;
-       case NALNUMCLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isALNUMC_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
+           if (last == NULL) goto phooey; /* Should not happen! */
+           dontbother = strend - last + prog->float_min_offset;
+       }
+       if (minlen && (dontbother < minlen))
+           dontbother = minlen - 1;
+       strend -= dontbother;              /* this one's always in bytes! */
+       /* We don't know much -- general case. */
+       if (UTF) {
+           for (;;) {
+               if (regtry(prog, s))
+                   goto got_it;
+               if (s >= strend)
+                   break;
                s += UTF8SKIP(s);
+           };
+       }
+       else {
+           do {
+               if (regtry(prog, s))
+                   goto got_it;
+           } while (s++ < strend);
+       }
+    }
+
+    /* Failure. */
+    goto phooey;
+
+got_it:
+    RX_MATCH_TAINTED_set(prog, PL_reg_flags & RF_tainted);
+
+    if (PL_reg_eval_set) {
+       /* Preserve the current value of $^R */
+       if (oreplsv != GvSV(PL_replgv))
+           sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
+                                                 restored, the value remains
+                                                 the same. */
+       restore_pos(aTHXo_ 0);
+    }
+
+    /* make sure $`, $&, $', and $digit will work later */
+    if ( !(flags & REXEC_NOT_FIRST) ) {
+       if (RX_MATCH_COPIED(prog)) {
+           Safefree(prog->subbeg);
+           RX_MATCH_COPIED_off(prog);
+       }
+       if (flags & REXEC_COPY_STR) {
+           I32 i = PL_regeol - startpos + (stringarg - strbeg);
+
+           s = savepvn(strbeg, i);
+           prog->subbeg = s;
+           prog->sublen = i;
+           RX_MATCH_COPIED_on(prog);
+       }
+       else {
+           prog->subbeg = strbeg;
+           prog->sublen = PL_regeol - strbeg;  /* strend may have been modified */
+       }
+    }
+    
+    return 1;
+
+phooey:
+    if (PL_reg_eval_set)
+       restore_pos(aTHXo_ 0);
+    return 0;
+}
+
+/*
+ - regtry - try match at specific point
+ */
+STATIC I32                     /* 0 failure, 1 success */
+S_regtry(pTHX_ regexp *prog, char *startpos)
+{
+    dTHR;
+    register I32 i;
+    register I32 *sp;
+    register I32 *ep;
+    CHECKPOINT lastcp;
+
+    if ((prog->reganch & ROPT_EVAL_SEEN) && !PL_reg_eval_set) {
+       MAGIC *mg;
+
+       PL_reg_eval_set = RS_init;
+       DEBUG_r(DEBUG_s(
+           PerlIO_printf(Perl_debug_log, "  setting stack tmpbase at %i\n",
+                         PL_stack_sp - PL_stack_base);
+           ));
+       SAVEINT(cxstack[cxstack_ix].blk_oldsp);
+       cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
+       /* Otherwise OP_NEXTSTATE will free whatever on stack now.  */
+       SAVETMPS;
+       /* Apparently this is not needed, judging by wantarray. */
+       /* SAVEINT(cxstack[cxstack_ix].blk_gimme);
+          cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
+
+       if (PL_reg_sv) {
+           /* Make $_ available to executed code. */
+           if (PL_reg_sv != DEFSV) {
+               /* SAVE_DEFSV does *not* suffice here for USE_THREADS */
+               SAVESPTR(DEFSV);
+               DEFSV = PL_reg_sv;
            }
-           break;
-       case ASCII:
-           while (s < strend) {
-               if (isASCII(*(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NASCII:
-           while (s < strend) {
-               if (!isASCII(*(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case CNTRL:
-           while (s < strend) {
-               if (isCNTRL(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case CNTRLUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_cntrl,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case CNTRLL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isCNTRL_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case CNTRLLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (*s == ' ' || isCNTRL_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NCNTRL:
-           while (s < strend) {
-               if (!isCNTRL(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NCNTRLUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_cntrl,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NCNTRLL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isCNTRL_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NCNTRLLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isCNTRL_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case GRAPH:
-           while (s < strend) {
-               if (isGRAPH(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case GRAPHUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_graph,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case GRAPHL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isGRAPH_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case GRAPHLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (*s == ' ' || isGRAPH_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NGRAPH:
-           while (s < strend) {
-               if (!isGRAPH(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NGRAPHUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_graph,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NGRAPHL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isGRAPH_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NGRAPHLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isGRAPH_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case LOWER:
-           while (s < strend) {
-               if (isLOWER(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case LOWERUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_lower,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case LOWERL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isLOWER_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case LOWERLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (*s == ' ' || isLOWER_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NLOWER:
-           while (s < strend) {
-               if (!isLOWER(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NLOWERUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_lower,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NLOWERL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isLOWER_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NLOWERLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isLOWER_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case PRINT:
-           while (s < strend) {
-               if (isPRINT(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case PRINTUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_print,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case PRINTL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isPRINT_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case PRINTLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (*s == ' ' || isPRINT_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NPRINT:
-           while (s < strend) {
-               if (!isPRINT(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NPRINTUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_print,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NPRINTL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isPRINT_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NPRINTLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isPRINT_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case PUNCT:
-           while (s < strend) {
-               if (isPUNCT(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case PUNCTUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_punct,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case PUNCTL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isPUNCT_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case PUNCTLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (*s == ' ' || isPUNCT_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NPUNCT:
-           while (s < strend) {
-               if (!isPUNCT(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NPUNCTUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_punct,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NPUNCTL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isPUNCT_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NPUNCTLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isPUNCT_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case UPPER:
-           while (s < strend) {
-               if (isUPPER(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case UPPERUTF8:
-           while (s < strend) {
-               if (swash_fetch(PL_utf8_upper,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case UPPERL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (isUPPER_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case UPPERLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (*s == ' ' || isUPPER_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NUPPER:
-           while (s < strend) {
-               if (!isUPPER(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NUPPERUTF8:
-           while (s < strend) {
-               if (!swash_fetch(PL_utf8_upper,(U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case NUPPERL:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isUPPER_LC(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NUPPERLUTF8:
-           PL_reg_flags |= RF_tainted;
-           while (s < strend) {
-               if (!isUPPER_LC_utf8((U8*)s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s += UTF8SKIP(s);
-           }
-           break;
-       case XDIGIT:
-           while (s < strend) {
-               if (isXDIGIT(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       case NXDIGIT:
-           while (s < strend) {
-               if (!isXDIGIT(*s)) {
-                   if (tmp && regtry(prog, s))
-                       goto got_it;
-                   else
-                       tmp = doevery;
-               }
-               else
-                   tmp = 1;
-               s++;
-           }
-           break;
-       }
-    }
-    else {
-       dontbother = 0;
-       if (prog->float_substr != Nullsv) {     /* Trim the end. */
-           char *last;
-           I32 oldpos = scream_pos;
-
-           if (flags & REXEC_SCREAM) {
-               last = screaminstr(sv, prog->float_substr, s - strbeg,
-                                  end_shift, &scream_pos, 1); /* last one */
-               if (!last)
-                   last = scream_olds; /* Only one occurence. */
-           }
-           else {
-               STRLEN len;
-               char *little = SvPV(prog->float_substr, len);
-
-               if (SvTAIL(prog->float_substr)) {
-                   if (memEQ(strend - len + 1, little, len - 1))
-                       last = strend - len + 1;
-                   else if (!PL_multiline)
-                       last = memEQ(strend - len, little, len) 
-                           ? strend - len : Nullch;
-                   else
-                       goto find_last;
-               } else {
-                 find_last:
-                   if (len) 
-                       last = rninstr(s, strend, little, little + len);
-                   else
-                       last = strend;  /* matching `$' */
-               }
-           }
-           if (last == NULL) goto phooey; /* Should not happen! */
-           dontbother = strend - last + prog->float_min_offset;
-       }
-       if (minlen && (dontbother < minlen))
-           dontbother = minlen - 1;
-       strend -= dontbother;              /* this one's always in bytes! */
-       /* We don't know much -- general case. */
-       if (UTF) {
-           for (;;) {
-               if (regtry(prog, s))
-                   goto got_it;
-               if (s >= strend)
-                   break;
-               s += UTF8SKIP(s);
-           };
-       }
-       else {
-           do {
-               if (regtry(prog, s))
-                   goto got_it;
-           } while (s++ < strend);
-       }
-    }
-
-    /* Failure. */
-    goto phooey;
-
-got_it:
-    RX_MATCH_TAINTED_set(prog, PL_reg_flags & RF_tainted);
-
-    if (PL_reg_eval_set) {
-       /* Preserve the current value of $^R */
-       if (oreplsv != GvSV(PL_replgv))
-           sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
-                                                 restored, the value remains
-                                                 the same. */
-       restore_pos(aTHXo_ 0);
-    }
-
-    /* make sure $`, $&, $', and $digit will work later */
-    if ( !(flags & REXEC_NOT_FIRST) ) {
-       if (RX_MATCH_COPIED(prog)) {
-           Safefree(prog->subbeg);
-           RX_MATCH_COPIED_off(prog);
-       }
-       if (flags & REXEC_COPY_STR) {
-           I32 i = PL_regeol - startpos + (stringarg - strbeg);
-
-           s = savepvn(strbeg, i);
-           prog->subbeg = s;
-           prog->sublen = i;
-           RX_MATCH_COPIED_on(prog);
-       }
-       else {
-           prog->subbeg = strbeg;
-           prog->sublen = PL_regeol - strbeg;  /* strend may have been modified */
-       }
-    }
-    
-    return 1;
-
-phooey:
-    if (PL_reg_eval_set)
-       restore_pos(aTHXo_ 0);
-    return 0;
-}
-
-/*
- - regtry - try match at specific point
- */
-STATIC I32                     /* 0 failure, 1 success */
-S_regtry(pTHX_ regexp *prog, char *startpos)
-{
-    dTHR;
-    register I32 i;
-    register I32 *sp;
-    register I32 *ep;
-    CHECKPOINT lastcp;
-
-    if ((prog->reganch & ROPT_EVAL_SEEN) && !PL_reg_eval_set) {
-       MAGIC *mg;
-
-       PL_reg_eval_set = RS_init;
-       DEBUG_r(DEBUG_s(
-           PerlIO_printf(Perl_debug_log, "  setting stack tmpbase at %i\n",
-                         PL_stack_sp - PL_stack_base);
-           ));
-       SAVEINT(cxstack[cxstack_ix].blk_oldsp);
-       cxstack[cxstack_ix].blk_oldsp = PL_stack_sp - PL_stack_base;
-       /* Otherwise OP_NEXTSTATE will free whatever on stack now.  */
-       SAVETMPS;
-       /* Apparently this is not needed, judging by wantarray. */
-       /* SAVEINT(cxstack[cxstack_ix].blk_gimme);
-          cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
-
-       if (PL_reg_sv) {
-           /* Make $_ available to executed code. */
-           if (PL_reg_sv != DEFSV) {
-               /* SAVE_DEFSV does *not* suffice here for USE_THREADS */
-               SAVESPTR(DEFSV);
-               DEFSV = PL_reg_sv;
-           }
-       
-           if (!(SvTYPE(PL_reg_sv) >= SVt_PVMG && SvMAGIC(PL_reg_sv) 
-                 && (mg = mg_find(PL_reg_sv, 'g')))) {
-               /* prepare for quick setting of pos */
-               sv_magic(PL_reg_sv, (SV*)0, 'g', Nullch, 0);
-               mg = mg_find(PL_reg_sv, 'g');
-               mg->mg_len = -1;
-           }
-           PL_reg_magic    = mg;
-           PL_reg_oldpos   = mg->mg_len;
-           SAVEDESTRUCTOR(restore_pos, 0);
-        }
-       if (!PL_reg_curpm)
-           New(22,PL_reg_curpm, 1, PMOP);
-       PL_reg_curpm->op_pmregexp = prog;
-       PL_reg_oldcurpm = PL_curpm;
-       PL_curpm = PL_reg_curpm;
-       if (RX_MATCH_COPIED(prog)) {
-           /*  Here is a serious problem: we cannot rewrite subbeg,
-               since it may be needed if this match fails.  Thus
-               $` inside (?{}) could fail... */
-           PL_reg_oldsaved = prog->subbeg;
-           PL_reg_oldsavedlen = prog->sublen;
-           RX_MATCH_COPIED_off(prog);
-       }
-       else
-           PL_reg_oldsaved = Nullch;
-       prog->subbeg = PL_bostr;
-       prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
-    }
-    prog->startp[0] = startpos - PL_bostr;
-    PL_reginput = startpos;
-    PL_regstartp = prog->startp;
-    PL_regendp = prog->endp;
-    PL_reglastparen = &prog->lastparen;
-    prog->lastparen = 0;
-    PL_regsize = 0;
-    DEBUG_r(PL_reg_starttry = startpos);
-    if (PL_reg_start_tmpl <= prog->nparens) {
-       PL_reg_start_tmpl = prog->nparens*3/2 + 3;
-        if(PL_reg_start_tmp)
-            Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
-        else
-            New(22,PL_reg_start_tmp, PL_reg_start_tmpl, char*);
-    }
-
-    /* XXXX What this code is doing here?!!!  There should be no need
-       to do this again and again, PL_reglastparen should take care of
-       this!  */
-    sp = prog->startp;
-    ep = prog->endp;
-    if (prog->nparens) {
-       for (i = prog->nparens; i >= 1; i--) {
-           *++sp = -1;
-           *++ep = -1;
-       }
-    }
-    REGCP_SET;
-    if (regmatch(prog->program + 1)) {
-       prog->endp[0] = PL_reginput - PL_bostr;
-       return 1;
-    }
-    REGCP_UNWIND;
-    return 0;
-}
-
-/*
- - regmatch - main matching routine
- *
- * Conceptually the strategy is simple:  check to see whether the current
- * node matches, call self recursively to see whether the rest matches,
- * and then act accordingly.  In practice we make some effort to avoid
- * recursion, in particular by going through "ordinary" nodes (that don't
- * need to know whether the rest of the match failed) by a loop instead of
- * by recursion.
- */
-/* [lwall] I've hoisted the register declarations to the outer block in order to
- * maybe save a little bit of pushing and popping on the stack.  It also takes
- * advantage of machines that use a register save mask on subroutine entry.
- */
-STATIC I32                     /* 0 failure, 1 success */
-S_regmatch(pTHX_ regnode *prog)
-{
-    dTHR;
-    register regnode *scan;    /* Current node. */
-    regnode *next;             /* Next node. */
-    regnode *inner;            /* Next node in internal branch. */
-    register I32 nextchr;      /* renamed nextchr - nextchar colides with
-                                  function of same name */
-    register I32 n;            /* no or next */
-    register I32 ln;           /* len or last */
-    register char *s;          /* operand or save */
-    register char *locinput = PL_reginput;
-    register I32 c1, c2, paren;        /* case fold search, parenth */
-    int minmod = 0, sw = 0, logical = 0;
-#ifdef DEBUGGING
-    PL_regindent++;
-#endif
-
-    /* Note that nextchr is a byte even in UTF */
-    nextchr = UCHARAT(locinput);
-    scan = prog;
-    while (scan != NULL) {
-#define sayNO_L (logical ? (logical = 0, sw = 0, goto cont) : sayNO)
-#ifdef DEBUGGING
-#  define sayYES goto yes
-#  define sayNO goto no
-#  define saySAME(x) if (x) goto yes; else goto no
-#  define REPORT_CODE_OFF 24
-#else
-#  define sayYES return 1
-#  define sayNO return 0
-#  define saySAME(x) return x
-#endif
-       DEBUG_r( {
-           SV *prop = sv_newmortal();
-           int docolor = *PL_colors[0];
-           int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
-           int l = (PL_regeol - locinput > taill ? taill : PL_regeol - locinput);
-           /* The part of the string before starttry has one color
-              (pref0_len chars), between starttry and current
-              position another one (pref_len - pref0_len chars),
-              after the current position the third one.
-              We assume that pref0_len <= pref_len, otherwise we
-              decrease pref0_len.  */
-           int pref_len = (locinput - PL_bostr > (5 + taill) - l 
-                           ? (5 + taill) - l : locinput - PL_bostr);
-           int pref0_len = pref_len  - (locinput - PL_reg_starttry);
-
-           if (l + pref_len < (5 + taill) && l < PL_regeol - locinput)
-               l = ( PL_regeol - locinput > (5 + taill) - pref_len 
-                     ? (5 + taill) - pref_len : PL_regeol - locinput);
-           if (pref0_len < 0)
-               pref0_len = 0;
-           if (pref0_len > pref_len)
-               pref0_len = pref_len;
-           regprop(prop, scan);
-           PerlIO_printf(Perl_debug_log, 
-                         "%4i <%s%.*s%s%s%.*s%s%s%s%.*s%s>%*s|%3d:%*s%s\n",
-                         locinput - PL_bostr, 
-                         PL_colors[4], pref0_len, 
-                         locinput - pref_len, PL_colors[5],
-                         PL_colors[2], pref_len - pref0_len, 
-                         locinput - pref_len + pref0_len, PL_colors[3],
-                         (docolor ? "" : "> <"),
-                         PL_colors[0], l, locinput, PL_colors[1],
-                         15 - l - pref_len + 1,
-                         "",
-                         scan - PL_regprogram, PL_regindent*2, "",
-                         SvPVX(prop));
-       } );
-
-       next = scan + NEXT_OFF(scan);
-       if (next == scan)
-           next = NULL;
-
-       switch (OP(scan)) {
-       case BOL:
-           if (locinput == PL_bostr
-               ? PL_regprev == '\n'
-               : (PL_multiline && 
-                  (nextchr || locinput < PL_regeol) && locinput[-1] == '\n') )
-           {
-               /* regtill = regbol; */
-               break;
-           }
-           sayNO;
-       case MBOL:
-           if (locinput == PL_bostr
-               ? PL_regprev == '\n'
-               : ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n') )
-           {
-               break;
-           }
-           sayNO;
-       case SBOL:
-           if (locinput == PL_regbol && PL_regprev == '\n')
-               break;
-           sayNO;
-       case GPOS:
-           if (locinput == PL_reg_ganch)
-               break;
-           sayNO;
-       case EOL:
-           if (PL_multiline)
-               goto meol;
-           else
-               goto seol;
-       case MEOL:
-         meol:
-           if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
-               sayNO;
-           break;
-       case SEOL:
-         seol:
-           if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
-               sayNO;
-           if (PL_regeol - locinput > 1)
-               sayNO;
-           break;
-       case EOS:
-           if (PL_regeol != locinput)
-               sayNO;
-           break;
-       case SANYUTF8:
-           if (nextchr & 0x80) {
-               locinput += PL_utf8skip[nextchr];
-               if (locinput > PL_regeol)
-                   sayNO;
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case SANY:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ANYUTF8:
-           if (nextchr & 0x80) {
-               locinput += PL_utf8skip[nextchr];
-               if (locinput > PL_regeol)
-                   sayNO;
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (!nextchr && locinput >= PL_regeol || nextchr == '\n')
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case REG_ANY:
-           if (!nextchr && locinput >= PL_regeol || nextchr == '\n')
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case EXACT:
-           s = (char *) OPERAND(scan);
-           ln = UCHARAT(s++);
-           /* Inline the first character, for speed. */
-           if (UCHARAT(s) != nextchr)
-               sayNO;
-           if (PL_regeol - locinput < ln)
-               sayNO;
-           if (ln > 1 && memNE(s, locinput, ln))
-               sayNO;
-           locinput += ln;
-           nextchr = UCHARAT(locinput);
-           break;
-       case EXACTFL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case EXACTF:
-           s = (char *) OPERAND(scan);
-           ln = UCHARAT(s++);
-
-           if (UTF) {
-               char *l = locinput;
-               char *e = s + ln;
-               c1 = OP(scan) == EXACTF;
-               while (s < e) {
-                   if (l >= PL_regeol)
-                       sayNO;
-                   if (utf8_to_uv((U8*)s, 0) != (c1 ?
-                                                 toLOWER_utf8((U8*)l) :
-                                                 toLOWER_LC_utf8((U8*)l)))
-                   {
-                       sayNO;
-                   }
-                   s += UTF8SKIP(s);
-                   l += UTF8SKIP(l);
-               }
-               locinput = l;
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-
-           /* Inline the first character, for speed. */
-           if (UCHARAT(s) != nextchr &&
-               UCHARAT(s) != ((OP(scan) == EXACTF)
-                              ? PL_fold : PL_fold_locale)[nextchr])
-               sayNO;
-           if (PL_regeol - locinput < ln)
-               sayNO;
-           if (ln > 1 && (OP(scan) == EXACTF
-                          ? ibcmp(s, locinput, ln)
-                          : ibcmp_locale(s, locinput, ln)))
-               sayNO;
-           locinput += ln;
-           nextchr = UCHARAT(locinput);
-           break;
-       case ANYOFUTF8:
-           s = (char *) OPERAND(scan);
-           if (!REGINCLASSUTF8(scan, (U8*)locinput))
-               sayNO;
-           if (locinput >= PL_regeol)
-               sayNO;
-           locinput += PL_utf8skip[nextchr];
-           nextchr = UCHARAT(locinput);
-           break;
-       case ANYOF:
-           s = (char *) OPERAND(scan);
-           if (nextchr < 0)
-               nextchr = UCHARAT(locinput);
-           if (!REGINCLASS(s, nextchr))
-               sayNO;
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ALNUML:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case ALNUM:
-           if (!nextchr)
-               sayNO;
-           if (!(OP(scan) == ALNUM
-                 ? isALNUM(nextchr) : isALNUM_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ALNUMLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case ALNUMUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (!(OP(scan) == ALNUMUTF8
-                     ? swash_fetch(PL_utf8_alnum, (U8*)locinput)
-                     : isALNUM_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (!(OP(scan) == ALNUMUTF8
-                 ? isALNUM(nextchr) : isALNUM_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NALNUML:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NALNUM:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (OP(scan) == NALNUM
-               ? isALNUM(nextchr) : isALNUM_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NALNUMLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NALNUMUTF8:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (OP(scan) == NALNUMUTF8
-                   ? swash_fetch(PL_utf8_alnum, (U8*)locinput)
-                   : isALNUM_LC_utf8((U8*)locinput))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (OP(scan) == NALNUMUTF8
-               ? isALNUM(nextchr) : isALNUM_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case BOUNDL:
-       case NBOUNDL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case BOUND:
-       case NBOUND:
-           /* was last char in word? */
-           ln = (locinput != PL_regbol) ? UCHARAT(locinput - 1) : PL_regprev;
-           if (OP(scan) == BOUND || OP(scan) == NBOUND) {
-               ln = isALNUM(ln);
-               n = isALNUM(nextchr);
-           }
-           else {
-               ln = isALNUM_LC(ln);
-               n = isALNUM_LC(nextchr);
-           }
-           if (((!ln) == (!n)) == (OP(scan) == BOUND || OP(scan) == BOUNDL))
-               sayNO;
-           break;
-       case BOUNDLUTF8:
-       case NBOUNDLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case BOUNDUTF8:
-       case NBOUNDUTF8:
-           /* was last char in word? */
-           ln = (locinput != PL_regbol)
-               ? utf8_to_uv(reghop((U8*)locinput, -1), 0) : PL_regprev;
-           if (OP(scan) == BOUNDUTF8 || OP(scan) == NBOUNDUTF8) {
-               ln = isALNUM_uni(ln);
-               n = swash_fetch(PL_utf8_alnum, (U8*)locinput);
-           }
-           else {
-               ln = isALNUM_LC_uni(ln);
-               n = isALNUM_LC_utf8((U8*)locinput);
-           }
-           if (((!ln) == (!n)) == (OP(scan) == BOUNDUTF8 || OP(scan) == BOUNDLUTF8))
-               sayNO;
-           break;
-       case SPACEL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case SPACE:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (!(OP(scan) == SPACE
-                 ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case SPACELUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case SPACEUTF8:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (!(OP(scan) == SPACEUTF8
-                     ? swash_fetch(PL_utf8_space,(U8*)locinput)
-                     : isSPACE_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (!(OP(scan) == SPACEUTF8
-                 ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NSPACEL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NSPACE:
-           if (!nextchr)
-               sayNO;
-           if (OP(scan) == SPACE
-               ? isSPACE(nextchr) : isSPACE_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NSPACELUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NSPACEUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (OP(scan) == NSPACEUTF8
-                   ? swash_fetch(PL_utf8_space,(U8*)locinput)
-                   : isSPACE_LC_utf8((U8*)locinput))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (OP(scan) == NSPACEUTF8
-               ? isSPACE(nextchr) : isSPACE_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case DIGITL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case DIGIT:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (!(OP(scan) == DIGIT
-                 ? isDIGIT(nextchr) : isDIGIT_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case DIGITLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case DIGITUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (OP(scan) == NDIGITUTF8
-                   ? swash_fetch(PL_utf8_digit,(U8*)locinput)
-                   : isDIGIT_LC_utf8((U8*)locinput))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (!isDIGIT(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NDIGITL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NDIGIT:
-           if (!nextchr)
-               sayNO;
-           if (OP(scan) == DIGIT
-               ? isDIGIT(nextchr) : isDIGIT_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NDIGITLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NDIGITUTF8:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_digit,(U8*)locinput))
-                   sayNO;
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (isDIGIT(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ALNUMCL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case ALNUMC:
-           if (!nextchr)
-               sayNO;
-           if (!(OP(scan) == ALNUMC
-                 ? isALNUMC(nextchr) : isALNUMC_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ALNUMCLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case ALNUMCUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (!(OP(scan) == ALNUMCUTF8
-                     ? swash_fetch(PL_utf8_alnumc, (U8*)locinput)
-                     : isALNUMC_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
+       
+           if (!(SvTYPE(PL_reg_sv) >= SVt_PVMG && SvMAGIC(PL_reg_sv) 
+                 && (mg = mg_find(PL_reg_sv, 'g')))) {
+               /* prepare for quick setting of pos */
+               sv_magic(PL_reg_sv, (SV*)0, 'g', Nullch, 0);
+               mg = mg_find(PL_reg_sv, 'g');
+               mg->mg_len = -1;
            }
-           if (!(OP(scan) == ALNUMCUTF8
-                 ? isALNUMC(nextchr) : isALNUMC_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NALNUMCL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NALNUMC:
-           if (!nextchr)
-               sayNO;
-           if (OP(scan) == ALNUMC
-               ? isALNUMC(nextchr) : isALNUMC_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NALNUMCLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NALNUMCUTF8:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_alnumc,(U8*)locinput))
-                   sayNO;
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
+           PL_reg_magic    = mg;
+           PL_reg_oldpos   = mg->mg_len;
+           SAVEDESTRUCTOR(restore_pos, 0);
+        }
+       if (!PL_reg_curpm)
+           New(22,PL_reg_curpm, 1, PMOP);
+       PL_reg_curpm->op_pmregexp = prog;
+       PL_reg_oldcurpm = PL_curpm;
+       PL_curpm = PL_reg_curpm;
+       if (RX_MATCH_COPIED(prog)) {
+           /*  Here is a serious problem: we cannot rewrite subbeg,
+               since it may be needed if this match fails.  Thus
+               $` inside (?{}) could fail... */
+           PL_reg_oldsaved = prog->subbeg;
+           PL_reg_oldsavedlen = prog->sublen;
+           RX_MATCH_COPIED_off(prog);
+       }
+       else
+           PL_reg_oldsaved = Nullch;
+       prog->subbeg = PL_bostr;
+       prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
+    }
+    prog->startp[0] = startpos - PL_bostr;
+    PL_reginput = startpos;
+    PL_regstartp = prog->startp;
+    PL_regendp = prog->endp;
+    PL_reglastparen = &prog->lastparen;
+    prog->lastparen = 0;
+    PL_regsize = 0;
+    DEBUG_r(PL_reg_starttry = startpos);
+    if (PL_reg_start_tmpl <= prog->nparens) {
+       PL_reg_start_tmpl = prog->nparens*3/2 + 3;
+        if(PL_reg_start_tmp)
+            Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
+        else
+            New(22,PL_reg_start_tmp, PL_reg_start_tmpl, char*);
+    }
+
+    /* XXXX What this code is doing here?!!!  There should be no need
+       to do this again and again, PL_reglastparen should take care of
+       this!  */
+    sp = prog->startp;
+    ep = prog->endp;
+    if (prog->nparens) {
+       for (i = prog->nparens; i >= 1; i--) {
+           *++sp = -1;
+           *++ep = -1;
+       }
+    }
+    REGCP_SET;
+    if (regmatch(prog->program + 1)) {
+       prog->endp[0] = PL_reginput - PL_bostr;
+       return 1;
+    }
+    REGCP_UNWIND;
+    return 0;
+}
+
+/*
+ - regmatch - main matching routine
+ *
+ * Conceptually the strategy is simple:  check to see whether the current
+ * node matches, call self recursively to see whether the rest matches,
+ * and then act accordingly.  In practice we make some effort to avoid
+ * recursion, in particular by going through "ordinary" nodes (that don't
+ * need to know whether the rest of the match failed) by a loop instead of
+ * by recursion.
+ */
+/* [lwall] I've hoisted the register declarations to the outer block in order to
+ * maybe save a little bit of pushing and popping on the stack.  It also takes
+ * advantage of machines that use a register save mask on subroutine entry.
+ */
+STATIC I32                     /* 0 failure, 1 success */
+S_regmatch(pTHX_ regnode *prog)
+{
+    dTHR;
+    register regnode *scan;    /* Current node. */
+    regnode *next;             /* Next node. */
+    regnode *inner;            /* Next node in internal branch. */
+    register I32 nextchr;      /* renamed nextchr - nextchar colides with
+                                  function of same name */
+    register I32 n;            /* no or next */
+    register I32 ln;           /* len or last */
+    register char *s;          /* operand or save */
+    register char *locinput = PL_reginput;
+    register I32 c1, c2, paren;        /* case fold search, parenth */
+    int minmod = 0, sw = 0, logical = 0;
+#ifdef DEBUGGING
+    PL_regindent++;
+#endif
+
+    /* Note that nextchr is a byte even in UTF */
+    nextchr = UCHARAT(locinput);
+    scan = prog;
+    while (scan != NULL) {
+#define sayNO_L (logical ? (logical = 0, sw = 0, goto cont) : sayNO)
+#ifdef DEBUGGING
+#  define sayYES goto yes
+#  define sayNO goto no
+#  define saySAME(x) if (x) goto yes; else goto no
+#  define REPORT_CODE_OFF 24
+#else
+#  define sayYES return 1
+#  define sayNO return 0
+#  define saySAME(x) return x
+#endif
+       DEBUG_r( {
+           SV *prop = sv_newmortal();
+           int docolor = *PL_colors[0];
+           int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
+           int l = (PL_regeol - locinput > taill ? taill : PL_regeol - locinput);
+           /* The part of the string before starttry has one color
+              (pref0_len chars), between starttry and current
+              position another one (pref_len - pref0_len chars),
+              after the current position the third one.
+              We assume that pref0_len <= pref_len, otherwise we
+              decrease pref0_len.  */
+           int pref_len = (locinput - PL_bostr > (5 + taill) - l 
+                           ? (5 + taill) - l : locinput - PL_bostr);
+           int pref0_len = pref_len  - (locinput - PL_reg_starttry);
+
+           if (l + pref_len < (5 + taill) && l < PL_regeol - locinput)
+               l = ( PL_regeol - locinput > (5 + taill) - pref_len 
+                     ? (5 + taill) - pref_len : PL_regeol - locinput);
+           if (pref0_len < 0)
+               pref0_len = 0;
+           if (pref0_len > pref_len)
+               pref0_len = pref_len;
+           regprop(prop, scan);
+           PerlIO_printf(Perl_debug_log, 
+                         "%4i <%s%.*s%s%s%.*s%s%s%s%.*s%s>%*s|%3d:%*s%s\n",
+                         locinput - PL_bostr, 
+                         PL_colors[4], pref0_len, 
+                         locinput - pref_len, PL_colors[5],
+                         PL_colors[2], pref_len - pref0_len, 
+                         locinput - pref_len + pref0_len, PL_colors[3],
+                         (docolor ? "" : "> <"),
+                         PL_colors[0], l, locinput, PL_colors[1],
+                         15 - l - pref_len + 1,
+                         "",
+                         scan - PL_regprogram, PL_regindent*2, "",
+                         SvPVX(prop));
+       } );
+
+       next = scan + NEXT_OFF(scan);
+       if (next == scan)
+           next = NULL;
+
+       switch (OP(scan)) {
+       case BOL:
+           if (locinput == PL_bostr
+               ? PL_regprev == '\n'
+               : (PL_multiline && 
+                  (nextchr || locinput < PL_regeol) && locinput[-1] == '\n') )
+           {
+               /* regtill = regbol; */
                break;
            }
-           if (isALNUMC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ALPHAL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case ALPHA:
-           if (!nextchr)
-               sayNO;
-           if (!(OP(scan) == ALPHA
-                 ? isALPHA(nextchr) : isALPHA_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ALPHALUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case ALPHAUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (!(OP(scan) == ALPHAUTF8
-                     ? swash_fetch(PL_utf8_alpha, (U8*)locinput)
-                     : isALPHA_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
+           sayNO;
+       case MBOL:
+           if (locinput == PL_bostr
+               ? PL_regprev == '\n'
+               : ((nextchr || locinput < PL_regeol) && locinput[-1] == '\n') )
+           {
                break;
            }
-           if (!(OP(scan) == ALPHAUTF8
-                 ? isALPHA(nextchr) : isALPHA_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NALPHAL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NALPHA:
-           if (!nextchr)
-               sayNO;
-           if (OP(scan) == ALPHA
-               ? isALPHA(nextchr) : isALPHA_LC(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NALPHALUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NALPHAUTF8:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_alpha,(U8*)locinput))
-                   sayNO;
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
+           sayNO;
+       case SBOL:
+           if (locinput == PL_regbol && PL_regprev == '\n')
                break;
-           }
-           if (isALPHA(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case ASCII:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (!isASCII(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NASCII:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (isASCII(nextchr))
+           sayNO;
+       case GPOS:
+           if (locinput == PL_reg_ganch)
+               break;
+           sayNO;
+       case EOL:
+           if (PL_multiline)
+               goto meol;
+           else
+               goto seol;
+       case MEOL:
+         meol:
+           if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
                sayNO;
-           nextchr = UCHARAT(++locinput);
            break;
-       case CNTRLL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case CNTRL:
-           if (!nextchr)
+       case SEOL:
+         seol:
+           if ((nextchr || locinput < PL_regeol) && nextchr != '\n')
                sayNO;
-           if (!(OP(scan) == CNTRL
-                 ? isCNTRL(nextchr) : isCNTRL_LC(nextchr)))
+           if (PL_regeol - locinput > 1)
                sayNO;
-           nextchr = UCHARAT(++locinput);
            break;
-       case CNTRLLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case CNTRLUTF8:
-           if (!nextchr)
+       case EOS:
+           if (PL_regeol != locinput)
                sayNO;
+           break;
+       case SANYUTF8:
            if (nextchr & 0x80) {
-               if (!(OP(scan) == CNTRLUTF8
-                     ? swash_fetch(PL_utf8_cntrl, (U8*)locinput)
-                     : isCNTRL_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
-               }
                locinput += PL_utf8skip[nextchr];
+               if (locinput > PL_regeol)
+                   sayNO;
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (!(OP(scan) == CNTRLUTF8
-                 ? isCNTRL(nextchr) : isCNTRL_LC(nextchr)))
+           if (!nextchr && locinput >= PL_regeol)
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NCNTRLL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NCNTRL:
-           if (!nextchr)
-               sayNO;
-           if (OP(scan) == CNTRL
-               ? isCNTRL(nextchr) : isCNTRL_LC(nextchr))
+       case SANY:
+           if (!nextchr && locinput >= PL_regeol)
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NCNTRLLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NCNTRLUTF8:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
+       case ANYUTF8:
            if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_cntrl,(U8*)locinput))
-                   sayNO;
                locinput += PL_utf8skip[nextchr];
+               if (locinput > PL_regeol)
+                   sayNO;
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (isCNTRL(nextchr))
+           if (!nextchr && locinput >= PL_regeol || nextchr == '\n')
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case GRAPHL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case GRAPH:
-           if (!nextchr)
-               sayNO;
-           if (!(OP(scan) == GRAPH
-                 ? isGRAPH(nextchr) : isGRAPH_LC(nextchr)))
+       case REG_ANY:
+           if (!nextchr && locinput >= PL_regeol || nextchr == '\n')
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case GRAPHLUTF8:
+       case EXACT:
+           s = (char *) OPERAND(scan);
+           ln = UCHARAT(s++);
+           /* Inline the first character, for speed. */
+           if (UCHARAT(s) != nextchr)
+               sayNO;
+           if (PL_regeol - locinput < ln)
+               sayNO;
+           if (ln > 1 && memNE(s, locinput, ln))
+               sayNO;
+           locinput += ln;
+           nextchr = UCHARAT(locinput);
+           break;
+       case EXACTFL:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case GRAPHUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (!(OP(scan) == GRAPHUTF8
-                     ? swash_fetch(PL_utf8_graph, (U8*)locinput)
-                     : isGRAPH_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
+       case EXACTF:
+           s = (char *) OPERAND(scan);
+           ln = UCHARAT(s++);
+
+           if (UTF) {
+               char *l = locinput;
+               char *e = s + ln;
+               c1 = OP(scan) == EXACTF;
+               while (s < e) {
+                   if (l >= PL_regeol)
+                       sayNO;
+                   if (utf8_to_uv((U8*)s, 0) != (c1 ?
+                                                 toLOWER_utf8((U8*)l) :
+                                                 toLOWER_LC_utf8((U8*)l)))
+                   {
+                       sayNO;
+                   }
+                   s += UTF8SKIP(s);
+                   l += UTF8SKIP(l);
                }
-               locinput += PL_utf8skip[nextchr];
+               locinput = l;
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (!(OP(scan) == GRAPHUTF8
-                 ? isGRAPH(nextchr) : isGRAPH_LC(nextchr)))
+
+           /* Inline the first character, for speed. */
+           if (UCHARAT(s) != nextchr &&
+               UCHARAT(s) != ((OP(scan) == EXACTF)
+                              ? PL_fold : PL_fold_locale)[nextchr])
                sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NGRAPHL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NGRAPH:
-           if (!nextchr)
+           if (PL_regeol - locinput < ln)
                sayNO;
-           if (OP(scan) == GRAPH
-               ? isGRAPH(nextchr) : isGRAPH_LC(nextchr))
+           if (ln > 1 && (OP(scan) == EXACTF
+                          ? ibcmp(s, locinput, ln)
+                          : ibcmp_locale(s, locinput, ln)))
                sayNO;
-           nextchr = UCHARAT(++locinput);
+           locinput += ln;
+           nextchr = UCHARAT(locinput);
            break;
-       case NGRAPHLUTF8:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NGRAPHUTF8:
-           if (!nextchr && locinput >= PL_regeol)
+       case ANYOFUTF8:
+           s = (char *) OPERAND(scan);
+           if (!REGINCLASSUTF8(scan, (U8*)locinput))
                sayNO;
-           if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_graph,(U8*)locinput))
-                   sayNO;
-               locinput += PL_utf8skip[nextchr];
+           if (locinput >= PL_regeol)
+               sayNO;
+           locinput += PL_utf8skip[nextchr];
+           nextchr = UCHARAT(locinput);
+           break;
+       case ANYOF:
+           s = (char *) OPERAND(scan);
+           if (nextchr < 0)
                nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (isGRAPH(nextchr))
+           if (!REGINCLASS(s, nextchr))
+               sayNO;
+           if (!nextchr && locinput >= PL_regeol)
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case LOWERL:
+       case ALNUML:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case LOWER:
+       case ALNUM:
            if (!nextchr)
                sayNO;
-           if (!(OP(scan) == LOWER
-                 ? isLOWER(nextchr) : isLOWER_LC(nextchr)))
+           if (!(OP(scan) == ALNUM
+                 ? isALNUM(nextchr) : isALNUM_LC(nextchr)))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case LOWERLUTF8:
+       case ALNUMLUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case LOWERUTF8:
+       case ALNUMUTF8:
            if (!nextchr)
                sayNO;
            if (nextchr & 0x80) {
-               if (!(OP(scan) == LOWERUTF8
-                     ? swash_fetch(PL_utf8_lower, (U8*)locinput)
-                     : isLOWER_LC_utf8((U8*)locinput)))
+               if (!(OP(scan) == ALNUMUTF8
+                     ? swash_fetch(PL_utf8_alnum, (U8*)locinput)
+                     : isALNUM_LC_utf8((U8*)locinput)))
                {
                    sayNO;
                }
@@ -3095,121 +1798,137 @@ S_regmatch(pTHX_ regnode *prog)
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (!(OP(scan) == LOWERUTF8
-                 ? isLOWER(nextchr) : isLOWER_LC(nextchr)))
+           if (!(OP(scan) == ALNUMUTF8
+                 ? isALNUM(nextchr) : isALNUM_LC(nextchr)))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NLOWERL:
+       case NALNUML:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NLOWER:
-           if (!nextchr)
+       case NALNUM:
+           if (!nextchr && locinput >= PL_regeol)
                sayNO;
-           if (OP(scan) == LOWER
-               ? isLOWER(nextchr) : isLOWER_LC(nextchr))
+           if (OP(scan) == NALNUM
+               ? isALNUM(nextchr) : isALNUM_LC(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NLOWERLUTF8:
+       case NALNUMLUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NLOWERUTF8:
+       case NALNUMUTF8:
            if (!nextchr && locinput >= PL_regeol)
                sayNO;
            if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_lower,(U8*)locinput))
+               if (OP(scan) == NALNUMUTF8
+                   ? swash_fetch(PL_utf8_alnum, (U8*)locinput)
+                   : isALNUM_LC_utf8((U8*)locinput))
+               {
                    sayNO;
+               }
                locinput += PL_utf8skip[nextchr];
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (isLOWER(nextchr))
+           if (OP(scan) == NALNUMUTF8
+               ? isALNUM(nextchr) : isALNUM_LC(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case PRINTL:
+       case BOUNDL:
+       case NBOUNDL:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case PRINT:
-           if (!nextchr)
-               sayNO;
-           if (!(OP(scan) == PRINT
-                 ? isPRINT(nextchr) : isPRINT_LC(nextchr)))
+       case BOUND:
+       case NBOUND:
+           /* was last char in word? */
+           ln = (locinput != PL_regbol) ? UCHARAT(locinput - 1) : PL_regprev;
+           if (OP(scan) == BOUND || OP(scan) == NBOUND) {
+               ln = isALNUM(ln);
+               n = isALNUM(nextchr);
+           }
+           else {
+               ln = isALNUM_LC(ln);
+               n = isALNUM_LC(nextchr);
+           }
+           if (((!ln) == (!n)) == (OP(scan) == BOUND || OP(scan) == BOUNDL))
                sayNO;
-           nextchr = UCHARAT(++locinput);
            break;
-       case PRINTLUTF8:
+       case BOUNDLUTF8:
+       case NBOUNDLUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case PRINTUTF8:
-           if (!nextchr)
-               sayNO;
-           if (nextchr & 0x80) {
-               if (!(OP(scan) == PRINTUTF8
-                     ? swash_fetch(PL_utf8_print, (U8*)locinput)
-                     : isPRINT_LC_utf8((U8*)locinput)))
-               {
-                   sayNO;
-               }
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
+       case BOUNDUTF8:
+       case NBOUNDUTF8:
+           /* was last char in word? */
+           ln = (locinput != PL_regbol)
+               ? utf8_to_uv(reghop((U8*)locinput, -1), 0) : PL_regprev;
+           if (OP(scan) == BOUNDUTF8 || OP(scan) == NBOUNDUTF8) {
+               ln = isALNUM_uni(ln);
+               n = swash_fetch(PL_utf8_alnum, (U8*)locinput);
            }
-           if (!(OP(scan) == PRINTUTF8
-                 ? isPRINT(nextchr) : isPRINT_LC(nextchr)))
+           else {
+               ln = isALNUM_LC_uni(ln);
+               n = isALNUM_LC_utf8((U8*)locinput);
+           }
+           if (((!ln) == (!n)) == (OP(scan) == BOUNDUTF8 || OP(scan) == BOUNDLUTF8))
                sayNO;
-           nextchr = UCHARAT(++locinput);
            break;
-       case NPRINTL:
+       case SPACEL:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NPRINT:
-           if (!nextchr)
+       case SPACE:
+           if (!nextchr && locinput >= PL_regeol)
                sayNO;
-           if (OP(scan) == PRINT
-               ? isPRINT(nextchr) : isPRINT_LC(nextchr))
+           if (!(OP(scan) == SPACE
+                 ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NPRINTLUTF8:
+       case SPACELUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NPRINTUTF8:
+       case SPACEUTF8:
            if (!nextchr && locinput >= PL_regeol)
                sayNO;
            if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_print,(U8*)locinput))
+               if (!(OP(scan) == SPACEUTF8
+                     ? swash_fetch(PL_utf8_space,(U8*)locinput)
+                     : isSPACE_LC_utf8((U8*)locinput)))
+               {
                    sayNO;
+               }
                locinput += PL_utf8skip[nextchr];
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (isPRINT(nextchr))
+           if (!(OP(scan) == SPACEUTF8
+                 ? isSPACE(nextchr) : isSPACE_LC(nextchr)))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case PUNCTL:
+       case NSPACEL:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case PUNCT:
+       case NSPACE:
            if (!nextchr)
                sayNO;
-           if (!(OP(scan) == PUNCT
-                 ? isPUNCT(nextchr) : isPUNCT_LC(nextchr)))
+           if (OP(scan) == SPACE
+               ? isSPACE(nextchr) : isSPACE_LC(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case PUNCTLUTF8:
+       case NSPACELUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case PUNCTUTF8:
+       case NSPACEUTF8:
            if (!nextchr)
                sayNO;
            if (nextchr & 0x80) {
-               if (!(OP(scan) == PUNCTUTF8
-                     ? swash_fetch(PL_utf8_punct, (U8*)locinput)
-                     : isPUNCT_LC_utf8((U8*)locinput)))
+               if (OP(scan) == NSPACEUTF8
+                   ? swash_fetch(PL_utf8_space,(U8*)locinput)
+                   : isSPACE_LC_utf8((U8*)locinput))
                {
                    sayNO;
                }
@@ -3217,60 +1936,32 @@ S_regmatch(pTHX_ regnode *prog)
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (!(OP(scan) == PUNCTUTF8
-                 ? isPUNCT(nextchr) : isPUNCT_LC(nextchr)))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NPUNCTL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case NPUNCT:
-           if (!nextchr)
-               sayNO;
-           if (OP(scan) == PUNCT
-               ? isPUNCT(nextchr) : isPUNCT_LC(nextchr))
+           if (OP(scan) == NSPACEUTF8
+               ? isSPACE(nextchr) : isSPACE_LC(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NPUNCTLUTF8:
+       case DIGITL:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NPUNCTUTF8:
+       case DIGIT:
            if (!nextchr && locinput >= PL_regeol)
                sayNO;
-           if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_punct,(U8*)locinput))
-                   sayNO;
-               locinput += PL_utf8skip[nextchr];
-               nextchr = UCHARAT(locinput);
-               break;
-           }
-           if (isPUNCT(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case UPPERL:
-           PL_reg_flags |= RF_tainted;
-           /* FALL THROUGH */
-       case UPPER:
-           if (!nextchr)
-               sayNO;
-           if (!(OP(scan) == UPPER
-                 ? isUPPER(nextchr) : isUPPER_LC(nextchr)))
+           if (!(OP(scan) == DIGIT
+                 ? isDIGIT(nextchr) : isDIGIT_LC(nextchr)))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case UPPERLUTF8:
+       case DIGITLUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case UPPERUTF8:
+       case DIGITUTF8:
            if (!nextchr)
                sayNO;
            if (nextchr & 0x80) {
-               if (!(OP(scan) == UPPERUTF8
-                     ? swash_fetch(PL_utf8_upper, (U8*)locinput)
-                     : isUPPER_LC_utf8((U8*)locinput)))
+               if (OP(scan) == NDIGITUTF8
+                   ? swash_fetch(PL_utf8_digit,(U8*)locinput)
+                   : isDIGIT_LC_utf8((U8*)locinput))
                {
                    sayNO;
                }
@@ -3278,50 +1969,35 @@ S_regmatch(pTHX_ regnode *prog)
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (!(OP(scan) == UPPERUTF8
-                 ? isUPPER(nextchr) : isUPPER_LC(nextchr)))
+           if (!isDIGIT(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NUPPERL:
+       case NDIGITL:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NUPPER:
+       case NDIGIT:
            if (!nextchr)
                sayNO;
-           if (OP(scan) == UPPER
-               ? isUPPER(nextchr) : isUPPER_LC(nextchr))
+           if (OP(scan) == DIGIT
+               ? isDIGIT(nextchr) : isDIGIT_LC(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;
-       case NUPPERLUTF8:
+       case NDIGITLUTF8:
            PL_reg_flags |= RF_tainted;
            /* FALL THROUGH */
-       case NUPPERUTF8:
+       case NDIGITUTF8:
            if (!nextchr && locinput >= PL_regeol)
                sayNO;
            if (nextchr & 0x80) {
-               if (swash_fetch(PL_utf8_upper,(U8*)locinput))
+               if (swash_fetch(PL_utf8_digit,(U8*)locinput))
                    sayNO;
                locinput += PL_utf8skip[nextchr];
                nextchr = UCHARAT(locinput);
                break;
            }
-           if (isUPPER(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case XDIGIT:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (!isXDIGIT(nextchr))
-               sayNO;
-           nextchr = UCHARAT(++locinput);
-           break;
-       case NXDIGIT:
-           if (!nextchr && locinput >= PL_regeol)
-               sayNO;
-           if (isXDIGIT(nextchr))
+           if (isDIGIT(nextchr))
                sayNO;
            nextchr = UCHARAT(++locinput);
            break;