/*
----------------------------------------------------------------------
- ppport.h -- Perl/Pollution/Portability Version 3.39
+ ppport.h -- Perl/Pollution/Portability Version 3.55
- Automatically created by Devel::PPPort running under perl 5.027010.
+ Automatically created by Devel::PPPort running under perl 5.031004.
Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
includes in parts/inc/ instead.
=head1 NAME
-ppport.h - Perl/Pollution/Portability version 3.39
+ppport.h - Perl/Pollution/Portability version 3.55
=head1 SYNOPSIS
=head1 COMPATIBILITY
This version of F<ppport.h> is designed to support operation with Perl
-installations back to 5.003, and has been tested up to 5.20.
+installations back to 5.003, and has been tested up to 5.30.
=head1 OPTIONS
-----------------------------------------------------------------------------------------
PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL
PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL
- SvRX() NEED_SvRX NEED_SvRX_GLOBAL
caller_cx() NEED_caller_cx NEED_caller_cx_GLOBAL
croak_xs_usage() NEED_croak_xs_usage NEED_croak_xs_usage_GLOBAL
die_sv() NEED_die_sv NEED_die_sv_GLOBAL
grok_number() NEED_grok_number NEED_grok_number_GLOBAL
grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL
grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL
- gv_fetchpvn_flags() NEED_gv_fetchpvn_flags NEED_gv_fetchpvn_flags_GLOBAL
load_module() NEED_load_module NEED_load_module_GLOBAL
mess() NEED_mess NEED_mess_GLOBAL
mess_nocontext() NEED_mess_nocontext NEED_mess_nocontext_GLOBAL
my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL
my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL
my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL
+ my_strnlen() NEED_my_strnlen NEED_my_strnlen_GLOBAL
newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL
- newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL
- newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL
- newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL
newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL
pv_display() NEED_pv_display NEED_pv_display_GLOBAL
pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL
pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL
- sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL
- sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL
sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL
sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL
- sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL
sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL
sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL
sv_unmagicext() NEED_sv_unmagicext NEED_sv_unmagicext_GLOBAL
+ utf8_to_uvchr_buf() NEED_utf8_to_uvchr_buf NEED_utf8_to_uvchr_buf_GLOBAL
vload_module() NEED_vload_module NEED_vload_module_GLOBAL
vmess() NEED_vmess NEED_vmess_GLOBAL
- vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL
warner() NEED_warner NEED_warner_GLOBAL
To avoid namespace conflicts, you can change the namespace of the
If F<ppport.h> was generated using the latest version of
C<Devel::PPPort> and is causing failure of this module, please
-file a bug report here: L<https://github.com/mhx/Devel-PPPort/issues/>
+send a bug report to L<perlbug@perl.org|mailto:perlbug@perl.org>.
Please include the following information:
use strict;
# Disable broken TRIE-optimization
-BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }
+BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if "$]" >= 5.009004 && "$]" <= 5.009005 }
-my $VERSION = 3.39;
+my $VERSION = 3.55;
my %opt = (
quiet => 0,
(index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()),
} )
: die "invalid spec: $_" } qw(
-ASCII_TO_NEED||5.007001|n
AvFILLp|5.004050||p
AvFILL|||
-BhkDISABLE||5.024000|
-BhkENABLE||5.024000|
-BhkENTRY_set||5.024000|
-BhkENTRY|||
-BhkFLAGS|||
-CALL_BLOCK_HOOKS|||
-CLASS|||n
+BOM_UTF8|||
+CLASS|||
CPERLscope|5.005000||p
-CX_CURPAD_SAVE|||
-CX_CURPAD_SV|||
C_ARRAY_END|5.013002||p
C_ARRAY_LENGTH|5.008001||p
CopFILEAV|5.006000||p
CopSTASH|5.006000||p
CopyD|5.009002|5.004050|p
Copy|||
-CvPADLIST||5.008001|
CvSTASH|||
-CvWEAKOUTSIDE|||
-DECLARATION_FOR_LC_NUMERIC_MANIPULATION||5.021010|n
+DECLARATION_FOR_LC_NUMERIC_MANIPULATION||5.021010|
DEFSV_set|5.010001||p
DEFSV|5.004050||p
DO_UTF8||5.006000|
END_EXTERN_C|5.005000||p
+ENTER_with_name|||
ENTER|||
ERRSV|5.004050||p
EXTEND|||
EXTERN_C|5.005000||p
-F0convert|||n
FREETMPS|||
-GIMME_V||5.004000|n
-GIMME|||n
+GIMME_V||5.004000|
+GIMME|||
GROK_NUMERIC_RADIX|5.007002||p
+GV_NOADD_MASK|||p
G_ARRAY|||
G_DISCARD|||
G_EVAL|||
GvAV|||
GvCV|||
GvHV|||
+GvSVn|||p
GvSV|||
Gv_AMupdate||5.011000|
HEf_SVKEY|5.003070||p
IVSIZE|5.006000||p
IVTYPE|5.006000||p
IVdf|5.006000||p
+LEAVE_with_name|||
LEAVE|||
+LIKELY|||p
LINKLIST||5.013006|
-LVRET|||
MARK|||
MULTICALL||5.024000|
MUTABLE_PTR|5.010001||p
MY_CXT|5.007003||p
MoveD|5.009002|5.004050|p
Move|||
-NATIVE_TO_NEED||5.007001|n
NOOP|5.005000||p
NUM2PTR|5.006000||p
NVTYPE|5.006000||p
OpMAYBESIB_set|5.021011||p
OpMORESIB_set|5.021011||p
OpSIBLING|5.021007||p
-PAD_BASE_SV|||
-PAD_CLONE_VARS|||
-PAD_COMPNAME_FLAGS|||
-PAD_COMPNAME_GEN_set|||
-PAD_COMPNAME_GEN|||
-PAD_COMPNAME_OURSTASH|||
-PAD_COMPNAME_PV|||
-PAD_COMPNAME_TYPE|||
-PAD_RESTORE_LOCAL|||
-PAD_SAVE_LOCAL|||
-PAD_SAVE_SETNULLPAD|||
-PAD_SETSV|||
-PAD_SET_CUR_NOSAVE|||
-PAD_SET_CUR|||
-PAD_SVl|||
-PAD_SV|||
PERLIO_FUNCS_CAST|5.009003||p
PERLIO_FUNCS_DECL|5.009003||p
PERL_ABS|5.008001||p
PERL_USHORT_MIN|5.003070||p
PERL_VERSION|5.006000||p
PL_DBsignal|5.005000||p
-PL_DBsingle|||pn
-PL_DBsub|||pn
-PL_DBtrace|||pn
+PL_DBsingle|||p
+PL_DBsub|||p
+PL_DBtrace|||p
PL_Sv|5.005000||p
PL_bufend|5.024000||p
PL_bufptr|5.024000||p
PL_check||5.006000|
PL_compiling|5.004050||p
-PL_comppad_name||5.017004|
-PL_comppad||5.008001|
PL_copline|5.024000||p
PL_curcop|5.004050||p
-PL_curpad||5.005000|
PL_curstash|5.004050||p
PL_debstash|5.004050||p
PL_defgv|5.004050||p
PL_diehook|5.004050||p
PL_dirty|5.004050||p
-PL_dowarn|||pn
+PL_dowarn|||p
PL_errgv|5.004050||p
PL_error_count|5.024000||p
PL_expect|5.024000||p
PL_hints|5.005000||p
PL_in_my_stash|5.024000||p
PL_in_my|5.024000||p
-PL_keyword_plugin||5.011002|
-PL_last_in_gv|||n
PL_laststatval|5.005000||p
PL_lex_state|5.024000||p
PL_lex_stuff|5.024000||p
PL_linestr|5.024000||p
-PL_modglobal||5.005000|n
-PL_na|5.004050||pn
+PL_modglobal||5.005000|
+PL_na|5.004050||p
PL_no_modify|5.006000||p
-PL_ofsgv|||n
-PL_opfreehook||5.011000|n
+PL_opfreehook||5.011000|
PL_parser|5.009005||p
-PL_peepp||5.007003|n
+PL_peepp||5.007003|
PL_perl_destruct_level|5.004050||p
PL_perldb|5.004050||p
PL_ppaddr|5.006000||p
-PL_rpeepp||5.013005|n
+PL_rpeepp||5.013005|
PL_rsfp_filters|5.024000||p
PL_rsfp|5.024000||p
-PL_rs|||n
PL_signals|5.008001||p
PL_stack_base|5.004050||p
PL_stack_sp|5.004050||p
PL_statcache|5.005000||p
PL_stdingv|5.004050||p
PL_sv_arenaroot|5.004050||p
-PL_sv_no|5.004050||pn
-PL_sv_undef|5.004050||pn
-PL_sv_yes|5.004050||pn
+PL_sv_no|5.004050||p
+PL_sv_undef|5.004050||p
+PL_sv_yes|5.004050||p
+PL_sv_zero|||
PL_tainted|5.004050||p
PL_tainting|5.004050||p
PL_tokenbuf|5.024000||p
POP_MULTICALL||5.024000|
-POPi|||n
-POPl|||n
-POPn|||n
-POPpbytex||5.007001|n
-POPpx||5.005030|n
-POPp|||n
-POPs|||n
-POPul||5.006000|n
-POPu||5.004000|n
+POPi|||
+POPl|||
+POPn|||
+POPpbytex||5.007001|
+POPpx||5.005030|
+POPp|||
+POPs|||
+POPul||5.006000|
+POPu||5.004000|
PTR2IV|5.006000||p
PTR2NV|5.006000||p
PTR2UV|5.006000||p
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
-PadARRAY||5.024000|
-PadMAX||5.024000|
-PadlistARRAY||5.024000|
-PadlistMAX||5.024000|
-PadlistNAMESARRAY||5.024000|
-PadlistNAMESMAX||5.024000|
-PadlistNAMES||5.024000|
-PadlistREFCNT||5.017004|
-PadnameIsOUR|||
-PadnameIsSTATE|||
-PadnameLEN||5.024000|
-PadnameOURSTASH|||
-PadnameOUTER|||
-PadnamePV||5.024000|
-PadnameREFCNT_dec||5.024000|
-PadnameREFCNT||5.024000|
-PadnameSV||5.024000|
-PadnameTYPE|||
-PadnameUTF8||5.021007|
-PadnamelistARRAY||5.024000|
-PadnamelistMAX||5.024000|
-PadnamelistREFCNT_dec||5.024000|
-PadnamelistREFCNT||5.024000|
PerlIO_clearerr||5.007003|
PerlIO_close||5.007003|
PerlIO_context_layers||5.009004|
PerlIO_get_cnt||5.007003|
PerlIO_get_ptr||5.007003|
PerlIO_read||5.007003|
-PerlIO_restore_errno|||
-PerlIO_save_errno|||
PerlIO_seek||5.007003|
PerlIO_set_cnt||5.007003|
PerlIO_set_ptrcnt||5.007003|
PerlIO_tell||5.007003|
PerlIO_unread||5.007003|
PerlIO_write||5.007003|
-Perl_signbit||5.009005|n
+Perl_langinfo|||n
+Perl_setlocale|||n
PoisonFree|5.009004||p
PoisonNew|5.009004||p
PoisonWith|5.009004||p
Poison|5.008000||p
READ_XDIGIT||5.017006|
+REPLACEMENT_CHARACTER_UTF8|||
RESTORE_LC_NUMERIC||5.024000|
-RETVAL|||n
+RETVAL|||
Renewc|||
Renew|||
-SAVECLEARSV|||
-SAVECOMPPAD|||
-SAVEPADSV|||
SAVETMPS|||
SAVE_DEFSV|5.004050||p
SPAGAIN|||
SVt_PV|||
SVt_REGEXP||5.011000|
Safefree|||
-Slab_Alloc|||
-Slab_Free|||
-Slab_to_ro|||
-Slab_to_rw|||
StructCopy|||
SvCUR_set|||
SvCUR|||
SvPOK_on|||
SvPOKp|||
SvPOK|||
+SvPVCLEAR|||
SvPVX_const|5.009003||p
SvPVX_mutable|5.009003||p
SvPVX|||
SvPVutf8||5.006000|
SvPVx|||
SvPV|||
+SvREADONLY_off|||
+SvREADONLY_on|||
+SvREADONLY|||
SvREFCNT_dec_NN||5.017007|
SvREFCNT_dec|||
SvREFCNT_inc_NN|5.009004||p
SvTAINTED_on||5.004000|
SvTAINTED||5.004000|
SvTAINT|||
-SvTHINKFIRST|||
SvTRUE_nomg||5.013006|
SvTRUE|||
SvTYPE|||
SvUV|5.004000||p
SvVOK||5.008001|
SvVSTRING_mg|5.009004||p
-THIS|||n
+THIS|||
UNDERBAR|5.009002||p
+UNICODE_REPLACEMENT|||p
+UNLIKELY|||p
UTF8SKIP||5.006000|
+UTF8_ALLOW_ANYUV|||p
+UTF8_ALLOW_ANY|||p
+UTF8_ALLOW_CONTINUATION|||p
+UTF8_ALLOW_EMPTY|||p
+UTF8_ALLOW_LONG|||p
+UTF8_ALLOW_NON_CONTINUATION|||p
+UTF8_ALLOW_OVERFLOW|||p
+UTF8_ALLOW_SHORT|||p
+UTF8_IS_INVARIANT|||
+UTF8_IS_NONCHAR|||
+UTF8_IS_SUPER|||
+UTF8_IS_SURROGATE|||
UTF8_MAXBYTES|5.009002||p
+UTF8_SAFE_SKIP|||p
+UVCHR_IS_INVARIANT|||
UVCHR_SKIP||5.022000|
UVSIZE|5.006000||p
UVTYPE|5.006000||p
XopFLAGS||5.013007|
ZeroD|5.009002||p
Zero|||
+__ASSERT_|||p
_aMY_CXT|5.007003||p
-_add_range_to_invlist|||
-_append_range_to_invlist|||
-_core_swash_init|||
-_get_encoding|||
-_get_regclass_nonbitmap_data|||
-_get_swash_invlist|||
-_invlistEQ|||
-_invlist_array_init|||n
-_invlist_contains_cp|||n
-_invlist_dump|||
-_invlist_intersection_maybe_complement_2nd|||
-_invlist_intersection|||
-_invlist_invert|||
-_invlist_len|||n
-_invlist_populate_swatch|||n
-_invlist_search|||n
-_invlist_subtract|||
-_invlist_union_maybe_complement_2nd|||
-_invlist_union|||
-_is_cur_LC_category_utf8|||
-_is_in_locale_category||5.021001|
-_is_uni_FOO||5.017008|
-_is_uni_perl_idcont||5.017008|
-_is_uni_perl_idstart||5.017007|
-_is_utf8_FOO||5.017008|
-_is_utf8_char_slow||5.021001|n
-_is_utf8_idcont||5.021001|
-_is_utf8_idstart||5.021001|
-_is_utf8_mark||5.017008|
-_is_utf8_perl_idcont||5.017008|
-_is_utf8_perl_idstart||5.017007|
-_is_utf8_xidcont||5.021001|
-_is_utf8_xidstart||5.021001|
-_load_PL_utf8_foldclosures|||
-_make_exactf_invlist|||
-_new_invlist_C_array|||
-_new_invlist|||
_pMY_CXT|5.007003||p
-_setlocale_debug_string|||n
-_setup_canned_invlist|||
-_swash_inversion_hash|||
-_swash_to_invlist|||
-_to_fold_latin1|||
-_to_uni_fold_flags||5.014000|
-_to_upper_title_latin1|||
-_to_utf8_case|||
-_to_utf8_fold_flags||5.019009|
-_to_utf8_lower_flags||5.019009|
-_to_utf8_title_flags||5.019009|
-_to_utf8_upper_flags||5.019009|
-_warn_problematic_locale|||n
+_variant_byte_number|||n
aMY_CXT_|5.007003||p
aMY_CXT|5.007003||p
aTHXR_|5.024000||p
aTHXR|5.024000||p
aTHX_|5.006000||p
aTHX|5.006000||p
-add_above_Latin1_folds|||
-add_cp_to_invlist|||
-add_data|||n
-add_multi_match|||
-add_utf16_textfilter|||
-adjust_size_and_find_bucket|||n
-advance_one_LB|||
-advance_one_SB|||
-advance_one_WB|||
-alloc_maybe_populate_EXACT|||
-alloccopstash|||
-allocmy|||
amagic_call|||
-amagic_cmp_locale|||
-amagic_cmp|||
amagic_deref_call||5.013007|
-amagic_i_ncmp|||
-amagic_is_enabled|||
-amagic_ncmp|||
-anonymise_cv_maybe|||
any_dup|||
-ao|||
-append_utf8_from_native_byte||5.019004|n
-apply_attrs_my|||
-apply_attrs_string||5.006001|
-apply_attrs|||
-apply|||
-assert_uft8_cache_coherent|||
-assignment_type|||
atfork_lock||5.007003|n
atfork_unlock||5.007003|n
av_arylen_p||5.009003|
av_clear|||
-av_create_and_push||5.009005|
-av_create_and_unshift_one||5.009005|
av_delete||5.006000|
av_exists||5.006000|
-av_extend_guts|||
av_extend|||
av_fetch|||
av_fill|||
av_make|||
av_pop|||
av_push|||
-av_reify|||
av_shift|||
av_store|||
-av_tindex||5.017009|
-av_top_index||5.017009|
+av_tindex|5.017009|5.017009|p
+av_top_index|5.017009|5.017009|p
av_undef|||
av_unshift|||
-ax|||n
-backup_one_LB|||
-backup_one_SB|||
-backup_one_WB|||
-bad_type_gv|||
-bad_type_pv|||
-bind_match|||
+ax|||
block_end||5.004000|
block_gimme||5.004000|
block_start||5.004000|
-blockhook_register||5.013003|
boolSV|5.004000||p
-boot_core_PerlIO|||
-boot_core_UNIVERSAL|||
-boot_core_mro|||
bytes_cmp_utf8||5.013007|
-bytes_from_utf8||5.007001|
-bytes_to_utf8||5.006001|
cBOOL|5.013000||p
call_argv|5.006000||p
call_atexit||5.006000|
call_sv|5.006000||p
caller_cx|5.013005|5.006000|p
calloc||5.007002|n
-cando|||
cast_i32||5.006000|n
cast_iv||5.006000|n
cast_ulong||5.006000|n
cast_uv||5.006000|n
-check_locale_boundary_crossing|||
-check_type_and_open|||
-check_uni|||
-check_utf8_print|||
-checkcomma|||
+ckWARN2_d|||
+ckWARN2|||
+ckWARN3_d|||
+ckWARN3|||
+ckWARN4_d|||
+ckWARN4|||
+ckWARN_d|||
ckWARN|5.006000||p
-ck_entersub_args_core|||
ck_entersub_args_list||5.013006|
ck_entersub_args_proto_or_list||5.013006|
ck_entersub_args_proto||5.013006|
ck_warner_d||5.011001|v
ck_warner||5.011001|v
-ckwarn_common|||
ckwarn_d||5.009003|
ckwarn||5.009003|
clear_defarray||5.023008|
-clear_placeholders|||
-clear_special_blocks|||
clone_params_del|||n
clone_params_new|||n
-closest_cop|||
-cntrl_to_mnemonic|||n
-compute_EXACTish|||n
-construct_ahocorasick_from_trie|||
-cop_fetch_label||5.015001|
-cop_free|||
cop_hints_2hv||5.013007|
cop_hints_fetch_pvn||5.013007|
cop_hints_fetch_pvs||5.013007|
cop_hints_fetch_pv||5.013007|
cop_hints_fetch_sv||5.013007|
-cop_store_label||5.015001|
-cophh_2hv||5.013007|
-cophh_copy||5.013007|
-cophh_delete_pvn||5.013007|
-cophh_delete_pvs||5.013007|
-cophh_delete_pv||5.013007|
-cophh_delete_sv||5.013007|
-cophh_fetch_pvn||5.013007|
-cophh_fetch_pvs||5.013007|
-cophh_fetch_pv||5.013007|
-cophh_fetch_sv||5.013007|
-cophh_free||5.013007|
-cophh_new_empty||5.024000|
-cophh_store_pvn||5.013007|
-cophh_store_pvs||5.013007|
-cophh_store_pv||5.013007|
-cophh_store_sv||5.013007|
-core_prototype|||
-coresub_op|||
-cr_textfilter|||
-create_eval_scope|||
croak_memory_wrap|5.019003||pn
-croak_no_mem|||n
croak_no_modify|5.013003||pn
croak_nocontext|||pvn
-croak_popstack|||n
croak_sv|5.013001||p
croak_xs_usage|5.010001||pn
croak|||v
csighandler||5.009003|n
-current_re_engine|||
-curse|||
custom_op_desc||5.007003|
-custom_op_get_field|||
custom_op_name||5.007003|
custom_op_register||5.013007|
custom_op_xop||5.013007|
-cv_ckproto_len_flags|||
-cv_clone_into|||
cv_clone|||
-cv_const_sv_or_av|||n
cv_const_sv||5.003070|n
-cv_dump|||
-cv_forget_slab|||
+cv_get_call_checker_flags|||
cv_get_call_checker||5.013006|
cv_name||5.021005|
cv_set_call_checker_flags||5.021004|
cv_set_call_checker||5.013006|
-cv_undef_flags|||
cv_undef|||
-cvgv_from_hek|||
-cvgv_set|||
-cvstash_set|||
cx_dump||5.005000|
cx_dup|||
-cx_popblock||5.023008|
-cx_popeval||5.023008|
-cx_popformat||5.023008|
-cx_popgiven||5.023008|
-cx_poploop||5.023008|
-cx_popsub_args||5.023008|
-cx_popsub_common||5.023008|
-cx_popsub||5.023008|
-cx_popwhen||5.023008|
-cx_pushblock||5.023008|
-cx_pusheval||5.023008|
-cx_pushformat||5.023008|
-cx_pushgiven||5.023008|
-cx_pushloop_for||5.023008|
-cx_pushloop_plain||5.023008|
-cx_pushsub||5.023008|
-cx_pushwhen||5.023008|
-cx_topblock||5.023008|
cxinc|||
dAXMARK|5.009003||p
dAX|5.007002||p
dXSARGS|||
dXSI32|||
dXSTARG|5.006000||p
-deb_curcv|||
deb_nocontext|||vn
-deb_stack_all|||
-deb_stack_n|||
debop||5.005000|
debprofdump||5.005000|
-debprof|||
debstackptrs||5.007003|
debstack||5.007003|
-debug_start_match|||
deb||5.007003|v
-defelem_target|||
-del_sv|||
-delete_eval_scope|||
delimcpy||5.004000|n
-deprecate_commaless_var_list|||
despatch_signals||5.007001|
-destroy_matcher|||
die_nocontext|||vn
die_sv|5.013001||p
-die_unwind|||
die|||v
dirp_dup|||
-div128|||
-djSP|||
-do_aexec5|||
-do_aexec|||
do_aspawn|||
do_binmode||5.004050|
-do_chomp|||
do_close|||
-do_delete_local|||
-do_dump_pad|||
-do_eof|||
-do_exec3|||
-do_execfree|||
-do_exec|||
do_gv_dump||5.006000|
do_gvgv_dump||5.006000|
do_hv_dump||5.006000|
-do_ipcctl|||
-do_ipcget|||
do_join|||
do_magic_dump||5.006000|
-do_msgrcv|||
-do_msgsnd|||
-do_ncmp|||
-do_oddball|||
do_op_dump||5.006000|
-do_open6|||
do_open9||5.006000|
-do_open_raw|||
do_openn||5.007001|
do_open||5.003070|
do_pmop_dump||5.006000|
-do_print|||
-do_readline|||
-do_seek|||
-do_semop|||
-do_shmio|||
-do_smartmatch|||
do_spawn_nowait|||
do_spawn|||
do_sprintf|||
do_sv_dump||5.006000|
-do_sysseek|||
-do_tell|||
-do_trans_complex_utf8|||
-do_trans_complex|||
-do_trans_count_utf8|||
-do_trans_count|||
-do_trans_simple_utf8|||
-do_trans_simple|||
-do_trans|||
-do_vecget|||
-do_vecset|||
-do_vop|||
-docatch|||
-doeval_compile|||
-dofile|||
-dofindlabel|||
-doform|||
doing_taint||5.008001|n
-dooneliner|||
-doopen_pm|||
-doparseform|||
-dopoptoeval|||
-dopoptogivenfor|||
-dopoptolabel|||
-dopoptoloop|||
-dopoptosub_at|||
-dopoptowhen|||
doref||5.009003|
dounwind|||
dowantarray|||
-drand48_init_r|||n
-drand48_r|||n
-dtrace_probe_call|||
-dtrace_probe_load|||
-dtrace_probe_op|||
-dtrace_probe_phase|||
-dump_all_perl|||
dump_all||5.006000|
dump_c_backtrace|||
dump_eval||5.006000|
-dump_exec_pos|||
dump_form||5.006000|
dump_indent||5.006000|v
dump_mstats|||
-dump_packsubs_perl|||
dump_packsubs||5.006000|
-dump_sub_perl|||
dump_sub||5.006000|
-dump_sv_child|||
-dump_trie_interim_list|||
-dump_trie_interim_table|||
-dump_trie|||
dump_vindent||5.006000|
-dumpuntil|||
-dup_attrlist|||
-edit_distance|||n
-emulate_cop_io|||
eval_pv|5.006000||p
eval_sv|5.006000||p
-exec_failed|||
-expect_number|||
fbm_compile||5.005000|
fbm_instr||5.005000|
-feature_is_enabled|||
filter_add|||
filter_del|||
-filter_gets|||
filter_read|||
-finalize_optree|||
-finalize_op|||
-find_and_forget_pmops|||
-find_array_subscript|||
-find_beginning|||
-find_byclass|||
-find_default_stash|||
-find_hash_subscript|||
-find_in_my_stash|||
-find_lexical_cv|||
-find_runcv_where|||
find_runcv||5.008001|
-find_rundefsvoffset||5.009002|
find_rundefsv||5.013002|
-find_script|||
-find_uninit_var|||
-first_symbol|||n
-fixup_errno_string|||
foldEQ_latin1||5.013008|n
foldEQ_locale||5.013002|n
-foldEQ_utf8_flags||5.013010|
foldEQ_utf8||5.013002|
foldEQ||5.013002|n
-fold_constants|||
-forbid_setid|||
-force_ident_maybe_lex|||
-force_ident|||
-force_list|||
-force_next|||
-force_strict_version|||
-force_version|||
-force_word|||
-forget_pmop|||
form_nocontext|||vn
-form_short_octal_warning|||
form||5.004000|v
fp_dup|||
fprintf_nocontext|||vn
-free_c_backtrace|||
free_global_struct|||
-free_tied_hv_pool|||
free_tmps|||
-gen_constant_list|||
-get_ANYOF_cp_list_for_ssc|||
-get_and_check_backslash_N_name|||
-get_aux_mg|||
get_av|5.006000||p
get_c_backtrace_dump|||
-get_c_backtrace|||
get_context||5.006000|n
-get_cvn_flags|||
+get_cvn_flags|5.009005||p
get_cvs|5.011000||p
get_cv|5.006000||p
-get_db_sub|||
-get_debug_opts|||
-get_hash_seed|||
get_hv|5.006000||p
-get_invlist_iter_addr|||n
-get_invlist_offset_addr|||n
-get_invlist_previous_index_addr|||n
get_mstats|||
-get_no_modify|||
-get_num|||
get_op_descs||5.005000|
get_op_names||5.005000|
-get_opargs|||
get_ppaddr||5.006000|
-get_re_arg|||
get_sv|5.006000||p
get_vtbl||5.005030|
getcwd_sv||5.007002|
-getenv_len|||
-glob_2number|||
-glob_assign_glob|||
gp_dup|||
gp_free|||
gp_ref|||
-grok_atoUV|||n
grok_bin|5.007003||p
-grok_bslash_N|||
-grok_bslash_c|||
-grok_bslash_o|||
-grok_bslash_x|||
grok_hex|5.007003||p
grok_infnan||5.021004|
grok_number_flags||5.021002|
grok_number|5.007002||p
grok_numeric_radix|5.007002||p
grok_oct|5.007003||p
-group_end|||
gv_AVadd|||
gv_HVadd|||
gv_IOadd|||
gv_fetchfile_flags||5.009005|
gv_fetchfile|||
gv_fetchmeth_autoload||5.007003|
-gv_fetchmeth_internal|||
gv_fetchmeth_pv_autoload||5.015004|
gv_fetchmeth_pvn_autoload||5.015004|
gv_fetchmeth_pvn||5.015004|
gv_fetchmeth_sv_autoload||5.015004|
gv_fetchmeth_sv||5.015004|
gv_fetchmethod_autoload||5.004000|
-gv_fetchmethod_pv_flags||5.015004|
-gv_fetchmethod_pvn_flags||5.015004|
-gv_fetchmethod_sv_flags||5.015004|
gv_fetchmethod|||
gv_fetchmeth|||
gv_fetchpvn_flags|5.009002||p
gv_fetchpvs|5.009004||p
gv_fetchpv|||
-gv_fetchsv|||
+gv_fetchsv|5.009002||p
gv_fullname3||5.003070|
gv_fullname4||5.006001|
gv_fullname|||
gv_handler||5.007001|
-gv_init_pvn|||
+gv_init_pvn|5.015004||p
gv_init_pv||5.015004|
-gv_init_svtype|||
gv_init_sv||5.015004|
gv_init|||
-gv_is_in_main|||
-gv_magicalize_isa|||
-gv_magicalize|||
gv_name_set||5.009004|
-gv_override|||
-gv_setref|||
-gv_stashpvn_internal|||
gv_stashpvn|5.003070||p
gv_stashpvs|5.009003||p
gv_stashpv|||
-gv_stashsvpvn_cached|||
gv_stashsv|||
-gv_try_downgrade|||
-handle_named_backref|||
-handle_possible_posix|||
-handle_regex_sets|||
he_dup|||
hek_dup|||
-hfree_next_entry|||
-hsplit|||
hv_assert|||
-hv_auxinit_internal|||n
-hv_auxinit|||
-hv_backreferences_p|||
hv_clear_placeholders||5.009001|
hv_clear|||
hv_common_key_len||5.010000|
hv_common||5.010000|
hv_copy_hints_hv||5.009004|
hv_delayfree_ent||5.004000|
-hv_delete_common|||
hv_delete_ent||5.003070|
hv_delete|||
hv_eiter_p||5.009003|
hv_eiter_set||5.009003|
-hv_ename_add|||
-hv_ename_delete|||
hv_exists_ent||5.003070|
hv_exists|||
hv_fetch_ent||5.003070|
hv_fetchs|5.009003||p
hv_fetch|||
hv_fill||5.013002|
-hv_free_ent_ret|||
-hv_free_entries|||
hv_free_ent||5.004000|
hv_iterinit|||
hv_iterkeysv||5.003070|
hv_iterkey|||
-hv_iternext_flags||5.008000|
hv_iternextsv|||
hv_iternext|||
hv_iterval|||
-hv_kill_backrefs|||
hv_ksplit||5.003070|
-hv_magic_check|||n
hv_magic|||
hv_name_set||5.009003|
-hv_notallowed|||
hv_placeholders_get||5.009003|
-hv_placeholders_p|||
hv_placeholders_set||5.009003|
hv_rand_set||5.018000|
hv_riter_p||5.009003|
hv_riter_set||5.009003|
hv_scalar||5.009001|
hv_store_ent||5.003070|
-hv_store_flags||5.008000|
hv_stores|5.009004||p
hv_store|||
-hv_undef_flags|||
hv_undef|||
ibcmp_locale||5.004000|
ibcmp_utf8||5.007003|
ibcmp|||
-incline|||
-incpush_if_exists|||
-incpush_use_sep|||
-incpush|||
-ingroup|||
-init_argv_symbols|||
-init_constants|||
-init_dbargs|||
-init_debugger|||
init_global_struct|||
-init_i18nl10n||5.006000|
-init_i18nl14n||5.006000|
-init_ids|||
-init_interp|||
-init_main_stash|||
-init_perllib|||
-init_postdump_symbols|||
-init_predump_symbols|||
init_stacks||5.005000|
init_tm||5.007002|
-inplace_aassign|||
instr|||n
intro_my||5.004000|
-intuit_method|||
-intuit_more|||
-invert|||
-invlist_array|||n
-invlist_clear|||
-invlist_clone|||
-invlist_contents|||
-invlist_extend|||
-invlist_highest|||n
-invlist_is_iterating|||n
-invlist_iterfinish|||n
-invlist_iterinit|||n
-invlist_iternext|||n
-invlist_max|||n
-invlist_previous_index|||n
-invlist_replace_list_destroys_src|||
-invlist_set_len|||
-invlist_set_previous_index|||n
-invlist_trim|||n
-invoke_exception_hook|||
-io_close|||
+isALNUMC_A|||p
isALNUMC|5.006000||p
-isALNUM_lazy||5.021001|
-isALPHANUMERIC||5.017008|
-isALPHA|||
+isALNUM_A|||p
+isALNUM|||p
+isALPHANUMERIC_A|||p
+isALPHANUMERIC|5.017008|5.017008|p
+isALPHA_A|||p
+isALPHA|||p
+isASCII_A|||p
isASCII|5.006000||p
+isBLANK_A|||p
isBLANK|5.006001||p
+isC9_STRICT_UTF8_CHAR|||n
+isCNTRL_A|||p
isCNTRL|5.006000||p
-isDIGIT|||
-isFOO_lc|||
-isFOO_utf8_lc|||
-isGCB|||n
+isDIGIT_A|||p
+isDIGIT|||p
+isGRAPH_A|||p
isGRAPH|5.006000||p
-isIDCONT||5.017008|
-isIDFIRST_lazy||5.021001|
-isIDFIRST|||
-isLB|||
-isLOWER|||
-isOCTAL||5.013005|
+isGV_with_GP|||p
+isIDCONT_A|||p
+isIDCONT|5.017008|5.017008|p
+isIDFIRST_A|||p
+isIDFIRST|||p
+isLOWER_A|||p
+isLOWER|||p
+isOCTAL_A|||p
+isOCTAL|5.013005|5.013005|p
+isPRINT_A|||p
isPRINT|5.004000||p
+isPSXSPC_A|||p
isPSXSPC|5.006001||p
+isPUNCT_A|||p
isPUNCT|5.006000||p
-isSB|||
-isSPACE|||
-isUPPER|||
-isUTF8_CHAR||5.021001|
-isWB|||
-isWORDCHAR||5.013006|
+isSPACE_A|||p
+isSPACE|||p
+isSTRICT_UTF8_CHAR|||n
+isUPPER_A|||p
+isUPPER|||p
+isUTF8_CHAR_flags|||
+isUTF8_CHAR||5.021001|n
+isWORDCHAR_A|||p
+isWORDCHAR|5.013006|5.013006|p
+isXDIGIT_A|||p
isXDIGIT|5.006000||p
-is_an_int|||
-is_ascii_string||5.011000|
-is_handle_constructor|||n
+is_ascii_string||5.011000|n
+is_c9strict_utf8_string_loclen|||n
+is_c9strict_utf8_string_loc|||n
+is_c9strict_utf8_string|||n
is_invariant_string||5.021007|n
is_lvalue_sub||5.007001|
is_safe_syscall||5.019004|
-is_ssc_worth_it|||n
-is_uni_alnum_lc||5.006000|
-is_uni_alnumc_lc||5.017007|
-is_uni_alnumc||5.017007|
-is_uni_alnum||5.006000|
-is_uni_alpha_lc||5.006000|
-is_uni_alpha||5.006000|
-is_uni_ascii_lc||5.006000|
-is_uni_ascii||5.006000|
-is_uni_blank_lc||5.017002|
-is_uni_blank||5.017002|
-is_uni_cntrl_lc||5.006000|
-is_uni_cntrl||5.006000|
-is_uni_digit_lc||5.006000|
-is_uni_digit||5.006000|
-is_uni_graph_lc||5.006000|
-is_uni_graph||5.006000|
-is_uni_idfirst_lc||5.006000|
-is_uni_idfirst||5.006000|
-is_uni_lower_lc||5.006000|
-is_uni_lower||5.006000|
-is_uni_print_lc||5.006000|
-is_uni_print||5.006000|
-is_uni_punct_lc||5.006000|
-is_uni_punct||5.006000|
-is_uni_space_lc||5.006000|
-is_uni_space||5.006000|
-is_uni_upper_lc||5.006000|
-is_uni_upper||5.006000|
-is_uni_xdigit_lc||5.006000|
-is_uni_xdigit||5.006000|
-is_utf8_alnumc||5.017007|
-is_utf8_alnum||5.006000|
-is_utf8_alpha||5.006000|
-is_utf8_ascii||5.006000|
-is_utf8_blank||5.017002|
+is_strict_utf8_string_loclen|||n
+is_strict_utf8_string_loc|||n
+is_strict_utf8_string|||n
is_utf8_char_buf||5.015008|n
-is_utf8_char||5.006000|n
-is_utf8_cntrl||5.006000|
-is_utf8_common|||
-is_utf8_digit||5.006000|
-is_utf8_graph||5.006000|
-is_utf8_idcont||5.008000|
-is_utf8_idfirst||5.006000|
-is_utf8_lower||5.006000|
-is_utf8_mark||5.006000|
-is_utf8_perl_space||5.011001|
-is_utf8_perl_word||5.011001|
-is_utf8_posix_digit||5.011001|
-is_utf8_print||5.006000|
-is_utf8_punct||5.006000|
-is_utf8_space||5.006000|
+is_utf8_fixed_width_buf_flags|||n
+is_utf8_fixed_width_buf_loc_flags|||n
+is_utf8_fixed_width_buf_loclen_flags|||n
+is_utf8_invariant_string_loc|||n
+is_utf8_invariant_string|||n
+is_utf8_string_flags|||n
+is_utf8_string_loc_flags|||n
+is_utf8_string_loclen_flags|||n
is_utf8_string_loclen||5.009003|n
is_utf8_string_loc||5.008001|n
is_utf8_string||5.006001|n
-is_utf8_upper||5.006000|
-is_utf8_xdigit||5.006000|
-is_utf8_xidcont||5.013010|
-is_utf8_xidfirst||5.013010|
-isa_lookup|||
-isinfnansv|||
+is_utf8_valid_partial_char_flags|||n
+is_utf8_valid_partial_char|||n
isinfnan||5.021004|n
-items|||n
-ix|||n
-jmaybe|||
-join_exact|||
-keyword_plugin_standard|||
-keyword|||
-leave_adjust_stacks||5.023008|
+items|||
+ix|||
leave_scope|||
-lex_bufutf8||5.011002|
-lex_discard_to||5.011002|
-lex_grow_linestr||5.011002|
-lex_next_chunk||5.011002|
-lex_peek_unichar||5.011002|
-lex_read_space||5.011002|
-lex_read_to||5.011002|
-lex_read_unichar||5.011002|
-lex_start||5.009005|
-lex_stuff_pvn||5.011002|
-lex_stuff_pvs||5.013005|
-lex_stuff_pv||5.013006|
-lex_stuff_sv||5.011002|
-lex_unstuff||5.011002|
-listkids|||
-list|||
load_module_nocontext|||vn
load_module|5.006000||pv
-localize|||
-looks_like_bool|||
looks_like_number|||
-lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mXPUSHp|5.009002||p
mXPUSHs|5.010001||p
mXPUSHu|5.009002||p
-magic_clear_all_env|||
-magic_cleararylen_p|||
-magic_clearenv|||
-magic_clearhints|||
-magic_clearhint|||
-magic_clearisa|||
-magic_clearpack|||
-magic_clearsig|||
-magic_copycallchecker|||
magic_dump||5.006000|
-magic_existspack|||
-magic_freearylen_p|||
-magic_freeovrld|||
-magic_getarylen|||
-magic_getdebugvar|||
-magic_getdefelem|||
-magic_getnkeys|||
-magic_getpack|||
-magic_getpos|||
-magic_getsig|||
-magic_getsubstr|||
-magic_gettaint|||
-magic_getuvar|||
-magic_getvec|||
-magic_get|||
-magic_killbackrefs|||
-magic_methcall1|||
-magic_methcall|||v
-magic_methpack|||
-magic_nextpack|||
-magic_regdata_cnt|||
-magic_regdatum_get|||
-magic_regdatum_set|||
-magic_scalarpack|||
-magic_set_all_env|||
-magic_setarylen|||
-magic_setcollxfrm|||
-magic_setdbline|||
-magic_setdebugvar|||
-magic_setdefelem|||
-magic_setenv|||
-magic_sethint|||
-magic_setisa|||
-magic_setlvref|||
-magic_setmglob|||
-magic_setnkeys|||
-magic_setpack|||
-magic_setpos|||
-magic_setregexp|||
-magic_setsig|||
-magic_setsubstr|||
-magic_settaint|||
-magic_setutf8|||
-magic_setuvar|||
-magic_setvec|||
-magic_set|||
-magic_sizepack|||
-magic_wipepack|||
-make_matcher|||
-make_trie|||
-malloc_good_size|||n
-malloced_size|||n
malloc||5.007002|n
markstack_grow||5.021001|
-matcher_matches_sv|||
-maybe_multimagic_gv|||
-mayberelocate|||
-measure_struct|||
memEQs|5.009005||p
memEQ|5.004000||p
memNEs|5.009005||p
memNE|5.004000||p
-mem_collxfrm|||
-mem_log_alloc|||n
-mem_log_common|||n
-mem_log_free|||n
-mem_log_realloc|||n
-mess_alloc|||
mess_nocontext|||pvn
mess_sv|5.013001||p
mess|5.006000||pv
mg_clear|||
mg_copy|||
mg_dup|||
-mg_find_mglob|||
mg_findext|5.013008||pn
mg_find|||n
mg_free_type||5.013006|
+mg_freeext|||
mg_free|||
mg_get|||
-mg_length||5.005000|
-mg_localize|||
mg_magical|||n
mg_set|||
mg_size||5.005000|
mini_mktime||5.007002|n
-minus_v|||
-missingterm|||
-mode_from_discipline|||
-modkids|||
-more_bodies|||
-more_sv|||
moreswitches|||
-move_proto_attr|||
-mro_clean_isarev|||
-mro_gather_and_rename|||
mro_get_from_name||5.010001|
-mro_get_linear_isa_dfs|||
mro_get_linear_isa||5.009005|
mro_get_private_data||5.010001|
-mro_isa_changed_in|||
-mro_meta_dup|||
-mro_meta_init|||
mro_method_changed_in||5.009005|
-mro_package_moved|||
mro_register||5.010001|
mro_set_mro||5.010001|
mro_set_private_data||5.010001|
-mul128|||
-mulexp10|||n
-multideref_stringify|||
my_atof2||5.007002|
+my_atof3|||
my_atof||5.006000|
-my_attrs|||
-my_bcopy||5.004050|n
-my_bytes_to_utf8|||n
-my_bzero|||n
my_chsize|||
-my_clearenv|||
my_cxt_index|||
my_cxt_init|||
my_dirfd||5.009005|n
-my_exit_jump|||
my_exit|||
my_failure_exit||5.004000|
my_fflush_all||5.006000|
my_fork||5.007003|n
-my_kid|||
-my_lstat_flags|||
my_lstat||5.024000|
-my_memcmp|||n
-my_memset|||n
my_pclose||5.003070|
my_popen_list||5.007001|
my_popen||5.003070|
my_setenv|||
-my_setlocale|||
my_snprintf|5.009004||pvn
my_socketpair||5.007003|n
my_sprintf|5.009003||pvn
-my_stat_flags|||
my_stat||5.024000|
-my_strerror||5.021001|
my_strftime||5.007002|
my_strlcat|5.009004||pn
my_strlcpy|5.009004||pn
-my_unexec|||
+my_strnlen|||pn
+my_strtod|||n
my_vsnprintf||5.009004|n
-need_utf8|||n
newANONATTRSUB||5.006000|
newANONHASH|||
newANONLIST|||
newANONSUB|||
newASSIGNOP|||
-newATTRSUB_x|||
newATTRSUB||5.006000|
newAVREF|||
newAV|||
newFORM|||
newFOROP||5.013007|
newGIVENOP||5.009003|
-newGIVWHENOP|||
-newGP|||
newGVOP|||
newGVREF|||
newGVgen_flags||5.015004|
newLOGOP|||
newLOOPEX|||
newLOOPOP|||
-newMETHOP_internal|||
newMETHOP_named||5.021005|
newMETHOP||5.021005|
newMYSUB||5.017004|
newNULLLIST|||
newOP|||
-newPADNAMELIST||5.021007|n
-newPADNAMEouter||5.021007|n
-newPADNAMEpvn||5.021007|n
newPADOP|||
newPMOP|||
newPROG|||
newRV|||
newSLICEOP|||
newSTATEOP|||
-newSTUB|||
newSUB|||
newSVOP|||
newSVREF|||
newSV_type|5.009005||p
-newSVavdefelem|||
newSVhek||5.009003|
newSViv|||
newSVnv|||
-newSVpadname||5.017004|
newSVpv_share||5.013006|
newSVpvf_nocontext|||vn
newSVpvf||5.004000|v
newSVpvs|5.009003||p
newSVpv|||
newSVrv|||
+newSVsv_flags|||
+newSVsv_nomg|||p
newSVsv|||
newSVuv|5.006000||p
newSV|||
newUNOP|||
newWHENOP||5.009003|
newWHILEOP||5.013007|
-newXS_deffile|||
-newXS_flags||5.009004|
-newXS_len_flags|||
newXSproto||5.006000|
newXS||5.006000|
-new_collate||5.006000|
-new_constant|||
-new_ctype||5.006000|
-new_he|||
-new_logop|||
-new_numeric||5.006000|
new_stackinfo||5.005000|
new_version||5.009000|
-new_warnings_bitfield|||
-next_symbol|||
-nextargv|||
-nextchar|||
ninstr|||n
-no_bareword_allowed|||
-no_fh_allowed|||
-no_op|||
-noperl_die|||vn
-not_a_number|||
-not_incrementable|||
nothreadhook||5.008000|
-nuke_stacks|||
-num_overflow|||n
-oopsAV|||
-oopsHV|||
op_append_elem||5.013006|
op_append_list||5.013006|
-op_clear|||
+op_class|||
op_contextualize||5.013006|
op_convert_list||5.021006|
op_dump||5.006000|
op_free|||
-op_integerize|||
op_linklist||5.013006|
-op_lvalue_flags|||
-op_lvalue||5.013007|
op_null||5.007002|
op_parent|||n
op_prepend_elem||5.013006|
-op_refcnt_dec|||
-op_refcnt_inc|||
op_refcnt_lock||5.009002|
op_refcnt_unlock||5.009002|
-op_relocate_sv|||
-op_scope||5.013007|
op_sibling_splice||5.021002|n
-op_std_init|||
-op_unscope|||
-open_script|||
-openn_cleanup|||
-openn_setup|||
-opmethod_stash|||
-opslab_force_free|||
-opslab_free_nopad|||
-opslab_free|||
-output_or_return_posix_warnings|||
pMY_CXT_|5.007003||p
pMY_CXT|5.007003||p
pTHX_|5.006000||p
pTHX|5.006000||p
packWARN|5.007003||p
pack_cat||5.007003|
-pack_rec|||
-package_version|||
-package|||
packlist||5.008001|
pad_add_anon||5.008001|
pad_add_name_pvn||5.015001|
pad_add_name_pvs||5.015001|
pad_add_name_pv||5.015001|
pad_add_name_sv||5.015001|
-pad_add_weakref|||
-pad_alloc_name|||
-pad_alloc|||
-pad_block_start|||
-pad_check_dup|||
pad_compname_type||5.009003|
-pad_findlex|||
pad_findmy_pvn||5.015001|
pad_findmy_pvs||5.015001|
pad_findmy_pv||5.015001|
pad_findmy_sv||5.015001|
-pad_fixup_inner_anons|||
-pad_free|||
-pad_leavemy|||
pad_new||5.008001|
-pad_push|||
-pad_reset|||
pad_setsv|||
pad_sv|||
-pad_swipe|||
-pad_tidy||5.008001|
-padlist_dup|||
-padlist_store|||
-padname_dup|||
-padname_free|||
-padnamelist_dup|||
-padnamelist_fetch||5.021007|n
-padnamelist_free|||
-padnamelist_store||5.021007|
-parse_arithexpr||5.013008|
-parse_barestmt||5.013007|
-parse_block||5.013007|
-parse_body|||
-parse_fullexpr||5.013008|
-parse_fullstmt||5.013005|
-parse_gv_stash_name|||
-parse_ident|||
-parse_label||5.013007|
-parse_listexpr||5.013008|
-parse_lparen_question_flags|||
-parse_stmtseq||5.013006|
-parse_subsignature|||
-parse_termexpr||5.013008|
-parse_unicode_opts|||
parser_dup|||
-parser_free_nexttoke_ops|||
-parser_free|||
-path_is_searchable|||n
-peep|||
-pending_ident|||
perl_alloc_using|||n
perl_alloc|||n
perl_clone_using|||n
perl_free|||n
perl_parse||5.006000|n
perl_run|||n
-pidgone|||
-pm_description|||
pmop_dump||5.006000|
-pmruntime|||
-pmtrans|||
pop_scope|||
-populate_ANYOF_from_invlist|||
-populate_isa|||v
pregcomp||5.009005|
pregexec|||
pregfree2||5.011000|
pregfree|||
prescan_version||5.011004|
-printbuf|||
printf_nocontext|||vn
-process_special_blocks|||
-ptr_hash|||n
-ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
-ptr_table_find|||n
ptr_table_free||5.009005|
ptr_table_new||5.009005|
ptr_table_split||5.009005|
ptr_table_store||5.009005|
push_scope|||
-put_charclass_bitmap_innards_common|||
-put_charclass_bitmap_innards_invlist|||
-put_charclass_bitmap_innards|||
-put_code_point|||
-put_range|||
pv_display|5.006000||p
pv_escape|5.009004||p
pv_pretty|5.009004||p
pv_uni_display||5.007003|
-qerror|||
-qsortsvu|||
quadmath_format_needed|||n
quadmath_format_single|||n
re_compile||5.009005|
-re_croak2|||
re_dup_guts|||
-re_exec_indentf|||v
-re_indentf|||v
re_intuit_start||5.019001|
re_intuit_string||5.006000|
-re_op_compile|||
-re_printf|||v
realloc||5.007002|n
reentrant_free||5.024000|
reentrant_init||5.024000|
reentrant_retry||5.024000|vn
reentrant_size||5.024000|
-ref_array_or_hash|||
-refcounted_he_chain_2hv|||
-refcounted_he_fetch_pvn|||
-refcounted_he_fetch_pvs|||
-refcounted_he_fetch_pv|||
-refcounted_he_fetch_sv|||
-refcounted_he_free|||
-refcounted_he_inc|||
-refcounted_he_new_pvn|||
-refcounted_he_new_pvs|||
-refcounted_he_new_pv|||
-refcounted_he_new_sv|||
-refcounted_he_value|||
-refkids|||
-refto|||
ref||5.024000|
-reg2Lanode|||
-reg_check_named_buff_matched|||n
reg_named_buff_all||5.009005|
reg_named_buff_exists||5.009005|
reg_named_buff_fetch||5.009005|
reg_named_buff_firstkey||5.009005|
-reg_named_buff_iter|||
reg_named_buff_nextkey||5.009005|
reg_named_buff_scalar||5.009005|
-reg_named_buff|||
-reg_node|||
-reg_numbered_buff_fetch|||
-reg_numbered_buff_length|||
-reg_numbered_buff_store|||
-reg_qr_package|||
-reg_recode|||
-reg_scan_name|||
-reg_skipcomment|||n
-reg_temp_copy|||
-reganode|||
-regatom|||
-regbranch|||
-regclass_swash||5.009004|
-regclass|||
-regcppop|||
-regcppush|||
-regcurly|||n
-regdump_extflags|||
-regdump_intflags|||
regdump||5.005000|
regdupe_internal|||
-regex_set_precedence|||n
regexec_flags||5.005000|
regfree_internal||5.009005|
-reghop3|||n
-reghop4|||n
-reghopmaybe3|||n
-reginclass|||
reginitcolors||5.006000|
-reginsert|||
-regmatch|||
regnext||5.005000|
-regnode_guts|||
-regpiece|||
-regprop|||
-regrepeat|||
-regtail_study|||
-regtail|||
-regtry|||
-reg|||
repeatcpy|||n
-report_evil_fh|||
-report_redefined_cv|||
-report_uninit|||
-report_wrongway_fh|||
require_pv||5.006000|
-require_tie_mod|||
-restore_magic|||
rninstr|||n
-rpeep|||
-rsignal_restore|||
-rsignal_save|||
rsignal_state||5.004000|
rsignal||5.004000|
-run_body|||
-run_user_filter|||
runops_debug||5.005000|
runops_standard||5.005000|
rv2cv_op_cv||5.013006|
rvpv_dup|||
-rxres_free|||
-rxres_restore|||
-rxres_save|||
safesyscalloc||5.006000|n
safesysfree||5.006000|n
safesysmalloc||5.006000|n
safesysrealloc||5.006000|n
-same_dirent|||
save_I16||5.004000|
save_I32|||
save_I8||5.006000|
save_gp||5.004000|
save_hash|||
save_hdelete||5.011000|
-save_hek_flags|||n
save_helem_flags||5.011000|
save_helem||5.004050|
save_hints||5.010001|
save_int|||
save_item|||
save_iv||5.005000|
-save_lines|||
save_list|||
save_long|||
-save_magic_flags|||
save_mortalizesv||5.007001|
save_nogv|||
save_op||5.005000|
save_padsv_and_mortalize||5.010001|
save_pptr|||
save_pushi32ptr||5.010001|
-save_pushptri32ptr|||
save_pushptrptr||5.010001|
save_pushptr||5.010001|
save_re_context||5.006000|
-save_scalar_at|||
save_scalar|||
save_set_svflags||5.009000|
save_shared_pvref||5.007003|
save_sptr|||
-save_strlen|||
save_svref|||
save_vptr||5.006000|
savepvn|||
savestack_grow_cnt||5.008001|
savestack_grow|||
savesvpv||5.009002|
-savetmps||5.023008|
-sawparens|||
-scalar_mod_type|||n
-scalarboolean|||
-scalarkids|||
-scalarseq|||
-scalarvoid|||
-scalar|||
scan_bin||5.006000|
-scan_commit|||
-scan_const|||
-scan_formline|||
-scan_heredoc|||
scan_hex|||
-scan_ident|||
-scan_inputsymbol|||
scan_num||5.007001|
scan_oct|||
-scan_pat|||
-scan_str|||
-scan_subst|||
-scan_trans|||
scan_version||5.009001|
scan_vstring||5.009005|
-scan_word|||
-search_const|||
seed||5.008001|
-sequence_num|||
-set_ANYOF_arg|||
-set_caret_X|||
set_context||5.006000|n
-set_numeric_local||5.006000|
-set_numeric_radix||5.006000|
-set_numeric_standard||5.006000|
-set_padlist|||n
setdefout|||
-share_hek_flags|||
share_hek||5.004000|
-should_warn_nl|||n
si_dup|||
-sighandler|||n
-simplify_sort|||
-skip_to_be_ignored_text|||
-skipspace_flags|||
-softref2xv|||
-sortcv_stacked|||
-sortcv_xsub|||
-sortcv|||
sortsv_flags||5.009003|
sortsv||5.007003|
-space_join_names_mortal|||
ss_dup|||
-ssc_add_range|||
-ssc_and|||
-ssc_anything|||
-ssc_clear_locale|||n
-ssc_cp_and|||
-ssc_finalize|||
-ssc_init|||
-ssc_intersection|||
-ssc_is_anything|||n
-ssc_is_cp_posixl_init|||n
-ssc_or|||
-ssc_union|||
stack_grow|||
-start_glob|||
start_subparse||5.004000|
-stdize_locale|||
strEQ|||
strGE|||
strGT|||
strLT|||
strNE|||
str_to_version||5.006000|
-strip_return|||
strnEQ|||
strnNE|||
-study_chunk|||
-sub_crush_depth|||
-sublex_done|||
-sublex_push|||
-sublex_start|||
sv_2bool_flags||5.013006|
sv_2bool|||
sv_2cv|||
sv_2io|||
-sv_2iuv_common|||
-sv_2iuv_non_preserve|||
sv_2iv_flags||5.009001|
sv_2iv|||
sv_2mortal|||
-sv_2num|||
sv_2nv_flags||5.013001|
sv_2pv_flags|5.007002||p
sv_2pv_nolen|5.006000||p
sv_2pv|||
sv_2uv_flags||5.009001|
sv_2uv|5.004000||p
-sv_add_arena|||
-sv_add_backref|||
sv_backoff|||n
sv_bless|||
-sv_buf_to_ro|||
-sv_buf_to_rw|||
sv_cat_decode||5.008001|
sv_catpv_flags||5.013006|
sv_catpv_mg|5.004050||p
sv_catsv_nomg|5.007002||p
sv_catsv|||
sv_chop|||
-sv_clean_all|||
-sv_clean_objs|||
sv_clear|||
sv_cmp_flags||5.013006|
sv_cmp_locale_flags||5.013006|
sv_copypv|||
sv_dec_nomg||5.013002|
sv_dec|||
-sv_del_backref|||
sv_derived_from_pvn||5.015004|
sv_derived_from_pv||5.015004|
sv_derived_from_sv||5.015004|
sv_derived_from||5.004000|
sv_destroyable||5.010000|
-sv_display|||
sv_does_pvn||5.015004|
sv_does_pv||5.015004|
sv_does_sv||5.015004|
sv_does||5.009004|
sv_dump|||
-sv_dup_common|||
-sv_dup_inc_multiple|||
sv_dup_inc|||
sv_dup|||
sv_eq_flags||5.013006|
sv_eq|||
-sv_exp_grow|||
sv_force_normal_flags||5.007001|
sv_force_normal||5.006000|
-sv_free2|||
-sv_free_arenas|||
sv_free|||
-sv_get_backrefs||5.021008|n
sv_gets||5.003070|
sv_grow|||
-sv_i_ncmp|||
sv_inc_nomg||5.013002|
sv_inc|||
sv_insert_flags||5.010001|
sv_isa|||
sv_isobject|||
sv_iv||5.005000|
-sv_kill_backrefs|||
-sv_len_utf8_nomg|||
sv_len_utf8||5.006000|
sv_len|||
sv_magic_portable|5.024000|5.004000|p
-sv_magicext_mglob|||
sv_magicext||5.007003|
sv_magic|||
sv_mortalcopy_flags|||
sv_mortalcopy|||
-sv_ncmp|||
sv_newmortal|||
sv_newref|||
sv_nolocking||5.007003|
sv_nosharing||5.007003|
sv_nounlocking|||
sv_nv||5.005000|
-sv_only_taint_gmagic|||n
-sv_or_pv_pos_u2b|||
sv_peek||5.005000|
sv_pos_b2u_flags||5.019003|
-sv_pos_b2u_midway|||
sv_pos_b2u||5.006000|
-sv_pos_u2b_cached|||
sv_pos_u2b_flags||5.011005|
-sv_pos_u2b_forwards|||n
-sv_pos_u2b_midway|||n
sv_pos_u2b||5.006000|
sv_pvbyten_force||5.006000|
sv_pvbyten||5.006000|
sv_ref||5.015004|
sv_replace|||
sv_report_used|||
-sv_resetpvn|||
sv_reset|||
+sv_rvunweaken|||
sv_rvweaken||5.006000|
-sv_sethek|||
+sv_set_undef|||
sv_setiv_mg|5.004050||p
sv_setiv|||
sv_setnv_mg|5.006000||p
sv_setnv|||
+sv_setpv_bufsize|||
sv_setpv_mg|5.004050||p
sv_setpvf_mg_nocontext|||pvn
sv_setpvf_mg|5.006000|5.004000|pv
sv_setref_pvs||5.024000|
sv_setref_pv|||
sv_setref_uv||5.007001|
-sv_setsv_cow|||
-sv_setsv_flags||5.007002|
+sv_setsv_flags|5.007002|5.007002|p
sv_setsv_mg|5.004050||p
sv_setsv_nomg|5.007002||p
sv_setsv|||
sv_setuv_mg|5.004050||p
sv_setuv|5.004000||p
+sv_string_from_errnum|||
sv_tainted||5.004000|
sv_taint||5.004000|
sv_true||5.005000|
-sv_unglob|||
sv_uni_display||5.007003|
sv_unmagicext|5.013008||p
sv_unmagic|||
sv_usepvn_flags||5.009004|
sv_usepvn_mg|5.004050||p
sv_usepvn|||
-sv_utf8_decode||5.006000|
-sv_utf8_downgrade||5.006000|
+sv_utf8_decode|||
+sv_utf8_downgrade|||
sv_utf8_encode||5.006000|
sv_utf8_upgrade_flags_grow||5.011000|
sv_utf8_upgrade_flags||5.007002|
sv_vsetpvfn||5.004000|
sv_vsetpvf|5.006000|5.004000|p
svtype|||
-swallow_bom|||
-swash_fetch||5.007002|
-swash_init||5.006000|
-swash_scan_list_line|||
-swatch_get|||
-sync_locale||5.021004|
+switch_to_global_locale|||n
+sync_locale||5.021004|n
sys_init3||5.010000|n
sys_init||5.010000|n
sys_intern_clear|||
sys_term||5.010000|n
taint_env|||
taint_proper|||
-tied_method|||v
-tmps_grow_p|||
+toFOLD_utf8_safe|||
toFOLD_utf8||5.019001|
toFOLD_uvchr||5.023009|
toFOLD||5.019001|
toLOWER_L1||5.019001|
toLOWER_LC||5.004000|
+toLOWER_utf8_safe|||
toLOWER_utf8||5.015007|
toLOWER_uvchr||5.023009|
toLOWER|||
+toTITLE_utf8_safe|||
toTITLE_utf8||5.015007|
toTITLE_uvchr||5.023009|
toTITLE||5.019001|
+toUPPER_utf8_safe|||
toUPPER_utf8||5.015007|
toUPPER_uvchr||5.023009|
toUPPER|||
-to_byte_substr|||
-to_lower_latin1|||n
-to_uni_fold||5.007003|
-to_uni_lower_lc||5.006000|
-to_uni_lower||5.007003|
-to_uni_title_lc||5.006000|
-to_uni_title||5.007003|
-to_uni_upper_lc||5.006000|
-to_uni_upper||5.007003|
-to_utf8_case||5.007003|
-to_utf8_fold||5.015007|
-to_utf8_lower||5.015007|
-to_utf8_substr|||
-to_utf8_title||5.015007|
-to_utf8_upper||5.015007|
-tokenize_use|||
-tokeq|||
-tokereport|||
-too_few_arguments_pv|||
-too_many_arguments_pv|||
-translate_substr_offsets|||n
-try_amagic_bin|||
-try_amagic_un|||
-uiv_2buf|||n
unlnk|||
-unpack_rec|||
unpack_str||5.007003|
unpackstring||5.008001|
-unreferenced_to_tmp_stack|||
-unshare_hek_or_pvn|||
-unshare_hek|||
unsharepvn||5.003070|
-unwind_handler_stack|||
-update_debugger_info|||
upg_version||5.009005|
-usage|||
-utf16_textfilter|||
-utf16_to_utf8_reversed||5.006001|
-utf16_to_utf8||5.006001|
utf8_distance||5.006000|
+utf8_hop_back|||n
+utf8_hop_forward|||n
+utf8_hop_safe|||n
utf8_hop||5.006000|n
utf8_length||5.007001|
-utf8_mg_len_cache_update|||
-utf8_mg_pos_cache_update|||
-utf8_to_bytes||5.006001|
-utf8_to_uvchr_buf||5.015009|
-utf8_to_uvchr||5.007001|
-utf8_to_uvuni_buf||5.015009|
-utf8_to_uvuni||5.007001|
-utf8n_to_uvchr||5.007001|
+utf8_to_uvchr_buf|5.015009||p
+utf8_to_uvchr|||p
+utf8n_to_uvchr_error|||n
+utf8n_to_uvchr||5.007001|n
utf8n_to_uvuni||5.007001|
-utilize|||
uvchr_to_utf8_flags||5.007003|
uvchr_to_utf8||5.007001|
uvoffuni_to_utf8_flags||5.019004|
uvuni_to_utf8_flags||5.007003|
uvuni_to_utf8||5.007001|
-valid_utf8_to_uvchr||5.015009|
-valid_utf8_to_uvuni||5.015009|
-validate_proto|||
-validate_suid|||
-varname|||
+valid_utf8_to_uvchr|||n
vcmp||5.009000|
vcroak||5.006000|
vdeb||5.007003|
vform||5.006000|
-visit|||
-vivify_defelem|||
-vivify_ref|||
vload_module|5.006000||p
-vmess|5.006000||p
+vmess|5.006000|5.006000|p
vnewSVpvf|5.006000|5.004000|p
vnormal||5.009002|
vnumify||5.009000|
vverify||5.009003|
vwarner||5.006000|
vwarn||5.006000|
-wait4pid|||
warn_nocontext|||pvn
warn_sv|5.013001||p
warner_nocontext|||vn
warner|5.006000|5.004000|pv
warn|||v
-was_lvalue_sub|||
-watch|||
whichsig_pvn||5.015004|
whichsig_pv||5.015004|
whichsig_sv||5.015004|
whichsig|||
-win32_croak_not_implemented|||n
-with_queued_errors|||
wrap_op_checker||5.015008|
-write_to_stderr|||
-xs_boot_epilog|||
-xs_handshake|||vn
-xs_version_bootcheck|||
-yyerror_pvn|||
-yyerror_pv|||
-yyerror|||
-yylex|||
-yyparse|||
-yyunlex|||
-yywarn|||
);
if (exists $opt{'list-unsupported'}) {
# endif
#endif
-#define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
-#define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))
+#define D_PPP_DEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
+#define PERL_BCDVERSION ((D_PPP_DEC2BCD(PERL_REVISION)<<24)|(D_PPP_DEC2BCD(PERL_VERSION)<<12)|D_PPP_DEC2BCD(PERL_SUBVERSION))
/* It is very unlikely that anyone will try to use this with Perl 6
(or greater), but who knows.
#ifndef UVSIZE
# define UVSIZE IVSIZE
#endif
-#ifndef sv_setuv
-# define sv_setuv(sv, uv) \
- STMT_START { \
- UV TeMpUv = uv; \
- if (TeMpUv <= IV_MAX) \
- sv_setiv(sv, TeMpUv); \
- else \
- sv_setnv(sv, (double)TeMpUv); \
- } STMT_END
-#endif
-#ifndef newSVuv
-# define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
-#endif
-#ifndef sv_2uv
-# define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
-#endif
-
-#ifndef SvUVX
-# define SvUVX(sv) ((UV)SvIVX(sv))
-#endif
-
-#ifndef SvUVXx
-# define SvUVXx(sv) SvUVX(sv)
-#endif
-
-#ifndef SvUV
-# define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
-#endif
-
-#ifndef SvUVx
-# define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
-#endif
-
-/* Hint: sv_uv
- * Always use the SvUVx() macro instead of sv_uv().
- */
-#ifndef sv_uv
-# define sv_uv(sv) SvUVx(sv)
-#endif
-
-#if !defined(SvUOK) && defined(SvIOK_UV)
-# define SvUOK(sv) SvIOK_UV(sv)
-#endif
-#ifndef XST_mUV
-# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
-#endif
-
-#ifndef XSRETURN_UV
-# define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END
-#endif
-#ifndef PUSHu
-# define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
-#endif
-
-#ifndef XPUSHu
-# define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
-#endif
-
-#ifdef HAS_MEMCMP
-#ifndef memNE
-# define memNE(s1,s2,l) (memcmp(s1,s2,l))
-#endif
-
-#ifndef memEQ
-# define memEQ(s1,s2,l) (!memcmp(s1,s2,l))
-#endif
-
-#else
-#ifndef memNE
-# define memNE(s1,s2,l) (bcmp(s1,s2,l))
-#endif
-
-#ifndef memEQ
-# define memEQ(s1,s2,l) (!bcmp(s1,s2,l))
-#endif
-
-#endif
-#ifndef memEQs
-# define memEQs(s1, l, s2) \
- (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1)))
-#endif
-
-#ifndef memNEs
-# define memNEs(s1, l, s2) !memEQs(s1, l, s2)
-#endif
-#ifndef MoveD
-# define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t))
-#endif
-
-#ifndef CopyD
-# define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
-#endif
-
-#ifdef HAS_MEMSET
-#ifndef ZeroD
-# define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t))
-#endif
-
-#else
-#ifndef ZeroD
-# define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d)
-#endif
-
-#endif
-#ifndef PoisonWith
-# define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
-#endif
-
-#ifndef PoisonNew
-# define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB)
-#endif
-
-#ifndef PoisonFree
-# define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF)
-#endif
-
-#ifndef Poison
-# define Poison(d,n,t) PoisonFree(d,n,t)
-#endif
-#ifndef Newx
-# define Newx(v,n,t) New(0,v,n,t)
-#endif
-
-#ifndef Newxc
-# define Newxc(v,n,t,c) Newc(0,v,n,t,c)
-#endif
-
-#ifndef Newxz
-# define Newxz(v,n,t) Newz(0,v,n,t)
-#endif
-#ifndef SvGETMAGIC
-# define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
-#endif
-
-/* Some random bits for sv_unmagicext. These should probably be pulled in for
- real and organized at some point */
-#ifndef HEf_SVKEY
-# define HEf_SVKEY -2
-#endif
-
-#ifndef MUTABLE_PTR
-#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
-# define MUTABLE_PTR(p) ({ void *_p = (p); _p; })
-#else
-# define MUTABLE_PTR(p) ((void *) (p))
-#endif
-#endif
-#ifndef MUTABLE_SV
-# define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p))
-#endif
-
-/* end of random bits */
#ifndef PERL_MAGIC_sv
# define PERL_MAGIC_sv '\0'
#endif
#ifndef PERL_MAGIC_ext
# define PERL_MAGIC_ext '~'
#endif
-
-/* That's the best we can do... */
-#ifndef sv_catpvn_nomg
-# define sv_catpvn_nomg sv_catpvn
+#ifndef cBOOL
+# define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0)
#endif
-#ifndef sv_catsv_nomg
-# define sv_catsv_nomg sv_catsv
+#ifndef OpHAS_SIBLING
+# define OpHAS_SIBLING(o) (cBOOL((o)->op_sibling))
#endif
-#ifndef sv_setsv_nomg
-# define sv_setsv_nomg sv_setsv
+#ifndef OpSIBLING
+# define OpSIBLING(o) (0 + (o)->op_sibling)
#endif
-#ifndef sv_pvn_nomg
-# define sv_pvn_nomg sv_pvn
+#ifndef OpMORESIB_set
+# define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib))
#endif
-#ifndef SvIV_nomg
-# define SvIV_nomg SvIV
+#ifndef OpLASTSIB_set
+# define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL)
#endif
-#ifndef SvUV_nomg
-# define SvUV_nomg SvUV
+#ifndef OpMAYBESIB_set
+# define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif
-#ifndef sv_catpv_mg
-# define sv_catpv_mg(sv, ptr) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_catpv(TeMpSv,ptr); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
+#ifndef HEf_SVKEY
+# define HEf_SVKEY -2
#endif
-#ifndef sv_catpvn_mg
-# define sv_catpvn_mg(sv, ptr, len) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_catpvn(TeMpSv,ptr,len); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
+#if defined(DEBUGGING) && !defined(__COVERITY__)
+#ifndef __ASSERT_
+# define __ASSERT_(statement) assert(statement),
#endif
-#ifndef sv_catsv_mg
-# define sv_catsv_mg(dsv, ssv) \
- STMT_START { \
- SV *TeMpSv = dsv; \
- sv_catsv(TeMpSv,ssv); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
+#else
+#ifndef __ASSERT_
+# define __ASSERT_(statement)
#endif
-#ifndef sv_setiv_mg
-# define sv_setiv_mg(sv, i) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_setiv(TeMpSv,i); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
#endif
-
-#ifndef sv_setnv_mg
-# define sv_setnv_mg(sv, num) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_setnv(TeMpSv,num); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
+#ifndef SvRX
+# define SvRX(rv) (SvROK((rv)) ? (SvMAGICAL(SvRV((rv))) ? (mg_find(SvRV((rv)), PERL_MAGIC_qr) ? mg_find(SvRV((rv)), PERL_MAGIC_qr)->mg_obj : NULL) : NULL) : NULL)
#endif
-#ifndef sv_setpv_mg
-# define sv_setpv_mg(sv, ptr) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_setpv(TeMpSv,ptr); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
+#ifndef SvRXOK
+# define SvRXOK(sv) (!!SvRX(sv))
#endif
-#ifndef sv_setpvn_mg
-# define sv_setpvn_mg(sv, ptr, len) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_setpvn(TeMpSv,ptr,len); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
+#ifndef PERL_UNUSED_DECL
+# ifdef HASATTRIBUTE
+# if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
+# define PERL_UNUSED_DECL
+# else
+# define PERL_UNUSED_DECL __attribute__((unused))
+# endif
+# else
+# define PERL_UNUSED_DECL
+# endif
#endif
-#ifndef sv_setsv_mg
-# define sv_setsv_mg(dsv, ssv) \
- STMT_START { \
- SV *TeMpSv = dsv; \
- sv_setsv(TeMpSv,ssv); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
-#endif
-
-#ifndef sv_setuv_mg
-# define sv_setuv_mg(sv, i) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_setuv(TeMpSv,i); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
-#endif
-
-#ifndef sv_usepvn_mg
-# define sv_usepvn_mg(sv, ptr, len) \
- STMT_START { \
- SV *TeMpSv = sv; \
- sv_usepvn(TeMpSv,ptr,len); \
- SvSETMAGIC(TeMpSv); \
- } STMT_END
-#endif
-#ifndef SvVSTRING_mg
-# define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
-#endif
-
-/* Hint: sv_magic_portable
- * This is a compatibility function that is only available with
- * Devel::PPPort. It is NOT in the perl core.
- * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
- * it is being passed a name pointer with namlen == 0. In that
- * case, perl 5.8.0 and later store the pointer, not a copy of it.
- * The compatibility can be provided back to perl 5.004. With
- * earlier versions, the code will not compile.
- */
-
-#if (PERL_BCDVERSION < 0x5004000)
-
- /* code that uses sv_magic_portable will not compile */
-
-#elif (PERL_BCDVERSION < 0x5008000)
-
-# define sv_magic_portable(sv, obj, how, name, namlen) \
- STMT_START { \
- SV *SvMp_sv = (sv); \
- char *SvMp_name = (char *) (name); \
- I32 SvMp_namlen = (namlen); \
- if (SvMp_name && SvMp_namlen == 0) \
- { \
- MAGIC *mg; \
- sv_magic(SvMp_sv, obj, how, 0, 0); \
- mg = SvMAGIC(SvMp_sv); \
- mg->mg_len = -42; /* XXX: this is the tricky part */ \
- mg->mg_ptr = SvMp_name; \
- } \
- else \
- { \
- sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
- } \
- } STMT_END
-
-#else
-
-# define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e)
-
-#endif
-
-#if !defined(mg_findext)
-#if defined(NEED_mg_findext)
-static MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl);
-static
-#else
-extern MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl);
-#endif
-
-#define mg_findext DPPP_(my_mg_findext)
-#define Perl_mg_findext DPPP_(my_mg_findext)
-
-#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL)
-
-MAGIC *
-DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl) {
- if (sv) {
- MAGIC *mg;
-
-#ifdef AvPAD_NAMELIST
- assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv)));
-#endif
-
- for (mg = SvMAGIC (sv); mg; mg = mg->mg_moremagic) {
- if (mg->mg_type == type && mg->mg_virtual == vtbl)
- return mg;
- }
- }
-
- return NULL;
-}
-
-#endif
-#endif
-
-#if !defined(sv_unmagicext)
-#if defined(NEED_sv_unmagicext)
-static int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
-static
-#else
-extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
-#endif
-
-#ifdef sv_unmagicext
-# undef sv_unmagicext
-#endif
-#define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c)
-#define Perl_sv_unmagicext DPPP_(my_sv_unmagicext)
-
-#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL)
-
-int
-DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl)
-{
- MAGIC* mg;
- MAGIC** mgp;
-
- if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
- return 0;
- mgp = &(SvMAGIC(sv));
- for (mg = *mgp; mg; mg = *mgp) {
- const MGVTBL* const virt = mg->mg_virtual;
- if (mg->mg_type == type && virt == vtbl) {
- *mgp = mg->mg_moremagic;
- if (virt && virt->svt_free)
- virt->svt_free(aTHX_ sv, mg);
- if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
- if (mg->mg_len > 0)
- Safefree(mg->mg_ptr);
- else if (mg->mg_len == HEf_SVKEY) /* Questionable on older perls... */
- SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
- else if (mg->mg_type == PERL_MAGIC_utf8)
- Safefree(mg->mg_ptr);
- }
- if (mg->mg_flags & MGf_REFCOUNTED)
- SvREFCNT_dec(mg->mg_obj);
- Safefree(mg);
- }
- else
- mgp = &mg->mg_moremagic;
- }
- if (SvMAGIC(sv)) {
- if (SvMAGICAL(sv)) /* if we're under save_magic, wait for restore_magic; */
- mg_magical(sv); /* else fix the flags now */
- }
- else {
- SvMAGICAL_off(sv);
- SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
- }
- return 0;
-}
-
-#endif
-#endif
-#ifndef cBOOL
-# define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0)
-#endif
-
-#ifndef OpHAS_SIBLING
-# define OpHAS_SIBLING(o) (cBOOL((o)->op_sibling))
-#endif
-
-#ifndef OpSIBLING
-# define OpSIBLING(o) (0 + (o)->op_sibling)
-#endif
-
-#ifndef OpMORESIB_set
-# define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib))
-#endif
-
-#ifndef OpLASTSIB_set
-# define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL)
-#endif
-
-#ifndef OpMAYBESIB_set
-# define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
-#endif
-
-#ifndef SvRX
-#if defined(NEED_SvRX)
-static void * DPPP_(my_SvRX)(pTHX_ SV *rv);
-static
-#else
-extern void * DPPP_(my_SvRX)(pTHX_ SV *rv);
-#endif
-
-#ifdef SvRX
-# undef SvRX
-#endif
-#define SvRX(a) DPPP_(my_SvRX)(aTHX_ a)
-
-#if defined(NEED_SvRX) || defined(NEED_SvRX_GLOBAL)
-
-void *
-DPPP_(my_SvRX)(pTHX_ SV *rv)
-{
- if (SvROK(rv)) {
- SV *sv = SvRV(rv);
- if (SvMAGICAL(sv)) {
- MAGIC *mg = mg_find(sv, PERL_MAGIC_qr);
- if (mg && mg->mg_obj) {
- return mg->mg_obj;
- }
- }
- }
- return 0;
-}
-#endif
-#endif
-#ifndef SvRXOK
-# define SvRXOK(sv) (!!SvRX(sv))
-#endif
-
-#ifndef PERL_UNUSED_DECL
-# ifdef HASATTRIBUTE
-# if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
-# define PERL_UNUSED_DECL
-# else
-# define PERL_UNUSED_DECL __attribute__((unused))
-# endif
-# else
-# define PERL_UNUSED_DECL
-# endif
-#endif
-
-#ifndef PERL_UNUSED_ARG
-# if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
-# include <note.h>
-# define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
-# else
-# define PERL_UNUSED_ARG(x) ((void)x)
-# endif
+#ifndef PERL_UNUSED_ARG
+# if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
+# include <note.h>
+# define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
+# else
+# define PERL_UNUSED_ARG(x) ((void)x)
+# endif
#endif
#ifndef PERL_UNUSED_VAR
#ifndef AvFILLp
# define AvFILLp AvFILL
#endif
+#ifndef av_tindex
+# define av_tindex AvFILL
+#endif
+
+#ifndef av_top_index
+# define av_top_index AvFILL
+#endif
#ifndef ERRSV
# define ERRSV get_sv("@",FALSE)
#endif
#ifndef UTF8_MAXBYTES
# define UTF8_MAXBYTES UTF8_MAXLEN
#endif
+#ifndef UTF8_ALLOW_ANYUV
+# define UTF8_ALLOW_ANYUV 0
+#endif
+
+#ifndef UTF8_ALLOW_EMPTY
+# define UTF8_ALLOW_EMPTY 0x0001
+#endif
+
+#ifndef UTF8_ALLOW_CONTINUATION
+# define UTF8_ALLOW_CONTINUATION 0x0002
+#endif
+
+#ifndef UTF8_ALLOW_NON_CONTINUATION
+# define UTF8_ALLOW_NON_CONTINUATION 0x0004
+#endif
+
+#ifndef UTF8_ALLOW_SHORT
+# define UTF8_ALLOW_SHORT 0x0008
+#endif
+
+#ifndef UTF8_ALLOW_LONG
+# define UTF8_ALLOW_LONG 0x0010
+#endif
+
+#ifndef UTF8_ALLOW_OVERFLOW
+# define UTF8_ALLOW_OVERFLOW 0x0080
+#endif
+
+#ifndef UTF8_ALLOW_ANY
+# define UTF8_ALLOW_ANY ( UTF8_ALLOW_CONTINUATION \
+ |UTF8_ALLOW_NON_CONTINUATION \
+ |UTF8_ALLOW_SHORT \
+ |UTF8_ALLOW_LONG \
+ |UTF8_ALLOW_OVERFLOW)
+#endif
#ifndef CPERLscope
# define CPERLscope(x) x
#endif
typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
#endif
-#ifndef isPSXSPC
-# define isPSXSPC(c) (isSPACE(c) || (c) == '\v')
-#endif
-#ifndef isBLANK
-# define isBLANK(c) ((c) == ' ' || (c) == '\t')
+#ifndef WIDEST_UTYPE
+# ifdef QUADKIND
+# ifdef U64TYPE
+# define WIDEST_UTYPE U64TYPE
+# else
+# define WIDEST_UTYPE Quad_t
+# endif
+# else
+# define WIDEST_UTYPE U32
+# endif
#endif
#ifdef EBCDIC
-#ifndef isALNUMC
-# define isALNUMC(c) isalnum(c)
-#endif
+/* This is the first version where these macros are fully correct. Relying on
+ * the C library functions, as earlier releases did, causes problems with
+ * locales */
+# if (PERL_BCDVERSION < 0x5022000)
+# undef isALNUM
+# undef isALNUM_A
+# undef isALNUMC
+# undef isALNUMC_A
+# undef isALPHA
+# undef isALPHA_A
+# undef isALPHANUMERIC
+# undef isALPHANUMERIC_A
+# undef isASCII
+# undef isASCII_A
+# undef isBLANK
+# undef isBLANK_A
+# undef isCNTRL
+# undef isCNTRL_A
+# undef isDIGIT
+# undef isDIGIT_A
+# undef isGRAPH
+# undef isGRAPH_A
+# undef isIDCONT
+# undef isIDCONT_A
+# undef isIDFIRST
+# undef isIDFIRST_A
+# undef isLOWER
+# undef isLOWER_A
+# undef isOCTAL
+# undef isOCTAL_A
+# undef isPRINT
+# undef isPRINT_A
+# undef isPSXSPC
+# undef isPSXSPC_A
+# undef isPUNCT
+# undef isPUNCT_A
+# undef isSPACE
+# undef isSPACE_A
+# undef isUPPER
+# undef isUPPER_A
+# undef isWORDCHAR
+# undef isWORDCHAR_A
+# undef isXDIGIT
+# undef isXDIGIT_A
+# endif
#ifndef isASCII
-# define isASCII(c) isascii(c)
+# define isASCII(c) (isCNTRL(c) || isPRINT(c))
#endif
+ /* The below is accurate for all EBCDIC code pages supported by
+ * all the versions of Perl overridden by this */
#ifndef isCNTRL
-# define isCNTRL(c) iscntrl(c)
-#endif
+# define isCNTRL(c) ( (c) == '\0' || (c) == '\a' || (c) == '\b' \
+ || (c) == '\f' || (c) == '\n' || (c) == '\r' \
+ || (c) == '\t' || (c) == '\v' \
+ || ((c) <= 3 && (c) >= 1) /* SOH, STX, ETX */ \
+ || (c) == 7 /* U+7F DEL */ \
+ || ((c) <= 0x13 && (c) >= 0x0E) /* SO, SI */ \
+ /* DLE, DC[1-3] */ \
+ || (c) == 0x18 /* U+18 CAN */ \
+ || (c) == 0x19 /* U+19 EOM */ \
+ || ((c) <= 0x1F && (c) >= 0x1C) /* [FGRU]S */ \
+ || (c) == 0x26 /* U+17 ETB */ \
+ || (c) == 0x27 /* U+1B ESC */ \
+ || (c) == 0x2D /* U+05 ENQ */ \
+ || (c) == 0x2E /* U+06 ACK */ \
+ || (c) == 0x32 /* U+16 SYN */ \
+ || (c) == 0x37 /* U+04 EOT */ \
+ || (c) == 0x3C /* U+14 DC4 */ \
+ || (c) == 0x3D /* U+15 NAK */ \
+ || (c) == 0x3F /* U+1A SUB */ \
+ )
+#endif
+
+/* The ordering of the tests in this and isUPPER are to exclude most characters
+ * early */
+#ifndef isLOWER
+# define isLOWER(c) ( (c) >= 'a' && (c) <= 'z' \
+ && ( (c) <= 'i' \
+ || ((c) >= 'j' && (c) <= 'r') \
+ || (c) >= 's'))
+#endif
+
+#ifndef isUPPER
+# define isUPPER(c) ( (c) >= 'A' && (c) <= 'Z' \
+ && ( (c) <= 'I' \
+ || ((c) >= 'J' && (c) <= 'R') \
+ || (c) >= 'S'))
+#endif
+
+#else /* Above is EBCDIC; below is ASCII */
+
+# if (PERL_BCDVERSION < 0x5004000)
+/* The implementation of these in older perl versions can give wrong results if
+ * the C program locale is set to other than the C locale */
+# undef isALNUM
+# undef isALNUM_A
+# undef isALPHA
+# undef isALPHA_A
+# undef isDIGIT
+# undef isDIGIT_A
+# undef isIDFIRST
+# undef isIDFIRST_A
+# undef isLOWER
+# undef isLOWER_A
+# undef isUPPER
+# undef isUPPER_A
+# endif
-#ifndef isGRAPH
-# define isGRAPH(c) isgraph(c)
-#endif
-
-#ifndef isPRINT
-# define isPRINT(c) isprint(c)
-#endif
-
-#ifndef isPUNCT
-# define isPUNCT(c) ispunct(c)
-#endif
-
-#ifndef isXDIGIT
-# define isXDIGIT(c) isxdigit(c)
-#endif
+# if (PERL_BCDVERSION < 0x5008000)
+/* Hint: isCNTRL
+ * Earlier perls omitted DEL */
+# undef isCNTRL
+# endif
-#else
# if (PERL_BCDVERSION < 0x5010000)
/* Hint: isPRINT
* The implementation in older perl versions includes all of the
* Devel::PPPort always overrides a present buggy version.
*/
# undef isPRINT
+# undef isPRINT_A
# endif
-#ifndef WIDEST_UTYPE
-# ifdef QUADKIND
-# ifdef U64TYPE
-# define WIDEST_UTYPE U64TYPE
-# else
-# define WIDEST_UTYPE Quad_t
-# endif
-# else
-# define WIDEST_UTYPE U32
+# if (PERL_BCDVERSION < 0x5014000)
+/* Hint: isASCII
+ * The implementation in older perl versions always returned true if the
+ * parameter was a signed char
+ */
+# undef isASCII
+# undef isASCII_A
# endif
-#endif
-#ifndef isALNUMC
-# define isALNUMC(c) (isALPHA(c) || isDIGIT(c))
-#endif
+# if (PERL_BCDVERSION < 0x5020000)
+/* Hint: isSPACE
+ * The implementation in older perl versions didn't include \v */
+# undef isSPACE
+# undef isSPACE_A
+# endif
#ifndef isASCII
# define isASCII(c) ((WIDEST_UTYPE) (c) <= 127)
#endif
# define isCNTRL(c) ((WIDEST_UTYPE) (c) < ' ' || (c) == 127)
#endif
-#ifndef isGRAPH
-# define isGRAPH(c) (isALNUM(c) || isPUNCT(c))
+#ifndef isLOWER
+# define isLOWER(c) ((c) >= 'a' && (c) <= 'z')
#endif
-#ifndef isPRINT
-# define isPRINT(c) (((c) >= 32 && (c) < 127))
+#ifndef isUPPER
+# define isUPPER(c) ((c) <= 'Z' && (c) >= 'A')
#endif
-#ifndef isPUNCT
-# define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
+#endif /* Below are definitions common to EBCDIC and ASCII */
+#ifndef isALNUM
+# define isALNUM(c) isWORDCHAR(c)
#endif
-#ifndef isXDIGIT
-# define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
+#ifndef isALNUMC
+# define isALNUMC(c) isALPHANUMERIC(c)
#endif
+#ifndef isALPHA
+# define isALPHA(c) (isUPPER(c) || isLOWER(c))
#endif
-/* Until we figure out how to support this in older perls... */
-#if (PERL_BCDVERSION >= 0x5008000)
-#ifndef HeUTF8
-# define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \
- SvUTF8(HeKEY_sv(he)) : \
- (U32)HeKUTF8(he))
+#ifndef isALPHANUMERIC
+# define isALPHANUMERIC(c) (isALPHA(c) || isDIGIT(c))
#endif
+#ifndef isBLANK
+# define isBLANK(c) ((c) == ' ' || (c) == '\t')
#endif
-#ifndef C_ARRAY_LENGTH
-# define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0]))
+
+#ifndef isDIGIT
+# define isDIGIT(c) ((c) <= '9' && (c) >= '0')
#endif
-#ifndef C_ARRAY_END
-# define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a))
+#ifndef isGRAPH
+# define isGRAPH(c) (isWORDCHAR(c) || isPUNCT(c))
#endif
-#ifndef IVdf
-# if IVSIZE == LONGSIZE
-# define IVdf "ld"
-# define UVuf "lu"
-# define UVof "lo"
-# define UVxf "lx"
-# define UVXf "lX"
-# elif IVSIZE == INTSIZE
-# define IVdf "d"
-# define UVuf "u"
-# define UVof "o"
-# define UVxf "x"
-# define UVXf "X"
-# else
-# error "cannot define IV/UV formats"
-# endif
+#ifndef isIDCONT
+# define isIDCONT(c) isWORDCHAR(c)
#endif
-#ifndef NVef
-# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
- defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
- /* Not very likely, but let's try anyway. */
-# define NVef PERL_PRIeldbl
-# define NVff PERL_PRIfldbl
-# define NVgf PERL_PRIgldbl
-# else
-# define NVef "e"
-# define NVff "f"
-# define NVgf "g"
-# endif
+#ifndef isIDFIRST
+# define isIDFIRST(c) (isALPHA(c) || (c) == '_')
#endif
-#ifdef NEED_mess_sv
-#define NEED_mess
+#ifndef isOCTAL
+# define isOCTAL(c) (((WIDEST_UTYPE)((c)) & ~7) == '0')
#endif
-#ifdef NEED_mess
-#define NEED_mess_nocontext
-#define NEED_vmess
+#ifndef isPRINT
+# define isPRINT(c) (isGRAPH(c) || (c) == ' ')
#endif
-#ifndef croak_sv
-#if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) )
-# if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) )
-# define _dppp_fix_utf8_errsv(errsv, sv) \
- STMT_START { \
- if (sv != ERRSV) \
- SvFLAGS(ERRSV) = (SvFLAGS(ERRSV) & ~SVf_UTF8) | \
- (SvFLAGS(sv) & SVf_UTF8); \
- } STMT_END
-# else
-# define _dppp_fix_utf8_errsv(errsv, sv) STMT_START {} STMT_END
-# endif
-# define croak_sv(sv) \
- STMT_START { \
- if (SvROK(sv)) { \
- sv_setsv(ERRSV, sv); \
- croak(NULL); \
- } else { \
- _dppp_fix_utf8_errsv(ERRSV, sv); \
- croak("%" SVf, SVfARG(sv)); \
- } \
- } STMT_END
-#elif (PERL_BCDVERSION >= 0x5004000)
-# define croak_sv(sv) croak("%" SVf, SVfARG(sv))
-#else
-# define croak_sv(sv) croak("%s", SvPV_nolen(sv))
+#ifndef isPSXSPC
+# define isPSXSPC(c) isSPACE(c)
#endif
+
+#ifndef isPUNCT
+# define isPUNCT(c) ( (c) == '-' || (c) == '!' || (c) == '"' \
+ || (c) == '#' || (c) == '$' || (c) == '%' \
+ || (c) == '&' || (c) == '\'' || (c) == '(' \
+ || (c) == ')' || (c) == '*' || (c) == '+' \
+ || (c) == ',' || (c) == '.' || (c) == '/' \
+ || (c) == ':' || (c) == ';' || (c) == '<' \
+ || (c) == '=' || (c) == '>' || (c) == '?' \
+ || (c) == '@' || (c) == '[' || (c) == '\\' \
+ || (c) == ']' || (c) == '^' || (c) == '_' \
+ || (c) == '`' || (c) == '{' || (c) == '|' \
+ || (c) == '}' || (c) == '~')
#endif
-#ifndef die_sv
-#if defined(NEED_die_sv)
-static OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
-static
-#else
-extern OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+#ifndef isSPACE
+# define isSPACE(c) ( isBLANK(c) || (c) == '\n' || (c) == '\r' \
+ || (c) == '\v' || (c) == '\f')
#endif
-#ifdef die_sv
-# undef die_sv
+#ifndef isWORDCHAR
+# define isWORDCHAR(c) (isALPHANUMERIC(c) || (c) == '_')
#endif
-#define die_sv(a) DPPP_(my_die_sv)(aTHX_ a)
-#define Perl_die_sv DPPP_(my_die_sv)
-#if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL)
-OP *
-DPPP_(my_die_sv)(pTHX_ SV *sv)
-{
- croak_sv(sv);
- return (OP *)NULL;
-}
+#ifndef isXDIGIT
+# define isXDIGIT(c) ( isDIGIT(c) \
+ || ((c) >= 'a' && (c) <= 'f') \
+ || ((c) >= 'A' && (c) <= 'F'))
#endif
+#ifndef isALNUM_A
+# define isALNUM_A isALNUM
#endif
-#ifndef warn_sv
-#if (PERL_BCDVERSION >= 0x5004000)
-# define warn_sv(sv) warn("%" SVf, SVfARG(sv))
-#else
-# define warn_sv(sv) warn("%s", SvPV_nolen(sv))
-#endif
+#ifndef isALNUMC_A
+# define isALNUMC_A isALNUMC
#endif
-#ifndef vmess
-#if defined(NEED_vmess)
-static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
-static
-#else
-extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+#ifndef isALPHA_A
+# define isALPHA_A isALPHA
#endif
-#ifdef vmess
-# undef vmess
+#ifndef isALPHANUMERIC_A
+# define isALPHANUMERIC_A isALPHANUMERIC
#endif
-#define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b)
-#define Perl_vmess DPPP_(my_vmess)
-#if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL)
-SV*
-DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args)
-{
- mess(pat, args);
- return PL_mess_sv;
-}
+#ifndef isASCII_A
+# define isASCII_A isASCII
#endif
+
+#ifndef isBLANK_A
+# define isBLANK_A isBLANK
#endif
-#if (PERL_BCDVERSION < 0x5006000)
-#undef mess
+#ifndef isCNTRL_A
+# define isCNTRL_A isCNTRL
#endif
-#if !defined(mess_nocontext) && !defined(Perl_mess_nocontext)
-#if defined(NEED_mess_nocontext)
-static SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
-static
-#else
-extern SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
+#ifndef isDIGIT_A
+# define isDIGIT_A isDIGIT
#endif
-#define mess_nocontext DPPP_(my_mess_nocontext)
-#define Perl_mess_nocontext DPPP_(my_mess_nocontext)
+#ifndef isGRAPH_A
+# define isGRAPH_A isGRAPH
+#endif
-#if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL)
-SV*
-DPPP_(my_mess_nocontext)(const char* pat, ...)
-{
- dTHX;
- SV *sv;
- va_list args;
- va_start(args, pat);
- sv = vmess(pat, &args);
- va_end(args);
- return sv;
-}
+#ifndef isIDCONT_A
+# define isIDCONT_A isIDCONT
#endif
+
+#ifndef isIDFIRST_A
+# define isIDFIRST_A isIDFIRST
#endif
-#ifndef mess
-#if defined(NEED_mess)
-static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
-static
-#else
-extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+#ifndef isLOWER_A
+# define isLOWER_A isLOWER
#endif
-#define Perl_mess DPPP_(my_mess)
+#ifndef isOCTAL_A
+# define isOCTAL_A isOCTAL
+#endif
-#if defined(NEED_mess) || defined(NEED_mess_GLOBAL)
-SV*
-DPPP_(my_mess)(pTHX_ const char* pat, ...)
-{
- SV *sv;
- va_list args;
- va_start(args, pat);
- sv = vmess(pat, &args);
- va_end(args);
- return sv;
-}
-#ifdef mess_nocontext
-#define mess mess_nocontext
-#else
-#define mess Perl_mess_nocontext
+#ifndef isPRINT_A
+# define isPRINT_A isPRINT
#endif
+
+#ifndef isPSXSPC_A
+# define isPSXSPC_A isPSXSPC
#endif
+
+#ifndef isPUNCT_A
+# define isPUNCT_A isPUNCT
#endif
-#ifndef mess_sv
-#if defined(NEED_mess_sv)
-static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
-static
-#else
-extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+#ifndef isSPACE_A
+# define isSPACE_A isSPACE
#endif
-#ifdef mess_sv
-# undef mess_sv
+#ifndef isUPPER_A
+# define isUPPER_A isUPPER
#endif
-#define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b)
-#define Perl_mess_sv DPPP_(my_mess_sv)
-#if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL)
-SV *
-DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume)
-{
- SV *tmp;
- SV *ret;
+#ifndef isWORDCHAR_A
+# define isWORDCHAR_A isWORDCHAR
+#endif
- if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') {
- if (consume)
- return basemsg;
- ret = mess("");
- SvSetSV_nosteal(ret, basemsg);
- return ret;
- }
+#ifndef isXDIGIT_A
+# define isXDIGIT_A isXDIGIT
+#endif
- if (consume) {
- sv_catsv(basemsg, mess(""));
- return basemsg;
- }
+/* Until we figure out how to support this in older perls... */
+#if (PERL_BCDVERSION >= 0x5008000)
+#ifndef HeUTF8
+# define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \
+ SvUTF8(HeKEY_sv(he)) : \
+ (U32)HeKUTF8(he))
+#endif
- ret = mess("");
- tmp = newSVsv(ret);
- SvSetSV_nosteal(ret, basemsg);
- sv_catsv(ret, tmp);
- sv_dec(tmp);
- return ret;
-}
#endif
+#ifndef C_ARRAY_LENGTH
+# define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0]))
#endif
-#ifndef warn_nocontext
-#define warn_nocontext warn
+#ifndef C_ARRAY_END
+# define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a))
#endif
-
-#ifndef croak_nocontext
-#define croak_nocontext croak
+#ifndef LIKELY
+# define LIKELY(x) (x)
#endif
-#ifndef croak_no_modify
-#define croak_no_modify() croak_nocontext("%s", PL_no_modify)
-#define Perl_croak_no_modify() croak_no_modify()
+#ifndef UNLIKELY
+# define UNLIKELY(x) (x)
+#endif
+#ifndef UNICODE_REPLACEMENT
+# define UNICODE_REPLACEMENT 0xFFFD
#endif
-#ifndef croak_memory_wrap
-#if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) )
-# define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap)
+#ifndef MUTABLE_PTR
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define MUTABLE_PTR(p) ({ void *_p = (p); _p; })
#else
-# define croak_memory_wrap() croak_nocontext("panic: memory wrap")
+# define MUTABLE_PTR(p) ((void *) (p))
#endif
#endif
-
-#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
-#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)
+#ifndef MUTABLE_SV
+# define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p))
#endif
-#ifndef croak_xs_usage
-#if defined(NEED_croak_xs_usage)
-static void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
-static
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define vnewSVpvf(pat, args) ({ SV *_sv = newSV(0); sv_vsetpvfn(_sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)); _sv; })
#else
-extern void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
+# define vnewSVpvf(pat, args) ((PL_Sv = newSV(0)), sv_vsetpvfn(PL_Sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)), PL_Sv)
+#endif
#endif
-#define croak_xs_usage DPPP_(my_croak_xs_usage)
-#define Perl_croak_xs_usage DPPP_(my_croak_xs_usage)
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
+# define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
+#endif
-#if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL)
-void
-DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params)
-{
- dTHX;
- const GV *const gv = CvGV(cv);
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
+# define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
+#endif
- PERL_ARGS_ASSERT_CROAK_XS_USAGE;
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
+#if defined(NEED_sv_catpvf_mg)
+static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
+static
+#else
+extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
+#endif
- if (gv) {
- const char *const gvname = GvNAME(gv);
- const HV *const stash = GvSTASH(gv);
- const char *const hvname = stash ? HvNAME(stash) : NULL;
+#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
- if (hvname)
- croak("Usage: %s::%s(%s)", hvname, gvname, params);
- else
- croak("Usage: %s(%s)", gvname, params);
- } else {
- /* Pants. I don't think that it should be possible to get here. */
- croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
- }
-}
-#endif
-#endif
+#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
-#ifndef PERL_SIGNALS_UNSAFE_FLAG
-#define PERL_SIGNALS_UNSAFE_FLAG 0x0001
+void
+DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
+{
+ va_list args;
+ va_start(args, pat);
+ sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+ SvSETMAGIC(sv);
+ va_end(args);
+}
-#if (PERL_BCDVERSION < 0x5008000)
-# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG
-#else
-# define D_PPP_PERL_SIGNALS_INIT 0
+#endif
#endif
-#if defined(NEED_PL_signals)
-static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
-#elif defined(NEED_PL_signals_GLOBAL)
-U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
+#ifdef PERL_IMPLICIT_CONTEXT
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
+#if defined(NEED_sv_catpvf_mg_nocontext)
+static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
+static
#else
-extern U32 DPPP_(my_PL_signals);
+extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
#endif
-#define PL_signals DPPP_(my_PL_signals)
-#endif
+#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
-/* Hint: PL_ppaddr
- * Calling an op via PL_ppaddr requires passing a context argument
- * for threaded builds. Since the context argument is different for
- * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
- * automatically be defined as the correct argument.
- */
+#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
+#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
-#if (PERL_BCDVERSION <= 0x5005005)
-/* Replace: 1 */
-# define PL_ppaddr ppaddr
-# define PL_no_modify no_modify
-/* Replace: 0 */
-#endif
-#if (PERL_BCDVERSION <= 0x5004005)
-/* Replace: 1 */
-# define PL_DBsignal DBsignal
-# define PL_DBsingle DBsingle
-# define PL_DBsub DBsub
-# define PL_DBtrace DBtrace
-# define PL_Sv Sv
-# define PL_bufend bufend
-# define PL_bufptr bufptr
-# define PL_compiling compiling
-# define PL_copline copline
-# define PL_curcop curcop
-# define PL_curstash curstash
-# define PL_debstash debstash
-# define PL_defgv defgv
-# define PL_diehook diehook
-# define PL_dirty dirty
-# define PL_dowarn dowarn
-# define PL_errgv errgv
-# define PL_error_count error_count
-# define PL_expect expect
-# define PL_hexdigit hexdigit
-# define PL_hints hints
-# define PL_in_my in_my
-# define PL_laststatval laststatval
-# define PL_lex_state lex_state
-# define PL_lex_stuff lex_stuff
-# define PL_linestr linestr
-# define PL_na na
-# define PL_perl_destruct_level perl_destruct_level
-# define PL_perldb perldb
-# define PL_rsfp_filters rsfp_filters
-# define PL_rsfp rsfp
-# define PL_stack_base stack_base
-# define PL_stack_sp stack_sp
-# define PL_statcache statcache
-# define PL_stdingv stdingv
-# define PL_sv_arenaroot sv_arenaroot
-# define PL_sv_no sv_no
-# define PL_sv_undef sv_undef
-# define PL_sv_yes sv_yes
-# define PL_tainted tainted
-# define PL_tainting tainting
-# define PL_tokenbuf tokenbuf
-/* Replace: 0 */
-#endif
+void
+DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
+{
+ dTHX;
+ va_list args;
+ va_start(args, pat);
+ sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+ SvSETMAGIC(sv);
+ va_end(args);
+}
-/* Warning: PL_parser
- * For perl versions earlier than 5.9.5, this is an always
- * non-NULL dummy. Also, it cannot be dereferenced. Don't
- * use it if you can avoid is and unless you absolutely know
- * what you're doing.
- * If you always check that PL_parser is non-NULL, you can
- * define DPPP_PL_parser_NO_DUMMY to avoid the creation of
- * a dummy parser structure.
- */
+#endif
+#endif
+#endif
-#if (PERL_BCDVERSION >= 0x5009005)
-# ifdef DPPP_PL_parser_NO_DUMMY
-# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
- (croak("panic: PL_parser == NULL in %s:%d", \
- __FILE__, __LINE__), (yy_parser *) NULL))->var)
-# else
-# ifdef DPPP_PL_parser_NO_DUMMY_WARNING
-# define D_PPP_parser_dummy_warning(var)
+/* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
+#ifndef sv_catpvf_mg
+# ifdef PERL_IMPLICIT_CONTEXT
+# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext
# else
-# define D_PPP_parser_dummy_warning(var) \
- warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
+# define sv_catpvf_mg Perl_sv_catpvf_mg
# endif
-# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
- (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
-#if defined(NEED_PL_parser)
-static yy_parser DPPP_(dummy_PL_parser);
-#elif defined(NEED_PL_parser_GLOBAL)
-yy_parser DPPP_(dummy_PL_parser);
-#else
-extern yy_parser DPPP_(dummy_PL_parser);
#endif
-# endif
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
+# define sv_vcatpvf_mg(sv, pat, args) \
+ STMT_START { \
+ sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
+ SvSETMAGIC(sv); \
+ } STMT_END
+#endif
-/* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */
-/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
- * Do not use this variable unless you know exactly what you're
- * doing. It is internal to the perl parser and may change or even
- * be removed in the future. As of perl 5.9.5, you have to check
- * for (PL_parser != NULL) for this variable to have any effect.
- * An always non-NULL PL_parser dummy is provided for earlier
- * perl versions.
- * If PL_parser is NULL when you try to access this variable, a
- * dummy is being accessed instead and a warning is issued unless
- * you define DPPP_PL_parser_NO_DUMMY_WARNING.
- * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
- * this variable will croak with a panic message.
- */
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
+#if defined(NEED_sv_setpvf_mg)
+static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
+static
+#else
+extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
+#endif
-# define PL_expect D_PPP_my_PL_parser_var(expect)
-# define PL_copline D_PPP_my_PL_parser_var(copline)
-# define PL_rsfp D_PPP_my_PL_parser_var(rsfp)
-# define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters)
-# define PL_linestr D_PPP_my_PL_parser_var(linestr)
-# define PL_bufptr D_PPP_my_PL_parser_var(bufptr)
-# define PL_bufend D_PPP_my_PL_parser_var(bufend)
-# define PL_lex_state D_PPP_my_PL_parser_var(lex_state)
-# define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff)
-# define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf)
-# define PL_in_my D_PPP_my_PL_parser_var(in_my)
-# define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash)
-# define PL_error_count D_PPP_my_PL_parser_var(error_count)
+#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
+#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
-#else
-/* ensure that PL_parser != NULL and cannot be dereferenced */
-# define PL_parser ((void *) 1)
+void
+DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
+{
+ va_list args;
+ va_start(args, pat);
+ sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+ SvSETMAGIC(sv);
+ va_end(args);
+}
#endif
-#ifndef mPUSHs
-# define mPUSHs(s) PUSHs(sv_2mortal(s))
#endif
-#ifndef PUSHmortal
-# define PUSHmortal PUSHs(sv_newmortal())
+#ifdef PERL_IMPLICIT_CONTEXT
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
+#if defined(NEED_sv_setpvf_mg_nocontext)
+static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
+static
+#else
+extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
#endif
-#ifndef mPUSHp
-# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l))
-#endif
+#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
-#ifndef mPUSHn
-# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n))
-#endif
+#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
+#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
-#ifndef mPUSHi
-# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i))
-#endif
-#ifndef mPUSHu
-# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u))
-#endif
-#ifndef mXPUSHs
-# define mXPUSHs(s) XPUSHs(sv_2mortal(s))
-#endif
+void
+DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
+{
+ dTHX;
+ va_list args;
+ va_start(args, pat);
+ sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+ SvSETMAGIC(sv);
+ va_end(args);
+}
-#ifndef XPUSHmortal
-# define XPUSHmortal XPUSHs(sv_newmortal())
#endif
-
-#ifndef mXPUSHp
-# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
#endif
-
-#ifndef mXPUSHn
-# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
#endif
-#ifndef mXPUSHi
-# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
+/* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
+#ifndef sv_setpvf_mg
+# ifdef PERL_IMPLICIT_CONTEXT
+# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext
+# else
+# define sv_setpvf_mg Perl_sv_setpvf_mg
+# endif
#endif
-#ifndef mXPUSHu
-# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
+# define sv_vsetpvf_mg(sv, pat, args) \
+ STMT_START { \
+ sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
+ SvSETMAGIC(sv); \
+ } STMT_END
#endif
-/* Replace: 1 */
-#ifndef call_sv
-# define call_sv perl_call_sv
+/* Hint: sv_2pv_nolen
+ * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
+ */
+#ifndef sv_2pv_nolen
+# define sv_2pv_nolen(sv) SvPV_nolen(sv)
#endif
-#ifndef call_pv
-# define call_pv perl_call_pv
-#endif
+#ifdef SvPVbyte
-#ifndef call_argv
-# define call_argv perl_call_argv
-#endif
+/* Hint: SvPVbyte
+ * Does not work in perl-5.6.1, ppport.h implements a version
+ * borrowed from perl-5.7.3.
+ */
-#ifndef call_method
-# define call_method perl_call_method
-#endif
-#ifndef eval_sv
-# define eval_sv perl_eval_sv
+#if (PERL_BCDVERSION < 0x5007000)
+#ifndef sv_2pvbyte
+# define sv_2pvbyte(sv, lp) (sv_utf8_downgrade((sv), 0), SvPV((sv), *(lp)))
#endif
-/* Replace: 0 */
-#ifndef PERL_LOADMOD_DENY
-# define PERL_LOADMOD_DENY 0x1
-#endif
+/* Hint: sv_2pvbyte
+ * Use the SvPVbyte() macro instead of sv_2pvbyte().
+ */
-#ifndef PERL_LOADMOD_NOIMPORT
-# define PERL_LOADMOD_NOIMPORT 0x2
-#endif
+#undef SvPVbyte
-#ifndef PERL_LOADMOD_IMPORT_OPS
-# define PERL_LOADMOD_IMPORT_OPS 0x4
-#endif
+#define SvPVbyte(sv, lp) \
+ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
+ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
-#ifndef G_METHOD
-# define G_METHOD 64
-# ifdef call_sv
-# undef call_sv
-# endif
-# if (PERL_BCDVERSION < 0x5006000)
-# define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
- (flags) & ~G_METHOD) : perl_call_sv(sv, flags))
-# else
-# define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
- (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
-# endif
#endif
-/* Replace perl_eval_pv with eval_pv */
-
-#ifndef eval_pv
-#if defined(NEED_eval_pv)
-static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
-static
#else
-extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
-#endif
-
-#ifdef eval_pv
-# undef eval_pv
-#endif
-#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
-#define Perl_eval_pv DPPP_(my_eval_pv)
-
-#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
-
-SV*
-DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
-{
- dSP;
- SV* sv = newSVpv(p, 0);
- PUSHMARK(sp);
- eval_sv(sv, G_SCALAR);
- SvREFCNT_dec(sv);
+# define SvPVbyte SvPV
+# define sv_2pvbyte sv_2pv
- SPAGAIN;
- sv = POPs;
- PUTBACK;
+#endif
+#ifndef sv_2pvbyte_nolen
+# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv)
+#endif
- if (croak_on_error && SvTRUEx(ERRSV))
- croak_sv(ERRSV);
+/* Hint: sv_pvn
+ * Always use the SvPV() macro instead of sv_pvn().
+ */
- return sv;
-}
+/* Hint: sv_pvn_force
+ * Always use the SvPV_force() macro instead of sv_pvn_force().
+ */
-#endif
+/* If these are undefined, they're not handled by the core anyway */
+#ifndef SV_IMMEDIATE_UNREF
+# define SV_IMMEDIATE_UNREF 0
#endif
-#ifndef vload_module
-#if defined(NEED_vload_module)
-static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
-static
-#else
-extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
+#ifndef SV_GMAGIC
+# define SV_GMAGIC 0
#endif
-#ifdef vload_module
-# undef vload_module
+#ifndef SV_COW_DROP_PV
+# define SV_COW_DROP_PV 0
#endif
-#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
-#define Perl_vload_module DPPP_(my_vload_module)
-
-#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
-
-void
-DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
-{
- dTHR;
- dVAR;
- OP *veop, *imop;
-
- OP * const modname = newSVOP(OP_CONST, 0, name);
- /* 5.005 has a somewhat hacky force_normal that doesn't croak on
- SvREADONLY() if PL_compling is true. Current perls take care in
- ck_require() to correctly turn off SvREADONLY before calling
- force_normal_flags(). This seems a better fix than fudging PL_compling
- */
- SvREADONLY_off(((SVOP*)modname)->op_sv);
- modname->op_private |= OPpCONST_BARE;
- if (ver) {
- veop = newSVOP(OP_CONST, 0, ver);
- }
- else
- veop = NULL;
- if (flags & PERL_LOADMOD_NOIMPORT) {
- imop = sawparens(newNULLLIST());
- }
- else if (flags & PERL_LOADMOD_IMPORT_OPS) {
- imop = va_arg(*args, OP*);
- }
- else {
- SV *sv;
- imop = NULL;
- sv = va_arg(*args, SV*);
- while (sv) {
- imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
- sv = va_arg(*args, SV*);
- }
- }
- {
- const line_t ocopline = PL_copline;
- COP * const ocurcop = PL_curcop;
- const int oexpect = PL_expect;
-#if (PERL_BCDVERSION >= 0x5004000)
- utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
- veop, modname, imop);
-#elif (PERL_BCDVERSION > 0x5003000)
- utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
- veop, modname, imop);
-#else
- utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
- modname, imop);
+#ifndef SV_UTF8_NO_ENCODING
+# define SV_UTF8_NO_ENCODING 0
#endif
- PL_expect = oexpect;
- PL_copline = ocopline;
- PL_curcop = ocurcop;
- }
-}
-#endif
+#ifndef SV_CONST_RETURN
+# define SV_CONST_RETURN 0
#endif
-#ifndef load_module
-#if defined(NEED_load_module)
-static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
-static
-#else
-extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
+#ifndef SV_MUTABLE_RETURN
+# define SV_MUTABLE_RETURN 0
#endif
-#ifdef load_module
-# undef load_module
+#ifndef SV_SMAGIC
+# define SV_SMAGIC 0
#endif
-#define load_module DPPP_(my_load_module)
-#define Perl_load_module DPPP_(my_load_module)
-#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
+#ifndef SV_HAS_TRAILING_NUL
+# define SV_HAS_TRAILING_NUL 0
+#endif
-void
-DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
-{
- va_list args;
- va_start(args, ver);
- vload_module(flags, name, ver, &args);
- va_end(args);
-}
+#ifndef SV_COW_SHARED_HASH_KEYS
+# define SV_COW_SHARED_HASH_KEYS 0
+#endif
+#if (PERL_BCDVERSION < 0x5007002)
+#ifndef sv_2pv_flags
+# define sv_2pv_flags(sv, lp, flags) sv_2pv((sv), (lp) ? (lp) : &PL_na)
#endif
+
+#ifndef sv_pvn_force_flags
+# define sv_pvn_force_flags(sv, lp, flags) sv_pvn_force((sv), (lp) ? (lp) : &PL_na)
#endif
-#ifndef newRV_inc
-# define newRV_inc(sv) newRV(sv) /* Replace */
+
#endif
-#ifndef newRV_noinc
-#if defined(NEED_newRV_noinc)
-static SV * DPPP_(my_newRV_noinc)(SV *sv);
-static
+#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
+# define D_PPP_SVPV_NOLEN_LP_ARG &PL_na
#else
-extern SV * DPPP_(my_newRV_noinc)(SV *sv);
+# define D_PPP_SVPV_NOLEN_LP_ARG 0
#endif
-
-#ifdef newRV_noinc
-# undef newRV_noinc
+#ifndef SvPV_const
+# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
#endif
-#define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
-#define Perl_newRV_noinc DPPP_(my_newRV_noinc)
-#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
-SV *
-DPPP_(my_newRV_noinc)(SV *sv)
-{
- SV *rv = (SV *)newRV(sv);
- SvREFCNT_dec(sv);
- return rv;
-}
+#ifndef SvPV_mutable
+# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
+#endif
+#ifndef SvPV_flags
+# define SvPV_flags(sv, lp, flags) \
+ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
+#endif
+#ifndef SvPV_flags_const
+# define SvPV_flags_const(sv, lp, flags) \
+ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
+ (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
+#endif
+#ifndef SvPV_flags_const_nolen
+# define SvPV_flags_const_nolen(sv, flags) \
+ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? SvPVX_const(sv) : \
+ (const char*) sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
+#endif
+#ifndef SvPV_flags_mutable
+# define SvPV_flags_mutable(sv, lp, flags) \
+ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
+ sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
#endif
+#ifndef SvPV_force
+# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
#endif
-/* Hint: newCONSTSUB
- * Returns a CV* as of perl-5.7.1. This return value is not supported
- * by Devel::PPPort.
- */
+#ifndef SvPV_force_nolen
+# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
+#endif
-/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
-#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
-#if defined(NEED_newCONSTSUB)
-static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
-static
-#else
-extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
+#ifndef SvPV_force_mutable
+# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
#endif
-#ifdef newCONSTSUB
-# undef newCONSTSUB
+#ifndef SvPV_force_nomg
+# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
#endif
-#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
-#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
-#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
+#ifndef SvPV_force_nomg_nolen
+# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
+#endif
+#ifndef SvPV_force_flags
+# define SvPV_force_flags(sv, lp, flags) \
+ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
+ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
+#endif
+#ifndef SvPV_force_flags_nolen
+# define SvPV_force_flags_nolen(sv, flags) \
+ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
+ ? SvPVX(sv) : sv_pvn_force_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags))
+#endif
+#ifndef SvPV_force_flags_mutable
+# define SvPV_force_flags_mutable(sv, lp, flags) \
+ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
+ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
+ : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
+#endif
+#ifndef SvPV_nolen
+# define SvPV_nolen(sv) \
+ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
+#endif
+#ifndef SvPV_nolen_const
+# define SvPV_nolen_const(sv) \
+ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? SvPVX_const(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
+#endif
+#ifndef SvPV_nomg
+# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
+#endif
-/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
-/* (There's no PL_parser in perl < 5.005, so this is completely safe) */
-#define D_PPP_PL_copline PL_copline
+#ifndef SvPV_nomg_const
+# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
+#endif
-void
-DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
-{
- U32 oldhints = PL_hints;
- HV *old_cop_stash = PL_curcop->cop_stash;
- HV *old_curstash = PL_curstash;
- line_t oldline = PL_curcop->cop_line;
- PL_curcop->cop_line = D_PPP_PL_copline;
+#ifndef SvPV_nomg_const_nolen
+# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
+#endif
- PL_hints &= ~HINT_BLOCK_SCOPE;
- if (stash)
- PL_curstash = PL_curcop->cop_stash = stash;
+#ifndef SvPV_nomg_nolen
+# define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+ ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, 0))
+#endif
+#ifndef SvPV_renew
+# define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \
+ SvPV_set((sv), (char *) saferealloc( \
+ (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
+ } STMT_END
+#endif
+#ifndef WARN_ALL
+# define WARN_ALL 0
+#endif
- newSUB(
+#ifndef WARN_CLOSURE
+# define WARN_CLOSURE 1
+#endif
-#if (PERL_BCDVERSION < 0x5003022)
- start_subparse(),
-#elif (PERL_BCDVERSION == 0x5003022)
- start_subparse(0),
-#else /* 5.003_23 onwards */
- start_subparse(FALSE, 0),
+#ifndef WARN_DEPRECATED
+# define WARN_DEPRECATED 2
#endif
- newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
- newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
- newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
- );
+#ifndef WARN_EXITING
+# define WARN_EXITING 3
+#endif
- PL_hints = oldhints;
- PL_curcop->cop_stash = old_cop_stash;
- PL_curstash = old_curstash;
- PL_curcop->cop_line = oldline;
-}
+#ifndef WARN_GLOB
+# define WARN_GLOB 4
#endif
+
+#ifndef WARN_IO
+# define WARN_IO 5
#endif
-/*
- * Boilerplate macros for initializing and accessing interpreter-local
- * data from C. All statics in extensions should be reworked to use
- * this, if you want to make the extension thread-safe. See ext/re/re.xs
- * for an example of the use of these macros.
- *
- * Code that uses these macros is responsible for the following:
- * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
- * 2. Declare a typedef named my_cxt_t that is a structure that contains
- * all the data that needs to be interpreter-local.
- * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
- * 4. Use the MY_CXT_INIT macro such that it is called exactly once
- * (typically put in the BOOT: section).
- * 5. Use the members of the my_cxt_t structure everywhere as
- * MY_CXT.member.
- * 6. Use the dMY_CXT macro (a declaration) in all the functions that
- * access MY_CXT.
- */
+#ifndef WARN_CLOSED
+# define WARN_CLOSED 6
+#endif
-#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
- defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT)
+#ifndef WARN_EXEC
+# define WARN_EXEC 7
+#endif
-#ifndef START_MY_CXT
+#ifndef WARN_LAYER
+# define WARN_LAYER 8
+#endif
-/* This must appear in all extensions that define a my_cxt_t structure,
- * right after the definition (i.e. at file scope). The non-threads
- * case below uses it to declare the data as static. */
-#define START_MY_CXT
+#ifndef WARN_NEWLINE
+# define WARN_NEWLINE 9
+#endif
-#if (PERL_BCDVERSION < 0x5004068)
-/* Fetches the SV that keeps the per-interpreter data. */
-#define dMY_CXT_SV \
- SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
-#else /* >= perl5.004_68 */
-#define dMY_CXT_SV \
- SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \
- sizeof(MY_CXT_KEY)-1, TRUE)
-#endif /* < perl5.004_68 */
+#ifndef WARN_PIPE
+# define WARN_PIPE 10
+#endif
-/* This declaration should be used within all functions that use the
- * interpreter-local data. */
-#define dMY_CXT \
- dMY_CXT_SV; \
- my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
+#ifndef WARN_UNOPENED
+# define WARN_UNOPENED 11
+#endif
-/* Creates and zeroes the per-interpreter data.
- * (We allocate my_cxtp in a Perl SV so that it will be released when
- * the interpreter goes away.) */
-#define MY_CXT_INIT \
- dMY_CXT_SV; \
- /* newSV() allocates one more than needed */ \
- my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
- Zero(my_cxtp, 1, my_cxt_t); \
- sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
+#ifndef WARN_MISC
+# define WARN_MISC 12
+#endif
-/* This macro must be used to access members of the my_cxt_t structure.
- * e.g. MYCXT.some_data */
-#define MY_CXT (*my_cxtp)
+#ifndef WARN_NUMERIC
+# define WARN_NUMERIC 13
+#endif
-/* Judicious use of these macros can reduce the number of times dMY_CXT
- * is used. Use is similar to pTHX, aTHX etc. */
-#define pMY_CXT my_cxt_t *my_cxtp
-#define pMY_CXT_ pMY_CXT,
-#define _pMY_CXT ,pMY_CXT
-#define aMY_CXT my_cxtp
-#define aMY_CXT_ aMY_CXT,
-#define _aMY_CXT ,aMY_CXT
+#ifndef WARN_ONCE
+# define WARN_ONCE 14
+#endif
-#endif /* START_MY_CXT */
+#ifndef WARN_OVERFLOW
+# define WARN_OVERFLOW 15
+#endif
-#ifndef MY_CXT_CLONE
-/* Clones the per-interpreter data. */
-#define MY_CXT_CLONE \
- dMY_CXT_SV; \
- my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
- Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
- sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
+#ifndef WARN_PACK
+# define WARN_PACK 16
#endif
-#else /* single interpreter */
+#ifndef WARN_PORTABLE
+# define WARN_PORTABLE 17
+#endif
-#ifndef START_MY_CXT
+#ifndef WARN_RECURSION
+# define WARN_RECURSION 18
+#endif
-#define START_MY_CXT static my_cxt_t my_cxt;
-#define dMY_CXT_SV dNOOP
-#define dMY_CXT dNOOP
-#define MY_CXT_INIT NOOP
-#define MY_CXT my_cxt
+#ifndef WARN_REDEFINE
+# define WARN_REDEFINE 19
+#endif
-#define pMY_CXT void
-#define pMY_CXT_
-#define _pMY_CXT
-#define aMY_CXT
-#define aMY_CXT_
-#define _aMY_CXT
+#ifndef WARN_REGEXP
+# define WARN_REGEXP 20
+#endif
-#endif /* START_MY_CXT */
+#ifndef WARN_SEVERE
+# define WARN_SEVERE 21
+#endif
-#ifndef MY_CXT_CLONE
-#define MY_CXT_CLONE NOOP
+#ifndef WARN_DEBUGGING
+# define WARN_DEBUGGING 22
#endif
+#ifndef WARN_INPLACE
+# define WARN_INPLACE 23
#endif
-#ifndef SvREFCNT_inc
-# ifdef PERL_USE_GCC_BRACE_GROUPS
-# define SvREFCNT_inc(sv) \
- ({ \
- SV * const _sv = (SV*)(sv); \
- if (_sv) \
- (SvREFCNT(_sv))++; \
- _sv; \
- })
-# else
-# define SvREFCNT_inc(sv) \
- ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
-# endif
+#ifndef WARN_INTERNAL
+# define WARN_INTERNAL 24
#endif
-#ifndef SvREFCNT_inc_simple
-# ifdef PERL_USE_GCC_BRACE_GROUPS
-# define SvREFCNT_inc_simple(sv) \
- ({ \
- if (sv) \
- (SvREFCNT(sv))++; \
- (SV *)(sv); \
- })
+#ifndef WARN_MALLOC
+# define WARN_MALLOC 25
+#endif
+
+#ifndef WARN_SIGNAL
+# define WARN_SIGNAL 26
+#endif
+
+#ifndef WARN_SUBSTR
+# define WARN_SUBSTR 27
+#endif
+
+#ifndef WARN_SYNTAX
+# define WARN_SYNTAX 28
+#endif
+
+#ifndef WARN_AMBIGUOUS
+# define WARN_AMBIGUOUS 29
+#endif
+
+#ifndef WARN_BAREWORD
+# define WARN_BAREWORD 30
+#endif
+
+#ifndef WARN_DIGIT
+# define WARN_DIGIT 31
+#endif
+
+#ifndef WARN_PARENTHESIS
+# define WARN_PARENTHESIS 32
+#endif
+
+#ifndef WARN_PRECEDENCE
+# define WARN_PRECEDENCE 33
+#endif
+
+#ifndef WARN_PRINTF
+# define WARN_PRINTF 34
+#endif
+
+#ifndef WARN_PROTOTYPE
+# define WARN_PROTOTYPE 35
+#endif
+
+#ifndef WARN_QW
+# define WARN_QW 36
+#endif
+
+#ifndef WARN_RESERVED
+# define WARN_RESERVED 37
+#endif
+
+#ifndef WARN_SEMICOLON
+# define WARN_SEMICOLON 38
+#endif
+
+#ifndef WARN_TAINT
+# define WARN_TAINT 39
+#endif
+
+#ifndef WARN_THREADS
+# define WARN_THREADS 40
+#endif
+
+#ifndef WARN_UNINITIALIZED
+# define WARN_UNINITIALIZED 41
+#endif
+
+#ifndef WARN_UNPACK
+# define WARN_UNPACK 42
+#endif
+
+#ifndef WARN_UNTIE
+# define WARN_UNTIE 43
+#endif
+
+#ifndef WARN_UTF8
+# define WARN_UTF8 44
+#endif
+
+#ifndef WARN_VOID
+# define WARN_VOID 45
+#endif
+
+#ifndef WARN_ASSERTIONS
+# define WARN_ASSERTIONS 46
+#endif
+#ifndef packWARN
+# define packWARN(a) (a)
+#endif
+
+#ifndef ckWARN
+# ifdef G_WARN_ON
+# define ckWARN(a) (PL_dowarn & G_WARN_ON)
# else
-# define SvREFCNT_inc_simple(sv) \
- ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
+# define ckWARN(a) PL_dowarn
# endif
#endif
-#ifndef SvREFCNT_inc_NN
-# ifdef PERL_USE_GCC_BRACE_GROUPS
-# define SvREFCNT_inc_NN(sv) \
- ({ \
- SV * const _sv = (SV*)(sv); \
- SvREFCNT(_sv)++; \
- _sv; \
- })
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
+#if defined(NEED_warner)
+static void DPPP_(my_warner)(U32 err, const char *pat, ...);
+static
+#else
+extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
+#endif
+
+#if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
+
+#define Perl_warner DPPP_(my_warner)
+
+
+void
+DPPP_(my_warner)(U32 err, const char *pat, ...)
+{
+ SV *sv;
+ va_list args;
+
+ PERL_UNUSED_ARG(err);
+
+ va_start(args, pat);
+ sv = vnewSVpvf(pat, &args);
+ va_end(args);
+ sv_2mortal(sv);
+ warn("%s", SvPV_nolen(sv));
+}
+
+#define warner Perl_warner
+
+#define Perl_warner_nocontext Perl_warner
+
+#endif
+#endif
+
+#ifndef IVdf
+# if IVSIZE == LONGSIZE
+# define IVdf "ld"
+# define UVuf "lu"
+# define UVof "lo"
+# define UVxf "lx"
+# define UVXf "lX"
+# elif IVSIZE == INTSIZE
+# define IVdf "d"
+# define UVuf "u"
+# define UVof "o"
+# define UVxf "x"
+# define UVXf "X"
# else
-# define SvREFCNT_inc_NN(sv) \
- (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
+# error "cannot define IV/UV formats"
# endif
#endif
-#ifndef SvREFCNT_inc_void
-# ifdef PERL_USE_GCC_BRACE_GROUPS
-# define SvREFCNT_inc_void(sv) \
- ({ \
- SV * const _sv = (SV*)(sv); \
- if (_sv) \
- (void)(SvREFCNT(_sv)++); \
- })
+#ifndef NVef
+# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
+ defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
+ /* Not very likely, but let's try anyway. */
+# define NVef PERL_PRIeldbl
+# define NVff PERL_PRIfldbl
+# define NVgf PERL_PRIgldbl
# else
-# define SvREFCNT_inc_void(sv) \
- (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
+# define NVef "e"
+# define NVff "f"
+# define NVgf "g"
# endif
#endif
-#ifndef SvREFCNT_inc_simple_void
-# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
+
+#define D_PPP_MIN(a,b) (((a) <= (b)) ? (a) : (b))
+#ifndef sv_setuv
+# define sv_setuv(sv, uv) \
+ STMT_START { \
+ UV TeMpUv = uv; \
+ if (TeMpUv <= IV_MAX) \
+ sv_setiv(sv, TeMpUv); \
+ else \
+ sv_setnv(sv, (double)TeMpUv); \
+ } STMT_END
+#endif
+#ifndef newSVuv
+# define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
+#endif
+
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#ifndef sv_2uv
+# define sv_2uv(sv) ({ SV *_sv = (sv); (UV) (SvNOK(_sv) ? SvNV(_sv) : sv_2nv(_sv)); })
+#endif
+
+#else
+#ifndef sv_2uv
+# define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
+#endif
+
+#endif
+#ifndef SvUVX
+# define SvUVX(sv) ((UV)SvIVX(sv))
+#endif
+
+#ifndef SvUVXx
+# define SvUVXx(sv) SvUVX(sv)
+#endif
+
+#ifndef SvUV
+# define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
+#endif
+
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#ifndef SvUVx
+# define SvUVx(sv) ({ SV *_sv = (sv)); SvUV(_sv); })
+#endif
+
+#else
+#ifndef SvUVx
+# define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
+#endif
+
+#endif
+
+/* Hint: sv_uv
+ * Always use the SvUVx() macro instead of sv_uv().
+ */
+#ifndef sv_uv
+# define sv_uv(sv) SvUVx(sv)
+#endif
+
+#if !defined(SvUOK) && defined(SvIOK_UV)
+# define SvUOK(sv) SvIOK_UV(sv)
+#endif
+#ifndef XST_mUV
+# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
+#endif
+
+#ifndef XSRETURN_UV
+# define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END
+#endif
+#ifndef PUSHu
+# define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
+#endif
+
+#ifndef XPUSHu
+# define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
+#endif
+
+#if defined UTF8SKIP
+
+/* Don't use official version because it uses MIN, which may not be available */
+#undef UTF8_SAFE_SKIP
+#ifndef UTF8_SAFE_SKIP
+# define UTF8_SAFE_SKIP(s, e) ( \
+ ((((e) - (s)) <= 0) \
+ ? 0 \
+ : D_PPP_MIN(((e) - (s)), UTF8SKIP(s))))
+#endif
+
+#endif
+
+#if !defined(my_strnlen)
+#if defined(NEED_my_strnlen)
+static STRLEN DPPP_(my_my_strnlen)(const char *str, Size_t maxlen);
+static
+#else
+extern STRLEN DPPP_(my_my_strnlen)(const char *str, Size_t maxlen);
+#endif
+
+#if defined(NEED_my_strnlen) || defined(NEED_my_strnlen_GLOBAL)
+
+#define my_strnlen DPPP_(my_my_strnlen)
+#define Perl_my_strnlen DPPP_(my_my_strnlen)
+
+
+STRLEN
+DPPP_(my_my_strnlen)(const char *str, Size_t maxlen)
+{
+ const char *p = str;
+
+ while(maxlen-- && *p)
+ p++;
+
+ return p - str;
+}
+
+#endif
+#endif
+
+#if (PERL_BCDVERSION < 0x5031004)
+ /* Versions prior to this accepted things that are now considered
+ * malformations, and didn't return -1 on error with warnings enabled
+ * */
+# undef utf8_to_uvchr_buf
+#endif
+
+/* This implementation brings modern, generally more restricted standards to
+ * utf8_to_uvchr_buf. Some of these are security related, and clearly must
+ * be done. But its arguable that the others need not, and hence should not.
+ * The reason they're here is that a module that intends to play with the
+ * latest perls should be able to work the same in all releases. An example is
+ * that perl no longer accepts any UV for a code point, but limits them to
+ * IV_MAX or below. This is for future internal use of the larger code points.
+ * If it turns out that some of these changes are breaking code that isn't
+ * intended to work with modern perls, the tighter restrictions could be
+ * relaxed. khw thinks this is unlikely, but has been wrong in the past. */
+
+/* 5.6.0 is the first release with UTF-8, and we don't implement this function
+ * there due to its likely lack of still being in use, and the underlying
+ * implementation is very different from later ones, without the later
+ * safeguards, so would require extra work to deal with */
+#if (PERL_BCDVERSION >= 0x5006001) && ! defined(utf8_to_uvchr_buf)
+ /* Choose which underlying implementation to use. At least one must be
+ * present or the perl is too early to handle this function */
+# if defined(utf8n_to_uvchr) || defined(utf8_to_uv)
+# if defined(utf8n_to_uvchr) /* This is the preferred implementation */
+# define D_PPP_utf8_to_uvchr_buf_callee utf8n_to_uvchr
+# else /* Must be at least 5.6.1 from #if above */
+# define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags) utf8_to_uv((U8 *)(s), (curlen), (retlen), (flags))
+# endif
+# endif
+
+# if defined(NEED_utf8_to_uvchr_buf)
+static UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen);
+static
+#else
+extern UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen);
+#endif
+
+#if defined(NEED_utf8_to_uvchr_buf) || defined(NEED_utf8_to_uvchr_buf_GLOBAL)
+
+#ifdef utf8_to_uvchr_buf
+# undef utf8_to_uvchr_buf
+#endif
+#define utf8_to_uvchr_buf(a,b,c) DPPP_(my_utf8_to_uvchr_buf)(aTHX_ a,b,c)
+#define Perl_utf8_to_uvchr_buf DPPP_(my_utf8_to_uvchr_buf)
+
+
+UV
+DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
+{
+ UV ret;
+ STRLEN curlen;
+ bool overflows = 0;
+ const U8 *cur_s = s;
+ const bool do_warnings = ckWARN_d(WARN_UTF8);
+# if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC)
+ STRLEN overflow_length = 0;
+# endif
+
+ if (send > s) {
+ curlen = send - s;
+ }
+ else {
+ assert(0); /* Modern perls die under this circumstance */
+ curlen = 0;
+ if (! do_warnings) { /* Handle empty here if no warnings needed */
+ if (retlen) *retlen = 0;
+ return UNICODE_REPLACEMENT;
+ }
+ }
+
+# if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC)
+
+ /* Perl did not properly detect overflow for much of its history on
+ * non-EBCDIC platforms, often returning an overlong value which may or may
+ * not have been tolerated in the call. Also, earlier versions, when they
+ * did detect overflow, may have disallowed it completely. Modern ones can
+ * replace it with the REPLACEMENT CHARACTER, depending on calling
+ * parameters. Therefore detect it ourselves in releases it was
+ * problematic in. */
+
+ if (curlen > 0 && UNLIKELY(*s >= 0xFE)) {
+
+ /* First, on a 32-bit machine the first byte being at least \xFE
+ * automatically is overflow, as it indicates something requiring more
+ * than 31 bits */
+ if (sizeof(ret) < 8) {
+ overflows = 1;
+ overflow_length = 7;
+ }
+ else {
+ const U8 highest[] = /* 2*63-1 */
+ "\xFF\x80\x87\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF";
+ const U8 *cur_h = highest;
+
+ for (cur_s = s; cur_s < send; cur_s++, cur_h++) {
+ if (UNLIKELY(*cur_s == *cur_h)) {
+ continue;
+ }
+
+ /* If this byte is larger than the corresponding highest UTF-8
+ * byte, the sequence overflows; otherwise the byte is less
+ * than (as we handled the equality case above), and so the
+ * sequence doesn't overflow */
+ overflows = *cur_s > *cur_h;
+ break;
+
+ }
+
+ /* Here, either we set the bool and broke out of the loop, or got
+ * to the end and all bytes are the same which indicates it doesn't
+ * overflow. If it did overflow, it would be this number of bytes
+ * */
+ overflow_length = 13;
+ }
+ }
+
+ if (UNLIKELY(overflows)) {
+ ret = 0;
+
+ if (! do_warnings && retlen) {
+ *retlen = overflow_length;
+ }
+ }
+ else
+
+# endif /* < 5.26 */
+
+ /* Here, we are either in a release that properly detects overflow, or
+ * we have checked for overflow and the next statement is executing as
+ * part of the above conditional where we know we don't have overflow.
+ *
+ * The modern versions allow anything that evaluates to a legal UV, but
+ * not overlongs nor an empty input */
+ ret = D_PPP_utf8_to_uvchr_buf_callee(
+ s, curlen, retlen, (UTF8_ALLOW_ANYUV
+ & ~(UTF8_ALLOW_LONG|UTF8_ALLOW_EMPTY)));
+
+# if (PERL_BCDVERSION >= 0x5026000) && (PERL_BCDVERSION < 0x5028000)
+
+ /* But actually, more modern versions restrict the UV to being no more than
+ * what * an IV can hold, so it could, so it could still have gotten it
+ * wrong about overflowing. */
+ if (UNLIKELY(ret > IV_MAX)) {
+ overflows = 1;
+ }
+
+# endif
+
+ if (UNLIKELY(overflows)) {
+ if (! do_warnings) {
+ if (retlen) {
+ *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s));
+ *retlen = D_PPP_MIN(*retlen, curlen);
+ }
+ return UNICODE_REPLACEMENT;
+ }
+ else {
+
+ /* We use the error message in use from 5.8-5.26 */
+ Perl_warner(aTHX_ packWARN(WARN_UTF8),
+ "Malformed UTF-8 character (overflow at 0x%" UVxf
+ ", byte 0x%02x, after start byte 0x%02x)",
+ ret, *cur_s, *s);
+ if (retlen) {
+ *retlen = (STRLEN) -1;
+ }
+ return 0;
+ }
+ }
+
+ /* Here, did not overflow, but if it failed for some other reason, and
+ * warnings are off, to emulate the behavior of the real utf8_to_uvchr(),
+ * try again, allowing anything. (Note a return of 0 is ok if the input
+ * was '\0') */
+ if (UNLIKELY(ret == 0 && (curlen == 0 || *s != '\0'))) {
+
+ /* If curlen is 0, we already handled the case where warnings are
+ * disabled, so this 'if' will be true, and so later on, we know that
+ * 's' is dereferencible */
+ if (do_warnings) {
+ *retlen = (STRLEN) -1;
+ }
+ else {
+ ret = D_PPP_utf8_to_uvchr_buf_callee(
+ s, curlen, retlen, UTF8_ALLOW_ANY);
+ /* Override with the REPLACEMENT character, as that is what the
+ * modern version of this function returns */
+ ret = UNICODE_REPLACEMENT;
+
+# if (PERL_BCDVERSION < 0x5016000)
+
+ /* Versions earlier than this don't necessarily return the proper
+ * length. It should not extend past the end of string, nor past
+ * what the first byte indicates the length is, nor past the
+ * continuation characters */
+ if (retlen && *retlen >= 0) {
+ unsigned int i = 1;
+
+ *retlen = D_PPP_MIN(*retlen, curlen);
+ *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s));
+ do {
+ if (s[i] < 0x80 || s[i] > 0xBF) {
+ *retlen = i;
+ break;
+ }
+ } while (++i < *retlen);
+ }
+
+# endif
+
+ }
+ }
+
+ return ret;
+}
+
+# endif
+#endif
+
+#if defined(UTF8SKIP) && defined(utf8_to_uvchr_buf)
+#undef utf8_to_uvchr /* Always redefine this unsafe function so that it refuses
+ to read past a NUL, making it much less likely to read
+ off the end of the buffer. A NUL indicates the start
+ of the next character anyway. If the input isn't
+ NUL-terminated, the function remains unsafe, as it
+ always has been. */
+#ifndef utf8_to_uvchr
+# define utf8_to_uvchr(s, lp) \
+ ((*(s) == '\0') \
+ ? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */ \
+ : utf8_to_uvchr_buf(s, (s) + my_strnlen((char *) (s), UTF8SKIP(s)), (lp)))
+#endif
+
+#endif
+
+#ifdef HAS_MEMCMP
+#ifndef memNE
+# define memNE(s1,s2,l) (memcmp(s1,s2,l))
+#endif
+
+#ifndef memEQ
+# define memEQ(s1,s2,l) (!memcmp(s1,s2,l))
+#endif
+
+#else
+#ifndef memNE
+# define memNE(s1,s2,l) (bcmp(s1,s2,l))
+#endif
+
+#ifndef memEQ
+# define memEQ(s1,s2,l) (!bcmp(s1,s2,l))
+#endif
+
+#endif
+#ifndef memEQs
+# define memEQs(s1, l, s2) \
+ (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1)))
+#endif
+
+#ifndef memNEs
+# define memNEs(s1, l, s2) !memEQs(s1, l, s2)
+#endif
+#ifndef MoveD
+# define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t))
+#endif
+
+#ifndef CopyD
+# define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
+#endif
+
+#ifdef HAS_MEMSET
+#ifndef ZeroD
+# define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t))
+#endif
+
+#else
+#ifndef ZeroD
+# define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d)
+#endif
+
+#endif
+#ifndef PoisonWith
+# define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
+#endif
+
+#ifndef PoisonNew
+# define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB)
+#endif
+
+#ifndef PoisonFree
+# define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF)
+#endif
+
+#ifndef Poison
+# define Poison(d,n,t) PoisonFree(d,n,t)
+#endif
+#ifndef Newx
+# define Newx(v,n,t) New(0,v,n,t)
+#endif
+
+#ifndef Newxc
+# define Newxc(v,n,t,c) Newc(0,v,n,t,c)
+#endif
+
+#ifndef Newxz
+# define Newxz(v,n,t) Newz(0,v,n,t)
+#endif
+
+#ifdef NEED_mess_sv
+#define NEED_mess
+#endif
+
+#ifdef NEED_mess
+#define NEED_mess_nocontext
+#define NEED_vmess
+#endif
+
+#ifndef croak_sv
+#if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) )
+# if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) )
+# define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) \
+ STMT_START { \
+ SV *_errsv = ERRSV; \
+ SvFLAGS(_errsv) = (SvFLAGS(_errsv) & ~SVf_UTF8) | \
+ (SvFLAGS(sv) & SVf_UTF8); \
+ } STMT_END
+# else
+# define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) STMT_START {} STMT_END
+# endif
+# define croak_sv(sv) \
+ STMT_START { \
+ SV *_sv = (sv); \
+ if (SvROK(_sv)) { \
+ sv_setsv(ERRSV, _sv); \
+ croak(NULL); \
+ } else { \
+ D_PPP_FIX_UTF8_ERRSV_FOR_SV(_sv); \
+ croak("%" SVf, SVfARG(_sv)); \
+ } \
+ } STMT_END
+#elif (PERL_BCDVERSION >= 0x5004000)
+# define croak_sv(sv) croak("%" SVf, SVfARG(sv))
+#else
+# define croak_sv(sv) croak("%s", SvPV_nolen(sv))
+#endif
+#endif
+
+#ifndef die_sv
+#if defined(NEED_die_sv)
+static OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+static
+#else
+extern OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+#endif
+
+#if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL)
+
+#ifdef die_sv
+# undef die_sv
+#endif
+#define die_sv(a) DPPP_(my_die_sv)(aTHX_ a)
+#define Perl_die_sv DPPP_(my_die_sv)
+
+OP *
+DPPP_(my_die_sv)(pTHX_ SV *sv)
+{
+ croak_sv(sv);
+ return (OP *)NULL;
+}
+#endif
+#endif
+
+#ifndef warn_sv
+#if (PERL_BCDVERSION >= 0x5004000)
+# define warn_sv(sv) warn("%" SVf, SVfARG(sv))
+#else
+# define warn_sv(sv) warn("%s", SvPV_nolen(sv))
+#endif
+#endif
+
+#ifndef vmess
+#if defined(NEED_vmess)
+static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+static
+#else
+extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+#endif
+
+#if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL)
+
+#ifdef vmess
+# undef vmess
+#endif
+#define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b)
+#define Perl_vmess DPPP_(my_vmess)
+
+SV*
+DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args)
+{
+ mess(pat, args);
+ return PL_mess_sv;
+}
+#endif
+#endif
+
+#if (PERL_BCDVERSION < 0x5006000)
+#undef mess
+#endif
+
+#if !defined(mess_nocontext) && !defined(Perl_mess_nocontext)
+#if defined(NEED_mess_nocontext)
+static SV* DPPP_(my_mess_nocontext)(const char* pat, ...);
+static
+#else
+extern SV* DPPP_(my_mess_nocontext)(const char* pat, ...);
+#endif
+
+#if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL)
+
+#define mess_nocontext DPPP_(my_mess_nocontext)
+#define Perl_mess_nocontext DPPP_(my_mess_nocontext)
+
+SV*
+DPPP_(my_mess_nocontext)(const char* pat, ...)
+{
+ dTHX;
+ SV *sv;
+ va_list args;
+ va_start(args, pat);
+ sv = vmess(pat, &args);
+ va_end(args);
+ return sv;
+}
+#endif
+#endif
+
+#ifndef mess
+#if defined(NEED_mess)
+static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+static
+#else
+extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+#endif
+
+#if defined(NEED_mess) || defined(NEED_mess_GLOBAL)
+
+#define Perl_mess DPPP_(my_mess)
+
+SV*
+DPPP_(my_mess)(pTHX_ const char* pat, ...)
+{
+ SV *sv;
+ va_list args;
+ va_start(args, pat);
+ sv = vmess(pat, &args);
+ va_end(args);
+ return sv;
+}
+#ifdef mess_nocontext
+#define mess mess_nocontext
+#else
+#define mess Perl_mess_nocontext
+#endif
+#endif
+#endif
+
+#ifndef mess_sv
+#if defined(NEED_mess_sv)
+static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+static
+#else
+extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+#endif
+
+#if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL)
+
+#ifdef mess_sv
+# undef mess_sv
+#endif
+#define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b)
+#define Perl_mess_sv DPPP_(my_mess_sv)
+
+SV *
+DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume)
+{
+ SV *tmp;
+ SV *ret;
+
+ if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') {
+ if (consume)
+ return basemsg;
+ ret = mess("");
+ SvSetSV_nosteal(ret, basemsg);
+ return ret;
+ }
+
+ if (consume) {
+ sv_catsv(basemsg, mess(""));
+ return basemsg;
+ }
+
+ ret = mess("");
+ tmp = newSVsv(ret);
+ SvSetSV_nosteal(ret, basemsg);
+ sv_catsv(ret, tmp);
+ sv_dec(tmp);
+ return ret;
+}
+#endif
+#endif
+
+#ifndef warn_nocontext
+#define warn_nocontext warn
+#endif
+
+#ifndef croak_nocontext
+#define croak_nocontext croak
+#endif
+
+#ifndef croak_no_modify
+#define croak_no_modify() croak_nocontext("%s", PL_no_modify)
+#define Perl_croak_no_modify() croak_no_modify()
+#endif
+
+#ifndef croak_memory_wrap
+#if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) )
+# define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap)
+#else
+# define croak_memory_wrap() croak_nocontext("panic: memory wrap")
+#endif
+#endif
+
+#ifndef croak_xs_usage
+#if defined(NEED_croak_xs_usage)
+static void DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params);
+static
+#else
+extern void DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params);
+#endif
+
+#if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL)
+
+#define croak_xs_usage DPPP_(my_croak_xs_usage)
+#define Perl_croak_xs_usage DPPP_(my_croak_xs_usage)
+
+
+#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
+#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)
+#endif
+
+void
+DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params)
+{
+ dTHX;
+ const GV *const gv = CvGV(cv);
+
+ PERL_ARGS_ASSERT_CROAK_XS_USAGE;
+
+ if (gv) {
+ const char *const gvname = GvNAME(gv);
+ const HV *const stash = GvSTASH(gv);
+ const char *const hvname = stash ? HvNAME(stash) : NULL;
+
+ if (hvname)
+ croak("Usage: %s::%s(%s)", hvname, gvname, params);
+ else
+ croak("Usage: %s(%s)", gvname, params);
+ } else {
+ /* Pants. I don't think that it should be possible to get here. */
+ croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
+ }
+}
+#endif
+#endif
+
+#ifndef PERL_SIGNALS_UNSAFE_FLAG
+
+#define PERL_SIGNALS_UNSAFE_FLAG 0x0001
+
+#if (PERL_BCDVERSION < 0x5008000)
+# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG
+#else
+# define D_PPP_PERL_SIGNALS_INIT 0
+#endif
+
+#if defined(NEED_PL_signals)
+static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
+#elif defined(NEED_PL_signals_GLOBAL)
+U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
+#else
+extern U32 DPPP_(my_PL_signals);
+#endif
+#define PL_signals DPPP_(my_PL_signals)
+
+#endif
+
+/* Hint: PL_ppaddr
+ * Calling an op via PL_ppaddr requires passing a context argument
+ * for threaded builds. Since the context argument is different for
+ * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
+ * automatically be defined as the correct argument.
+ */
+
+#if (PERL_BCDVERSION <= 0x5005005)
+/* Replace: 1 */
+# define PL_ppaddr ppaddr
+# define PL_no_modify no_modify
+/* Replace: 0 */
+#endif
+
+#if (PERL_BCDVERSION <= 0x5004005)
+/* Replace: 1 */
+# define PL_DBsignal DBsignal
+# define PL_DBsingle DBsingle
+# define PL_DBsub DBsub
+# define PL_DBtrace DBtrace
+# define PL_Sv Sv
+# define PL_bufend bufend
+# define PL_bufptr bufptr
+# define PL_compiling compiling
+# define PL_copline copline
+# define PL_curcop curcop
+# define PL_curstash curstash
+# define PL_debstash debstash
+# define PL_defgv defgv
+# define PL_diehook diehook
+# define PL_dirty dirty
+# define PL_dowarn dowarn
+# define PL_errgv errgv
+# define PL_error_count error_count
+# define PL_expect expect
+# define PL_hexdigit hexdigit
+# define PL_hints hints
+# define PL_in_my in_my
+# define PL_laststatval laststatval
+# define PL_lex_state lex_state
+# define PL_lex_stuff lex_stuff
+# define PL_linestr linestr
+# define PL_na na
+# define PL_perl_destruct_level perl_destruct_level
+# define PL_perldb perldb
+# define PL_rsfp_filters rsfp_filters
+# define PL_rsfp rsfp
+# define PL_stack_base stack_base
+# define PL_stack_sp stack_sp
+# define PL_statcache statcache
+# define PL_stdingv stdingv
+# define PL_sv_arenaroot sv_arenaroot
+# define PL_sv_no sv_no
+# define PL_sv_undef sv_undef
+# define PL_sv_yes sv_yes
+# define PL_tainted tainted
+# define PL_tainting tainting
+# define PL_tokenbuf tokenbuf
+/* Replace: 0 */
+#endif
+
+/* Warning: PL_parser
+ * For perl versions earlier than 5.9.5, this is an always
+ * non-NULL dummy. Also, it cannot be dereferenced. Don't
+ * use it if you can avoid is and unless you absolutely know
+ * what you're doing.
+ * If you always check that PL_parser is non-NULL, you can
+ * define DPPP_PL_parser_NO_DUMMY to avoid the creation of
+ * a dummy parser structure.
+ */
+
+#if (PERL_BCDVERSION >= 0x5009005)
+# ifdef DPPP_PL_parser_NO_DUMMY
+# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
+ (croak("panic: PL_parser == NULL in %s:%d", \
+ __FILE__, __LINE__), (yy_parser *) NULL))->var)
+# else
+# ifdef DPPP_PL_parser_NO_DUMMY_WARNING
+# define D_PPP_parser_dummy_warning(var)
+# else
+# define D_PPP_parser_dummy_warning(var) \
+ warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
+# endif
+# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
+ (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
+#if defined(NEED_PL_parser)
+static yy_parser DPPP_(dummy_PL_parser);
+#elif defined(NEED_PL_parser_GLOBAL)
+yy_parser DPPP_(dummy_PL_parser);
+#else
+extern yy_parser DPPP_(dummy_PL_parser);
#endif
-#ifndef SvREFCNT_inc_simple_NN
-# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv))
-#endif
+# endif
-#ifndef SvREFCNT_inc_void_NN
-# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
-#endif
+/* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */
+/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
+ * Do not use this variable unless you know exactly what you're
+ * doing. It is internal to the perl parser and may change or even
+ * be removed in the future. As of perl 5.9.5, you have to check
+ * for (PL_parser != NULL) for this variable to have any effect.
+ * An always non-NULL PL_parser dummy is provided for earlier
+ * perl versions.
+ * If PL_parser is NULL when you try to access this variable, a
+ * dummy is being accessed instead and a warning is issued unless
+ * you define DPPP_PL_parser_NO_DUMMY_WARNING.
+ * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
+ * this variable will croak with a panic message.
+ */
-#ifndef SvREFCNT_inc_simple_void_NN
-# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
-#endif
+# define PL_expect D_PPP_my_PL_parser_var(expect)
+# define PL_copline D_PPP_my_PL_parser_var(copline)
+# define PL_rsfp D_PPP_my_PL_parser_var(rsfp)
+# define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters)
+# define PL_linestr D_PPP_my_PL_parser_var(linestr)
+# define PL_bufptr D_PPP_my_PL_parser_var(bufptr)
+# define PL_bufend D_PPP_my_PL_parser_var(bufend)
+# define PL_lex_state D_PPP_my_PL_parser_var(lex_state)
+# define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff)
+# define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf)
+# define PL_in_my D_PPP_my_PL_parser_var(in_my)
+# define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash)
+# define PL_error_count D_PPP_my_PL_parser_var(error_count)
-#ifndef newSV_type
-#if defined(NEED_newSV_type)
-static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
-static
#else
-extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
-#endif
-#ifdef newSV_type
-# undef newSV_type
-#endif
-#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a)
-#define Perl_newSV_type DPPP_(my_newSV_type)
+/* ensure that PL_parser != NULL and cannot be dereferenced */
+# define PL_parser ((void *) 1)
-#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)
+#endif
+#ifndef mPUSHs
+# define mPUSHs(s) PUSHs(sv_2mortal(s))
+#endif
-SV*
-DPPP_(my_newSV_type)(pTHX_ svtype const t)
-{
- SV* const sv = newSV(0);
- sv_upgrade(sv, t);
- return sv;
-}
+#ifndef PUSHmortal
+# define PUSHmortal PUSHs(sv_newmortal())
+#endif
+#ifndef mPUSHp
+# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l))
#endif
+#ifndef mPUSHn
+# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n))
#endif
-#if (PERL_BCDVERSION < 0x5006000)
-# define D_PPP_CONSTPV_ARG(x) ((char *) (x))
-#else
-# define D_PPP_CONSTPV_ARG(x) (x)
+#ifndef mPUSHi
+# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i))
#endif
-#ifndef newSVpvn
-# define newSVpvn(data,len) ((data) \
- ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
- : newSV(0))
+
+#ifndef mPUSHu
+# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u))
#endif
-#ifndef newSVpvn_utf8
-# define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
+#ifndef mXPUSHs
+# define mXPUSHs(s) XPUSHs(sv_2mortal(s))
#endif
-#ifndef SVf_UTF8
-# define SVf_UTF8 0
+
+#ifndef XPUSHmortal
+# define XPUSHmortal XPUSHs(sv_newmortal())
#endif
-#ifndef newSVpvn_flags
+#ifndef mXPUSHp
+# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
+#endif
-#if defined(NEED_newSVpvn_flags)
-static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
-static
-#else
-extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
+#ifndef mXPUSHn
+# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
#endif
-#ifdef newSVpvn_flags
-# undef newSVpvn_flags
+#ifndef mXPUSHi
+# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
#endif
-#define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
-#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
-#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
+#ifndef mXPUSHu
+# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
+#endif
-SV *
-DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
-{
- SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len);
- SvFLAGS(sv) |= (flags & SVf_UTF8);
- return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
-}
+/* Replace: 1 */
+#ifndef call_sv
+# define call_sv perl_call_sv
+#endif
+#ifndef call_pv
+# define call_pv perl_call_pv
#endif
+#ifndef call_argv
+# define call_argv perl_call_argv
#endif
-/* Backwards compatibility stuff... :-( */
-#if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen)
-# define NEED_sv_2pv_flags
+#ifndef call_method
+# define call_method perl_call_method
#endif
-#if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL)
-# define NEED_sv_2pv_flags_GLOBAL
+#ifndef eval_sv
+# define eval_sv perl_eval_sv
#endif
-/* Hint: sv_2pv_nolen
- * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
- */
-#ifndef sv_2pv_nolen
-# define sv_2pv_nolen(sv) SvPV_nolen(sv)
+/* Replace: 0 */
+#ifndef PERL_LOADMOD_DENY
+# define PERL_LOADMOD_DENY 0x1
#endif
-#ifdef SvPVbyte
+#ifndef PERL_LOADMOD_NOIMPORT
+# define PERL_LOADMOD_NOIMPORT 0x2
+#endif
-/* Hint: SvPVbyte
- * Does not work in perl-5.6.1, ppport.h implements a version
- * borrowed from perl-5.7.3.
- */
+#ifndef PERL_LOADMOD_IMPORT_OPS
+# define PERL_LOADMOD_IMPORT_OPS 0x4
+#endif
-#if (PERL_BCDVERSION < 0x5007000)
+#ifndef G_METHOD
+# define G_METHOD 64
+# ifdef call_sv
+# undef call_sv
+# endif
+# if (PERL_BCDVERSION < 0x5006000)
+# define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
+ (flags) & ~G_METHOD) : perl_call_sv(sv, flags))
+# else
+# define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
+ (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
+# endif
+#endif
+
+/* Replace perl_eval_pv with eval_pv */
-#if defined(NEED_sv_2pvbyte)
-static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
+#ifndef eval_pv
+#if defined(NEED_eval_pv)
+static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
static
#else
-extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
+extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
#endif
-#ifdef sv_2pvbyte
-# undef sv_2pvbyte
+#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
+
+#ifdef eval_pv
+# undef eval_pv
#endif
-#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
-#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)
+#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
+#define Perl_eval_pv DPPP_(my_eval_pv)
-#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
-char *
-DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
+SV*
+DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
{
- sv_utf8_downgrade(sv,0);
- return SvPV(sv,*lp);
-}
+ dSP;
+ SV* errsv;
+ SV* sv = newSVpv(p, 0);
-#endif
+ PUSHMARK(sp);
+ eval_sv(sv, G_SCALAR);
+ SvREFCNT_dec(sv);
-/* Hint: sv_2pvbyte
- * Use the SvPVbyte() macro instead of sv_2pvbyte().
- */
+ SPAGAIN;
+ sv = POPs;
+ PUTBACK;
-#undef SvPVbyte
+ if (croak_on_error) {
+ errsv = ERRSV;
+ if (SvTRUE(errsv))
+ croak_sv(errsv);
+ }
-#define SvPVbyte(sv, lp) \
- ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
- ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
+ return sv;
+}
#endif
+#endif
+#ifndef vload_module
+#if defined(NEED_vload_module)
+static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
+static
#else
+extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
+#endif
-# define SvPVbyte SvPV
-# define sv_2pvbyte sv_2pv
+#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
+#ifdef vload_module
+# undef vload_module
#endif
-#ifndef sv_2pvbyte_nolen
-# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv)
-#endif
+#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
+#define Perl_vload_module DPPP_(my_vload_module)
-/* Hint: sv_pvn
- * Always use the SvPV() macro instead of sv_pvn().
- */
-/* Hint: sv_pvn_force
- * Always use the SvPV_force() macro instead of sv_pvn_force().
- */
+void
+DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
+{
+ dTHR;
+ dVAR;
+ OP *veop, *imop;
-/* If these are undefined, they're not handled by the core anyway */
-#ifndef SV_IMMEDIATE_UNREF
-# define SV_IMMEDIATE_UNREF 0
+ OP * const modname = newSVOP(OP_CONST, 0, name);
+ /* 5.005 has a somewhat hacky force_normal that doesn't croak on
+ SvREADONLY() if PL_compling is true. Current perls take care in
+ ck_require() to correctly turn off SvREADONLY before calling
+ force_normal_flags(). This seems a better fix than fudging PL_compling
+ */
+ SvREADONLY_off(((SVOP*)modname)->op_sv);
+ modname->op_private |= OPpCONST_BARE;
+ if (ver) {
+ veop = newSVOP(OP_CONST, 0, ver);
+ }
+ else
+ veop = NULL;
+ if (flags & PERL_LOADMOD_NOIMPORT) {
+ imop = sawparens(newNULLLIST());
+ }
+ else if (flags & PERL_LOADMOD_IMPORT_OPS) {
+ imop = va_arg(*args, OP*);
+ }
+ else {
+ SV *sv;
+ imop = NULL;
+ sv = va_arg(*args, SV*);
+ while (sv) {
+ imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
+ sv = va_arg(*args, SV*);
+ }
+ }
+ {
+ const line_t ocopline = PL_copline;
+ COP * const ocurcop = PL_curcop;
+ const int oexpect = PL_expect;
+
+#if (PERL_BCDVERSION >= 0x5004000)
+ utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
+ veop, modname, imop);
+#elif (PERL_BCDVERSION > 0x5003000)
+ utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
+ veop, modname, imop);
+#else
+ utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
+ modname, imop);
#endif
+ PL_expect = oexpect;
+ PL_copline = ocopline;
+ PL_curcop = ocurcop;
+ }
+}
-#ifndef SV_GMAGIC
-# define SV_GMAGIC 0
#endif
-
-#ifndef SV_COW_DROP_PV
-# define SV_COW_DROP_PV 0
#endif
-#ifndef SV_UTF8_NO_ENCODING
-# define SV_UTF8_NO_ENCODING 0
+#ifndef load_module
+#if defined(NEED_load_module)
+static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
+static
+#else
+extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
#endif
-#ifndef SV_NOSTEAL
-# define SV_NOSTEAL 0
-#endif
+#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
-#ifndef SV_CONST_RETURN
-# define SV_CONST_RETURN 0
+#ifdef load_module
+# undef load_module
#endif
+#define load_module DPPP_(my_load_module)
+#define Perl_load_module DPPP_(my_load_module)
-#ifndef SV_MUTABLE_RETURN
-# define SV_MUTABLE_RETURN 0
-#endif
-#ifndef SV_SMAGIC
-# define SV_SMAGIC 0
-#endif
+void
+DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
+{
+ va_list args;
+ va_start(args, ver);
+ vload_module(flags, name, ver, &args);
+ va_end(args);
+}
-#ifndef SV_HAS_TRAILING_NUL
-# define SV_HAS_TRAILING_NUL 0
+#endif
+#endif
+#ifndef newRV_inc
+# define newRV_inc(sv) newRV(sv) /* Replace */
#endif
-#ifndef SV_COW_SHARED_HASH_KEYS
-# define SV_COW_SHARED_HASH_KEYS 0
+#ifndef newRV_noinc
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define newRV_noinc(sv) ({ SV *_sv = (SV *)newRV((sv)); SvREFCNT_dec((sv)); _sv; })
+#else
+# define newRV_noinc(sv) ((PL_Sv = (SV *)newRV((sv))), SvREFCNT_dec((sv)), PL_Sv)
+#endif
#endif
-#if (PERL_BCDVERSION < 0x5007002)
+/* Hint: newCONSTSUB
+ * Returns a CV* as of perl-5.7.1. This return value is not supported
+ * by Devel::PPPort.
+ */
-#if defined(NEED_sv_2pv_flags)
-static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
+/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
+#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
+#if defined(NEED_newCONSTSUB)
+static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
static
#else
-extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
+extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
#endif
-#ifdef sv_2pv_flags
-# undef sv_2pv_flags
+#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
+
+#ifdef newCONSTSUB
+# undef newCONSTSUB
#endif
-#define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
-#define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
+#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
+#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
-#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
-char *
-DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
+/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
+/* (There's no PL_parser in perl < 5.005, so this is completely safe) */
+#define D_PPP_PL_copline PL_copline
+
+void
+DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
{
- STRLEN n_a = (STRLEN) flags;
- return sv_2pv(sv, lp ? lp : &n_a);
-}
+ U32 oldhints = PL_hints;
+ HV *old_cop_stash = PL_curcop->cop_stash;
+ HV *old_curstash = PL_curstash;
+ line_t oldline = PL_curcop->cop_line;
+ PL_curcop->cop_line = D_PPP_PL_copline;
-#endif
+ PL_hints &= ~HINT_BLOCK_SCOPE;
+ if (stash)
+ PL_curstash = PL_curcop->cop_stash = stash;
-#if defined(NEED_sv_pvn_force_flags)
-static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
-static
-#else
-extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
-#endif
+ newSUB(
-#ifdef sv_pvn_force_flags
-# undef sv_pvn_force_flags
+#if (PERL_BCDVERSION < 0x5003022)
+ start_subparse(),
+#elif (PERL_BCDVERSION == 0x5003022)
+ start_subparse(0),
+#else /* 5.003_23 onwards */
+ start_subparse(FALSE, 0),
#endif
-#define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
-#define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
-#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
+ newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
+ newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
+ newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
+ );
-char *
-DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
-{
- STRLEN n_a = (STRLEN) flags;
- return sv_pvn_force(sv, lp ? lp : &n_a);
+ PL_hints = oldhints;
+ PL_curcop->cop_stash = old_cop_stash;
+ PL_curstash = old_curstash;
+ PL_curcop->cop_line = oldline;
}
-
#endif
-
#endif
-#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
-# define DPPP_SVPV_NOLEN_LP_ARG &PL_na
-#else
-# define DPPP_SVPV_NOLEN_LP_ARG 0
-#endif
-#ifndef SvPV_const
-# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
-#endif
+/*
+ * Boilerplate macros for initializing and accessing interpreter-local
+ * data from C. All statics in extensions should be reworked to use
+ * this, if you want to make the extension thread-safe. See ext/re/re.xs
+ * for an example of the use of these macros.
+ *
+ * Code that uses these macros is responsible for the following:
+ * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
+ * 2. Declare a typedef named my_cxt_t that is a structure that contains
+ * all the data that needs to be interpreter-local.
+ * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
+ * 4. Use the MY_CXT_INIT macro such that it is called exactly once
+ * (typically put in the BOOT: section).
+ * 5. Use the members of the my_cxt_t structure everywhere as
+ * MY_CXT.member.
+ * 6. Use the dMY_CXT macro (a declaration) in all the functions that
+ * access MY_CXT.
+ */
-#ifndef SvPV_mutable
-# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
-#endif
-#ifndef SvPV_flags
-# define SvPV_flags(sv, lp, flags) \
- ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
-#endif
-#ifndef SvPV_flags_const
-# define SvPV_flags_const(sv, lp, flags) \
- ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
- (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
-#endif
-#ifndef SvPV_flags_const_nolen
-# define SvPV_flags_const_nolen(sv, flags) \
- ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? SvPVX_const(sv) : \
- (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
-#endif
-#ifndef SvPV_flags_mutable
-# define SvPV_flags_mutable(sv, lp, flags) \
- ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
- sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
-#endif
-#ifndef SvPV_force
-# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
-#endif
+#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
+ defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT)
-#ifndef SvPV_force_nolen
-# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
-#endif
+#ifndef START_MY_CXT
-#ifndef SvPV_force_mutable
-# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
-#endif
+/* This must appear in all extensions that define a my_cxt_t structure,
+ * right after the definition (i.e. at file scope). The non-threads
+ * case below uses it to declare the data as static. */
+#define START_MY_CXT
-#ifndef SvPV_force_nomg
-# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
-#endif
+#if (PERL_BCDVERSION < 0x5004068)
+/* Fetches the SV that keeps the per-interpreter data. */
+#define dMY_CXT_SV \
+ SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
+#else /* >= perl5.004_68 */
+#define dMY_CXT_SV \
+ SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \
+ sizeof(MY_CXT_KEY)-1, TRUE)
+#endif /* < perl5.004_68 */
-#ifndef SvPV_force_nomg_nolen
-# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
-#endif
-#ifndef SvPV_force_flags
-# define SvPV_force_flags(sv, lp, flags) \
- ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
- ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
-#endif
-#ifndef SvPV_force_flags_nolen
-# define SvPV_force_flags_nolen(sv, flags) \
- ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
- ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
-#endif
-#ifndef SvPV_force_flags_mutable
-# define SvPV_force_flags_mutable(sv, lp, flags) \
- ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
- ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
- : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
-#endif
-#ifndef SvPV_nolen
-# define SvPV_nolen(sv) \
- ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
-#endif
-#ifndef SvPV_nolen_const
-# define SvPV_nolen_const(sv) \
- ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
-#endif
-#ifndef SvPV_nomg
-# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
-#endif
+/* This declaration should be used within all functions that use the
+ * interpreter-local data. */
+#define dMY_CXT \
+ dMY_CXT_SV; \
+ my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
-#ifndef SvPV_nomg_const
-# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
-#endif
+/* Creates and zeroes the per-interpreter data.
+ * (We allocate my_cxtp in a Perl SV so that it will be released when
+ * the interpreter goes away.) */
+#define MY_CXT_INIT \
+ dMY_CXT_SV; \
+ /* newSV() allocates one more than needed */ \
+ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
+ Zero(my_cxtp, 1, my_cxt_t); \
+ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
-#ifndef SvPV_nomg_const_nolen
-# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
-#endif
+/* This macro must be used to access members of the my_cxt_t structure.
+ * e.g. MYCXT.some_data */
+#define MY_CXT (*my_cxtp)
-#ifndef SvPV_nomg_nolen
-# define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
- ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, 0))
-#endif
-#ifndef SvPV_renew
-# define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \
- SvPV_set((sv), (char *) saferealloc( \
- (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
- } STMT_END
-#endif
-#ifndef SvMAGIC_set
-# define SvMAGIC_set(sv, val) \
- STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
- (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
-#endif
+/* Judicious use of these macros can reduce the number of times dMY_CXT
+ * is used. Use is similar to pTHX, aTHX etc. */
+#define pMY_CXT my_cxt_t *my_cxtp
+#define pMY_CXT_ pMY_CXT,
+#define _pMY_CXT ,pMY_CXT
+#define aMY_CXT my_cxtp
+#define aMY_CXT_ aMY_CXT,
+#define _aMY_CXT ,aMY_CXT
-#if (PERL_BCDVERSION < 0x5009003)
-#ifndef SvPVX_const
-# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv)))
-#endif
+#endif /* START_MY_CXT */
-#ifndef SvPVX_mutable
-# define SvPVX_mutable(sv) (0 + SvPVX(sv))
-#endif
-#ifndef SvRV_set
-# define SvRV_set(sv, val) \
- STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
- (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
+#ifndef MY_CXT_CLONE
+/* Clones the per-interpreter data. */
+#define MY_CXT_CLONE \
+ dMY_CXT_SV; \
+ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
+ Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
+ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
#endif
-#else
-#ifndef SvPVX_const
-# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv))
-#endif
+#else /* single interpreter */
-#ifndef SvPVX_mutable
-# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv)
-#endif
-#ifndef SvRV_set
-# define SvRV_set(sv, val) \
- STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
- ((sv)->sv_u.svu_rv = (val)); } STMT_END
-#endif
+#ifndef START_MY_CXT
-#endif
-#ifndef SvSTASH_set
-# define SvSTASH_set(sv, val) \
- STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
- (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
-#endif
+#define START_MY_CXT static my_cxt_t my_cxt;
+#define dMY_CXT_SV dNOOP
+#define dMY_CXT dNOOP
+#define MY_CXT_INIT NOOP
+#define MY_CXT my_cxt
-#if (PERL_BCDVERSION < 0x5004000)
-#ifndef SvUV_set
-# define SvUV_set(sv, val) \
- STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
- (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
-#endif
+#define pMY_CXT void
+#define pMY_CXT_
+#define _pMY_CXT
+#define aMY_CXT
+#define aMY_CXT_
+#define _aMY_CXT
-#else
-#ifndef SvUV_set
-# define SvUV_set(sv, val) \
- STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
- (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
-#endif
+#endif /* START_MY_CXT */
+#ifndef MY_CXT_CLONE
+#define MY_CXT_CLONE NOOP
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
-#if defined(NEED_vnewSVpvf)
-static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
-static
-#else
-extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
#endif
-#ifdef vnewSVpvf
-# undef vnewSVpvf
+#ifndef SvREFCNT_inc
+# ifdef PERL_USE_GCC_BRACE_GROUPS
+# define SvREFCNT_inc(sv) \
+ ({ \
+ SV * const _sv = (SV*)(sv); \
+ if (_sv) \
+ (SvREFCNT(_sv))++; \
+ _sv; \
+ })
+# else
+# define SvREFCNT_inc(sv) \
+ ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
+# endif
#endif
-#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
-#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
-#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
+#ifndef SvREFCNT_inc_simple
+# ifdef PERL_USE_GCC_BRACE_GROUPS
+# define SvREFCNT_inc_simple(sv) \
+ ({ \
+ if (sv) \
+ (SvREFCNT(sv))++; \
+ (SV *)(sv); \
+ })
+# else
+# define SvREFCNT_inc_simple(sv) \
+ ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
+# endif
+#endif
-SV *
-DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
-{
- register SV *sv = newSV(0);
- sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
- return sv;
-}
+#ifndef SvREFCNT_inc_NN
+# ifdef PERL_USE_GCC_BRACE_GROUPS
+# define SvREFCNT_inc_NN(sv) \
+ ({ \
+ SV * const _sv = (SV*)(sv); \
+ SvREFCNT(_sv)++; \
+ _sv; \
+ })
+# else
+# define SvREFCNT_inc_NN(sv) \
+ (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
+# endif
+#endif
+#ifndef SvREFCNT_inc_void
+# ifdef PERL_USE_GCC_BRACE_GROUPS
+# define SvREFCNT_inc_void(sv) \
+ ({ \
+ SV * const _sv = (SV*)(sv); \
+ if (_sv) \
+ (void)(SvREFCNT(_sv)++); \
+ })
+# else
+# define SvREFCNT_inc_void(sv) \
+ (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
+# endif
#endif
+#ifndef SvREFCNT_inc_simple_void
+# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
-# define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
+#ifndef SvREFCNT_inc_simple_NN
+# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv))
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
-# define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
+#ifndef SvREFCNT_inc_void_NN
+# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
-#if defined(NEED_sv_catpvf_mg)
-static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
-static
-#else
-extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
+#ifndef SvREFCNT_inc_simple_void_NN
+# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
#endif
-#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
-
-#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
-
-void
-DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
-{
- va_list args;
- va_start(args, pat);
- sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
- SvSETMAGIC(sv);
- va_end(args);
-}
-
+#ifndef newSV_type
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define newSV_type(t) ({ SV *_sv = newSV(0); sv_upgrade(_sv, (t)); _sv; })
+#else
+# define newSV_type(t) ((PL_Sv = newSV(0)), sv_upgrade(PL_Sv, (t)), PL_Sv)
#endif
#endif
-#ifdef PERL_IMPLICIT_CONTEXT
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
-#if defined(NEED_sv_catpvf_mg_nocontext)
-static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
-static
+#if (PERL_BCDVERSION < 0x5006000)
+# define D_PPP_CONSTPV_ARG(x) ((char *) (x))
#else
-extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
+# define D_PPP_CONSTPV_ARG(x) (x)
#endif
-
-#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
-#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
-
-#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
-
-void
-DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
-{
- dTHX;
- va_list args;
- va_start(args, pat);
- sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
- SvSETMAGIC(sv);
- va_end(args);
-}
-
+#ifndef newSVpvn
+# define newSVpvn(data,len) ((data) \
+ ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
+ : newSV(0))
#endif
+#ifndef newSVpvn_utf8
+# define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
#endif
+#ifndef SVf_UTF8
+# define SVf_UTF8 0
#endif
-/* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
-#ifndef sv_catpvf_mg
-# ifdef PERL_IMPLICIT_CONTEXT
-# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext
-# else
-# define sv_catpvf_mg Perl_sv_catpvf_mg
-# endif
+#ifndef newSVpvn_flags
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define newSVpvn_flags(s, len, flags) ({ SV *_sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len)); SvFLAGS(_sv) |= ((flags) & SVf_UTF8); ((flags) & SVs_TEMP) ? sv_2mortal(_sv) : _sv; })
+#else
+# define newSVpvn_flags(s, len, flags) ((PL_Sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len))), SvFLAGS(PL_Sv) |= ((flags) & SVf_UTF8), (((flags) & SVs_TEMP) ? sv_2mortal(PL_Sv) : PL_Sv))
+#endif
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
-# define sv_vcatpvf_mg(sv, pat, args) \
- STMT_START { \
- sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
- SvSETMAGIC(sv); \
- } STMT_END
+#if ( (PERL_BCDVERSION >= 0x5007003) && (PERL_BCDVERSION < 0x5008007) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009002) )
+#undef sv_setsv_flags
+#define SV_NOSTEAL 16
+#define sv_setsv_flags(dstr, sstr, flags) \
+ STMT_START { \
+ if (((flags) & SV_NOSTEAL) && (SvFLAGS((sstr)) & SVs_TEMP)) { \
+ SvTEMP_off((sstr)); \
+ Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL); \
+ SvTEMP_on((sstr)); \
+ } else { \
+ Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL); \
+ } \
+ } STMT_END
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
-#if defined(NEED_sv_setpvf_mg)
-static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
-static
+#if !defined(newSVsv_nomg) && defined(SV_NOSTEAL)
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define newSVsv_nomg(sv) ({ SV *_sv = newSV(0); sv_setsv_flags(_sv, (sv), SV_NOSTEAL); _sv; })
#else
-extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
+# define newSVsv_nomg(sv) ((PL_Sv = newSV(0)), sv_setsv_flags(PL_Sv, (sv), SV_NOSTEAL), PL_Sv)
#endif
-
-#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
-
-#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
-
-void
-DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
-{
- va_list args;
- va_start(args, pat);
- sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
- SvSETMAGIC(sv);
- va_end(args);
-}
-
#endif
+#ifndef SvMAGIC_set
+# define SvMAGIC_set(sv, val) \
+ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
+ (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
#endif
-#ifdef PERL_IMPLICIT_CONTEXT
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
-#if defined(NEED_sv_setpvf_mg_nocontext)
-static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
-static
-#else
-extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
+#if (PERL_BCDVERSION < 0x5009003)
+#ifndef SvPVX_const
+# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv)))
#endif
-#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
-#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
+#ifndef SvPVX_mutable
+# define SvPVX_mutable(sv) (0 + SvPVX(sv))
+#endif
+#ifndef SvRV_set
+# define SvRV_set(sv, val) \
+ STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
+ (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
+#endif
-#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
+#else
+#ifndef SvPVX_const
+# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv))
+#endif
-void
-DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
-{
- dTHX;
- va_list args;
- va_start(args, pat);
- sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
- SvSETMAGIC(sv);
- va_end(args);
-}
+#ifndef SvPVX_mutable
+# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv)
+#endif
+#ifndef SvRV_set
+# define SvRV_set(sv, val) \
+ STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
+ ((sv)->sv_u.svu_rv = (val)); } STMT_END
+#endif
#endif
+#ifndef SvSTASH_set
+# define SvSTASH_set(sv, val) \
+ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
+ (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
#endif
+
+#if (PERL_BCDVERSION < 0x5004000)
+#ifndef SvUV_set
+# define SvUV_set(sv, val) \
+ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
+ (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
#endif
-/* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
-#ifndef sv_setpvf_mg
-# ifdef PERL_IMPLICIT_CONTEXT
-# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext
-# else
-# define sv_setpvf_mg Perl_sv_setpvf_mg
-# endif
+#else
+#ifndef SvUV_set
+# define SvUV_set(sv, val) \
+ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
+ (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
-# define sv_vsetpvf_mg(sv, pat, args) \
- STMT_START { \
- sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
- SvSETMAGIC(sv); \
- } STMT_END
#endif
/* Hint: newSVpvn_share
extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
#endif
+#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
+
#ifdef newSVpvn_share
# undef newSVpvn_share
#endif
#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
-#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
SV *
DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
# define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)
#endif
-#ifndef gv_fetchpvn_flags
-#if defined(NEED_gv_fetchpvn_flags)
-static GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types);
-static
-#else
-extern GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types);
+#if (PERL_BCDVERSION >= 0x5009002) && (PERL_BCDVERSION <= 0x5009003) /* 5.9.2 and 5.9.3 ignore the length param */
+#undef gv_fetchpvn_flags
#endif
-
-#ifdef gv_fetchpvn_flags
-# undef gv_fetchpvn_flags
+#ifndef GV_NOADD_MASK
+# define GV_NOADD_MASK 0xE0
#endif
-#define gv_fetchpvn_flags(a,b,c,d) DPPP_(my_gv_fetchpvn_flags)(aTHX_ a,b,c,d)
-#define Perl_gv_fetchpvn_flags DPPP_(my_gv_fetchpvn_flags)
-#if defined(NEED_gv_fetchpvn_flags) || defined(NEED_gv_fetchpvn_flags_GLOBAL)
-
-GV*
-DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types) {
- char *namepv = savepvn(name, len);
- GV* stash = gv_fetchpv(namepv, TRUE, SVt_PVHV);
- Safefree(namepv);
- return stash;
-}
-
-#endif
+#ifndef gv_fetchpvn_flags
+# define gv_fetchpvn_flags(name, len, flags, sv_type) gv_fetchpv(SvPVX(sv_2mortal(newSVpvn((name), (len)))), ((flags) & GV_NOADD_MASK) ? FALSE : TRUE, (I32)(sv_type))
#endif
#ifndef GvSVn
# define GvSVn(gv) GvSV(gv)
#ifndef gv_init_pvn
# define gv_init_pvn(gv, stash, ptr, len, flags) gv_init(gv, stash, ptr, len, flags & GV_ADDMULTI ? TRUE : FALSE)
#endif
-#ifndef WARN_ALL
-# define WARN_ALL 0
-#endif
-
-#ifndef WARN_CLOSURE
-# define WARN_CLOSURE 1
-#endif
-
-#ifndef WARN_DEPRECATED
-# define WARN_DEPRECATED 2
-#endif
-
-#ifndef WARN_EXITING
-# define WARN_EXITING 3
-#endif
-
-#ifndef WARN_GLOB
-# define WARN_GLOB 4
-#endif
-
-#ifndef WARN_IO
-# define WARN_IO 5
-#endif
-
-#ifndef WARN_CLOSED
-# define WARN_CLOSED 6
-#endif
-
-#ifndef WARN_EXEC
-# define WARN_EXEC 7
-#endif
-#ifndef WARN_LAYER
-# define WARN_LAYER 8
-#endif
-
-#ifndef WARN_NEWLINE
-# define WARN_NEWLINE 9
-#endif
-
-#ifndef WARN_PIPE
-# define WARN_PIPE 10
-#endif
-
-#ifndef WARN_UNOPENED
-# define WARN_UNOPENED 11
-#endif
-
-#ifndef WARN_MISC
-# define WARN_MISC 12
+/* concatenating with "" ensures that only literal strings are accepted as argument
+ * note that STR_WITH_LEN() can't be used as argument to macros or functions that
+ * under some configurations might be macros
+ */
+#ifndef STR_WITH_LEN
+# define STR_WITH_LEN(s) (s ""), (sizeof(s)-1)
#endif
-
-#ifndef WARN_NUMERIC
-# define WARN_NUMERIC 13
+#ifndef newSVpvs
+# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1)
#endif
-#ifndef WARN_ONCE
-# define WARN_ONCE 14
+#ifndef newSVpvs_flags
+# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags)
#endif
-#ifndef WARN_OVERFLOW
-# define WARN_OVERFLOW 15
+#ifndef newSVpvs_share
+# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0)
#endif
-#ifndef WARN_PACK
-# define WARN_PACK 16
+#ifndef sv_catpvs
+# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1)
#endif
-#ifndef WARN_PORTABLE
-# define WARN_PORTABLE 17
+#ifndef sv_setpvs
+# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1)
#endif
-#ifndef WARN_RECURSION
-# define WARN_RECURSION 18
+#ifndef hv_fetchs
+# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval)
#endif
-#ifndef WARN_REDEFINE
-# define WARN_REDEFINE 19
+#ifndef hv_stores
+# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0)
#endif
-
-#ifndef WARN_REGEXP
-# define WARN_REGEXP 20
+#ifndef gv_fetchpvs
+# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)
#endif
-#ifndef WARN_SEVERE
-# define WARN_SEVERE 21
+#ifndef gv_stashpvs
+# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags)
#endif
-
-#ifndef WARN_DEBUGGING
-# define WARN_DEBUGGING 22
+#ifndef get_cvs
+# define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags)
#endif
-
-#ifndef WARN_INPLACE
-# define WARN_INPLACE 23
+#ifndef SvGETMAGIC
+# define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
#endif
-#ifndef WARN_INTERNAL
-# define WARN_INTERNAL 24
+/* That's the best we can do... */
+#ifndef sv_catpvn_nomg
+# define sv_catpvn_nomg sv_catpvn
#endif
-#ifndef WARN_MALLOC
-# define WARN_MALLOC 25
+#ifndef sv_catsv_nomg
+# define sv_catsv_nomg sv_catsv
#endif
-#ifndef WARN_SIGNAL
-# define WARN_SIGNAL 26
+#ifndef sv_setsv_nomg
+# define sv_setsv_nomg sv_setsv
#endif
-#ifndef WARN_SUBSTR
-# define WARN_SUBSTR 27
+#ifndef sv_pvn_nomg
+# define sv_pvn_nomg sv_pvn
#endif
-#ifndef WARN_SYNTAX
-# define WARN_SYNTAX 28
+#ifndef SvIV_nomg
+# define SvIV_nomg SvIV
#endif
-#ifndef WARN_AMBIGUOUS
-# define WARN_AMBIGUOUS 29
+#ifndef SvUV_nomg
+# define SvUV_nomg SvUV
#endif
-#ifndef WARN_BAREWORD
-# define WARN_BAREWORD 30
+#ifndef sv_catpv_mg
+# define sv_catpv_mg(sv, ptr) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_catpv(TeMpSv,ptr); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_DIGIT
-# define WARN_DIGIT 31
+#ifndef sv_catpvn_mg
+# define sv_catpvn_mg(sv, ptr, len) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_catpvn(TeMpSv,ptr,len); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_PARENTHESIS
-# define WARN_PARENTHESIS 32
+#ifndef sv_catsv_mg
+# define sv_catsv_mg(dsv, ssv) \
+ STMT_START { \
+ SV *TeMpSv = dsv; \
+ sv_catsv(TeMpSv,ssv); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_PRECEDENCE
-# define WARN_PRECEDENCE 33
+#ifndef sv_setiv_mg
+# define sv_setiv_mg(sv, i) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_setiv(TeMpSv,i); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_PRINTF
-# define WARN_PRINTF 34
+#ifndef sv_setnv_mg
+# define sv_setnv_mg(sv, num) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_setnv(TeMpSv,num); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_PROTOTYPE
-# define WARN_PROTOTYPE 35
+#ifndef sv_setpv_mg
+# define sv_setpv_mg(sv, ptr) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_setpv(TeMpSv,ptr); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_QW
-# define WARN_QW 36
+#ifndef sv_setpvn_mg
+# define sv_setpvn_mg(sv, ptr, len) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_setpvn(TeMpSv,ptr,len); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_RESERVED
-# define WARN_RESERVED 37
+#ifndef sv_setsv_mg
+# define sv_setsv_mg(dsv, ssv) \
+ STMT_START { \
+ SV *TeMpSv = dsv; \
+ sv_setsv(TeMpSv,ssv); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_SEMICOLON
-# define WARN_SEMICOLON 38
+#ifndef sv_setuv_mg
+# define sv_setuv_mg(sv, i) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_setuv(TeMpSv,i); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-#ifndef WARN_TAINT
-# define WARN_TAINT 39
+#ifndef sv_usepvn_mg
+# define sv_usepvn_mg(sv, ptr, len) \
+ STMT_START { \
+ SV *TeMpSv = sv; \
+ sv_usepvn(TeMpSv,ptr,len); \
+ SvSETMAGIC(TeMpSv); \
+ } STMT_END
#endif
-
-#ifndef WARN_THREADS
-# define WARN_THREADS 40
+#ifndef SvVSTRING_mg
+# define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
#endif
-#ifndef WARN_UNINITIALIZED
-# define WARN_UNINITIALIZED 41
-#endif
+/* Hint: sv_magic_portable
+ * This is a compatibility function that is only available with
+ * Devel::PPPort. It is NOT in the perl core.
+ * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
+ * it is being passed a name pointer with namlen == 0. In that
+ * case, perl 5.8.0 and later store the pointer, not a copy of it.
+ * The compatibility can be provided back to perl 5.004. With
+ * earlier versions, the code will not compile.
+ */
-#ifndef WARN_UNPACK
-# define WARN_UNPACK 42
-#endif
+#if (PERL_BCDVERSION < 0x5004000)
-#ifndef WARN_UNTIE
-# define WARN_UNTIE 43
-#endif
+ /* code that uses sv_magic_portable will not compile */
-#ifndef WARN_UTF8
-# define WARN_UTF8 44
-#endif
+#elif (PERL_BCDVERSION < 0x5008000)
-#ifndef WARN_VOID
-# define WARN_VOID 45
-#endif
+# define sv_magic_portable(sv, obj, how, name, namlen) \
+ STMT_START { \
+ SV *SvMp_sv = (sv); \
+ char *SvMp_name = (char *) (name); \
+ I32 SvMp_namlen = (namlen); \
+ if (SvMp_name && SvMp_namlen == 0) \
+ { \
+ MAGIC *mg; \
+ sv_magic(SvMp_sv, obj, how, 0, 0); \
+ mg = SvMAGIC(SvMp_sv); \
+ mg->mg_len = -42; /* XXX: this is the tricky part */ \
+ mg->mg_ptr = SvMp_name; \
+ } \
+ else \
+ { \
+ sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
+ } \
+ } STMT_END
-#ifndef WARN_ASSERTIONS
-# define WARN_ASSERTIONS 46
-#endif
-#ifndef packWARN
-# define packWARN(a) (a)
-#endif
+#else
+
+# define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e)
-#ifndef ckWARN
-# ifdef G_WARN_ON
-# define ckWARN(a) (PL_dowarn & G_WARN_ON)
-# else
-# define ckWARN(a) PL_dowarn
-# endif
#endif
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
-#if defined(NEED_warner)
-static void DPPP_(my_warner)(U32 err, const char *pat, ...);
+#if !defined(mg_findext)
+#if defined(NEED_mg_findext)
+static MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl);
static
#else
-extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
+extern MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl);
#endif
-#define Perl_warner DPPP_(my_warner)
-
-#if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
+#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL)
-void
-DPPP_(my_warner)(U32 err, const char *pat, ...)
-{
- SV *sv;
- va_list args;
+#define mg_findext DPPP_(my_mg_findext)
+#define Perl_mg_findext DPPP_(my_mg_findext)
- PERL_UNUSED_ARG(err);
- va_start(args, pat);
- sv = vnewSVpvf(pat, &args);
- va_end(args);
- sv_2mortal(sv);
- warn("%s", SvPV_nolen(sv));
-}
+MAGIC *
+DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl) {
+ if (sv) {
+ MAGIC *mg;
-#define warner Perl_warner
+#ifdef AvPAD_NAMELIST
+ assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv)));
+#endif
-#define Perl_warner_nocontext Perl_warner
+ for (mg = SvMAGIC (sv); mg; mg = mg->mg_moremagic) {
+ if (mg->mg_type == type && mg->mg_virtual == vtbl)
+ return mg;
+ }
+ }
-#endif
-#endif
+ return NULL;
+}
-/* concatenating with "" ensures that only literal strings are accepted as argument
- * note that STR_WITH_LEN() can't be used as argument to macros or functions that
- * under some configurations might be macros
- */
-#ifndef STR_WITH_LEN
-# define STR_WITH_LEN(s) (s ""), (sizeof(s)-1)
#endif
-#ifndef newSVpvs
-# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1)
#endif
-#ifndef newSVpvs_flags
-# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags)
+#if !defined(sv_unmagicext)
+#if defined(NEED_sv_unmagicext)
+static int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
+static
+#else
+extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
#endif
-#ifndef newSVpvs_share
-# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0)
-#endif
+#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL)
-#ifndef sv_catpvs
-# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1)
+#ifdef sv_unmagicext
+# undef sv_unmagicext
#endif
+#define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c)
+#define Perl_sv_unmagicext DPPP_(my_sv_unmagicext)
-#ifndef sv_setpvs
-# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1)
-#endif
-#ifndef hv_fetchs
-# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval)
-#endif
+int
+DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl)
+{
+ MAGIC* mg;
+ MAGIC** mgp;
-#ifndef hv_stores
-# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0)
-#endif
-#ifndef gv_fetchpvs
-# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)
-#endif
+ if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
+ return 0;
+ mgp = &(SvMAGIC(sv));
+ for (mg = *mgp; mg; mg = *mgp) {
+ const MGVTBL* const virt = mg->mg_virtual;
+ if (mg->mg_type == type && virt == vtbl) {
+ *mgp = mg->mg_moremagic;
+ if (virt && virt->svt_free)
+ virt->svt_free(aTHX_ sv, mg);
+ if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
+ if (mg->mg_len > 0)
+ Safefree(mg->mg_ptr);
+ else if (mg->mg_len == HEf_SVKEY) /* Questionable on older perls... */
+ SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
+ else if (mg->mg_type == PERL_MAGIC_utf8)
+ Safefree(mg->mg_ptr);
+ }
+ if (mg->mg_flags & MGf_REFCOUNTED)
+ SvREFCNT_dec(mg->mg_obj);
+ Safefree(mg);
+ }
+ else
+ mgp = &mg->mg_moremagic;
+ }
+ if (SvMAGIC(sv)) {
+ if (SvMAGICAL(sv)) /* if we're under save_magic, wait for restore_magic; */
+ mg_magical(sv); /* else fix the flags now */
+ }
+ else {
+ SvMAGICAL_off(sv);
+ SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
+ }
+ return 0;
+}
-#ifndef gv_stashpvs
-# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags)
#endif
-#ifndef get_cvs
-# define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags)
#endif
#ifdef USE_ITHREADS
extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp);
#endif
+#if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL)
+
#ifdef caller_cx
# undef caller_cx
#endif
#define caller_cx(a,b) DPPP_(my_caller_cx)(aTHX_ a,b)
#define Perl_caller_cx DPPP_(my_caller_cx)
-#if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL)
const PERL_CONTEXT *
DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp)
extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
#endif
+#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
+
#ifdef grok_numeric_radix
# undef grok_numeric_radix
#endif
#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)
-#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
bool
DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
{
extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
#endif
+#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
+
#ifdef grok_number
# undef grok_number
#endif
#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
#define Perl_grok_number DPPP_(my_grok_number)
-#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
int
DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
{
extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
#endif
+#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
+
#ifdef grok_bin
# undef grok_bin
#endif
#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
#define Perl_grok_bin DPPP_(my_grok_bin)
-#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
UV
DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
{
extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
#endif
+#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
+
#ifdef grok_hex
# undef grok_hex
#endif
#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
#define Perl_grok_hex DPPP_(my_grok_hex)
-#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
UV
DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
{
extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
#endif
+#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
+
#ifdef grok_oct
# undef grok_oct
#endif
#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
#define Perl_grok_oct DPPP_(my_grok_oct)
-#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
UV
DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
{
#if !defined(my_snprintf)
#if defined(NEED_my_snprintf)
-static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
+static int DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...);
static
#else
-extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
+extern int DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...);
#endif
+#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
+
#define my_snprintf DPPP_(my_my_snprintf)
#define Perl_my_snprintf DPPP_(my_my_snprintf)
-#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
int
DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
#if !defined(my_sprintf)
#if defined(NEED_my_sprintf)
-static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
+static int DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...);
static
#else
-extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
+extern int DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...);
#endif
+#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
+
#define my_sprintf DPPP_(my_my_sprintf)
#define Perl_my_sprintf DPPP_(my_my_sprintf)
-#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
int
DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)
#if !defined(my_strlcat)
#if defined(NEED_my_strlcat)
-static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
+static Size_t DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size);
static
#else
-extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
+extern Size_t DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size);
#endif
+#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
+
#define my_strlcat DPPP_(my_my_strlcat)
#define Perl_my_strlcat DPPP_(my_my_strlcat)
-#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
Size_t
DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
#if !defined(my_strlcpy)
#if defined(NEED_my_strlcpy)
-static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
+static Size_t DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size);
static
#else
-extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
+extern Size_t DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size);
#endif
+#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
+
#define my_strlcpy DPPP_(my_my_strlcpy)
#define Perl_my_strlcpy DPPP_(my_my_strlcpy)
-#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
Size_t
DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)
extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
#endif
+#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
+
#ifdef pv_escape
# undef pv_escape
#endif
#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
#define Perl_pv_escape DPPP_(my_pv_escape)
-#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
char *
DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,
STRLEN wrote = 0;
STRLEN chsize = 0;
STRLEN readsize = 1;
-#if defined(is_utf8_string) && defined(utf8_to_uvchr)
+#if defined(is_utf8_string) && defined(utf8_to_uvchr_buf)
bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0;
#endif
const char *pv = str;
if (!(flags & PERL_PV_ESCAPE_NOCLEAR))
sv_setpvs(dsv, "");
-#if defined(is_utf8_string) && defined(utf8_to_uvchr)
+#if defined(is_utf8_string) && defined(utf8_to_uvchr_buf)
if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
isuni = 1;
#endif
for (; pv < end && (!max || wrote < max) ; pv += readsize) {
const UV u =
-#if defined(is_utf8_string) && defined(utf8_to_uvchr)
- isuni ? utf8_to_uvchr((U8*)pv, &readsize) :
+#if defined(is_utf8_string) && defined(utf8_to_uvchr_buf)
+ isuni ? utf8_to_uvchr_buf((U8*)pv, end, &readsize) :
#endif
(U8)*pv;
const U8 c = (U8)u & 0xFF;
extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
#endif
+#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
+
#ifdef pv_pretty
# undef pv_pretty
#endif
#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)
#define Perl_pv_pretty DPPP_(my_pv_pretty)
-#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
char *
DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,
extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
#endif
+#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
+
#ifdef pv_display
# undef pv_display
#endif
#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)
#define Perl_pv_display DPPP_(my_pv_display)
-#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
char *
DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
projects / p5sagit/Sub-Name.git / blobdiff