From: Jarkko Hietaniemi 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. Deprecated, use C 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 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 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. 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 values onto the beginning of the @@ -114,6 +147,9 @@ must then use C 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. @@ -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. @@ -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 to indicate the @@ -155,6 +203,9 @@ class name for a C++ XS constructor. This is always a C. See C. char* CLASS +=for hackers +Found in file XSUB.h + =item Copy The XSUB-writer's interface to the C C function. The C is the @@ -163,6 +214,9 @@ the type. May fail on overlapping copies. See also C. 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 function. @@ -178,12 +232,18 @@ C<$@> and then pass C 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, for the XSUB. See C and @@ -191,12 +251,18 @@ C. dMARK; +=for hackers +Found in file pp.h + =item dORIGMARK Saves the original stack mark for the XSUB. See C. 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 macro. See C. 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 variable for an XSUB which has aliases. This is usually @@ -219,12 +291,18 @@ handled automatically by C. dXSI32; +=for hackers +Found in file XSUB.h + =item ENTER Opening bracket on a callback. See C and L. ENTER; +=for hackers +Found in file scope.h + =item eval_pv Tells Perl to C 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 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 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 and @@ -272,6 +365,9 @@ L. FREETMPS; +=for hackers +Found in file scope.h + =item get_av Returns the AV of the specified Perl array. If C 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 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 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 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 which can only return @@ -321,6 +429,9 @@ Deprecated. Use C instead. U32 GIMME +=for hackers +Found in file op.h + =item GIMME_V The XSUB-writer's equivalent to Perl's C. Returns C, @@ -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 and a defined subroutine or @@ -354,12 +471,18 @@ obtained from the GV with the C 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* 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 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 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. HV* gv_stashsv(SV* sv, I32 create) +=for hackers +Found in file gv.c + =item G_ARRAY Used to indicate array context. See C, C and L. +=for hackers +Found in file cop.h + =item G_DISCARD Indicates that arguments returned from a callback should be discarded. See L. +=for hackers +Found in file cop.h + =item G_EVAL Used to force a Perl C wrapper around a callback. See L. +=for hackers +Found in file cop.h + =item G_NOARGS Indicates that no arguments are being sent to a callback. See L. +=for hackers +Found in file cop.h + =item G_SCALAR Used to indicate scalar context. See C, C, and L. +=for hackers +Found in file cop.h + =item G_VOID Used to indicate void context. See C and L. +=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 pointer where a C 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, 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 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, or C if the hash entry does not @@ -482,6 +647,9 @@ contain an C key. SV* HeSVKEY(HE* he) +=for hackers +Found in file hv.h + =item HeSVKEY_force Returns the key as an C. Will create and return a temporary mortal @@ -489,6 +657,9 @@ C if the hash entry contains only a C key. SV* HeSVKEY_force(HE* he) +=for hackers +Found in file hv.h + =item HeSVKEY_set Sets the key to a given C, taking care to set the appropriate flags to @@ -497,24 +668,36 @@ C. SV* HeSVKEY_set(HE* he, SV* sv) +=for hackers +Found in file hv.h + =item HeVAL Returns the value slot (type C) 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, C. 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 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 @@ -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. 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. char* hv_iterkey(HE* entry, I32* retlen) +=for hackers +Found in file hv.c + =item hv_iterkeysv Returns the key as an C from the current position of the hash @@ -602,12 +809,18 @@ see C. SV* hv_iterkeysv(HE* entry) +=for hackers +Found in file hv.c + =item hv_iternext Returns entries from a hash iterator. See C. HE* hv_iternext(HV* tb) +=for hackers +Found in file hv.c + =item hv_iternextsv Performs an C, C, and C 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. SV* hv_iterval(HV* tb, HE* entry) +=for hackers +Found in file hv.c + =item hv_magic Adds magic to a hash. See C. 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 and C 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 in a hash. The hash key is specified as C. The C @@ -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 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 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 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 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 is whitespace. bool isSPACE(char ch) +=for hackers +Found in file handy.h + =item isUPPER Returns a boolean indicating whether the C C 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 to indicate the number of @@ -715,6 +964,9 @@ items on the stack. See L. I32 items +=for hackers +Found in file XSUB.h + =item ix Variable which is setup by C to indicate which of an @@ -722,12 +974,18 @@ XSUB's aliases was used to invoke it. See L. I32 ix +=for hackers +Found in file XSUB.h + =item LEAVE Closing bracket on a callback. See C and L. 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. +=for hackers +Found in file pp.h + =item mg_clear Clear something magical that the SV represents. See C. 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. 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. 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. 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. int mg_get(SV* sv) +=for hackers +Found in file mg.c + =item mg_length Report on the SV's length. See C. 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. 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. int mg_set(SV* sv) +=for hackers +Found in file mg.c + =item Move The XSUB-writer's interface to the C C function. The C is the @@ -795,18 +1083,27 @@ the type. Can do overlapping moves. See also C. 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 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 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 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 incremented. SV* newRV_noinc(SV *sv) +=for hackers +Found in file sv.c + =item NEWSV Creates a new SV. A non-zero C parameter indicates the number of @@ -851,6 +1163,9 @@ C 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 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. 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 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, to point to. If C 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 to hook up XSUBs as Perl subs. +=for hackers +Found in file op.c + =item newXSproto Used by C 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 function. The allocated @@ -927,66 +1272,105 @@ memory is zeroed with C. 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. +=for hackers +Found in file pp.h + =item perl_alloc Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc() +=for hackers +Found in file perl.c + =item perl_construct Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp) +=for hackers +Found in file perl.c + =item perl_destruct Shuts down a Perl interpreter. See L. void perl_destruct(PerlInterpreter* interp) +=for hackers +Found in file perl.c + =item perl_free Releases a Perl interpreter. See L. 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. 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. 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. 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. 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. 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 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 when one @@ -1039,6 +1438,9 @@ C macro. STRLEN PL_na +=for hackers +Found in file thrdvar.h + =item PL_sv_no This is the C SV. See C. 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 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 SV. See C. 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. void PUSHi(IV iv) +=for hackers +Found in file pp.h + =item PUSHMARK Opening bracket for arguments on a callback. See C and @@ -1103,6 +1532,9 @@ L. 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. 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. 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. 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. void PUSHu(UV uv) +=for hackers +Found in file pp.h + =item PUTBACK Closing bracket for XSUB arguments. This is usually handled by C. @@ -1139,12 +1583,18 @@ See C and L for other uses. PUTBACK; +=for hackers +Found in file pp.h + =item Renew The XSUB-writer's interface to the C C 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 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 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 to hold the return value for an @@ -1168,18 +1624,27 @@ L. (whatever) RETVAL +=for hackers +Found in file XSUB.h + =item Safefree The XSUB-writer's interface to the C C 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 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 and @@ -1194,29 +1662,44 @@ L. SAVETMPS; +=for hackers +Found in file scope.h + =item SP Stack pointer. This is usually handled by C. See C and C. +=for hackers +Found in file pp.h + =item SPAGAIN Refetch the stack pointer. Used after a callback. See L. 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, is greater than or equal to @@ -1224,6 +1707,9 @@ the second, C. 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, is greater than the second, @@ -1231,6 +1717,9 @@ C. 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, is less than or equal to the @@ -1238,6 +1727,9 @@ second, C. 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, is less than the second, @@ -1245,6 +1737,9 @@ C. 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 parameter indicates @@ -1260,6 +1758,9 @@ C). 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 parameter @@ -1268,24 +1769,36 @@ wrapper for C). 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. 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. 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. Access the character as *(SvEND(sv)). char* SvEND(SV* sv) +=for hackers +Found in file sv.h + =item SvGETMAGIC Invokes C 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 setting. Use C. 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. 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 setting. Use C. 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 setting. Use C. 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 setting. Use C. 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 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 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 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 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 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(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 in the C enum. Test these flags with the C macro. +=for hackers +Found in file sv.h + =item SVt_IV Integer type flag for scalars. See C. +=for hackers +Found in file sv.h + =item SVt_NV Double type flag for scalars. See C. +=for hackers +Found in file sv.h + =item SVt_PV Pointer type flag for scalars. See C. +=for hackers +Found in file sv.h + =item SVt_PVAV Type flag for arrays. See C. +=for hackers +Found in file sv.h + =item SVt_PVCV Type flag for code refs. See C. +=for hackers +Found in file sv.h + =item SVt_PVHV Type flag for hashes. See C. +=for hackers +Found in file sv.h + =item SVt_PVMG Type flag for blessed scalars. See C. +=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 to @@ -1663,12 +2353,18 @@ perform the upgrade if necessary. See C. 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. void sv_catpv(SV* sv, const char* ptr) +=for hackers +Found in file sv.c + =item sv_catpvf Processes its arguments like C 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, 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 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, 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, 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 onto the end of the string in SV @@ -1739,12 +2462,18 @@ C. Handles 'get' magic, but not 'set' magic. See C. void sv_catsv(SV* dsv, SV* ssv) +=for hackers +Found in file sv.c + =item sv_catsv_mg Like C, 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. 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 and will @@ -1791,12 +2535,18 @@ Use C. 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. 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. void sv_setiv(SV* sv, IV num) +=for hackers +Found in file sv.c + =item sv_setiv_mg Like C, 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. void sv_setnv(SV* sv, NV num) +=for hackers +Found in file sv.c + =item sv_setnv_mg Like C, 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. void sv_setpv(SV* sv, const char* ptr) +=for hackers +Found in file sv.c + =item sv_setpvf Processes its arguments like C and sets an SV to the formatted @@ -1885,12 +2671,18 @@ output. Does not handle 'set' magic. See C. void sv_setpvf(SV* sv, const char* pat, ...) +=for hackers +Found in file sv.c + =item sv_setpvf_mg Like C, 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. void sv_setpviv(SV* sv, IV num) +=for hackers +Found in file sv.c + =item sv_setpviv_mg Like C, 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 parameter indicates the number of @@ -1911,18 +2709,27 @@ bytes to be copied. Does not handle 'set' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len) +=for hackers +Found in file sv.c + =item sv_setpvn_mg Like C, 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, 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 @@ -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 @@ -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 @@ -1959,6 +2772,9 @@ Note that C 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 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 into the destination SV C. @@ -1981,12 +2800,18 @@ C. void sv_setsv(SV* dsv, SV* ssv) +=for hackers +Found in file sv.c + =item sv_setsv_mg Like C, 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. void sv_setuv(SV* sv, UV num) +=for hackers +Found in file sv.c + =item sv_setuv_mg Like C, 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. See C. 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. See @@ -2015,6 +2849,9 @@ C. bool sv_upgrade(SV* sv, U32 mt) +=for hackers +Found in file sv.c + =item sv_usepvn Tells an SV to use C to find its string value. Normally the string is @@ -2027,12 +2864,18 @@ See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len) +=for hackers +Found in file sv.c + =item sv_usepvn_mg Like C, 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 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 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 to designate the object in a C++ @@ -2058,18 +2907,27 @@ L. (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 function. Use this @@ -2078,6 +2936,9 @@ C. 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 @@ -2100,6 +2967,9 @@ C. 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. 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. 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. +=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. 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. 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. XSRETURN_NO; +=for hackers +Found in file XSUB.h + =item XSRETURN_NV Return an double from an XSUB immediately. Uses C. 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. 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. XSRETURN_UNDEF; +=for hackers +Found in file XSUB.h + =item XSRETURN_YES Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES; +=for hackers +Found in file XSUB.h + =item XST_mIV Place an integer into the specified position C 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 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 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 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 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 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. See C. +=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. See L. XS_VERSION_BOOTCHECK; +=for hackers +Found in file XSUB.h + =item Zero The XSUB-writer's interface to the C C function. The C is the @@ -2230,6 +3157,9 @@ destination, C is the number of items, and C 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