av = (AV*)NEWSV(8,0);
sv_upgrade((SV *) av,SVt_PVAV);
- AvFLAGS(av) = AVf_REAL;
+ AvREAL_only(av);
if (size) { /* `defined' was returning undef for size==0 anyway. */
register SV** ary;
register I32 i;
New(4,ary,size+1,SV*);
AvALLOC(av) = ary;
Copy(strp,ary,size,SV*);
- AvFLAGS(av) = AVf_REIFY;
+ AvREIFY_only(av);
SvPV_set(av, (char*)ary);
AvFILLp(av) = size - 1;
AvMAX(av) = size - 1;
SV** xav_alloc; /* pointer to beginning of C array of SVs */
SV* xav_arylen;
- U8 xav_flags;
};
* manipulations external to perl should not care about any of this.
* GSAR 1999-09-10
*/
-#define AVf_REAL 1 /* free old entries */
-#define AVf_REIFY 2 /* can become real */
-
-/* XXX this is not used anywhere */
-#define AVf_REUSED 4 /* got undeffed--don't turn old memory into SVs now */
/*
=head1 Handy Values
#define AvMAX(av) ((XPVAV*) SvANY(av))->xav_max
#define AvFILLp(av) ((XPVAV*) SvANY(av))->xav_fill
#define AvARYLEN(av) ((XPVAV*) SvANY(av))->xav_arylen
-#define AvFLAGS(av) ((XPVAV*) SvANY(av))->xav_flags
-#define AvREAL(av) (AvFLAGS(av) & AVf_REAL)
-#define AvREAL_on(av) (AvFLAGS(av) |= AVf_REAL)
-#define AvREAL_off(av) (AvFLAGS(av) &= ~AVf_REAL)
-#define AvREIFY(av) (AvFLAGS(av) & AVf_REIFY)
-#define AvREIFY_on(av) (AvFLAGS(av) |= AVf_REIFY)
-#define AvREIFY_off(av) (AvFLAGS(av) &= ~AVf_REIFY)
-#define AvREUSED(av) (AvFLAGS(av) & AVf_REUSED)
-#define AvREUSED_on(av) (AvFLAGS(av) |= AVf_REUSED)
-#define AvREUSED_off(av) (AvFLAGS(av) &= ~AVf_REUSED)
+#define AvREAL(av) (SvFLAGS(av) & SVpav_REAL)
+#define AvREAL_on(av) (SvFLAGS(av) |= SVpav_REAL)
+#define AvREAL_off(av) (SvFLAGS(av) &= ~SVpav_REAL)
+#define AvREAL_only(av) (AvREIFY_off(av), SvFLAGS(av) |= SVpav_REAL)
+#define AvREIFY(av) (SvFLAGS(av) & SVpav_REIFY)
+#define AvREIFY_on(av) (SvFLAGS(av) |= SVpav_REIFY)
+#define AvREIFY_off(av) (SvFLAGS(av) &= ~SVpav_REIFY)
+#define AvREIFY_only(av) (AvREAL_off(av), SvFLAGS(av) |= SVpav_REIFY)
-#define AvREALISH(av) (AvFLAGS(av) & (AVf_REAL|AVf_REIFY))
+#define AvREALISH(av) (SvFLAGS(av) & (SVpav_REAL|SVpav_REIFY))
#define AvFILL(av) ((SvRMAGICAL((SV *) (av))) \
? mg_size((SV *) av) : AvFILLp(av))
av_push bstate->bs_sv svindex x
xav_fill AvFILLp(bstate->bs_sv) SSize_t
xav_max AvMAX(bstate->bs_sv) SSize_t
-xav_flags AvFLAGS(bstate->bs_sv) U8
xhv_riter HvRITER(bstate->bs_sv) I32
xhv_name HvNAME(bstate->bs_sv) pvindex
xhv_pmroot *(OP**)&HvPMROOT(bstate->bs_sv) opindex
SvREFCNT_dec(cx->blk_sub.argarray); \
cx->blk_sub.argarray = newAV(); \
av_extend(cx->blk_sub.argarray, fill); \
- AvFLAGS(cx->blk_sub.argarray) = AVf_REIFY; \
+ AvREIFY_only(cx->blk_sub.argarray); \
CX_CURPAD_SV(cx->blk_sub, 0) = (SV*)cx->blk_sub.argarray; \
} \
else { \
if (flags & SVpad_TYPED)
sv_catpv(d, "TYPED,");
break;
+ case SVt_PVAV:
+ break;
}
/* SVphv_SHAREKEYS is also 0x20000000 */
if ((type != SVt_PVHV) && SvUTF8(sv))
Perl_dump_indent(aTHX_ level, file, " FILL = %"IVdf"\n", (IV)AvFILLp(sv));
Perl_dump_indent(aTHX_ level, file, " MAX = %"IVdf"\n", (IV)AvMAX(sv));
Perl_dump_indent(aTHX_ level, file, " ARYLEN = 0x%"UVxf"\n", PTR2UV(AvARYLEN(sv)));
- flags = AvFLAGS(sv);
sv_setpvn(d, "", 0);
- if (flags & AVf_REAL) sv_catpv(d, ",REAL");
- if (flags & AVf_REIFY) sv_catpv(d, ",REIFY");
- if (flags & AVf_REUSED) sv_catpv(d, ",REUSED");
+ if (AvREAL(sv)) sv_catpv(d, ",REAL");
+ if (AvREIFY(sv)) sv_catpv(d, ",REIFY");
Perl_dump_indent(aTHX_ level, file, " FLAGS = (%s)\n", SvCUR(d) ? SvPVX(d) + 1 : "");
if (nest < maxnest && av_len((AV*)sv) >= 0) {
int count;
Like C<ARRAY>, but takes an index as an argument to get only one element,
rather than a list of all of them.
-=item AvFLAGS
-
=back
=head2 B::CV Methods
else
XPUSHs(make_sv_object(aTHX_ sv_newmortal(), NULL));
-
-MODULE = B PACKAGE = B::AV
-
-U8
-AvFLAGS(av)
- B::AV av
-
MODULE = B PACKAGE = B::FM PREFIX = Fm
IV
$insn_data{av_push} = [62, \&PUT_svindex, "GET_svindex"];
$insn_data{xav_fill} = [63, \&PUT_PADOFFSET, "GET_PADOFFSET"];
$insn_data{xav_max} = [64, \&PUT_PADOFFSET, "GET_PADOFFSET"];
-$insn_data{xav_flags} = [65, \&PUT_U8, "GET_U8"];
-$insn_data{xhv_riter} = [66, \&PUT_I32, "GET_I32"];
-$insn_data{xhv_name} = [67, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{xhv_pmroot} = [68, \&PUT_opindex, "GET_opindex"];
-$insn_data{hv_store} = [69, \&PUT_svindex, "GET_svindex"];
-$insn_data{sv_magic} = [70, \&PUT_U8, "GET_U8"];
-$insn_data{mg_obj} = [71, \&PUT_svindex, "GET_svindex"];
-$insn_data{mg_private} = [72, \&PUT_U16, "GET_U16"];
-$insn_data{mg_flags} = [73, \&PUT_U8, "GET_U8"];
-$insn_data{mg_name} = [74, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{mg_namex} = [75, \&PUT_svindex, "GET_svindex"];
-$insn_data{xmg_stash} = [76, \&PUT_svindex, "GET_svindex"];
-$insn_data{gv_fetchpv} = [77, \&PUT_strconst, "GET_strconst"];
-$insn_data{gv_fetchpvx} = [78, \&PUT_strconst, "GET_strconst"];
-$insn_data{gv_stashpv} = [79, \&PUT_strconst, "GET_strconst"];
-$insn_data{gv_stashpvx} = [80, \&PUT_strconst, "GET_strconst"];
-$insn_data{gp_sv} = [81, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_refcnt} = [82, \&PUT_U32, "GET_U32"];
-$insn_data{gp_refcnt_add} = [83, \&PUT_I32, "GET_I32"];
-$insn_data{gp_av} = [84, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_hv} = [85, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_cv} = [86, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_file} = [87, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{gp_io} = [88, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_form} = [89, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_cvgen} = [90, \&PUT_U32, "GET_U32"];
-$insn_data{gp_line} = [91, \&PUT_U32, "GET_U32"];
-$insn_data{gp_share} = [92, \&PUT_svindex, "GET_svindex"];
-$insn_data{xgv_flags} = [93, \&PUT_U8, "GET_U8"];
-$insn_data{op_next} = [94, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_sibling} = [95, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_ppaddr} = [96, \&PUT_strconst, "GET_strconst"];
-$insn_data{op_targ} = [97, \&PUT_PADOFFSET, "GET_PADOFFSET"];
-$insn_data{op_type} = [98, \&PUT_U16, "GET_U16"];
-$insn_data{op_opt} = [99, \&PUT_U8, "GET_U8"];
-$insn_data{op_static} = [100, \&PUT_U8, "GET_U8"];
-$insn_data{op_flags} = [101, \&PUT_U8, "GET_U8"];
-$insn_data{op_private} = [102, \&PUT_U8, "GET_U8"];
-$insn_data{op_first} = [103, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_last} = [104, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_other} = [105, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmreplroot} = [106, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmreplstart} = [107, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmnext} = [108, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_pmstashpv} = [109, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{op_pmreplrootpo} = [110, \&PUT_PADOFFSET, "GET_PADOFFSET"];
-$insn_data{op_pmstash} = [111, \&PUT_svindex, "GET_svindex"];
-$insn_data{op_pmreplrootgv} = [112, \&PUT_svindex, "GET_svindex"];
-$insn_data{pregcomp} = [113, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{op_pmflags} = [114, \&PUT_U16, "GET_U16"];
-$insn_data{op_pmpermflags} = [115, \&PUT_U16, "GET_U16"];
-$insn_data{op_pmdynflags} = [116, \&PUT_U8, "GET_U8"];
-$insn_data{op_sv} = [117, \&PUT_svindex, "GET_svindex"];
-$insn_data{op_padix} = [118, \&PUT_PADOFFSET, "GET_PADOFFSET"];
-$insn_data{op_pv} = [119, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{op_pv_tr} = [120, \&PUT_op_tr_array, "GET_op_tr_array"];
-$insn_data{op_redoop} = [121, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_nextop} = [122, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_lastop} = [123, \&PUT_opindex, "GET_opindex"];
-$insn_data{cop_label} = [124, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{cop_stashpv} = [125, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{cop_file} = [126, \&PUT_pvindex, "GET_pvindex"];
-$insn_data{cop_stash} = [127, \&PUT_svindex, "GET_svindex"];
-$insn_data{cop_filegv} = [128, \&PUT_svindex, "GET_svindex"];
-$insn_data{cop_seq} = [129, \&PUT_U32, "GET_U32"];
-$insn_data{cop_arybase} = [130, \&PUT_I32, "GET_I32"];
-$insn_data{cop_line} = [131, \&PUT_U32, "GET_U32"];
-$insn_data{cop_io} = [132, \&PUT_svindex, "GET_svindex"];
-$insn_data{cop_warnings} = [133, \&PUT_svindex, "GET_svindex"];
-$insn_data{main_start} = [134, \&PUT_opindex, "GET_opindex"];
-$insn_data{main_root} = [135, \&PUT_opindex, "GET_opindex"];
-$insn_data{main_cv} = [136, \&PUT_svindex, "GET_svindex"];
-$insn_data{curpad} = [137, \&PUT_svindex, "GET_svindex"];
-$insn_data{push_begin} = [138, \&PUT_svindex, "GET_svindex"];
-$insn_data{push_init} = [139, \&PUT_svindex, "GET_svindex"];
-$insn_data{push_end} = [140, \&PUT_svindex, "GET_svindex"];
-$insn_data{curstash} = [141, \&PUT_svindex, "GET_svindex"];
-$insn_data{defstash} = [142, \&PUT_svindex, "GET_svindex"];
-$insn_data{data} = [143, \&PUT_U8, "GET_U8"];
-$insn_data{incav} = [144, \&PUT_svindex, "GET_svindex"];
-$insn_data{load_glob} = [145, \&PUT_svindex, "GET_svindex"];
-$insn_data{regex_padav} = [146, \&PUT_svindex, "GET_svindex"];
-$insn_data{dowarn} = [147, \&PUT_U8, "GET_U8"];
-$insn_data{comppad_name} = [148, \&PUT_svindex, "GET_svindex"];
-$insn_data{xgv_stash} = [149, \&PUT_svindex, "GET_svindex"];
-$insn_data{signal} = [150, \&PUT_strconst, "GET_strconst"];
-$insn_data{formfeed} = [151, \&PUT_svindex, "GET_svindex"];
+$insn_data{xhv_riter} = [65, \&PUT_I32, "GET_I32"];
+$insn_data{xhv_name} = [66, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{xhv_pmroot} = [67, \&PUT_opindex, "GET_opindex"];
+$insn_data{hv_store} = [68, \&PUT_svindex, "GET_svindex"];
+$insn_data{sv_magic} = [69, \&PUT_U8, "GET_U8"];
+$insn_data{mg_obj} = [70, \&PUT_svindex, "GET_svindex"];
+$insn_data{mg_private} = [71, \&PUT_U16, "GET_U16"];
+$insn_data{mg_flags} = [72, \&PUT_U8, "GET_U8"];
+$insn_data{mg_name} = [73, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{mg_namex} = [74, \&PUT_svindex, "GET_svindex"];
+$insn_data{xmg_stash} = [75, \&PUT_svindex, "GET_svindex"];
+$insn_data{gv_fetchpv} = [76, \&PUT_strconst, "GET_strconst"];
+$insn_data{gv_fetchpvx} = [77, \&PUT_strconst, "GET_strconst"];
+$insn_data{gv_stashpv} = [78, \&PUT_strconst, "GET_strconst"];
+$insn_data{gv_stashpvx} = [79, \&PUT_strconst, "GET_strconst"];
+$insn_data{gp_sv} = [80, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_refcnt} = [81, \&PUT_U32, "GET_U32"];
+$insn_data{gp_refcnt_add} = [82, \&PUT_I32, "GET_I32"];
+$insn_data{gp_av} = [83, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_hv} = [84, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_cv} = [85, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_file} = [86, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{gp_io} = [87, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_form} = [88, \&PUT_svindex, "GET_svindex"];
+$insn_data{gp_cvgen} = [89, \&PUT_U32, "GET_U32"];
+$insn_data{gp_line} = [90, \&PUT_U32, "GET_U32"];
+$insn_data{gp_share} = [91, \&PUT_svindex, "GET_svindex"];
+$insn_data{xgv_flags} = [92, \&PUT_U8, "GET_U8"];
+$insn_data{op_next} = [93, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_sibling} = [94, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_ppaddr} = [95, \&PUT_strconst, "GET_strconst"];
+$insn_data{op_targ} = [96, \&PUT_PADOFFSET, "GET_PADOFFSET"];
+$insn_data{op_type} = [97, \&PUT_U16, "GET_U16"];
+$insn_data{op_opt} = [98, \&PUT_U8, "GET_U8"];
+$insn_data{op_static} = [99, \&PUT_U8, "GET_U8"];
+$insn_data{op_flags} = [100, \&PUT_U8, "GET_U8"];
+$insn_data{op_private} = [101, \&PUT_U8, "GET_U8"];
+$insn_data{op_first} = [102, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_last} = [103, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_other} = [104, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmreplroot} = [105, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmreplstart} = [106, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmnext} = [107, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_pmstashpv} = [108, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{op_pmreplrootpo} = [109, \&PUT_PADOFFSET, "GET_PADOFFSET"];
+$insn_data{op_pmstash} = [110, \&PUT_svindex, "GET_svindex"];
+$insn_data{op_pmreplrootgv} = [111, \&PUT_svindex, "GET_svindex"];
+$insn_data{pregcomp} = [112, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{op_pmflags} = [113, \&PUT_U16, "GET_U16"];
+$insn_data{op_pmpermflags} = [114, \&PUT_U16, "GET_U16"];
+$insn_data{op_pmdynflags} = [115, \&PUT_U8, "GET_U8"];
+$insn_data{op_sv} = [116, \&PUT_svindex, "GET_svindex"];
+$insn_data{op_padix} = [117, \&PUT_PADOFFSET, "GET_PADOFFSET"];
+$insn_data{op_pv} = [118, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{op_pv_tr} = [119, \&PUT_op_tr_array, "GET_op_tr_array"];
+$insn_data{op_redoop} = [120, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_nextop} = [121, \&PUT_opindex, "GET_opindex"];
+$insn_data{op_lastop} = [122, \&PUT_opindex, "GET_opindex"];
+$insn_data{cop_label} = [123, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{cop_stashpv} = [124, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{cop_file} = [125, \&PUT_pvindex, "GET_pvindex"];
+$insn_data{cop_stash} = [126, \&PUT_svindex, "GET_svindex"];
+$insn_data{cop_filegv} = [127, \&PUT_svindex, "GET_svindex"];
+$insn_data{cop_seq} = [128, \&PUT_U32, "GET_U32"];
+$insn_data{cop_arybase} = [129, \&PUT_I32, "GET_I32"];
+$insn_data{cop_line} = [130, \&PUT_U32, "GET_U32"];
+$insn_data{cop_io} = [131, \&PUT_svindex, "GET_svindex"];
+$insn_data{cop_warnings} = [132, \&PUT_svindex, "GET_svindex"];
+$insn_data{main_start} = [133, \&PUT_opindex, "GET_opindex"];
+$insn_data{main_root} = [134, \&PUT_opindex, "GET_opindex"];
+$insn_data{main_cv} = [135, \&PUT_svindex, "GET_svindex"];
+$insn_data{curpad} = [136, \&PUT_svindex, "GET_svindex"];
+$insn_data{push_begin} = [137, \&PUT_svindex, "GET_svindex"];
+$insn_data{push_init} = [138, \&PUT_svindex, "GET_svindex"];
+$insn_data{push_end} = [139, \&PUT_svindex, "GET_svindex"];
+$insn_data{curstash} = [140, \&PUT_svindex, "GET_svindex"];
+$insn_data{defstash} = [141, \&PUT_svindex, "GET_svindex"];
+$insn_data{data} = [142, \&PUT_U8, "GET_U8"];
+$insn_data{incav} = [143, \&PUT_svindex, "GET_svindex"];
+$insn_data{load_glob} = [144, \&PUT_svindex, "GET_svindex"];
+$insn_data{regex_padav} = [145, \&PUT_svindex, "GET_svindex"];
+$insn_data{dowarn} = [146, \&PUT_U8, "GET_U8"];
+$insn_data{comppad_name} = [147, \&PUT_svindex, "GET_svindex"];
+$insn_data{xgv_stash} = [148, \&PUT_svindex, "GET_svindex"];
+$insn_data{signal} = [149, \&PUT_strconst, "GET_strconst"];
+$insn_data{formfeed} = [150, \&PUT_svindex, "GET_svindex"];
my ($insn_name, $insn_data);
while (($insn_name, $insn_data) = each %insn_data) {
asm "av_extend", $av->MAX if $av->MAX >= 0;
asm "av_pushx", $_ for @array;
asm "sv_refcnt", $av->REFCNT;
- asm "xav_flags", $av->AvFLAGS;
asm "xmg_stash", $stashix;
}
use B qw(minus_c sv_undef walkoptree walksymtable main_root main_start peekop
class cstring cchar svref_2object compile_stats comppadlist hash
threadsv_names main_cv init_av end_av regex_padav opnumber amagic_generation
- AVf_REAL HEf_SVKEY SVf_POK SVf_ROK CVf_CONST);
+ HEf_SVKEY SVf_POK SVf_ROK CVf_CONST);
use B::Asmdata qw(@specialsv_name);
use FileHandle;
my ($av) = @_;
my $sym = objsym($av);
return $sym if defined $sym;
- my $avflags = $av->AvFLAGS;
- $xpvavsect->add(sprintf("0, -1, -1, 0, 0.0, 0, Nullhv, 0, 0, 0x%x",
- $avflags));
+ $xpvavsect->add(sprintf("0, -1, -1, 0, 0.0, 0, Nullhv, 0, 0"));
$svsect->add(sprintf("&xpvav_list[%d], %lu, 0x%x",
$xpvavsect->index, $av->REFCNT , $av->FLAGS));
my $sv_list_index = $svsect->index;
my $fill = $av->FILL;
$av->save_magic;
- warn sprintf("saving AV 0x%x FILL=$fill AvFLAGS=0x%x", $$av, $avflags)
+ warn sprintf("saving AV 0x%x FILL=$fill", $$av)
if $debug_av;
# XXX AVf_REAL is wrong test: need to save comppadlist but not stack
#if ($fill > -1 && ($avflags & AVf_REAL)) {
$av->B::SV::debug;
my(@array) = $av->ARRAY;
print "\tARRAY\t\t(", join(", ", map("0x" . $$_, @array)), ")\n";
- printf <<'EOT', scalar(@array), $av->MAX, $av->OFF, $av->AvFLAGS;
+ printf <<'EOT', scalar(@array), $av->MAX, $av->OFF;
FILL %d
MAX %d
OFF %d
- AvFLAGS %d
EOT
}
END
foreach my $const (qw(
- AVf_REAL
CVf_ANON
CVf_ASSERTION
CVf_CLONE
AvMAX(bstate->bs_sv) = arg;
break;
}
- case INSN_XAV_FLAGS: /* 65 */
- {
- U8 arg;
- BGET_U8(arg);
- AvFLAGS(bstate->bs_sv) = arg;
- break;
- }
- case INSN_XHV_RITER: /* 66 */
+ case INSN_XHV_RITER: /* 65 */
{
I32 arg;
BGET_I32(arg);
HvRITER(bstate->bs_sv) = arg;
break;
}
- case INSN_XHV_NAME: /* 67 */
+ case INSN_XHV_NAME: /* 66 */
{
pvindex arg;
BGET_pvindex(arg);
HvNAME(bstate->bs_sv) = arg;
break;
}
- case INSN_XHV_PMROOT: /* 68 */
+ case INSN_XHV_PMROOT: /* 67 */
{
opindex arg;
BGET_opindex(arg);
*(OP**)&HvPMROOT(bstate->bs_sv) = arg;
break;
}
- case INSN_HV_STORE: /* 69 */
+ case INSN_HV_STORE: /* 68 */
{
svindex arg;
BGET_svindex(arg);
BSET_hv_store(bstate->bs_sv, arg);
break;
}
- case INSN_SV_MAGIC: /* 70 */
+ case INSN_SV_MAGIC: /* 69 */
{
char arg;
BGET_U8(arg);
BSET_sv_magic(bstate->bs_sv, arg);
break;
}
- case INSN_MG_OBJ: /* 71 */
+ case INSN_MG_OBJ: /* 70 */
{
svindex arg;
BGET_svindex(arg);
SvMAGIC(bstate->bs_sv)->mg_obj = arg;
break;
}
- case INSN_MG_PRIVATE: /* 72 */
+ case INSN_MG_PRIVATE: /* 71 */
{
U16 arg;
BGET_U16(arg);
SvMAGIC(bstate->bs_sv)->mg_private = arg;
break;
}
- case INSN_MG_FLAGS: /* 73 */
+ case INSN_MG_FLAGS: /* 72 */
{
U8 arg;
BGET_U8(arg);
SvMAGIC(bstate->bs_sv)->mg_flags = arg;
break;
}
- case INSN_MG_NAME: /* 74 */
+ case INSN_MG_NAME: /* 73 */
{
pvcontents arg;
BGET_pvcontents(arg);
BSET_mg_name(SvMAGIC(bstate->bs_sv), arg);
break;
}
- case INSN_MG_NAMEX: /* 75 */
+ case INSN_MG_NAMEX: /* 74 */
{
svindex arg;
BGET_svindex(arg);
BSET_mg_namex(SvMAGIC(bstate->bs_sv), arg);
break;
}
- case INSN_XMG_STASH: /* 76 */
+ case INSN_XMG_STASH: /* 75 */
{
svindex arg;
BGET_svindex(arg);
BSET_xmg_stash(bstate->bs_sv, arg);
break;
}
- case INSN_GV_FETCHPV: /* 77 */
+ case INSN_GV_FETCHPV: /* 76 */
{
strconst arg;
BGET_strconst(arg);
BSET_gv_fetchpv(bstate->bs_sv, arg);
break;
}
- case INSN_GV_FETCHPVX: /* 78 */
+ case INSN_GV_FETCHPVX: /* 77 */
{
strconst arg;
BGET_strconst(arg);
BSET_gv_fetchpvx(bstate->bs_sv, arg);
break;
}
- case INSN_GV_STASHPV: /* 79 */
+ case INSN_GV_STASHPV: /* 78 */
{
strconst arg;
BGET_strconst(arg);
BSET_gv_stashpv(bstate->bs_sv, arg);
break;
}
- case INSN_GV_STASHPVX: /* 80 */
+ case INSN_GV_STASHPVX: /* 79 */
{
strconst arg;
BGET_strconst(arg);
BSET_gv_stashpvx(bstate->bs_sv, arg);
break;
}
- case INSN_GP_SV: /* 81 */
+ case INSN_GP_SV: /* 80 */
{
svindex arg;
BGET_svindex(arg);
GvSV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_REFCNT: /* 82 */
+ case INSN_GP_REFCNT: /* 81 */
{
U32 arg;
BGET_U32(arg);
GvREFCNT(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_REFCNT_ADD: /* 83 */
+ case INSN_GP_REFCNT_ADD: /* 82 */
{
I32 arg;
BGET_I32(arg);
BSET_gp_refcnt_add(GvREFCNT(bstate->bs_sv), arg);
break;
}
- case INSN_GP_AV: /* 84 */
+ case INSN_GP_AV: /* 83 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvAV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_HV: /* 85 */
+ case INSN_GP_HV: /* 84 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvHV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_CV: /* 86 */
+ case INSN_GP_CV: /* 85 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvCV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_FILE: /* 87 */
+ case INSN_GP_FILE: /* 86 */
{
pvindex arg;
BGET_pvindex(arg);
GvFILE(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_IO: /* 88 */
+ case INSN_GP_IO: /* 87 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvIOp(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_FORM: /* 89 */
+ case INSN_GP_FORM: /* 88 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvFORM(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_CVGEN: /* 90 */
+ case INSN_GP_CVGEN: /* 89 */
{
U32 arg;
BGET_U32(arg);
GvCVGEN(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_LINE: /* 91 */
+ case INSN_GP_LINE: /* 90 */
{
line_t arg;
BGET_U32(arg);
GvLINE(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_SHARE: /* 92 */
+ case INSN_GP_SHARE: /* 91 */
{
svindex arg;
BGET_svindex(arg);
BSET_gp_share(bstate->bs_sv, arg);
break;
}
- case INSN_XGV_FLAGS: /* 93 */
+ case INSN_XGV_FLAGS: /* 92 */
{
U8 arg;
BGET_U8(arg);
GvFLAGS(bstate->bs_sv) = arg;
break;
}
- case INSN_OP_NEXT: /* 94 */
+ case INSN_OP_NEXT: /* 93 */
{
opindex arg;
BGET_opindex(arg);
PL_op->op_next = arg;
break;
}
- case INSN_OP_SIBLING: /* 95 */
+ case INSN_OP_SIBLING: /* 94 */
{
opindex arg;
BGET_opindex(arg);
PL_op->op_sibling = arg;
break;
}
- case INSN_OP_PPADDR: /* 96 */
+ case INSN_OP_PPADDR: /* 95 */
{
strconst arg;
BGET_strconst(arg);
BSET_op_ppaddr(PL_op->op_ppaddr, arg);
break;
}
- case INSN_OP_TARG: /* 97 */
+ case INSN_OP_TARG: /* 96 */
{
PADOFFSET arg;
BGET_PADOFFSET(arg);
PL_op->op_targ = arg;
break;
}
- case INSN_OP_TYPE: /* 98 */
+ case INSN_OP_TYPE: /* 97 */
{
OPCODE arg;
BGET_U16(arg);
BSET_op_type(PL_op, arg);
break;
}
- case INSN_OP_OPT: /* 99 */
+ case INSN_OP_OPT: /* 98 */
{
U8 arg;
BGET_U8(arg);
PL_op->op_opt = arg;
break;
}
- case INSN_OP_STATIC: /* 100 */
+ case INSN_OP_STATIC: /* 99 */
{
U8 arg;
BGET_U8(arg);
PL_op->op_static = arg;
break;
}
- case INSN_OP_FLAGS: /* 101 */
+ case INSN_OP_FLAGS: /* 100 */
{
U8 arg;
BGET_U8(arg);
PL_op->op_flags = arg;
break;
}
- case INSN_OP_PRIVATE: /* 102 */
+ case INSN_OP_PRIVATE: /* 101 */
{
U8 arg;
BGET_U8(arg);
PL_op->op_private = arg;
break;
}
- case INSN_OP_FIRST: /* 103 */
+ case INSN_OP_FIRST: /* 102 */
{
opindex arg;
BGET_opindex(arg);
cUNOP->op_first = arg;
break;
}
- case INSN_OP_LAST: /* 104 */
+ case INSN_OP_LAST: /* 103 */
{
opindex arg;
BGET_opindex(arg);
cBINOP->op_last = arg;
break;
}
- case INSN_OP_OTHER: /* 105 */
+ case INSN_OP_OTHER: /* 104 */
{
opindex arg;
BGET_opindex(arg);
cLOGOP->op_other = arg;
break;
}
- case INSN_OP_PMREPLROOT: /* 106 */
+ case INSN_OP_PMREPLROOT: /* 105 */
{
opindex arg;
BGET_opindex(arg);
cPMOP->op_pmreplroot = arg;
break;
}
- case INSN_OP_PMREPLSTART: /* 107 */
+ case INSN_OP_PMREPLSTART: /* 106 */
{
opindex arg;
BGET_opindex(arg);
cPMOP->op_pmreplstart = arg;
break;
}
- case INSN_OP_PMNEXT: /* 108 */
+ case INSN_OP_PMNEXT: /* 107 */
{
opindex arg;
BGET_opindex(arg);
break;
}
#ifdef USE_ITHREADS
- case INSN_OP_PMSTASHPV: /* 109 */
+ case INSN_OP_PMSTASHPV: /* 108 */
{
pvindex arg;
BGET_pvindex(arg);
BSET_op_pmstashpv(cPMOP, arg);
break;
}
- case INSN_OP_PMREPLROOTPO: /* 110 */
+ case INSN_OP_PMREPLROOTPO: /* 109 */
{
PADOFFSET arg;
BGET_PADOFFSET(arg);
break;
}
#else
- case INSN_OP_PMSTASH: /* 111 */
+ case INSN_OP_PMSTASH: /* 110 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&cPMOP->op_pmstash = arg;
break;
}
- case INSN_OP_PMREPLROOTGV: /* 112 */
+ case INSN_OP_PMREPLROOTGV: /* 111 */
{
svindex arg;
BGET_svindex(arg);
break;
}
#endif
- case INSN_PREGCOMP: /* 113 */
+ case INSN_PREGCOMP: /* 112 */
{
pvcontents arg;
BGET_pvcontents(arg);
BSET_pregcomp(PL_op, arg);
break;
}
- case INSN_OP_PMFLAGS: /* 114 */
+ case INSN_OP_PMFLAGS: /* 113 */
{
U16 arg;
BGET_U16(arg);
cPMOP->op_pmflags = arg;
break;
}
- case INSN_OP_PMPERMFLAGS: /* 115 */
+ case INSN_OP_PMPERMFLAGS: /* 114 */
{
U16 arg;
BGET_U16(arg);
cPMOP->op_pmpermflags = arg;
break;
}
- case INSN_OP_PMDYNFLAGS: /* 116 */
+ case INSN_OP_PMDYNFLAGS: /* 115 */
{
U8 arg;
BGET_U8(arg);
cPMOP->op_pmdynflags = arg;
break;
}
- case INSN_OP_SV: /* 117 */
+ case INSN_OP_SV: /* 116 */
{
svindex arg;
BGET_svindex(arg);
cSVOP->op_sv = arg;
break;
}
- case INSN_OP_PADIX: /* 118 */
+ case INSN_OP_PADIX: /* 117 */
{
PADOFFSET arg;
BGET_PADOFFSET(arg);
cPADOP->op_padix = arg;
break;
}
- case INSN_OP_PV: /* 119 */
+ case INSN_OP_PV: /* 118 */
{
pvcontents arg;
BGET_pvcontents(arg);
cPVOP->op_pv = arg;
break;
}
- case INSN_OP_PV_TR: /* 120 */
+ case INSN_OP_PV_TR: /* 119 */
{
op_tr_array arg;
BGET_op_tr_array(arg);
cPVOP->op_pv = arg;
break;
}
- case INSN_OP_REDOOP: /* 121 */
+ case INSN_OP_REDOOP: /* 120 */
{
opindex arg;
BGET_opindex(arg);
cLOOP->op_redoop = arg;
break;
}
- case INSN_OP_NEXTOP: /* 122 */
+ case INSN_OP_NEXTOP: /* 121 */
{
opindex arg;
BGET_opindex(arg);
cLOOP->op_nextop = arg;
break;
}
- case INSN_OP_LASTOP: /* 123 */
+ case INSN_OP_LASTOP: /* 122 */
{
opindex arg;
BGET_opindex(arg);
cLOOP->op_lastop = arg;
break;
}
- case INSN_COP_LABEL: /* 124 */
+ case INSN_COP_LABEL: /* 123 */
{
pvindex arg;
BGET_pvindex(arg);
break;
}
#ifdef USE_ITHREADS
- case INSN_COP_STASHPV: /* 125 */
+ case INSN_COP_STASHPV: /* 124 */
{
pvindex arg;
BGET_pvindex(arg);
BSET_cop_stashpv(cCOP, arg);
break;
}
- case INSN_COP_FILE: /* 126 */
+ case INSN_COP_FILE: /* 125 */
{
pvindex arg;
BGET_pvindex(arg);
break;
}
#else
- case INSN_COP_STASH: /* 127 */
+ case INSN_COP_STASH: /* 126 */
{
svindex arg;
BGET_svindex(arg);
BSET_cop_stash(cCOP, arg);
break;
}
- case INSN_COP_FILEGV: /* 128 */
+ case INSN_COP_FILEGV: /* 127 */
{
svindex arg;
BGET_svindex(arg);
break;
}
#endif
- case INSN_COP_SEQ: /* 129 */
+ case INSN_COP_SEQ: /* 128 */
{
U32 arg;
BGET_U32(arg);
cCOP->cop_seq = arg;
break;
}
- case INSN_COP_ARYBASE: /* 130 */
+ case INSN_COP_ARYBASE: /* 129 */
{
I32 arg;
BGET_I32(arg);
cCOP->cop_arybase = arg;
break;
}
- case INSN_COP_LINE: /* 131 */
+ case INSN_COP_LINE: /* 130 */
{
line_t arg;
BGET_U32(arg);
cCOP->cop_line = arg;
break;
}
- case INSN_COP_IO: /* 132 */
+ case INSN_COP_IO: /* 131 */
{
svindex arg;
BGET_svindex(arg);
cCOP->cop_io = arg;
break;
}
- case INSN_COP_WARNINGS: /* 133 */
+ case INSN_COP_WARNINGS: /* 132 */
{
svindex arg;
BGET_svindex(arg);
cCOP->cop_warnings = arg;
break;
}
- case INSN_MAIN_START: /* 134 */
+ case INSN_MAIN_START: /* 133 */
{
opindex arg;
BGET_opindex(arg);
PL_main_start = arg;
break;
}
- case INSN_MAIN_ROOT: /* 135 */
+ case INSN_MAIN_ROOT: /* 134 */
{
opindex arg;
BGET_opindex(arg);
PL_main_root = arg;
break;
}
- case INSN_MAIN_CV: /* 136 */
+ case INSN_MAIN_CV: /* 135 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&PL_main_cv = arg;
break;
}
- case INSN_CURPAD: /* 137 */
+ case INSN_CURPAD: /* 136 */
{
svindex arg;
BGET_svindex(arg);
BSET_curpad(PL_curpad, arg);
break;
}
- case INSN_PUSH_BEGIN: /* 138 */
+ case INSN_PUSH_BEGIN: /* 137 */
{
svindex arg;
BGET_svindex(arg);
BSET_push_begin(PL_beginav, arg);
break;
}
- case INSN_PUSH_INIT: /* 139 */
+ case INSN_PUSH_INIT: /* 138 */
{
svindex arg;
BGET_svindex(arg);
BSET_push_init(PL_initav, arg);
break;
}
- case INSN_PUSH_END: /* 140 */
+ case INSN_PUSH_END: /* 139 */
{
svindex arg;
BGET_svindex(arg);
BSET_push_end(PL_endav, arg);
break;
}
- case INSN_CURSTASH: /* 141 */
+ case INSN_CURSTASH: /* 140 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&PL_curstash = arg;
break;
}
- case INSN_DEFSTASH: /* 142 */
+ case INSN_DEFSTASH: /* 141 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&PL_defstash = arg;
break;
}
- case INSN_DATA: /* 143 */
+ case INSN_DATA: /* 142 */
{
U8 arg;
BGET_U8(arg);
BSET_data(none, arg);
break;
}
- case INSN_INCAV: /* 144 */
+ case INSN_INCAV: /* 143 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvAV(PL_incgv) = arg;
break;
}
- case INSN_LOAD_GLOB: /* 145 */
+ case INSN_LOAD_GLOB: /* 144 */
{
svindex arg;
BGET_svindex(arg);
break;
}
#ifdef USE_ITHREADS
- case INSN_REGEX_PADAV: /* 146 */
+ case INSN_REGEX_PADAV: /* 145 */
{
svindex arg;
BGET_svindex(arg);
break;
}
#endif
- case INSN_DOWARN: /* 147 */
+ case INSN_DOWARN: /* 146 */
{
U8 arg;
BGET_U8(arg);
PL_dowarn = arg;
break;
}
- case INSN_COMPPAD_NAME: /* 148 */
+ case INSN_COMPPAD_NAME: /* 147 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&PL_comppad_name = arg;
break;
}
- case INSN_XGV_STASH: /* 149 */
+ case INSN_XGV_STASH: /* 148 */
{
svindex arg;
BGET_svindex(arg);
*(SV**)&GvSTASH(bstate->bs_sv) = arg;
break;
}
- case INSN_SIGNAL: /* 150 */
+ case INSN_SIGNAL: /* 149 */
{
strconst arg;
BGET_strconst(arg);
BSET_signal(bstate->bs_sv, arg);
break;
}
- case INSN_FORMFEED: /* 151 */
+ case INSN_FORMFEED: /* 150 */
{
svindex arg;
BGET_svindex(arg);
INSN_AV_PUSH, /* 62 */
INSN_XAV_FILL, /* 63 */
INSN_XAV_MAX, /* 64 */
- INSN_XAV_FLAGS, /* 65 */
- INSN_XHV_RITER, /* 66 */
- INSN_XHV_NAME, /* 67 */
- INSN_XHV_PMROOT, /* 68 */
- INSN_HV_STORE, /* 69 */
- INSN_SV_MAGIC, /* 70 */
- INSN_MG_OBJ, /* 71 */
- INSN_MG_PRIVATE, /* 72 */
- INSN_MG_FLAGS, /* 73 */
- INSN_MG_NAME, /* 74 */
- INSN_MG_NAMEX, /* 75 */
- INSN_XMG_STASH, /* 76 */
- INSN_GV_FETCHPV, /* 77 */
- INSN_GV_FETCHPVX, /* 78 */
- INSN_GV_STASHPV, /* 79 */
- INSN_GV_STASHPVX, /* 80 */
- INSN_GP_SV, /* 81 */
- INSN_GP_REFCNT, /* 82 */
- INSN_GP_REFCNT_ADD, /* 83 */
- INSN_GP_AV, /* 84 */
- INSN_GP_HV, /* 85 */
- INSN_GP_CV, /* 86 */
- INSN_GP_FILE, /* 87 */
- INSN_GP_IO, /* 88 */
- INSN_GP_FORM, /* 89 */
- INSN_GP_CVGEN, /* 90 */
- INSN_GP_LINE, /* 91 */
- INSN_GP_SHARE, /* 92 */
- INSN_XGV_FLAGS, /* 93 */
- INSN_OP_NEXT, /* 94 */
- INSN_OP_SIBLING, /* 95 */
- INSN_OP_PPADDR, /* 96 */
- INSN_OP_TARG, /* 97 */
- INSN_OP_TYPE, /* 98 */
- INSN_OP_OPT, /* 99 */
- INSN_OP_STATIC, /* 100 */
- INSN_OP_FLAGS, /* 101 */
- INSN_OP_PRIVATE, /* 102 */
- INSN_OP_FIRST, /* 103 */
- INSN_OP_LAST, /* 104 */
- INSN_OP_OTHER, /* 105 */
- INSN_OP_PMREPLROOT, /* 106 */
- INSN_OP_PMREPLSTART, /* 107 */
- INSN_OP_PMNEXT, /* 108 */
- INSN_OP_PMSTASHPV, /* 109 */
- INSN_OP_PMREPLROOTPO, /* 110 */
- INSN_OP_PMSTASH, /* 111 */
- INSN_OP_PMREPLROOTGV, /* 112 */
- INSN_PREGCOMP, /* 113 */
- INSN_OP_PMFLAGS, /* 114 */
- INSN_OP_PMPERMFLAGS, /* 115 */
- INSN_OP_PMDYNFLAGS, /* 116 */
- INSN_OP_SV, /* 117 */
- INSN_OP_PADIX, /* 118 */
- INSN_OP_PV, /* 119 */
- INSN_OP_PV_TR, /* 120 */
- INSN_OP_REDOOP, /* 121 */
- INSN_OP_NEXTOP, /* 122 */
- INSN_OP_LASTOP, /* 123 */
- INSN_COP_LABEL, /* 124 */
- INSN_COP_STASHPV, /* 125 */
- INSN_COP_FILE, /* 126 */
- INSN_COP_STASH, /* 127 */
- INSN_COP_FILEGV, /* 128 */
- INSN_COP_SEQ, /* 129 */
- INSN_COP_ARYBASE, /* 130 */
- INSN_COP_LINE, /* 131 */
- INSN_COP_IO, /* 132 */
- INSN_COP_WARNINGS, /* 133 */
- INSN_MAIN_START, /* 134 */
- INSN_MAIN_ROOT, /* 135 */
- INSN_MAIN_CV, /* 136 */
- INSN_CURPAD, /* 137 */
- INSN_PUSH_BEGIN, /* 138 */
- INSN_PUSH_INIT, /* 139 */
- INSN_PUSH_END, /* 140 */
- INSN_CURSTASH, /* 141 */
- INSN_DEFSTASH, /* 142 */
- INSN_DATA, /* 143 */
- INSN_INCAV, /* 144 */
- INSN_LOAD_GLOB, /* 145 */
- INSN_REGEX_PADAV, /* 146 */
- INSN_DOWARN, /* 147 */
- INSN_COMPPAD_NAME, /* 148 */
- INSN_XGV_STASH, /* 149 */
- INSN_SIGNAL, /* 150 */
- INSN_FORMFEED, /* 151 */
- MAX_INSN = 151
+ INSN_XHV_RITER, /* 65 */
+ INSN_XHV_NAME, /* 66 */
+ INSN_XHV_PMROOT, /* 67 */
+ INSN_HV_STORE, /* 68 */
+ INSN_SV_MAGIC, /* 69 */
+ INSN_MG_OBJ, /* 70 */
+ INSN_MG_PRIVATE, /* 71 */
+ INSN_MG_FLAGS, /* 72 */
+ INSN_MG_NAME, /* 73 */
+ INSN_MG_NAMEX, /* 74 */
+ INSN_XMG_STASH, /* 75 */
+ INSN_GV_FETCHPV, /* 76 */
+ INSN_GV_FETCHPVX, /* 77 */
+ INSN_GV_STASHPV, /* 78 */
+ INSN_GV_STASHPVX, /* 79 */
+ INSN_GP_SV, /* 80 */
+ INSN_GP_REFCNT, /* 81 */
+ INSN_GP_REFCNT_ADD, /* 82 */
+ INSN_GP_AV, /* 83 */
+ INSN_GP_HV, /* 84 */
+ INSN_GP_CV, /* 85 */
+ INSN_GP_FILE, /* 86 */
+ INSN_GP_IO, /* 87 */
+ INSN_GP_FORM, /* 88 */
+ INSN_GP_CVGEN, /* 89 */
+ INSN_GP_LINE, /* 90 */
+ INSN_GP_SHARE, /* 91 */
+ INSN_XGV_FLAGS, /* 92 */
+ INSN_OP_NEXT, /* 93 */
+ INSN_OP_SIBLING, /* 94 */
+ INSN_OP_PPADDR, /* 95 */
+ INSN_OP_TARG, /* 96 */
+ INSN_OP_TYPE, /* 97 */
+ INSN_OP_OPT, /* 98 */
+ INSN_OP_STATIC, /* 99 */
+ INSN_OP_FLAGS, /* 100 */
+ INSN_OP_PRIVATE, /* 101 */
+ INSN_OP_FIRST, /* 102 */
+ INSN_OP_LAST, /* 103 */
+ INSN_OP_OTHER, /* 104 */
+ INSN_OP_PMREPLROOT, /* 105 */
+ INSN_OP_PMREPLSTART, /* 106 */
+ INSN_OP_PMNEXT, /* 107 */
+ INSN_OP_PMSTASHPV, /* 108 */
+ INSN_OP_PMREPLROOTPO, /* 109 */
+ INSN_OP_PMSTASH, /* 110 */
+ INSN_OP_PMREPLROOTGV, /* 111 */
+ INSN_PREGCOMP, /* 112 */
+ INSN_OP_PMFLAGS, /* 113 */
+ INSN_OP_PMPERMFLAGS, /* 114 */
+ INSN_OP_PMDYNFLAGS, /* 115 */
+ INSN_OP_SV, /* 116 */
+ INSN_OP_PADIX, /* 117 */
+ INSN_OP_PV, /* 118 */
+ INSN_OP_PV_TR, /* 119 */
+ INSN_OP_REDOOP, /* 120 */
+ INSN_OP_NEXTOP, /* 121 */
+ INSN_OP_LASTOP, /* 122 */
+ INSN_COP_LABEL, /* 123 */
+ INSN_COP_STASHPV, /* 124 */
+ INSN_COP_FILE, /* 125 */
+ INSN_COP_STASH, /* 126 */
+ INSN_COP_FILEGV, /* 127 */
+ INSN_COP_SEQ, /* 128 */
+ INSN_COP_ARYBASE, /* 129 */
+ INSN_COP_LINE, /* 130 */
+ INSN_COP_IO, /* 131 */
+ INSN_COP_WARNINGS, /* 132 */
+ INSN_MAIN_START, /* 133 */
+ INSN_MAIN_ROOT, /* 134 */
+ INSN_MAIN_CV, /* 135 */
+ INSN_CURPAD, /* 136 */
+ INSN_PUSH_BEGIN, /* 137 */
+ INSN_PUSH_INIT, /* 138 */
+ INSN_PUSH_END, /* 139 */
+ INSN_CURSTASH, /* 140 */
+ INSN_DEFSTASH, /* 141 */
+ INSN_DATA, /* 142 */
+ INSN_INCAV, /* 143 */
+ INSN_LOAD_GLOB, /* 144 */
+ INSN_REGEX_PADAV, /* 145 */
+ INSN_DOWARN, /* 146 */
+ INSN_COMPPAD_NAME, /* 147 */
+ INSN_XGV_STASH, /* 148 */
+ INSN_SIGNAL, /* 149 */
+ INSN_FORMFEED, /* 150 */
+ MAX_INSN = 150
};
enum {
AV * const a0 = newAV(); /* will be @_ */
av_extend(a0, 0);
av_store(pad, 0, (SV*)a0);
- AvFLAGS(a0) = AVf_REIFY;
+ AvREIFY_only(a0);
}
else {
av_store(pad, 0, Nullsv);
AV *av = newAV(); /* Will be @_ */
av_extend(av, 0);
av_store(PL_comppad, 0, (SV*)av);
- AvFLAGS(av) = AVf_REIFY;
+ AvREIFY_only(av);
}
/* XXX DAPM rationalise these two similar branches */
av = newAV();
av_extend(av, 0);
av_store(newpad, 0, (SV*)av);
- AvFLAGS(av) = AVf_REIFY;
+ AvREIFY_only(av);
av_store(padlist, depth, (SV*)newpad);
AvFILLp(padlist) = depth;
SvREFCNT_dec(av);
av = newAV();
av_extend(av, items-1);
- AvFLAGS(av) = AVf_REIFY;
+ AvREIFY_only(av);
PAD_SVl(0) = (SV*)(cx->blk_sub.argarray = av);
}
}
AvFILLp(sv) = -1;
AvALLOC(sv) = 0;
AvARYLEN(sv)= 0;
- AvFLAGS(sv) = AVf_REAL;
+ AvREAL_only(sv);
SvIV_set(sv, 0);
SvNV_set(sv, 0.0);
}
SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
AvARYLEN((AV*)dstr) = sv_dup_inc(AvARYLEN((AV*)sstr), param);
- AvFLAGS((AV*)dstr) = AvFLAGS((AV*)sstr);
if (AvARRAY((AV*)sstr)) {
SV **dst_ary, **src_ary;
SSize_t items = AvFILLp((AV*)sstr) + 1;
#define SVprv_WEAKREF 0x80000000 /* Weak reference */
+#define SVpav_REAL 0x40000000 /* free old entries */
+#define SVpav_REIFY 0x80000000 /* can become real */
+
struct xrv {
SV * xrv_rv; /* pointer to another SV */
};
projects / platform / upstream / perl.git / commitdiff