From: Jarkko Hietaniemi <jhi@iki.fi>
Date: Sun, 25 Jun 2000 15:26:42 +0000 (+0000)
Subject: Regen headers.
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=21fff32650ffc8719558f625ca6c5cc49a442d92;p=p5sagit%2Fp5-mst-13.2.git
Regen headers.
p4raw-id: //depot/cfgperl@6236
---
diff --git a/embed.h b/embed.h
index 7cc8e63..4c95dc2 100644
--- a/embed.h
+++ b/embed.h
@@ -721,6 +721,8 @@
#define utf16_to_utf8_reversed Perl_utf16_to_utf8_reversed
#define utf8_distance Perl_utf8_distance
#define utf8_hop Perl_utf8_hop
+#define utf8_to_bytes Perl_utf8_to_bytes
+#define bytes_to_utf8 Perl_bytes_to_utf8
#define utf8_to_uv Perl_utf8_to_uv
#define uv_to_utf8 Perl_uv_to_utf8
#define vivify_defelem Perl_vivify_defelem
@@ -849,8 +851,6 @@
#define do_trans_UU_simple S_do_trans_UU_simple
#define do_trans_UU_count S_do_trans_UU_count
#define do_trans_UU_complex S_do_trans_UU_complex
-#define do_trans_UC_simple S_do_trans_UC_simple
-#define do_trans_CU_simple S_do_trans_CU_simple
#define do_trans_UC_trivial S_do_trans_UC_trivial
#define do_trans_CU_trivial S_do_trans_CU_trivial
#endif
@@ -2169,6 +2169,8 @@
#define utf16_to_utf8_reversed(a,b,c) Perl_utf16_to_utf8_reversed(aTHX_ a,b,c)
#define utf8_distance(a,b) Perl_utf8_distance(aTHX_ a,b)
#define utf8_hop(a,b) Perl_utf8_hop(aTHX_ a,b)
+#define utf8_to_bytes(a,b) Perl_utf8_to_bytes(aTHX_ a,b)
+#define bytes_to_utf8(a,b) Perl_bytes_to_utf8(aTHX_ a,b)
#define utf8_to_uv(a,b) Perl_utf8_to_uv(aTHX_ a,b)
#define uv_to_utf8(a,b) Perl_uv_to_utf8(aTHX_ a,b)
#define vivify_defelem(a) Perl_vivify_defelem(aTHX_ a)
@@ -2291,8 +2293,6 @@
#define do_trans_UU_simple(a) S_do_trans_UU_simple(aTHX_ a)
#define do_trans_UU_count(a) S_do_trans_UU_count(aTHX_ a)
#define do_trans_UU_complex(a) S_do_trans_UU_complex(aTHX_ a)
-#define do_trans_UC_simple(a) S_do_trans_UC_simple(aTHX_ a)
-#define do_trans_CU_simple(a) S_do_trans_CU_simple(aTHX_ a)
#define do_trans_UC_trivial(a) S_do_trans_UC_trivial(aTHX_ a)
#define do_trans_CU_trivial(a) S_do_trans_CU_trivial(aTHX_ a)
#endif
@@ -4250,6 +4250,10 @@
#define utf8_distance Perl_utf8_distance
#define Perl_utf8_hop CPerlObj::Perl_utf8_hop
#define utf8_hop Perl_utf8_hop
+#define Perl_utf8_to_bytes CPerlObj::Perl_utf8_to_bytes
+#define utf8_to_bytes Perl_utf8_to_bytes
+#define Perl_bytes_to_utf8 CPerlObj::Perl_bytes_to_utf8
+#define bytes_to_utf8 Perl_bytes_to_utf8
#define Perl_utf8_to_uv CPerlObj::Perl_utf8_to_uv
#define utf8_to_uv Perl_utf8_to_uv
#define Perl_uv_to_utf8 CPerlObj::Perl_uv_to_utf8
@@ -4483,10 +4487,6 @@
#define do_trans_UU_count S_do_trans_UU_count
#define S_do_trans_UU_complex CPerlObj::S_do_trans_UU_complex
#define do_trans_UU_complex S_do_trans_UU_complex
-#define S_do_trans_UC_simple CPerlObj::S_do_trans_UC_simple
-#define do_trans_UC_simple S_do_trans_UC_simple
-#define S_do_trans_CU_simple CPerlObj::S_do_trans_CU_simple
-#define do_trans_CU_simple S_do_trans_CU_simple
#define S_do_trans_UC_trivial CPerlObj::S_do_trans_UC_trivial
#define do_trans_UC_trivial S_do_trans_UC_trivial
#define S_do_trans_CU_trivial CPerlObj::S_do_trans_CU_trivial
diff --git a/ext/B/B/Asmdata.pm b/ext/B/B/Asmdata.pm
index 314498d..b412927 100644
--- a/ext/B/B/Asmdata.pm
+++ b/ext/B/B/Asmdata.pm
@@ -27,120 +27,121 @@ $insn_data{ldsv} = [1, \&PUT_svindex, "GET_svindex"];
$insn_data{ldop} = [2, \&PUT_opindex, "GET_opindex"];
$insn_data{stsv} = [3, \&PUT_U32, "GET_U32"];
$insn_data{stop} = [4, \&PUT_U32, "GET_U32"];
-$insn_data{ldspecsv} = [5, \&PUT_U8, "GET_U8"];
-$insn_data{newsv} = [6, \&PUT_U8, "GET_U8"];
-$insn_data{newop} = [7, \&PUT_U8, "GET_U8"];
-$insn_data{newopn} = [8, \&PUT_U8, "GET_U8"];
-$insn_data{newpv} = [9, \&PUT_PV, "GET_PV"];
-$insn_data{pv_cur} = [11, \&PUT_U32, "GET_U32"];
-$insn_data{pv_free} = [12, \&PUT_none, "GET_none"];
-$insn_data{sv_upgrade} = [13, \&PUT_U8, "GET_U8"];
-$insn_data{sv_refcnt} = [14, \&PUT_U32, "GET_U32"];
-$insn_data{sv_refcnt_add} = [15, \&PUT_I32, "GET_I32"];
-$insn_data{sv_flags} = [16, \&PUT_U32, "GET_U32"];
-$insn_data{xrv} = [17, \&PUT_svindex, "GET_svindex"];
-$insn_data{xpv} = [18, \&PUT_none, "GET_none"];
-$insn_data{xiv32} = [19, \&PUT_I32, "GET_I32"];
-$insn_data{xiv64} = [20, \&PUT_IV64, "GET_IV64"];
-$insn_data{xnv} = [21, \&PUT_NV, "GET_NV"];
-$insn_data{xlv_targoff} = [22, \&PUT_U32, "GET_U32"];
-$insn_data{xlv_targlen} = [23, \&PUT_U32, "GET_U32"];
-$insn_data{xlv_targ} = [24, \&PUT_svindex, "GET_svindex"];
-$insn_data{xlv_type} = [25, \&PUT_U8, "GET_U8"];
-$insn_data{xbm_useful} = [26, \&PUT_I32, "GET_I32"];
-$insn_data{xbm_previous} = [27, \&PUT_U16, "GET_U16"];
-$insn_data{xbm_rare} = [28, \&PUT_U8, "GET_U8"];
-$insn_data{xfm_lines} = [29, \&PUT_I32, "GET_I32"];
-$insn_data{xio_lines} = [30, \&PUT_I32, "GET_I32"];
-$insn_data{xio_page} = [31, \&PUT_I32, "GET_I32"];
-$insn_data{xio_page_len} = [32, \&PUT_I32, "GET_I32"];
-$insn_data{xio_lines_left} = [33, \&PUT_I32, "GET_I32"];
-$insn_data{xio_top_name} = [34, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{xio_top_gv} = [36, \&PUT_svindex, "GET_svindex"];
-$insn_data{xio_fmt_name} = [37, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{xio_fmt_gv} = [38, \&PUT_svindex, "GET_svindex"];
-$insn_data{xio_bottom_name} = [39, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{xio_bottom_gv} = [40, \&PUT_svindex, "GET_svindex"];
-$insn_data{xio_subprocess} = [41, \&PUT_U16, "GET_U16"];
-$insn_data{xio_type} = [42, \&PUT_U8, "GET_U8"];
-$insn_data{xio_flags} = [43, \&PUT_U8, "GET_U8"];
-$insn_data{xcv_stash} = [44, \&PUT_svindex, "GET_svindex"];
-$insn_data{xcv_start} = [45, \&PUT_opindex, "GET_opindex"];
-$insn_data{xcv_root} = [46, \&PUT_opindex, "GET_opindex"];
-$insn_data{xcv_gv} = [47, \&PUT_svindex, "GET_svindex"];
-$insn_data{xcv_file} = [48, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{xcv_depth} = [49, \&PUT_I32, "GET_I32"];
-$insn_data{xcv_padlist} = [50, \&PUT_svindex, "GET_svindex"];
-$insn_data{xcv_outside} = [51, \&PUT_svindex, "GET_svindex"];
-$insn_data{xcv_flags} = [52, \&PUT_U16, "GET_U16"];
-$insn_data{av_extend} = [53, \&PUT_I32, "GET_I32"];
-$insn_data{av_push} = [54, \&PUT_svindex, "GET_svindex"];
-$insn_data{xav_fill} = [55, \&PUT_I32, "GET_I32"];
-$insn_data{xav_max} = [56, \&PUT_I32, "GET_I32"];
-$insn_data{xav_flags} = [57, \&PUT_U8, "GET_U8"];
-$insn_data{xhv_riter} = [58, \&PUT_I32, "GET_I32"];
-$insn_data{xhv_name} = [59, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{hv_store} = [60, \&PUT_svindex, "GET_svindex"];
-$insn_data{sv_magic} = [61, \&PUT_U8, "GET_U8"];
-$insn_data{mg_obj} = [62, \&PUT_svindex, "GET_svindex"];
-$insn_data{mg_private} = [63, \&PUT_U16, "GET_U16"];
-$insn_data{mg_flags} = [64, \&PUT_U8, "GET_U8"];
-$insn_data{mg_pv} = [65, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{xmg_stash} = [66, \&PUT_svindex, "GET_svindex"];
-$insn_data{gv_fetchpv} = [67, \&PUT_strconst, "GET_strconst"];
-$insn_data{gv_stashpv} = [68, \&PUT_strconst, "GET_strconst"];
-$insn_data{gp_sv} = [69, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_refcnt} = [70, \&PUT_U32, "GET_U32"];
-$insn_data{gp_refcnt_add} = [71, \&PUT_I32, "GET_I32"];
-$insn_data{gp_av} = [72, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_hv} = [73, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_cv} = [74, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_file} = [75, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{gp_io} = [76, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_form} = [77, \&PUT_svindex, "GET_svindex"];
-$insn_data{gp_cvgen} = [78, \&PUT_U32, "GET_U32"];
-$insn_data{gp_line} = [79, \&PUT_U16, "GET_U16"];
-$insn_data{gp_share} = [80, \&PUT_svindex, "GET_svindex"];
-$insn_data{xgv_flags} = [81, \&PUT_U8, "GET_U8"];
-$insn_data{op_next} = [82, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_sibling} = [83, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_ppaddr} = [84, \&PUT_strconst, "GET_strconst"];
-$insn_data{op_targ} = [85, \&PUT_U32, "GET_U32"];
-$insn_data{op_type} = [86, \&PUT_U16, "GET_U16"];
-$insn_data{op_seq} = [87, \&PUT_U16, "GET_U16"];
-$insn_data{op_flags} = [88, \&PUT_U8, "GET_U8"];
-$insn_data{op_private} = [89, \&PUT_U8, "GET_U8"];
-$insn_data{op_first} = [90, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_last} = [91, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_other} = [92, \&PUT_opindex, "GET_opindex"];
-$insn_data{op_children} = [93, \&PUT_U32, "GET_U32"];
-$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_pvcontents, "GET_pvcontents"];
-$insn_data{cop_stashpv} = [109, \&PUT_pvcontents, "GET_pvcontents"];
-$insn_data{cop_file} = [110, \&PUT_pvcontents, "GET_pvcontents"];
-$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{stpv} = [5, \&PUT_U32, "GET_U32"];
+$insn_data{ldspecsv} = [6, \&PUT_U8, "GET_U8"];
+$insn_data{newsv} = [7, \&PUT_U8, "GET_U8"];
+$insn_data{newop} = [8, \&PUT_U8, "GET_U8"];
+$insn_data{newopn} = [9, \&PUT_U8, "GET_U8"];
+$insn_data{newpv} = [11, \&PUT_PV, "GET_PV"];
+$insn_data{pv_cur} = [12, \&PUT_U32, "GET_U32"];
+$insn_data{pv_free} = [13, \&PUT_none, "GET_none"];
+$insn_data{sv_upgrade} = [14, \&PUT_U8, "GET_U8"];
+$insn_data{sv_refcnt} = [15, \&PUT_U32, "GET_U32"];
+$insn_data{sv_refcnt_add} = [16, \&PUT_I32, "GET_I32"];
+$insn_data{sv_flags} = [17, \&PUT_U32, "GET_U32"];
+$insn_data{xrv} = [18, \&PUT_svindex, "GET_svindex"];
+$insn_data{xpv} = [19, \&PUT_none, "GET_none"];
+$insn_data{xiv32} = [20, \&PUT_I32, "GET_I32"];
+$insn_data{xiv64} = [21, \&PUT_IV64, "GET_IV64"];
+$insn_data{xnv} = [22, \&PUT_NV, "GET_NV"];
+$insn_data{xlv_targoff} = [23, \&PUT_U32, "GET_U32"];
+$insn_data{xlv_targlen} = [24, \&PUT_U32, "GET_U32"];
+$insn_data{xlv_targ} = [25, \&PUT_svindex, "GET_svindex"];
+$insn_data{xlv_type} = [26, \&PUT_U8, "GET_U8"];
+$insn_data{xbm_useful} = [27, \&PUT_I32, "GET_I32"];
+$insn_data{xbm_previous} = [28, \&PUT_U16, "GET_U16"];
+$insn_data{xbm_rare} = [29, \&PUT_U8, "GET_U8"];
+$insn_data{xfm_lines} = [30, \&PUT_I32, "GET_I32"];
+$insn_data{xio_lines} = [31, \&PUT_I32, "GET_I32"];
+$insn_data{xio_page} = [32, \&PUT_I32, "GET_I32"];
+$insn_data{xio_page_len} = [33, \&PUT_I32, "GET_I32"];
+$insn_data{xio_lines_left} = [34, \&PUT_I32, "GET_I32"];
+$insn_data{xio_top_name} = [36, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{xio_top_gv} = [37, \&PUT_svindex, "GET_svindex"];
+$insn_data{xio_fmt_name} = [38, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{xio_fmt_gv} = [39, \&PUT_svindex, "GET_svindex"];
+$insn_data{xio_bottom_name} = [40, \&PUT_pvcontents, "GET_pvcontents"];
+$insn_data{xio_bottom_gv} = [41, \&PUT_svindex, "GET_svindex"];
+$insn_data{xio_subprocess} = [42, \&PUT_U16, "GET_U16"];
+$insn_data{xio_type} = [43, \&PUT_U8, "GET_U8"];
+$insn_data{xio_flags} = [44, \&PUT_U8, "GET_U8"];
+$insn_data{xcv_stash} = [45, \&PUT_svindex, "GET_svindex"];
+$insn_data{xcv_start} = [46, \&PUT_opindex, "GET_opindex"];
+$insn_data{xcv_root} = [47, \&PUT_opindex, "GET_opindex"];
+$insn_data{xcv_gv} = [48, \&PUT_svindex, "GET_svindex"];
+$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_children} = [94, \&PUT_U32, "GET_U32"];
+$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) {
diff --git a/ext/ByteLoader/byterun.c b/ext/ByteLoader/byterun.c
index 091767e..19f1f6b 100644
--- a/ext/ByteLoader/byterun.c
+++ b/ext/ByteLoader/byterun.c
@@ -40,39 +40,29 @@ static const int optype_size[] = {
sizeof(COP)
};
-static int bytecode_iv_overflows = 0;
-static void **bytecode_obj_list = Null(void**);
-static I32 bytecode_obj_list_fill = -1;
-
void *
-bset_obj_store(pTHXo_ void *obj, I32 ix)
+bset_obj_store(pTHXo_ struct byteloader_state *bstate, void *obj, I32 ix)
{
- if (ix > bytecode_obj_list_fill) {
- if (bytecode_obj_list_fill == -1)
- New(666, bytecode_obj_list, ix + 32, void*);
- else
- Renew(bytecode_obj_list, ix + 32, void*);
- bytecode_obj_list_fill = ix;
+ if (ix > bstate->bs_obj_list_fill) {
+ Renew(bstate->bs_obj_list, ix + 32, void*);
+ bstate->bs_obj_list_fill = ix + 31;
}
- bytecode_obj_list[ix] = obj;
+ bstate->bs_obj_list[ix] = obj;
return obj;
}
void
-byterun(pTHXo)
+byterun(pTHXo_ register struct byteloader_state *bstate)
{
dTHR;
- int insn;
- SV *bytecode_sv;
- XPV bytecode_pv;
+ register int insn;
+ U32 ix;
SV *specialsv_list[6];
- ENTER;
- SAVEVPTR(bytecode_obj_list);
- SAVEI32(bytecode_obj_list_fill);
- bytecode_obj_list = Null(void**);
- bytecode_obj_list_fill = -1;
BYTECODE_HEADER_CHECK; /* croak if incorrect platform */
+ New(666, bstate->bs_obj_list, 32, void*); /* set op objlist */
+ bstate->bs_obj_list_fill = 31;
+
specialsv_list[0] = Nullsv;
specialsv_list[1] = &PL_sv_undef;
specialsv_list[2] = &PL_sv_yes;
@@ -102,7 +92,7 @@ byterun(pTHXo)
{
svindex arg;
BGET_svindex(arg);
- bytecode_sv = arg;
+ bstate->bs_sv = arg;
break;
}
case INSN_LDOP: /* 2 */
@@ -116,7 +106,7 @@ byterun(pTHXo)
{
U32 arg;
BGET_U32(arg);
- BSET_OBJ_STORE(bytecode_sv, arg);
+ BSET_OBJ_STORE(bstate->bs_sv, arg);
break;
}
case INSN_STOP: /* 4 */
@@ -126,793 +116,800 @@ byterun(pTHXo)
BSET_OBJ_STORE(PL_op, arg);
break;
}
- case INSN_LDSPECSV: /* 5 */
+ case INSN_STPV: /* 5 */
+ {
+ U32 arg;
+ BGET_U32(arg);
+ BSET_stpv(bstate->bs_pv.xpv_pv, arg);
+ break;
+ }
+ case INSN_LDSPECSV: /* 6 */
{
U8 arg;
BGET_U8(arg);
- BSET_ldspecsv(bytecode_sv, arg);
+ BSET_ldspecsv(bstate->bs_sv, arg);
break;
}
- case INSN_NEWSV: /* 6 */
+ case INSN_NEWSV: /* 7 */
{
U8 arg;
BGET_U8(arg);
- BSET_newsv(bytecode_sv, arg);
+ BSET_newsv(bstate->bs_sv, arg);
break;
}
- case INSN_NEWOP: /* 7 */
+ case INSN_NEWOP: /* 8 */
{
U8 arg;
BGET_U8(arg);
BSET_newop(PL_op, arg);
break;
}
- case INSN_NEWOPN: /* 8 */
+ case INSN_NEWOPN: /* 9 */
{
U8 arg;
BGET_U8(arg);
BSET_newopn(PL_op, arg);
break;
}
- case INSN_NEWPV: /* 9 */
+ case INSN_NEWPV: /* 11 */
{
PV arg;
BGET_PV(arg);
break;
}
- case INSN_PV_CUR: /* 11 */
+ case INSN_PV_CUR: /* 12 */
{
STRLEN arg;
BGET_U32(arg);
- bytecode_pv.xpv_cur = arg;
+ bstate->bs_pv.xpv_cur = arg;
break;
}
- case INSN_PV_FREE: /* 12 */
+ case INSN_PV_FREE: /* 13 */
{
- BSET_pv_free(bytecode_pv);
+ BSET_pv_free(bstate->bs_pv);
break;
}
- case INSN_SV_UPGRADE: /* 13 */
+ case INSN_SV_UPGRADE: /* 14 */
{
char arg;
BGET_U8(arg);
- BSET_sv_upgrade(bytecode_sv, arg);
+ BSET_sv_upgrade(bstate->bs_sv, arg);
break;
}
- case INSN_SV_REFCNT: /* 14 */
+ case INSN_SV_REFCNT: /* 15 */
{
U32 arg;
BGET_U32(arg);
- SvREFCNT(bytecode_sv) = arg;
+ SvREFCNT(bstate->bs_sv) = arg;
break;
}
- case INSN_SV_REFCNT_ADD: /* 15 */
+ case INSN_SV_REFCNT_ADD: /* 16 */
{
I32 arg;
BGET_I32(arg);
- BSET_sv_refcnt_add(SvREFCNT(bytecode_sv), arg);
+ BSET_sv_refcnt_add(SvREFCNT(bstate->bs_sv), arg);
break;
}
- case INSN_SV_FLAGS: /* 16 */
+ case INSN_SV_FLAGS: /* 17 */
{
U32 arg;
BGET_U32(arg);
- SvFLAGS(bytecode_sv) = arg;
+ SvFLAGS(bstate->bs_sv) = arg;
break;
}
- case INSN_XRV: /* 17 */
+ case INSN_XRV: /* 18 */
{
svindex arg;
BGET_svindex(arg);
- SvRV(bytecode_sv) = arg;
+ SvRV(bstate->bs_sv) = arg;
break;
}
- case INSN_XPV: /* 18 */
+ case INSN_XPV: /* 19 */
{
- BSET_xpv(bytecode_sv);
+ BSET_xpv(bstate->bs_sv);
break;
}
- case INSN_XIV32: /* 19 */
+ case INSN_XIV32: /* 20 */
{
I32 arg;
BGET_I32(arg);
- SvIVX(bytecode_sv) = arg;
+ SvIVX(bstate->bs_sv) = arg;
break;
}
- case INSN_XIV64: /* 20 */
+ case INSN_XIV64: /* 21 */
{
IV64 arg;
BGET_IV64(arg);
- SvIVX(bytecode_sv) = arg;
+ SvIVX(bstate->bs_sv) = arg;
break;
}
- case INSN_XNV: /* 21 */
+ case INSN_XNV: /* 22 */
{
NV arg;
BGET_NV(arg);
- SvNVX(bytecode_sv) = arg;
+ SvNVX(bstate->bs_sv) = arg;
break;
}
- case INSN_XLV_TARGOFF: /* 22 */
+ case INSN_XLV_TARGOFF: /* 23 */
{
STRLEN arg;
BGET_U32(arg);
- LvTARGOFF(bytecode_sv) = arg;
+ LvTARGOFF(bstate->bs_sv) = arg;
break;
}
- case INSN_XLV_TARGLEN: /* 23 */
+ case INSN_XLV_TARGLEN: /* 24 */
{
STRLEN arg;
BGET_U32(arg);
- LvTARGLEN(bytecode_sv) = arg;
+ LvTARGLEN(bstate->bs_sv) = arg;
break;
}
- case INSN_XLV_TARG: /* 24 */
+ case INSN_XLV_TARG: /* 25 */
{
svindex arg;
BGET_svindex(arg);
- LvTARG(bytecode_sv) = arg;
+ LvTARG(bstate->bs_sv) = arg;
break;
}
- case INSN_XLV_TYPE: /* 25 */
+ case INSN_XLV_TYPE: /* 26 */
{
char arg;
BGET_U8(arg);
- LvTYPE(bytecode_sv) = arg;
+ LvTYPE(bstate->bs_sv) = arg;
break;
}
- case INSN_XBM_USEFUL: /* 26 */
+ case INSN_XBM_USEFUL: /* 27 */
{
I32 arg;
BGET_I32(arg);
- BmUSEFUL(bytecode_sv) = arg;
+ BmUSEFUL(bstate->bs_sv) = arg;
break;
}
- case INSN_XBM_PREVIOUS: /* 27 */
+ case INSN_XBM_PREVIOUS: /* 28 */
{
U16 arg;
BGET_U16(arg);
- BmPREVIOUS(bytecode_sv) = arg;
+ BmPREVIOUS(bstate->bs_sv) = arg;
break;
}
- case INSN_XBM_RARE: /* 28 */
+ case INSN_XBM_RARE: /* 29 */
{
U8 arg;
BGET_U8(arg);
- BmRARE(bytecode_sv) = arg;
+ BmRARE(bstate->bs_sv) = arg;
break;
}
- case INSN_XFM_LINES: /* 29 */
+ case INSN_XFM_LINES: /* 30 */
{
I32 arg;
BGET_I32(arg);
- FmLINES(bytecode_sv) = arg;
+ FmLINES(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_LINES: /* 30 */
+ case INSN_XIO_LINES: /* 31 */
{
long arg;
BGET_I32(arg);
- IoLINES(bytecode_sv) = arg;
+ IoLINES(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_PAGE: /* 31 */
+ case INSN_XIO_PAGE: /* 32 */
{
long arg;
BGET_I32(arg);
- IoPAGE(bytecode_sv) = arg;
+ IoPAGE(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_PAGE_LEN: /* 32 */
+ case INSN_XIO_PAGE_LEN: /* 33 */
{
long arg;
BGET_I32(arg);
- IoPAGE_LEN(bytecode_sv) = arg;
+ IoPAGE_LEN(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_LINES_LEFT: /* 33 */
+ case INSN_XIO_LINES_LEFT: /* 34 */
{
long arg;
BGET_I32(arg);
- IoLINES_LEFT(bytecode_sv) = arg;
+ IoLINES_LEFT(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_TOP_NAME: /* 34 */
+ case INSN_XIO_TOP_NAME: /* 36 */
{
pvcontents arg;
BGET_pvcontents(arg);
- IoTOP_NAME(bytecode_sv) = arg;
+ IoTOP_NAME(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_TOP_GV: /* 36 */
+ case INSN_XIO_TOP_GV: /* 37 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&IoTOP_GV(bytecode_sv) = arg;
+ *(SV**)&IoTOP_GV(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_FMT_NAME: /* 37 */
+ case INSN_XIO_FMT_NAME: /* 38 */
{
pvcontents arg;
BGET_pvcontents(arg);
- IoFMT_NAME(bytecode_sv) = arg;
+ IoFMT_NAME(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_FMT_GV: /* 38 */
+ case INSN_XIO_FMT_GV: /* 39 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&IoFMT_GV(bytecode_sv) = arg;
+ *(SV**)&IoFMT_GV(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_BOTTOM_NAME: /* 39 */
+ case INSN_XIO_BOTTOM_NAME: /* 40 */
{
pvcontents arg;
BGET_pvcontents(arg);
- IoBOTTOM_NAME(bytecode_sv) = arg;
+ IoBOTTOM_NAME(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_BOTTOM_GV: /* 40 */
+ case INSN_XIO_BOTTOM_GV: /* 41 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&IoBOTTOM_GV(bytecode_sv) = arg;
+ *(SV**)&IoBOTTOM_GV(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_SUBPROCESS: /* 41 */
+ case INSN_XIO_SUBPROCESS: /* 42 */
{
short arg;
BGET_U16(arg);
- IoSUBPROCESS(bytecode_sv) = arg;
+ IoSUBPROCESS(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_TYPE: /* 42 */
+ case INSN_XIO_TYPE: /* 43 */
{
char arg;
BGET_U8(arg);
- IoTYPE(bytecode_sv) = arg;
+ IoTYPE(bstate->bs_sv) = arg;
break;
}
- case INSN_XIO_FLAGS: /* 43 */
+ case INSN_XIO_FLAGS: /* 44 */
{
char arg;
BGET_U8(arg);
- IoFLAGS(bytecode_sv) = arg;
+ IoFLAGS(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_STASH: /* 44 */
+ case INSN_XCV_STASH: /* 45 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&CvSTASH(bytecode_sv) = arg;
+ *(SV**)&CvSTASH(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_START: /* 45 */
+ case INSN_XCV_START: /* 46 */
{
opindex arg;
BGET_opindex(arg);
- CvSTART(bytecode_sv) = arg;
+ CvSTART(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_ROOT: /* 46 */
+ case INSN_XCV_ROOT: /* 47 */
{
opindex arg;
BGET_opindex(arg);
- CvROOT(bytecode_sv) = arg;
+ CvROOT(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_GV: /* 47 */
+ case INSN_XCV_GV: /* 48 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&CvGV(bytecode_sv) = arg;
+ *(SV**)&CvGV(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_FILE: /* 48 */
+ case INSN_XCV_FILE: /* 49 */
{
- pvcontents arg;
- BGET_pvcontents(arg);
- CvFILE(bytecode_sv) = arg;
+ pvindex arg;
+ BGET_pvindex(arg);
+ CvFILE(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_DEPTH: /* 49 */
+ case INSN_XCV_DEPTH: /* 50 */
{
long arg;
BGET_I32(arg);
- CvDEPTH(bytecode_sv) = arg;
+ CvDEPTH(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_PADLIST: /* 50 */
+ case INSN_XCV_PADLIST: /* 51 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&CvPADLIST(bytecode_sv) = arg;
+ *(SV**)&CvPADLIST(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_OUTSIDE: /* 51 */
+ case INSN_XCV_OUTSIDE: /* 52 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&CvOUTSIDE(bytecode_sv) = arg;
+ *(SV**)&CvOUTSIDE(bstate->bs_sv) = arg;
break;
}
- case INSN_XCV_FLAGS: /* 52 */
+ case INSN_XCV_FLAGS: /* 53 */
{
U16 arg;
BGET_U16(arg);
- CvFLAGS(bytecode_sv) = arg;
+ CvFLAGS(bstate->bs_sv) = arg;
break;
}
- case INSN_AV_EXTEND: /* 53 */
+ case INSN_AV_EXTEND: /* 54 */
{
SSize_t arg;
BGET_I32(arg);
- BSET_av_extend(bytecode_sv, arg);
+ BSET_av_extend(bstate->bs_sv, arg);
break;
}
- case INSN_AV_PUSH: /* 54 */
+ case INSN_AV_PUSH: /* 55 */
{
svindex arg;
BGET_svindex(arg);
- BSET_av_push(bytecode_sv, arg);
+ BSET_av_push(bstate->bs_sv, arg);
break;
}
- case INSN_XAV_FILL: /* 55 */
+ case INSN_XAV_FILL: /* 56 */
{
SSize_t arg;
BGET_I32(arg);
- AvFILLp(bytecode_sv) = arg;
+ AvFILLp(bstate->bs_sv) = arg;
break;
}
- case INSN_XAV_MAX: /* 56 */
+ case INSN_XAV_MAX: /* 57 */
{
SSize_t arg;
BGET_I32(arg);
- AvMAX(bytecode_sv) = arg;
+ AvMAX(bstate->bs_sv) = arg;
break;
}
- case INSN_XAV_FLAGS: /* 57 */
+ case INSN_XAV_FLAGS: /* 58 */
{
U8 arg;
BGET_U8(arg);
- AvFLAGS(bytecode_sv) = arg;
+ AvFLAGS(bstate->bs_sv) = arg;
break;
}
- case INSN_XHV_RITER: /* 58 */
+ case INSN_XHV_RITER: /* 59 */
{
I32 arg;
BGET_I32(arg);
- HvRITER(bytecode_sv) = arg;
+ HvRITER(bstate->bs_sv) = arg;
break;
}
- case INSN_XHV_NAME: /* 59 */
+ case INSN_XHV_NAME: /* 60 */
{
pvcontents arg;
BGET_pvcontents(arg);
- HvNAME(bytecode_sv) = arg;
+ HvNAME(bstate->bs_sv) = arg;
break;
}
- case INSN_HV_STORE: /* 60 */
+ case INSN_HV_STORE: /* 61 */
{
svindex arg;
BGET_svindex(arg);
- BSET_hv_store(bytecode_sv, arg);
+ BSET_hv_store(bstate->bs_sv, arg);
break;
}
- case INSN_SV_MAGIC: /* 61 */
+ case INSN_SV_MAGIC: /* 62 */
{
char arg;
BGET_U8(arg);
- BSET_sv_magic(bytecode_sv, arg);
+ BSET_sv_magic(bstate->bs_sv, arg);
break;
}
- case INSN_MG_OBJ: /* 62 */
+ case INSN_MG_OBJ: /* 63 */
{
svindex arg;
BGET_svindex(arg);
- SvMAGIC(bytecode_sv)->mg_obj = arg;
+ SvMAGIC(bstate->bs_sv)->mg_obj = arg;
break;
}
- case INSN_MG_PRIVATE: /* 63 */
+ case INSN_MG_PRIVATE: /* 64 */
{
U16 arg;
BGET_U16(arg);
- SvMAGIC(bytecode_sv)->mg_private = arg;
+ SvMAGIC(bstate->bs_sv)->mg_private = arg;
break;
}
- case INSN_MG_FLAGS: /* 64 */
+ case INSN_MG_FLAGS: /* 65 */
{
U8 arg;
BGET_U8(arg);
- SvMAGIC(bytecode_sv)->mg_flags = arg;
+ SvMAGIC(bstate->bs_sv)->mg_flags = arg;
break;
}
- case INSN_MG_PV: /* 65 */
+ case INSN_MG_PV: /* 66 */
{
pvcontents arg;
BGET_pvcontents(arg);
- BSET_mg_pv(SvMAGIC(bytecode_sv), arg);
+ BSET_mg_pv(SvMAGIC(bstate->bs_sv), arg);
break;
}
- case INSN_XMG_STASH: /* 66 */
+ case INSN_XMG_STASH: /* 67 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&SvSTASH(bytecode_sv) = arg;
+ *(SV**)&SvSTASH(bstate->bs_sv) = arg;
break;
}
- case INSN_GV_FETCHPV: /* 67 */
+ case INSN_GV_FETCHPV: /* 68 */
{
strconst arg;
BGET_strconst(arg);
- BSET_gv_fetchpv(bytecode_sv, arg);
+ BSET_gv_fetchpv(bstate->bs_sv, arg);
break;
}
- case INSN_GV_STASHPV: /* 68 */
+ case INSN_GV_STASHPV: /* 69 */
{
strconst arg;
BGET_strconst(arg);
- BSET_gv_stashpv(bytecode_sv, arg);
+ BSET_gv_stashpv(bstate->bs_sv, arg);
break;
}
- case INSN_GP_SV: /* 69 */
+ case INSN_GP_SV: /* 70 */
{
svindex arg;
BGET_svindex(arg);
- GvSV(bytecode_sv) = arg;
+ GvSV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_REFCNT: /* 70 */
+ case INSN_GP_REFCNT: /* 71 */
{
U32 arg;
BGET_U32(arg);
- GvREFCNT(bytecode_sv) = arg;
+ GvREFCNT(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_REFCNT_ADD: /* 71 */
+ case INSN_GP_REFCNT_ADD: /* 72 */
{
I32 arg;
BGET_I32(arg);
- BSET_gp_refcnt_add(GvREFCNT(bytecode_sv), arg);
+ BSET_gp_refcnt_add(GvREFCNT(bstate->bs_sv), arg);
break;
}
- case INSN_GP_AV: /* 72 */
+ case INSN_GP_AV: /* 73 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&GvAV(bytecode_sv) = arg;
+ *(SV**)&GvAV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_HV: /* 73 */
+ case INSN_GP_HV: /* 74 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&GvHV(bytecode_sv) = arg;
+ *(SV**)&GvHV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_CV: /* 74 */
+ case INSN_GP_CV: /* 75 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&GvCV(bytecode_sv) = arg;
+ *(SV**)&GvCV(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_FILE: /* 75 */
+ case INSN_GP_FILE: /* 76 */
{
- pvcontents arg;
- BGET_pvcontents(arg);
- GvFILE(bytecode_sv) = arg;
+ pvindex arg;
+ BGET_pvindex(arg);
+ GvFILE(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_IO: /* 76 */
+ case INSN_GP_IO: /* 77 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&GvIOp(bytecode_sv) = arg;
+ *(SV**)&GvIOp(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_FORM: /* 77 */
+ case INSN_GP_FORM: /* 78 */
{
svindex arg;
BGET_svindex(arg);
- *(SV**)&GvFORM(bytecode_sv) = arg;
+ *(SV**)&GvFORM(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_CVGEN: /* 78 */
+ case INSN_GP_CVGEN: /* 79 */
{
U32 arg;
BGET_U32(arg);
- GvCVGEN(bytecode_sv) = arg;
+ GvCVGEN(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_LINE: /* 79 */
+ case INSN_GP_LINE: /* 80 */
{
line_t arg;
BGET_U16(arg);
- GvLINE(bytecode_sv) = arg;
+ GvLINE(bstate->bs_sv) = arg;
break;
}
- case INSN_GP_SHARE: /* 80 */
+ case INSN_GP_SHARE: /* 81 */
{
svindex arg;
BGET_svindex(arg);
- BSET_gp_share(bytecode_sv, arg);
+ BSET_gp_share(bstate->bs_sv, arg);
break;
}
- case INSN_XGV_FLAGS: /* 81 */
+ case INSN_XGV_FLAGS: /* 82 */
{
U8 arg;
BGET_U8(arg);
- GvFLAGS(bytecode_sv) = arg;
+ GvFLAGS(bstate->bs_sv) = arg;
break;
}
- case INSN_OP_NEXT: /* 82 */
+ case INSN_OP_NEXT: /* 83 */
{
opindex arg;
BGET_opindex(arg);
PL_op->op_next = arg;
break;
}
- case INSN_OP_SIBLING: /* 83 */
+ case INSN_OP_SIBLING: /* 84 */
{
opindex arg;
BGET_opindex(arg);
PL_op->op_sibling = arg;
break;
}
- case INSN_OP_PPADDR: /* 84 */
+ case INSN_OP_PPADDR: /* 85 */
{
strconst arg;
BGET_strconst(arg);
BSET_op_ppaddr(PL_op->op_ppaddr, arg);
break;
}
- case INSN_OP_TARG: /* 85 */
+ case INSN_OP_TARG: /* 86 */
{
PADOFFSET arg;
BGET_U32(arg);
PL_op->op_targ = arg;
break;
}
- case INSN_OP_TYPE: /* 86 */
+ case INSN_OP_TYPE: /* 87 */
{
OPCODE arg;
BGET_U16(arg);
BSET_op_type(PL_op, arg);
break;
}
- case INSN_OP_SEQ: /* 87 */
+ case INSN_OP_SEQ: /* 88 */
{
U16 arg;
BGET_U16(arg);
PL_op->op_seq = arg;
break;
}
- case INSN_OP_FLAGS: /* 88 */
+ case INSN_OP_FLAGS: /* 89 */
{
U8 arg;
BGET_U8(arg);
PL_op->op_flags = arg;
break;
}
- case INSN_OP_PRIVATE: /* 89 */
+ case INSN_OP_PRIVATE: /* 90 */
{
U8 arg;
BGET_U8(arg);
PL_op->op_private = arg;
break;
}
- case INSN_OP_FIRST: /* 90 */
+ case INSN_OP_FIRST: /* 91 */
{
opindex arg;
BGET_opindex(arg);
cUNOP->op_first = arg;
break;
}
- case INSN_OP_LAST: /* 91 */
+ case INSN_OP_LAST: /* 92 */
{
opindex arg;
BGET_opindex(arg);
cBINOP->op_last = arg;
break;
}
- case INSN_OP_OTHER: /* 92 */
+ case INSN_OP_OTHER: /* 93 */
{
opindex arg;
BGET_opindex(arg);
cLOGOP->op_other = arg;
break;
}
- case INSN_OP_CHILDREN: /* 93 */
+ case INSN_OP_CHILDREN: /* 94 */
{
U32 arg;
BGET_U32(arg);
cLISTOP->op_children = 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 */
{
- pvcontents arg;
- BGET_pvcontents(arg);
+ pvindex arg;
+ BGET_pvindex(arg);
cCOP->cop_label = arg;
break;
}
- case INSN_COP_STASHPV: /* 109 */
+ case INSN_COP_STASHPV: /* 110 */
{
- pvcontents arg;
- BGET_pvcontents(arg);
+ pvindex arg;
+ BGET_pvindex(arg);
BSET_cop_stashpv(cCOP, arg);
break;
}
- case INSN_COP_FILE: /* 110 */
+ case INSN_COP_FILE: /* 111 */
{
- pvcontents arg;
- BGET_pvcontents(arg);
+ 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);
diff --git a/ext/ByteLoader/byterun.h b/ext/ByteLoader/byterun.h
index 52f6241..1e67b89 100644
--- a/ext/ByteLoader/byterun.h
+++ b/ext/ByteLoader/byterun.h
@@ -8,136 +8,149 @@
/*
* This file is autogenerated from bytecode.pl. Changes made here will be lost.
*/
-struct bytestream { /* XXX: not currently used - too slow */
- void *data;
- int (*pfgetc)(void *);
- int (*pfread)(char *, size_t, size_t, void *);
- void (*pfreadpv)(U32, void *, XPV *);
+struct byteloader_fdata {
+ SV *datasv;
+ int next_out;
+ int idx;
};
+struct byteloader_state {
+ struct byteloader_fdata *bs_fdata;
+ SV *bs_sv;
+ void **bs_obj_list;
+ int bs_obj_list_fill;
+ XPV bs_pv;
+ int bs_iv_overflows;
+};
+
+int bl_getc(struct byteloader_fdata *);
+int bl_read(struct byteloader_fdata *, char *, size_t, size_t);
+extern void byterun(pTHXo_ struct byteloader_state *);
+
enum {
INSN_RET, /* 0 */
INSN_LDSV, /* 1 */
INSN_LDOP, /* 2 */
INSN_STSV, /* 3 */
INSN_STOP, /* 4 */
- INSN_LDSPECSV, /* 5 */
- INSN_NEWSV, /* 6 */
- INSN_NEWOP, /* 7 */
- INSN_NEWOPN, /* 8 */
- INSN_NEWPV, /* 9 */
+ INSN_STPV, /* 5 */
+ INSN_LDSPECSV, /* 6 */
+ INSN_NEWSV, /* 7 */
+ INSN_NEWOP, /* 8 */
+ INSN_NEWOPN, /* 9 */
INSN_NOP, /* 10 */
- INSN_PV_CUR, /* 11 */
- INSN_PV_FREE, /* 12 */
- INSN_SV_UPGRADE, /* 13 */
- INSN_SV_REFCNT, /* 14 */
- INSN_SV_REFCNT_ADD, /* 15 */
- INSN_SV_FLAGS, /* 16 */
- INSN_XRV, /* 17 */
- INSN_XPV, /* 18 */
- INSN_XIV32, /* 19 */
- INSN_XIV64, /* 20 */
- INSN_XNV, /* 21 */
- INSN_XLV_TARGOFF, /* 22 */
- INSN_XLV_TARGLEN, /* 23 */
- INSN_XLV_TARG, /* 24 */
- INSN_XLV_TYPE, /* 25 */
- INSN_XBM_USEFUL, /* 26 */
- INSN_XBM_PREVIOUS, /* 27 */
- INSN_XBM_RARE, /* 28 */
- INSN_XFM_LINES, /* 29 */
- INSN_XIO_LINES, /* 30 */
- INSN_XIO_PAGE, /* 31 */
- INSN_XIO_PAGE_LEN, /* 32 */
- INSN_XIO_LINES_LEFT, /* 33 */
- INSN_XIO_TOP_NAME, /* 34 */
+ INSN_NEWPV, /* 11 */
+ INSN_PV_CUR, /* 12 */
+ INSN_PV_FREE, /* 13 */
+ INSN_SV_UPGRADE, /* 14 */
+ INSN_SV_REFCNT, /* 15 */
+ INSN_SV_REFCNT_ADD, /* 16 */
+ INSN_SV_FLAGS, /* 17 */
+ INSN_XRV, /* 18 */
+ INSN_XPV, /* 19 */
+ INSN_XIV32, /* 20 */
+ INSN_XIV64, /* 21 */
+ INSN_XNV, /* 22 */
+ INSN_XLV_TARGOFF, /* 23 */
+ INSN_XLV_TARGLEN, /* 24 */
+ INSN_XLV_TARG, /* 25 */
+ INSN_XLV_TYPE, /* 26 */
+ INSN_XBM_USEFUL, /* 27 */
+ INSN_XBM_PREVIOUS, /* 28 */
+ INSN_XBM_RARE, /* 29 */
+ INSN_XFM_LINES, /* 30 */
+ INSN_XIO_LINES, /* 31 */
+ INSN_XIO_PAGE, /* 32 */
+ INSN_XIO_PAGE_LEN, /* 33 */
+ INSN_XIO_LINES_LEFT, /* 34 */
INSN_COMMENT, /* 35 */
- INSN_XIO_TOP_GV, /* 36 */
- INSN_XIO_FMT_NAME, /* 37 */
- INSN_XIO_FMT_GV, /* 38 */
- INSN_XIO_BOTTOM_NAME, /* 39 */
- INSN_XIO_BOTTOM_GV, /* 40 */
- INSN_XIO_SUBPROCESS, /* 41 */
- INSN_XIO_TYPE, /* 42 */
- INSN_XIO_FLAGS, /* 43 */
- INSN_XCV_STASH, /* 44 */
- INSN_XCV_START, /* 45 */
- INSN_XCV_ROOT, /* 46 */
- INSN_XCV_GV, /* 47 */
- INSN_XCV_FILE, /* 48 */
- INSN_XCV_DEPTH, /* 49 */
- INSN_XCV_PADLIST, /* 50 */
- INSN_XCV_OUTSIDE, /* 51 */
- INSN_XCV_FLAGS, /* 52 */
- INSN_AV_EXTEND, /* 53 */
- INSN_AV_PUSH, /* 54 */
- INSN_XAV_FILL, /* 55 */
- INSN_XAV_MAX, /* 56 */
- INSN_XAV_FLAGS, /* 57 */
- INSN_XHV_RITER, /* 58 */
- INSN_XHV_NAME, /* 59 */
- INSN_HV_STORE, /* 60 */
- INSN_SV_MAGIC, /* 61 */
- INSN_MG_OBJ, /* 62 */
- INSN_MG_PRIVATE, /* 63 */
- INSN_MG_FLAGS, /* 64 */
- INSN_MG_PV, /* 65 */
- INSN_XMG_STASH, /* 66 */
- INSN_GV_FETCHPV, /* 67 */
- INSN_GV_STASHPV, /* 68 */
- INSN_GP_SV, /* 69 */
- INSN_GP_REFCNT, /* 70 */
- INSN_GP_REFCNT_ADD, /* 71 */
- INSN_GP_AV, /* 72 */
- INSN_GP_HV, /* 73 */
- INSN_GP_CV, /* 74 */
- INSN_GP_FILE, /* 75 */
- INSN_GP_IO, /* 76 */
- INSN_GP_FORM, /* 77 */
- INSN_GP_CVGEN, /* 78 */
- INSN_GP_LINE, /* 79 */
- INSN_GP_SHARE, /* 80 */
- INSN_XGV_FLAGS, /* 81 */
- INSN_OP_NEXT, /* 82 */
- INSN_OP_SIBLING, /* 83 */
- INSN_OP_PPADDR, /* 84 */
- INSN_OP_TARG, /* 85 */
- INSN_OP_TYPE, /* 86 */
- INSN_OP_SEQ, /* 87 */
- INSN_OP_FLAGS, /* 88 */
- INSN_OP_PRIVATE, /* 89 */
- INSN_OP_FIRST, /* 90 */
- INSN_OP_LAST, /* 91 */
- INSN_OP_OTHER, /* 92 */
- INSN_OP_CHILDREN, /* 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_XIO_TOP_NAME, /* 36 */
+ INSN_XIO_TOP_GV, /* 37 */
+ INSN_XIO_FMT_NAME, /* 38 */
+ INSN_XIO_FMT_GV, /* 39 */
+ INSN_XIO_BOTTOM_NAME, /* 40 */
+ INSN_XIO_BOTTOM_GV, /* 41 */
+ INSN_XIO_SUBPROCESS, /* 42 */
+ INSN_XIO_TYPE, /* 43 */
+ INSN_XIO_FLAGS, /* 44 */
+ INSN_XCV_STASH, /* 45 */
+ INSN_XCV_START, /* 46 */
+ INSN_XCV_ROOT, /* 47 */
+ INSN_XCV_GV, /* 48 */
+ INSN_XCV_FILE, /* 49 */
+ 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_CHILDREN, /* 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 {
@@ -154,4 +167,3 @@ enum {
OPt_COP /* 10 */
};
-extern void byterun(pTHXo);
diff --git a/global.sym b/global.sym
index 1d7eb97..8a9b008 100644
--- a/global.sym
+++ b/global.sym
@@ -460,6 +460,8 @@ Perl_utf16_to_utf8
Perl_utf16_to_utf8_reversed
Perl_utf8_distance
Perl_utf8_hop
+Perl_utf8_to_bytes
+Perl_bytes_to_utf8
Perl_utf8_to_uv
Perl_uv_to_utf8
Perl_warn
diff --git a/objXSUB.h b/objXSUB.h
index 23077d4..ad5aa09 100644
--- a/objXSUB.h
+++ b/objXSUB.h
@@ -1849,6 +1849,14 @@
#define Perl_utf8_hop pPerl->Perl_utf8_hop
#undef utf8_hop
#define utf8_hop Perl_utf8_hop
+#undef Perl_utf8_to_bytes
+#define Perl_utf8_to_bytes pPerl->Perl_utf8_to_bytes
+#undef utf8_to_bytes
+#define utf8_to_bytes Perl_utf8_to_bytes
+#undef Perl_bytes_to_utf8
+#define Perl_bytes_to_utf8 pPerl->Perl_bytes_to_utf8
+#undef bytes_to_utf8
+#define bytes_to_utf8 Perl_bytes_to_utf8
#undef Perl_utf8_to_uv
#define Perl_utf8_to_uv pPerl->Perl_utf8_to_uv
#undef utf8_to_uv
diff --git a/perlapi.c b/perlapi.c
index 396e101..a911be2 100755
--- a/perlapi.c
+++ b/perlapi.c
@@ -3343,6 +3343,20 @@ Perl_utf8_hop(pTHXo_ U8 *s, I32 off)
return ((CPerlObj*)pPerl)->Perl_utf8_hop(s, off);
}
+#undef Perl_utf8_to_bytes
+U8*
+Perl_utf8_to_bytes(pTHXo_ U8 *s, STRLEN len)
+{
+ return ((CPerlObj*)pPerl)->Perl_utf8_to_bytes(s, len);
+}
+
+#undef Perl_bytes_to_utf8
+U8*
+Perl_bytes_to_utf8(pTHXo_ U8 *s, STRLEN len)
+{
+ return ((CPerlObj*)pPerl)->Perl_bytes_to_utf8(s, len);
+}
+
#undef Perl_utf8_to_uv
UV
Perl_utf8_to_uv(pTHXo_ U8 *s, I32* retlen)
diff --git a/pod/perlapi.pod b/pod/perlapi.pod
index 9b3d20a..6e504c1 100644
--- a/pod/perlapi.pod
+++ b/pod/perlapi.pod
@@ -25,6 +25,9 @@ Same as C<av_len()>. Deprecated, use C<av_len()> instead.
int AvFILL(AV* av)
+=for hackers
+Found in file av.h
+
=item av_clear
Clears an array, making it empty. Does not free the memory used by the
@@ -32,6 +35,9 @@ array itself.
void av_clear(AV* ar)
+=for hackers
+Found in file av.c
+
=item av_extend
Pre-extend an array. The C<key> is the index to which the array should be
@@ -39,6 +45,9 @@ extended.
void av_extend(AV* ar, I32 key)
+=for hackers
+Found in file av.c
+
=item av_fetch
Returns the SV at the specified index in the array. The C<key> is the
@@ -50,6 +59,9 @@ more information on how to use this function on tied arrays.
SV** av_fetch(AV* ar, I32 key, I32 lval)
+=for hackers
+Found in file av.c
+
=item av_len
Returns the highest index in the array. Returns -1 if the array is
@@ -57,6 +69,9 @@ empty.
I32 av_len(AV* ar)
+=for hackers
+Found in file av.c
+
=item av_make
Creates a new AV and populates it with a list of SVs. The SVs are copied
@@ -65,6 +80,9 @@ will have a reference count of 1.
AV* av_make(I32 size, SV** svp)
+=for hackers
+Found in file av.c
+
=item av_pop
Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array
@@ -72,6 +90,9 @@ is empty.
SV* av_pop(AV* ar)
+=for hackers
+Found in file av.c
+
=item av_push
Pushes an SV onto the end of the array. The array will grow automatically
@@ -79,12 +100,18 @@ to accommodate the addition.
void av_push(AV* ar, SV* val)
+=for hackers
+Found in file av.c
+
=item av_shift
Shifts an SV off the beginning of the array.
SV* av_shift(AV* ar)
+=for hackers
+Found in file av.c
+
=item av_store
Stores an SV in an array. The array index is specified as C<key>. The
@@ -100,12 +127,18 @@ more information on how to use this function on tied arrays.
SV** av_store(AV* ar, I32 key, SV* val)
+=for hackers
+Found in file av.c
+
=item av_undef
Undefines the array. Frees the memory used by the array itself.
void av_undef(AV* ar)
+=for hackers
+Found in file av.c
+
=item av_unshift
Unshift the given number of C<undef> values onto the beginning of the
@@ -114,6 +147,9 @@ must then use C<av_store> to assign values to these new elements.
void av_unshift(AV* ar, I32 num)
+=for hackers
+Found in file av.c
+
=item call_argv
Performs a callback to the specified Perl sub. See L<perlcall>.
@@ -122,6 +158,9 @@ NOTE: the perl_ form of this function is deprecated.
I32 call_argv(const char* sub_name, I32 flags, char** argv)
+=for hackers
+Found in file perl.c
+
=item call_method
Performs a callback to the specified Perl method. The blessed object must
@@ -131,6 +170,9 @@ NOTE: the perl_ form of this function is deprecated.
I32 call_method(const char* methname, I32 flags)
+=for hackers
+Found in file perl.c
+
=item call_pv
Performs a callback to the specified Perl sub. See L<perlcall>.
@@ -139,6 +181,9 @@ NOTE: the perl_ form of this function is deprecated.
I32 call_pv(const char* sub_name, I32 flags)
+=for hackers
+Found in file perl.c
+
=item call_sv
Performs a callback to the Perl sub whose name is in the SV. See
@@ -148,6 +193,9 @@ NOTE: the perl_ form of this function is deprecated.
I32 call_sv(SV* sv, I32 flags)
+=for hackers
+Found in file perl.c
+
=item CLASS
Variable which is setup by C<xsubpp> to indicate the
@@ -155,6 +203,9 @@ class name for a C++ XS constructor. This is always a C<char*>. See C<THIS>.
char* CLASS
+=for hackers
+Found in file XSUB.h
+
=item Copy
The XSUB-writer's interface to the C C<memcpy> function. The C<src> is the
@@ -163,6 +214,9 @@ the type. May fail on overlapping copies. See also C<Move>.
void Copy(void* src, void* dest, int nitems, type)
+=for hackers
+Found in file handy.h
+
=item croak
This is the XSUB-writer's interface to Perl's C<die> function.
@@ -178,12 +232,18 @@ C<$@> and then pass C<Nullch> to croak():
void croak(const char* pat, ...)
+=for hackers
+Found in file util.c
+
=item CvSTASH
Returns the stash of the CV.
HV* CvSTASH(CV* cv)
+=for hackers
+Found in file cv.h
+
=item dMARK
Declare a stack marker variable, C<mark>, for the XSUB. See C<MARK> and
@@ -191,12 +251,18 @@ C<dORIGMARK>.
dMARK;
+=for hackers
+Found in file pp.h
+
=item dORIGMARK
Saves the original stack mark for the XSUB. See C<ORIGMARK>.
dORIGMARK;
+=for hackers
+Found in file pp.h
+
=item dSP
Declares a local copy of perl's stack pointer for the XSUB, available via
@@ -204,6 +270,9 @@ the C<SP> macro. See C<SP>.
dSP;
+=for hackers
+Found in file pp.h
+
=item dXSARGS
Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. This
@@ -212,6 +281,9 @@ variable to indicate the number of items on the stack.
dXSARGS;
+=for hackers
+Found in file XSUB.h
+
=item dXSI32
Sets up the C<ix> variable for an XSUB which has aliases. This is usually
@@ -219,12 +291,18 @@ handled automatically by C<xsubpp>.
dXSI32;
+=for hackers
+Found in file XSUB.h
+
=item ENTER
Opening bracket on a callback. See C<LEAVE> and L<perlcall>.
ENTER;
+=for hackers
+Found in file scope.h
+
=item eval_pv
Tells Perl to C<eval> the given string and return an SV* result.
@@ -233,6 +311,9 @@ NOTE: the perl_ form of this function is deprecated.
SV* eval_pv(const char* p, I32 croak_on_error)
+=for hackers
+Found in file perl.c
+
=item eval_sv
Tells Perl to C<eval> the string in the SV.
@@ -241,6 +322,9 @@ NOTE: the perl_ form of this function is deprecated.
I32 eval_sv(SV* sv, I32 flags)
+=for hackers
+Found in file perl.c
+
=item EXTEND
Used to extend the argument stack for an XSUB's return values. Once
@@ -249,6 +333,9 @@ onto the stack.
void EXTEND(SP, int nitems)
+=for hackers
+Found in file pp.h
+
=item fbm_compile
Analyses the string in order to make fast searches on it using fbm_instr()
@@ -256,6 +343,9 @@ Analyses the string in order to make fast searches on it using fbm_instr()
void fbm_compile(SV* sv, U32 flags)
+=for hackers
+Found in file util.c
+
=item fbm_instr
Returns the location of the SV in the string delimited by C<str> and
@@ -265,6 +355,9 @@ then.
char* fbm_instr(unsigned char* big, unsigned char* bigend, SV* littlesv, U32 flags)
+=for hackers
+Found in file util.c
+
=item FREETMPS
Closing bracket for temporaries on a callback. See C<SAVETMPS> and
@@ -272,6 +365,9 @@ L<perlcall>.
FREETMPS;
+=for hackers
+Found in file scope.h
+
=item get_av
Returns the AV of the specified Perl array. If C<create> is set and the
@@ -282,6 +378,9 @@ NOTE: the perl_ form of this function is deprecated.
AV* get_av(const char* name, I32 create)
+=for hackers
+Found in file perl.c
+
=item get_cv
Returns the CV of the specified Perl subroutine. If C<create> is set and
@@ -293,6 +392,9 @@ NOTE: the perl_ form of this function is deprecated.
CV* get_cv(const char* name, I32 create)
+=for hackers
+Found in file perl.c
+
=item get_hv
Returns the HV of the specified Perl hash. If C<create> is set and the
@@ -303,6 +405,9 @@ NOTE: the perl_ form of this function is deprecated.
HV* get_hv(const char* name, I32 create)
+=for hackers
+Found in file perl.c
+
=item get_sv
Returns the SV of the specified Perl scalar. If C<create> is set and the
@@ -313,6 +418,9 @@ NOTE: the perl_ form of this function is deprecated.
SV* get_sv(const char* name, I32 create)
+=for hackers
+Found in file perl.c
+
=item GIMME
A backward-compatible version of C<GIMME_V> which can only return
@@ -321,6 +429,9 @@ Deprecated. Use C<GIMME_V> instead.
U32 GIMME
+=for hackers
+Found in file op.h
+
=item GIMME_V
The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>,
@@ -329,12 +440,18 @@ respectively.
U32 GIMME_V
+=for hackers
+Found in file op.h
+
=item GvSV
Return the SV from the GV.
SV* GvSV(GV* gv)
+=for hackers
+Found in file gv.h
+
=item gv_fetchmeth
Returns the glob with the given C<name> and a defined subroutine or
@@ -354,12 +471,18 @@ obtained from the GV with the C<GvCV> macro.
GV* gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)
+=for hackers
+Found in file gv.c
+
=item gv_fetchmethod
See L<gv_fetchmethod_autoload>.
GV* gv_fetchmethod(HV* stash, const char* name)
+=for hackers
+Found in file gv.c
+
=item gv_fetchmethod_autoload
Returns the glob which contains the subroutine to call to invoke the method
@@ -386,6 +509,9 @@ C<call_sv> apply equally to these functions.
GV* gv_fetchmethod_autoload(HV* stash, const char* name, I32 autoload)
+=for hackers
+Found in file gv.c
+
=item gv_stashpv
Returns a pointer to the stash for a specified package. C<name> should
@@ -395,6 +521,9 @@ package does not exist then NULL is returned.
HV* gv_stashpv(const char* name, I32 create)
+=for hackers
+Found in file gv.c
+
=item gv_stashsv
Returns a pointer to the stash for a specified package, which must be a
@@ -402,47 +531,74 @@ valid UTF-8 string. See C<gv_stashpv>.
HV* gv_stashsv(SV* sv, I32 create)
+=for hackers
+Found in file gv.c
+
=item G_ARRAY
Used to indicate array context. See C<GIMME_V>, C<GIMME> and
L<perlcall>.
+=for hackers
+Found in file cop.h
+
=item G_DISCARD
Indicates that arguments returned from a callback should be discarded. See
L<perlcall>.
+=for hackers
+Found in file cop.h
+
=item G_EVAL
Used to force a Perl C<eval> wrapper around a callback. See
L<perlcall>.
+=for hackers
+Found in file cop.h
+
=item G_NOARGS
Indicates that no arguments are being sent to a callback. See
L<perlcall>.
+=for hackers
+Found in file cop.h
+
=item G_SCALAR
Used to indicate scalar context. See C<GIMME_V>, C<GIMME>, and
L<perlcall>.
+=for hackers
+Found in file cop.h
+
=item G_VOID
Used to indicate void context. See C<GIMME_V> and L<perlcall>.
+=for hackers
+Found in file cop.h
+
=item HEf_SVKEY
This flag, used in the length slot of hash entries and magic structures,
specifies the structure contains a C<SV*> pointer where a C<char*> pointer
is to be expected. (For information only--not to be used).
+=for hackers
+Found in file hv.h
+
=item HeHASH
Returns the computed hash stored in the hash entry.
U32 HeHASH(HE* he)
+=for hackers
+Found in file hv.h
+
=item HeKEY
Returns the actual pointer stored in the key slot of the hash entry. The
@@ -452,6 +608,9 @@ usually preferable for finding the value of a key.
void* HeKEY(HE* he)
+=for hackers
+Found in file hv.h
+
=item HeKLEN
If this is negative, and amounts to C<HEf_SVKEY>, it indicates the entry
@@ -461,6 +620,9 @@ lengths.
STRLEN HeKLEN(HE* he)
+=for hackers
+Found in file hv.h
+
=item HePV
Returns the key slot of the hash entry as a C<char*> value, doing any
@@ -475,6 +637,9 @@ described elsewhere in this document.
char* HePV(HE* he, STRLEN len)
+=for hackers
+Found in file hv.h
+
=item HeSVKEY
Returns the key as an C<SV*>, or C<Nullsv> if the hash entry does not
@@ -482,6 +647,9 @@ contain an C<SV*> key.
SV* HeSVKEY(HE* he)
+=for hackers
+Found in file hv.h
+
=item HeSVKEY_force
Returns the key as an C<SV*>. Will create and return a temporary mortal
@@ -489,6 +657,9 @@ C<SV*> if the hash entry contains only a C<char*> key.
SV* HeSVKEY_force(HE* he)
+=for hackers
+Found in file hv.h
+
=item HeSVKEY_set
Sets the key to a given C<SV*>, taking care to set the appropriate flags to
@@ -497,24 +668,36 @@ C<SV*>.
SV* HeSVKEY_set(HE* he, SV* sv)
+=for hackers
+Found in file hv.h
+
=item HeVAL
Returns the value slot (type C<SV*>) stored in the hash entry.
SV* HeVAL(HE* he)
+=for hackers
+Found in file hv.h
+
=item HvNAME
Returns the package name of a stash. See C<SvSTASH>, C<CvSTASH>.
char* HvNAME(HV* stash)
+=for hackers
+Found in file hv.h
+
=item hv_clear
Clears a hash, making it empty.
void hv_clear(HV* tb)
+=for hackers
+Found in file hv.c
+
=item hv_delete
Deletes a key/value pair in the hash. The value SV is removed from the
@@ -524,6 +707,9 @@ will be returned.
SV* hv_delete(HV* tb, const char* key, U32 klen, I32 flags)
+=for hackers
+Found in file hv.c
+
=item hv_delete_ent
Deletes a key/value pair in the hash. The value SV is removed from the
@@ -533,6 +719,9 @@ precomputed hash value, or 0 to ask for it to be computed.
SV* hv_delete_ent(HV* tb, SV* key, I32 flags, U32 hash)
+=for hackers
+Found in file hv.c
+
=item hv_exists
Returns a boolean indicating whether the specified hash key exists. The
@@ -540,6 +729,9 @@ C<klen> is the length of the key.
bool hv_exists(HV* tb, const char* key, U32 klen)
+=for hackers
+Found in file hv.c
+
=item hv_exists_ent
Returns a boolean indicating whether the specified hash key exists. C<hash>
@@ -548,6 +740,9 @@ computed.
bool hv_exists_ent(HV* tb, SV* key, U32 hash)
+=for hackers
+Found in file hv.c
+
=item hv_fetch
Returns the SV which corresponds to the specified key in the hash. The
@@ -560,6 +755,9 @@ information on how to use this function on tied hashes.
SV** hv_fetch(HV* tb, const char* key, U32 klen, I32 lval)
+=for hackers
+Found in file hv.c
+
=item hv_fetch_ent
Returns the hash entry which corresponds to the specified key in the hash.
@@ -575,6 +773,9 @@ information on how to use this function on tied hashes.
HE* hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash)
+=for hackers
+Found in file hv.c
+
=item hv_iterinit
Prepares a starting point to traverse a hash table. Returns the number of
@@ -587,6 +788,9 @@ value, you can get it through the macro C<HvFILL(tb)>.
I32 hv_iterinit(HV* tb)
+=for hackers
+Found in file hv.c
+
=item hv_iterkey
Returns the key from the current position of the hash iterator. See
@@ -594,6 +798,9 @@ C<hv_iterinit>.
char* hv_iterkey(HE* entry, I32* retlen)
+=for hackers
+Found in file hv.c
+
=item hv_iterkeysv
Returns the key as an C<SV*> from the current position of the hash
@@ -602,12 +809,18 @@ see C<hv_iterinit>.
SV* hv_iterkeysv(HE* entry)
+=for hackers
+Found in file hv.c
+
=item hv_iternext
Returns entries from a hash iterator. See C<hv_iterinit>.
HE* hv_iternext(HV* tb)
+=for hackers
+Found in file hv.c
+
=item hv_iternextsv
Performs an C<hv_iternext>, C<hv_iterkey>, and C<hv_iterval> in one
@@ -615,6 +828,9 @@ operation.
SV* hv_iternextsv(HV* hv, char** key, I32* retlen)
+=for hackers
+Found in file hv.c
+
=item hv_iterval
Returns the value from the current position of the hash iterator. See
@@ -622,12 +838,18 @@ C<hv_iterkey>.
SV* hv_iterval(HV* tb, HE* entry)
+=for hackers
+Found in file hv.c
+
=item hv_magic
Adds magic to a hash. See C<sv_magic>.
void hv_magic(HV* hv, GV* gv, int how)
+=for hackers
+Found in file hv.c
+
=item hv_store
Stores an SV in a hash. The hash key is specified as C<key> and C<klen> is
@@ -644,6 +866,9 @@ information on how to use this function on tied hashes.
SV** hv_store(HV* tb, const char* key, U32 klen, SV* val, U32 hash)
+=for hackers
+Found in file hv.c
+
=item hv_store_ent
Stores C<val> in a hash. The hash key is specified as C<key>. The C<hash>
@@ -661,12 +886,18 @@ information on how to use this function on tied hashes.
HE* hv_store_ent(HV* tb, SV* key, SV* val, U32 hash)
+=for hackers
+Found in file hv.c
+
=item hv_undef
Undefines the hash.
void hv_undef(HV* tb)
+=for hackers
+Found in file hv.c
+
=item isALNUM
Returns a boolean indicating whether the C C<char> is an ASCII alphanumeric
@@ -674,6 +905,9 @@ character (including underscore) or digit.
bool isALNUM(char ch)
+=for hackers
+Found in file handy.h
+
=item isALPHA
Returns a boolean indicating whether the C C<char> is an ASCII alphabetic
@@ -681,6 +915,9 @@ character.
bool isALPHA(char ch)
+=for hackers
+Found in file handy.h
+
=item isDIGIT
Returns a boolean indicating whether the C C<char> is an ASCII
@@ -688,6 +925,9 @@ digit.
bool isDIGIT(char ch)
+=for hackers
+Found in file handy.h
+
=item isLOWER
Returns a boolean indicating whether the C C<char> is a lowercase
@@ -695,12 +935,18 @@ character.
bool isLOWER(char ch)
+=for hackers
+Found in file handy.h
+
=item isSPACE
Returns a boolean indicating whether the C C<char> is whitespace.
bool isSPACE(char ch)
+=for hackers
+Found in file handy.h
+
=item isUPPER
Returns a boolean indicating whether the C C<char> is an uppercase
@@ -708,6 +954,9 @@ character.
bool isUPPER(char ch)
+=for hackers
+Found in file handy.h
+
=item items
Variable which is setup by C<xsubpp> to indicate the number of
@@ -715,6 +964,9 @@ items on the stack. See L<perlxs/"Variable-length Parameter Lists">.
I32 items
+=for hackers
+Found in file XSUB.h
+
=item ix
Variable which is setup by C<xsubpp> to indicate which of an
@@ -722,12 +974,18 @@ XSUB's aliases was used to invoke it. See L<perlxs/"The ALIAS: Keyword">.
I32 ix
+=for hackers
+Found in file XSUB.h
+
=item LEAVE
Closing bracket on a callback. See C<ENTER> and L<perlcall>.
LEAVE;
+=for hackers
+Found in file scope.h
+
=item looks_like_number
Test if an the content of an SV looks like a number (or is a
@@ -735,58 +993,88 @@ number).
I32 looks_like_number(SV* sv)
+=for hackers
+Found in file sv.c
+
=item MARK
Stack marker variable for the XSUB. See C<dMARK>.
+=for hackers
+Found in file pp.h
+
=item mg_clear
Clear something magical that the SV represents. See C<sv_magic>.
int mg_clear(SV* sv)
+=for hackers
+Found in file mg.c
+
=item mg_copy
Copies the magic from one SV to another. See C<sv_magic>.
int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)
+=for hackers
+Found in file mg.c
+
=item mg_find
Finds the magic pointer for type matching the SV. See C<sv_magic>.
MAGIC* mg_find(SV* sv, int type)
+=for hackers
+Found in file mg.c
+
=item mg_free
Free any magic storage used by the SV. See C<sv_magic>.
int mg_free(SV* sv)
+=for hackers
+Found in file mg.c
+
=item mg_get
Do magic after a value is retrieved from the SV. See C<sv_magic>.
int mg_get(SV* sv)
+=for hackers
+Found in file mg.c
+
=item mg_length
Report on the SV's length. See C<sv_magic>.
U32 mg_length(SV* sv)
+=for hackers
+Found in file mg.c
+
=item mg_magical
Turns on the magical status of an SV. See C<sv_magic>.
void mg_magical(SV* sv)
+=for hackers
+Found in file mg.c
+
=item mg_set
Do magic after a value is assigned to the SV. See C<sv_magic>.
int mg_set(SV* sv)
+=for hackers
+Found in file mg.c
+
=item Move
The XSUB-writer's interface to the C C<memmove> function. The C<src> is the
@@ -795,18 +1083,27 @@ the type. Can do overlapping moves. See also C<Copy>.
void Move(void* src, void* dest, int nitems, type)
+=for hackers
+Found in file handy.h
+
=item New
The XSUB-writer's interface to the C C<malloc> function.
void New(int id, void* ptr, int nitems, type)
+=for hackers
+Found in file handy.h
+
=item newAV
Creates a new AV. The reference count is set to 1.
AV* newAV()
+=for hackers
+Found in file av.c
+
=item Newc
The XSUB-writer's interface to the C C<malloc> function, with
@@ -814,6 +1111,9 @@ cast.
void Newc(int id, void* ptr, int nitems, type, cast)
+=for hackers
+Found in file handy.h
+
=item newCONSTSUB
Creates a constant sub equivalent to Perl C<sub FOO () { 123 }> which is
@@ -821,12 +1121,18 @@ eligible for inlining at compile-time.
void newCONSTSUB(HV* stash, char* name, SV* sv)
+=for hackers
+Found in file op.c
+
=item newHV
Creates a new HV. The reference count is set to 1.
HV* newHV()
+=for hackers
+Found in file hv.c
+
=item newRV_inc
Creates an RV wrapper for an SV. The reference count for the original SV is
@@ -834,6 +1140,9 @@ incremented.
SV* newRV_inc(SV* sv)
+=for hackers
+Found in file sv.h
+
=item newRV_noinc
Creates an RV wrapper for an SV. The reference count for the original
@@ -841,6 +1150,9 @@ SV is B<not> incremented.
SV* newRV_noinc(SV *sv)
+=for hackers
+Found in file sv.c
+
=item NEWSV
Creates a new SV. A non-zero C<len> parameter indicates the number of
@@ -851,6 +1163,9 @@ C<id> is an integer id between 0 and 1299 (used to identify leaks).
SV* NEWSV(int id, STRLEN len)
+=for hackers
+Found in file handy.h
+
=item newSViv
Creates a new SV and copies an integer into it. The reference count for the
@@ -858,6 +1173,9 @@ SV is set to 1.
SV* newSViv(IV i)
+=for hackers
+Found in file sv.c
+
=item newSVnv
Creates a new SV and copies a floating point value into it.
@@ -865,6 +1183,9 @@ The reference count for the SV is set to 1.
SV* newSVnv(NV n)
+=for hackers
+Found in file sv.c
+
=item newSVpv
Creates a new SV and copies a string into it. The reference count for the
@@ -873,6 +1194,9 @@ strlen(). For efficiency, consider using C<newSVpvn> instead.
SV* newSVpv(const char* s, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item newSVpvf
Creates a new SV an initialize it with the string formatted like
@@ -880,6 +1204,9 @@ C<sprintf>.
SV* newSVpvf(const char* pat, ...)
+=for hackers
+Found in file sv.c
+
=item newSVpvn
Creates a new SV and copies a string into it. The reference count for the
@@ -889,6 +1216,9 @@ C<len> bytes long.
SV* newSVpvn(const char* s, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item newSVrv
Creates a new SV for the RV, C<rv>, to point to. If C<rv> is not an RV then
@@ -898,12 +1228,18 @@ reference count is 1.
SV* newSVrv(SV* rv, const char* classname)
+=for hackers
+Found in file sv.c
+
=item newSVsv
Creates a new SV which is an exact duplicate of the original SV.
SV* newSVsv(SV* old)
+=for hackers
+Found in file sv.c
+
=item newSVuv
Creates a new SV and copies an unsigned integer into it.
@@ -911,15 +1247,24 @@ The reference count for the SV is set to 1.
SV* newSVuv(UV u)
+=for hackers
+Found in file sv.c
+
=item newXS
Used by C<xsubpp> to hook up XSUBs as Perl subs.
+=for hackers
+Found in file op.c
+
=item newXSproto
Used by C<xsubpp> to hook up XSUBs as Perl subs. Adds Perl prototypes to
the subs.
+=for hackers
+Found in file XSUB.h
+
=item Newz
The XSUB-writer's interface to the C C<malloc> function. The allocated
@@ -927,66 +1272,105 @@ memory is zeroed with C<memzero>.
void Newz(int id, void* ptr, int nitems, type)
+=for hackers
+Found in file handy.h
+
=item Nullav
Null AV pointer.
+=for hackers
+Found in file av.h
+
=item Nullch
Null character pointer.
+=for hackers
+Found in file handy.h
+
=item Nullcv
Null CV pointer.
+=for hackers
+Found in file cv.h
+
=item Nullhv
Null HV pointer.
+=for hackers
+Found in file hv.h
+
=item Nullsv
Null SV pointer.
+=for hackers
+Found in file handy.h
+
=item ORIGMARK
The original stack mark for the XSUB. See C<dORIGMARK>.
+=for hackers
+Found in file pp.h
+
=item perl_alloc
Allocates a new Perl interpreter. See L<perlembed>.
PerlInterpreter* perl_alloc()
+=for hackers
+Found in file perl.c
+
=item perl_construct
Initializes a new Perl interpreter. See L<perlembed>.
void perl_construct(PerlInterpreter* interp)
+=for hackers
+Found in file perl.c
+
=item perl_destruct
Shuts down a Perl interpreter. See L<perlembed>.
void perl_destruct(PerlInterpreter* interp)
+=for hackers
+Found in file perl.c
+
=item perl_free
Releases a Perl interpreter. See L<perlembed>.
void perl_free(PerlInterpreter* interp)
+=for hackers
+Found in file perl.c
+
=item perl_parse
Tells a Perl interpreter to parse a Perl script. See L<perlembed>.
int perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env)
+=for hackers
+Found in file perl.c
+
=item perl_run
Tells a Perl interpreter to run. See L<perlembed>.
int perl_run(PerlInterpreter* interp)
+=for hackers
+Found in file perl.c
+
=item PL_DBsingle
When Perl is run in debugging mode, with the B<-d> switch, this SV is a
@@ -997,6 +1381,9 @@ C<PL_DBsub>.
SV * PL_DBsingle
+=for hackers
+Found in file intrpvar.h
+
=item PL_DBsub
When Perl is run in debugging mode, with the B<-d> switch, this GV contains
@@ -1006,6 +1393,9 @@ C<PL_DBsingle>.
GV * PL_DBsub
+=for hackers
+Found in file intrpvar.h
+
=item PL_DBtrace
Trace variable used when Perl is run in debugging mode, with the B<-d>
@@ -1014,12 +1404,18 @@ variable. See C<PL_DBsingle>.
SV * PL_DBtrace
+=for hackers
+Found in file intrpvar.h
+
=item PL_dowarn
The C variable which corresponds to Perl's $^W warning variable.
bool PL_dowarn
+=for hackers
+Found in file intrpvar.h
+
=item PL_modglobal
C<PL_modglobal> is a general purpose, interpreter global HV for use by
@@ -1030,6 +1426,9 @@ prefixed by the package name of the extension that owns the data.
HV* PL_modglobal
+=for hackers
+Found in file intrpvar.h
+
=item PL_na
A convenience variable which is typically used with C<SvPV> when one
@@ -1039,6 +1438,9 @@ C<SvPV_nolen> macro.
STRLEN PL_na
+=for hackers
+Found in file thrdvar.h
+
=item PL_sv_no
This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as
@@ -1046,12 +1448,18 @@ C<&PL_sv_no>.
SV PL_sv_no
+=for hackers
+Found in file intrpvar.h
+
=item PL_sv_undef
This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>.
SV PL_sv_undef
+=for hackers
+Found in file intrpvar.h
+
=item PL_sv_yes
This is the C<true> SV. See C<PL_sv_no>. Always refer to this as
@@ -1059,36 +1467,54 @@ C<&PL_sv_yes>.
SV PL_sv_yes
+=for hackers
+Found in file intrpvar.h
+
=item POPi
Pops an integer off the stack.
IV POPi
+=for hackers
+Found in file pp.h
+
=item POPl
Pops a long off the stack.
long POPl
+=for hackers
+Found in file pp.h
+
=item POPn
Pops a double off the stack.
NV POPn
+=for hackers
+Found in file pp.h
+
=item POPp
Pops a string off the stack.
char* POPp
+=for hackers
+Found in file pp.h
+
=item POPs
Pops an SV off the stack.
SV* POPs
+=for hackers
+Found in file pp.h
+
=item PUSHi
Push an integer onto the stack. The stack must have room for this element.
@@ -1096,6 +1522,9 @@ Handles 'set' magic. See C<XPUSHi>.
void PUSHi(IV iv)
+=for hackers
+Found in file pp.h
+
=item PUSHMARK
Opening bracket for arguments on a callback. See C<PUTBACK> and
@@ -1103,6 +1532,9 @@ L<perlcall>.
PUSHMARK;
+=for hackers
+Found in file pp.h
+
=item PUSHn
Push a double onto the stack. The stack must have room for this element.
@@ -1110,6 +1542,9 @@ Handles 'set' magic. See C<XPUSHn>.
void PUSHn(NV nv)
+=for hackers
+Found in file pp.h
+
=item PUSHp
Push a string onto the stack. The stack must have room for this element.
@@ -1118,6 +1553,9 @@ C<XPUSHp>.
void PUSHp(char* str, STRLEN len)
+=for hackers
+Found in file pp.h
+
=item PUSHs
Push an SV onto the stack. The stack must have room for this element.
@@ -1125,6 +1563,9 @@ Does not handle 'set' magic. See C<XPUSHs>.
void PUSHs(SV* sv)
+=for hackers
+Found in file pp.h
+
=item PUSHu
Push an unsigned integer onto the stack. The stack must have room for this
@@ -1132,6 +1573,9 @@ element. See C<XPUSHu>.
void PUSHu(UV uv)
+=for hackers
+Found in file pp.h
+
=item PUTBACK
Closing bracket for XSUB arguments. This is usually handled by C<xsubpp>.
@@ -1139,12 +1583,18 @@ See C<PUSHMARK> and L<perlcall> for other uses.
PUTBACK;
+=for hackers
+Found in file pp.h
+
=item Renew
The XSUB-writer's interface to the C C<realloc> function.
void Renew(void* ptr, int nitems, type)
+=for hackers
+Found in file handy.h
+
=item Renewc
The XSUB-writer's interface to the C C<realloc> function, with
@@ -1152,6 +1602,9 @@ cast.
void Renewc(void* ptr, int nitems, type, cast)
+=for hackers
+Found in file handy.h
+
=item require_pv
Tells Perl to C<require> a module.
@@ -1160,6 +1613,9 @@ NOTE: the perl_ form of this function is deprecated.
void require_pv(const char* pv)
+=for hackers
+Found in file perl.c
+
=item RETVAL
Variable which is setup by C<xsubpp> to hold the return value for an
@@ -1168,18 +1624,27 @@ L<perlxs/"The RETVAL Variable">.
(whatever) RETVAL
+=for hackers
+Found in file XSUB.h
+
=item Safefree
The XSUB-writer's interface to the C C<free> function.
void Safefree(void* src, void* dest, int nitems, type)
+=for hackers
+Found in file handy.h
+
=item savepv
Copy a string to a safe spot. This does not use an SV.
char* savepv(const char* sv)
+=for hackers
+Found in file util.c
+
=item savepvn
Copy a string to a safe spot. The C<len> indicates number of bytes to
@@ -1187,6 +1652,9 @@ copy. This does not use an SV.
char* savepvn(const char* sv, I32 len)
+=for hackers
+Found in file util.c
+
=item SAVETMPS
Opening bracket for temporaries on a callback. See C<FREETMPS> and
@@ -1194,29 +1662,44 @@ L<perlcall>.
SAVETMPS;
+=for hackers
+Found in file scope.h
+
=item SP
Stack pointer. This is usually handled by C<xsubpp>. See C<dSP> and
C<SPAGAIN>.
+=for hackers
+Found in file pp.h
+
=item SPAGAIN
Refetch the stack pointer. Used after a callback. See L<perlcall>.
SPAGAIN;
+=for hackers
+Found in file pp.h
+
=item ST
Used to access elements on the XSUB's stack.
SV* ST(int ix)
+=for hackers
+Found in file XSUB.h
+
=item strEQ
Test two strings to see if they are equal. Returns true or false.
bool strEQ(char* s1, char* s2)
+=for hackers
+Found in file handy.h
+
=item strGE
Test two strings to see if the first, C<s1>, is greater than or equal to
@@ -1224,6 +1707,9 @@ the second, C<s2>. Returns true or false.
bool strGE(char* s1, char* s2)
+=for hackers
+Found in file handy.h
+
=item strGT
Test two strings to see if the first, C<s1>, is greater than the second,
@@ -1231,6 +1717,9 @@ C<s2>. Returns true or false.
bool strGT(char* s1, char* s2)
+=for hackers
+Found in file handy.h
+
=item strLE
Test two strings to see if the first, C<s1>, is less than or equal to the
@@ -1238,6 +1727,9 @@ second, C<s2>. Returns true or false.
bool strLE(char* s1, char* s2)
+=for hackers
+Found in file handy.h
+
=item strLT
Test two strings to see if the first, C<s1>, is less than the second,
@@ -1245,6 +1737,9 @@ C<s2>. Returns true or false.
bool strLT(char* s1, char* s2)
+=for hackers
+Found in file handy.h
+
=item strNE
Test two strings to see if they are different. Returns true or
@@ -1252,6 +1747,9 @@ false.
bool strNE(char* s1, char* s2)
+=for hackers
+Found in file handy.h
+
=item strnEQ
Test two strings to see if they are equal. The C<len> parameter indicates
@@ -1260,6 +1758,9 @@ C<strncmp>).
bool strnEQ(char* s1, char* s2, STRLEN len)
+=for hackers
+Found in file handy.h
+
=item strnNE
Test two strings to see if they are different. The C<len> parameter
@@ -1268,24 +1769,36 @@ wrapper for C<strncmp>).
bool strnNE(char* s1, char* s2, STRLEN len)
+=for hackers
+Found in file handy.h
+
=item StructCopy
This is an architecture-independent macro to copy one structure to another.
void StructCopy(type src, type dest, type)
+=for hackers
+Found in file handy.h
+
=item SvCUR
Returns the length of the string which is in the SV. See C<SvLEN>.
STRLEN SvCUR(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvCUR_set
Set the length of the string which is in the SV. See C<SvCUR>.
void SvCUR_set(SV* sv, STRLEN len)
+=for hackers
+Found in file sv.h
+
=item SvEND
Returns a pointer to the last character in the string which is in the SV.
@@ -1293,6 +1806,9 @@ See C<SvCUR>. Access the character as *(SvEND(sv)).
char* SvEND(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvGETMAGIC
Invokes C<mg_get> on an SV if it has 'get' magic. This macro evaluates its
@@ -1300,6 +1816,9 @@ argument more than once.
void SvGETMAGIC(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvGROW
Expands the character buffer in the SV so that it has room for the
@@ -1309,12 +1828,18 @@ Returns a pointer to the character buffer.
void SvGROW(SV* sv, STRLEN len)
+=for hackers
+Found in file sv.h
+
=item SvIOK
Returns a boolean indicating whether the SV contains an integer.
bool SvIOK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvIOKp
Returns a boolean indicating whether the SV contains an integer. Checks
@@ -1322,30 +1847,45 @@ the B<private> setting. Use C<SvIOK>.
bool SvIOKp(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvIOK_off
Unsets the IV status of an SV.
void SvIOK_off(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvIOK_on
Tells an SV that it is an integer.
void SvIOK_on(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvIOK_only
Tells an SV that it is an integer and disables all other OK bits.
void SvIOK_only(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvIV
Coerces the given SV to an integer and returns it.
IV SvIV(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvIVX
Returns the integer which is stored in the SV, assuming SvIOK is
@@ -1353,12 +1893,18 @@ true.
IV SvIVX(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvLEN
Returns the size of the string buffer in the SV. See C<SvCUR>.
STRLEN SvLEN(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvLOCK
Aquires an internal mutex for a SV. Used to make sure multiple threads
@@ -1366,6 +1912,9 @@ don't stomp on the guts of an SV at the same time
void SvLOCK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNIOK
Returns a boolean indicating whether the SV contains a number, integer or
@@ -1373,6 +1922,9 @@ double.
bool SvNIOK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNIOKp
Returns a boolean indicating whether the SV contains a number, integer or
@@ -1380,18 +1932,27 @@ double. Checks the B<private> setting. Use C<SvNIOK>.
bool SvNIOKp(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNIOK_off
Unsets the NV/IV status of an SV.
void SvNIOK_off(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNOK
Returns a boolean indicating whether the SV contains a double.
bool SvNOK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNOKp
Returns a boolean indicating whether the SV contains a double. Checks the
@@ -1399,30 +1960,45 @@ B<private> setting. Use C<SvNOK>.
bool SvNOKp(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNOK_off
Unsets the NV status of an SV.
void SvNOK_off(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNOK_on
Tells an SV that it is a double.
void SvNOK_on(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNOK_only
Tells an SV that it is a double and disables all other OK bits.
void SvNOK_only(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNV
Coerce the given SV to a double and return it.
NV SvNV(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvNVX
Returns the double which is stored in the SV, assuming SvNOK is
@@ -1430,12 +2006,18 @@ true.
NV SvNVX(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvOK
Returns a boolean indicating whether the value is an SV.
bool SvOK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvOOK
Returns a boolean indicating whether the SvIVX is a valid offset value for
@@ -1445,6 +2027,9 @@ allocated string buffer is really (SvPVX - SvIVX).
bool SvOOK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPOK
Returns a boolean indicating whether the SV contains a character
@@ -1452,6 +2037,9 @@ string.
bool SvPOK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPOKp
Returns a boolean indicating whether the SV contains a character string.
@@ -1459,24 +2047,36 @@ Checks the B<private> setting. Use C<SvPOK>.
bool SvPOKp(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPOK_off
Unsets the PV status of an SV.
void SvPOK_off(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPOK_on
Tells an SV that it is a string.
void SvPOK_on(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPOK_only
Tells an SV that it is a string and disables all other OK bits.
void SvPOK_only(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPV
Returns a pointer to the string in the SV, or a stringified form of the SV
@@ -1484,6 +2084,9 @@ if the SV does not contain a string. Handles 'get' magic.
char* SvPV(SV* sv, STRLEN len)
+=for hackers
+Found in file sv.h
+
=item SvPVX
Returns a pointer to the string in the SV. The SV must contain a
@@ -1491,6 +2094,9 @@ string.
char* SvPVX(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvPV_force
Like <SvPV> but will force the SV into becoming a string (SvPOK). You want
@@ -1498,6 +2104,9 @@ force if you are going to update the SvPVX directly.
char* SvPV_force(SV* sv, STRLEN len)
+=for hackers
+Found in file sv.h
+
=item SvPV_nolen
Returns a pointer to the string in the SV, or a stringified form of the SV
@@ -1505,48 +2114,72 @@ if the SV does not contain a string. Handles 'get' magic.
char* SvPV_nolen(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvREFCNT
Returns the value of the object's reference count.
U32 SvREFCNT(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvREFCNT_dec
Decrements the reference count of the given SV.
void SvREFCNT_dec(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvREFCNT_inc
Increments the reference count of the given SV.
SV* SvREFCNT_inc(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvROK
Tests if the SV is an RV.
bool SvROK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvROK_off
Unsets the RV status of an SV.
void SvROK_off(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvROK_on
Tells an SV that it is an RV.
void SvROK_on(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvRV
Dereferences an RV to return the SV.
SV* SvRV(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvSETMAGIC
Invokes C<mg_set> on an SV if it has 'set' magic. This macro evaluates its
@@ -1554,6 +2187,9 @@ argument more than once.
void SvSETMAGIC(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvSetSV
Calls C<sv_setsv> if dsv is not the same as ssv. May evaluate arguments
@@ -1561,6 +2197,9 @@ more than once.
void SvSetSV(SV* dsb, SV* ssv)
+=for hackers
+Found in file sv.h
+
=item SvSetSV_nosteal
Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
@@ -1568,18 +2207,27 @@ ssv. May evaluate arguments more than once.
void SvSetSV_nosteal(SV* dsv, SV* ssv)
+=for hackers
+Found in file sv.h
+
=item SvSTASH
Returns the stash of the SV.
HV* SvSTASH(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvTAINT
Taints an SV if tainting is enabled
void SvTAINT(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvTAINTED
Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
@@ -1587,6 +2235,9 @@ not.
bool SvTAINTED(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvTAINTED_off
Untaints an SV. Be I<very> careful with this routine, as it short-circuits
@@ -1598,12 +2249,18 @@ untainting variables.
void SvTAINTED_off(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvTAINTED_on
Marks an SV as tainted.
void SvTAINTED_on(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvTRUE
Returns a boolean indicating whether Perl would evaluate the SV as true or
@@ -1611,51 +2268,84 @@ false, defined or undefined. Does not handle 'get' magic.
bool SvTRUE(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvTYPE
Returns the type of the SV. See C<svtype>.
svtype SvTYPE(SV* sv)
+=for hackers
+Found in file sv.h
+
=item svtype
An enum of flags for Perl types. These are found in the file B<sv.h>
in the C<svtype> enum. Test these flags with the C<SvTYPE> macro.
+=for hackers
+Found in file sv.h
+
=item SVt_IV
Integer type flag for scalars. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SVt_NV
Double type flag for scalars. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SVt_PV
Pointer type flag for scalars. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SVt_PVAV
Type flag for arrays. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SVt_PVCV
Type flag for code refs. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SVt_PVHV
Type flag for hashes. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SVt_PVMG
Type flag for blessed scalars. See C<svtype>.
+=for hackers
+Found in file sv.h
+
=item SvUNLOCK
Release the internal mutex for an SV.
void SvUNLOCK(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvUPGRADE
Used to upgrade an SV to a more complex form. Uses C<sv_upgrade> to
@@ -1663,12 +2353,18 @@ perform the upgrade if necessary. See C<svtype>.
void SvUPGRADE(SV* sv, svtype type)
+=for hackers
+Found in file sv.h
+
=item SvUV
Coerces the given SV to an unsigned integer and returns it.
UV SvUV(SV* sv)
+=for hackers
+Found in file sv.h
+
=item SvUVX
Returns the unsigned integer which is stored in the SV, assuming SvIOK is
@@ -1676,6 +2372,9 @@ true.
UV SvUVX(SV* sv)
+=for hackers
+Found in file sv.h
+
=item sv_2mortal
Marks an SV as mortal. The SV will be destroyed when the current context
@@ -1683,6 +2382,9 @@ ends.
SV* sv_2mortal(SV* sv)
+=for hackers
+Found in file sv.c
+
=item sv_bless
Blesses an SV into a specified package. The SV must be an RV. The package
@@ -1691,6 +2393,9 @@ of the SV is unaffected.
SV* sv_bless(SV* sv, HV* stash)
+=for hackers
+Found in file sv.c
+
=item sv_catpv
Concatenates the string onto the end of the string which is in the SV.
@@ -1698,6 +2403,9 @@ Handles 'get' magic, but not 'set' magic. See C<sv_catpv_mg>.
void sv_catpv(SV* sv, const char* ptr)
+=for hackers
+Found in file sv.c
+
=item sv_catpvf
Processes its arguments like C<sprintf> and appends the formatted output
@@ -1706,12 +2414,18 @@ typically be called after calling this function to handle 'set' magic.
void sv_catpvf(SV* sv, const char* pat, ...)
+=for hackers
+Found in file sv.c
+
=item sv_catpvf_mg
Like C<sv_catpvf>, but also handles 'set' magic.
void sv_catpvf_mg(SV *sv, const char* pat, ...)
+=for hackers
+Found in file sv.c
+
=item sv_catpvn
Concatenates the string onto the end of the string which is in the SV. The
@@ -1720,18 +2434,27 @@ C<len> indicates number of bytes to copy. Handles 'get' magic, but not
void sv_catpvn(SV* sv, const char* ptr, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item sv_catpvn_mg
Like C<sv_catpvn>, but also handles 'set' magic.
void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item sv_catpv_mg
Like C<sv_catpv>, but also handles 'set' magic.
void sv_catpv_mg(SV *sv, const char *ptr)
+=for hackers
+Found in file sv.c
+
=item sv_catsv
Concatenates the string from SV C<ssv> onto the end of the string in SV
@@ -1739,12 +2462,18 @@ C<dsv>. Handles 'get' magic, but not 'set' magic. See C<sv_catsv_mg>.
void sv_catsv(SV* dsv, SV* ssv)
+=for hackers
+Found in file sv.c
+
=item sv_catsv_mg
Like C<sv_catsv>, but also handles 'set' magic.
void sv_catsv_mg(SV *dstr, SV *sstr)
+=for hackers
+Found in file sv.c
+
=item sv_chop
Efficient removal of characters from the beginning of the string buffer.
@@ -1754,6 +2483,9 @@ string.
void sv_chop(SV* sv, char* ptr)
+=for hackers
+Found in file sv.c
+
=item sv_cmp
Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the
@@ -1762,12 +2494,18 @@ C<sv2>.
I32 sv_cmp(SV* sv1, SV* sv2)
+=for hackers
+Found in file sv.c
+
=item sv_dec
Auto-decrement of the value in the SV.
void sv_dec(SV* sv)
+=for hackers
+Found in file sv.c
+
=item sv_derived_from
Returns a boolean indicating whether the SV is derived from the specified
@@ -1776,6 +2514,9 @@ for class names as well as for objects.
bool sv_derived_from(SV* sv, const char* name)
+=for hackers
+Found in file universal.c
+
=item sv_eq
Returns a boolean indicating whether the strings in the two SVs are
@@ -1783,6 +2524,9 @@ identical.
I32 sv_eq(SV* sv1, SV* sv2)
+=for hackers
+Found in file sv.c
+
=item sv_grow
Expands the character buffer in the SV. This will use C<sv_unref> and will
@@ -1791,12 +2535,18 @@ Use C<SvGROW>.
char* sv_grow(SV* sv, STRLEN newlen)
+=for hackers
+Found in file sv.c
+
=item sv_inc
Auto-increment of the value in the SV.
void sv_inc(SV* sv)
+=for hackers
+Found in file sv.c
+
=item sv_insert
Inserts a string at the specified offset/length within the SV. Similar to
@@ -1804,6 +2554,9 @@ the Perl substr() function.
void sv_insert(SV* bigsv, STRLEN offset, STRLEN len, char* little, STRLEN littlelen)
+=for hackers
+Found in file sv.c
+
=item sv_isa
Returns a boolean indicating whether the SV is blessed into the specified
@@ -1812,6 +2565,9 @@ an inheritance relationship.
int sv_isa(SV* sv, const char* name)
+=for hackers
+Found in file sv.c
+
=item sv_isobject
Returns a boolean indicating whether the SV is an RV pointing to a blessed
@@ -1820,18 +2576,27 @@ will return false.
int sv_isobject(SV* sv)
+=for hackers
+Found in file sv.c
+
=item sv_len
Returns the length of the string in the SV. See also C<SvCUR>.
STRLEN sv_len(SV* sv)
+=for hackers
+Found in file sv.c
+
=item sv_magic
Adds magic to an SV.
void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)
+=for hackers
+Found in file sv.c
+
=item sv_mortalcopy
Creates a new SV which is a copy of the original SV. The new SV is marked
@@ -1839,12 +2604,18 @@ as mortal.
SV* sv_mortalcopy(SV* oldsv)
+=for hackers
+Found in file sv.c
+
=item sv_newmortal
Creates a new SV which is mortal. The reference count of the SV is set to 1.
SV* sv_newmortal()
+=for hackers
+Found in file sv.c
+
=item sv_setiv
Copies an integer into the given SV. Does not handle 'set' magic. See
@@ -1852,12 +2623,18 @@ C<sv_setiv_mg>.
void sv_setiv(SV* sv, IV num)
+=for hackers
+Found in file sv.c
+
=item sv_setiv_mg
Like C<sv_setiv>, but also handles 'set' magic.
void sv_setiv_mg(SV *sv, IV i)
+=for hackers
+Found in file sv.c
+
=item sv_setnv
Copies a double into the given SV. Does not handle 'set' magic. See
@@ -1865,12 +2642,18 @@ C<sv_setnv_mg>.
void sv_setnv(SV* sv, NV num)
+=for hackers
+Found in file sv.c
+
=item sv_setnv_mg
Like C<sv_setnv>, but also handles 'set' magic.
void sv_setnv_mg(SV *sv, NV num)
+=for hackers
+Found in file sv.c
+
=item sv_setpv
Copies a string into an SV. The string must be null-terminated. Does not
@@ -1878,6 +2661,9 @@ handle 'set' magic. See C<sv_setpv_mg>.
void sv_setpv(SV* sv, const char* ptr)
+=for hackers
+Found in file sv.c
+
=item sv_setpvf
Processes its arguments like C<sprintf> and sets an SV to the formatted
@@ -1885,12 +2671,18 @@ output. Does not handle 'set' magic. See C<sv_setpvf_mg>.
void sv_setpvf(SV* sv, const char* pat, ...)
+=for hackers
+Found in file sv.c
+
=item sv_setpvf_mg
Like C<sv_setpvf>, but also handles 'set' magic.
void sv_setpvf_mg(SV *sv, const char* pat, ...)
+=for hackers
+Found in file sv.c
+
=item sv_setpviv
Copies an integer into the given SV, also updating its string value.
@@ -1898,12 +2690,18 @@ Does not handle 'set' magic. See C<sv_setpviv_mg>.
void sv_setpviv(SV* sv, IV num)
+=for hackers
+Found in file sv.c
+
=item sv_setpviv_mg
Like C<sv_setpviv>, but also handles 'set' magic.
void sv_setpviv_mg(SV *sv, IV iv)
+=for hackers
+Found in file sv.c
+
=item sv_setpvn
Copies a string into an SV. The C<len> parameter indicates the number of
@@ -1911,18 +2709,27 @@ bytes to be copied. Does not handle 'set' magic. See C<sv_setpvn_mg>.
void sv_setpvn(SV* sv, const char* ptr, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item sv_setpvn_mg
Like C<sv_setpvn>, but also handles 'set' magic.
void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item sv_setpv_mg
Like C<sv_setpv>, but also handles 'set' magic.
void sv_setpv_mg(SV *sv, const char *ptr)
+=for hackers
+Found in file sv.c
+
=item sv_setref_iv
Copies an integer into a new SV, optionally blessing the SV. The C<rv>
@@ -1933,6 +2740,9 @@ will be returned and will have a reference count of 1.
SV* sv_setref_iv(SV* rv, const char* classname, IV iv)
+=for hackers
+Found in file sv.c
+
=item sv_setref_nv
Copies a double into a new SV, optionally blessing the SV. The C<rv>
@@ -1943,6 +2753,9 @@ will be returned and will have a reference count of 1.
SV* sv_setref_nv(SV* rv, const char* classname, NV nv)
+=for hackers
+Found in file sv.c
+
=item sv_setref_pv
Copies a pointer into a new SV, optionally blessing the SV. The C<rv>
@@ -1959,6 +2772,9 @@ Note that C<sv_setref_pvn> copies the string while this copies the pointer.
SV* sv_setref_pv(SV* rv, const char* classname, void* pv)
+=for hackers
+Found in file sv.c
+
=item sv_setref_pvn
Copies a string into a new SV, optionally blessing the SV. The length of the
@@ -1972,6 +2788,9 @@ Note that C<sv_setref_pv> copies the pointer while this copies the string.
SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)
+=for hackers
+Found in file sv.c
+
=item sv_setsv
Copies the contents of the source SV C<ssv> into the destination SV C<dsv>.
@@ -1981,12 +2800,18 @@ C<sv_setsv_mg>.
void sv_setsv(SV* dsv, SV* ssv)
+=for hackers
+Found in file sv.c
+
=item sv_setsv_mg
Like C<sv_setsv>, but also handles 'set' magic.
void sv_setsv_mg(SV *dstr, SV *sstr)
+=for hackers
+Found in file sv.c
+
=item sv_setuv
Copies an unsigned integer into the given SV. Does not handle 'set' magic.
@@ -1994,12 +2819,18 @@ See C<sv_setuv_mg>.
void sv_setuv(SV* sv, UV num)
+=for hackers
+Found in file sv.c
+
=item sv_setuv_mg
Like C<sv_setuv>, but also handles 'set' magic.
void sv_setuv_mg(SV *sv, UV u)
+=for hackers
+Found in file sv.c
+
=item sv_unref
Unsets the RV status of the SV, and decrements the reference count of
@@ -2008,6 +2839,9 @@ as a reversal of C<newSVrv>. See C<SvROK_off>.
void sv_unref(SV* sv)
+=for hackers
+Found in file sv.c
+
=item sv_upgrade
Upgrade an SV to a more complex form. Use C<SvUPGRADE>. See
@@ -2015,6 +2849,9 @@ C<svtype>.
bool sv_upgrade(SV* sv, U32 mt)
+=for hackers
+Found in file sv.c
+
=item sv_usepvn
Tells an SV to use C<ptr> to find its string value. Normally the string is
@@ -2027,12 +2864,18 @@ See C<sv_usepvn_mg>.
void sv_usepvn(SV* sv, char* ptr, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item sv_usepvn_mg
Like C<sv_usepvn>, but also handles 'set' magic.
void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)
+=for hackers
+Found in file sv.c
+
=item sv_vcatpvfn
Processes its arguments like C<vsprintf> and appends the formatted output
@@ -2043,6 +2886,9 @@ locales).
void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
+=for hackers
+Found in file sv.c
+
=item sv_vsetpvfn
Works like C<vcatpvfn> but copies the text into the SV instead of
@@ -2050,6 +2896,9 @@ appending it.
void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
+=for hackers
+Found in file sv.c
+
=item THIS
Variable which is setup by C<xsubpp> to designate the object in a C++
@@ -2058,18 +2907,27 @@ L<perlxs/"Using XS With C++">.
(whatever) THIS
+=for hackers
+Found in file XSUB.h
+
=item toLOWER
Converts the specified character to lowercase.
char toLOWER(char ch)
+=for hackers
+Found in file handy.h
+
=item toUPPER
Converts the specified character to uppercase.
char toUPPER(char ch)
+=for hackers
+Found in file handy.h
+
=item warn
This is the XSUB-writer's interface to Perl's C<warn> function. Use this
@@ -2078,6 +2936,9 @@ C<croak>.
void warn(const char* pat, ...)
+=for hackers
+Found in file util.c
+
=item XPUSHi
Push an integer onto the stack, extending the stack if necessary. Handles
@@ -2085,6 +2946,9 @@ Push an integer onto the stack, extending the stack if necessary. Handles
void XPUSHi(IV iv)
+=for hackers
+Found in file pp.h
+
=item XPUSHn
Push a double onto the stack, extending the stack if necessary. Handles
@@ -2092,6 +2956,9 @@ Push a double onto the stack, extending the stack if necessary. Handles
void XPUSHn(NV nv)
+=for hackers
+Found in file pp.h
+
=item XPUSHp
Push a string onto the stack, extending the stack if necessary. The C<len>
@@ -2100,6 +2967,9 @@ C<PUSHp>.
void XPUSHp(char* str, STRLEN len)
+=for hackers
+Found in file pp.h
+
=item XPUSHs
Push an SV onto the stack, extending the stack if necessary. Does not
@@ -2107,6 +2977,9 @@ handle 'set' magic. See C<PUSHs>.
void XPUSHs(SV* sv)
+=for hackers
+Found in file pp.h
+
=item XPUSHu
Push an unsigned integer onto the stack, extending the stack if necessary.
@@ -2114,11 +2987,17 @@ See C<PUSHu>.
void XPUSHu(UV uv)
+=for hackers
+Found in file pp.h
+
=item XS
Macro to declare an XSUB and its C parameter list. This is handled by
C<xsubpp>.
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN
Return from XSUB, indicating number of items on the stack. This is usually
@@ -2126,48 +3005,72 @@ handled by C<xsubpp>.
void XSRETURN(int nitems)
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_EMPTY
Return an empty list from an XSUB immediately.
XSRETURN_EMPTY;
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_IV
Return an integer from an XSUB immediately. Uses C<XST_mIV>.
void XSRETURN_IV(IV iv)
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_NO
Return C<&PL_sv_no> from an XSUB immediately. Uses C<XST_mNO>.
XSRETURN_NO;
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_NV
Return an double from an XSUB immediately. Uses C<XST_mNV>.
void XSRETURN_NV(NV nv)
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_PV
Return a copy of a string from an XSUB immediately. Uses C<XST_mPV>.
void XSRETURN_PV(char* str)
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_UNDEF
Return C<&PL_sv_undef> from an XSUB immediately. Uses C<XST_mUNDEF>.
XSRETURN_UNDEF;
+=for hackers
+Found in file XSUB.h
+
=item XSRETURN_YES
Return C<&PL_sv_yes> from an XSUB immediately. Uses C<XST_mYES>.
XSRETURN_YES;
+=for hackers
+Found in file XSUB.h
+
=item XST_mIV
Place an integer into the specified position C<pos> on the stack. The
@@ -2175,6 +3078,9 @@ value is stored in a new mortal SV.
void XST_mIV(int pos, IV iv)
+=for hackers
+Found in file XSUB.h
+
=item XST_mNO
Place C<&PL_sv_no> into the specified position C<pos> on the
@@ -2182,6 +3088,9 @@ stack.
void XST_mNO(int pos)
+=for hackers
+Found in file XSUB.h
+
=item XST_mNV
Place a double into the specified position C<pos> on the stack. The value
@@ -2189,6 +3098,9 @@ is stored in a new mortal SV.
void XST_mNV(int pos, NV nv)
+=for hackers
+Found in file XSUB.h
+
=item XST_mPV
Place a copy of a string into the specified position C<pos> on the stack.
@@ -2196,6 +3108,9 @@ The value is stored in a new mortal SV.
void XST_mPV(int pos, char* str)
+=for hackers
+Found in file XSUB.h
+
=item XST_mUNDEF
Place C<&PL_sv_undef> into the specified position C<pos> on the
@@ -2203,6 +3118,9 @@ stack.
void XST_mUNDEF(int pos)
+=for hackers
+Found in file XSUB.h
+
=item XST_mYES
Place C<&PL_sv_yes> into the specified position C<pos> on the
@@ -2210,11 +3128,17 @@ stack.
void XST_mYES(int pos)
+=for hackers
+Found in file XSUB.h
+
=item XS_VERSION
The version identifier for an XS module. This is usually
handled automatically by C<ExtUtils::MakeMaker>. See C<XS_VERSION_BOOTCHECK>.
+=for hackers
+Found in file XSUB.h
+
=item XS_VERSION_BOOTCHECK
Macro to verify that a PM module's $VERSION variable matches the XS
@@ -2223,6 +3147,9 @@ C<xsubpp>. See L<perlxs/"The VERSIONCHECK: Keyword">.
XS_VERSION_BOOTCHECK;
+=for hackers
+Found in file XSUB.h
+
=item Zero
The XSUB-writer's interface to the C C<memzero> function. The C<dest> is the
@@ -2230,6 +3157,9 @@ destination, C<nitems> is the number of items, and C<type> is the type.
void Zero(void* dest, int nitems, type)
+=for hackers
+Found in file handy.h
+
=back
=head1 AUTHORS
diff --git a/pod/perlintern.pod b/pod/perlintern.pod
index 6d8d67d..8afabd9 100644
--- a/pod/perlintern.pod
+++ b/pod/perlintern.pod
@@ -24,6 +24,9 @@ allow selecting particular classes of magical variable.
bool is_gv_magical(char *name, STRLEN len, U32 flags)
+=for hackers
+Found in file gv.c
+
=back
=head1 AUTHORS
diff --git a/proto.h b/proto.h
index afe67b1..2171aa1 100644
--- a/proto.h
+++ b/proto.h
@@ -809,6 +809,8 @@ PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U16* p, U8 *d, I32 bytelen);
PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U16* p, U8 *d, I32 bytelen);
PERL_CALLCONV I32 Perl_utf8_distance(pTHX_ U8 *a, U8 *b);
PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ U8 *s, I32 off);
+PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN len);
+PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ U8 *s, STRLEN len);
PERL_CALLCONV UV Perl_utf8_to_uv(pTHX_ U8 *s, I32* retlen);
PERL_CALLCONV U8* Perl_uv_to_utf8(pTHX_ U8 *d, UV uv);
PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv);
@@ -962,8 +964,6 @@ STATIC I32 S_do_trans_CC_complex(pTHX_ SV *sv);
STATIC I32 S_do_trans_UU_simple(pTHX_ SV *sv);
STATIC I32 S_do_trans_UU_count(pTHX_ SV *sv);
STATIC I32 S_do_trans_UU_complex(pTHX_ SV *sv);
-STATIC I32 S_do_trans_UC_simple(pTHX_ SV *sv);
-STATIC I32 S_do_trans_CU_simple(pTHX_ SV *sv);
STATIC I32 S_do_trans_UC_trivial(pTHX_ SV *sv);
STATIC I32 S_do_trans_CU_trivial(pTHX_ SV *sv);
#endif