Store state subs in the pad
authorFather Chrysostomos <sprout@cpan.org>
Fri, 6 Jul 2012 06:22:21 +0000 (23:22 -0700)
committerFather Chrysostomos <sprout@cpan.org>
Sun, 16 Sep 2012 05:44:57 +0000 (22:44 -0700)
In making ‘sub foo’ respect previous ‘our sub’ declarations in a
recent commit, I actually made ‘state sub foo’ into a syntax error.
(At the time, I patched up MYSUB in perly.y to keep the tests for ‘"my
sub" not yet implemented’ still working.)  Basically, it was creat-
ing an empty pad entry, but returning something that perly.y was not
expecting.

This commit adjusts the grammar to allow the SUB branch of barestmt to
accept a PRIVATEREF for its subname, in addition to a WORD.  It reuses
the subname rule that SUB used to use (before our subs were added),
gutting it to remove the special block handling, which SUB now tokes
care of.  That means the MYSUB rule will no longer turn on CvSPECIAL
on the PL_compcv that is going to be thrown away anyway.

The code for special blocks (BEGIN, END, etc.) that turns on CvSPECIAL
now checks for state subs and skips those.  It only applies to our
subs and package subs.

newMYSUB has now actually been written.  It basically duplicates
newATTRSUB, except for GV-specific things.  It does currently vivify a
GV and set CvGV, but I am hoping to change that later.  I also hope to
merge some of the code later, too.

I changed the prototype of newMYSUB to make it easier to use.  It is
not used anywhere on CPAN and has always simply died, so that should
be all right.

embed.fnc
embed.h
op.c
perly.act
perly.h
perly.tab
perly.y
proto.h

index b2f1887..99b168b 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -1627,12 +1627,8 @@ Ap       |CV*    |newATTRSUB     |I32 floor|NULLOK OP *o|NULLOK OP *proto|NULLOK OP *attrs|NU
 p      |CV*    |newATTRSUB_flags|I32 floor|NULLOK OP *o|NULLOK OP *proto \
                                 |NULLOK OP *attrs|NULLOK OP *block \
                                 |U32 flags
-#ifdef PERL_MAD
-Apr    |OP *   |newMYSUB       |I32 floor|NULLOK OP *o|NULLOK OP *proto \
+Ap     |CV *   |newMYSUB       |I32 floor|NN OP *o|NULLOK OP *proto \
                                |NULLOK OP *attrs|NULLOK OP *block
-#else
-Apr    |void   |newMYSUB       |I32 floor|NULLOK OP *o|NULLOK OP *proto|NULLOK OP *attrs|NULLOK OP *block
-#endif
 p      |CV*    |newSTUB        |NN GV *gv|bool fake
 : Used in perly.y
 p      |OP *   |my_attrs       |NN OP *o|NULLOK OP *attrs
diff --git a/embed.h b/embed.h
index def1f16..655a0a1 100644 (file)
--- a/embed.h
+++ b/embed.h
 #define newLOGOP(a,b,c,d)      Perl_newLOGOP(aTHX_ a,b,c,d)
 #define newLOOPEX(a,b)         Perl_newLOOPEX(aTHX_ a,b)
 #define newLOOPOP(a,b,c,d)     Perl_newLOOPOP(aTHX_ a,b,c,d)
+#define newMYSUB(a,b,c,d,e)    Perl_newMYSUB(aTHX_ a,b,c,d,e)
 #define newNULLLIST()          Perl_newNULLLIST(aTHX)
 #define newOP(a,b)             Perl_newOP(aTHX_ a,b)
 #define newPMOP(a,b)           Perl_newPMOP(aTHX_ a,b)
 #endif
 #if !(defined(PERL_MAD))
 #define newFORM(a,b,c)         Perl_newFORM(aTHX_ a,b,c)
-#define newMYSUB(a,b,c,d,e)    Perl_newMYSUB(aTHX_ a,b,c,d,e)
 #endif
 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
 #define my_bzero               Perl_my_bzero
 #endif
 #if defined(PERL_MAD)
 #define newFORM(a,b,c)         Perl_newFORM(aTHX_ a,b,c)
-#define newMYSUB(a,b,c,d,e)    Perl_newMYSUB(aTHX_ a,b,c,d,e)
 #endif
 #if defined(UNLINK_ALL_VERSIONS)
 #define unlnk(a)               Perl_unlnk(aTHX_ a)
diff --git a/op.c b/op.c
index a072b29..08c1338 100644 (file)
--- a/op.c
+++ b/op.c
@@ -6856,32 +6856,324 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
     return sv;
 }
 
-#ifdef PERL_MAD
-OP *
-#else
-void
-#endif
+CV *
 Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 {
-#if 0
-    /* This would be the return value, but the return cannot be reached.  */
-    OP* pegop = newOP(OP_NULL, 0);
+    dVAR;
+    GV *gv;
+    CV **spot;
+    SV **svspot;
+    const char *ps;
+    STRLEN ps_len = 0; /* init it to avoid false uninit warning from icc */
+    U32 ps_utf8 = 0;
+    register CV *cv = NULL;
+    register CV *compcv = PL_compcv;
+    SV *const_sv;
+    const bool ec = PL_parser && PL_parser->error_count;
+
+    /* If the subroutine has no body, no attributes, and no builtin attributes
+       then it's just a sub declaration, and we may be able to get away with
+       storing with a placeholder scalar in the symbol table, rather than a
+       full CV.  If anything is present then it will take a full CV to
+       store it.  */
+    const I32 gv_fetch_flags
+       = ec ? GV_NOADD_NOINIT : GV_ADD;
+    PADNAME *name;
+
+    PERL_ARGS_ASSERT_NEWMYSUB;
+
+    /* PL_comppad is the pad owned by the new sub.  Popping scope will make
+       the PL_comppad point to the pad belonging to the enclosing sub,
+       where we store the new one. */
+    LEAVE_SCOPE(floor);
+
+    name = PadnamelistARRAY(PL_comppad_name)[o->op_targ];
+    if (!PadnameIsSTATE(name))
+       Perl_croak(aTHX_ "\"my sub\" not yet implemented");
+    svspot = &PL_curpad[o->op_targ];
+    spot = (CV **)svspot;
+
+    if (proto) {
+       assert(proto->op_type == OP_CONST);
+       ps = SvPV_const(((SVOP*)proto)->op_sv, ps_len);
+        ps_utf8 = SvUTF8(((SVOP*)proto)->op_sv);
+    }
+    else
+       ps = NULL;
+
+    gv = gv_fetchpvn_flags(PadnamePV(name)+1, PadnameLEN(name)-1,
+                          PadnameUTF8(name)|gv_fetch_flags, SVt_PVCV);
+
+    if (!PL_madskills) {
+       if (o)
+           SAVEFREEOP(o);
+       if (proto)
+           SAVEFREEOP(proto);
+       if (attrs)
+           SAVEFREEOP(attrs);
+    }
+
+    if (ec) {
+       op_free(block);
+       goto done;
+    }
+
+    if (SvTYPE(*spot) != SVt_PVCV) {   /* Maybe prototype now, and had at
+                                          maximum a prototype before. */
+       if (SvTYPE(*spot) > SVt_NULL) {
+           cv_ckproto_len_flags(*spot, NULL, ps, ps_len, ps_utf8);
+       }
+       if (!block && !attrs && !(CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS)
+        && !PL_madskills) {
+         if (ps) {
+           sv_setpvn(*svspot, ps, ps_len);
+            if ( ps_utf8 ) SvUTF8_on(*svspot);
+          }
+         else
+           sv_setiv(*svspot, -1);
+
+         SvREFCNT_dec(compcv);
+         cv = compcv = NULL;
+         goto done;
+       }
+       SvREFCNT_dec(*spot);
+       *spot = NULL;
+    }
+
+    cv = *spot;
+
+    if (!block || !ps || *ps || attrs
+       || (CvFLAGS(compcv) & CVf_BUILTIN_ATTRS)
+#ifdef PERL_MAD
+       || block->op_type == OP_NULL
 #endif
+       )
+       const_sv = NULL;
+    else
+       const_sv = op_const_sv(block, NULL);
 
-    PERL_UNUSED_ARG(floor);
+    if (cv) {
+        const bool exists = CvROOT(cv) || CvXSUB(cv);
 
-    if (o)
-       SAVEFREEOP(o);
-    if (proto)
-       SAVEFREEOP(proto);
-    if (attrs)
-       SAVEFREEOP(attrs);
-    if (block)
-       SAVEFREEOP(block);
-    Perl_croak(aTHX_ "\"my sub\" not yet implemented");
+        /* if the subroutine doesn't exist and wasn't pre-declared
+         * with a prototype, assume it will be AUTOLOADed,
+         * skipping the prototype check
+         */
+        if (exists || SvPOK(cv))
+            cv_ckproto_len_flags(cv, gv, ps, ps_len, ps_utf8);
+       /* already defined? */
+       if (exists) {
+           if ((!block
+#ifdef PERL_MAD
+                || block->op_type == OP_NULL
+#endif
+                )) {
+               if (CvFLAGS(compcv)) {
+                   /* might have had built-in attrs applied */
+                   const bool pureperl = !CvISXSUB(cv) && CvROOT(cv);
+                   if (CvLVALUE(compcv) && ! CvLVALUE(cv) && pureperl
+                    && ckWARN(WARN_MISC))
+                       Perl_warner(aTHX_ packWARN(WARN_MISC), "lvalue attribute ignored after the subroutine has been defined");
+                   CvFLAGS(cv) |=
+                       (CvFLAGS(compcv) & CVf_BUILTIN_ATTRS
+                         & ~(CVf_LVALUE * pureperl));
+               }
+               if (attrs) goto attrs;
+               /* just a "sub foo;" when &foo is already defined */
+               SAVEFREESV(compcv);
+               goto done;
+           }
+           else {
+               const line_t oldline = CopLINE(PL_curcop);
+               if (PL_parser && PL_parser->copline != NOLINE)
+                       CopLINE_set(PL_curcop, PL_parser->copline);
+               report_redefined_cv(name, cv, &const_sv);
+               CopLINE_set(PL_curcop, oldline);
+#ifdef PERL_MAD
+               if (!PL_minus_c)        /* keep old one around for madskills */
+#endif
+                   {
+                       /* (PL_madskills unset in used file.) */
+                       SvREFCNT_dec(cv);
+                   }
+               cv = NULL;
+           }
+       }
+    }
+    if (const_sv) {
+       SvREFCNT_inc_simple_void_NN(const_sv);
+       if (cv) {
+           assert(!CvROOT(cv) && !CvCONST(cv));
+           cv_forget_slab(cv);
+       }
+       else {
+           cv = MUTABLE_CV(newSV_type(SVt_PVCV));
+           CvFILE_set_from_cop(cv, PL_curcop);
+           CvSTASH_set(cv, PL_curstash);
+           *spot = cv;
+       }
+       sv_setpvs(MUTABLE_SV(cv), "");  /* prototype is "" */
+       CvXSUBANY(cv).any_ptr = const_sv;
+       CvXSUB(cv) = const_sv_xsub;
+       CvCONST_on(cv);
+       CvISXSUB_on(cv);
+       if (PL_madskills)
+           goto install_block;
+       op_free(block);
+       SvREFCNT_dec(compcv);
+       goto done;
+    }
+    SvREFCNT_dec(CvOUTSIDE(compcv));
+    CvWEAKOUTSIDE_on(compcv);
+    if (cv) {  /* must reuse cv in case stub is referenced elsewhere */
+       /* transfer PL_compcv to cv */
+       if (block
+#ifdef PERL_MAD
+                  && block->op_type != OP_NULL
+#endif
+       ) {
+           cv_flags_t existing_builtin_attrs = CvFLAGS(cv) & CVf_BUILTIN_ATTRS;
+           PADLIST *const temp_padl = CvPADLIST(cv);
+           CV *const temp_cv = CvOUTSIDE(cv);
+           const cv_flags_t slabbed = CvSLABBED(cv);
+           OP * const cvstart = CvSTART(cv);
+
+           assert(CvWEAKOUTSIDE(cv));
+           assert(CvCVGV_RC(cv));
+           assert(CvGV(cv) == gv);
+
+           SvPOK_off(cv);
+           CvFLAGS(cv) =
+               CvFLAGS(compcv) | existing_builtin_attrs | CVf_CVGV_RC;
+           CvOUTSIDE(cv) = CvOUTSIDE(compcv);
+           CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(compcv);
+           CvPADLIST(cv) = CvPADLIST(compcv);
+           CvOUTSIDE(compcv) = temp_cv;
+           CvPADLIST(compcv) = temp_padl;
+           CvSTART(cv) = CvSTART(compcv);
+           CvSTART(compcv) = cvstart;
+           if (slabbed) CvSLABBED_on(compcv);
+           else CvSLABBED_off(compcv);
+
+           if (CvFILE(cv) && CvDYNFILE(cv)) {
+               Safefree(CvFILE(cv));
+           }
+
+           /* inner references to compcv must be fixed up ... */
+           pad_fixup_inner_anons(CvPADLIST(cv), compcv, cv);
+           if (PERLDB_INTER)/* Advice debugger on the new sub. */
+             ++PL_sub_generation;
+       }
+       else {
+           /* Might have had built-in attributes applied -- propagate them. */
+           CvFLAGS(cv) |= (CvFLAGS(compcv) & CVf_BUILTIN_ATTRS);
+       }
+       /* ... before we throw it away */
+       SvREFCNT_dec(compcv);
+       compcv = cv;
+    }
+    else {
+       cv = compcv;
+       *spot = cv;
+       CvGV_set(cv, gv);
+    }
+    CvFILE_set_from_cop(cv, PL_curcop);
+    CvSTASH_set(cv, PL_curstash);
+
+    if (ps) {
+       sv_setpvn(MUTABLE_SV(cv), ps, ps_len);
+        if ( ps_utf8 ) SvUTF8_on(MUTABLE_SV(cv));
+    }
+
+ install_block:
+    if (!block)
+       goto attrs;
+
+    /* If we assign an optree to a PVCV, then we've defined a subroutine that
+       the debugger could be able to set a breakpoint in, so signal to
+       pp_entereval that it should not throw away any saved lines at scope
+       exit.  */
+       
+    PL_breakable_sub_gen++;
+    /* This makes sub {}; work as expected.  */
+    if (block->op_type == OP_STUB) {
+           OP* const newblock = newSTATEOP(0, NULL, 0);
 #ifdef PERL_MAD
-    NORETURN_FUNCTION_END;
+           op_getmad(block,newblock,'B');
+#else
+           op_free(block);
 #endif
+           block = newblock;
+    }
+    CvROOT(cv) = CvLVALUE(cv)
+                  ? newUNOP(OP_LEAVESUBLV, 0,
+                            op_lvalue(scalarseq(block), OP_LEAVESUBLV))
+                  : newUNOP(OP_LEAVESUB, 0, scalarseq(block));
+    CvROOT(cv)->op_private |= OPpREFCOUNTED;
+    OpREFCNT_set(CvROOT(cv), 1);
+    /* The cv no longer needs to hold a refcount on the slab, as CvROOT
+       itself has a refcount. */
+    CvSLABBED_off(cv);
+    OpslabREFCNT_dec_padok((OPSLAB *)CvSTART(cv));
+    CvSTART(cv) = LINKLIST(CvROOT(cv));
+    CvROOT(cv)->op_next = 0;
+    CALL_PEEP(CvSTART(cv));
+    finalize_optree(CvROOT(cv));
+
+    /* now that optimizer has done its work, adjust pad values */
+
+    ENTER;
+    SAVESPTR(PL_compcv);
+    SAVECOMPPAD();
+    PL_compcv  = cv;
+    PL_comppad = *PadlistARRAY(CvPADLIST(cv));
+    PL_curpad  = PadARRAY(PL_comppad);
+    pad_tidy(CvCLONE(cv) ? padtidy_SUBCLONE : padtidy_SUB);
+    LEAVE;
+
+    if (CvCLONE(cv)) {
+       assert(!CvCONST(cv));
+       if (ps && !*ps && op_const_sv(block, cv))
+           CvCONST_on(cv);
+    }
+
+  attrs:
+    if (attrs) {
+       /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>. */
+       apply_attrs(PL_curstash, MUTABLE_SV(cv), attrs, FALSE);
+    }
+
+    if (block) {
+       if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
+           SV * const tmpstr = sv_newmortal();
+           GV * const db_postponed = gv_fetchpvs("DB::postponed",
+                                                 GV_ADDMULTI, SVt_PVHV);
+           HV *hv;
+           SV * const sv = Perl_newSVpvf(aTHX_ "%s:%ld-%ld",
+                                         CopFILE(PL_curcop),
+                                         (long)PL_subline,
+                                         (long)CopLINE(PL_curcop));
+           gv_efullname3(tmpstr, gv, NULL);
+           (void)hv_store(GvHV(PL_DBsub), SvPVX_const(tmpstr),
+                   SvUTF8(tmpstr) ? -(I32)SvCUR(tmpstr) : (I32)SvCUR(tmpstr), sv, 0);
+           hv = GvHVn(db_postponed);
+           if (HvTOTALKEYS(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvUTF8(tmpstr) ? -(I32)SvCUR(tmpstr) : (I32)SvCUR(tmpstr))) {
+               CV * const pcv = GvCV(db_postponed);
+               if (pcv) {
+                   dSP;
+                   PUSHMARK(SP);
+                   XPUSHs(tmpstr);
+                   PUTBACK;
+                   call_sv(MUTABLE_SV(pcv), G_DISCARD);
+               }
+           }
+       }
+    }
+
+  done:
+    if (PL_parser)
+       PL_parser->copline = NOLINE;
+    return cv;
 }
 
 CV *
index 303dae7..d541e85 100644 (file)
--- a/perly.act
+++ b/perly.act
@@ -241,24 +241,34 @@ case 2:
 
   case 30:
 #line 318 "perly.y"
-    { const char *const name = SvPV_nolen_const(((SVOP*)(ps[(2) - (3)].val.opval))->op_sv);
-                         if (strEQ(name, "BEGIN") || strEQ(name, "END")
+    {
+                         if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
+                           const char *const name =
+                               SvPV_nolen_const(((SVOP*)(ps[(2) - (3)].val.opval))->op_sv);
+                           if (strEQ(name, "BEGIN") || strEQ(name, "END")
                              || strEQ(name, "INIT") || strEQ(name, "CHECK")
                              || strEQ(name, "UNITCHECK"))
                              CvSPECIAL_on(PL_compcv);
+                         }
                          PL_parser->in_my = 0;
                          PL_parser->in_my_stash = NULL;
                        ;}
     break;
 
   case 31:
-#line 327 "perly.y"
+#line 331 "perly.y"
     {
                          SvREFCNT_inc_simple_void(PL_compcv);
 #ifdef MAD
                          {
                              OP* o = newSVOP(OP_ANONCODE, 0,
-                               (SV*)newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
+                               (SV*)(
+#endif
+                         (ps[(2) - (7)].val.opval)->op_type == OP_CONST
+                             ? newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
+                             : newMYSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
+#ifdef MAD
+                               ));
                              (yyval.opval) = newOP(OP_NULL,0);
                              op_getmad(o,(yyval.opval),'&');
                              op_getmad((ps[(2) - (7)].val.opval),(yyval.opval),'n');
@@ -269,7 +279,7 @@ case 2:
                              (ps[(7) - (7)].val.opval)->op_madprop = 0;
                          }
 #else
-                         newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval));
+                         ;
                          (yyval.opval) = (OP*)NULL;
 #endif
                          intro_my();
@@ -277,7 +287,7 @@ case 2:
     break;
 
   case 32:
-#line 349 "perly.y"
+#line 359 "perly.y"
     {
                          /* Unimplemented "my sub foo { }" */
                          SvREFCNT_inc_simple_void(PL_compcv);
@@ -292,7 +302,7 @@ case 2:
     break;
 
   case 33:
-#line 361 "perly.y"
+#line 371 "perly.y"
     {
 #ifdef MAD
                          (yyval.opval) = package((ps[(3) - (4)].val.opval));
@@ -310,12 +320,12 @@ case 2:
     break;
 
   case 34:
-#line 376 "perly.y"
+#line 386 "perly.y"
     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
     break;
 
   case 35:
-#line 378 "perly.y"
+#line 388 "perly.y"
     {
                          SvREFCNT_inc_simple_void(PL_compcv);
 #ifdef MAD
@@ -333,7 +343,7 @@ case 2:
     break;
 
   case 36:
-#line 393 "perly.y"
+#line 403 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
                              newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
@@ -345,7 +355,7 @@ case 2:
     break;
 
   case 37:
-#line 402 "perly.y"
+#line 412 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
                              newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
@@ -357,7 +367,7 @@ case 2:
     break;
 
   case 38:
-#line 411 "perly.y"
+#line 421 "perly.y"
     {
                          const PADOFFSET offset = pad_findmy_pvs("$_", 0);
                          (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
@@ -371,17 +381,17 @@ case 2:
     break;
 
   case 39:
-#line 422 "perly.y"
+#line 432 "perly.y"
     { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); ;}
     break;
 
   case 40:
-#line 424 "perly.y"
+#line 434 "perly.y"
     { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); ;}
     break;
 
   case 41:
-#line 426 "perly.y"
+#line 436 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
                                  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -394,7 +404,7 @@ case 2:
     break;
 
   case 42:
-#line 436 "perly.y"
+#line 446 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
                                  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -407,7 +417,7 @@ case 2:
     break;
 
   case 43:
-#line 447 "perly.y"
+#line 457 "perly.y"
     {
                          OP *initop = IF_MAD((ps[(4) - (11)].val.opval) ? (ps[(4) - (11)].val.opval) : newOP(OP_NULL, 0), (ps[(4) - (11)].val.opval));
                          OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -430,7 +440,7 @@ case 2:
     break;
 
   case 44:
-#line 467 "perly.y"
+#line 477 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (9)].val.ival), newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (9)].val.i_tkval),(yyval.opval),'W');
@@ -442,7 +452,7 @@ case 2:
     break;
 
   case 45:
-#line 476 "perly.y"
+#line 486 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
                                      op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
@@ -454,7 +464,7 @@ case 2:
     break;
 
   case 46:
-#line 485 "perly.y"
+#line 495 "perly.y"
     {
                          (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
                                  newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
@@ -466,7 +476,7 @@ case 2:
     break;
 
   case 47:
-#line 494 "perly.y"
+#line 504 "perly.y"
     {
                          /* a block is a loop that happens once */
                          (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -475,7 +485,7 @@ case 2:
     break;
 
   case 48:
-#line 500 "perly.y"
+#line 510 "perly.y"
     {
                          package((ps[(3) - (5)].val.opval));
                          if ((ps[(2) - (5)].val.opval)) {
@@ -485,7 +495,7 @@ case 2:
     break;
 
   case 49:
-#line 507 "perly.y"
+#line 517 "perly.y"
     {
                          /* a block is a loop that happens once */
                          (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
@@ -498,7 +508,7 @@ case 2:
     break;
 
   case 50:
-#line 517 "perly.y"
+#line 527 "perly.y"
     {
                          PL_parser->expect = XSTATE;
                          (yyval.opval) = (ps[(1) - (2)].val.opval);
@@ -507,7 +517,7 @@ case 2:
     break;
 
   case 51:
-#line 523 "perly.y"
+#line 533 "perly.y"
     {
                          PL_parser->expect = XSTATE;
                          (yyval.opval) = IF_MAD(newOP(OP_NULL, 0), (OP*)NULL);
@@ -517,7 +527,7 @@ case 2:
     break;
 
   case 52:
-#line 533 "perly.y"
+#line 543 "perly.y"
     { OP *list;
                          if ((ps[(2) - (2)].val.opval)) {
                              OP *term = (ps[(2) - (2)].val.opval);
@@ -541,55 +551,55 @@ case 2:
     break;
 
   case 53:
-#line 556 "perly.y"
+#line 566 "perly.y"
     { (yyval.opval) = NULL; ;}
     break;
 
   case 54:
-#line 558 "perly.y"
+#line 568 "perly.y"
     { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
     break;
 
   case 55:
-#line 563 "perly.y"
+#line 573 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 56:
-#line 565 "perly.y"
+#line 575 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 57:
-#line 567 "perly.y"
+#line 577 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                        ;}
     break;
 
   case 58:
-#line 571 "perly.y"
+#line 581 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                        ;}
     break;
 
   case 59:
-#line 575 "perly.y"
+#line 585 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                        ;}
     break;
 
   case 60:
-#line 579 "perly.y"
+#line 589 "perly.y"
     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                        ;}
     break;
 
   case 61:
-#line 583 "perly.y"
+#line 593 "perly.y"
     { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
                          PL_parser->copline = (line_t)IVAL((ps[(2) - (3)].val.i_tkval));
@@ -597,17 +607,17 @@ case 2:
     break;
 
   case 62:
-#line 588 "perly.y"
+#line 598 "perly.y"
     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); ;}
     break;
 
   case 63:
-#line 593 "perly.y"
+#line 603 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 64:
-#line 595 "perly.y"
+#line 605 "perly.y"
     {
                          ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
                          (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
@@ -616,7 +626,7 @@ case 2:
     break;
 
   case 65:
-#line 601 "perly.y"
+#line 611 "perly.y"
     { PL_parser->copline = (line_t)IVAL((ps[(1) - (6)].val.i_tkval));
                            (yyval.opval) = newCONDOP(0,
                                newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
@@ -629,12 +639,12 @@ case 2:
     break;
 
   case 66:
-#line 614 "perly.y"
+#line 624 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 67:
-#line 616 "perly.y"
+#line 626 "perly.y"
     {
                          (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -642,101 +652,91 @@ case 2:
     break;
 
   case 68:
-#line 624 "perly.y"
+#line 634 "perly.y"
     { (yyval.ival) = (PL_min_intro_pending &&
                            PL_max_intro_pending >=  PL_min_intro_pending);
                          intro_my(); ;}
     break;
 
   case 69:
-#line 630 "perly.y"
+#line 640 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 71:
-#line 636 "perly.y"
+#line 646 "perly.y"
     { YYSTYPE tmplval;
                          (void)scan_num("1", &tmplval);
                          (yyval.opval) = tmplval.opval; ;}
     break;
 
   case 73:
-#line 644 "perly.y"
+#line 654 "perly.y"
     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 74:
-#line 649 "perly.y"
+#line 659 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 75:
-#line 653 "perly.y"
+#line 663 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 76:
-#line 657 "perly.y"
+#line 667 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
     break;
 
   case 77:
-#line 660 "perly.y"
+#line 670 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 78:
-#line 661 "perly.y"
+#line 671 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 79:
-#line 665 "perly.y"
+#line 675 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 80:
-#line 671 "perly.y"
+#line 681 "perly.y"
     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
   case 81:
-#line 676 "perly.y"
+#line 686 "perly.y"
     { (yyval.ival) = start_subparse(TRUE, 0);
                            SAVEFREESV(PL_compcv); ;}
     break;
 
-  case 82:
-#line 681 "perly.y"
-    { const char *const name = SvPV_nolen_const(((SVOP*)(ps[(1) - (1)].val.opval))->op_sv);
-                         if (strEQ(name, "BEGIN") || strEQ(name, "END")
-                             || strEQ(name, "INIT") || strEQ(name, "CHECK")
-                             || strEQ(name, "UNITCHECK"))
-                             CvSPECIAL_on(PL_compcv);
-                         (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
-    break;
-
   case 84:
-#line 692 "perly.y"
+#line 697 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 86:
-#line 698 "perly.y"
+#line 703 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 87:
-#line 700 "perly.y"
+#line 705 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
   case 88:
-#line 704 "perly.y"
+#line 709 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -746,14 +746,14 @@ case 2:
     break;
 
   case 89:
-#line 714 "perly.y"
+#line 719 "perly.y"
     { (yyval.opval) = (ps[(2) - (2)].val.opval);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
                        ;}
     break;
 
   case 90:
-#line 718 "perly.y"
+#line 723 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL, 0),
                                    (OP*)NULL
@@ -763,12 +763,12 @@ case 2:
     break;
 
   case 91:
-#line 727 "perly.y"
+#line 732 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 92:
-#line 728 "perly.y"
+#line 733 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newOP(OP_NULL,0),
                                    (OP*)NULL
@@ -779,28 +779,28 @@ case 2:
     break;
 
   case 93:
-#line 739 "perly.y"
+#line 744 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 94:
-#line 743 "perly.y"
+#line 748 "perly.y"
     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 95:
-#line 747 "perly.y"
+#line 752 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 97:
-#line 755 "perly.y"
+#line 760 "perly.y"
     {
 #ifdef MAD
                          OP* op = newNULLLIST();
@@ -813,7 +813,7 @@ case 2:
     break;
 
   case 98:
-#line 765 "perly.y"
+#line 770 "perly.y"
     { 
                          OP* term = (ps[(3) - (3)].val.opval);
                          DO_MAD(
@@ -825,7 +825,7 @@ case 2:
     break;
 
   case 100:
-#line 778 "perly.y"
+#line 783 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
                                op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
@@ -833,7 +833,7 @@ case 2:
     break;
 
   case 101:
-#line 783 "perly.y"
+#line 788 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
                                op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
@@ -843,7 +843,7 @@ case 2:
     break;
 
   case 102:
-#line 790 "perly.y"
+#line 795 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
@@ -855,7 +855,7 @@ case 2:
     break;
 
   case 103:
-#line 799 "perly.y"
+#line 804 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
                                    newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
@@ -864,7 +864,7 @@ case 2:
     break;
 
   case 104:
-#line 805 "perly.y"
+#line 810 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
@@ -873,7 +873,7 @@ case 2:
     break;
 
   case 105:
-#line 811 "perly.y"
+#line 816 "perly.y"
     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST,
                                    op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
@@ -884,14 +884,14 @@ case 2:
     break;
 
   case 106:
-#line 819 "perly.y"
+#line 824 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 107:
-#line 823 "perly.y"
+#line 828 "perly.y"
     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -900,13 +900,13 @@ case 2:
     break;
 
   case 108:
-#line 829 "perly.y"
+#line 834 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
                          (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
     break;
 
   case 109:
-#line 832 "perly.y"
+#line 837 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                 op_append_elem(OP_LIST,
                                   op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
@@ -914,7 +914,7 @@ case 2:
     break;
 
   case 112:
-#line 847 "perly.y"
+#line 852 "perly.y"
     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
                            PL_parser->expect = XOPERATOR;
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
@@ -924,7 +924,7 @@ case 2:
     break;
 
   case 113:
-#line 854 "perly.y"
+#line 859 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
@@ -932,7 +932,7 @@ case 2:
     break;
 
   case 114:
-#line 859 "perly.y"
+#line 864 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
                                        scalar((ps[(4) - (5)].val.opval)));
@@ -943,7 +943,7 @@ case 2:
     break;
 
   case 115:
-#line 867 "perly.y"
+#line 872 "perly.y"
     { (yyval.opval) = newBINOP(OP_AELEM, 0,
                                        ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
                                        scalar((ps[(3) - (4)].val.opval)));
@@ -953,7 +953,7 @@ case 2:
     break;
 
   case 116:
-#line 874 "perly.y"
+#line 879 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
                            PL_parser->expect = XOPERATOR;
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
@@ -963,7 +963,7 @@ case 2:
     break;
 
   case 117:
-#line 881 "perly.y"
+#line 886 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(4) - (6)].val.opval)));
@@ -976,7 +976,7 @@ case 2:
     break;
 
   case 118:
-#line 891 "perly.y"
+#line 896 "perly.y"
     { (yyval.opval) = newBINOP(OP_HELEM, 0,
                                        ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
                                        jmaybe((ps[(3) - (5)].val.opval)));
@@ -988,7 +988,7 @@ case 2:
     break;
 
   case 119:
-#line 900 "perly.y"
+#line 905 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
@@ -998,7 +998,7 @@ case 2:
     break;
 
   case 120:
-#line 907 "perly.y"
+#line 912 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
                                       newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
@@ -1009,7 +1009,7 @@ case 2:
     break;
 
   case 121:
-#line 916 "perly.y"
+#line 921 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
                                               newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
@@ -1019,7 +1019,7 @@ case 2:
     break;
 
   case 122:
-#line 923 "perly.y"
+#line 928 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                   newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
@@ -1028,7 +1028,7 @@ case 2:
     break;
 
   case 123:
-#line 929 "perly.y"
+#line 934 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
@@ -1038,7 +1038,7 @@ case 2:
     break;
 
   case 124:
-#line 936 "perly.y"
+#line 941 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
@@ -1046,7 +1046,7 @@ case 2:
     break;
 
   case 125:
-#line 941 "perly.y"
+#line 946 "perly.y"
     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
@@ -1056,21 +1056,21 @@ case 2:
     break;
 
   case 126:
-#line 951 "perly.y"
+#line 956 "perly.y"
     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 127:
-#line 955 "perly.y"
+#line 960 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 128:
-#line 959 "perly.y"
+#line 964 "perly.y"
     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
                                scalar((ps[(1) - (3)].val.opval));
                            (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
@@ -1079,49 +1079,49 @@ case 2:
     break;
 
   case 129:
-#line 965 "perly.y"
+#line 970 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 130:
-#line 969 "perly.y"
+#line 974 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 131:
-#line 973 "perly.y"
+#line 978 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 132:
-#line 977 "perly.y"
+#line 982 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 133:
-#line 981 "perly.y"
+#line 986 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 134:
-#line 985 "perly.y"
+#line 990 "perly.y"
     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 135:
-#line 989 "perly.y"
+#line 994 "perly.y"
     {
                          (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
                          DO_MAD({
@@ -1136,28 +1136,28 @@ case 2:
     break;
 
   case 136:
-#line 1001 "perly.y"
+#line 1006 "perly.y"
     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 137:
-#line 1005 "perly.y"
+#line 1010 "perly.y"
     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 138:
-#line 1009 "perly.y"
+#line 1014 "perly.y"
     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 139:
-#line 1013 "perly.y"
+#line 1018 "perly.y"
     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
                                ((yyval.opval)->op_type == OP_NOT
@@ -1167,14 +1167,14 @@ case 2:
     break;
 
   case 140:
-#line 1023 "perly.y"
+#line 1028 "perly.y"
     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 141:
-#line 1027 "perly.y"
+#line 1032 "perly.y"
     { (yyval.opval) = IF_MAD(
                                    newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
                                    (ps[(2) - (2)].val.opval)
@@ -1184,21 +1184,21 @@ case 2:
     break;
 
   case 142:
-#line 1034 "perly.y"
+#line 1039 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 143:
-#line 1038 "perly.y"
+#line 1043 "perly.y"
     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 144:
-#line 1042 "perly.y"
+#line 1047 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
                                        op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1206,7 +1206,7 @@ case 2:
     break;
 
   case 145:
-#line 1047 "perly.y"
+#line 1052 "perly.y"
     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
                                        op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1214,7 +1214,7 @@ case 2:
     break;
 
   case 146:
-#line 1052 "perly.y"
+#line 1057 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREINC, 0,
                                        op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1222,7 +1222,7 @@ case 2:
     break;
 
   case 147:
-#line 1057 "perly.y"
+#line 1062 "perly.y"
     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
                                        op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
@@ -1230,7 +1230,7 @@ case 2:
     break;
 
   case 148:
-#line 1066 "perly.y"
+#line 1071 "perly.y"
     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
@@ -1238,7 +1238,7 @@ case 2:
     break;
 
   case 149:
-#line 1071 "perly.y"
+#line 1076 "perly.y"
     { (yyval.opval) = newANONLIST((OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
@@ -1246,7 +1246,7 @@ case 2:
     break;
 
   case 150:
-#line 1076 "perly.y"
+#line 1081 "perly.y"
     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
                          TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
@@ -1255,7 +1255,7 @@ case 2:
     break;
 
   case 151:
-#line 1082 "perly.y"
+#line 1087 "perly.y"
     { (yyval.opval) = newANONHASH((OP*)NULL);
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
@@ -1264,7 +1264,7 @@ case 2:
     break;
 
   case 152:
-#line 1088 "perly.y"
+#line 1093 "perly.y"
     { SvREFCNT_inc_simple_void(PL_compcv);
                          (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
@@ -1274,21 +1274,21 @@ case 2:
     break;
 
   case 153:
-#line 1099 "perly.y"
+#line 1104 "perly.y"
     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 154:
-#line 1103 "perly.y"
+#line 1108 "perly.y"
     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
                        ;}
     break;
 
   case 155:
-#line 1107 "perly.y"
+#line 1112 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
@@ -1303,7 +1303,7 @@ case 2:
     break;
 
   case 156:
-#line 1119 "perly.y"
+#line 1124 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB,
                            OPf_SPECIAL|OPf_STACKED,
                            op_append_elem(OP_LIST,
@@ -1319,7 +1319,7 @@ case 2:
     break;
 
   case 157:
-#line 1132 "perly.y"
+#line 1137 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
                                scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
@@ -1330,7 +1330,7 @@ case 2:
     break;
 
   case 158:
-#line 1140 "perly.y"
+#line 1145 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
                            op_prepend_elem(OP_LIST,
                                (ps[(4) - (5)].val.opval),
@@ -1342,7 +1342,7 @@ case 2:
     break;
 
   case 163:
-#line 1156 "perly.y"
+#line 1161 "perly.y"
     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                          TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
                          TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
@@ -1350,26 +1350,26 @@ case 2:
     break;
 
   case 164:
-#line 1161 "perly.y"
+#line 1166 "perly.y"
     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 165:
-#line 1165 "perly.y"
+#line 1170 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 166:
-#line 1167 "perly.y"
+#line 1172 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
                        ;}
     break;
 
   case 167:
-#line 1171 "perly.y"
+#line 1176 "perly.y"
     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1377,12 +1377,12 @@ case 2:
     break;
 
   case 168:
-#line 1176 "perly.y"
+#line 1181 "perly.y"
     { (yyval.opval) = IF_MAD(newUNOP(OP_NULL,0,(ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 169:
-#line 1178 "perly.y"
+#line 1183 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST());
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
@@ -1390,37 +1390,37 @@ case 2:
     break;
 
   case 170:
-#line 1183 "perly.y"
+#line 1188 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 171:
-#line 1185 "perly.y"
+#line 1190 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 172:
-#line 1187 "perly.y"
+#line 1192 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 173:
-#line 1189 "perly.y"
+#line 1194 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 174:
-#line 1191 "perly.y"
+#line 1196 "perly.y"
     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
     break;
 
   case 175:
-#line 1193 "perly.y"
+#line 1198 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 176:
-#line 1195 "perly.y"
+#line 1200 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_ASLICE, 0,
@@ -1432,7 +1432,7 @@ case 2:
     break;
 
   case 177:
-#line 1204 "perly.y"
+#line 1209 "perly.y"
     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
                                newOP(OP_PUSHMARK, 0),
                                    newLISTOP(OP_HSLICE, 0,
@@ -1446,17 +1446,17 @@ case 2:
     break;
 
   case 178:
-#line 1215 "perly.y"
+#line 1220 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 179:
-#line 1217 "perly.y"
+#line 1222 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 180:
-#line 1219 "perly.y"
+#line 1224 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1464,7 +1464,7 @@ case 2:
     break;
 
   case 181:
-#line 1224 "perly.y"
+#line 1229 "perly.y"
     {
                          (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
@@ -1480,7 +1480,7 @@ case 2:
     break;
 
   case 182:
-#line 1237 "perly.y"
+#line 1242 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                            op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
@@ -1488,7 +1488,7 @@ case 2:
     break;
 
   case 183:
-#line 1242 "perly.y"
+#line 1247 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
                            PL_hints |= HINT_BLOCK_SCOPE;
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
@@ -1496,74 +1496,74 @@ case 2:
     break;
 
   case 184:
-#line 1247 "perly.y"
+#line 1252 "perly.y"
     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 185:
-#line 1251 "perly.y"
+#line 1256 "perly.y"
     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 186:
-#line 1255 "perly.y"
+#line 1260 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 187:
-#line 1259 "perly.y"
+#line 1264 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 188:
-#line 1263 "perly.y"
+#line 1268 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 189:
-#line 1267 "perly.y"
+#line 1272 "perly.y"
     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 190:
-#line 1271 "perly.y"
+#line 1276 "perly.y"
     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 191:
-#line 1275 "perly.y"
+#line 1280 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 192:
-#line 1277 "perly.y"
+#line 1282 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                            op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
     break;
 
   case 193:
-#line 1280 "perly.y"
+#line 1285 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                        ;}
     break;
 
   case 194:
-#line 1284 "perly.y"
+#line 1289 "perly.y"
     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
@@ -1572,12 +1572,12 @@ case 2:
     break;
 
   case 195:
-#line 1290 "perly.y"
+#line 1295 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 196:
-#line 1292 "perly.y"
+#line 1297 "perly.y"
     { (yyval.opval) = (ps[(1) - (3)].val.opval);
                          TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1585,13 +1585,13 @@ case 2:
     break;
 
   case 197:
-#line 1297 "perly.y"
+#line 1302 "perly.y"
     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                scalar((ps[(1) - (1)].val.opval))); ;}
     break;
 
   case 198:
-#line 1300 "perly.y"
+#line 1305 "perly.y"
     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
                            ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
                            : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
@@ -1603,7 +1603,7 @@ case 2:
     break;
 
   case 199:
-#line 1309 "perly.y"
+#line 1314 "perly.y"
     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                          TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
@@ -1612,7 +1612,7 @@ case 2:
     break;
 
   case 200:
-#line 1315 "perly.y"
+#line 1320 "perly.y"
     {
                            if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
                                && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
@@ -1626,7 +1626,7 @@ case 2:
     break;
 
   case 201:
-#line 1326 "perly.y"
+#line 1331 "perly.y"
     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival));
                          TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
@@ -1634,7 +1634,7 @@ case 2:
     break;
 
   case 204:
-#line 1333 "perly.y"
+#line 1338 "perly.y"
     {
                          (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
                                newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
@@ -1643,7 +1643,7 @@ case 2:
     break;
 
   case 206:
-#line 1343 "perly.y"
+#line 1348 "perly.y"
     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
                          DO_MAD(
                              token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
@@ -1654,14 +1654,14 @@ case 2:
     break;
 
   case 207:
-#line 1351 "perly.y"
+#line 1356 "perly.y"
     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
                        ;}
     break;
 
   case 208:
-#line 1358 "perly.y"
+#line 1363 "perly.y"
     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
@@ -1669,7 +1669,7 @@ case 2:
     break;
 
   case 209:
-#line 1363 "perly.y"
+#line 1368 "perly.y"
     { (yyval.opval) = sawparens(newNULLLIST());
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                          TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
@@ -1677,104 +1677,104 @@ case 2:
     break;
 
   case 210:
-#line 1368 "perly.y"
+#line 1373 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 211:
-#line 1370 "perly.y"
+#line 1375 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 212:
-#line 1372 "perly.y"
+#line 1377 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 213:
-#line 1377 "perly.y"
+#line 1382 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 214:
-#line 1379 "perly.y"
+#line 1384 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 215:
-#line 1383 "perly.y"
+#line 1388 "perly.y"
     { (yyval.opval) = (OP*)NULL; ;}
     break;
 
   case 216:
-#line 1385 "perly.y"
+#line 1390 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
   case 217:
-#line 1391 "perly.y"
+#line 1396 "perly.y"
     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 218:
-#line 1395 "perly.y"
+#line 1400 "perly.y"
     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
                        ;}
     break;
 
   case 219:
-#line 1401 "perly.y"
+#line 1406 "perly.y"
     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
                        ;}
     break;
 
   case 220:
-#line 1407 "perly.y"
+#line 1412 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
                        ;}
     break;
 
   case 221:
-#line 1413 "perly.y"
+#line 1418 "perly.y"
     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
                        ;}
     break;
 
   case 222:
-#line 1419 "perly.y"
+#line 1424 "perly.y"
     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
                        ;}
     break;
 
   case 223:
-#line 1425 "perly.y"
+#line 1430 "perly.y"
     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
                          TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
                        ;}
     break;
 
   case 224:
-#line 1432 "perly.y"
+#line 1437 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 225:
-#line 1434 "perly.y"
+#line 1439 "perly.y"
     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 226:
-#line 1436 "perly.y"
+#line 1441 "perly.y"
     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
     break;
 
   case 227:
-#line 1439 "perly.y"
+#line 1444 "perly.y"
     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
     break;
 
@@ -1785,6 +1785,6 @@ case 2:
     
 
 /* Generated from:
- * d37e00fcfb1737df464a95af8f4a92c2518ee5b69cd05ffc577f253313aa81c3 perly.y
+ * a216aadb9729f2e06283be0b4e7f08adc1209abb0bb9b50c453be450c6104a81 perly.y
  * 4a3ced51fe6585f6ec59e65e1ffd74bc976c498b0e6992eaab337219fee72e51 regen_perly.pl
  * ex: set ro: */
diff --git a/perly.h b/perly.h
index c531e48..63133c7 100644 (file)
--- a/perly.h
+++ b/perly.h
@@ -268,6 +268,6 @@ typedef union YYSTYPE
 
 
 /* Generated from:
- * d37e00fcfb1737df464a95af8f4a92c2518ee5b69cd05ffc577f253313aa81c3 perly.y
+ * a216aadb9729f2e06283be0b4e7f08adc1209abb0bb9b50c453be450c6104a81 perly.y
  * 4a3ced51fe6585f6ec59e65e1ffd74bc976c498b0e6992eaab337219fee72e51 regen_perly.pl
  * ex: set ro: */
index f6add2d..6c7fb0d 100644 (file)
--- a/perly.tab
+++ b/perly.tab
@@ -6,7 +6,7 @@
 
 #define YYFINAL  14
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   2817
+#define YYLAST   2820
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  105
@@ -104,7 +104,7 @@ static const yytype_int16 yyrhs[] =
      118,    10,    -1,    -1,    -1,   118,   120,    -1,    -1,   119,
      126,    -1,   122,    -1,   121,    -1,    36,   122,    -1,    36,
      121,    -1,    35,    -1,   104,    -1,    37,   141,   138,   114,
-      -1,    -1,    38,    23,   139,   123,   143,   144,   146,    -1,
+      -1,    -1,    38,   142,   139,   123,   143,   144,   146,    -1,
       71,   139,   142,   143,   144,   146,    -1,    40,    23,    23,
       20,    -1,    -1,    41,   139,   124,    23,    23,   161,    20,
       -1,    44,   103,   115,   135,   102,   116,   129,    -1,    45,
@@ -183,26 +183,26 @@ static const yytype_uint16 yyrline[] =
        0,   141,   141,   140,   150,   149,   159,   158,   171,   170,
      183,   182,   195,   194,   206,   216,   226,   229,   239,   244,
      245,   255,   256,   265,   273,   277,   284,   293,   295,   300,
-     318,   317,   348,   360,   376,   375,   392,   401,   410,   421,
-     423,   425,   435,   445,   466,   475,   484,   493,   500,   499,
-     516,   522,   532,   556,   557,   562,   564,   566,   570,   574,
-     578,   582,   587,   593,   594,   600,   614,   615,   624,   630,
-     631,   636,   639,   643,   648,   652,   656,   660,   661,   665,
-     671,   676,   681,   687,   692,   693,   698,   699,   703,   713,
-     717,   727,   728,   738,   742,   746,   750,   754,   764,   773,
-     777,   782,   789,   798,   804,   810,   818,   822,   829,   828,
-     839,   840,   844,   853,   858,   866,   873,   880,   890,   899,
-     906,   915,   922,   928,   935,   940,   950,   954,   958,   964,
-     968,   972,   976,   980,   984,   988,  1000,  1004,  1008,  1012,
-    1022,  1026,  1033,  1037,  1041,  1046,  1051,  1056,  1065,  1070,
-    1075,  1081,  1087,  1098,  1102,  1106,  1118,  1131,  1139,  1151,
-    1152,  1153,  1154,  1155,  1160,  1164,  1166,  1170,  1175,  1177,
-    1182,  1184,  1186,  1188,  1190,  1192,  1194,  1203,  1214,  1216,
-    1218,  1223,  1236,  1241,  1246,  1250,  1254,  1258,  1262,  1266,
-    1270,  1274,  1276,  1279,  1283,  1289,  1291,  1296,  1299,  1308,
-    1315,  1314,  1330,  1331,  1332,  1338,  1342,  1350,  1357,  1362,
-    1367,  1369,  1371,  1376,  1378,  1383,  1384,  1390,  1394,  1400,
-    1406,  1412,  1418,  1424,  1431,  1433,  1435,  1438
+     318,   317,   358,   370,   386,   385,   402,   411,   420,   431,
+     433,   435,   445,   455,   476,   485,   494,   503,   510,   509,
+     526,   532,   542,   566,   567,   572,   574,   576,   580,   584,
+     588,   592,   597,   603,   604,   610,   624,   625,   634,   640,
+     641,   646,   649,   653,   658,   662,   666,   670,   671,   675,
+     681,   686,   691,   692,   697,   698,   703,   704,   708,   718,
+     722,   732,   733,   743,   747,   751,   755,   759,   769,   778,
+     782,   787,   794,   803,   809,   815,   823,   827,   834,   833,
+     844,   845,   849,   858,   863,   871,   878,   885,   895,   904,
+     911,   920,   927,   933,   940,   945,   955,   959,   963,   969,
+     973,   977,   981,   985,   989,   993,  1005,  1009,  1013,  1017,
+    1027,  1031,  1038,  1042,  1046,  1051,  1056,  1061,  1070,  1075,
+    1080,  1086,  1092,  1103,  1107,  1111,  1123,  1136,  1144,  1156,
+    1157,  1158,  1159,  1160,  1165,  1169,  1171,  1175,  1180,  1182,
+    1187,  1189,  1191,  1193,  1195,  1197,  1199,  1208,  1219,  1221,
+    1223,  1228,  1241,  1246,  1251,  1255,  1259,  1263,  1267,  1271,
+    1275,  1279,  1281,  1284,  1288,  1294,  1296,  1301,  1304,  1313,
+    1320,  1319,  1335,  1336,  1337,  1343,  1347,  1355,  1362,  1367,
+    1372,  1374,  1376,  1381,  1383,  1388,  1389,  1395,  1399,  1405,
+    1411,  1417,  1423,  1429,  1436,  1438,  1440,  1443
 };
 #endif
 
@@ -338,17 +338,17 @@ static const yytype_uint8 yydefact[] =
        0,    97,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
      145,   144,     0,     0,     0,     0,     0,     0,     0,    19,
-      78,    79,     0,    34,    16,    16,    16,    16,    16,    16,
-       0,    16,    16,    40,     0,     0,    47,    50,     0,     0,
-       0,     0,     0,     0,    26,    25,    20,   148,   104,   215,
-       0,     0,   196,   108,    85,    86,   194,   198,     0,     0,
-       0,   100,     0,     0,   151,     0,   182,   209,     0,    90,
-     206,     0,   167,    95,    94,    93,    98,     0,     0,   122,
-       0,   135,   131,   132,   128,   129,   126,     0,   138,   137,
-     136,   134,   133,   130,   139,   127,     0,     0,   110,     0,
-     103,   111,   180,     0,     0,     0,     0,     0,     0,     0,
-      77,     0,    30,     0,     0,    71,     0,     0,     0,     0,
-       0,    16,     0,     0,    82,    83,    84,    67,    59,    60,
+      78,    82,    83,    79,     0,    34,    16,    16,    16,    16,
+      16,    16,     0,    16,    16,    40,     0,     0,    47,    50,
+       0,     0,     0,     0,     0,     0,    26,    25,    20,   148,
+     104,   215,     0,     0,   196,   108,    85,    86,   194,   198,
+       0,     0,     0,   100,     0,     0,   151,     0,   182,   209,
+       0,    90,   206,     0,   167,    95,    94,    93,    98,     0,
+       0,   122,     0,   135,   131,   132,   128,   129,   126,     0,
+     138,   137,   136,   134,   133,   130,   139,   127,     0,     0,
+     110,     0,   103,   111,   180,     0,     0,     0,     0,     0,
+       0,     0,    77,     0,    30,     0,     0,    71,     0,     0,
+       0,     0,     0,    16,     0,     0,    84,    67,    59,    60,
       73,    57,    58,    61,    62,     0,     0,   124,   213,    88,
        0,   199,   107,     0,   155,     0,   157,     0,   150,   208,
       89,     0,     0,     0,   115,   121,     0,     0,     0,   119,
@@ -371,77 +371,77 @@ static const yytype_uint8 yydefact[] =
 static const yytype_int16 yydefgoto[] =
 {
       -1,     7,     8,     9,    10,    11,    12,    13,   109,   340,
-      15,   407,   424,   101,   433,   216,    99,   100,   341,   284,
-     402,   445,   452,    95,   427,   206,   404,   355,   345,   299,
-     348,   357,   351,   281,   193,   122,   190,   296,   225,   310,
-     240,   417,    96,    58,    59,   308,   270,    60,    61,    62,
+      15,   407,   424,   101,   433,   218,    99,   100,   341,   286,
+     402,   445,   452,    95,   427,   208,   404,   355,   345,   299,
+     348,   357,   351,   283,   195,   122,   190,   193,   227,   310,
+     242,   417,    96,    58,    59,   308,   272,    60,    61,    62,
       63,    64,    65,   118,    66,   145,   132,    67,   352,    68,
       69,    70,    71,    72,    73,   111
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -396
+#define YYPACT_NINF -399
 static const yytype_int16 yypact[] =
 {
-     601,  -396,  -396,  -396,  -396,  -396,  -396,    26,  -396,  2656,
-      81,  1107,  1011,  -396,  -396,  -396,  1730,  2656,  2656,   315,
-     315,   315,   315,   315,  -396,   315,   315,  -396,  -396,    68,
-      -8,  -396,  2656,  -396,  -396,  -396,  2656,  -396,    10,    38,
-      42,  1544,  1451,   315,  1637,  1821,    75,  2656,    21,  2656,
-    2656,  2656,  2656,  2656,  2656,  2656,  1912,   274,    29,  -396,
-       1,  -396,  -396,  -396,  -396,  2716,  -396,  -396,    43,   127,
-     254,  -396,  -396,   131,  -396,  -396,  -396,  -396,  -396,  -396,
-     148,   170,  -396,    91,   107,   108,   129,     3,   130,   157,
-      81,  -396,  -396,   151,  -396,   266,  2003,  1011,  -396,  -396,
-    -396,   435,   531,  -396,     7,   415,   415,  -396,  -396,  -396,
-    -396,  -396,  -396,  -396,  -396,  -396,  2656,   171,   173,  2656,
-     187,  1897,    81,   269,  2716,   197,  2005,  1451,  -396,  1897,
-     278,    29,  -396,  1357,  2656,  -396,   198,  -396,  1897,    24,
-     292,    73,  2656,  1897,  2098,   235,  -396,  -396,  -396,  1897,
-      29,   415,   415,   415,     4,     4,   298,   -30,  2656,  2656,
+     307,  -399,  -399,  -399,  -399,  -399,  -399,    17,  -399,  2656,
+      34,  1107,  1011,  -399,  -399,  -399,  1730,  2656,  2656,   410,
+     410,   410,   410,   410,  -399,   410,   410,  -399,  -399,    15,
+     -47,  -399,  2656,  -399,  -399,  -399,  2656,  -399,   -27,    37,
+      43,  1544,  1451,   410,  1637,  1821,    78,  2656,    21,  2656,
+    2656,  2656,  2656,  2656,  2656,  2656,  1912,    26,    12,  -399,
+       7,  -399,  -399,  -399,  -399,  2719,  -399,  -399,    48,    50,
+      77,  -399,  -399,   104,  -399,  -399,  -399,  -399,  -399,  -399,
+      55,    83,  -399,    57,    69,    85,    86,     5,    90,    91,
+      34,  -399,  -399,   114,  -399,   125,  2096,  1011,  -399,  -399,
+    -399,   435,   531,  -399,    -7,   517,   517,  -399,  -399,  -399,
+    -399,  -399,  -399,  -399,  -399,  -399,  2656,    93,   101,  2656,
+     109,  1990,    34,   187,  2719,   112,  2005,  1451,  -399,  1990,
+     279,    12,  -399,  1357,  2656,  -399,   117,  -399,  1990,    38,
+     205,    59,  2656,  1990,  2098,   153,  -399,  -399,  -399,  1990,
+      12,   517,   517,   517,   127,   127,   220,   294,  2656,  2656,
     2656,  2656,  2656,  2656,  2191,  2656,  2656,  2656,  2656,  2656,
     2656,  2656,  2656,  2656,  2656,  2656,  2656,  2656,  2656,  2656,
-    -396,  -396,     5,  2284,  2656,  2656,  2656,  2656,  2656,  -396,
-     293,  -396,   295,  -396,  -396,  -396,  -396,  -396,  -396,  -396,
-     212,  -396,  -396,  -396,    41,    81,  -396,  -396,  2656,  2656,
-    2656,  2656,  2656,  2656,  -396,  -396,  -396,  -396,  -396,  2656,
-    2656,    40,  -396,  -396,  -396,   246,  -396,  -396,   226,   223,
-    2656,    29,  2377,  2470,  -396,   321,  -396,  -396,   234,   311,
-    -396,  2656,   333,   270,   270,  -396,  2716,    96,    65,  -396,
-     256,  1532,  1806,   125,   301,   310,  2716,  2699,   332,   332,
-    1282,  1622,  1715,   133,   415,   415,  2656,  2656,  -396,  2563,
-     245,  -396,  -396,   268,   141,    70,   189,   113,   193,   627,
-    -396,   350,  -396,    58,   349,  2656,  2656,  2656,  2656,   362,
-    1201,  -396,  2656,  2656,  -396,  -396,   269,  -396,   274,  -396,
-     274,   274,   274,   274,   274,   276,   -42,  -396,  2656,   355,
-      81,  -396,  -396,   336,  -396,   339,  -396,   419,  -396,  -396,
-    -396,   123,  2656,   372,  -396,  -396,  2656,   215,   160,  -396,
-     431,  2656,  -396,   373,  -396,   374,  -396,   378,  -396,  -396,
-    -396,   269,  -396,  -396,   366,   302,   274,   307,   322,   274,
-    -396,   323,   297,  -396,  -396,  -396,   324,   383,  1200,  2656,
-     329,   330,   246,  -396,  -396,  -396,  -396,  -396,  -396,  -396,
-    -396,  -396,   164,  -396,  1439,   427,  -396,  -396,   338,  -396,
-    -396,  -396,   422,   246,  -396,  2656,  -396,  -396,   434,   434,
-    2656,   434,  2656,   345,   434,   434,    74,  -396,  -396,  -396,
-     381,    74,  -396,   437,   434,   434,  -396,    19,    19,   361,
-     151,   461,   434,  -396,  -396,  -396,  -396,  -396,  -396,  -396,
-     723,  -396,   151,   151,  -396,   434,   379,  -396,  -396,   434,
-    -396,  -396,   151,    37,  -396,  -396,  -396,   819,  -396,  2656,
-     151,  1295,  -396,   467,   409,  -396,  -396,   397,  -396,   412,
-    -396,  -396,  -396,   434,   434,   915,    19,  -396,  -396,  -396
+    -399,  -399,    24,  2284,  2656,  2656,  2656,  2656,  2656,  -399,
+     213,  -399,  -399,  -399,   219,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,   156,  -399,  -399,  -399,    55,    34,  -399,  -399,
+    2656,  2656,  2656,  2656,  2656,  2656,  -399,  -399,  -399,  -399,
+    -399,  2656,  2656,    65,  -399,  -399,  -399,   170,  -399,  -399,
+     322,   160,  2656,    12,  2377,  2470,  -399,   255,  -399,  -399,
+     419,   246,  -399,  2656,   263,   197,   197,  -399,  2719,   217,
+      70,  -399,   431,  1439,  1897,  1715,   612,   207,  2719,  2678,
+    1283,  1283,  1529,  1622,  1806,   320,   517,   517,  2656,  2656,
+    -399,  2563,   175,  -399,  -399,   434,   241,    97,   257,   113,
+     260,   627,  -399,   265,  -399,    10,   258,  2656,  2656,  2656,
+    2656,   282,  1201,  -399,  2656,  2656,   187,  -399,    26,  -399,
+      26,    26,    26,    26,    26,   199,    -8,  -399,  2656,   276,
+      34,  -399,  -399,   439,  -399,   515,  -399,   527,  -399,  -399,
+    -399,   123,  2656,   297,  -399,  -399,  2656,   268,   140,  -399,
+     530,  2656,  -399,   306,  -399,   315,  -399,   317,  -399,  -399,
+    -399,   187,  -399,  -399,   308,   227,    26,   230,   242,    26,
+    -399,   247,   245,  -399,  -399,  -399,   249,   332,   190,  2656,
+     251,   253,   170,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,   144,  -399,  1189,   349,  -399,  -399,   272,  -399,
+    -399,  -399,   358,   170,  -399,  2656,  -399,  -399,   370,   370,
+    2656,   370,  2656,   280,   370,   370,    33,  -399,  -399,  -399,
+     313,    33,  -399,   369,   370,   370,  -399,    71,    71,   291,
+     114,   375,   370,  -399,  -399,  -399,  -399,  -399,  -399,  -399,
+     723,  -399,   114,   114,  -399,   370,   299,  -399,  -399,   370,
+    -399,  -399,   114,    40,  -399,  -399,  -399,   819,  -399,  2656,
+     114,  1295,  -399,   381,   330,  -399,  -399,   304,  -399,   311,
+    -399,  -399,  -399,   370,   370,   915,    71,  -399,  -399,  -399
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -396,  -396,  -396,  -396,  -396,  -396,  -396,  -396,   -10,  -396,
-     -32,  2340,  -396,   -12,  -396,   505,   421,     6,  -396,  -396,
-    -396,  -396,  -396,  -285,  -395,  -126,  -357,  -396,   128,    -9,
-    -222,    78,  -396,  -396,   -82,   487,  -396,  -396,  -253,  -321,
-    -396,   122,    -5,   -35,  -396,  -396,  -396,  -396,  -396,  -396,
-    -396,  -396,    79,  -396,  -396,  -396,  -110,  -119,  -396,  -396,
-       2,   476,   477,  -396,  -396,    33
+    -399,  -399,  -399,  -399,  -399,  -399,  -399,  -399,   -10,  -399,
+     -33,     3,  -399,   -12,  -399,   397,   323,    -2,  -399,  -399,
+    -399,  -399,  -399,  -280,  -398,  -237,  -374,  -399,    22,  -190,
+    -240,   -19,  -399,  -399,   -77,   388,  -399,   223,  -267,  -293,
+    -399,    25,    -5,   -35,  -399,  -399,  -399,  -399,  -399,  -399,
+    -399,  -399,    79,  -399,  -399,  -399,  -110,  -119,  -399,  -399,
+       2,   382,   383,  -399,  -399,    42
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
@@ -451,78 +451,78 @@ static const yytype_int16 yypgoto[] =
 #define YYTABLE_NINF -203
 static const yytype_int16 yytable[] =
 {
-      75,    93,    93,   102,    57,   354,   218,   131,   229,   204,
-     162,   104,   163,   428,   266,   150,   267,    94,    19,   217,
-      19,   110,   110,   110,   110,   110,    14,   110,   110,   268,
-     405,   128,   236,   184,   137,   185,    19,    20,    21,   161,
-     141,   396,   189,   362,   133,   110,   139,   158,   159,   160,
-     146,   157,   307,   112,   113,   114,   115,   443,   116,   117,
-     364,   459,   401,   444,   294,   425,   426,   342,   356,   295,
-     360,   361,   242,   198,   441,   134,   135,   324,   343,   119,
-     203,   131,   334,    74,   158,   159,   160,    93,   383,   200,
-      74,    93,    93,   235,   415,   120,   105,   106,   142,   231,
-     305,  -203,  -203,   215,   164,   182,   199,   131,   269,   282,
-     161,   121,   223,   125,   221,   124,   323,   158,   159,   160,
-     129,   228,    57,   138,   144,   336,   143,   233,   149,   133,
-     151,   152,   153,   154,   155,   371,   184,   393,   185,   238,
-     188,   126,   158,   159,   160,   127,   183,   158,   159,   160,
-     158,   159,   160,   243,   244,   245,   354,   247,   248,   250,
-     230,   333,   285,   286,   287,   288,   289,   290,   409,   292,
-     293,   191,   376,   158,   159,   160,   397,   279,   273,   274,
-     275,   276,   277,   278,   271,   306,   166,  -203,   168,   169,
-     158,   159,   160,   192,   194,   297,   168,   169,   365,   205,
-     158,   159,   160,   298,   300,   301,   302,   303,   304,   335,
-     195,   196,   378,   337,    57,   177,   178,   447,   158,   159,
-     160,   179,   180,   181,   178,   313,   182,   315,   317,   179,
-     180,   181,   197,   201,   182,   375,   321,   158,   159,   160,
-     246,   158,   159,   160,   251,   252,   253,   254,   255,   256,
-     257,   258,   259,   260,   261,   262,   263,   264,   265,   359,
-     202,   327,   328,   186,   330,   187,   158,   159,   160,    93,
-     158,   159,   160,   131,   219,   403,   220,   347,  -202,   350,
-     346,   300,   349,   300,   430,   358,   207,   349,   349,   222,
-    -202,   353,   158,   159,   160,   224,   435,   436,  -202,   226,
-     367,   232,   234,   158,   159,   160,   442,   382,   239,   241,
-     384,   158,   159,   160,   448,   291,   280,   372,   283,   309,
-    -202,  -202,  -202,  -202,    74,   312,    57,  -202,   311,  -202,
-      19,   318,  -202,   158,   159,   160,   319,   320,   107,  -202,
-    -202,  -202,  -202,   108,   322,   158,   159,   160,   331,   160,
-     131,   158,   159,   160,   349,  -202,  -202,  -202,   325,  -202,
+      75,    93,    93,   102,    57,   219,   220,   131,   231,    94,
+     428,   104,   354,   405,   206,   150,   162,    14,   163,   342,
+      19,   110,   110,   110,   110,   110,   119,   110,   110,   362,
+     343,   128,   238,   268,   137,   269,    19,    20,    21,    19,
+     141,   189,    74,    74,   133,   110,   139,   184,   270,   185,
+     146,   157,   356,   415,   360,   361,   120,   441,   459,   184,
+     443,   185,   112,   113,   114,   115,   444,   116,   117,   396,
+     158,   159,   160,   161,   383,   200,   125,   307,   191,   237,
+     205,   131,   324,   192,   134,   135,   186,    93,   187,   202,
+     401,    93,    93,   161,   364,   217,   105,   106,   347,   233,
+     350,   142,   305,   158,   159,   160,   194,   131,   201,   334,
+     164,   121,   225,   188,   223,   124,   284,   425,   426,   393,
+     129,   230,    57,   138,   144,   336,   143,   271,   149,   133,
+     151,   152,   153,   154,   155,   371,   158,   159,   160,   240,
+     126,   235,   158,   159,   160,   209,   127,   158,   159,   160,
+     409,   183,   376,   245,   246,   247,   397,   249,   250,   252,
+     196,   354,   207,   287,   288,   289,   290,   291,   292,   232,
+     294,   295,   197,   430,   158,   159,   160,   281,   275,   276,
+     277,   278,   279,   280,   273,   435,   436,   306,   198,   199,
+     158,   159,   160,   203,   204,   442,   221,   297,   365,   447,
+     158,   159,   160,   448,   222,   298,   300,   301,   302,   303,
+     304,   224,   378,   226,   228,   236,    57,   158,   159,   160,
+     234,   158,   159,   160,  -203,  -203,   241,   313,   182,   315,
+     317,   243,   210,   211,   212,   213,   282,   323,   321,   214,
+     248,   215,   285,   309,   253,   254,   255,   256,   257,   258,
+     259,   260,   261,   262,   263,   264,   265,   266,   267,   293,
+     359,   333,   312,   327,   328,   318,   330,   158,   159,   160,
+     168,    93,   320,   131,   322,   403,   160,   335,   331,  -202,
+     337,   344,   346,   300,   349,   300,   339,   358,   375,   349,
+     349,  -202,   -74,   353,   158,   159,   160,    19,   178,  -202,
+     367,   363,   366,   179,   180,   181,   382,   373,   182,   384,
+       1,     2,     3,     4,     5,     6,   379,   372,   158,   159,
+     160,  -202,  -202,  -202,  -202,   380,    57,   381,  -202,   386,
+    -202,   385,   387,  -202,   158,   159,   160,   158,   159,   160,
+    -202,  -202,  -202,  -202,   388,   158,   159,   160,   390,   389,
+     131,   391,   392,   394,   349,   395,  -202,  -202,  -202,   398,
     -202,  -202,  -202,  -202,  -202,  -202,  -202,  -202,  -202,  -202,
-     332,   339,   344,   168,  -202,  -202,  -202,    19,   363,  -202,
-    -202,   366,   373,   379,   380,   349,   416,   346,   381,   385,
-     420,   416,   178,   166,   167,   168,   169,   179,   180,   181,
-     390,   178,   182,   392,   386,   374,   179,   180,   181,   387,
-      93,   182,   437,   158,   159,   160,   158,   159,   160,   174,
-     175,   176,   177,   178,   388,   389,   391,    93,   179,   180,
-     181,   394,   395,   182,   349,   -13,    76,   398,   368,   455,
-     399,   369,   400,   406,    74,    93,    16,   412,    17,    18,
-      19,    20,    21,    22,    23,    77,   418,   421,    24,    25,
-      26,    27,    28,   429,    29,    30,    31,    32,    33,    34,
+    -202,   158,   159,   160,   399,  -202,  -202,  -202,   400,   406,
+    -202,  -202,   412,   168,   169,   349,   416,   346,   418,   421,
+     420,   416,   408,   429,   410,   431,   244,   413,   414,   158,
+     159,   160,   439,   450,   451,   374,   453,   422,   423,    98,
+      93,   178,   437,   454,   411,   432,   179,   180,   181,    74,
+     216,   182,   449,   123,   311,    19,   419,    93,   438,   296,
+     147,   148,   440,   107,   349,   -13,    76,     0,   108,   455,
+       0,     0,     0,     0,    74,    93,    16,     0,    17,    18,
+      19,    20,    21,    22,    23,    77,   456,   457,    24,    25,
+      26,    27,    28,     0,    29,    30,    31,    32,    33,    34,
       78,    97,    79,    80,    35,    81,    82,    83,    84,    85,
-      86,   431,   439,   451,    87,    88,    89,    90,    36,   450,
-      37,    38,    39,    40,    41,    42,   158,   159,   160,   453,
+      86,     0,     0,     0,    87,    88,    89,    90,    36,     0,
+      37,    38,    39,    40,    41,    42,   158,   159,   160,     0,
       43,    44,    45,    46,    47,    48,    91,    49,   158,   159,
-     160,   179,   180,   181,   454,    50,   182,    98,   214,   449,
-     411,   370,   123,   419,   147,   148,     0,    51,    52,    53,
-       0,    -3,    76,   377,    54,    55,     0,     0,    56,    92,
-      74,     0,    16,     0,    17,    18,    19,    20,    21,    22,
+     160,   158,   159,   160,     0,    50,   158,   159,   160,     0,
+       0,   319,     0,     0,     0,     0,     0,    51,    52,    53,
+       0,    -3,    76,   325,    54,    55,   332,     0,    56,    92,
+      74,   368,    16,     0,    17,    18,    19,    20,    21,    22,
       23,    77,     0,     0,    24,    25,    26,    27,    28,     0,
       29,    30,    31,    32,    33,    34,    78,    97,    79,    80,
       35,    81,    82,    83,    84,    85,    86,     0,     0,     0,
       87,    88,    89,    90,    36,     0,    37,    38,    39,    40,
-      41,    42,     0,     0,     0,     0,    43,    44,    45,    46,
-      47,    48,    91,    49,     1,     2,     3,     4,     5,     6,
-       0,    50,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    51,    52,    53,     0,     0,    76,     0,
-      54,    55,     0,     0,    56,    92,    74,   338,    16,     0,
+      41,    42,   158,   159,   160,     0,    43,    44,    45,    46,
+      47,    48,    91,    49,   158,   159,   160,   158,   159,   160,
+       0,    50,     0,   179,   180,   181,     0,   369,   182,     0,
+       0,     0,     0,    51,    52,    53,     0,     0,    76,   370,
+      54,    55,   377,     0,    56,    92,    74,   338,    16,     0,
       17,    18,    19,    20,    21,    22,    23,    77,     0,     0,
       24,    25,    26,    27,    28,     0,    29,    30,    31,    32,
       33,    34,    78,    97,    79,    80,    35,    81,    82,    83,
       84,    85,    86,     0,     0,     0,    87,    88,    89,    90,
       36,     0,    37,    38,    39,    40,    41,    42,     0,     0,
        0,     0,    43,    44,    45,    46,    47,    48,    91,    49,
-       0,     0,     0,     0,     0,     0,     0,    50,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    51,
+       0,     0,     0,   178,     0,     0,     0,    50,   179,   180,
+     181,     0,     0,   182,     0,     0,     0,     0,     0,    51,
       52,    53,     0,     0,    76,     0,    54,    55,     0,     0,
       56,    92,    74,   434,    16,     0,    17,    18,    19,    20,
       21,    22,    23,    77,     0,     0,    24,    25,    26,    27,
@@ -575,21 +575,21 @@ static const yytype_int16 yytable[] =
       56,    92,    16,     0,    17,    18,    19,    20,    21,    22,
       23,   -69,     0,     0,    24,    25,    26,    27,    28,     0,
       29,    30,    31,    32,    33,    34,     0,     0,     0,     0,
-      35,     0,   208,   209,   210,   211,     0,     0,     0,   212,
-       0,   213,     0,     0,    36,     0,    37,    38,    39,    40,
+      35,     0,     0,   165,     0,     0,     0,     0,     0,     0,
+     166,   167,   168,   169,    36,     0,    37,    38,    39,    40,
       41,    42,     0,     0,     0,     0,    43,    44,    45,    46,
-      47,    48,     0,    49,     0,     0,     0,   158,   159,   160,
-       0,    50,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    51,    52,    53,    76,     0,     0,     0,
-      54,    55,   -74,     0,    56,     0,    16,     0,    17,    18,
+      47,    48,   171,    49,   172,   173,   174,   175,   176,   177,
+     178,    50,     0,     0,     0,   179,   180,   181,     0,     0,
+     182,     0,     0,    51,    52,    53,    76,     0,     0,     0,
+      54,    55,     0,     0,    56,     0,    16,     0,    17,    18,
       19,    20,    21,    22,    23,     0,     0,     0,    24,    25,
       26,    27,    28,     0,    29,    30,    31,    32,    33,    34,
        0,     0,     0,     0,    35,     0,     0,     0,     0,     0,
-       0,     0,     0,   166,   167,   168,   169,     0,    36,     0,
+       0,     0,     0,     0,   166,   167,   168,   169,    36,     0,
       37,    38,    39,    40,    41,    42,     0,  -170,     0,     0,
       43,    44,    45,    46,    47,    48,   184,    49,   185,  -170,
-     175,   176,   177,   178,     0,    50,     0,  -170,   179,   180,
-     181,     0,     0,   182,     0,     0,     0,    51,    52,    53,
+     174,   175,   176,   177,   178,    50,     0,  -170,     0,   179,
+     180,   181,     0,     0,   182,     0,     0,    51,    52,    53,
        0,     0,     0,     0,    54,    55,     0,   -69,    56,  -170,
     -170,  -170,  -170,     0,     0,     0,  -170,     0,  -170,     0,
        0,  -170,     0,     0,     0,     0,     0,     0,  -170,  -170,
@@ -600,21 +600,21 @@ static const yytype_int16 yytable[] =
       74,     0,    16,     0,    17,    18,    19,    20,    21,    22,
       23,     0,     0,     0,   130,    25,    26,    27,    28,   108,
       29,    30,    31,    32,    33,    34,     0,     0,     0,     0,
-      35,     0,     0,   165,     0,     0,     0,     0,     0,     0,
+      35,     0,     0,  -203,     0,     0,     0,     0,     0,     0,
      166,   167,   168,   169,    36,     0,    37,    38,    39,    40,
       41,    42,     0,     0,     0,     0,    43,    44,    45,    46,
-      47,    48,   171,    49,   172,   173,   174,   175,   176,   177,
+      47,    48,     0,    49,   172,   173,   174,   175,   176,   177,
      178,    50,     0,     0,     0,   179,   180,   181,     0,     0,
      182,     0,     0,    51,    52,    53,     0,     0,     0,     0,
       54,    55,     0,    74,    56,    16,     0,    17,    18,    19,
       20,    21,    22,    23,     0,     0,     0,    24,    25,    26,
       27,    28,     0,    29,    30,    31,    32,    33,    34,     0,
-       0,     0,     0,    35,     0,     0,  -203,     0,     0,     0,
-       0,     0,     0,   166,   167,   168,   169,    36,     0,    37,
+       0,     0,     0,    35,     0,     0,     0,     0,     0,     0,
+     166,   167,   168,   169,     0,     0,     0,    36,     0,    37,
       38,    39,    40,    41,    42,     0,     0,     0,     0,    43,
-      44,    45,    46,    47,    48,     0,    49,   172,   173,   174,
-     175,   176,   177,   178,    50,     0,     0,     0,   179,   180,
-     181,     0,     0,   182,     0,     0,    51,    52,    53,     0,
+      44,    45,    46,    47,    48,     0,    49,   175,   176,   177,
+     178,     0,     0,     0,    50,   179,   180,   181,     0,     0,
+     182,     0,     0,     0,     0,     0,    51,    52,    53,     0,
        0,     0,     0,    54,    55,     0,    74,    56,    16,     0,
       17,    18,    19,    20,    21,    22,    23,     0,     0,     0,
      136,    25,    26,    27,    28,     0,    29,    30,    31,    32,
@@ -628,7 +628,7 @@ static const yytype_int16 yytable[] =
       56,    16,   103,    17,    18,    19,    20,    21,    22,    23,
        0,     0,     0,    24,    25,    26,    27,    28,     0,    29,
       30,    31,    32,    33,    34,     0,     0,     0,     0,    35,
-       0,     0,     0,     0,     0,     0,   166,   167,   168,   169,
+       0,     0,     0,     0,     0,     0,   166,  -203,   168,   169,
        0,     0,     0,    36,     0,    37,    38,    39,    40,    41,
       42,     0,     0,     0,     0,    43,    44,    45,    46,    47,
       48,     0,    49,     0,     0,   177,   178,     0,     0,     0,
@@ -637,7 +637,7 @@ static const yytype_int16 yytable[] =
       55,     0,    16,    56,    17,    18,    19,    20,    21,    22,
       23,   140,     0,     0,    24,    25,    26,    27,    28,     0,
       29,    30,    31,    32,    33,    34,     0,     0,     0,     0,
-      35,     0,     0,     0,     0,     0,     0,  -203,     0,   168,
+      35,     0,     0,     0,     0,     0,     0,   166,   167,   168,
      169,     0,     0,     0,    36,     0,    37,    38,    39,    40,
       41,    42,     0,     0,     0,     0,    43,    44,    45,    46,
       47,    48,     0,    49,     0,     0,   177,   178,     0,     0,
@@ -646,7 +646,7 @@ static const yytype_int16 yytable[] =
       54,    55,     0,    16,    56,    17,    18,    19,    20,    21,
       22,    23,     0,     0,     0,    24,    25,    26,    27,    28,
        0,    29,    30,    31,    32,    33,    34,     0,     0,     0,
-       0,    35,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    35,     0,     0,     0,     0,     0,     0,  -203,     0,
      168,   169,     0,     0,     0,    36,     0,    37,    38,    39,
       40,    41,    42,     0,     0,     0,     0,    43,    44,    45,
       46,    47,    48,     0,    49,     0,     0,   177,   178,     0,
@@ -655,23 +655,23 @@ static const yytype_int16 yytable[] =
        0,    54,    55,     0,   156,    56,    16,     0,    17,    18,
       19,    20,    21,    22,    23,     0,     0,     0,    24,    25,
       26,    27,    28,     0,    29,    30,    31,    32,    33,    34,
-       0,     0,     0,     0,    35,   208,   209,   210,   211,     0,
-       0,     0,   212,     0,   213,     0,     0,     0,    36,     0,
+       0,     0,     0,     0,    35,     0,     0,     0,     0,     0,
+       0,     0,     0,   168,   169,     0,     0,     0,    36,     0,
       37,    38,    39,    40,    41,    42,     0,     0,     0,     0,
       43,    44,    45,    46,    47,    48,     0,    49,     0,     0,
-     158,   159,   160,     0,     0,    50,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    51,    52,    53,
-       0,     0,     0,     0,    54,    55,     0,   227,    56,    16,
+     177,   178,     0,     0,     0,    50,   179,   180,   181,     0,
+       0,   182,     0,     0,     0,     0,     0,    51,    52,    53,
+       0,     0,     0,     0,    54,    55,     0,   229,    56,    16,
        0,    17,    18,    19,    20,    21,    22,    23,     0,     0,
        0,    24,    25,    26,    27,    28,     0,    29,    30,    31,
-      32,    33,    34,     0,     0,     0,     0,    35,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      32,    33,    34,     0,     0,     0,     0,    35,   210,   211,
+     212,   213,     0,     0,     0,   214,     0,   215,     0,     0,
        0,    36,     0,    37,    38,    39,    40,    41,    42,     0,
        0,     0,     0,    43,    44,    45,    46,    47,    48,     0,
-      49,     0,     0,     0,     0,     0,     0,     0,    50,     0,
+      49,     0,     0,   158,   159,   160,     0,     0,    50,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       51,    52,    53,     0,     0,     0,     0,    54,    55,     0,
-     237,    56,    16,     0,    17,    18,    19,    20,    21,    22,
+     239,    56,    16,     0,    17,    18,    19,    20,    21,    22,
       23,     0,     0,     0,    24,    25,    26,    27,    28,     0,
       29,    30,    31,    32,    33,    34,     0,     0,     0,     0,
       35,     0,     0,     0,     0,     0,     0,     0,     0,     0,
@@ -680,7 +680,7 @@ static const yytype_int16 yytable[] =
       47,    48,     0,    49,     0,     0,     0,     0,     0,     0,
        0,    50,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,    51,    52,    53,     0,     0,     0,     0,
-      54,    55,     0,   249,    56,    16,     0,    17,    18,    19,
+      54,    55,     0,   251,    56,    16,     0,    17,    18,    19,
       20,    21,    22,    23,     0,     0,     0,    24,    25,    26,
       27,    28,     0,    29,    30,    31,    32,    33,    34,     0,
        0,     0,     0,    35,     0,     0,     0,     0,     0,     0,
@@ -689,7 +689,7 @@ static const yytype_int16 yytable[] =
       44,    45,    46,    47,    48,     0,    49,     0,     0,     0,
        0,     0,     0,     0,    50,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,    51,    52,    53,     0,
-       0,     0,     0,    54,    55,     0,   272,    56,    16,     0,
+       0,     0,     0,    54,    55,     0,   274,    56,    16,     0,
       17,    18,    19,    20,    21,    22,    23,     0,     0,     0,
       24,    25,    26,    27,    28,     0,    29,    30,    31,    32,
       33,    34,     0,     0,     0,     0,    35,     0,     0,     0,
@@ -723,92 +723,93 @@ static const yytype_int16 yytable[] =
       34,     0,     0,     0,     0,    35,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    36,
        0,    37,    38,    39,    40,    41,    42,     0,     0,     0,
-       0,    43,    44,    45,    46,    47,    48,     0,    49,   408,
-       0,   410,     0,     0,   413,   414,    50,     0,     0,     0,
-       0,     0,     0,     0,   422,   423,     0,     0,    51,    52,
-      53,     0,   432,   165,     0,    54,    55,     0,     0,    56,
-     166,   167,   168,   169,     0,   438,     0,     0,     0,   440,
-     165,     0,     0,     0,     0,     0,     0,   166,   167,   168,
-     169,   170,   171,   326,   172,   173,   174,   175,   176,   177,
-     178,     0,     0,   456,   457,   179,   180,   181,   170,   171,
-     182,   172,   173,   174,   175,   176,   177,   178,     0,     0,
-       0,     0,   179,   180,   181,     0,     0,   182
+       0,    43,    44,    45,    46,    47,    48,     0,    49,     0,
+       0,     0,   165,     0,     0,     0,    50,     0,     0,   166,
+     167,   168,   169,     0,     0,     0,     0,     0,    51,    52,
+      53,     0,     0,     0,     0,    54,    55,     0,     0,    56,
+     170,   171,   326,   172,   173,   174,   175,   176,   177,   178,
+       0,     0,     0,   165,   179,   180,   181,     0,     0,   182,
+     166,   167,   168,   169,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   170,   171,     0,   172,   173,   174,   175,   176,   177,
+     178,     0,     0,     0,     0,   179,   180,   181,     0,     0,
+     182
 };
 
 static const yytype_int16 yycheck[] =
 {
-      10,    11,    12,    15,     9,   290,   116,    42,   127,    91,
-       9,    16,    11,   408,     9,    50,    11,    11,    15,    12,
-      15,    19,    20,    21,    22,    23,     0,    25,    26,    24,
-     387,    41,   142,     9,    44,    11,    15,    16,    17,    81,
-      45,   362,    74,   296,    42,    43,    44,    77,    78,    79,
-      48,    56,    12,    20,    21,    22,    23,    20,    25,    26,
-     102,   456,   383,    26,    23,    46,    47,     9,   290,    28,
-     292,   293,   102,    70,   431,    42,    43,    12,    20,    11,
-      90,   116,    12,     9,    77,    78,    79,    97,   341,    87,
-       9,   101,   102,    20,    20,   103,    17,    18,    23,   134,
-     219,    97,    98,    97,   103,   101,   103,   142,   103,   191,
-      81,    32,   122,   103,   119,    36,    20,    77,    78,    79,
+      10,    11,    12,    15,     9,    12,   116,    42,   127,    11,
+     408,    16,   292,   387,    91,    50,     9,     0,    11,     9,
+      15,    19,    20,    21,    22,    23,    11,    25,    26,   296,
+      20,    41,   142,     9,    44,    11,    15,    16,    17,    15,
+      45,    74,     9,     9,    42,    43,    44,     9,    24,    11,
+      48,    56,   292,    20,   294,   295,   103,   431,   456,     9,
+      20,    11,    20,    21,    22,    23,    26,    25,    26,   362,
+      77,    78,    79,    81,   341,    70,   103,    12,    23,    20,
+      90,   116,    12,    28,    42,    43,     9,    97,    11,    87,
+     383,   101,   102,    81,   102,    97,    17,    18,   288,   134,
+     290,    23,   221,    77,    78,    79,    23,   142,   103,    12,
+     103,    32,   122,     9,   119,    36,   193,    46,    47,   359,
       41,   126,   127,    44,   103,    12,    47,   103,    49,   127,
-      51,    52,    53,    54,    55,    12,     9,   359,    11,   144,
-       9,   103,    77,    78,    79,   103,   103,    77,    78,    79,
-      77,    78,    79,   158,   159,   160,   441,   162,   163,   164,
-     127,    20,   194,   195,   196,   197,   198,   199,   390,   201,
-     202,    23,    12,    77,    78,    79,    12,   189,   183,   184,
-     185,   186,   187,   188,   182,   220,    61,    62,    63,    64,
-      77,    78,    79,    23,   103,   205,    63,    64,   308,    48,
-      77,    78,    79,   208,   209,   210,   211,   212,   213,    20,
-     103,   103,   331,    20,   219,    90,    91,   439,    77,    78,
-      79,    96,    97,    98,    91,   230,   101,   232,   233,    96,
-      97,    98,   103,   103,   101,    20,   241,    77,    78,    79,
-     161,    77,    78,    79,   165,   166,   167,   168,   169,   170,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   291,
-     103,   266,   267,     9,   269,    11,    77,    78,    79,   279,
-      77,    78,    79,   308,   103,   385,   103,   286,     0,   288,
-     285,   286,   287,   288,   410,   290,    20,   292,   293,   102,
-      12,   289,    77,    78,    79,    26,   422,   423,    20,   102,
-     310,   103,    10,    77,    78,    79,   432,   339,    73,    11,
-     342,    77,    78,    79,   440,   103,    23,   322,    23,    73,
-      42,    43,    44,    45,     9,   102,   331,    49,   102,    51,
-      15,    10,    54,    77,    78,    79,   102,    26,    23,    61,
-      62,    63,    64,    28,    11,    77,    78,    79,   103,    79,
-     385,    77,    78,    79,   359,    77,    78,    79,   102,    81,
-      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
-     102,    21,    23,    63,    96,    97,    98,    15,   102,   101,
-     102,    26,    10,    10,    10,   390,   396,   392,    10,    23,
-     402,   401,    91,    61,    62,    63,    64,    96,    97,    98,
-     103,    91,   101,    20,   102,   326,    96,    97,    98,   102,
-     420,   101,   424,    77,    78,    79,    77,    78,    79,    87,
-      88,    89,    90,    91,   102,   102,   102,   437,    96,    97,
-      98,   102,   102,   101,   439,     0,     1,    10,   102,   451,
-     102,   102,    20,     9,     9,   455,    11,   102,    13,    14,
-      15,    16,    17,    18,    19,    20,    75,    20,    23,    24,
-      25,    26,    27,   102,    29,    30,    31,    32,    33,    34,
+      51,    52,    53,    54,    55,    12,    77,    78,    79,   144,
+     103,   103,    77,    78,    79,    20,   103,    77,    78,    79,
+     390,   103,    12,   158,   159,   160,    12,   162,   163,   164,
+     103,   441,    48,   196,   197,   198,   199,   200,   201,   127,
+     203,   204,   103,   410,    77,    78,    79,   189,   183,   184,
+     185,   186,   187,   188,   182,   422,   423,   222,   103,   103,
+      77,    78,    79,   103,   103,   432,   103,   207,   308,   439,
+      77,    78,    79,   440,   103,   210,   211,   212,   213,   214,
+     215,   102,   331,    26,   102,    10,   221,    77,    78,    79,
+     103,    77,    78,    79,    97,    98,    73,   232,   101,   234,
+     235,    11,    42,    43,    44,    45,    23,    20,   243,    49,
+     161,    51,    23,    73,   165,   166,   167,   168,   169,   170,
+     171,   172,   173,   174,   175,   176,   177,   178,   179,   103,
+     293,    20,   102,   268,   269,    10,   271,    77,    78,    79,
+      63,   281,    26,   308,    11,   385,    79,    20,   103,     0,
+      20,    23,   287,   288,   289,   290,    21,   292,    20,   294,
+     295,    12,   102,   291,    77,    78,    79,    15,    91,    20,
+     310,   102,    26,    96,    97,    98,   339,    10,   101,   342,
+       3,     4,     5,     6,     7,     8,    10,   322,    77,    78,
+      79,    42,    43,    44,    45,    10,   331,    10,    49,   102,
+      51,    23,   102,    54,    77,    78,    79,    77,    78,    79,
+      61,    62,    63,    64,   102,    77,    78,    79,   103,   102,
+     385,   102,    20,   102,   359,   102,    77,    78,    79,    10,
+      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
+      91,    77,    78,    79,   102,    96,    97,    98,    20,     9,
+     101,   102,   102,    63,    64,   390,   396,   392,    75,    20,
+     402,   401,   389,   102,   391,    20,   102,   394,   395,    77,
+      78,    79,   103,    22,    74,   326,   102,   404,   405,    12,
+     420,    91,   424,   102,   392,   412,    96,    97,    98,     9,
+      97,   101,   441,    35,   102,    15,   401,   437,   425,   206,
+      48,    48,   429,    23,   439,     0,     1,    -1,    28,   451,
+      -1,    -1,    -1,    -1,     9,   455,    11,    -1,    13,    14,
+      15,    16,    17,    18,    19,    20,   453,   454,    23,    24,
+      25,    26,    27,    -1,    29,    30,    31,    32,    33,    34,
       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    20,   103,    74,    49,    50,    51,    52,    53,    22,
-      55,    56,    57,    58,    59,    60,    77,    78,    79,   102,
+      45,    -1,    -1,    -1,    49,    50,    51,    52,    53,    -1,
+      55,    56,    57,    58,    59,    60,    77,    78,    79,    -1,
       65,    66,    67,    68,    69,    70,    71,    72,    77,    78,
-      79,    96,    97,    98,   102,    80,   101,    12,    97,   441,
-     392,   102,    35,   401,    48,    48,    -1,    92,    93,    94,
-      -1,     0,     1,   102,    99,   100,    -1,    -1,   103,   104,
-       9,    -1,    11,    -1,    13,    14,    15,    16,    17,    18,
+      79,    77,    78,    79,    -1,    80,    77,    78,    79,    -1,
+      -1,   102,    -1,    -1,    -1,    -1,    -1,    92,    93,    94,
+      -1,     0,     1,   102,    99,   100,   102,    -1,   103,   104,
+       9,   102,    11,    -1,    13,    14,    15,    16,    17,    18,
       19,    20,    -1,    -1,    23,    24,    25,    26,    27,    -1,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
       39,    40,    41,    42,    43,    44,    45,    -1,    -1,    -1,
       49,    50,    51,    52,    53,    -1,    55,    56,    57,    58,
-      59,    60,    -1,    -1,    -1,    -1,    65,    66,    67,    68,
-      69,    70,    71,    72,     3,     4,     5,     6,     7,     8,
-      -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    92,    93,    94,    -1,    -1,     1,    -1,
-      99,   100,    -1,    -1,   103,   104,     9,    10,    11,    -1,
+      59,    60,    77,    78,    79,    -1,    65,    66,    67,    68,
+      69,    70,    71,    72,    77,    78,    79,    77,    78,    79,
+      -1,    80,    -1,    96,    97,    98,    -1,   102,   101,    -1,
+      -1,    -1,    -1,    92,    93,    94,    -1,    -1,     1,   102,
+      99,   100,   102,    -1,   103,   104,     9,    10,    11,    -1,
       13,    14,    15,    16,    17,    18,    19,    20,    -1,    -1,
       23,    24,    25,    26,    27,    -1,    29,    30,    31,    32,
       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
       43,    44,    45,    -1,    -1,    -1,    49,    50,    51,    52,
       53,    -1,    55,    56,    57,    58,    59,    60,    -1,    -1,
       -1,    -1,    65,    66,    67,    68,    69,    70,    71,    72,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+      -1,    -1,    -1,    91,    -1,    -1,    -1,    80,    96,    97,
+      98,    -1,    -1,   101,    -1,    -1,    -1,    -1,    -1,    92,
       93,    94,    -1,    -1,     1,    -1,    99,   100,    -1,    -1,
      103,   104,     9,    10,    11,    -1,    13,    14,    15,    16,
       17,    18,    19,    20,    -1,    -1,    23,    24,    25,    26,
@@ -861,21 +862,21 @@ static const yytype_int16 yycheck[] =
      103,   104,    11,    -1,    13,    14,    15,    16,    17,    18,
       19,    20,    -1,    -1,    23,    24,    25,    26,    27,    -1,
       29,    30,    31,    32,    33,    34,    -1,    -1,    -1,    -1,
-      39,    -1,    42,    43,    44,    45,    -1,    -1,    -1,    49,
-      -1,    51,    -1,    -1,    53,    -1,    55,    56,    57,    58,
+      39,    -1,    -1,    54,    -1,    -1,    -1,    -1,    -1,    -1,
+      61,    62,    63,    64,    53,    -1,    55,    56,    57,    58,
       59,    60,    -1,    -1,    -1,    -1,    65,    66,    67,    68,
-      69,    70,    -1,    72,    -1,    -1,    -1,    77,    78,    79,
-      -1,    80,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    92,    93,    94,     1,    -1,    -1,    -1,
-      99,   100,   102,    -1,   103,    -1,    11,    -1,    13,    14,
+      69,    70,    83,    72,    85,    86,    87,    88,    89,    90,
+      91,    80,    -1,    -1,    -1,    96,    97,    98,    -1,    -1,
+     101,    -1,    -1,    92,    93,    94,     1,    -1,    -1,    -1,
+      99,   100,    -1,    -1,   103,    -1,    11,    -1,    13,    14,
       15,    16,    17,    18,    19,    -1,    -1,    -1,    23,    24,
       25,    26,    27,    -1,    29,    30,    31,    32,    33,    34,
       -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    61,    62,    63,    64,    -1,    53,    -1,
+      -1,    -1,    -1,    -1,    61,    62,    63,    64,    53,    -1,
       55,    56,    57,    58,    59,    60,    -1,     0,    -1,    -1,
       65,    66,    67,    68,    69,    70,     9,    72,    11,    12,
-      88,    89,    90,    91,    -1,    80,    -1,    20,    96,    97,
-      98,    -1,    -1,   101,    -1,    -1,    -1,    92,    93,    94,
+      87,    88,    89,    90,    91,    80,    -1,    20,    -1,    96,
+      97,    98,    -1,    -1,   101,    -1,    -1,    92,    93,    94,
       -1,    -1,    -1,    -1,    99,   100,    -1,   102,   103,    42,
       43,    44,    45,    -1,    -1,    -1,    49,    -1,    51,    -1,
       -1,    54,    -1,    -1,    -1,    -1,    -1,    -1,    61,    62,
@@ -889,18 +890,18 @@ static const yytype_int16 yycheck[] =
       39,    -1,    -1,    54,    -1,    -1,    -1,    -1,    -1,    -1,
       61,    62,    63,    64,    53,    -1,    55,    56,    57,    58,
       59,    60,    -1,    -1,    -1,    -1,    65,    66,    67,    68,
-      69,    70,    83,    72,    85,    86,    87,    88,    89,    90,
+      69,    70,    -1,    72,    85,    86,    87,    88,    89,    90,
       91,    80,    -1,    -1,    -1,    96,    97,    98,    -1,    -1,
      101,    -1,    -1,    92,    93,    94,    -1,    -1,    -1,    -1,
       99,   100,    -1,     9,   103,    11,    -1,    13,    14,    15,
       16,    17,    18,    19,    -1,    -1,    -1,    23,    24,    25,
       26,    27,    -1,    29,    30,    31,    32,    33,    34,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    54,    -1,    -1,    -1,
-      -1,    -1,    -1,    61,    62,    63,    64,    53,    -1,    55,
+      -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
+      61,    62,    63,    64,    -1,    -1,    -1,    53,    -1,    55,
       56,    57,    58,    59,    60,    -1,    -1,    -1,    -1,    65,
-      66,    67,    68,    69,    70,    -1,    72,    85,    86,    87,
-      88,    89,    90,    91,    80,    -1,    -1,    -1,    96,    97,
-      98,    -1,    -1,   101,    -1,    -1,    92,    93,    94,    -1,
+      66,    67,    68,    69,    70,    -1,    72,    88,    89,    90,
+      91,    -1,    -1,    -1,    80,    96,    97,    98,    -1,    -1,
+     101,    -1,    -1,    -1,    -1,    -1,    92,    93,    94,    -1,
       -1,    -1,    -1,    99,   100,    -1,     9,   103,    11,    -1,
       13,    14,    15,    16,    17,    18,    19,    -1,    -1,    -1,
       23,    24,    25,    26,    27,    -1,    29,    30,    31,    32,
@@ -923,7 +924,7 @@ static const yytype_int16 yycheck[] =
      100,    -1,    11,   103,    13,    14,    15,    16,    17,    18,
       19,    20,    -1,    -1,    23,    24,    25,    26,    27,    -1,
       29,    30,    31,    32,    33,    34,    -1,    -1,    -1,    -1,
-      39,    -1,    -1,    -1,    -1,    -1,    -1,    61,    -1,    63,
+      39,    -1,    -1,    -1,    -1,    -1,    -1,    61,    62,    63,
       64,    -1,    -1,    -1,    53,    -1,    55,    56,    57,    58,
       59,    60,    -1,    -1,    -1,    -1,    65,    66,    67,    68,
       69,    70,    -1,    72,    -1,    -1,    90,    91,    -1,    -1,
@@ -932,7 +933,7 @@ static const yytype_int16 yycheck[] =
       99,   100,    -1,    11,   103,    13,    14,    15,    16,    17,
       18,    19,    -1,    -1,    -1,    23,    24,    25,    26,    27,
       -1,    29,    30,    31,    32,    33,    34,    -1,    -1,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    61,    -1,
       63,    64,    -1,    -1,    -1,    53,    -1,    55,    56,    57,
       58,    59,    60,    -1,    -1,    -1,    -1,    65,    66,    67,
       68,    69,    70,    -1,    72,    -1,    -1,    90,    91,    -1,
@@ -941,20 +942,20 @@ static const yytype_int16 yycheck[] =
       -1,    99,   100,    -1,   102,   103,    11,    -1,    13,    14,
       15,    16,    17,    18,    19,    -1,    -1,    -1,    23,    24,
       25,    26,    27,    -1,    29,    30,    31,    32,    33,    34,
-      -1,    -1,    -1,    -1,    39,    42,    43,    44,    45,    -1,
-      -1,    -1,    49,    -1,    51,    -1,    -1,    -1,    53,    -1,
+      -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    63,    64,    -1,    -1,    -1,    53,    -1,
       55,    56,    57,    58,    59,    60,    -1,    -1,    -1,    -1,
       65,    66,    67,    68,    69,    70,    -1,    72,    -1,    -1,
-      77,    78,    79,    -1,    -1,    80,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    92,    93,    94,
+      90,    91,    -1,    -1,    -1,    80,    96,    97,    98,    -1,
+      -1,   101,    -1,    -1,    -1,    -1,    -1,    92,    93,    94,
       -1,    -1,    -1,    -1,    99,   100,    -1,   102,   103,    11,
       -1,    13,    14,    15,    16,    17,    18,    19,    -1,    -1,
       -1,    23,    24,    25,    26,    27,    -1,    29,    30,    31,
-      32,    33,    34,    -1,    -1,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      32,    33,    34,    -1,    -1,    -1,    -1,    39,    42,    43,
+      44,    45,    -1,    -1,    -1,    49,    -1,    51,    -1,    -1,
       -1,    53,    -1,    55,    56,    57,    58,    59,    60,    -1,
       -1,    -1,    -1,    65,    66,    67,    68,    69,    70,    -1,
-      72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    80,    -1,
+      72,    -1,    -1,    77,    78,    79,    -1,    -1,    80,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       92,    93,    94,    -1,    -1,    -1,    -1,    99,   100,    -1,
      102,   103,    11,    -1,    13,    14,    15,    16,    17,    18,
@@ -1009,16 +1010,17 @@ static const yytype_int16 yycheck[] =
       34,    -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    53,
       -1,    55,    56,    57,    58,    59,    60,    -1,    -1,    -1,
-      -1,    65,    66,    67,    68,    69,    70,    -1,    72,   389,
-      -1,   391,    -1,    -1,   394,   395,    80,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   404,   405,    -1,    -1,    92,    93,
-      94,    -1,   412,    54,    -1,    99,   100,    -1,    -1,   103,
-      61,    62,    63,    64,    -1,   425,    -1,    -1,    -1,   429,
-      54,    -1,    -1,    -1,    -1,    -1,    -1,    61,    62,    63,
-      64,    82,    83,    84,    85,    86,    87,    88,    89,    90,
-      91,    -1,    -1,   453,   454,    96,    97,    98,    82,    83,
-     101,    85,    86,    87,    88,    89,    90,    91,    -1,    -1,
-      -1,    -1,    96,    97,    98,    -1,    -1,   101
+      -1,    65,    66,    67,    68,    69,    70,    -1,    72,    -1,
+      -1,    -1,    54,    -1,    -1,    -1,    80,    -1,    -1,    61,
+      62,    63,    64,    -1,    -1,    -1,    -1,    -1,    92,    93,
+      94,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,   103,
+      82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
+      -1,    -1,    -1,    54,    96,    97,    98,    -1,    -1,   101,
+      61,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    82,    83,    -1,    85,    86,    87,    88,    89,    90,
+      91,    -1,    -1,    -1,    -1,    96,    97,    98,    -1,    -1,
+     101
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -1044,17 +1046,17 @@ static const yytype_uint8 yystos[] =
       79,    81,     9,    11,   103,    54,    61,    62,    63,    64,
       82,    83,    85,    86,    87,    88,    89,    90,    91,    96,
       97,    98,   101,   103,     9,    11,     9,    11,     9,   115,
-     141,    23,    23,   139,   103,   103,   103,   103,    70,   103,
-     165,   103,   103,   113,   139,    48,   130,    20,    42,    43,
-      44,    45,    49,    51,   121,   122,   120,    12,   161,   103,
-     103,   147,   102,   113,    26,   143,   102,   102,   147,   162,
-     170,   148,   103,   103,    10,    20,   161,   102,   147,    73,
-     145,    11,   102,   147,   147,   147,   157,   147,   147,   102,
-     147,   157,   157,   157,   157,   157,   157,   157,   157,   157,
-     157,   157,   157,   157,   157,   157,     9,    11,    24,   103,
-     151,   165,   102,   147,   147,   147,   147,   147,   147,   118,
-      23,   138,   139,    23,   124,   115,   115,   115,   115,   115,
-     115,   103,   115,   115,    23,    28,   142,   113,   147,   134,
+     141,    23,    28,   142,    23,   139,   103,   103,   103,   103,
+      70,   103,   165,   103,   103,   113,   139,    48,   130,    20,
+      42,    43,    44,    45,    49,    51,   121,   122,   120,    12,
+     161,   103,   103,   147,   102,   113,    26,   143,   102,   102,
+     147,   162,   170,   148,   103,   103,    10,    20,   161,   102,
+     147,    73,   145,    11,   102,   147,   147,   147,   157,   147,
+     147,   102,   147,   157,   157,   157,   157,   157,   157,   157,
+     157,   157,   157,   157,   157,   157,   157,   157,     9,    11,
+      24,   103,   151,   165,   102,   147,   147,   147,   147,   147,
+     147,   118,    23,   138,   139,    23,   124,   115,   115,   115,
+     115,   115,   115,   103,   115,   115,   142,   113,   147,   134,
      147,   147,   147,   147,   147,   162,   148,    12,   150,    73,
      144,   102,   102,   147,   102,   147,   102,   147,    10,   102,
       26,   147,    11,    20,    12,   102,    84,   147,   147,   102,
@@ -1108,6 +1110,6 @@ static const toketypes yy_type_tab[] =
 };
 
 /* Generated from:
- * d37e00fcfb1737df464a95af8f4a92c2518ee5b69cd05ffc577f253313aa81c3 perly.y
+ * a216aadb9729f2e06283be0b4e7f08adc1209abb0bb9b50c453be450c6104a81 perly.y
  * 4a3ced51fe6585f6ec59e65e1ffd74bc976c498b0e6992eaab337219fee72e51 regen_perly.pl
  * ex: set ro: */
diff --git a/perly.y b/perly.y
index a091d3d..72065cf 100644 (file)
--- a/perly.y
+++ b/perly.y
@@ -314,12 +314,16 @@ barestmt: PLUGSTMT
                              pad_add_anon(fmtcv, OP_NULL);
                          }
                        }
-       |       SUB WORD startsub
-                       { const char *const name = SvPV_nolen_const(((SVOP*)$2)->op_sv);
-                         if (strEQ(name, "BEGIN") || strEQ(name, "END")
+       |       SUB subname startsub
+                       {
+                         if ($2->op_type == OP_CONST) {
+                           const char *const name =
+                               SvPV_nolen_const(((SVOP*)$2)->op_sv);
+                           if (strEQ(name, "BEGIN") || strEQ(name, "END")
                              || strEQ(name, "INIT") || strEQ(name, "CHECK")
                              || strEQ(name, "UNITCHECK"))
                              CvSPECIAL_on(PL_compcv);
+                         }
                          PL_parser->in_my = 0;
                          PL_parser->in_my_stash = NULL;
                        }
@@ -329,7 +333,13 @@ barestmt:  PLUGSTMT
 #ifdef MAD
                          {
                              OP* o = newSVOP(OP_ANONCODE, 0,
-                               (SV*)newATTRSUB($3, $2, $5, $6, $7));
+                               (SV*)(
+#endif
+                         $2->op_type == OP_CONST
+                             ? newATTRSUB($3, $2, $5, $6, $7)
+                             : newMYSUB($3, $2, $5, $6, $7)
+#ifdef MAD
+                               ));
                              $$ = newOP(OP_NULL,0);
                              op_getmad(o,$$,'&');
                              op_getmad($2,$$,'n');
@@ -340,7 +350,7 @@ barestmt:   PLUGSTMT
                              $7->op_madprop = 0;
                          }
 #else
-                         newATTRSUB($3, $2, $5, $6, $7);
+                         ;
                          $$ = (OP*)NULL;
 #endif
                          intro_my();
@@ -678,12 +688,7 @@ startformsub:      /* NULL */      /* start a format subroutine scope */
        ;
 
 /* Name of a subroutine - must be a bareword, could be special */
-subname        :       WORD    { const char *const name = SvPV_nolen_const(((SVOP*)$1)->op_sv);
-                         if (strEQ(name, "BEGIN") || strEQ(name, "END")
-                             || strEQ(name, "INIT") || strEQ(name, "CHECK")
-                             || strEQ(name, "UNITCHECK"))
-                             CvSPECIAL_on(PL_compcv);
-                         $$ = $1; }
+subname        :       WORD
        |       PRIVATEREF
        ;
 
diff --git a/proto.h b/proto.h
index e6cba14..c09d5fe 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -2644,6 +2644,11 @@ PERL_CALLCONV OP*        Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP*
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV CV *     Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_NEWMYSUB      \
+       assert(o)
+
 PERL_CALLCONV OP*      Perl_newNULLLIST(pTHX)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -4825,9 +4830,6 @@ PERL_CALLCONV void*       Perl_my_cxt_init(pTHX_ int *index, size_t size)
 #endif
 #if !(defined(PERL_MAD))
 PERL_CALLCONV void     Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV_NO_RET void      Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
-                       __attribute__noreturn__;
-
 PERL_CALLCONV void     Perl_package(pTHX_ OP* o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PACKAGE       \
@@ -7329,9 +7331,6 @@ PERL_CALLCONV MADPROP*    Perl_newMADsv(pTHX_ char key, SV* sv)
 #define PERL_ARGS_ASSERT_NEWMADSV      \
        assert(sv)
 
-PERL_CALLCONV_NO_RET OP *      Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
-                       __attribute__noreturn__;
-
 PERL_CALLCONV TOKEN*   Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop);
 PERL_CALLCONV void     Perl_op_getmad(pTHX_ OP* from, OP* o, char slot);
 PERL_CALLCONV void     Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot);