This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Re: Bytecode? Back into service.
authorAdrian M. Enache <enache@rdslink.ro>
Thu, 20 Mar 2003 07:38:39 +0000 (09:38 +0200)
committerRafael Garcia-Suarez <rgarciasuarez@gmail.com>
Thu, 20 Mar 2003 22:07:50 +0000 (22:07 +0000)
Message-ID: <20030320053839.GA4044@ratsnest.hole>

p4raw-id: //depot/perl@19038

bytecode.pl
ext/B/B/Asmdata.pm
ext/ByteLoader/byterun.c
ext/ByteLoader/byterun.h
op.c

index 569d28e..38ae809 100644 (file)
@@ -382,6 +382,7 @@ xcv_file    CvFILE(bstate->bs_sv)                   pvindex
 xcv_depth      CvDEPTH(bstate->bs_sv)                  long
 xcv_padlist    *(SV**)&CvPADLIST(bstate->bs_sv)        svindex
 xcv_outside    *(SV**)&CvOUTSIDE(bstate->bs_sv)        svindex
+xcv_outside_seq        CvOUTSIDE_SEQ(bstate->bs_sv)            U32
 xcv_flags      CvFLAGS(bstate->bs_sv)                  U16
 av_extend      bstate->bs_sv                           SSize_t         x
 av_push                bstate->bs_sv                           svindex         x
index 9b95e37..1f6498a 100644 (file)
@@ -76,74 +76,75 @@ $insn_data{xcv_file} = [49, \&PUT_pvindex, "GET_pvindex"];
 $insn_data{xcv_depth} = [50, \&PUT_I32, "GET_I32"];
 $insn_data{xcv_padlist} = [51, \&PUT_svindex, "GET_svindex"];
 $insn_data{xcv_outside} = [52, \&PUT_svindex, "GET_svindex"];
-$insn_data{xcv_flags} = [53, \&PUT_U16, "GET_U16"];
-$insn_data{av_extend} = [54, \&PUT_I32, "GET_I32"];
-$insn_data{av_push} = [55, \&PUT_svindex, "GET_svindex"];
-$insn_data{xav_fill} = [56, \&PUT_I32, "GET_I32"];
-$insn_data{xav_max} = [57, \&PUT_I32, "GET_I32"];
-$insn_data{xav_flags} = [58, \&PUT_U8, "GET_U8"];
-$insn_data{xhv_riter} = [59, \&PUT_I32, "GET_I32"];
-$insn_data{xhv_name} = [60, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{hv_store} = [61, \&PUT_svindex, "GET_svindex"];
-$insn_data{sv_magic} = [62, \&PUT_U8, "GET_U8"];
-$insn_data{mg_obj} = [63, \&PUT_svindex, "GET_svindex"];
-$insn_data{mg_private} = [64, \&PUT_U16, "GET_U16"];
-$insn_data{mg_flags} = [65, \&PUT_U8, "GET_U8"];
-$insn_data{mg_pv} = [66, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{xmg_stash} = [67, \&PUT_svindex, "GET_svindex"];
-$insn_data{gv_fetchpv} = [68, \&PUT_strconst, "GET_strconst"];
-$insn_data{gv_stashpv} = [69, \&PUT_strconst, "GET_strconst"];
-$insn_data{gp_sv} = [70, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_refcnt} = [71, \&PUT_U32, "GET_U32"];
-$insn_data{gp_refcnt_add} = [72, \&PUT_I32, "GET_I32"];
-$insn_data{gp_av} = [73, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_hv} = [74, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_cv} = [75, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_file} = [76, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{gp_io} = [77, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_form} = [78, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_cvgen} = [79, \&PUT_U32, "GET_U32"];
-$insn_data{gp_line} = [80, \&PUT_U16, "GET_U16"];
-$insn_data{gp_share} = [81, \&PUT_svindex, "GET_svindex"];
-$insn_data{xgv_flags} = [82, \&PUT_U8, "GET_U8"];
-$insn_data{op_next} = [83, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_sibling} = [84, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_ppaddr} = [85, \&PUT_strconst, "GET_strconst"];
-$insn_data{op_targ} = [86, \&PUT_U32, "GET_U32"];
-$insn_data{op_type} = [87, \&PUT_U16, "GET_U16"];
-$insn_data{op_seq} = [88, \&PUT_U16, "GET_U16"];
-$insn_data{op_flags} = [89, \&PUT_U8, "GET_U8"];
-$insn_data{op_private} = [90, \&PUT_U8, "GET_U8"];
-$insn_data{op_first} = [91, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_last} = [92, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_other} = [93, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmreplroot} = [94, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmreplrootgv} = [95, \&PUT_svindex, "GET_svindex"];
-$insn_data{op_pmreplstart} = [96, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmnext} = [97, \&PUT_opindex, "GET_opindex"];
-$insn_data{pregcomp} = [98, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{op_pmflags} = [99, \&PUT_U16, "GET_U16"];
-$insn_data{op_pmpermflags} = [100, \&PUT_U16, "GET_U16"];
-$insn_data{op_sv} = [101, \&PUT_svindex, "GET_svindex"];
-$insn_data{op_padix} = [102, \&PUT_U32, "GET_U32"];
-$insn_data{op_pv} = [103, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{op_pv_tr} = [104, \&PUT_op_tr_array, "GET_op_tr_array"];
-$insn_data{op_redoop} = [105, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_nextop} = [106, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_lastop} = [107, \&PUT_opindex, "GET_opindex"];
-$insn_data{cop_label} = [108, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{cop_stashpv} = [109, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{cop_file} = [110, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{cop_seq} = [111, \&PUT_U32, "GET_U32"];
-$insn_data{cop_arybase} = [112, \&PUT_I32, "GET_I32"];
-$insn_data{cop_line} = [113, \&PUT_U16, "GET_U16"];
-$insn_data{cop_warnings} = [114, \&PUT_svindex, "GET_svindex"];
-$insn_data{main_start} = [115, \&PUT_opindex, "GET_opindex"];
-$insn_data{main_root} = [116, \&PUT_opindex, "GET_opindex"];
-$insn_data{curpad} = [117, \&PUT_svindex, "GET_svindex"];
-$insn_data{push_begin} = [118, \&PUT_svindex, "GET_svindex"];
-$insn_data{push_init} = [119, \&PUT_svindex, "GET_svindex"];
-$insn_data{push_end} = [120, \&PUT_svindex, "GET_svindex"];
+$insn_data{xcv_outside_seq} = [53, \&PUT_U32, "GET_U32"];
+$insn_data{xcv_flags} = [54, \&PUT_U16, "GET_U16"];
+$insn_data{av_extend} = [55, \&PUT_I32, "GET_I32"];
+$insn_data{av_push} = [56, \&PUT_svindex, "GET_svindex"];
+$insn_data{xav_fill} = [57, \&PUT_I32, "GET_I32"];
+$insn_data{xav_max} = [58, \&PUT_I32, "GET_I32"];
+$insn_data{xav_flags} = [59, \&PUT_U8, "GET_U8"];
+$insn_data{xhv_riter} = [60, \&PUT_I32, "GET_I32"];
+$insn_data{xhv_name} = [61, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{hv_store} = [62, \&PUT_svindex, "GET_svindex"];
+$insn_data{sv_magic} = [63, \&PUT_U8, "GET_U8"];
+$insn_data{mg_obj} = [64, \&PUT_svindex, "GET_svindex"];
+$insn_data{mg_private} = [65, \&PUT_U16, "GET_U16"];
+$insn_data{mg_flags} = [66, \&PUT_U8, "GET_U8"];
+$insn_data{mg_pv} = [67, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{xmg_stash} = [68, \&PUT_svindex, "GET_svindex"];
+$insn_data{gv_fetchpv} = [69, \&PUT_strconst, "GET_strconst"];
+$insn_data{gv_stashpv} = [70, \&PUT_strconst, "GET_strconst"];
+$insn_data{gp_sv} = [71, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_refcnt} = [72, \&PUT_U32, "GET_U32"];
+$insn_data{gp_refcnt_add} = [73, \&PUT_I32, "GET_I32"];
+$insn_data{gp_av} = [74, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_hv} = [75, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_cv} = [76, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_file} = [77, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{gp_io} = [78, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_form} = [79, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_cvgen} = [80, \&PUT_U32, "GET_U32"];
+$insn_data{gp_line} = [81, \&PUT_U16, "GET_U16"];
+$insn_data{gp_share} = [82, \&PUT_svindex, "GET_svindex"];
+$insn_data{xgv_flags} = [83, \&PUT_U8, "GET_U8"];
+$insn_data{op_next} = [84, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_sibling} = [85, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_ppaddr} = [86, \&PUT_strconst, "GET_strconst"];
+$insn_data{op_targ} = [87, \&PUT_U32, "GET_U32"];
+$insn_data{op_type} = [88, \&PUT_U16, "GET_U16"];
+$insn_data{op_seq} = [89, \&PUT_U16, "GET_U16"];
+$insn_data{op_flags} = [90, \&PUT_U8, "GET_U8"];
+$insn_data{op_private} = [91, \&PUT_U8, "GET_U8"];
+$insn_data{op_first} = [92, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_last} = [93, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_other} = [94, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmreplroot} = [95, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmreplrootgv} = [96, \&PUT_svindex, "GET_svindex"];
+$insn_data{op_pmreplstart} = [97, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmnext} = [98, \&PUT_opindex, "GET_opindex"];
+$insn_data{pregcomp} = [99, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{op_pmflags} = [100, \&PUT_U16, "GET_U16"];
+$insn_data{op_pmpermflags} = [101, \&PUT_U16, "GET_U16"];
+$insn_data{op_sv} = [102, \&PUT_svindex, "GET_svindex"];
+$insn_data{op_padix} = [103, \&PUT_U32, "GET_U32"];
+$insn_data{op_pv} = [104, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{op_pv_tr} = [105, \&PUT_op_tr_array, "GET_op_tr_array"];
+$insn_data{op_redoop} = [106, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_nextop} = [107, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_lastop} = [108, \&PUT_opindex, "GET_opindex"];
+$insn_data{cop_label} = [109, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{cop_stashpv} = [110, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{cop_file} = [111, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{cop_seq} = [112, \&PUT_U32, "GET_U32"];
+$insn_data{cop_arybase} = [113, \&PUT_I32, "GET_I32"];
+$insn_data{cop_line} = [114, \&PUT_U16, "GET_U16"];
+$insn_data{cop_warnings} = [115, \&PUT_svindex, "GET_svindex"];
+$insn_data{main_start} = [116, \&PUT_opindex, "GET_opindex"];
+$insn_data{main_root} = [117, \&PUT_opindex, "GET_opindex"];
+$insn_data{curpad} = [118, \&PUT_svindex, "GET_svindex"];
+$insn_data{push_begin} = [119, \&PUT_svindex, "GET_svindex"];
+$insn_data{push_init} = [120, \&PUT_svindex, "GET_svindex"];
+$insn_data{push_end} = [121, \&PUT_svindex, "GET_svindex"];
 
 my ($insn_name, $insn_data);
 while (($insn_name, $insn_data) = each %insn_data) {
index ee06b1c..8c8ad12 100644 (file)
@@ -425,476 +425,483 @@ byterun(pTHX_ register struct byteloader_state *bstate)
                *(SV**)&CvOUTSIDE(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_XCV_FLAGS:          /* 53 */
+         case INSN_XCV_OUTSIDE_SEQ:            /* 53 */
+           {
+               U32 arg;
+               BGET_U32(arg);
+               CvOUTSIDE_SEQ(bstate->bs_sv) = arg;
+               break;
+           }
+         case INSN_XCV_FLAGS:          /* 54 */
            {
                U16 arg;
                BGET_U16(arg);
                CvFLAGS(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_AV_EXTEND:          /* 54 */
+         case INSN_AV_EXTEND:          /* 55 */
            {
                SSize_t arg;
                BGET_I32(arg);
                BSET_av_extend(bstate->bs_sv, arg);
                break;
            }
-         case INSN_AV_PUSH:            /* 55 */
+         case INSN_AV_PUSH:            /* 56 */
            {
                svindex arg;
                BGET_svindex(arg);
                BSET_av_push(bstate->bs_sv, arg);
                break;
            }
-         case INSN_XAV_FILL:           /* 56 */
+         case INSN_XAV_FILL:           /* 57 */
            {
                SSize_t arg;
                BGET_I32(arg);
                AvFILLp(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_XAV_MAX:            /* 57 */
+         case INSN_XAV_MAX:            /* 58 */
            {
                SSize_t arg;
                BGET_I32(arg);
                AvMAX(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_XAV_FLAGS:          /* 58 */
+         case INSN_XAV_FLAGS:          /* 59 */
            {
                U8 arg;
                BGET_U8(arg);
                AvFLAGS(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_XHV_RITER:          /* 59 */
+         case INSN_XHV_RITER:          /* 60 */
            {
                I32 arg;
                BGET_I32(arg);
                HvRITER(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_XHV_NAME:           /* 60 */
+         case INSN_XHV_NAME:           /* 61 */
            {
                pvcontents arg;
                BGET_pvcontents(arg);
                HvNAME(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_HV_STORE:           /* 61 */
+         case INSN_HV_STORE:           /* 62 */
            {
                svindex arg;
                BGET_svindex(arg);
                BSET_hv_store(bstate->bs_sv, arg);
                break;
            }
-         case INSN_SV_MAGIC:           /* 62 */
+         case INSN_SV_MAGIC:           /* 63 */
            {
                char arg;
                BGET_U8(arg);
                BSET_sv_magic(bstate->bs_sv, arg);
                break;
            }
-         case INSN_MG_OBJ:             /* 63 */
+         case INSN_MG_OBJ:             /* 64 */
            {
                svindex arg;
                BGET_svindex(arg);
                SvMAGIC(bstate->bs_sv)->mg_obj = arg;
                break;
            }
-         case INSN_MG_PRIVATE:         /* 64 */
+         case INSN_MG_PRIVATE:         /* 65 */
            {
                U16 arg;
                BGET_U16(arg);
                SvMAGIC(bstate->bs_sv)->mg_private = arg;
                break;
            }
-         case INSN_MG_FLAGS:           /* 65 */
+         case INSN_MG_FLAGS:           /* 66 */
            {
                U8 arg;
                BGET_U8(arg);
                SvMAGIC(bstate->bs_sv)->mg_flags = arg;
                break;
            }
-         case INSN_MG_PV:              /* 66 */
+         case INSN_MG_PV:              /* 67 */
            {
                pvcontents arg;
                BGET_pvcontents(arg);
                BSET_mg_pv(SvMAGIC(bstate->bs_sv), arg);
                break;
            }
-         case INSN_XMG_STASH:          /* 67 */
+         case INSN_XMG_STASH:          /* 68 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&SvSTASH(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GV_FETCHPV:         /* 68 */
+         case INSN_GV_FETCHPV:         /* 69 */
            {
                strconst arg;
                BGET_strconst(arg);
                BSET_gv_fetchpv(bstate->bs_sv, arg);
                break;
            }
-         case INSN_GV_STASHPV:         /* 69 */
+         case INSN_GV_STASHPV:         /* 70 */
            {
                strconst arg;
                BGET_strconst(arg);
                BSET_gv_stashpv(bstate->bs_sv, arg);
                break;
            }
-         case INSN_GP_SV:              /* 70 */
+         case INSN_GP_SV:              /* 71 */
            {
                svindex arg;
                BGET_svindex(arg);
                GvSV(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_REFCNT:          /* 71 */
+         case INSN_GP_REFCNT:          /* 72 */
            {
                U32 arg;
                BGET_U32(arg);
                GvREFCNT(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_REFCNT_ADD:              /* 72 */
+         case INSN_GP_REFCNT_ADD:              /* 73 */
            {
                I32 arg;
                BGET_I32(arg);
                BSET_gp_refcnt_add(GvREFCNT(bstate->bs_sv), arg);
                break;
            }
-         case INSN_GP_AV:              /* 73 */
+         case INSN_GP_AV:              /* 74 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&GvAV(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_HV:              /* 74 */
+         case INSN_GP_HV:              /* 75 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&GvHV(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_CV:              /* 75 */
+         case INSN_GP_CV:              /* 76 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&GvCV(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_FILE:            /* 76 */
+         case INSN_GP_FILE:            /* 77 */
            {
                pvindex arg;
                BGET_pvindex(arg);
                GvFILE(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_IO:              /* 77 */
+         case INSN_GP_IO:              /* 78 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&GvIOp(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_FORM:            /* 78 */
+         case INSN_GP_FORM:            /* 79 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&GvFORM(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_CVGEN:           /* 79 */
+         case INSN_GP_CVGEN:           /* 80 */
            {
                U32 arg;
                BGET_U32(arg);
                GvCVGEN(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_LINE:            /* 80 */
+         case INSN_GP_LINE:            /* 81 */
            {
                line_t arg;
                BGET_U16(arg);
                GvLINE(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_GP_SHARE:           /* 81 */
+         case INSN_GP_SHARE:           /* 82 */
            {
                svindex arg;
                BGET_svindex(arg);
                BSET_gp_share(bstate->bs_sv, arg);
                break;
            }
-         case INSN_XGV_FLAGS:          /* 82 */
+         case INSN_XGV_FLAGS:          /* 83 */
            {
                U8 arg;
                BGET_U8(arg);
                GvFLAGS(bstate->bs_sv) = arg;
                break;
            }
-         case INSN_OP_NEXT:            /* 83 */
+         case INSN_OP_NEXT:            /* 84 */
            {
                opindex arg;
                BGET_opindex(arg);
                PL_op->op_next = arg;
                break;
            }
-         case INSN_OP_SIBLING:         /* 84 */
+         case INSN_OP_SIBLING:         /* 85 */
            {
                opindex arg;
                BGET_opindex(arg);
                PL_op->op_sibling = arg;
                break;
            }
-         case INSN_OP_PPADDR:          /* 85 */
+         case INSN_OP_PPADDR:          /* 86 */
            {
                strconst arg;
                BGET_strconst(arg);
                BSET_op_ppaddr(PL_op->op_ppaddr, arg);
                break;
            }
-         case INSN_OP_TARG:            /* 86 */
+         case INSN_OP_TARG:            /* 87 */
            {
                PADOFFSET arg;
                BGET_U32(arg);
                PL_op->op_targ = arg;
                break;
            }
-         case INSN_OP_TYPE:            /* 87 */
+         case INSN_OP_TYPE:            /* 88 */
            {
                OPCODE arg;
                BGET_U16(arg);
                BSET_op_type(PL_op, arg);
                break;
            }
-         case INSN_OP_SEQ:             /* 88 */
+         case INSN_OP_SEQ:             /* 89 */
            {
                U16 arg;
                BGET_U16(arg);
                PL_op->op_seq = arg;
                break;
            }
-         case INSN_OP_FLAGS:           /* 89 */
+         case INSN_OP_FLAGS:           /* 90 */
            {
                U8 arg;
                BGET_U8(arg);
                PL_op->op_flags = arg;
                break;
            }
-         case INSN_OP_PRIVATE:         /* 90 */
+         case INSN_OP_PRIVATE:         /* 91 */
            {
                U8 arg;
                BGET_U8(arg);
                PL_op->op_private = arg;
                break;
            }
-         case INSN_OP_FIRST:           /* 91 */
+         case INSN_OP_FIRST:           /* 92 */
            {
                opindex arg;
                BGET_opindex(arg);
                cUNOP->op_first = arg;
                break;
            }
-         case INSN_OP_LAST:            /* 92 */
+         case INSN_OP_LAST:            /* 93 */
            {
                opindex arg;
                BGET_opindex(arg);
                cBINOP->op_last = arg;
                break;
            }
-         case INSN_OP_OTHER:           /* 93 */
+         case INSN_OP_OTHER:           /* 94 */
            {
                opindex arg;
                BGET_opindex(arg);
                cLOGOP->op_other = arg;
                break;
            }
-         case INSN_OP_PMREPLROOT:              /* 94 */
+         case INSN_OP_PMREPLROOT:              /* 95 */
            {
                opindex arg;
                BGET_opindex(arg);
                cPMOP->op_pmreplroot = arg;
                break;
            }
-         case INSN_OP_PMREPLROOTGV:            /* 95 */
+         case INSN_OP_PMREPLROOTGV:            /* 96 */
            {
                svindex arg;
                BGET_svindex(arg);
                *(SV**)&cPMOP->op_pmreplroot = arg;
                break;
            }
-         case INSN_OP_PMREPLSTART:             /* 96 */
+         case INSN_OP_PMREPLSTART:             /* 97 */
            {
                opindex arg;
                BGET_opindex(arg);
                cPMOP->op_pmreplstart = arg;
                break;
            }
-         case INSN_OP_PMNEXT:          /* 97 */
+         case INSN_OP_PMNEXT:          /* 98 */
            {
                opindex arg;
                BGET_opindex(arg);
                *(OP**)&cPMOP->op_pmnext = arg;
                break;
            }
-         case INSN_PREGCOMP:           /* 98 */
+         case INSN_PREGCOMP:           /* 99 */
            {
                pvcontents arg;
                BGET_pvcontents(arg);
                BSET_pregcomp(PL_op, arg);
                break;
            }
-         case INSN_OP_PMFLAGS:         /* 99 */
+         case INSN_OP_PMFLAGS:         /* 100 */
            {
                U16 arg;
                BGET_U16(arg);
                cPMOP->op_pmflags = arg;
                break;
            }
-         case INSN_OP_PMPERMFLAGS:             /* 100 */
+         case INSN_OP_PMPERMFLAGS:             /* 101 */
            {
                U16 arg;
                BGET_U16(arg);
                cPMOP->op_pmpermflags = arg;
                break;
            }
-         case INSN_OP_SV:              /* 101 */
+         case INSN_OP_SV:              /* 102 */
            {
                svindex arg;
                BGET_svindex(arg);
                cSVOP->op_sv = arg;
                break;
            }
-         case INSN_OP_PADIX:           /* 102 */
+         case INSN_OP_PADIX:           /* 103 */
            {
                PADOFFSET arg;
                BGET_U32(arg);
                cPADOP->op_padix = arg;
                break;
            }
-         case INSN_OP_PV:              /* 103 */
+         case INSN_OP_PV:              /* 104 */
            {
                pvcontents arg;
                BGET_pvcontents(arg);
                cPVOP->op_pv = arg;
                break;
            }
-         case INSN_OP_PV_TR:           /* 104 */
+         case INSN_OP_PV_TR:           /* 105 */
            {
                op_tr_array arg;
                BGET_op_tr_array(arg);
                cPVOP->op_pv = arg;
                break;
            }
-         case INSN_OP_REDOOP:          /* 105 */
+         case INSN_OP_REDOOP:          /* 106 */
            {
                opindex arg;
                BGET_opindex(arg);
                cLOOP->op_redoop = arg;
                break;
            }
-         case INSN_OP_NEXTOP:          /* 106 */
+         case INSN_OP_NEXTOP:          /* 107 */
            {
                opindex arg;
                BGET_opindex(arg);
                cLOOP->op_nextop = arg;
                break;
            }
-         case INSN_OP_LASTOP:          /* 107 */
+         case INSN_OP_LASTOP:          /* 108 */
            {
                opindex arg;
                BGET_opindex(arg);
                cLOOP->op_lastop = arg;
                break;
            }
-         case INSN_COP_LABEL:          /* 108 */
+         case INSN_COP_LABEL:          /* 109 */
            {
                pvindex arg;
                BGET_pvindex(arg);
                cCOP->cop_label = arg;
                break;
            }
-         case INSN_COP_STASHPV:                /* 109 */
+         case INSN_COP_STASHPV:                /* 110 */
            {
                pvindex arg;
                BGET_pvindex(arg);
                BSET_cop_stashpv(cCOP, arg);
                break;
            }
-         case INSN_COP_FILE:           /* 110 */
+         case INSN_COP_FILE:           /* 111 */
            {
                pvindex arg;
                BGET_pvindex(arg);
                BSET_cop_file(cCOP, arg);
                break;
            }
-         case INSN_COP_SEQ:            /* 111 */
+         case INSN_COP_SEQ:            /* 112 */
            {
                U32 arg;
                BGET_U32(arg);
                cCOP->cop_seq = arg;
                break;
            }
-         case INSN_COP_ARYBASE:                /* 112 */
+         case INSN_COP_ARYBASE:                /* 113 */
            {
                I32 arg;
                BGET_I32(arg);
                cCOP->cop_arybase = arg;
                break;
            }
-         case INSN_COP_LINE:           /* 113 */
+         case INSN_COP_LINE:           /* 114 */
            {
                line_t arg;
                BGET_U16(arg);
                BSET_cop_line(cCOP, arg);
                break;
            }
-         case INSN_COP_WARNINGS:               /* 114 */
+         case INSN_COP_WARNINGS:               /* 115 */
            {
                svindex arg;
                BGET_svindex(arg);
                cCOP->cop_warnings = arg;
                break;
            }
-         case INSN_MAIN_START:         /* 115 */
+         case INSN_MAIN_START:         /* 116 */
            {
                opindex arg;
                BGET_opindex(arg);
                PL_main_start = arg;
                break;
            }
-         case INSN_MAIN_ROOT:          /* 116 */
+         case INSN_MAIN_ROOT:          /* 117 */
            {
                opindex arg;
                BGET_opindex(arg);
                PL_main_root = arg;
                break;
            }
-         case INSN_CURPAD:             /* 117 */
+         case INSN_CURPAD:             /* 118 */
            {
                svindex arg;
                BGET_svindex(arg);
                BSET_curpad(PL_curpad, arg);
                break;
            }
-         case INSN_PUSH_BEGIN:         /* 118 */
+         case INSN_PUSH_BEGIN:         /* 119 */
            {
                svindex arg;
                BGET_svindex(arg);
                BSET_push_begin(PL_beginav, arg);
                break;
            }
-         case INSN_PUSH_INIT:          /* 119 */
+         case INSN_PUSH_INIT:          /* 120 */
            {
                svindex arg;
                BGET_svindex(arg);
                BSET_push_init(PL_initav, arg);
                break;
            }
-         case INSN_PUSH_END:           /* 120 */
+         case INSN_PUSH_END:           /* 121 */
            {
                svindex arg;
                BGET_svindex(arg);
index 205c88b..7cdfe99 100644 (file)
@@ -81,75 +81,76 @@ enum {
     INSN_XCV_DEPTH,                    /* 50 */
     INSN_XCV_PADLIST,                  /* 51 */
     INSN_XCV_OUTSIDE,                  /* 52 */
-    INSN_XCV_FLAGS,                    /* 53 */
-    INSN_AV_EXTEND,                    /* 54 */
-    INSN_AV_PUSH,                      /* 55 */
-    INSN_XAV_FILL,                     /* 56 */
-    INSN_XAV_MAX,                      /* 57 */
-    INSN_XAV_FLAGS,                    /* 58 */
-    INSN_XHV_RITER,                    /* 59 */
-    INSN_XHV_NAME,                     /* 60 */
-    INSN_HV_STORE,                     /* 61 */
-    INSN_SV_MAGIC,                     /* 62 */
-    INSN_MG_OBJ,                       /* 63 */
-    INSN_MG_PRIVATE,                   /* 64 */
-    INSN_MG_FLAGS,                     /* 65 */
-    INSN_MG_PV,                        /* 66 */
-    INSN_XMG_STASH,                    /* 67 */
-    INSN_GV_FETCHPV,                   /* 68 */
-    INSN_GV_STASHPV,                   /* 69 */
-    INSN_GP_SV,                        /* 70 */
-    INSN_GP_REFCNT,                    /* 71 */
-    INSN_GP_REFCNT_ADD,                        /* 72 */
-    INSN_GP_AV,                        /* 73 */
-    INSN_GP_HV,                        /* 74 */
-    INSN_GP_CV,                        /* 75 */
-    INSN_GP_FILE,                      /* 76 */
-    INSN_GP_IO,                        /* 77 */
-    INSN_GP_FORM,                      /* 78 */
-    INSN_GP_CVGEN,                     /* 79 */
-    INSN_GP_LINE,                      /* 80 */
-    INSN_GP_SHARE,                     /* 81 */
-    INSN_XGV_FLAGS,                    /* 82 */
-    INSN_OP_NEXT,                      /* 83 */
-    INSN_OP_SIBLING,                   /* 84 */
-    INSN_OP_PPADDR,                    /* 85 */
-    INSN_OP_TARG,                      /* 86 */
-    INSN_OP_TYPE,                      /* 87 */
-    INSN_OP_SEQ,                       /* 88 */
-    INSN_OP_FLAGS,                     /* 89 */
-    INSN_OP_PRIVATE,                   /* 90 */
-    INSN_OP_FIRST,                     /* 91 */
-    INSN_OP_LAST,                      /* 92 */
-    INSN_OP_OTHER,                     /* 93 */
-    INSN_OP_PMREPLROOT,                        /* 94 */
-    INSN_OP_PMREPLROOTGV,                      /* 95 */
-    INSN_OP_PMREPLSTART,                       /* 96 */
-    INSN_OP_PMNEXT,                    /* 97 */
-    INSN_PREGCOMP,                     /* 98 */
-    INSN_OP_PMFLAGS,                   /* 99 */
-    INSN_OP_PMPERMFLAGS,                       /* 100 */
-    INSN_OP_SV,                        /* 101 */
-    INSN_OP_PADIX,                     /* 102 */
-    INSN_OP_PV,                        /* 103 */
-    INSN_OP_PV_TR,                     /* 104 */
-    INSN_OP_REDOOP,                    /* 105 */
-    INSN_OP_NEXTOP,                    /* 106 */
-    INSN_OP_LASTOP,                    /* 107 */
-    INSN_COP_LABEL,                    /* 108 */
-    INSN_COP_STASHPV,                  /* 109 */
-    INSN_COP_FILE,                     /* 110 */
-    INSN_COP_SEQ,                      /* 111 */
-    INSN_COP_ARYBASE,                  /* 112 */
-    INSN_COP_LINE,                     /* 113 */
-    INSN_COP_WARNINGS,                 /* 114 */
-    INSN_MAIN_START,                   /* 115 */
-    INSN_MAIN_ROOT,                    /* 116 */
-    INSN_CURPAD,                       /* 117 */
-    INSN_PUSH_BEGIN,                   /* 118 */
-    INSN_PUSH_INIT,                    /* 119 */
-    INSN_PUSH_END,                     /* 120 */
-    MAX_INSN = 120
+    INSN_XCV_OUTSIDE_SEQ,                      /* 53 */
+    INSN_XCV_FLAGS,                    /* 54 */
+    INSN_AV_EXTEND,                    /* 55 */
+    INSN_AV_PUSH,                      /* 56 */
+    INSN_XAV_FILL,                     /* 57 */
+    INSN_XAV_MAX,                      /* 58 */
+    INSN_XAV_FLAGS,                    /* 59 */
+    INSN_XHV_RITER,                    /* 60 */
+    INSN_XHV_NAME,                     /* 61 */
+    INSN_HV_STORE,                     /* 62 */
+    INSN_SV_MAGIC,                     /* 63 */
+    INSN_MG_OBJ,                       /* 64 */
+    INSN_MG_PRIVATE,                   /* 65 */
+    INSN_MG_FLAGS,                     /* 66 */
+    INSN_MG_PV,                        /* 67 */
+    INSN_XMG_STASH,                    /* 68 */
+    INSN_GV_FETCHPV,                   /* 69 */
+    INSN_GV_STASHPV,                   /* 70 */
+    INSN_GP_SV,                        /* 71 */
+    INSN_GP_REFCNT,                    /* 72 */
+    INSN_GP_REFCNT_ADD,                        /* 73 */
+    INSN_GP_AV,                        /* 74 */
+    INSN_GP_HV,                        /* 75 */
+    INSN_GP_CV,                        /* 76 */
+    INSN_GP_FILE,                      /* 77 */
+    INSN_GP_IO,                        /* 78 */
+    INSN_GP_FORM,                      /* 79 */
+    INSN_GP_CVGEN,                     /* 80 */
+    INSN_GP_LINE,                      /* 81 */
+    INSN_GP_SHARE,                     /* 82 */
+    INSN_XGV_FLAGS,                    /* 83 */
+    INSN_OP_NEXT,                      /* 84 */
+    INSN_OP_SIBLING,                   /* 85 */
+    INSN_OP_PPADDR,                    /* 86 */
+    INSN_OP_TARG,                      /* 87 */
+    INSN_OP_TYPE,                      /* 88 */
+    INSN_OP_SEQ,                       /* 89 */
+    INSN_OP_FLAGS,                     /* 90 */
+    INSN_OP_PRIVATE,                   /* 91 */
+    INSN_OP_FIRST,                     /* 92 */
+    INSN_OP_LAST,                      /* 93 */
+    INSN_OP_OTHER,                     /* 94 */
+    INSN_OP_PMREPLROOT,                        /* 95 */
+    INSN_OP_PMREPLROOTGV,                      /* 96 */
+    INSN_OP_PMREPLSTART,                       /* 97 */
+    INSN_OP_PMNEXT,                    /* 98 */
+    INSN_PREGCOMP,                     /* 99 */
+    INSN_OP_PMFLAGS,                   /* 100 */
+    INSN_OP_PMPERMFLAGS,                       /* 101 */
+    INSN_OP_SV,                        /* 102 */
+    INSN_OP_PADIX,                     /* 103 */
+    INSN_OP_PV,                        /* 104 */
+    INSN_OP_PV_TR,                     /* 105 */
+    INSN_OP_REDOOP,                    /* 106 */
+    INSN_OP_NEXTOP,                    /* 107 */
+    INSN_OP_LASTOP,                    /* 108 */
+    INSN_COP_LABEL,                    /* 109 */
+    INSN_COP_STASHPV,                  /* 110 */
+    INSN_COP_FILE,                     /* 111 */
+    INSN_COP_SEQ,                      /* 112 */
+    INSN_COP_ARYBASE,                  /* 113 */
+    INSN_COP_LINE,                     /* 114 */
+    INSN_COP_WARNINGS,                 /* 115 */
+    INSN_MAIN_START,                   /* 116 */
+    INSN_MAIN_ROOT,                    /* 117 */
+    INSN_CURPAD,                       /* 118 */
+    INSN_PUSH_BEGIN,                   /* 119 */
+    INSN_PUSH_INIT,                    /* 120 */
+    INSN_PUSH_END,                     /* 121 */
+    MAX_INSN = 121
 };
 
 enum {
diff --git a/op.c b/op.c
index 54de5de..2c6b675 100644 (file)
--- a/op.c
+++ b/op.c
@@ -1796,7 +1796,7 @@ Perl_newPROG(pTHX_ OP *o)
        CALL_PEEP(PL_eval_start);
     }
     else {
-       if (!o)
+       if (o->op_type == OP_STUB)
            return;
        PL_main_root = scope(sawparens(scalarvoid(o)));
        PL_curcop = &PL_compiling;