From b5f59bcc71d772ecec306db130748fe39e7a3db8 Mon Sep 17 00:00:00 2001 From: Karel Miko Date: Thu, 6 Jun 2019 20:32:28 +0200 Subject: update ppport.h --- ppport.h | 4357 ++++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 2545 insertions(+), 1812 deletions(-) (limited to 'ppport.h') diff --git a/ppport.h b/ppport.h index 068275d0..96ac1342 100644 --- a/ppport.h +++ b/ppport.h @@ -4,9 +4,9 @@ /* ---------------------------------------------------------------------- - ppport.h -- Perl/Pollution/Portability Version 3.36 + ppport.h -- Perl/Pollution/Portability Version 3.52 - Automatically created by Devel::PPPort running under perl 5.022003. + Automatically created by Devel::PPPort running under perl 5.026003. Do NOT edit this file directly! -- Edit PPPort_pm.PL and the includes in parts/inc/ instead. @@ -21,7 +21,7 @@ SKIP =head1 NAME -ppport.h - Perl/Pollution/Portability version 3.36 +ppport.h - Perl/Pollution/Portability version 3.52 =head1 SYNOPSIS @@ -46,8 +46,8 @@ ppport.h - Perl/Pollution/Portability version 3.36 --nochanges don't suggest changes --nofilter don't filter input files - --strip strip all script and doc functionality from - ppport.h + --strip strip all script and doc functionality + from ppport.h --list-provided list provided API --list-unsupported list unsupported API @@ -56,7 +56,7 @@ ppport.h - Perl/Pollution/Portability version 3.36 =head1 COMPATIBILITY This version of F 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 @@ -221,6 +221,8 @@ same function or variable in your project. 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 eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL @@ -229,11 +231,15 @@ same function or variable in your project. 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 + mess_sv() NEED_mess_sv NEED_mess_sv_GLOBAL mg_findext() NEED_mg_findext NEED_mg_findext_GLOBAL my_snprintf() NEED_my_snprintf NEED_my_snprintf_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 @@ -250,7 +256,9 @@ same function or variable in your project. 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 @@ -330,7 +338,7 @@ before sending a bug report. If F was generated using the latest version of C and is causing failure of this module, please -file a bug report here: L +send a bug report to L. Please include the following information: @@ -381,9 +389,9 @@ See L. 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.36; +my $VERSION = 3.52; my %opt = ( quiet => 0, @@ -450,9 +458,9 @@ my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/ (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()), } ) : die "invalid spec: $_" } qw( -ASCII_TO_NEED||5.007001|n AvFILLp|5.004050||p AvFILL||| +BOM_UTF8||| BhkDISABLE||5.024000| BhkENABLE||5.024000| BhkENTRY_set||5.024000| @@ -541,6 +549,7 @@ IVSIZE|5.006000||p IVTYPE|5.006000||p IVdf|5.006000||p LEAVE||| +LIKELY|||p LINKLIST||5.013006| LVRET||| MARK||| @@ -552,7 +561,6 @@ MY_CXT_INIT|5.007003||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 @@ -597,6 +605,7 @@ PAD_SV||| PERLIO_FUNCS_CAST|5.009003||p PERLIO_FUNCS_DECL|5.009003||p PERL_ABS|5.008001||p +PERL_ARGS_ASSERT_CROAK_XS_USAGE|||p PERL_BCDVERSION|5.024000||p PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p PERL_HASH|5.003070||p @@ -744,6 +753,7 @@ 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_zero|||n PL_tainted|5.004050||p PL_tainting|5.004050||p PL_tokenbuf|5.024000||p @@ -820,12 +830,22 @@ PerlIO_stdout||5.007003| PerlIO_tell||5.007003| PerlIO_unread||5.007003| PerlIO_write||5.007003| -Perl_signbit||5.009005|n +PerlLIO_dup2_cloexec||| +PerlLIO_dup_cloexec||| +PerlLIO_open3_cloexec||| +PerlLIO_open_cloexec||| +PerlProc_pipe_cloexec||| +PerlSock_accept_cloexec||| +PerlSock_socket_cloexec||| +PerlSock_socketpair_cloexec||| +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 Renewc||| @@ -927,6 +947,7 @@ SvPOK_only||| SvPOK_on||| SvPOKp||| SvPOK||| +SvPVCLEAR||| SvPVX_const|5.009003||p SvPVX_mutable|5.009003||p SvPVX||| @@ -964,6 +985,9 @@ SvPVutf8x||5.006000| SvPVutf8||5.006000| SvPVx||| SvPV||| +SvREADONLY_off||| +SvREADONLY_on||| +SvREADONLY||| SvREFCNT_dec_NN||5.017007| SvREFCNT_dec||| SvREFCNT_inc_NN|5.009004||p @@ -1015,8 +1039,16 @@ SvVOK||5.008001| SvVSTRING_mg|5.009004||p THIS|||n UNDERBAR|5.009002||p +UNICODE_REPLACEMENT|||p +UNLIKELY|||p UTF8SKIP||5.006000| +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 @@ -1114,57 +1146,17 @@ XopENTRY||5.024000| 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||| +_inverse_folds||| +_is_grapheme||| +_is_in_locale_category||| _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_fold_latin1|||n _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| +_variant_byte_number|||n _warn_problematic_locale|||n aMY_CXT_|5.007003||p aMY_CXT|5.007003||p @@ -1172,8 +1164,8 @@ aTHXR_|5.024000||p aTHXR|5.024000||p aTHX_|5.006000||p aTHX|5.006000||p +abort_execution||| add_above_Latin1_folds||| -add_cp_to_invlist||| add_data|||n add_multi_match||| add_utf16_textfilter||| @@ -1181,8 +1173,6 @@ 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||| @@ -1194,19 +1184,16 @@ 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||| +argvout_final||| 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||| @@ -1216,16 +1203,18 @@ av_fill||| av_iter_p||5.011000| av_len||| av_make||| +av_nonelem||| 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_GCB||| backup_one_LB||| backup_one_SB||| backup_one_WB||| @@ -1241,8 +1230,6 @@ 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| @@ -1257,11 +1244,19 @@ cast_i32||5.006000|n cast_iv||5.006000|n cast_ulong||5.006000|n cast_uv||5.006000|n -check_locale_boundary_crossing||| +category_name|||n +change_engine_size||| +check_and_deprecate||| 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| @@ -1273,7 +1268,6 @@ 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 @@ -1281,14 +1275,12 @@ 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| @@ -1308,14 +1300,14 @@ cophh_store_sv||5.013007| core_prototype||| coresub_op||| cr_textfilter||| -create_eval_scope||| -croak_memory_wrap||5.019003|n +croak_caller|||vn +croak_memory_wrap|5.019003||pn croak_no_mem|||n -croak_no_modify||5.013003|n -croak_nocontext|||vn +croak_no_modify|5.013003||pn +croak_nocontext|||pvn croak_popstack|||n -croak_sv||5.013001| -croak_xs_usage||5.010001|n +croak_sv|5.013001||p +croak_xs_usage|5.010001||pn croak|||v csighandler||5.009003|n current_re_engine||| @@ -1325,13 +1317,13 @@ 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| @@ -1343,24 +1335,6 @@ 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 @@ -1396,13 +1370,12 @@ debug_start_match||| deb||5.007003|v defelem_target||| del_sv||| -delete_eval_scope||| +delimcpy_no_escape|||n delimcpy||5.004000|n -deprecate_commaless_var_list||| despatch_signals||5.007001| destroy_matcher||| die_nocontext|||vn -die_sv||5.013001| +die_sv|5.013001||p die_unwind||| die|||v dirp_dup||| @@ -1418,7 +1391,6 @@ do_delete_local||| do_dump_pad||| do_eof||| do_exec3||| -do_execfree||| do_exec||| do_gv_dump||5.006000| do_gvgv_dump||5.006000| @@ -1432,9 +1404,7 @@ 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| @@ -1461,6 +1431,7 @@ do_vecget||| do_vecset||| do_vop||| docatch||| +does_utf8_overflow|||n doeval_compile||| dofile||| dofindlabel||| @@ -1494,6 +1465,7 @@ dump_indent||5.006000|v dump_mstats||| dump_packsubs_perl||| dump_packsubs||5.006000| +dump_regex_sets_structures||| dump_sub_perl||| dump_sub||5.006000| dump_sv_child||| @@ -1503,8 +1475,9 @@ dump_trie||| dump_vindent||5.006000| dumpuntil||| dup_attrlist||| +dup_warnings||| edit_distance|||n -emulate_cop_io||| +emulate_setlocale|||n eval_pv|5.006000||p eval_sv|5.006000||p exec_failed||| @@ -1526,17 +1499,18 @@ find_default_stash||| find_hash_subscript||| find_in_my_stash||| find_lexical_cv||| +find_next_masked|||n find_runcv_where||| find_runcv||5.008001| -find_rundefsvoffset||5.009002| find_rundefsv||5.013002| find_script||| -find_uninit_var||| +find_span_end_mask|||n +find_span_end|||n first_symbol|||n fixup_errno_string||| +foldEQ_latin1_s2_folded|||n 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||| @@ -1550,7 +1524,6 @@ force_version||| force_word||| forget_pmop||| form_nocontext|||vn -form_short_octal_warning||| form||5.004000|v fp_dup||| fprintf_nocontext|||vn @@ -1559,7 +1532,9 @@ free_global_struct||| free_tied_hv_pool||| free_tmps||| gen_constant_list||| +get_ANYOFM_contents||| get_ANYOF_cp_list_for_ssc||| +get_and_check_backslash_N_name_wrapper||| get_and_check_backslash_N_name||| get_aux_mg||| get_av|5.006000||p @@ -1573,9 +1548,6 @@ 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||| @@ -1583,7 +1555,6 @@ 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| @@ -1596,9 +1567,6 @@ 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| @@ -1632,9 +1600,6 @@ gv_fetchmeth_pv||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 @@ -1662,26 +1627,23 @@ gv_stashpvs|5.009003||p gv_stashpv||| gv_stashsvpvn_cached||| gv_stashsv||| -gv_try_downgrade||| handle_named_backref||| handle_possible_posix||| handle_regex_sets||| +handle_user_defined_property||| he_dup||| hek_dup||| hfree_next_entry||| -hfreeentries||| 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| @@ -1695,15 +1657,14 @@ 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||| @@ -1712,12 +1673,12 @@ hv_notallowed||| hv_placeholders_get||5.009003| hv_placeholders_p||| hv_placeholders_set||5.009003| +hv_pushkv||| 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||| @@ -1735,133 +1696,107 @@ 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_named_cv||| init_perllib||| init_postdump_symbols||| init_predump_symbols||| init_stacks||5.005000| init_tm||5.007002| +init_uniprops||| 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||| +isDIGIT_A|||p +isDIGIT|||p +isFF_OVERLONG|||n isFOO_utf8_lc||| -isGCB|||n +isGCB||| +isGRAPH_A|||p isGRAPH|5.006000||p -isIDCONT||5.017008| -isIDFIRST_lazy||5.021001| -isIDFIRST||| +isIDCONT_A|||p +isIDCONT|5.017008|5.017008|p +isIDFIRST_A|||p +isIDFIRST|||p isLB||| -isLOWER||| -isOCTAL||5.013005| +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| +isSCRIPT_RUN||| +isSPACE_A|||p +isSPACE|||p +isSTRICT_UTF8_CHAR|||n +isUPPER_A|||p +isUPPER|||p +isUTF8_CHAR_flags||| +isUTF8_CHAR||5.021001|n isWB||| -isWORDCHAR||5.013006| +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_ascii_string||5.011000|n +is_c9strict_utf8_string_loclen|||n +is_c9strict_utf8_string_loc|||n +is_c9strict_utf8_string|||n is_handle_constructor|||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_with_len||| 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_cp_above_31_bits|||n +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_non_invariant_string|||n +is_utf8_overlong_given_start_byte_ok|||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| +is_utf8_valid_partial_char_flags|||n +is_utf8_valid_partial_char|||n isa_lookup||| isinfnansv||| isinfnan||5.021004|n @@ -1871,22 +1806,8 @@ jmaybe||| join_exact||| keyword_plugin_standard||| keyword||| -leave_adjust_stacks||5.023008| 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 @@ -1951,6 +1872,7 @@ magic_setisa||| magic_setlvref||| magic_setmglob||| magic_setnkeys||| +magic_setnonelem||| magic_setpack||| magic_setpos||| magic_setregexp||| @@ -1983,9 +1905,9 @@ mem_log_common|||n mem_log_free|||n mem_log_realloc|||n mess_alloc||| -mess_nocontext|||vn -mess_sv||5.013001| -mess||5.006000|v +mess_nocontext|||pvn +mess_sv|5.013001||p +mess|5.006000||pv mfree||5.007002|n mg_clear||| mg_copy||| @@ -1994,9 +1916,9 @@ 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||| @@ -2025,14 +1947,13 @@ mro_register||5.010001| mro_set_mro||5.010001| mro_set_private_data||5.010001| mul128||| -mulexp10|||n +multiconcat_stringify||| 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||| @@ -2046,22 +1967,26 @@ my_fork||5.007003|n my_kid||| my_lstat_flags||| my_lstat||5.024000| -my_memcmp|||n -my_memset|||n +my_memrchr|||n +my_mkostemp|||n +my_mkstemp_cloexec|||n +my_mkstemp|||n +my_nl_langinfo|||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_strerror||| my_strftime||5.007002| my_strlcat|5.009004||pn my_strlcpy|5.009004||pn +my_strnlen|||pn +my_strtod|||n my_unexec||| my_vsnprintf||5.009004|n need_utf8|||n @@ -2084,7 +2009,6 @@ newFORM||| newFOROP||5.013007| newGIVENOP||5.009003| newGIVWHENOP||| -newGP||| newGVOP||| newGVREF||| newGVgen_flags||5.015004| @@ -2103,9 +2027,6 @@ newMETHOP||5.021005| newMYSUB||5.017004| newNULLLIST||| newOP||| -newPADNAMELIST||5.021007|n -newPADNAMEouter||5.021007|n -newPADNAMEpvn||5.021007|n newPADOP||| newPMOP||| newPROG||| @@ -2138,6 +2059,8 @@ newSVpvs_share|5.009003||p newSVpvs|5.009003||p newSVpv||| newSVrv||| +newSVsv_flags||| +newSVsv_nomg||| newSVsv||| newSVuv|5.006000||p newSV||| @@ -2146,19 +2069,19 @@ 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_collate||| new_constant||| -new_ctype||5.006000| +new_ctype||| new_he||| new_logop||| -new_numeric||5.006000| +new_msg_hv||| +new_numeric||| +new_regcurly|||n new_stackinfo||5.005000| new_version||5.009000| -new_warnings_bitfield||| next_symbol||| nextargv||| nextchar||| @@ -2170,12 +2093,14 @@ noperl_die|||vn not_a_number||| not_incrementable||| nothreadhook||5.008000| +notify_parser_that_changed_to_utf8||| nuke_stacks||| num_overflow|||n oopsAV||| oopsHV||| op_append_elem||5.013006| op_append_list||5.013006| +op_class||| op_clear||| op_contextualize||5.013006| op_convert_list||5.021006| @@ -2184,19 +2109,14 @@ 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||| @@ -2204,7 +2124,9 @@ opmethod_stash||| opslab_force_free||| opslab_free_nopad||| opslab_free||| -output_or_return_posix_warnings||| +optimize_optree||| +optimize_op||| +output_posix_warnings||| pMY_CXT_|5.007003||p pMY_CXT|5.007003||p pTHX_|5.006000||p @@ -2222,7 +2144,6 @@ 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| @@ -2240,30 +2161,18 @@ 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||| +parse_uniprop_string||| parser_dup||| parser_free_nexttoke_ops||| parser_free||| @@ -2292,11 +2201,12 @@ pregexec||| pregfree2||5.011000| pregfree||| prescan_version||5.011004| +print_bytes_for_locale||| +print_collxfrm_input_and_return||| 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| @@ -2314,7 +2224,6 @@ 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| @@ -2362,15 +2271,14 @@ 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||| +regcp_restore||| regcppop||| regcppush||| regcurly|||n @@ -2405,6 +2313,7 @@ report_wrongway_fh||| require_pv||5.006000| require_tie_mod||| restore_magic||| +restore_switched_locale||| rninstr|||n rpeep||| rsignal_restore||| @@ -2476,6 +2385,7 @@ save_shared_pvref||5.007003| save_sptr||| save_strlen||| save_svref||| +save_to_buffer|||n save_vptr||5.006000| savepvn||| savepvs||5.009003| @@ -2487,7 +2397,6 @@ savesharedsvpv||5.013006| savestack_grow_cnt||5.008001| savestack_grow||| savesvpv||5.009002| -savetmps||5.023008| sawparens||| scalar_mod_type|||n scalarboolean||| @@ -2506,23 +2415,28 @@ 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_numeric_underlying||| set_padlist|||n +set_regex_pv||| setdefout||| +setfd_cloexec_for_nonsysfd||| +setfd_cloexec_or_inhexec_by_sysfdness||| +setfd_cloexec|||n +setfd_inhexec_for_sysfd||| +setfd_inhexec|||n +setlocale_debug_string|||n share_hek_flags||| share_hek||5.004000| should_warn_nl|||n @@ -2530,7 +2444,6 @@ si_dup||| sighandler|||n simplify_sort||| skip_to_be_ignored_text||| -skipspace_flags||| softref2xv||| sortcv_stacked||| sortcv_xsub||| @@ -2552,7 +2465,6 @@ ssc_is_cp_posixl_init|||n ssc_or||| ssc_union||| stack_grow||| -start_glob||| start_subparse||5.004000| stdize_locale||| strEQ||| @@ -2579,7 +2491,6 @@ 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 @@ -2653,10 +2564,8 @@ 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||| @@ -2667,7 +2576,6 @@ sv_insert||| sv_isa||| sv_isobject||| sv_iv||5.005000| -sv_kill_backrefs||| sv_len_utf8_nomg||| sv_len_utf8||5.006000| sv_len||| @@ -2713,12 +2621,15 @@ sv_replace||| sv_report_used||| sv_resetpvn||| sv_reset||| +sv_rvunweaken||| sv_rvweaken||5.006000| +sv_set_undef||| sv_sethek||| 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 @@ -2737,13 +2648,13 @@ sv_setref_pvn||| sv_setref_pvs||5.024000| sv_setref_pv||| sv_setref_uv||5.007001| -sv_setsv_cow||| sv_setsv_flags||5.007002| 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| @@ -2758,8 +2669,8 @@ sv_upgrade||| 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| @@ -2775,11 +2686,10 @@ 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_category_locale_to_template||| +switch_to_global_locale|||n +sync_locale||5.021004|n sys_init3||5.010000|n sys_init||5.010000|n sys_intern_clear||| @@ -2790,43 +2700,39 @@ 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 +traverse_op_tree||| try_amagic_bin||| try_amagic_un||| +turkic_fc||| +turkic_lc||| +turkic_uc||| uiv_2buf|||n unlnk||| unpack_rec||| @@ -2844,16 +2750,17 @@ 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|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| @@ -2861,10 +2768,9 @@ 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||| +valid_utf8_to_uvchr|||n validate_suid||| +variant_under_utf8_count|||n varname||| vcmp||5.009000| vcroak||5.006000| @@ -2874,7 +2780,7 @@ visit||| vivify_defelem||| vivify_ref||| vload_module|5.006000||p -vmess||5.006000| +vmess|5.006000|5.006000|p vnewSVpvf|5.006000|5.004000|p vnormal||5.009002| vnumify||5.009000| @@ -2883,8 +2789,9 @@ vverify||5.009003| vwarner||5.006000| vwarn||5.006000| wait4pid||| -warn_nocontext|||vn -warn_sv||5.013001| +warn_nocontext|||pvn +warn_on_first_deprecated_use||| +warn_sv|5.013001||p warner_nocontext|||vn warner|5.006000|5.004000|pv warn|||v @@ -2895,6 +2802,7 @@ whichsig_pv||5.015004| whichsig_sv||5.015004| whichsig||| win32_croak_not_implemented|||n +win32_setlocale||| with_queued_errors||| wrap_op_checker||5.015008| write_to_stderr||| @@ -2906,6 +2814,7 @@ yyerror_pv||| yyerror||| yylex||| yyparse||| +yyquit||| yyunlex||| yywarn||| ); @@ -3673,8 +3582,8 @@ __DATA__ # 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. @@ -4071,139 +3980,6 @@ __DATA__ #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 PERL_MAGIC_qr -# define PERL_MAGIC_qr 'r' -#endif #ifndef cBOOL # define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0) #endif @@ -4228,6 +4004,22 @@ __DATA__ # define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib)) #endif +#ifndef HEf_SVKEY +# define HEf_SVKEY -2 +#endif + +#if defined(DEBUGGING) && !defined(__COVERITY__) +#ifndef __ASSERT_ +# define __ASSERT_(statement) assert(statement), +#endif + +#else +#ifndef __ASSERT_ +# define __ASSERT_(statement) +#endif + +#endif + #ifndef SvRX #if defined(NEED_SvRX) static void * DPPP_(my_SvRX)(pTHX_ SV *rv); @@ -4236,12 +4028,13 @@ static extern void * DPPP_(my_SvRX)(pTHX_ SV *rv); #endif +#if defined(NEED_SvRX) || defined(NEED_SvRX_GLOBAL) + #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) @@ -4421,6 +4214,13 @@ typedef NVTYPE NV; #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 @@ -4541,45 +4341,137 @@ typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX); 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 - -#ifndef isGRAPH -# define isGRAPH(c) isgraph(c) -#endif - -#ifndef isPRINT -# define isPRINT(c) isprint(c) -#endif - -#ifndef isPUNCT -# define isPUNCT(c) ispunct(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 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 @@ -4587,21 +4479,24 @@ typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); * Devel::PPPort always overrides a present buggy version. */ # undef isPRINT +# undef isPRINT_A # endif -#ifdef HAS_QUAD -# ifdef U64TYPE -# define WIDEST_UTYPE U64TYPE -# else -# define WIDEST_UTYPE Quad_t +# 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 -#else -# define WIDEST_UTYPE U32 -#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 @@ -4610,1860 +4505,2683 @@ typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); # define isCNTRL(c) ((WIDEST_UTYPE) (c) < ' ' || (c) == 127) #endif +#ifndef isLOWER +# define isLOWER(c) ((c) >= 'a' && (c) <= 'z') +#endif + +#ifndef isUPPER +# define isUPPER(c) ((c) <= 'Z' && (c) >= 'A') +#endif + +#endif /* Below are definitions common to EBCDIC and ASCII */ +#ifndef isALNUM +# define isALNUM(c) isWORDCHAR(c) +#endif + +#ifndef isALNUMC +# define isALNUMC(c) isALPHANUMERIC(c) +#endif + +#ifndef isALPHA +# define isALPHA(c) (isUPPER(c) || isLOWER(c)) +#endif + +#ifndef isALPHANUMERIC +# define isALPHANUMERIC(c) (isALPHA(c) || isDIGIT(c)) +#endif + +#ifndef isBLANK +# define isBLANK(c) ((c) == ' ' || (c) == '\t') +#endif + +#ifndef isDIGIT +# define isDIGIT(c) ((c) <= '9' && (c) >= '0') +#endif + #ifndef isGRAPH -# define isGRAPH(c) (isALNUM(c) || isPUNCT(c)) +# define isGRAPH(c) (isWORDCHAR(c) || isPUNCT(c)) +#endif + +#ifndef isIDCONT +# define isIDCONT(c) isWORDCHAR(c) +#endif + +#ifndef isIDFIRST +# define isIDFIRST(c) (isALPHA(c) || (c) == '_') +#endif + +#ifndef isOCTAL +# define isOCTAL(c) (((WIDEST_UTYPE)((c)) & ~7) == '0') #endif #ifndef isPRINT -# define isPRINT(c) (((c) >= 32 && (c) < 127)) +# define isPRINT(c) (isGRAPH(c) || (c) == ' ') +#endif + +#ifndef isPSXSPC +# define isPSXSPC(c) isSPACE(c) #endif #ifndef isPUNCT -# define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) +# 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 isSPACE +# define isSPACE(c) ( isBLANK(c) || (c) == '\n' || (c) == '\r' \ + || (c) == '\v' || (c) == '\f') +#endif + +#ifndef isWORDCHAR +# define isWORDCHAR(c) (isALPHANUMERIC(c) || (c) == '_') #endif #ifndef isXDIGIT -# define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F')) +# define isXDIGIT(c) ( isDIGIT(c) \ + || ((c) >= 'a' && (c) <= 'f') \ + || ((c) >= 'A' && (c) <= 'F')) +#endif +#ifndef isALNUM_A +# define isALNUM_A isALNUM #endif +#ifndef isALNUMC_A +# define isALNUMC_A isALNUMC #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 isALPHA_A +# define isALPHA_A isALPHA #endif +#ifndef isALPHANUMERIC_A +# define isALPHANUMERIC_A isALPHANUMERIC #endif -#ifndef C_ARRAY_LENGTH -# define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) + +#ifndef isASCII_A +# define isASCII_A isASCII #endif -#ifndef C_ARRAY_END -# define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a)) +#ifndef isBLANK_A +# define isBLANK_A isBLANK #endif -#ifndef PERL_SIGNALS_UNSAFE_FLAG +#ifndef isCNTRL_A +# define isCNTRL_A isCNTRL +#endif -#define PERL_SIGNALS_UNSAFE_FLAG 0x0001 +#ifndef isDIGIT_A +# define isDIGIT_A isDIGIT +#endif -#if (PERL_BCDVERSION < 0x5008000) -# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG -#else -# define D_PPP_PERL_SIGNALS_INIT 0 +#ifndef isGRAPH_A +# define isGRAPH_A isGRAPH #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); +#ifndef isIDCONT_A +# define isIDCONT_A isIDCONT #endif -#define PL_signals DPPP_(my_PL_signals) +#ifndef isIDFIRST_A +# define isIDFIRST_A isIDFIRST #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. - */ +#ifndef isLOWER_A +# define isLOWER_A isLOWER +#endif -#if (PERL_BCDVERSION <= 0x5005005) -/* Replace: 1 */ -# define PL_ppaddr ppaddr -# define PL_no_modify no_modify -/* Replace: 0 */ +#ifndef isOCTAL_A +# define isOCTAL_A isOCTAL #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 */ +#ifndef isPRINT_A +# define isPRINT_A isPRINT #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); +#ifndef isPSXSPC_A +# define isPSXSPC_A isPSXSPC #endif -# endif +#ifndef isPUNCT_A +# define isPUNCT_A isPUNCT +#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 isSPACE_A +# define isSPACE_A isSPACE +#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 isUPPER_A +# define isUPPER_A isUPPER +#endif +#ifndef isWORDCHAR_A +# define isWORDCHAR_A isWORDCHAR +#endif -#else +#ifndef isXDIGIT_A +# define isXDIGIT_A isXDIGIT +#endif -/* ensure that PL_parser != NULL and cannot be dereferenced */ -# define PL_parser ((void *) 1) +/* 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 #endif -#ifndef mPUSHs -# define mPUSHs(s) PUSHs(sv_2mortal(s)) +#ifndef C_ARRAY_LENGTH +# define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) #endif -#ifndef PUSHmortal -# define PUSHmortal PUSHs(sv_newmortal()) +#ifndef C_ARRAY_END +# define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a)) +#endif +#ifndef LIKELY +# define LIKELY(x) (x) #endif -#ifndef mPUSHp -# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l)) +#ifndef UNLIKELY +# define UNLIKELY(x) (x) +#endif +#ifndef UNICODE_REPLACEMENT +# define UNICODE_REPLACEMENT 0xFFFD #endif -#ifndef mPUSHn -# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) +#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 +#ifndef WARN_ALL +# define WARN_ALL 0 #endif -#ifndef mPUSHi -# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) +#ifndef WARN_CLOSURE +# define WARN_CLOSURE 1 #endif -#ifndef mPUSHu -# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) +#ifndef WARN_DEPRECATED +# define WARN_DEPRECATED 2 #endif -#ifndef mXPUSHs -# define mXPUSHs(s) XPUSHs(sv_2mortal(s)) + +#ifndef WARN_EXITING +# define WARN_EXITING 3 #endif -#ifndef XPUSHmortal -# define XPUSHmortal XPUSHs(sv_newmortal()) +#ifndef WARN_GLOB +# define WARN_GLOB 4 #endif -#ifndef mXPUSHp -# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END +#ifndef WARN_IO +# define WARN_IO 5 #endif -#ifndef mXPUSHn -# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END +#ifndef WARN_CLOSED +# define WARN_CLOSED 6 #endif -#ifndef mXPUSHi -# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END +#ifndef WARN_EXEC +# define WARN_EXEC 7 #endif -#ifndef mXPUSHu -# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END +#ifndef WARN_LAYER +# define WARN_LAYER 8 #endif -/* Replace: 1 */ -#ifndef call_sv -# define call_sv perl_call_sv +#ifndef WARN_NEWLINE +# define WARN_NEWLINE 9 #endif -#ifndef call_pv -# define call_pv perl_call_pv +#ifndef WARN_PIPE +# define WARN_PIPE 10 #endif -#ifndef call_argv -# define call_argv perl_call_argv +#ifndef WARN_UNOPENED +# define WARN_UNOPENED 11 #endif -#ifndef call_method -# define call_method perl_call_method +#ifndef WARN_MISC +# define WARN_MISC 12 #endif -#ifndef eval_sv -# define eval_sv perl_eval_sv + +#ifndef WARN_NUMERIC +# define WARN_NUMERIC 13 #endif -/* Replace: 0 */ -#ifndef PERL_LOADMOD_DENY -# define PERL_LOADMOD_DENY 0x1 +#ifndef WARN_ONCE +# define WARN_ONCE 14 #endif -#ifndef PERL_LOADMOD_NOIMPORT -# define PERL_LOADMOD_NOIMPORT 0x2 +#ifndef WARN_OVERFLOW +# define WARN_OVERFLOW 15 #endif -#ifndef PERL_LOADMOD_IMPORT_OPS -# define PERL_LOADMOD_IMPORT_OPS 0x4 +#ifndef WARN_PACK +# define WARN_PACK 16 #endif -#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 +#ifndef WARN_PORTABLE +# define WARN_PORTABLE 17 #endif -/* Replace perl_eval_pv with eval_pv */ +#ifndef WARN_RECURSION +# define WARN_RECURSION 18 +#endif -#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); +#ifndef WARN_REDEFINE +# define WARN_REDEFINE 19 #endif -#ifdef eval_pv -# undef eval_pv +#ifndef WARN_REGEXP +# define WARN_REGEXP 20 #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) +#ifndef WARN_SEVERE +# define WARN_SEVERE 21 +#endif -SV* -DPPP_(my_eval_pv)(char *p, I32 croak_on_error) -{ - dSP; - SV* sv = newSVpv(p, 0); +#ifndef WARN_DEBUGGING +# define WARN_DEBUGGING 22 +#endif - PUSHMARK(sp); - eval_sv(sv, G_SCALAR); - SvREFCNT_dec(sv); +#ifndef WARN_INPLACE +# define WARN_INPLACE 23 +#endif - SPAGAIN; - sv = POPs; - PUTBACK; +#ifndef WARN_INTERNAL +# define WARN_INTERNAL 24 +#endif - if (croak_on_error && SvTRUE(GvSV(errgv))) - croak(SvPVx(GvSV(errgv), na)); +#ifndef WARN_MALLOC +# define WARN_MALLOC 25 +#endif - return sv; -} +#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 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 WARN_AMBIGUOUS +# define WARN_AMBIGUOUS 29 #endif -#ifdef vload_module -# undef vload_module +#ifndef WARN_BAREWORD +# define WARN_BAREWORD 30 #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) +#ifndef WARN_DIGIT +# define WARN_DIGIT 31 +#endif -void -DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args) -{ - dTHR; - dVAR; - OP *veop, *imop; +#ifndef WARN_PARENTHESIS +# define WARN_PARENTHESIS 32 +#endif - 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; +#ifndef WARN_PRECEDENCE +# define WARN_PRECEDENCE 33 +#endif -#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 WARN_PRINTF +# define WARN_PRINTF 34 #endif - PL_expect = oexpect; - PL_copline = ocopline; - PL_curcop = ocurcop; - } -} +#ifndef WARN_PROTOTYPE +# define WARN_PROTOTYPE 35 #endif + +#ifndef WARN_QW +# define WARN_QW 36 #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 WARN_RESERVED +# define WARN_RESERVED 37 #endif -#ifdef load_module -# undef load_module +#ifndef WARN_SEMICOLON +# define WARN_SEMICOLON 38 #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 WARN_TAINT +# define WARN_TAINT 39 +#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 WARN_THREADS +# define WARN_THREADS 40 +#endif +#ifndef WARN_UNINITIALIZED +# define WARN_UNINITIALIZED 41 #endif + +#ifndef WARN_UNPACK +# define WARN_UNPACK 42 #endif -#ifndef newRV_inc -# define newRV_inc(sv) newRV(sv) /* Replace */ + +#ifndef WARN_UNTIE +# define WARN_UNTIE 43 #endif -#ifndef newRV_noinc -#if defined(NEED_newRV_noinc) -static SV * DPPP_(my_newRV_noinc)(SV *sv); -static -#else -extern SV * DPPP_(my_newRV_noinc)(SV *sv); +#ifndef WARN_UTF8 +# define WARN_UTF8 44 #endif -#ifdef newRV_noinc -# undef newRV_noinc +#ifndef WARN_VOID +# define WARN_VOID 45 #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 WARN_ASSERTIONS +# define WARN_ASSERTIONS 46 #endif +#ifndef packWARN +# define packWARN(a) (a) #endif -/* Hint: newCONSTSUB - * Returns a CV* as of perl-5.7.1. This return value is not supported - * by Devel::PPPort. - */ +#ifndef ckWARN +# ifdef G_WARN_ON +# define ckWARN(a) (PL_dowarn & G_WARN_ON) +# else +# define ckWARN(a) PL_dowarn +# endif +#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); +#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_newCONSTSUB)(HV *stash, const char *name, SV *sv); +extern void DPPP_(my_warner)(U32 err, const char *pat, ...); #endif -#ifdef newCONSTSUB -# undef newCONSTSUB -#endif -#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) -#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) +#if defined(NEED_warner) || defined(NEED_warner_GLOBAL) -#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) +#define Perl_warner DPPP_(my_warner) -/* 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) +DPPP_(my_warner)(U32 err, const char *pat, ...) { - 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; + SV *sv; + va_list args; - PL_hints &= ~HINT_BLOCK_SCOPE; - if (stash) - PL_curstash = PL_curcop->cop_stash = stash; + PERL_UNUSED_ARG(err); - newSUB( + va_start(args, pat); + sv = vnewSVpvf(pat, &args); + va_end(args); + sv_2mortal(sv); + warn("%s", SvPV_nolen(sv)); +} -#if (PERL_BCDVERSION < 0x5003022) - start_subparse(), -#elif (PERL_BCDVERSION == 0x5003022) - start_subparse(0), -#else /* 5.003_23 onwards */ - start_subparse(FALSE, 0), -#endif +#define warner Perl_warner - 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)) - ); +#define Perl_warner_nocontext Perl_warner - PL_hints = oldhints; - PL_curcop->cop_stash = old_cop_stash; - PL_curstash = old_curstash; - PL_curcop->cop_line = oldline; -} #endif #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. - */ - -#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ - defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) - -#ifndef START_MY_CXT - -/* 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 - -#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 */ - -/* 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)) - -/* 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)) - -/* This macro must be used to access members of the my_cxt_t structure. - * e.g. MYCXT.some_data */ -#define MY_CXT (*my_cxtp) - -/* 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 - -#endif /* START_MY_CXT */ - -#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)) +#define _ppport_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 - -#else /* single interpreter */ - -#ifndef START_MY_CXT - -#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 - -#define pMY_CXT void -#define pMY_CXT_ -#define _pMY_CXT -#define aMY_CXT -#define aMY_CXT_ -#define _aMY_CXT - -#endif /* START_MY_CXT */ - -#ifndef MY_CXT_CLONE -#define MY_CXT_CLONE NOOP +#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 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 SvUVX +# define SvUVX(sv) ((UV)SvIVX(sv)) #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 SvUVXx +# define SvUVXx(sv) SvUVX(sv) #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 SvUV +# define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) #endif -#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 +#ifndef SvUVx +# define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) #endif -#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 +/* Hint: sv_uv + * Always use the SvUVx() macro instead of sv_uv(). + */ +#ifndef sv_uv +# define sv_uv(sv) SvUVx(sv) #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 +#if !defined(SvUOK) && defined(SvIOK_UV) +# define SvUOK(sv) SvIOK_UV(sv) #endif -#ifndef SvREFCNT_inc_simple_void -# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END +#ifndef XST_mUV +# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) #endif -#ifndef SvREFCNT_inc_simple_NN -# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) +#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 SvREFCNT_inc_void_NN -# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#ifndef XPUSHu +# define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END #endif -#ifndef SvREFCNT_inc_simple_void_NN -# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#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 \ + : _ppport_MIN(((e) - (s)), UTF8SKIP(s)))) #endif -#ifndef newSV_type +#endif -#if defined(NEED_newSV_type) -static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); +#if !defined(my_strnlen) +#if defined(NEED_my_strnlen) +static STRLEN DPPP_(my_my_strnlen)(const char *str, Size_t maxlen); static #else -extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); +extern STRLEN DPPP_(my_my_strnlen)(const char *str, Size_t maxlen); #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) +#if defined(NEED_my_strnlen) || defined(NEED_my_strnlen_GLOBAL) -#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL) +#define my_strnlen DPPP_(my_my_strnlen) +#define Perl_my_strnlen DPPP_(my_my_strnlen) -SV* -DPPP_(my_newSV_type)(pTHX_ svtype const t) + +STRLEN +DPPP_(my_my_strnlen)(const char *str, Size_t maxlen) { - SV* const sv = newSV(0); - sv_upgrade(sv, t); - return sv; -} + const char *p = str; -#endif + while(maxlen-- && *p) + p++; -#endif + return p - str; +} -#if (PERL_BCDVERSION < 0x5006000) -# define D_PPP_CONSTPV_ARG(x) ((char *) (x)) -#else -# define D_PPP_CONSTPV_ARG(x) (x) -#endif -#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 + +#if (PERL_BCDVERSION < 0x5031002) + /* 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 -#ifndef newSVpvn_flags +/* 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 shoud 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. */ -#if defined(NEED_newSVpvn_flags) -static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); +#ifndef 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 _ppport_utf8_to_uvchr_buf_callee utf8n_to_uvchr +# else +# define _ppport_utf8_to_uvchr_buf_callee utf8_to_uv +# endif + +# endif + +#ifdef _ppport_utf8_to_uvchr_buf_callee +# 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 SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); +extern UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen); #endif -#ifdef newSVpvn_flags -# undef newSVpvn_flags +#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 newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c) -#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags) +#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) -#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL) -SV * -DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags) +UV +DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) { - SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len); - SvFLAGS(sv) |= (flags & SVf_UTF8); - return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv; -} + UV ret; + STRLEN curlen; + bool overflows = 0; + const U8 *cur_s = s; + const bool do_warnings = ckWARN_d(WARN_UTF8); + + 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; + } + } -#endif + /* The modern version allows anything that evaluates to a legal UV, but not + * overlongs nor an empty input */ + ret = _ppport_utf8_to_uvchr_buf_callee( + s, curlen, retlen, (UTF8_ALLOW_ANYUV + & ~(UTF8_ALLOW_LONG|UTF8_ALLOW_EMPTY))); -#endif + /* But actually, modern versions restrict the UV to being no more than what + * an IV can hold */ + if (ret > PERL_INT_MAX) { + overflows = 1; + } -/* Backwards compatibility stuff... :-( */ -#if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen) -# define NEED_sv_2pv_flags -#endif -#if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL) -# define NEED_sv_2pv_flags_GLOBAL -#endif +# if (PERL_BCDVERSION < 0x5026000) +# ifndef EBCDIC -/* 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 + /* There are bugs in versions earlier than this on non-EBCDIC platforms + * in which it did not detect all instances of overflow, which could be + * a security hole. Also, earlier versions did not allow the overflow + * malformation under any circumstances, and modern ones do. So we + * need to check here. */ -#ifdef SvPVbyte + else if (curlen > 0 && *s >= 0xFE) { -/* Hint: SvPVbyte - * Does not work in perl-5.6.1, ppport.h implements a version - * borrowed from perl-5.7.3. - */ + /* If the main routine detected overflow, great; it returned 0. But if the + * input's first byte indicates it could overflow, we need to verify. + * First, on a 32-bit machine the first byte being at least \xFE + * automatically is overflow */ + if (sizeof(ret) < 8) { + overflows = 1; + } + 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; -#if (PERL_BCDVERSION < 0x5007000) + for (cur_s = s; cur_s < send; cur_s++, cur_h++) { + if (UNLIKELY(*cur_s == *cur_h)) { + continue; + } -#if defined(NEED_sv_2pvbyte) -static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); -static -#else -extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); -#endif + /* 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; -#ifdef sv_2pvbyte -# undef sv_2pvbyte -#endif -#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b) -#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte) + } -#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL) + /* 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. */ + } + } -char * -DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp) -{ - sv_utf8_downgrade(sv,0); - return SvPV(sv,*lp); -} +# endif +# endif /* < 5.26 */ -#endif + if (UNLIKELY(overflows)) { + if (! do_warnings) { + if (retlen) { + *retlen = _ppport_MIN(*retlen, UTF8SKIP(s)); + *retlen = _ppport_MIN(*retlen, curlen); + } + return UNICODE_REPLACEMENT; + } + else { -/* Hint: sv_2pvbyte - * Use the SvPVbyte() macro instead of sv_2pvbyte(). - */ + /* On versions that correctly detect overflow, but forbid it + * always, 0 will be returned, but also a warning will have been + * raised. Don't repeat it */ + if (ret != 0) { + /* We use the error message in use from 5.8-5.14 */ + 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; + } + } -#undef SvPVbyte + /* If failed 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'))) { -#define SvPVbyte(sv, lp) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ - ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) + /* If curlen is 0, we already handled the case where warnings are + * disabled, so this 'if' will be true, and we won't look at the + * contents of 's' */ + if (do_warnings) { + *retlen = (STRLEN) -1; + } + else { + ret = _ppport_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) { + *retlen = _ppport_MIN(*retlen, curlen); + *retlen = _ppport_MIN(*retlen, UTF8SKIP(s)); + unsigned int i = 1; + do { + if (s[i] < 0x80 || s[i] > 0xBF) { + *retlen = i; + break; + } + } while (++i < *retlen); + } -#endif +# endif -#else + } + } -# define SvPVbyte SvPV -# define sv_2pvbyte sv_2pv + return ret; +} +# endif #endif -#ifndef sv_2pvbyte_nolen -# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv) #endif -/* 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(). - */ - -/* If these are undefined, they're not handled by the core anyway */ -#ifndef SV_IMMEDIATE_UNREF -# define SV_IMMEDIATE_UNREF 0 +#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 -#ifndef SV_GMAGIC -# define SV_GMAGIC 0 #endif -#ifndef SV_COW_DROP_PV -# define SV_COW_DROP_PV 0 +#ifdef HAS_MEMCMP +#ifndef memNE +# define memNE(s1,s2,l) (memcmp(s1,s2,l)) #endif -#ifndef SV_UTF8_NO_ENCODING -# define SV_UTF8_NO_ENCODING 0 +#ifndef memEQ +# define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) #endif -#ifndef SV_NOSTEAL -# define SV_NOSTEAL 0 +#else +#ifndef memNE +# define memNE(s1,s2,l) (bcmp(s1,s2,l)) #endif -#ifndef SV_CONST_RETURN -# define SV_CONST_RETURN 0 +#ifndef memEQ +# define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) #endif -#ifndef SV_MUTABLE_RETURN -# define SV_MUTABLE_RETURN 0 #endif - -#ifndef SV_SMAGIC -# define SV_SMAGIC 0 +#ifndef memEQs +# define memEQs(s1, l, s2) \ + (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1))) #endif -#ifndef SV_HAS_TRAILING_NUL -# define SV_HAS_TRAILING_NUL 0 +#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 SV_COW_SHARED_HASH_KEYS -# define SV_COW_SHARED_HASH_KEYS 0 +#ifndef CopyD +# define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) #endif -#if (PERL_BCDVERSION < 0x5007002) +#ifdef HAS_MEMSET +#ifndef ZeroD +# define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) +#endif -#if defined(NEED_sv_2pv_flags) -static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); -static #else -extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); +#ifndef ZeroD +# define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d) #endif -#ifdef sv_2pv_flags -# undef sv_2pv_flags #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) - -#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) -{ - STRLEN n_a = (STRLEN) flags; - return sv_2pv(sv, lp ? lp : &n_a); -} - +#ifndef PoisonWith +# define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t)) #endif -#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); +#ifndef PoisonNew +# define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) #endif -#ifdef sv_pvn_force_flags -# undef sv_pvn_force_flags +#ifndef PoisonFree +# define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) #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) - -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); -} +#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 -#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 +#ifndef Newxz +# define Newxz(v,n,t) Newz(0,v,n,t) #endif -#ifndef SvPV_const -# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) +#ifndef PERL_MAGIC_sv +# define PERL_MAGIC_sv '\0' #endif -#ifndef SvPV_mutable -# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) +#ifndef PERL_MAGIC_overload +# define PERL_MAGIC_overload 'A' #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)) + +#ifndef PERL_MAGIC_overload_elem +# define PERL_MAGIC_overload_elem 'a' #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)) + +#ifndef PERL_MAGIC_overload_table +# define PERL_MAGIC_overload_table 'c' #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)) + +#ifndef PERL_MAGIC_bm +# define PERL_MAGIC_bm 'B' #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)) + +#ifndef PERL_MAGIC_regdata +# define PERL_MAGIC_regdata 'D' #endif -#ifndef SvPV_force -# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) + +#ifndef PERL_MAGIC_regdatum +# define PERL_MAGIC_regdatum 'd' #endif -#ifndef SvPV_force_nolen -# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) +#ifndef PERL_MAGIC_env +# define PERL_MAGIC_env 'E' #endif -#ifndef SvPV_force_mutable -# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) +#ifndef PERL_MAGIC_envelem +# define PERL_MAGIC_envelem 'e' #endif -#ifndef SvPV_force_nomg -# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) +#ifndef PERL_MAGIC_fm +# define PERL_MAGIC_fm 'f' #endif -#ifndef SvPV_force_nomg_nolen -# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) +#ifndef PERL_MAGIC_regex_global +# define PERL_MAGIC_regex_global 'g' #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)) + +#ifndef PERL_MAGIC_isa +# define PERL_MAGIC_isa 'I' #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)) + +#ifndef PERL_MAGIC_isaelem +# define PERL_MAGIC_isaelem 'i' #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)) + +#ifndef PERL_MAGIC_nkeys +# define PERL_MAGIC_nkeys 'k' #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)) + +#ifndef PERL_MAGIC_dbfile +# define PERL_MAGIC_dbfile 'L' #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)) + +#ifndef PERL_MAGIC_dbline +# define PERL_MAGIC_dbline 'l' #endif -#ifndef SvPV_nomg -# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) + +#ifndef PERL_MAGIC_mutex +# define PERL_MAGIC_mutex 'm' #endif -#ifndef SvPV_nomg_const -# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) +#ifndef PERL_MAGIC_shared +# define PERL_MAGIC_shared 'N' #endif -#ifndef SvPV_nomg_const_nolen -# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) +#ifndef PERL_MAGIC_shared_scalar +# define PERL_MAGIC_shared_scalar 'n' #endif -#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)) +#ifndef PERL_MAGIC_collxfrm +# define PERL_MAGIC_collxfrm 'o' #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 + +#ifndef PERL_MAGIC_tied +# define PERL_MAGIC_tied 'P' #endif -#ifndef SvMAGIC_set -# define SvMAGIC_set(sv, val) \ - STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ - (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END + +#ifndef PERL_MAGIC_tiedelem +# define PERL_MAGIC_tiedelem 'p' #endif -#if (PERL_BCDVERSION < 0x5009003) -#ifndef SvPVX_const -# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) +#ifndef PERL_MAGIC_tiedscalar +# define PERL_MAGIC_tiedscalar 'q' #endif -#ifndef SvPVX_mutable -# define SvPVX_mutable(sv) (0 + SvPVX(sv)) +#ifndef PERL_MAGIC_qr +# define PERL_MAGIC_qr 'r' #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 PERL_MAGIC_sig +# define PERL_MAGIC_sig 'S' +#endif + +#ifndef PERL_MAGIC_sigelem +# define PERL_MAGIC_sigelem 's' +#endif + +#ifndef PERL_MAGIC_taint +# define PERL_MAGIC_taint 't' +#endif + +#ifndef PERL_MAGIC_uvar +# define PERL_MAGIC_uvar 'U' +#endif + +#ifndef PERL_MAGIC_uvar_elem +# define PERL_MAGIC_uvar_elem 'u' +#endif + +#ifndef PERL_MAGIC_vstring +# define PERL_MAGIC_vstring 'V' +#endif + +#ifndef PERL_MAGIC_vec +# define PERL_MAGIC_vec 'v' +#endif + +#ifndef PERL_MAGIC_utf8 +# define PERL_MAGIC_utf8 'w' +#endif + +#ifndef PERL_MAGIC_substr +# define PERL_MAGIC_substr 'x' +#endif + +#ifndef PERL_MAGIC_defelem +# define PERL_MAGIC_defelem 'y' +#endif + +#ifndef PERL_MAGIC_glob +# define PERL_MAGIC_glob '*' +#endif + +#ifndef PERL_MAGIC_arylen +# define PERL_MAGIC_arylen '#' +#endif + +#ifndef PERL_MAGIC_pos +# define PERL_MAGIC_pos '.' +#endif + +#ifndef PERL_MAGIC_backref +# define PERL_MAGIC_backref '<' +#endif + +#ifndef PERL_MAGIC_ext +# define PERL_MAGIC_ext '~' +#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(errsv, sv) \ + STMT_START { \ + if (sv != errsv) \ + SvFLAGS(errsv) = (SvFLAGS(errsv) & ~SVf_UTF8) | \ + (SvFLAGS(sv) & SVf_UTF8); \ + } STMT_END +# else +# define D_PPP_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 { \ + D_PPP_FIX_UTF8_ERRSV(ERRSV, sv); \ + croak("%" SVf, SVfARG(sv)); \ + } \ + } STMT_END +#elif (PERL_BCDVERSION >= 0x5004000) +# define croak_sv(sv) croak("%" SVf, SVfARG(sv)) #else -#ifndef SvPVX_const -# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) +# define croak_sv(sv) croak("%s", SvPV_nolen(sv)) +#endif #endif -#ifndef SvPVX_mutable -# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) +#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 + +# 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. + */ + +# 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) + + +#else + +/* ensure that PL_parser != NULL and cannot be dereferenced */ +# define PL_parser ((void *) 1) + +#endif +#ifndef mPUSHs +# define mPUSHs(s) PUSHs(sv_2mortal(s)) +#endif + +#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 + +#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 + +#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 +#endif + +#ifndef mXPUSHu +# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END +#endif + +/* 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 + +#ifndef call_method +# define call_method perl_call_method +#endif +#ifndef eval_sv +# define eval_sv perl_eval_sv +#endif + +/* Replace: 0 */ +#ifndef PERL_LOADMOD_DENY +# define PERL_LOADMOD_DENY 0x1 +#endif + +#ifndef PERL_LOADMOD_NOIMPORT +# define PERL_LOADMOD_NOIMPORT 0x2 +#endif + +#ifndef PERL_LOADMOD_IMPORT_OPS +# define PERL_LOADMOD_IMPORT_OPS 0x4 +#endif + +#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 + +#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) + +#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) + + +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); + + SPAGAIN; + sv = POPs; + PUTBACK; + + if (croak_on_error && SvTRUEx(ERRSV)) + croak_sv(ERRSV); + + 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 + +#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) + +#ifdef vload_module +# undef vload_module +#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) + + +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); +#endif + PL_expect = oexpect; + PL_copline = ocopline; + PL_curcop = ocurcop; + } +} + +#endif +#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, ...); +#endif + +#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) + +#ifdef load_module +# undef load_module +#endif +#define load_module DPPP_(my_load_module) +#define Perl_load_module DPPP_(my_load_module) + + +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); +} + +#endif +#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 +#else +extern SV * DPPP_(my_newRV_noinc)(SV *sv); +#endif + +#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL) + +#ifdef newRV_noinc +# undef newRV_noinc +#endif +#define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a) +#define Perl_newRV_noinc DPPP_(my_newRV_noinc) + +SV * +DPPP_(my_newRV_noinc)(SV *sv) +{ + SV *rv = (SV *)newRV(sv); + SvREFCNT_dec(sv); + return rv; +} +#endif +#endif + +/* Hint: newCONSTSUB + * Returns a CV* as of perl-5.7.1. This return value is not supported + * by Devel::PPPort. + */ + +/* 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); +#endif + +#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) + +#ifdef newCONSTSUB +# undef newCONSTSUB +#endif +#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) +#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) + + +/* 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) +{ + 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; + + PL_hints &= ~HINT_BLOCK_SCOPE; + if (stash) + PL_curstash = PL_curcop->cop_stash = stash; + + newSUB( + +#if (PERL_BCDVERSION < 0x5003022) + start_subparse(), +#elif (PERL_BCDVERSION == 0x5003022) + start_subparse(0), +#else /* 5.003_23 onwards */ + start_subparse(FALSE, 0), +#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)) + ); + + PL_hints = oldhints; + PL_curcop->cop_stash = old_cop_stash; + PL_curstash = old_curstash; + PL_curcop->cop_line = oldline; +} +#endif +#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. + */ + +#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ + defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) + +#ifndef START_MY_CXT + +/* 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 + +#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 */ + +/* 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)) + +/* 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)) + +/* This macro must be used to access members of the my_cxt_t structure. + * e.g. MYCXT.some_data */ +#define MY_CXT (*my_cxtp) + +/* 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 + +#endif /* START_MY_CXT */ + +#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 /* single interpreter */ + +#ifndef START_MY_CXT + +#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 + +#define pMY_CXT void +#define pMY_CXT_ +#define _pMY_CXT +#define aMY_CXT +#define aMY_CXT_ +#define _aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +#define MY_CXT_CLONE NOOP +#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 +# error "cannot define IV/UV formats" +# endif +#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 +#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 +#endif + +#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 + +#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 SvRV_set -# define SvRV_set(sv, val) \ - STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ - ((sv)->sv_u.svu_rv = (val)); } STMT_END +#ifndef SvREFCNT_inc_simple_void +# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } 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 +#ifndef SvREFCNT_inc_simple_NN +# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) #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 +#ifndef SvREFCNT_inc_void_NN +# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) #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 +#ifndef SvREFCNT_inc_simple_void_NN +# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) #endif -#endif +#ifndef newSV_type -#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) -#if defined(NEED_vnewSVpvf) -static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); +#if defined(NEED_newSV_type) +static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); static #else -extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); +extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); #endif -#ifdef vnewSVpvf -# undef vnewSVpvf +#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL) + +#ifdef newSV_type +# undef newSV_type #endif -#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b) -#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf) +#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a) +#define Perl_newSV_type DPPP_(my_newSV_type) -#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL) -SV * -DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args) +SV* +DPPP_(my_newSV_type)(pTHX_ svtype const t) { - register SV *sv = newSV(0); - sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); + SV* const sv = newSV(0); + sv_upgrade(sv, t); return sv; } -#endif -#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*)) #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*)) #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 +#if (PERL_BCDVERSION < 0x5006000) +# define D_PPP_CONSTPV_ARG(x) ((char *) (x)) #else -extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +# define D_PPP_CONSTPV_ARG(x) (x) #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 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 -#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, ...); +#ifndef newSVpvn_flags + +#if defined(NEED_newSVpvn_flags) +static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); static #else -extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); +extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); #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_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL) -#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) +#ifdef newSVpvn_flags +# undef newSVpvn_flags +#endif +#define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c) +#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags) -void -DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...) + +SV * +DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags) { - 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); + SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len); + SvFLAGS(sv) |= (flags & SVf_UTF8); + return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv; } #endif -#endif + #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 +/* Backwards compatibility stuff... :-( */ +#if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen) +# define NEED_sv_2pv_flags +#endif +#if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL) +# define NEED_sv_2pv_flags_GLOBAL #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 +/* 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 -#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, ...); +#ifdef SvPVbyte + +/* Hint: SvPVbyte + * Does not work in perl-5.6.1, ppport.h implements a version + * borrowed from perl-5.7.3. + */ + +#if (PERL_BCDVERSION < 0x5007000) + +#if defined(NEED_sv_2pvbyte) +static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); static #else -extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); +extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); #endif -#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) +#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL) -#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) +#ifdef sv_2pvbyte +# undef sv_2pvbyte +#endif +#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b) +#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte) -void -DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...) + +char * +DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp) { - va_list args; - va_start(args, pat); - sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); - SvSETMAGIC(sv); - va_end(args); + sv_utf8_downgrade(sv,0); + return SvPV(sv,*lp); } #endif + +/* Hint: sv_2pvbyte + * Use the SvPVbyte() macro instead of sv_2pvbyte(). + */ + +#undef SvPVbyte + +#define SvPVbyte(sv, lp) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) + #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, ...); + +# define SvPVbyte SvPV +# define sv_2pvbyte sv_2pv + +#endif +#ifndef sv_2pvbyte_nolen +# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(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) +/* Hint: sv_pvn + * Always use the SvPV() macro instead of sv_pvn(). + */ -#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) +/* Hint: sv_pvn_force + * Always use the SvPV_force() macro instead of sv_pvn_force(). + */ -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); -} +/* If these are undefined, they're not handled by the core anyway */ +#ifndef SV_IMMEDIATE_UNREF +# define SV_IMMEDIATE_UNREF 0 +#endif + +#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 +#endif +#ifndef SV_NOSTEAL +# define SV_NOSTEAL 0 #endif + +#ifndef SV_CONST_RETURN +# define SV_CONST_RETURN 0 #endif + +#ifndef SV_MUTABLE_RETURN +# define SV_MUTABLE_RETURN 0 #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 +#ifndef SV_SMAGIC +# define SV_SMAGIC 0 #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 +#ifndef SV_HAS_TRAILING_NUL +# define SV_HAS_TRAILING_NUL 0 #endif -/* Hint: newSVpvn_share - * The SVs created by this function only mimic the behaviour of - * shared PVs without really being shared. Only use if you know - * what you're doing. - */ +#ifndef SV_COW_SHARED_HASH_KEYS +# define SV_COW_SHARED_HASH_KEYS 0 +#endif -#ifndef newSVpvn_share +#if (PERL_BCDVERSION < 0x5007002) -#if defined(NEED_newSVpvn_share) -static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +#if defined(NEED_sv_2pv_flags) +static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); static #else -extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); #endif -#ifdef newSVpvn_share -# undef newSVpvn_share +#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL) + +#ifdef sv_2pv_flags +# undef sv_2pv_flags #endif -#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c) -#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share) +#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) -#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) -SV * -DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash) +char * +DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) { - SV *sv; - if (len < 0) - len = -len; - if (!hash) - PERL_HASH(hash, (char*) src, len); - sv = newSVpvn((char *) src, len); - sv_upgrade(sv, SVt_PVIV); - SvIVX(sv) = hash; - SvREADONLY_on(sv); - SvPOK_on(sv); - return sv; + STRLEN n_a = (STRLEN) flags; + return sv_2pv(sv, lp ? lp : &n_a); } #endif -#endif -#ifndef SvSHARED_HASH -# define SvSHARED_HASH(sv) (0 + SvUVX(sv)) -#endif -#ifndef HvNAME_get -# define HvNAME_get(hv) HvNAME(hv) -#endif -#ifndef HvNAMELEN_get -# 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); +#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 GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types); +extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); #endif -#ifdef gv_fetchpvn_flags -# undef gv_fetchpvn_flags +#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL) + +#ifdef sv_pvn_force_flags +# undef sv_pvn_force_flags #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) +#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_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; +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); } -#endif -#endif -#ifndef GvSVn -# define GvSVn(gv) GvSV(gv) -#endif - -#ifndef isGV_with_GP -# define isGV_with_GP(gv) isGV(gv) -#endif - -#ifndef gv_fetchsv -# define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt) -#endif -#ifndef get_cvn_flags -# define get_cvn_flags(name, namelen, flags) get_cv(name, flags) #endif -#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 +#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) +# define D_PPP_SVPV_NOLEN_LP_ARG &PL_na +#else +# define D_PPP_SVPV_NOLEN_LP_ARG 0 #endif - -#ifndef WARN_DEPRECATED -# define WARN_DEPRECATED 2 +#ifndef SvPV_const +# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) #endif -#ifndef WARN_EXITING -# define WARN_EXITING 3 +#ifndef SvPV_mutable +# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) #endif - -#ifndef WARN_GLOB -# define WARN_GLOB 4 +#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 WARN_IO -# define WARN_IO 5 +#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 WARN_CLOSED -# define WARN_CLOSED 6 +#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 WARN_EXEC -# define WARN_EXEC 7 +#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 WARN_LAYER -# define WARN_LAYER 8 +#ifndef SvPV_force +# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) #endif -#ifndef WARN_NEWLINE -# define WARN_NEWLINE 9 +#ifndef SvPV_force_nolen +# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) #endif -#ifndef WARN_PIPE -# define WARN_PIPE 10 +#ifndef SvPV_force_mutable +# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) #endif -#ifndef WARN_UNOPENED -# define WARN_UNOPENED 11 +#ifndef SvPV_force_nomg +# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) #endif -#ifndef WARN_MISC -# define WARN_MISC 12 +#ifndef SvPV_force_nomg_nolen +# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) #endif - -#ifndef WARN_NUMERIC -# define WARN_NUMERIC 13 +#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 WARN_ONCE -# define WARN_ONCE 14 +#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 WARN_OVERFLOW -# define WARN_OVERFLOW 15 +#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 WARN_PACK -# define WARN_PACK 16 +#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 WARN_PORTABLE -# define WARN_PORTABLE 17 +#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 WARN_RECURSION -# define WARN_RECURSION 18 +#ifndef SvPV_nomg +# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) #endif -#ifndef WARN_REDEFINE -# define WARN_REDEFINE 19 +#ifndef SvPV_nomg_const +# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) #endif -#ifndef WARN_REGEXP -# define WARN_REGEXP 20 +#ifndef SvPV_nomg_const_nolen +# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) #endif -#ifndef WARN_SEVERE -# define WARN_SEVERE 21 +#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 WARN_DEBUGGING -# define WARN_DEBUGGING 22 +#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_INPLACE -# define WARN_INPLACE 23 +#ifndef SvMAGIC_set +# define SvMAGIC_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END #endif -#ifndef WARN_INTERNAL -# define WARN_INTERNAL 24 +#if (PERL_BCDVERSION < 0x5009003) +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) #endif -#ifndef WARN_MALLOC -# define WARN_MALLOC 25 +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) (0 + SvPVX(sv)) #endif - -#ifndef WARN_SIGNAL -# define WARN_SIGNAL 26 +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END #endif -#ifndef WARN_SUBSTR -# define WARN_SUBSTR 27 +#else +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) #endif -#ifndef WARN_SYNTAX -# define WARN_SYNTAX 28 +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) #endif - -#ifndef WARN_AMBIGUOUS -# define WARN_AMBIGUOUS 29 +#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 WARN_BAREWORD -# define WARN_BAREWORD 30 #endif - -#ifndef WARN_DIGIT -# define WARN_DIGIT 31 +#ifndef SvSTASH_set +# define SvSTASH_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END #endif -#ifndef WARN_PARENTHESIS -# define WARN_PARENTHESIS 32 +#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 -#ifndef WARN_PRECEDENCE -# define WARN_PRECEDENCE 33 +#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 -#ifndef WARN_PRINTF -# define WARN_PRINTF 34 #endif -#ifndef WARN_PROTOTYPE -# define WARN_PROTOTYPE 35 +#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 -#ifndef WARN_QW -# define WARN_QW 36 -#endif +#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL) -#ifndef WARN_RESERVED -# define WARN_RESERVED 37 +#ifdef vnewSVpvf +# undef vnewSVpvf #endif +#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b) +#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf) -#ifndef WARN_SEMICOLON -# define WARN_SEMICOLON 38 -#endif -#ifndef WARN_TAINT -# define WARN_TAINT 39 -#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 WARN_THREADS -# define WARN_THREADS 40 #endif - -#ifndef WARN_UNINITIALIZED -# define WARN_UNINITIALIZED 41 #endif -#ifndef WARN_UNPACK -# define WARN_UNPACK 42 +#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 -#ifndef WARN_UNTIE -# define WARN_UNTIE 43 +#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 -#ifndef WARN_UTF8 -# define WARN_UTF8 44 +#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 -#ifndef WARN_VOID -# define WARN_VOID 45 -#endif +#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) -#ifndef WARN_ASSERTIONS -# define WARN_ASSERTIONS 46 -#endif -#ifndef packWARN -# define packWARN(a) (a) -#endif +#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) + + +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 ckWARN -# ifdef G_WARN_ON -# define ckWARN(a) (PL_dowarn & G_WARN_ON) -# else -# define ckWARN(a) PL_dowarn -# endif +#endif #endif -#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner) -#if defined(NEED_warner) -static void DPPP_(my_warner)(U32 err, const char *pat, ...); +#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 void DPPP_(my_warner)(U32 err, const char *pat, ...); +extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); #endif -#define Perl_warner DPPP_(my_warner) +#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) + +#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_warner) || defined(NEED_warner_GLOBAL) void -DPPP_(my_warner)(U32 err, const char *pat, ...) +DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...) { - SV *sv; + dTHX; va_list args; - - PERL_UNUSED_ARG(err); - va_start(args, pat); - sv = vnewSVpvf(pat, &args); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); va_end(args); - sv_2mortal(sv); - warn("%s", SvPV_nolen(sv)); } -#define warner Perl_warner - -#define Perl_warner_nocontext Perl_warner - #endif #endif - -/* 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) +/* 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 #endif -#ifndef newSVpvs_share -# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0) +#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 -#ifndef sv_catpvs -# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) +#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 -#ifndef sv_setpvs -# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) -#endif +#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) -#ifndef hv_fetchs -# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) -#endif +#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) -#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 -#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) +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 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 +#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 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 +#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) + +#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) +#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) + + +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); +} + #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_overload -# define PERL_MAGIC_overload 'A' +/* 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 PERL_MAGIC_overload_elem -# define PERL_MAGIC_overload_elem 'a' +#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 -#ifndef PERL_MAGIC_overload_table -# define PERL_MAGIC_overload_table 'c' -#endif +/* Hint: newSVpvn_share + * The SVs created by this function only mimic the behaviour of + * shared PVs without really being shared. Only use if you know + * what you're doing. + */ -#ifndef PERL_MAGIC_bm -# define PERL_MAGIC_bm 'B' -#endif +#ifndef newSVpvn_share -#ifndef PERL_MAGIC_regdata -# define PERL_MAGIC_regdata 'D' +#if defined(NEED_newSVpvn_share) +static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); +static +#else +extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); #endif -#ifndef PERL_MAGIC_regdatum -# define PERL_MAGIC_regdatum 'd' -#endif +#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) -#ifndef PERL_MAGIC_env -# define PERL_MAGIC_env 'E' +#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) -#ifndef PERL_MAGIC_envelem -# define PERL_MAGIC_envelem 'e' -#endif -#ifndef PERL_MAGIC_fm -# define PERL_MAGIC_fm 'f' -#endif +SV * +DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash) +{ + SV *sv; + if (len < 0) + len = -len; + if (!hash) + PERL_HASH(hash, (char*) src, len); + sv = newSVpvn((char *) src, len); + sv_upgrade(sv, SVt_PVIV); + SvIVX(sv) = hash; + SvREADONLY_on(sv); + SvPOK_on(sv); + return sv; +} -#ifndef PERL_MAGIC_regex_global -# define PERL_MAGIC_regex_global 'g' #endif -#ifndef PERL_MAGIC_isa -# define PERL_MAGIC_isa 'I' #endif - -#ifndef PERL_MAGIC_isaelem -# define PERL_MAGIC_isaelem 'i' +#ifndef SvSHARED_HASH +# define SvSHARED_HASH(sv) (0 + SvUVX(sv)) #endif - -#ifndef PERL_MAGIC_nkeys -# define PERL_MAGIC_nkeys 'k' +#ifndef HvNAME_get +# define HvNAME_get(hv) HvNAME(hv) #endif - -#ifndef PERL_MAGIC_dbfile -# define PERL_MAGIC_dbfile 'L' +#ifndef HvNAMELEN_get +# define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0) #endif -#ifndef PERL_MAGIC_dbline -# define PERL_MAGIC_dbline 'l' +#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); #endif -#ifndef PERL_MAGIC_mutex -# define PERL_MAGIC_mutex 'm' -#endif +#if defined(NEED_gv_fetchpvn_flags) || defined(NEED_gv_fetchpvn_flags_GLOBAL) -#ifndef PERL_MAGIC_shared -# define PERL_MAGIC_shared 'N' +#ifdef gv_fetchpvn_flags +# undef gv_fetchpvn_flags #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) -#ifndef PERL_MAGIC_shared_scalar -# define PERL_MAGIC_shared_scalar 'n' -#endif -#ifndef PERL_MAGIC_collxfrm -# define PERL_MAGIC_collxfrm 'o' -#endif +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; +} -#ifndef PERL_MAGIC_tied -# define PERL_MAGIC_tied 'P' #endif - -#ifndef PERL_MAGIC_tiedelem -# define PERL_MAGIC_tiedelem 'p' #endif - -#ifndef PERL_MAGIC_tiedscalar -# define PERL_MAGIC_tiedscalar 'q' +#ifndef GvSVn +# define GvSVn(gv) GvSV(gv) #endif -#ifndef PERL_MAGIC_qr -# define PERL_MAGIC_qr 'r' +#ifndef isGV_with_GP +# define isGV_with_GP(gv) isGV(gv) #endif -#ifndef PERL_MAGIC_sig -# define PERL_MAGIC_sig 'S' +#ifndef gv_fetchsv +# define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt) #endif - -#ifndef PERL_MAGIC_sigelem -# define PERL_MAGIC_sigelem 's' +#ifndef get_cvn_flags +# define get_cvn_flags(name, namelen, flags) get_cv(name, flags) #endif -#ifndef PERL_MAGIC_taint -# define PERL_MAGIC_taint 't' +#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 PERL_MAGIC_uvar -# define PERL_MAGIC_uvar 'U' +/* 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 PERL_MAGIC_uvar_elem -# define PERL_MAGIC_uvar_elem 'u' +#ifndef newSVpvs +# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1) #endif -#ifndef PERL_MAGIC_vstring -# define PERL_MAGIC_vstring 'V' +#ifndef newSVpvs_flags +# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags) #endif -#ifndef PERL_MAGIC_vec -# define PERL_MAGIC_vec 'v' +#ifndef newSVpvs_share +# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0) #endif -#ifndef PERL_MAGIC_utf8 -# define PERL_MAGIC_utf8 'w' +#ifndef sv_catpvs +# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) #endif -#ifndef PERL_MAGIC_substr -# define PERL_MAGIC_substr 'x' +#ifndef sv_setpvs +# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) #endif -#ifndef PERL_MAGIC_defelem -# define PERL_MAGIC_defelem 'y' +#ifndef hv_fetchs +# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) #endif -#ifndef PERL_MAGIC_glob -# define PERL_MAGIC_glob '*' +#ifndef hv_stores +# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0) #endif - -#ifndef PERL_MAGIC_arylen -# define PERL_MAGIC_arylen '#' +#ifndef gv_fetchpvs +# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt) #endif -#ifndef PERL_MAGIC_pos -# define PERL_MAGIC_pos '.' +#ifndef gv_stashpvs +# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags) #endif - -#ifndef PERL_MAGIC_backref -# define PERL_MAGIC_backref '<' +#ifndef get_cvs +# define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags) #endif - -#ifndef PERL_MAGIC_ext -# define PERL_MAGIC_ext '~' +#ifndef SvGETMAGIC +# define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END #endif /* That's the best we can do... */ @@ -6633,10 +7351,11 @@ static extern MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl); #endif +#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL) + #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) { @@ -6667,13 +7386,14 @@ static extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); #endif +#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL) + #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) @@ -6840,13 +7560,14 @@ static 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) @@ -6957,13 +7678,14 @@ static 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) { @@ -7013,13 +7735,14 @@ static 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) { @@ -7227,13 +7950,14 @@ static 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) { @@ -7329,13 +8053,14 @@ static 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) { @@ -7431,13 +8156,14 @@ static 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) { @@ -7524,10 +8250,11 @@ static 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, ...) @@ -7558,10 +8285,11 @@ static 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, ...) @@ -7600,10 +8328,11 @@ static 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) @@ -7630,10 +8359,11 @@ static 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) @@ -7720,13 +8450,14 @@ static 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, @@ -7739,7 +8470,7 @@ 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; @@ -7749,15 +8480,15 @@ DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const 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; @@ -7829,13 +8560,14 @@ static 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, @@ -7883,13 +8615,14 @@ static 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) -- cgit v1.2.3