Sub-Name-0.26 v0.26
Karen Etheridge [Sat, 5 Oct 2019 22:23:51 +0000 (15:23 -0700)]
    - no changes since 0.25

CONTRIBUTING
Changes
INSTALL
README.pod
ppport.h

index 93e83ab..a486e89 100644 (file)
@@ -78,11 +78,18 @@ You can learn more about Dist::Zilla at http://dzil.org/.
 The code for this distribution is hosted at GitHub. The repository is:
 https://github.com/p5sagit/Sub-Name
 You can submit code changes by forking the repository, pushing your code
-changes to your clone, and then submitting a pull request. Detailed
-instructions for doing that is available here:
+changes to your clone, and then submitting a pull request. Please include a
+suitable end-user-oriented entry in the Changes file describing your change.
+Detailed instructions for doing that is available here:
 
 https://help.github.com/articles/creating-a-pull-request
 
+All pull requests for this distribution will be automatically tested on Linux
+by Travis at: https://travis-ci.com/p5sagit/Sub-Name
+Results will be visible in the pull request on GitHub. Follow the appropriate
+links for details when tests fail. Changes will not be mergeable until all
+tests pass.
+
 If you have found a bug, but do not have an accompanying patch to fix it, you
 can submit an issue report here:
 https://rt.cpan.org/Public/Dist/Display.html?Name=Sub-Name
@@ -98,5 +105,5 @@ wish to be listed under a different name or address, you should submit a pull
 request to the .mailmap file to contain the correct mapping.
 
 
-This file was generated via Dist::Zilla::Plugin::GenerateFile::FromShareDir 0.013 from a
-template file originating in Dist-Zilla-PluginBundle-Author-ETHER-0.137.
+This file was generated via Dist::Zilla::Plugin::GenerateFile::FromShareDir 0.014
+from a template file originating in Dist-Zilla-PluginBundle-Author-ETHER-0.150.
diff --git a/Changes b/Changes
index 27bdc19..6fbc399 100644 (file)
--- a/Changes
+++ b/Changes
@@ -1,6 +1,6 @@
 Revision history for Sub-Name
 
-{{$NEXT}}
+0.26      2019-10-05 22:23:12Z
     - no changes since 0.25
 
 0.25      2018-04-21 14:38:45Z (TRIAL RELEASE)
diff --git a/INSTALL b/INSTALL
index 6267cb5..8f1f9d4 100644 (file)
--- a/INSTALL
+++ b/INSTALL
@@ -22,7 +22,7 @@ Alternatively, if your CPAN shell is set up, you should just be able to do:
 ## Manual installation
 
 As a last resort, you can manually install it. Download the tarball, untar it,
-then build it:
+install configure prerequisites (see below), then build it:
 
     % perl Makefile.PL
     % make && make test
@@ -37,16 +37,36 @@ If your perl is system-managed, you can create a local::lib in your home
 directory to install modules to. For details, see the local::lib documentation:
 https://metacpan.org/pod/local::lib
 
-
 The prerequisites of this distribution will also have to be installed manually. The
 prerequisites are listed in one of the files: `MYMETA.yml` or `MYMETA.json` generated
 by running the manual build process described above.
 
+## Configure Prerequisites
+
+This distribution requires other modules to be installed before this
+distribution's installer can be run.  They can be found under the
+"configure_requires" key of META.yml or the
+"{prereqs}{configure}{requires}" key of META.json.
+
+## Other Prerequisites
+
+This distribution may require additional modules to be installed after running
+Makefile.PL.
+Look for prerequisites in the following phases:
+
+* to run make, PHASE = build
+* to use the module code itself, PHASE = runtime
+* to run tests, PHASE = test
+
+They can all be found in the "PHASE_requires" key of MYMETA.yml or the
+"{prereqs}{PHASE}{requires}" key of MYMETA.json.
+
 ## Documentation
 
 Sub-Name documentation is available as POD.
 You can run `perldoc` from a shell to read the documentation:
 
     % perldoc Sub::Name
+
 For more information on installing Perl modules via CPAN, please see:
 https://www.cpan.org/modules/INSTALL.html
index 351b48c..6746280 100644 (file)
@@ -8,7 +8,7 @@ Sub::Name - (Re)name a sub
 
 =head1 VERSION
 
-version 0.25
+version 0.26
 
 =head1 SYNOPSIS
 
@@ -85,7 +85,7 @@ Leon Timmermans <fawaka@gmail.com>
 
 =item *
 
-Reini Urban <rurban@cpanel.net>
+Reini Urban <rurban@cpan.org>
 
 =item *
 
index f8b31c5..1374707 100644 (file)
--- a/ppport.h
+++ b/ppport.h
@@ -4,9 +4,9 @@
 /*
 ----------------------------------------------------------------------
 
-    ppport.h -- Perl/Pollution/Portability Version 3.41
+    ppport.h -- Perl/Pollution/Portability Version 3.55
 
-    Automatically created by Devel::PPPort running under perl 5.027011.
+    Automatically created by Devel::PPPort running under perl 5.031004.
 
     Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
     includes in parts/inc/ instead.
@@ -21,7 +21,7 @@ SKIP
 
 =head1 NAME
 
-ppport.h - Perl/Pollution/Portability version 3.41
+ppport.h - Perl/Pollution/Portability version 3.55
 
 =head1 SYNOPSIS
 
@@ -56,7 +56,7 @@ ppport.h - Perl/Pollution/Portability version 3.41
 =head1 COMPATIBILITY
 
 This version of F<ppport.h> is designed to support operation with Perl
-installations back to 5.003, and has been tested up to 5.20.
+installations back to 5.003, and has been tested up to 5.30.
 
 =head1 OPTIONS
 
@@ -219,7 +219,6 @@ same function or variable in your project.
     -----------------------------------------------------------------------------------------
     PL_parser                 NEED_PL_parser               NEED_PL_parser_GLOBAL
     PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL
-    SvRX()                    NEED_SvRX                    NEED_SvRX_GLOBAL
     caller_cx()               NEED_caller_cx               NEED_caller_cx_GLOBAL
     croak_xs_usage()          NEED_croak_xs_usage          NEED_croak_xs_usage_GLOBAL
     die_sv()                  NEED_die_sv                  NEED_die_sv_GLOBAL
@@ -229,7 +228,6 @@ same function or variable in your project.
     grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL
     grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL
     grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL
-    gv_fetchpvn_flags()       NEED_gv_fetchpvn_flags       NEED_gv_fetchpvn_flags_GLOBAL
     load_module()             NEED_load_module             NEED_load_module_GLOBAL
     mess()                    NEED_mess                    NEED_mess_GLOBAL
     mess_nocontext()          NEED_mess_nocontext          NEED_mess_nocontext_GLOBAL
@@ -239,25 +237,20 @@ same function or variable in your project.
     my_sprintf()              NEED_my_sprintf              NEED_my_sprintf_GLOBAL
     my_strlcat()              NEED_my_strlcat              NEED_my_strlcat_GLOBAL
     my_strlcpy()              NEED_my_strlcpy              NEED_my_strlcpy_GLOBAL
+    my_strnlen()              NEED_my_strnlen              NEED_my_strnlen_GLOBAL
     newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
-    newRV_noinc()             NEED_newRV_noinc             NEED_newRV_noinc_GLOBAL
-    newSV_type()              NEED_newSV_type              NEED_newSV_type_GLOBAL
-    newSVpvn_flags()          NEED_newSVpvn_flags          NEED_newSVpvn_flags_GLOBAL
     newSVpvn_share()          NEED_newSVpvn_share          NEED_newSVpvn_share_GLOBAL
     pv_display()              NEED_pv_display              NEED_pv_display_GLOBAL
     pv_escape()               NEED_pv_escape               NEED_pv_escape_GLOBAL
     pv_pretty()               NEED_pv_pretty               NEED_pv_pretty_GLOBAL
-    sv_2pv_flags()            NEED_sv_2pv_flags            NEED_sv_2pv_flags_GLOBAL
-    sv_2pvbyte()              NEED_sv_2pvbyte              NEED_sv_2pvbyte_GLOBAL
     sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
     sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
-    sv_pvn_force_flags()      NEED_sv_pvn_force_flags      NEED_sv_pvn_force_flags_GLOBAL
     sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
     sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL
     sv_unmagicext()           NEED_sv_unmagicext           NEED_sv_unmagicext_GLOBAL
+    utf8_to_uvchr_buf()       NEED_utf8_to_uvchr_buf       NEED_utf8_to_uvchr_buf_GLOBAL
     vload_module()            NEED_vload_module            NEED_vload_module_GLOBAL
     vmess()                   NEED_vmess                   NEED_vmess_GLOBAL
-    vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL
     warner()                  NEED_warner                  NEED_warner_GLOBAL
 
 To avoid namespace conflicts, you can change the namespace of the
@@ -389,7 +382,7 @@ use strict;
 # Disable broken TRIE-optimization
 BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if "$]" >= 5.009004 && "$]" <= 5.009005 }
 
-my $VERSION = 3.41;
+my $VERSION = 3.55;
 
 my %opt = (
   quiet     => 0,
@@ -458,16 +451,9 @@ my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
                 : die "invalid spec: $_" } qw(
 AvFILLp|5.004050||p
 AvFILL|||
-BhkDISABLE||5.024000|
-BhkENABLE||5.024000|
-BhkENTRY_set||5.024000|
-BhkENTRY|||
-BhkFLAGS|||
-CALL_BLOCK_HOOKS|||
-CLASS|||n
+BOM_UTF8|||
+CLASS|||
 CPERLscope|5.005000||p
-CX_CURPAD_SAVE|||
-CX_CURPAD_SV|||
 C_ARRAY_END|5.013002||p
 C_ARRAY_LENGTH|5.008001||p
 CopFILEAV|5.006000||p
@@ -483,23 +469,22 @@ CopSTASH_set|5.006000||p
 CopSTASH|5.006000||p
 CopyD|5.009002|5.004050|p
 Copy|||
-CvPADLIST||5.008001|
 CvSTASH|||
-CvWEAKOUTSIDE|||
-DECLARATION_FOR_LC_NUMERIC_MANIPULATION||5.021010|n
+DECLARATION_FOR_LC_NUMERIC_MANIPULATION||5.021010|
 DEFSV_set|5.010001||p
 DEFSV|5.004050||p
 DO_UTF8||5.006000|
 END_EXTERN_C|5.005000||p
+ENTER_with_name|||
 ENTER|||
 ERRSV|5.004050||p
 EXTEND|||
 EXTERN_C|5.005000||p
-F0convert|||n
 FREETMPS|||
-GIMME_V||5.004000|n
-GIMME|||n
+GIMME_V||5.004000|
+GIMME|||
 GROK_NUMERIC_RADIX|5.007002||p
+GV_NOADD_MASK|||p
 G_ARRAY|||
 G_DISCARD|||
 G_EVAL|||
@@ -511,6 +496,7 @@ GetVars|||
 GvAV|||
 GvCV|||
 GvHV|||
+GvSVn|||p
 GvSV|||
 Gv_AMupdate||5.011000|
 HEf_SVKEY|5.003070||p
@@ -545,9 +531,10 @@ IS_NUMBER_NOT_INT|5.007002||p
 IVSIZE|5.006000||p
 IVTYPE|5.006000||p
 IVdf|5.006000||p
+LEAVE_with_name|||
 LEAVE|||
+LIKELY|||p
 LINKLIST||5.013006|
-LVRET|||
 MARK|||
 MULTICALL||5.024000|
 MUTABLE_PTR|5.010001||p
@@ -582,22 +569,6 @@ OpLASTSIB_set|5.021011||p
 OpMAYBESIB_set|5.021011||p
 OpMORESIB_set|5.021011||p
 OpSIBLING|5.021007||p
-PAD_BASE_SV|||
-PAD_CLONE_VARS|||
-PAD_COMPNAME_FLAGS|||
-PAD_COMPNAME_GEN_set|||
-PAD_COMPNAME_GEN|||
-PAD_COMPNAME_OURSTASH|||
-PAD_COMPNAME_PV|||
-PAD_COMPNAME_TYPE|||
-PAD_RESTORE_LOCAL|||
-PAD_SAVE_LOCAL|||
-PAD_SAVE_SETNULLPAD|||
-PAD_SETSV|||
-PAD_SET_CUR_NOSAVE|||
-PAD_SET_CUR|||
-PAD_SVl|||
-PAD_SV|||
 PERLIO_FUNCS_CAST|5.009003||p
 PERLIO_FUNCS_DECL|5.009003||p
 PERL_ABS|5.008001||p
@@ -694,25 +665,22 @@ PERL_USHORT_MAX|5.003070||p
 PERL_USHORT_MIN|5.003070||p
 PERL_VERSION|5.006000||p
 PL_DBsignal|5.005000||p
-PL_DBsingle|||pn
-PL_DBsub|||pn
-PL_DBtrace|||pn
+PL_DBsingle|||p
+PL_DBsub|||p
+PL_DBtrace|||p
 PL_Sv|5.005000||p
 PL_bufend|5.024000||p
 PL_bufptr|5.024000||p
 PL_check||5.006000|
 PL_compiling|5.004050||p
-PL_comppad_name||5.017004|
-PL_comppad||5.008001|
 PL_copline|5.024000||p
 PL_curcop|5.004050||p
-PL_curpad||5.005000|
 PL_curstash|5.004050||p
 PL_debstash|5.004050||p
 PL_defgv|5.004050||p
 PL_diehook|5.004050||p
 PL_dirty|5.004050||p
-PL_dowarn|||pn
+PL_dowarn|||p
 PL_errgv|5.004050||p
 PL_error_count|5.024000||p
 PL_expect|5.024000||p
@@ -720,48 +688,45 @@ PL_hexdigit|5.005000||p
 PL_hints|5.005000||p
 PL_in_my_stash|5.024000||p
 PL_in_my|5.024000||p
-PL_keyword_plugin||5.011002|
-PL_last_in_gv|||n
 PL_laststatval|5.005000||p
 PL_lex_state|5.024000||p
 PL_lex_stuff|5.024000||p
 PL_linestr|5.024000||p
-PL_modglobal||5.005000|n
-PL_na|5.004050||pn
+PL_modglobal||5.005000|
+PL_na|5.004050||p
 PL_no_modify|5.006000||p
-PL_ofsgv|||n
-PL_opfreehook||5.011000|n
+PL_opfreehook||5.011000|
 PL_parser|5.009005||p
-PL_peepp||5.007003|n
+PL_peepp||5.007003|
 PL_perl_destruct_level|5.004050||p
 PL_perldb|5.004050||p
 PL_ppaddr|5.006000||p
-PL_rpeepp||5.013005|n
+PL_rpeepp||5.013005|
 PL_rsfp_filters|5.024000||p
 PL_rsfp|5.024000||p
-PL_rs|||n
 PL_signals|5.008001||p
 PL_stack_base|5.004050||p
 PL_stack_sp|5.004050||p
 PL_statcache|5.005000||p
 PL_stdingv|5.004050||p
 PL_sv_arenaroot|5.004050||p
-PL_sv_no|5.004050||pn
-PL_sv_undef|5.004050||pn
-PL_sv_yes|5.004050||pn
+PL_sv_no|5.004050||p
+PL_sv_undef|5.004050||p
+PL_sv_yes|5.004050||p
+PL_sv_zero|||
 PL_tainted|5.004050||p
 PL_tainting|5.004050||p
 PL_tokenbuf|5.024000||p
 POP_MULTICALL||5.024000|
-POPi|||n
-POPl|||n
-POPn|||n
-POPpbytex||5.007001|n
-POPpx||5.005030|n
-POPp|||n
-POPs|||n
-POPul||5.006000|n
-POPu||5.004000|n
+POPi|||
+POPl|||
+POPn|||
+POPpbytex||5.007001|
+POPpx||5.005030|
+POPp|||
+POPs|||
+POPul||5.006000|
+POPu||5.004000|
 PTR2IV|5.006000||p
 PTR2NV|5.006000||p
 PTR2UV|5.006000||p
@@ -777,29 +742,6 @@ PUSHp|||
 PUSHs|||
 PUSHu|5.004000||p
 PUTBACK|||
-PadARRAY||5.024000|
-PadMAX||5.024000|
-PadlistARRAY||5.024000|
-PadlistMAX||5.024000|
-PadlistNAMESARRAY||5.024000|
-PadlistNAMESMAX||5.024000|
-PadlistNAMES||5.024000|
-PadlistREFCNT||5.017004|
-PadnameIsOUR|||
-PadnameIsSTATE|||
-PadnameLEN||5.024000|
-PadnameOURSTASH|||
-PadnameOUTER|||
-PadnamePV||5.024000|
-PadnameREFCNT_dec||5.024000|
-PadnameREFCNT||5.024000|
-PadnameSV||5.024000|
-PadnameTYPE|||
-PadnameUTF8||5.021007|
-PadnamelistARRAY||5.024000|
-PadnamelistMAX||5.024000|
-PadnamelistREFCNT_dec||5.024000|
-PadnamelistREFCNT||5.024000|
 PerlIO_clearerr||5.007003|
 PerlIO_close||5.007003|
 PerlIO_context_layers||5.009004|
@@ -813,8 +755,6 @@ PerlIO_get_bufsiz||5.007003|
 PerlIO_get_cnt||5.007003|
 PerlIO_get_ptr||5.007003|
 PerlIO_read||5.007003|
-PerlIO_restore_errno|||
-PerlIO_save_errno|||
 PerlIO_seek||5.007003|
 PerlIO_set_cnt||5.007003|
 PerlIO_set_ptrcnt||5.007003|
@@ -825,18 +765,18 @@ PerlIO_stdout||5.007003|
 PerlIO_tell||5.007003|
 PerlIO_unread||5.007003|
 PerlIO_write||5.007003|
+Perl_langinfo|||n
+Perl_setlocale|||n
 PoisonFree|5.009004||p
 PoisonNew|5.009004||p
 PoisonWith|5.009004||p
 Poison|5.008000||p
 READ_XDIGIT||5.017006|
+REPLACEMENT_CHARACTER_UTF8|||
 RESTORE_LC_NUMERIC||5.024000|
-RETVAL|||n
+RETVAL|||
 Renewc|||
 Renew|||
-SAVECLEARSV|||
-SAVECOMPPAD|||
-SAVEPADSV|||
 SAVETMPS|||
 SAVE_DEFSV|5.004050||p
 SPAGAIN|||
@@ -879,10 +819,6 @@ SVt_PVNV|||
 SVt_PV|||
 SVt_REGEXP||5.011000|
 Safefree|||
-Slab_Alloc|||
-Slab_Free|||
-Slab_to_ro|||
-Slab_to_rw|||
 StructCopy|||
 SvCUR_set|||
 SvCUR|||
@@ -931,6 +867,7 @@ SvPOK_only|||
 SvPOK_on|||
 SvPOKp|||
 SvPOK|||
+SvPVCLEAR|||
 SvPVX_const|5.009003||p
 SvPVX_mutable|5.009003||p
 SvPVX|||
@@ -968,6 +905,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
@@ -999,7 +939,6 @@ SvTAINTED_off||5.004000|
 SvTAINTED_on||5.004000|
 SvTAINTED||5.004000|
 SvTAINT|||
-SvTHINKFIRST|||
 SvTRUE_nomg||5.013006|
 SvTRUE|||
 SvTYPE|||
@@ -1017,10 +956,26 @@ SvUVx|5.004000||p
 SvUV|5.004000||p
 SvVOK||5.008001|
 SvVSTRING_mg|5.009004||p
-THIS|||n
+THIS|||
 UNDERBAR|5.009002||p
+UNICODE_REPLACEMENT|||p
+UNLIKELY|||p
 UTF8SKIP||5.006000|
+UTF8_ALLOW_ANYUV|||p
+UTF8_ALLOW_ANY|||p
+UTF8_ALLOW_CONTINUATION|||p
+UTF8_ALLOW_EMPTY|||p
+UTF8_ALLOW_LONG|||p
+UTF8_ALLOW_NON_CONTINUATION|||p
+UTF8_ALLOW_OVERFLOW|||p
+UTF8_ALLOW_SHORT|||p
+UTF8_IS_INVARIANT|||
+UTF8_IS_NONCHAR|||
+UTF8_IS_SUPER|||
+UTF8_IS_SURROGATE|||
 UTF8_MAXBYTES|5.009002||p
+UTF8_SAFE_SKIP|||p
+UVCHR_IS_INVARIANT|||
 UVCHR_SKIP||5.022000|
 UVSIZE|5.006000||p
 UVTYPE|5.006000||p
@@ -1118,51 +1073,25 @@ XopENTRY||5.024000|
 XopFLAGS||5.013007|
 ZeroD|5.009002||p
 Zero|||
+__ASSERT_|||p
 _aMY_CXT|5.007003||p
-_core_swash_init|||
-_load_PL_utf8_foldclosures|||
 _pMY_CXT|5.007003||p
-_to_fold_latin1|||
-_to_upper_title_latin1|||
-_to_utf8_case|||
+_variant_byte_number|||n
 aMY_CXT_|5.007003||p
 aMY_CXT|5.007003||p
 aTHXR_|5.024000||p
 aTHXR|5.024000||p
 aTHX_|5.006000||p
 aTHX|5.006000||p
-add_above_Latin1_folds|||
-add_data|||n
-add_multi_match|||
-add_utf16_textfilter|||
-adjust_size_and_find_bucket|||n
-advance_one_LB|||
-advance_one_SB|||
-advance_one_WB|||
-alloc_maybe_populate_EXACT|||
-allocmy|||
 amagic_call|||
-amagic_cmp_locale|||
-amagic_cmp|||
 amagic_deref_call||5.013007|
-amagic_i_ncmp|||
-amagic_is_enabled|||
-amagic_ncmp|||
-anonymise_cv_maybe|||
 any_dup|||
-ao|||
-apply_attrs_my|||
-apply_attrs|||
-apply|||
-assert_uft8_cache_coherent|||
-assignment_type|||
 atfork_lock||5.007003|n
 atfork_unlock||5.007003|n
 av_arylen_p||5.009003|
 av_clear|||
 av_delete||5.006000|
 av_exists||5.006000|
-av_extend_guts|||
 av_extend|||
 av_fetch|||
 av_fill|||
@@ -1171,28 +1100,17 @@ av_len|||
 av_make|||
 av_pop|||
 av_push|||
-av_reify|||
 av_shift|||
 av_store|||
-av_tindex||5.017009|
-av_top_index||5.017009|
+av_tindex|5.017009|5.017009|p
+av_top_index|5.017009|5.017009|p
 av_undef|||
 av_unshift|||
-ax|||n
-backup_one_LB|||
-backup_one_SB|||
-backup_one_WB|||
-bad_type_gv|||
-bad_type_pv|||
-bind_match|||
+ax|||
 block_end||5.004000|
 block_gimme||5.004000|
 block_start||5.004000|
-blockhook_register||5.013003|
 boolSV|5.004000||p
-boot_core_PerlIO|||
-boot_core_UNIVERSAL|||
-boot_core_mro|||
 bytes_cmp_utf8||5.013007|
 cBOOL|5.013000||p
 call_argv|5.006000||p
@@ -1203,88 +1121,52 @@ call_pv|5.006000||p
 call_sv|5.006000||p
 caller_cx|5.013005|5.006000|p
 calloc||5.007002|n
-cando|||
 cast_i32||5.006000|n
 cast_iv||5.006000|n
 cast_ulong||5.006000|n
 cast_uv||5.006000|n
-check_type_and_open|||
-check_uni|||
-checkcomma|||
+ckWARN2_d|||
+ckWARN2|||
+ckWARN3_d|||
+ckWARN3|||
+ckWARN4_d|||
+ckWARN4|||
+ckWARN_d|||
 ckWARN|5.006000||p
-ck_entersub_args_core|||
 ck_entersub_args_list||5.013006|
 ck_entersub_args_proto_or_list||5.013006|
 ck_entersub_args_proto||5.013006|
 ck_warner_d||5.011001|v
 ck_warner||5.011001|v
-ckwarn_common|||
 ckwarn_d||5.009003|
 ckwarn||5.009003|
 clear_defarray||5.023008|
-clear_special_blocks|||
 clone_params_del|||n
 clone_params_new|||n
-closest_cop|||
-cntrl_to_mnemonic|||n
-compute_EXACTish|||n
-construct_ahocorasick_from_trie|||
-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|
-cophh_2hv||5.013007|
-cophh_copy||5.013007|
-cophh_delete_pvn||5.013007|
-cophh_delete_pvs||5.013007|
-cophh_delete_pv||5.013007|
-cophh_delete_sv||5.013007|
-cophh_fetch_pvn||5.013007|
-cophh_fetch_pvs||5.013007|
-cophh_fetch_pv||5.013007|
-cophh_fetch_sv||5.013007|
-cophh_free||5.013007|
-cophh_new_empty||5.024000|
-cophh_store_pvn||5.013007|
-cophh_store_pvs||5.013007|
-cophh_store_pv||5.013007|
-cophh_store_sv||5.013007|
-core_prototype|||
-coresub_op|||
-cr_textfilter|||
 croak_memory_wrap|5.019003||pn
-croak_no_mem|||n
 croak_no_modify|5.013003||pn
 croak_nocontext|||pvn
-croak_popstack|||n
 croak_sv|5.013001||p
 croak_xs_usage|5.010001||pn
 croak|||v
 csighandler||5.009003|n
-current_re_engine|||
-curse|||
 custom_op_desc||5.007003|
-custom_op_get_field|||
 custom_op_name||5.007003|
 custom_op_register||5.013007|
 custom_op_xop||5.013007|
-cv_clone_into|||
 cv_clone|||
-cv_const_sv_or_av|||n
 cv_const_sv||5.003070|n
-cv_dump|||
-cv_forget_slab|||
+cv_get_call_checker_flags|||
 cv_get_call_checker||5.013006|
 cv_name||5.021005|
 cv_set_call_checker_flags||5.021004|
 cv_set_call_checker||5.013006|
-cv_undef_flags|||
 cv_undef|||
-cvgv_from_hek|||
-cvgv_set|||
-cvstash_set|||
 cx_dump||5.005000|
 cx_dup|||
 cxinc|||
@@ -1309,214 +1191,91 @@ dXCPT|5.009002||p
 dXSARGS|||
 dXSI32|||
 dXSTARG|5.006000||p
-deb_curcv|||
 deb_nocontext|||vn
-deb_stack_all|||
-deb_stack_n|||
 debop||5.005000|
 debprofdump||5.005000|
-debprof|||
 debstackptrs||5.007003|
 debstack||5.007003|
-debug_start_match|||
 deb||5.007003|v
-defelem_target|||
-del_sv|||
 delimcpy||5.004000|n
-deprecate_commaless_var_list|||
 despatch_signals||5.007001|
-destroy_matcher|||
 die_nocontext|||vn
 die_sv|5.013001||p
-die_unwind|||
 die|||v
 dirp_dup|||
-div128|||
-djSP|||
-do_aexec5|||
-do_aexec|||
 do_aspawn|||
 do_binmode||5.004050|
-do_chomp|||
 do_close|||
-do_delete_local|||
-do_dump_pad|||
-do_eof|||
-do_exec3|||
-do_execfree|||
-do_exec|||
 do_gv_dump||5.006000|
 do_gvgv_dump||5.006000|
 do_hv_dump||5.006000|
-do_ipcctl|||
-do_ipcget|||
 do_join|||
 do_magic_dump||5.006000|
-do_msgrcv|||
-do_msgsnd|||
-do_ncmp|||
-do_oddball|||
 do_op_dump||5.006000|
 do_open9||5.006000|
 do_openn||5.007001|
 do_open||5.003070|
 do_pmop_dump||5.006000|
-do_print|||
-do_readline|||
-do_seek|||
-do_semop|||
-do_shmio|||
-do_smartmatch|||
 do_spawn_nowait|||
 do_spawn|||
 do_sprintf|||
 do_sv_dump||5.006000|
-do_sysseek|||
-do_tell|||
-do_trans_complex_utf8|||
-do_trans_complex|||
-do_trans_count_utf8|||
-do_trans_count|||
-do_trans_simple_utf8|||
-do_trans_simple|||
-do_trans|||
-do_vecget|||
-do_vecset|||
-do_vop|||
-docatch|||
-doeval_compile|||
-dofile|||
-dofindlabel|||
-doform|||
 doing_taint||5.008001|n
-dooneliner|||
-doopen_pm|||
-doparseform|||
-dopoptoeval|||
-dopoptogivenfor|||
-dopoptolabel|||
-dopoptoloop|||
-dopoptosub_at|||
-dopoptowhen|||
 doref||5.009003|
 dounwind|||
 dowantarray|||
-drand48_init_r|||n
-drand48_r|||n
-dtrace_probe_call|||
-dtrace_probe_load|||
-dtrace_probe_op|||
-dtrace_probe_phase|||
-dump_all_perl|||
 dump_all||5.006000|
 dump_c_backtrace|||
 dump_eval||5.006000|
-dump_exec_pos|||
 dump_form||5.006000|
 dump_indent||5.006000|v
 dump_mstats|||
-dump_packsubs_perl|||
 dump_packsubs||5.006000|
-dump_sub_perl|||
 dump_sub||5.006000|
-dump_sv_child|||
-dump_trie_interim_list|||
-dump_trie_interim_table|||
-dump_trie|||
 dump_vindent||5.006000|
-dumpuntil|||
-dup_attrlist|||
-edit_distance|||n
 eval_pv|5.006000||p
 eval_sv|5.006000||p
-exec_failed|||
-expect_number|||
 fbm_compile||5.005000|
 fbm_instr||5.005000|
-feature_is_enabled|||
 filter_add|||
 filter_del|||
-filter_gets|||
 filter_read|||
-finalize_optree|||
-finalize_op|||
-find_and_forget_pmops|||
-find_array_subscript|||
-find_beginning|||
-find_byclass|||
-find_default_stash|||
-find_hash_subscript|||
-find_in_my_stash|||
-find_lexical_cv|||
-find_runcv_where|||
 find_runcv||5.008001|
 find_rundefsv||5.013002|
-find_script|||
-first_symbol|||n
-fixup_errno_string|||
 foldEQ_latin1||5.013008|n
 foldEQ_locale||5.013002|n
 foldEQ_utf8||5.013002|
 foldEQ||5.013002|n
-fold_constants|||
-forbid_setid|||
-force_ident_maybe_lex|||
-force_ident|||
-force_list|||
-force_next|||
-force_strict_version|||
-force_version|||
-force_word|||
-forget_pmop|||
 form_nocontext|||vn
 form||5.004000|v
 fp_dup|||
 fprintf_nocontext|||vn
-free_c_backtrace|||
 free_global_struct|||
-free_tied_hv_pool|||
 free_tmps|||
-gen_constant_list|||
-get_ANYOF_cp_list_for_ssc|||
-get_and_check_backslash_N_name|||
-get_aux_mg|||
 get_av|5.006000||p
 get_c_backtrace_dump|||
-get_c_backtrace|||
 get_context||5.006000|n
-get_cvn_flags|||
+get_cvn_flags|5.009005||p
 get_cvs|5.011000||p
 get_cv|5.006000||p
-get_db_sub|||
-get_debug_opts|||
-get_hash_seed|||
 get_hv|5.006000||p
 get_mstats|||
-get_no_modify|||
-get_num|||
 get_op_descs||5.005000|
 get_op_names||5.005000|
-get_opargs|||
 get_ppaddr||5.006000|
 get_sv|5.006000||p
 get_vtbl||5.005030|
 getcwd_sv||5.007002|
-getenv_len|||
-glob_2number|||
-glob_assign_glob|||
 gp_dup|||
 gp_free|||
 gp_ref|||
-grok_atoUV|||n
 grok_bin|5.007003||p
-grok_bslash_N|||
 grok_hex|5.007003||p
 grok_infnan||5.021004|
 grok_number_flags||5.021002|
 grok_number|5.007002||p
 grok_numeric_radix|5.007002||p
 grok_oct|5.007003||p
-group_end|||
 gv_AVadd|||
 gv_HVadd|||
 gv_IOadd|||
@@ -1535,7 +1294,6 @@ gv_efullname|||
 gv_fetchfile_flags||5.009005|
 gv_fetchfile|||
 gv_fetchmeth_autoload||5.007003|
-gv_fetchmeth_internal|||
 gv_fetchmeth_pv_autoload||5.015004|
 gv_fetchmeth_pvn_autoload||5.015004|
 gv_fetchmeth_pvn||5.015004|
@@ -1548,38 +1306,23 @@ gv_fetchmeth|||
 gv_fetchpvn_flags|5.009002||p
 gv_fetchpvs|5.009004||p
 gv_fetchpv|||
-gv_fetchsv|||
+gv_fetchsv|5.009002||p
 gv_fullname3||5.003070|
 gv_fullname4||5.006001|
 gv_fullname|||
 gv_handler||5.007001|
-gv_init_pvn|||
+gv_init_pvn|5.015004||p
 gv_init_pv||5.015004|
-gv_init_svtype|||
 gv_init_sv||5.015004|
 gv_init|||
-gv_is_in_main|||
-gv_magicalize_isa|||
-gv_magicalize|||
 gv_name_set||5.009004|
-gv_override|||
-gv_setref|||
-gv_stashpvn_internal|||
 gv_stashpvn|5.003070||p
 gv_stashpvs|5.009003||p
 gv_stashpv|||
-gv_stashsvpvn_cached|||
 gv_stashsv|||
-handle_named_backref|||
-handle_possible_posix|||
-handle_regex_sets|||
 he_dup|||
 hek_dup|||
-hfree_next_entry|||
-hsplit|||
 hv_assert|||
-hv_auxinit_internal|||n
-hv_auxinit|||
 hv_clear_placeholders||5.009001|
 hv_clear|||
 hv_common_key_len||5.010000|
@@ -1590,16 +1333,12 @@ hv_delete_ent||5.003070|
 hv_delete|||
 hv_eiter_p||5.009003|
 hv_eiter_set||5.009003|
-hv_ename_add|||
-hv_ename_delete|||
 hv_exists_ent||5.003070|
 hv_exists|||
 hv_fetch_ent||5.003070|
 hv_fetchs|5.009003||p
 hv_fetch|||
 hv_fill||5.013002|
-hv_free_ent_ret|||
-hv_free_entries|||
 hv_free_ent||5.004000|
 hv_iterinit|||
 hv_iterkeysv||5.003070|
@@ -1608,12 +1347,9 @@ hv_iternextsv|||
 hv_iternext|||
 hv_iterval|||
 hv_ksplit||5.003070|
-hv_magic_check|||n
 hv_magic|||
 hv_name_set||5.009003|
-hv_notallowed|||
 hv_placeholders_get||5.009003|
-hv_placeholders_p|||
 hv_placeholders_set||5.009003|
 hv_rand_set||5.018000|
 hv_riter_p||5.009003|
@@ -1622,94 +1358,91 @@ hv_scalar||5.009001|
 hv_store_ent||5.003070|
 hv_stores|5.009004||p
 hv_store|||
-hv_undef_flags|||
 hv_undef|||
 ibcmp_locale||5.004000|
 ibcmp_utf8||5.007003|
 ibcmp|||
-incline|||
-incpush_if_exists|||
-incpush_use_sep|||
-incpush|||
-ingroup|||
-init_argv_symbols|||
-init_constants|||
-init_dbargs|||
-init_debugger|||
 init_global_struct|||
-init_ids|||
-init_interp|||
-init_main_stash|||
-init_perllib|||
-init_postdump_symbols|||
-init_predump_symbols|||
 init_stacks||5.005000|
 init_tm||5.007002|
-inplace_aassign|||
 instr|||n
 intro_my||5.004000|
-intuit_method|||
-intuit_more|||
-invert|||
-invoke_exception_hook|||
-io_close|||
+isALNUMC_A|||p
 isALNUMC|5.006000||p
-isALPHANUMERIC||5.017008|
-isALPHA|||
+isALNUM_A|||p
+isALNUM|||p
+isALPHANUMERIC_A|||p
+isALPHANUMERIC|5.017008|5.017008|p
+isALPHA_A|||p
+isALPHA|||p
+isASCII_A|||p
 isASCII|5.006000||p
+isBLANK_A|||p
 isBLANK|5.006001||p
+isC9_STRICT_UTF8_CHAR|||n
+isCNTRL_A|||p
 isCNTRL|5.006000||p
-isDIGIT|||
-isFOO_lc|||
-isFOO_utf8_lc|||
-isGCB|||n
+isDIGIT_A|||p
+isDIGIT|||p
+isGRAPH_A|||p
 isGRAPH|5.006000||p
-isIDCONT||5.017008|
-isIDFIRST|||
-isLB|||
-isLOWER|||
-isOCTAL||5.013005|
+isGV_with_GP|||p
+isIDCONT_A|||p
+isIDCONT|5.017008|5.017008|p
+isIDFIRST_A|||p
+isIDFIRST|||p
+isLOWER_A|||p
+isLOWER|||p
+isOCTAL_A|||p
+isOCTAL|5.013005|5.013005|p
+isPRINT_A|||p
 isPRINT|5.004000||p
+isPSXSPC_A|||p
 isPSXSPC|5.006001||p
+isPUNCT_A|||p
 isPUNCT|5.006000||p
-isSB|||
-isSPACE|||
-isUPPER|||
-isUTF8_CHAR||5.021001|
-isWB|||
-isWORDCHAR||5.013006|
+isSPACE_A|||p
+isSPACE|||p
+isSTRICT_UTF8_CHAR|||n
+isUPPER_A|||p
+isUPPER|||p
+isUTF8_CHAR_flags|||
+isUTF8_CHAR||5.021001|n
+isWORDCHAR_A|||p
+isWORDCHAR|5.013006|5.013006|p
+isXDIGIT_A|||p
 isXDIGIT|5.006000||p
-is_an_int|||
-is_ascii_string||5.011000|
-is_handle_constructor|||n
+is_ascii_string||5.011000|n
+is_c9strict_utf8_string_loclen|||n
+is_c9strict_utf8_string_loc|||n
+is_c9strict_utf8_string|||n
 is_invariant_string||5.021007|n
 is_lvalue_sub||5.007001|
 is_safe_syscall||5.019004|
-is_ssc_worth_it|||n
+is_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_common|||
+is_utf8_fixed_width_buf_flags|||n
+is_utf8_fixed_width_buf_loc_flags|||n
+is_utf8_fixed_width_buf_loclen_flags|||n
+is_utf8_invariant_string_loc|||n
+is_utf8_invariant_string|||n
+is_utf8_string_flags|||n
+is_utf8_string_loc_flags|||n
+is_utf8_string_loclen_flags|||n
 is_utf8_string_loclen||5.009003|n
 is_utf8_string_loc||5.008001|n
 is_utf8_string||5.006001|n
-isa_lookup|||
-isinfnansv|||
+is_utf8_valid_partial_char_flags|||n
+is_utf8_valid_partial_char|||n
 isinfnan||5.021004|n
-items|||n
-ix|||n
-jmaybe|||
-join_exact|||
-keyword_plugin_standard|||
-keyword|||
+items|||
+ix|||
 leave_scope|||
-lex_stuff_pvs||5.013005|
-listkids|||
-list|||
 load_module_nocontext|||vn
 load_module|5.006000||pv
-localize|||
-looks_like_bool|||
 looks_like_number|||
-lop|||
 mPUSHi|5.009002||p
 mPUSHn|5.009002||p
 mPUSHp|5.009002||p
@@ -1720,84 +1453,13 @@ mXPUSHn|5.009002||p
 mXPUSHp|5.009002||p
 mXPUSHs|5.010001||p
 mXPUSHu|5.009002||p
-magic_clear_all_env|||
-magic_cleararylen_p|||
-magic_clearenv|||
-magic_clearhints|||
-magic_clearhint|||
-magic_clearisa|||
-magic_clearpack|||
-magic_clearsig|||
-magic_copycallchecker|||
 magic_dump||5.006000|
-magic_existspack|||
-magic_freearylen_p|||
-magic_freeovrld|||
-magic_getarylen|||
-magic_getdebugvar|||
-magic_getdefelem|||
-magic_getnkeys|||
-magic_getpack|||
-magic_getpos|||
-magic_getsig|||
-magic_getsubstr|||
-magic_gettaint|||
-magic_getuvar|||
-magic_getvec|||
-magic_get|||
-magic_killbackrefs|||
-magic_methcall1|||
-magic_methcall|||v
-magic_methpack|||
-magic_nextpack|||
-magic_regdata_cnt|||
-magic_regdatum_get|||
-magic_regdatum_set|||
-magic_scalarpack|||
-magic_set_all_env|||
-magic_setarylen|||
-magic_setcollxfrm|||
-magic_setdbline|||
-magic_setdebugvar|||
-magic_setdefelem|||
-magic_setenv|||
-magic_sethint|||
-magic_setisa|||
-magic_setlvref|||
-magic_setmglob|||
-magic_setnkeys|||
-magic_setpack|||
-magic_setpos|||
-magic_setregexp|||
-magic_setsig|||
-magic_setsubstr|||
-magic_settaint|||
-magic_setutf8|||
-magic_setuvar|||
-magic_setvec|||
-magic_set|||
-magic_sizepack|||
-magic_wipepack|||
-make_matcher|||
-make_trie|||
-malloc_good_size|||n
-malloced_size|||n
 malloc||5.007002|n
 markstack_grow||5.021001|
-matcher_matches_sv|||
-maybe_multimagic_gv|||
-mayberelocate|||
-measure_struct|||
 memEQs|5.009005||p
 memEQ|5.004000||p
 memNEs|5.009005||p
 memNE|5.004000||p
-mem_collxfrm|||
-mem_log_alloc|||n
-mem_log_common|||n
-mem_log_free|||n
-mem_log_realloc|||n
-mess_alloc|||
 mess_nocontext|||pvn
 mess_sv|5.013001||p
 mess|5.006000||pv
@@ -1805,63 +1467,36 @@ mfree||5.007002|n
 mg_clear|||
 mg_copy|||
 mg_dup|||
-mg_find_mglob|||
 mg_findext|5.013008||pn
 mg_find|||n
 mg_free_type||5.013006|
+mg_freeext|||
 mg_free|||
 mg_get|||
-mg_localize|||
 mg_magical|||n
 mg_set|||
 mg_size||5.005000|
 mini_mktime||5.007002|n
-minus_v|||
-missingterm|||
-mode_from_discipline|||
-modkids|||
-more_bodies|||
-more_sv|||
 moreswitches|||
-move_proto_attr|||
-mro_clean_isarev|||
-mro_gather_and_rename|||
 mro_get_from_name||5.010001|
-mro_get_linear_isa_dfs|||
 mro_get_linear_isa||5.009005|
 mro_get_private_data||5.010001|
-mro_isa_changed_in|||
-mro_meta_dup|||
-mro_meta_init|||
 mro_method_changed_in||5.009005|
-mro_package_moved|||
 mro_register||5.010001|
 mro_set_mro||5.010001|
 mro_set_private_data||5.010001|
-mul128|||
-mulexp10|||n
-multideref_stringify|||
 my_atof2||5.007002|
+my_atof3|||
 my_atof||5.006000|
-my_attrs|||
-my_bcopy||5.004050|n
-my_bytes_to_utf8|||n
-my_bzero|||n
 my_chsize|||
-my_clearenv|||
 my_cxt_index|||
 my_cxt_init|||
 my_dirfd||5.009005|n
-my_exit_jump|||
 my_exit|||
 my_failure_exit||5.004000|
 my_fflush_all||5.006000|
 my_fork||5.007003|n
-my_kid|||
-my_lstat_flags|||
 my_lstat||5.024000|
-my_memcmp|||n
-my_memset|||n
 my_pclose||5.003070|
 my_popen_list||5.007001|
 my_popen||5.003070|
@@ -1869,20 +1504,18 @@ my_setenv|||
 my_snprintf|5.009004||pvn
 my_socketpair||5.007003|n
 my_sprintf|5.009003||pvn
-my_stat_flags|||
 my_stat||5.024000|
 my_strftime||5.007002|
 my_strlcat|5.009004||pn
 my_strlcpy|5.009004||pn
-my_unexec|||
+my_strnlen|||pn
+my_strtod|||n
 my_vsnprintf||5.009004|n
-need_utf8|||n
 newANONATTRSUB||5.006000|
 newANONHASH|||
 newANONLIST|||
 newANONSUB|||
 newASSIGNOP|||
-newATTRSUB_x|||
 newATTRSUB||5.006000|
 newAVREF|||
 newAV|||
@@ -1895,7 +1528,6 @@ newDEFSVOP||5.021006|
 newFORM|||
 newFOROP||5.013007|
 newGIVENOP||5.009003|
-newGIVWHENOP|||
 newGVOP|||
 newGVREF|||
 newGVgen_flags||5.015004|
@@ -1908,7 +1540,6 @@ newLISTOP|||
 newLOGOP|||
 newLOOPEX|||
 newLOOPOP|||
-newMETHOP_internal|||
 newMETHOP_named||5.021005|
 newMETHOP||5.021005|
 newMYSUB||5.017004|
@@ -1924,16 +1555,13 @@ newRV_noinc|5.004000||p
 newRV|||
 newSLICEOP|||
 newSTATEOP|||
-newSTUB|||
 newSUB|||
 newSVOP|||
 newSVREF|||
 newSV_type|5.009005||p
-newSVavdefelem|||
 newSVhek||5.009003|
 newSViv|||
 newSVnv|||
-newSVpadname||5.017004|
 newSVpv_share||5.013006|
 newSVpvf_nocontext|||vn
 newSVpvf||5.004000|v
@@ -1946,6 +1574,8 @@ newSVpvs_share|5.009003||p
 newSVpvs|5.009003||p
 newSVpv|||
 newSVrv|||
+newSVsv_flags|||
+newSVsv_nomg|||p
 newSVsv|||
 newSVuv|5.006000||p
 newSV|||
@@ -1953,108 +1583,47 @@ newUNOP_AUX||5.021007|
 newUNOP|||
 newWHENOP||5.009003|
 newWHILEOP||5.013007|
-newXS_deffile|||
-newXS_len_flags|||
 newXSproto||5.006000|
 newXS||5.006000|
-new_constant|||
-new_he|||
-new_logop|||
 new_stackinfo||5.005000|
 new_version||5.009000|
-next_symbol|||
-nextargv|||
-nextchar|||
 ninstr|||n
-no_bareword_allowed|||
-no_fh_allowed|||
-no_op|||
-noperl_die|||vn
-not_a_number|||
-not_incrementable|||
 nothreadhook||5.008000|
-nuke_stacks|||
-num_overflow|||n
-oopsAV|||
-oopsHV|||
 op_append_elem||5.013006|
 op_append_list||5.013006|
-op_clear|||
+op_class|||
 op_contextualize||5.013006|
 op_convert_list||5.021006|
 op_dump||5.006000|
 op_free|||
-op_integerize|||
 op_linklist||5.013006|
-op_lvalue_flags|||
 op_null||5.007002|
 op_parent|||n
 op_prepend_elem||5.013006|
 op_refcnt_lock||5.009002|
 op_refcnt_unlock||5.009002|
-op_relocate_sv|||
 op_sibling_splice||5.021002|n
-op_std_init|||
-open_script|||
-openn_cleanup|||
-openn_setup|||
-opmethod_stash|||
-opslab_force_free|||
-opslab_free_nopad|||
-opslab_free|||
-output_or_return_posix_warnings|||
 pMY_CXT_|5.007003||p
 pMY_CXT|5.007003||p
 pTHX_|5.006000||p
 pTHX|5.006000||p
 packWARN|5.007003||p
 pack_cat||5.007003|
-pack_rec|||
-package_version|||
-package|||
 packlist||5.008001|
 pad_add_anon||5.008001|
 pad_add_name_pvn||5.015001|
 pad_add_name_pvs||5.015001|
 pad_add_name_pv||5.015001|
 pad_add_name_sv||5.015001|
-pad_add_weakref|||
-pad_alloc_name|||
-pad_block_start|||
-pad_check_dup|||
 pad_compname_type||5.009003|
-pad_findlex|||
 pad_findmy_pvn||5.015001|
 pad_findmy_pvs||5.015001|
 pad_findmy_pv||5.015001|
 pad_findmy_sv||5.015001|
-pad_fixup_inner_anons|||
-pad_free|||
-pad_leavemy|||
 pad_new||5.008001|
-pad_push|||
-pad_reset|||
 pad_setsv|||
 pad_sv|||
-pad_swipe|||
-padlist_dup|||
-padlist_store|||
-padname_dup|||
-padname_free|||
-padnamelist_dup|||
-padnamelist_free|||
-parse_body|||
-parse_gv_stash_name|||
-parse_ident|||
-parse_lparen_question_flags|||
-parse_subsignature|||
-parse_unicode_opts|||
 parser_dup|||
-parser_free_nexttoke_ops|||
-parser_free|||
-path_is_searchable|||n
-peep|||
-pending_ident|||
 perl_alloc_using|||n
 perl_alloc|||n
 perl_clone_using|||n
@@ -2064,150 +1633,61 @@ perl_destruct||5.007003|n
 perl_free|||n
 perl_parse||5.006000|n
 perl_run|||n
-pidgone|||
-pm_description|||
 pmop_dump||5.006000|
-pmruntime|||
-pmtrans|||
 pop_scope|||
-populate_ANYOF_from_invlist|||
-populate_isa|||v
 pregcomp||5.009005|
 pregexec|||
 pregfree2||5.011000|
 pregfree|||
 prescan_version||5.011004|
-printbuf|||
 printf_nocontext|||vn
-process_special_blocks|||
-ptr_hash|||n
 ptr_table_fetch||5.009005|
-ptr_table_find|||n
 ptr_table_free||5.009005|
 ptr_table_new||5.009005|
 ptr_table_split||5.009005|
 ptr_table_store||5.009005|
 push_scope|||
-put_charclass_bitmap_innards_common|||
-put_charclass_bitmap_innards_invlist|||
-put_charclass_bitmap_innards|||
-put_code_point|||
-put_range|||
 pv_display|5.006000||p
 pv_escape|5.009004||p
 pv_pretty|5.009004||p
 pv_uni_display||5.007003|
-qerror|||
-qsortsvu|||
 quadmath_format_needed|||n
 quadmath_format_single|||n
 re_compile||5.009005|
-re_croak2|||
 re_dup_guts|||
-re_exec_indentf|||v
-re_indentf|||v
 re_intuit_start||5.019001|
 re_intuit_string||5.006000|
-re_op_compile|||
-re_printf|||v
 realloc||5.007002|n
 reentrant_free||5.024000|
 reentrant_init||5.024000|
 reentrant_retry||5.024000|vn
 reentrant_size||5.024000|
-ref_array_or_hash|||
-refcounted_he_chain_2hv|||
-refcounted_he_fetch_pvn|||
-refcounted_he_fetch_pvs|||
-refcounted_he_fetch_pv|||
-refcounted_he_fetch_sv|||
-refcounted_he_free|||
-refcounted_he_inc|||
-refcounted_he_new_pvn|||
-refcounted_he_new_pvs|||
-refcounted_he_new_pv|||
-refcounted_he_new_sv|||
-refcounted_he_value|||
-refkids|||
-refto|||
 ref||5.024000|
-reg2Lanode|||
-reg_check_named_buff_matched|||n
 reg_named_buff_all||5.009005|
 reg_named_buff_exists||5.009005|
 reg_named_buff_fetch||5.009005|
 reg_named_buff_firstkey||5.009005|
-reg_named_buff_iter|||
 reg_named_buff_nextkey||5.009005|
 reg_named_buff_scalar||5.009005|
-reg_named_buff|||
-reg_node|||
-reg_numbered_buff_fetch|||
-reg_numbered_buff_length|||
-reg_numbered_buff_store|||
-reg_qr_package|||
-reg_recode|||
-reg_scan_name|||
-reg_skipcomment|||n
-reg_temp_copy|||
-reganode|||
-regatom|||
-regbranch|||
-regclass|||
-regcppop|||
-regcppush|||
-regcurly|||n
-regdump_extflags|||
-regdump_intflags|||
 regdump||5.005000|
 regdupe_internal|||
-regex_set_precedence|||n
 regexec_flags||5.005000|
 regfree_internal||5.009005|
-reghop3|||n
-reghop4|||n
-reghopmaybe3|||n
-reginclass|||
 reginitcolors||5.006000|
-reginsert|||
-regmatch|||
 regnext||5.005000|
-regnode_guts|||
-regpiece|||
-regprop|||
-regrepeat|||
-regtail_study|||
-regtail|||
-regtry|||
-reg|||
 repeatcpy|||n
-report_evil_fh|||
-report_redefined_cv|||
-report_uninit|||
-report_wrongway_fh|||
 require_pv||5.006000|
-require_tie_mod|||
-restore_magic|||
 rninstr|||n
-rpeep|||
-rsignal_restore|||
-rsignal_save|||
 rsignal_state||5.004000|
 rsignal||5.004000|
-run_body|||
-run_user_filter|||
 runops_debug||5.005000|
 runops_standard||5.005000|
 rv2cv_op_cv||5.013006|
 rvpv_dup|||
-rxres_free|||
-rxres_restore|||
-rxres_save|||
 safesyscalloc||5.006000|n
 safesysfree||5.006000|n
 safesysmalloc||5.006000|n
 safesysrealloc||5.006000|n
-same_dirent|||
 save_I16||5.004000|
 save_I32|||
 save_I8||5.006000|
@@ -2230,7 +1710,6 @@ save_generic_svref||5.005030|
 save_gp||5.004000|
 save_hash|||
 save_hdelete||5.011000|
-save_hek_flags|||n
 save_helem_flags||5.011000|
 save_helem||5.004050|
 save_hints||5.010001|
@@ -2238,26 +1717,21 @@ save_hptr|||
 save_int|||
 save_item|||
 save_iv||5.005000|
-save_lines|||
 save_list|||
 save_long|||
-save_magic_flags|||
 save_mortalizesv||5.007001|
 save_nogv|||
 save_op||5.005000|
 save_padsv_and_mortalize||5.010001|
 save_pptr|||
 save_pushi32ptr||5.010001|
-save_pushptri32ptr|||
 save_pushptrptr||5.010001|
 save_pushptr||5.010001|
 save_re_context||5.006000|
-save_scalar_at|||
 save_scalar|||
 save_set_svflags||5.009000|
 save_shared_pvref||5.007003|
 save_sptr|||
-save_strlen|||
 save_svref|||
 save_vptr||5.006000|
 savepvn|||
@@ -2270,72 +1744,22 @@ savesharedsvpv||5.013006|
 savestack_grow_cnt||5.008001|
 savestack_grow|||
 savesvpv||5.009002|
-sawparens|||
-scalar_mod_type|||n
-scalarboolean|||
-scalarkids|||
-scalarseq|||
-scalarvoid|||
-scalar|||
 scan_bin||5.006000|
-scan_commit|||
-scan_const|||
-scan_formline|||
-scan_heredoc|||
 scan_hex|||
-scan_ident|||
-scan_inputsymbol|||
 scan_num||5.007001|
 scan_oct|||
-scan_pat|||
-scan_str|||
-scan_subst|||
-scan_trans|||
 scan_version||5.009001|
 scan_vstring||5.009005|
-scan_word|||
-search_const|||
 seed||5.008001|
-sequence_num|||
-set_ANYOF_arg|||
-set_caret_X|||
 set_context||5.006000|n
-set_numeric_local||5.006000|
-set_numeric_radix||5.006000|
-set_numeric_standard||5.006000|
-set_padlist|||n
 setdefout|||
-share_hek_flags|||
 share_hek||5.004000|
-should_warn_nl|||n
 si_dup|||
-sighandler|||n
-simplify_sort|||
-skip_to_be_ignored_text|||
-skipspace_flags|||
-softref2xv|||
-sortcv_stacked|||
-sortcv_xsub|||
-sortcv|||
 sortsv_flags||5.009003|
 sortsv||5.007003|
-space_join_names_mortal|||
 ss_dup|||
-ssc_add_range|||
-ssc_and|||
-ssc_anything|||
-ssc_clear_locale|||n
-ssc_cp_and|||
-ssc_finalize|||
-ssc_init|||
-ssc_intersection|||
-ssc_is_anything|||n
-ssc_is_cp_posixl_init|||n
-ssc_or|||
-ssc_union|||
 stack_grow|||
 start_subparse||5.004000|
-stdize_locale|||
 strEQ|||
 strGE|||
 strGT|||
@@ -2343,20 +1767,12 @@ strLE|||
 strLT|||
 strNE|||
 str_to_version||5.006000|
-strip_return|||
 strnEQ|||
 strnNE|||
-study_chunk|||
-sub_crush_depth|||
-sublex_done|||
-sublex_push|||
-sublex_start|||
 sv_2bool_flags||5.013006|
 sv_2bool|||
 sv_2cv|||
 sv_2io|||
-sv_2iuv_common|||
-sv_2iuv_non_preserve|||
 sv_2iv_flags||5.009001|
 sv_2iv|||
 sv_2mortal|||
@@ -2370,12 +1786,8 @@ sv_2pvutf8||5.006000|
 sv_2pv|||
 sv_2uv_flags||5.009001|
 sv_2uv|5.004000||p
-sv_add_arena|||
-sv_add_backref|||
 sv_backoff|||n
 sv_bless|||
-sv_buf_to_ro|||
-sv_buf_to_rw|||
 sv_cat_decode||5.008001|
 sv_catpv_flags||5.013006|
 sv_catpv_mg|5.004050||p
@@ -2398,8 +1810,6 @@ sv_catsv_mg|5.004050||p
 sv_catsv_nomg|5.007002||p
 sv_catsv|||
 sv_chop|||
-sv_clean_all|||
-sv_clean_objs|||
 sv_clear|||
 sv_cmp_flags||5.013006|
 sv_cmp_locale_flags||5.013006|
@@ -2412,32 +1822,25 @@ sv_copypv_nomg||5.017002|
 sv_copypv|||
 sv_dec_nomg||5.013002|
 sv_dec|||
-sv_del_backref|||
 sv_derived_from_pvn||5.015004|
 sv_derived_from_pv||5.015004|
 sv_derived_from_sv||5.015004|
 sv_derived_from||5.004000|
 sv_destroyable||5.010000|
-sv_display|||
 sv_does_pvn||5.015004|
 sv_does_pv||5.015004|
 sv_does_sv||5.015004|
 sv_does||5.009004|
 sv_dump|||
-sv_dup_common|||
-sv_dup_inc_multiple|||
 sv_dup_inc|||
 sv_dup|||
 sv_eq_flags||5.013006|
 sv_eq|||
-sv_exp_grow|||
 sv_force_normal_flags||5.007001|
 sv_force_normal||5.006000|
-sv_free_arenas|||
 sv_free|||
 sv_gets||5.003070|
 sv_grow|||
-sv_i_ncmp|||
 sv_inc_nomg||5.013002|
 sv_inc|||
 sv_insert_flags||5.010001|
@@ -2445,32 +1848,23 @@ sv_insert|||
 sv_isa|||
 sv_isobject|||
 sv_iv||5.005000|
-sv_len_utf8_nomg|||
 sv_len_utf8||5.006000|
 sv_len|||
 sv_magic_portable|5.024000|5.004000|p
-sv_magicext_mglob|||
 sv_magicext||5.007003|
 sv_magic|||
 sv_mortalcopy_flags|||
 sv_mortalcopy|||
-sv_ncmp|||
 sv_newmortal|||
 sv_newref|||
 sv_nolocking||5.007003|
 sv_nosharing||5.007003|
 sv_nounlocking|||
 sv_nv||5.005000|
-sv_only_taint_gmagic|||n
-sv_or_pv_pos_u2b|||
 sv_peek||5.005000|
 sv_pos_b2u_flags||5.019003|
-sv_pos_b2u_midway|||
 sv_pos_b2u||5.006000|
-sv_pos_u2b_cached|||
 sv_pos_u2b_flags||5.011005|
-sv_pos_u2b_forwards|||n
-sv_pos_u2b_midway|||n
 sv_pos_u2b||5.006000|
 sv_pvbyten_force||5.006000|
 sv_pvbyten||5.006000|
@@ -2488,14 +1882,15 @@ sv_reftype|||
 sv_ref||5.015004|
 sv_replace|||
 sv_report_used|||
-sv_resetpvn|||
 sv_reset|||
+sv_rvunweaken|||
 sv_rvweaken||5.006000|
-sv_sethek|||
+sv_set_undef|||
 sv_setiv_mg|5.004050||p
 sv_setiv|||
 sv_setnv_mg|5.006000||p
 sv_setnv|||
+sv_setpv_bufsize|||
 sv_setpv_mg|5.004050||p
 sv_setpvf_mg_nocontext|||pvn
 sv_setpvf_mg|5.006000|5.004000|pv
@@ -2514,16 +1909,16 @@ sv_setref_pvn|||
 sv_setref_pvs||5.024000|
 sv_setref_pv|||
 sv_setref_uv||5.007001|
-sv_setsv_flags||5.007002|
+sv_setsv_flags|5.007002|5.007002|p
 sv_setsv_mg|5.004050||p
 sv_setsv_nomg|5.007002||p
 sv_setsv|||
 sv_setuv_mg|5.004050||p
 sv_setuv|5.004000||p
+sv_string_from_errnum|||
 sv_tainted||5.004000|
 sv_taint||5.004000|
 sv_true||5.005000|
-sv_unglob|||
 sv_uni_display||5.007003|
 sv_unmagicext|5.013008||p
 sv_unmagic|||
@@ -2534,6 +1929,8 @@ sv_upgrade|||
 sv_usepvn_flags||5.009004|
 sv_usepvn_mg|5.004050||p
 sv_usepvn|||
+sv_utf8_decode|||
+sv_utf8_downgrade|||
 sv_utf8_encode||5.006000|
 sv_utf8_upgrade_flags_grow||5.011000|
 sv_utf8_upgrade_flags||5.007002|
@@ -2548,9 +1945,8 @@ sv_vsetpvf_mg|5.006000|5.004000|p
 sv_vsetpvfn||5.004000|
 sv_vsetpvf|5.006000|5.004000|p
 svtype|||
-swallow_bom|||
-swatch_get|||
-sync_locale||5.021004|
+switch_to_global_locale|||n
+sync_locale||5.021004|n
 sys_init3||5.010000|n
 sys_init||5.010000|n
 sys_intern_clear|||
@@ -2559,76 +1955,50 @@ sys_intern_init|||
 sys_term||5.010000|n
 taint_env|||
 taint_proper|||
-tied_method|||v
-tmps_grow_p|||
+toFOLD_utf8_safe|||
 toFOLD_utf8||5.019001|
 toFOLD_uvchr||5.023009|
 toFOLD||5.019001|
 toLOWER_L1||5.019001|
 toLOWER_LC||5.004000|
+toLOWER_utf8_safe|||
 toLOWER_utf8||5.015007|
 toLOWER_uvchr||5.023009|
 toLOWER|||
+toTITLE_utf8_safe|||
 toTITLE_utf8||5.015007|
 toTITLE_uvchr||5.023009|
 toTITLE||5.019001|
+toUPPER_utf8_safe|||
 toUPPER_utf8||5.015007|
 toUPPER_uvchr||5.023009|
 toUPPER|||
-to_byte_substr|||
-to_lower_latin1|||n
-to_utf8_fold||5.015007|
-to_utf8_lower||5.015007|
-to_utf8_substr|||
-to_utf8_title||5.015007|
-to_utf8_upper||5.015007|
-tokenize_use|||
-tokeq|||
-tokereport|||
-too_few_arguments_pv|||
-too_many_arguments_pv|||
-translate_substr_offsets|||n
-try_amagic_bin|||
-try_amagic_un|||
-uiv_2buf|||n
 unlnk|||
-unpack_rec|||
 unpack_str||5.007003|
 unpackstring||5.008001|
-unreferenced_to_tmp_stack|||
-unshare_hek_or_pvn|||
-unshare_hek|||
 unsharepvn||5.003070|
-unwind_handler_stack|||
-update_debugger_info|||
 upg_version||5.009005|
-usage|||
-utf16_textfilter|||
-utf16_to_utf8_reversed||5.006001|
-utf16_to_utf8||5.006001|
 utf8_distance||5.006000|
+utf8_hop_back|||n
+utf8_hop_forward|||n
+utf8_hop_safe|||n
 utf8_hop||5.006000|n
 utf8_length||5.007001|
-utf8_mg_len_cache_update|||
-utf8_mg_pos_cache_update|||
-utf8_to_uvchr_buf||5.015009|
-utf8n_to_uvchr||5.007001|
+utf8_to_uvchr_buf|5.015009||p
+utf8_to_uvchr|||p
+utf8n_to_uvchr_error|||n
+utf8n_to_uvchr||5.007001|n
 utf8n_to_uvuni||5.007001|
-utilize|||
 uvchr_to_utf8_flags||5.007003|
 uvchr_to_utf8||5.007001|
 uvoffuni_to_utf8_flags||5.019004|
 uvuni_to_utf8_flags||5.007003|
 uvuni_to_utf8||5.007001|
-validate_suid|||
-varname|||
+valid_utf8_to_uvchr|||n
 vcmp||5.009000|
 vcroak||5.006000|
 vdeb||5.007003|
 vform||5.006000|
-visit|||
-vivify_defelem|||
-vivify_ref|||
 vload_module|5.006000||p
 vmess|5.006000|5.006000|p
 vnewSVpvf|5.006000|5.004000|p
@@ -2638,32 +2008,16 @@ vstringify||5.009000|
 vverify||5.009003|
 vwarner||5.006000|
 vwarn||5.006000|
-wait4pid|||
 warn_nocontext|||pvn
 warn_sv|5.013001||p
 warner_nocontext|||vn
 warner|5.006000|5.004000|pv
 warn|||v
-was_lvalue_sub|||
-watch|||
 whichsig_pvn||5.015004|
 whichsig_pv||5.015004|
 whichsig_sv||5.015004|
 whichsig|||
-win32_croak_not_implemented|||n
-with_queued_errors|||
 wrap_op_checker||5.015008|
-write_to_stderr|||
-xs_boot_epilog|||
-xs_handshake|||vn
-xs_version_bootcheck|||
-yyerror_pvn|||
-yyerror_pv|||
-yyerror|||
-yylex|||
-yyparse|||
-yyunlex|||
-yywarn|||
 );
 
 if (exists $opt{'list-unsupported'}) {
@@ -3827,136 +3181,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_sv
 #  define PERL_MAGIC_sv                  '\0'
 #endif
@@ -4140,38 +3364,21 @@ __DATA__
 #  define HEf_SVKEY                      -2
 #endif
 
-#ifndef SvRX
-#if defined(NEED_SvRX)
-static void * DPPP_(my_SvRX)(pTHX_ SV *rv);
-static
-#else
-extern void * DPPP_(my_SvRX)(pTHX_ SV *rv);
+#if defined(DEBUGGING) && !defined(__COVERITY__)
+#ifndef __ASSERT_
+#  define __ASSERT_(statement)           assert(statement),
 #endif
 
-#if defined(NEED_SvRX) || defined(NEED_SvRX_GLOBAL)
-
-#ifdef SvRX
-#  undef SvRX
+#else
+#ifndef __ASSERT_
+#  define __ASSERT_(statement)
 #endif
-#define SvRX(a) DPPP_(my_SvRX)(aTHX_ a)
-
 
-void *
-DPPP_(my_SvRX)(pTHX_ SV *rv)
-{
-       if (SvROK(rv)) {
-               SV *sv = SvRV(rv);
-               if (SvMAGICAL(sv)) {
-                       MAGIC *mg = mg_find(sv, PERL_MAGIC_qr);
-                       if (mg && mg->mg_obj) {
-                               return mg->mg_obj;
-                       }
-               }
-       }
-       return 0;
-}
 #endif
+#ifndef SvRX
+#  define SvRX(rv)                       (SvROK((rv)) ? (SvMAGICAL(SvRV((rv))) ? (mg_find(SvRV((rv)), PERL_MAGIC_qr) ? mg_find(SvRV((rv)), PERL_MAGIC_qr)->mg_obj : NULL) : NULL) : NULL)
 #endif
+
 #ifndef SvRXOK
 #  define SvRXOK(sv)                     (!!SvRX(sv))
 #endif
@@ -4334,6 +3541,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
@@ -4418,6 +3632,41 @@ typedef NVTYPE NV;
 #ifndef UTF8_MAXBYTES
 #  define UTF8_MAXBYTES                  UTF8_MAXLEN
 #endif
+#ifndef UTF8_ALLOW_ANYUV
+#  define UTF8_ALLOW_ANYUV               0
+#endif
+
+#ifndef UTF8_ALLOW_EMPTY
+#  define UTF8_ALLOW_EMPTY               0x0001
+#endif
+
+#ifndef UTF8_ALLOW_CONTINUATION
+#  define UTF8_ALLOW_CONTINUATION        0x0002
+#endif
+
+#ifndef UTF8_ALLOW_NON_CONTINUATION
+#  define UTF8_ALLOW_NON_CONTINUATION    0x0004
+#endif
+
+#ifndef UTF8_ALLOW_SHORT
+#  define UTF8_ALLOW_SHORT               0x0008
+#endif
+
+#ifndef UTF8_ALLOW_LONG
+#  define UTF8_ALLOW_LONG                0x0010
+#endif
+
+#ifndef UTF8_ALLOW_OVERFLOW
+#  define UTF8_ALLOW_OVERFLOW            0x0080
+#endif
+
+#ifndef UTF8_ALLOW_ANY
+#  define UTF8_ALLOW_ANY                 ( UTF8_ALLOW_CONTINUATION      \
+                                          |UTF8_ALLOW_NON_CONTINUATION  \
+                                          |UTF8_ALLOW_SHORT             \
+                                          |UTF8_ALLOW_LONG              \
+                                          |UTF8_ALLOW_OVERFLOW)
+#endif
 #ifndef CPERLscope
 #  define CPERLscope(x)                  x
 #endif
@@ -4455,44 +3704,136 @@ 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
@@ -4500,23 +3841,24 @@ typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
  * Devel::PPPort always overrides a present buggy version.
  */
 #  undef isPRINT
+#  undef isPRINT_A
 # endif
 
-#ifndef WIDEST_UTYPE
-# ifdef QUADKIND
-#  ifdef U64TYPE
-#   define WIDEST_UTYPE U64TYPE
-#  else
-#   define WIDEST_UTYPE Quad_t
-#  endif
-# else
-#  define WIDEST_UTYPE U32
+# if (PERL_BCDVERSION < 0x5014000)
+/* Hint: isASCII
+ * The implementation in older perl versions always returned true if the
+ * parameter was a signed char
+ */
+#  undef isASCII
+#  undef isASCII_A
 # endif
-#endif
-#ifndef isALNUMC
-#  define isALNUMC(c)                    (isALPHA(c) || isDIGIT(c))
-#endif
 
+# if (PERL_BCDVERSION < 0x5020000)
+/* Hint: isSPACE
+ * The implementation in older perl versions didn't include \v */
+#  undef isSPACE
+#  undef isSPACE_A
+# endif
 #ifndef isASCII
 #  define isASCII(c)                     ((WIDEST_UTYPE) (c) <= 127)
 #endif
@@ -4525,358 +3867,1570 @@ typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
 #  define isCNTRL(c)                     ((WIDEST_UTYPE) (c) < ' ' || (c) == 127)
 #endif
 
-#ifndef isGRAPH
-#  define isGRAPH(c)                     (isALNUM(c) || isPUNCT(c))
+#ifndef isLOWER
+#  define isLOWER(c)                     ((c) >= 'a' && (c) <= 'z')
 #endif
 
-#ifndef isPRINT
-#  define isPRINT(c)                     (((c) >= 32 && (c) < 127))
+#ifndef isUPPER
+#  define isUPPER(c)                     ((c) <= 'Z' && (c) >= 'A')
 #endif
 
-#ifndef isPUNCT
-#  define isPUNCT(c)                     (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64)  || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
+#endif /* Below are definitions common to EBCDIC and ASCII */
+#ifndef isALNUM
+#  define isALNUM(c)                     isWORDCHAR(c)
 #endif
 
-#ifndef isXDIGIT
-#  define isXDIGIT(c)                    (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
+#ifndef isALNUMC
+#  define isALNUMC(c)                    isALPHANUMERIC(c)
 #endif
 
+#ifndef isALPHA
+#  define isALPHA(c)                     (isUPPER(c) || isLOWER(c))
 #endif
 
-/* Until we figure out how to support this in older perls... */
-#if (PERL_BCDVERSION >= 0x5008000)
-#ifndef HeUTF8
-#  define HeUTF8(he)                     ((HeKLEN(he) == HEf_SVKEY) ?            \
-                                 SvUTF8(HeKEY_sv(he)) :                 \
-                                 (U32)HeKUTF8(he))
+#ifndef isALPHANUMERIC
+#  define isALPHANUMERIC(c)              (isALPHA(c) || isDIGIT(c))
 #endif
 
+#ifndef isBLANK
+#  define isBLANK(c)                     ((c) == ' ' || (c) == '\t')
 #endif
-#ifndef C_ARRAY_LENGTH
-#  define C_ARRAY_LENGTH(a)              (sizeof(a)/sizeof((a)[0]))
+
+#ifndef isDIGIT
+#  define isDIGIT(c)                     ((c) <= '9' && (c) >= '0')
 #endif
 
-#ifndef C_ARRAY_END
-#  define C_ARRAY_END(a)                 ((a) + C_ARRAY_LENGTH(a))
+#ifndef isGRAPH
+#  define isGRAPH(c)                     (isWORDCHAR(c) || isPUNCT(c))
 #endif
 
-#ifndef 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))
+#ifndef isIDCONT
+#  define isIDCONT(c)                    isWORDCHAR(c)
 #endif
+
+#ifndef isIDFIRST
+#  define isIDFIRST(c)                   (isALPHA(c) || (c) == '_')
 #endif
-#ifndef MUTABLE_SV
-#  define MUTABLE_SV(p)                  ((SV *)MUTABLE_PTR(p))
+
+#ifndef isOCTAL
+#  define isOCTAL(c)                     (((WIDEST_UTYPE)((c)) & ~7) == '0')
 #endif
 
-#ifdef NEED_mess_sv
-#define NEED_mess
+#ifndef isPRINT
+#  define isPRINT(c)                     (isGRAPH(c) || (c) == ' ')
 #endif
 
-#ifdef NEED_mess
-#define NEED_mess_nocontext
-#define NEED_vmess
+#ifndef isPSXSPC
+#  define isPSXSPC(c)                    isSPACE(c)
 #endif
 
-#ifndef croak_sv
-#if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) )
-#  if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) )
-#    define 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
-#  define croak_sv(sv) croak("%s", SvPV_nolen(sv))
+#ifndef isPUNCT
+#  define isPUNCT(c)                     (   (c) == '-' || (c) == '!' || (c) == '"'          \
+                             || (c) == '#' || (c) == '$' || (c) == '%'          \
+                             || (c) == '&' || (c) == '\'' || (c) == '('         \
+                             || (c) == ')' || (c) == '*' || (c) == '+'          \
+                             || (c) == ',' || (c) == '.' || (c) == '/'          \
+                             || (c) == ':' || (c) == ';' || (c) == '<'          \
+                             || (c) == '=' || (c) == '>' || (c) == '?'          \
+                             || (c) == '@' || (c) == '[' || (c) == '\\'         \
+                             || (c) == ']' || (c) == '^' || (c) == '_'          \
+                             || (c) == '`' || (c) == '{' || (c) == '|'          \
+                             || (c) == '}' || (c) == '~')
 #endif
+
+#ifndef isSPACE
+#  define isSPACE(c)                     (   isBLANK(c) || (c) == '\n' || (c) == '\r'    \
+                                 || (c) == '\v' || (c) == '\f')
 #endif
 
-#ifndef die_sv
-#if defined(NEED_die_sv)
-static OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
-static
-#else
-extern OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+#ifndef isWORDCHAR
+#  define isWORDCHAR(c)                  (isALPHANUMERIC(c) || (c) == '_')
 #endif
 
-#if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL)
+#ifndef isXDIGIT
+#  define isXDIGIT(c)                    (   isDIGIT(c)                                  \
+                                 || ((c) >= 'a' && (c) <= 'f')                  \
+                                 || ((c) >= 'A' && (c) <= 'F'))
+#endif
+#ifndef isALNUM_A
+#  define isALNUM_A                      isALNUM
+#endif
 
-#ifdef die_sv
-#  undef die_sv
+#ifndef isALNUMC_A
+#  define isALNUMC_A                     isALNUMC
 #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;
-}
+#ifndef isALPHA_A
+#  define isALPHA_A                      isALPHA
 #endif
+
+#ifndef isALPHANUMERIC_A
+#  define isALPHANUMERIC_A               isALPHANUMERIC
 #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))
+#ifndef isASCII_A
+#  define isASCII_A                      isASCII
 #endif
+
+#ifndef isBLANK_A
+#  define isBLANK_A                      isBLANK
 #endif
 
-#ifndef vmess
-#if defined(NEED_vmess)
-static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
-static
-#else
-extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+#ifndef isCNTRL_A
+#  define isCNTRL_A                      isCNTRL
 #endif
 
-#if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL)
+#ifndef isDIGIT_A
+#  define isDIGIT_A                      isDIGIT
+#endif
 
-#ifdef vmess
-#  undef vmess
+#ifndef isGRAPH_A
+#  define isGRAPH_A                      isGRAPH
 #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;
-}
+#ifndef isIDCONT_A
+#  define isIDCONT_A                     isIDCONT
 #endif
+
+#ifndef isIDFIRST_A
+#  define isIDFIRST_A                    isIDFIRST
 #endif
 
-#if (PERL_BCDVERSION < 0x5006000)
-#undef mess
+#ifndef isLOWER_A
+#  define isLOWER_A                      isLOWER
 #endif
 
-#if !defined(mess_nocontext) && !defined(Perl_mess_nocontext)
-#if defined(NEED_mess_nocontext)
-static SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
-static
-#else
-extern SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
+#ifndef isOCTAL_A
+#  define isOCTAL_A                      isOCTAL
 #endif
 
-#if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL)
+#ifndef isPRINT_A
+#  define isPRINT_A                      isPRINT
+#endif
 
-#define mess_nocontext DPPP_(my_mess_nocontext)
-#define Perl_mess_nocontext DPPP_(my_mess_nocontext)
+#ifndef isPSXSPC_A
+#  define isPSXSPC_A                     isPSXSPC
+#endif
 
-SV*
-DPPP_(my_mess_nocontext)(const char* pat, ...)
-{
-    dTHX;
-    SV *sv;
-    va_list args;
-    va_start(args, pat);
-    sv = vmess(pat, &args);
-    va_end(args);
-    return sv;
-}
+#ifndef isPUNCT_A
+#  define isPUNCT_A                      isPUNCT
 #endif
+
+#ifndef isSPACE_A
+#  define isSPACE_A                      isSPACE
 #endif
 
-#ifndef mess
-#if defined(NEED_mess)
-static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
-static
-#else
-extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+#ifndef isUPPER_A
+#  define isUPPER_A                      isUPPER
 #endif
 
-#if defined(NEED_mess) || defined(NEED_mess_GLOBAL)
+#ifndef isWORDCHAR_A
+#  define isWORDCHAR_A                   isWORDCHAR
+#endif
 
-#define Perl_mess DPPP_(my_mess)
+#ifndef isXDIGIT_A
+#  define isXDIGIT_A                     isXDIGIT
+#endif
 
-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
+/* 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 C_ARRAY_LENGTH
+#  define C_ARRAY_LENGTH(a)              (sizeof(a)/sizeof((a)[0]))
 #endif
 
-#ifndef mess_sv
-#if defined(NEED_mess_sv)
-static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
-static
-#else
-extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+#ifndef C_ARRAY_END
+#  define C_ARRAY_END(a)                 ((a) + C_ARRAY_LENGTH(a))
 #endif
-
-#if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL)
-
-#ifdef mess_sv
-#  undef mess_sv
+#ifndef LIKELY
+#  define LIKELY(x)                      (x)
 #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;
-}
+#ifndef UNLIKELY
+#  define UNLIKELY(x)                    (x)
 #endif
+#ifndef UNICODE_REPLACEMENT
+#  define UNICODE_REPLACEMENT            0xFFFD
 #endif
 
-#ifndef warn_nocontext
-#define warn_nocontext warn
+#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
-
-#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()
+#ifndef MUTABLE_SV
+#  define MUTABLE_SV(p)                  ((SV *)MUTABLE_PTR(p))
 #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)
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#  define vnewSVpvf(pat, args) ({ SV *_sv = newSV(0); sv_vsetpvfn(_sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)); _sv; })
 #else
-#  define croak_memory_wrap() croak_nocontext("panic: memory wrap")
+#  define vnewSVpvf(pat, args) ((PL_Sv = newSV(0)), sv_vsetpvfn(PL_Sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)), PL_Sv)
 #endif
 #endif
 
-#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);
+#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
 #else
-extern void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
+extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
 #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)
+#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
 
+#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
 
-#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)
+DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
 {
-    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);
-    }
+  va_list args;
+  va_start(args, pat);
+  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+  SvSETMAGIC(sv);
+  va_end(args);
 }
-#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
 #endif
 
-#if defined(NEED_PL_signals)
-static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
-#elif defined(NEED_PL_signals_GLOBAL)
-U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
+#ifdef PERL_IMPLICIT_CONTEXT
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
+#if defined(NEED_sv_catpvf_mg_nocontext)
+static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
+static
 #else
-extern U32 DPPP_(my_PL_signals);
+extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
 #endif
-#define PL_signals DPPP_(my_PL_signals)
 
-#endif
+#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
 
-/* Hint: PL_ppaddr
- * Calling an op via PL_ppaddr requires passing a context argument
- * for threaded builds. Since the context argument is different for
- * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
- * automatically be defined as the correct argument.
- */
+#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
+#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
 
-#if (PERL_BCDVERSION <= 0x5005005)
-/* Replace: 1 */
-#  define PL_ppaddr                 ppaddr
-#  define PL_no_modify              no_modify
-/* Replace: 0 */
-#endif
 
-#if (PERL_BCDVERSION <= 0x5004005)
-/* Replace: 1 */
-#  define PL_DBsignal               DBsignal
-#  define PL_DBsingle               DBsingle
-#  define PL_DBsub                  DBsub
+void
+DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
+{
+  dTHX;
+  va_list args;
+  va_start(args, pat);
+  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+  SvSETMAGIC(sv);
+  va_end(args);
+}
+
+#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
+#endif
+
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
+#  define sv_vcatpvf_mg(sv, pat, args)                                     \
+   STMT_START {                                                            \
+     sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
+     SvSETMAGIC(sv);                                                       \
+   } STMT_END
+#endif
+
+#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
+
+#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
+
+#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
+
+
+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
+#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, ...);
+#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
+#endif
+#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
+#endif
+
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
+#  define sv_vsetpvf_mg(sv, pat, args)                                     \
+   STMT_START {                                                            \
+     sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
+     SvSETMAGIC(sv);                                                       \
+   } STMT_END
+#endif
+
+/* Hint: 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
+
+#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)
+#ifndef sv_2pvbyte
+#  define sv_2pvbyte(sv, lp)             (sv_utf8_downgrade((sv), 0), 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
+
+#else
+
+#  define SvPVbyte          SvPV
+#  define sv_2pvbyte        sv_2pv
+
+#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
+#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_CONST_RETURN
+#  define SV_CONST_RETURN                0
+#endif
+
+#ifndef SV_MUTABLE_RETURN
+#  define SV_MUTABLE_RETURN              0
+#endif
+
+#ifndef SV_SMAGIC
+#  define SV_SMAGIC                      0
+#endif
+
+#ifndef SV_HAS_TRAILING_NUL
+#  define SV_HAS_TRAILING_NUL            0
+#endif
+
+#ifndef SV_COW_SHARED_HASH_KEYS
+#  define SV_COW_SHARED_HASH_KEYS        0
+#endif
+
+#if (PERL_BCDVERSION < 0x5007002)
+#ifndef sv_2pv_flags
+#  define sv_2pv_flags(sv, lp, flags)    sv_2pv((sv), (lp) ? (lp) : &PL_na)
+#endif
+
+#ifndef sv_pvn_force_flags
+#  define sv_pvn_force_flags(sv, lp, flags) sv_pvn_force((sv), (lp) ? (lp) : &PL_na)
+#endif
+
+#endif
+
+#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 SvPV_const
+#  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)
+#endif
+
+#ifndef SvPV_mutable
+#  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)
+#endif
+#ifndef SvPV_flags
+#  define SvPV_flags(sv, lp, flags)      \
+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                  ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
+#endif
+#ifndef SvPV_flags_const
+#  define SvPV_flags_const(sv, lp, flags) \
+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                  ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
+                  (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
+#endif
+#ifndef SvPV_flags_const_nolen
+#  define SvPV_flags_const_nolen(sv, flags) \
+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                  ? SvPVX_const(sv) : \
+                  (const char*) sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
+#endif
+#ifndef SvPV_flags_mutable
+#  define SvPV_flags_mutable(sv, lp, flags) \
+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                  ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
+                  sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
+#endif
+#ifndef SvPV_force
+#  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)
+#endif
+
+#ifndef SvPV_force_nolen
+#  define SvPV_force_nolen(sv)           SvPV_force_flags_nolen(sv, SV_GMAGIC)
+#endif
+
+#ifndef SvPV_force_mutable
+#  define SvPV_force_mutable(sv, lp)     SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
+#endif
+
+#ifndef SvPV_force_nomg
+#  define SvPV_force_nomg(sv, lp)        SvPV_force_flags(sv, lp, 0)
+#endif
+
+#ifndef SvPV_force_nomg_nolen
+#  define SvPV_force_nomg_nolen(sv)      SvPV_force_flags_nolen(sv, 0)
+#endif
+#ifndef SvPV_force_flags
+#  define SvPV_force_flags(sv, lp, flags) \
+                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
+                 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
+#endif
+#ifndef SvPV_force_flags_nolen
+#  define SvPV_force_flags_nolen(sv, flags) \
+                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
+                 ? SvPVX(sv) : sv_pvn_force_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags))
+#endif
+#ifndef SvPV_force_flags_mutable
+#  define SvPV_force_flags_mutable(sv, lp, flags) \
+                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
+                 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
+                  : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
+#endif
+#ifndef SvPV_nolen
+#  define SvPV_nolen(sv)                 \
+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                  ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
+#endif
+#ifndef SvPV_nolen_const
+#  define SvPV_nolen_const(sv)           \
+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                  ? SvPVX_const(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
+#endif
+#ifndef SvPV_nomg
+#  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)
+#endif
+
+#ifndef SvPV_nomg_const
+#  define SvPV_nomg_const(sv, lp)        SvPV_flags_const(sv, lp, 0)
+#endif
+
+#ifndef SvPV_nomg_const_nolen
+#  define SvPV_nomg_const_nolen(sv)      SvPV_flags_const_nolen(sv, 0)
+#endif
+
+#ifndef SvPV_nomg_nolen
+#  define SvPV_nomg_nolen(sv)            ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
+                                    ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, 0))
+#endif
+#ifndef SvPV_renew
+#  define SvPV_renew(sv,n)               STMT_START { SvLEN_set(sv, n); \
+                 SvPV_set((sv), (char *) saferealloc(          \
+                       (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
+               } STMT_END
+#endif
+#ifndef WARN_ALL
+#  define WARN_ALL                       0
+#endif
+
+#ifndef WARN_CLOSURE
+#  define WARN_CLOSURE                   1
+#endif
+
+#ifndef WARN_DEPRECATED
+#  define WARN_DEPRECATED                2
+#endif
+
+#ifndef WARN_EXITING
+#  define WARN_EXITING                   3
+#endif
+
+#ifndef WARN_GLOB
+#  define WARN_GLOB                      4
+#endif
+
+#ifndef WARN_IO
+#  define WARN_IO                        5
+#endif
+
+#ifndef WARN_CLOSED
+#  define WARN_CLOSED                    6
+#endif
+
+#ifndef WARN_EXEC
+#  define WARN_EXEC                      7
+#endif
+
+#ifndef WARN_LAYER
+#  define WARN_LAYER                     8
+#endif
+
+#ifndef WARN_NEWLINE
+#  define WARN_NEWLINE                   9
+#endif
+
+#ifndef WARN_PIPE
+#  define WARN_PIPE                      10
+#endif
+
+#ifndef WARN_UNOPENED
+#  define WARN_UNOPENED                  11
+#endif
+
+#ifndef WARN_MISC
+#  define WARN_MISC                      12
+#endif
+
+#ifndef WARN_NUMERIC
+#  define WARN_NUMERIC                   13
+#endif
+
+#ifndef WARN_ONCE
+#  define WARN_ONCE                      14
+#endif
+
+#ifndef WARN_OVERFLOW
+#  define WARN_OVERFLOW                  15
+#endif
+
+#ifndef WARN_PACK
+#  define WARN_PACK                      16
+#endif
+
+#ifndef WARN_PORTABLE
+#  define WARN_PORTABLE                  17
+#endif
+
+#ifndef WARN_RECURSION
+#  define WARN_RECURSION                 18
+#endif
+
+#ifndef WARN_REDEFINE
+#  define WARN_REDEFINE                  19
+#endif
+
+#ifndef WARN_REGEXP
+#  define WARN_REGEXP                    20
+#endif
+
+#ifndef WARN_SEVERE
+#  define WARN_SEVERE                    21
+#endif
+
+#ifndef WARN_DEBUGGING
+#  define WARN_DEBUGGING                 22
+#endif
+
+#ifndef WARN_INPLACE
+#  define WARN_INPLACE                   23
+#endif
+
+#ifndef WARN_INTERNAL
+#  define WARN_INTERNAL                  24
+#endif
+
+#ifndef WARN_MALLOC
+#  define WARN_MALLOC                    25
+#endif
+
+#ifndef WARN_SIGNAL
+#  define WARN_SIGNAL                    26
+#endif
+
+#ifndef WARN_SUBSTR
+#  define WARN_SUBSTR                    27
+#endif
+
+#ifndef WARN_SYNTAX
+#  define WARN_SYNTAX                    28
+#endif
+
+#ifndef WARN_AMBIGUOUS
+#  define WARN_AMBIGUOUS                 29
+#endif
+
+#ifndef WARN_BAREWORD
+#  define WARN_BAREWORD                  30
+#endif
+
+#ifndef WARN_DIGIT
+#  define WARN_DIGIT                     31
+#endif
+
+#ifndef WARN_PARENTHESIS
+#  define WARN_PARENTHESIS               32
+#endif
+
+#ifndef WARN_PRECEDENCE
+#  define WARN_PRECEDENCE                33
+#endif
+
+#ifndef WARN_PRINTF
+#  define WARN_PRINTF                    34
+#endif
+
+#ifndef WARN_PROTOTYPE
+#  define WARN_PROTOTYPE                 35
+#endif
+
+#ifndef WARN_QW
+#  define WARN_QW                        36
+#endif
+
+#ifndef WARN_RESERVED
+#  define WARN_RESERVED                  37
+#endif
+
+#ifndef WARN_SEMICOLON
+#  define WARN_SEMICOLON                 38
+#endif
+
+#ifndef WARN_TAINT
+#  define WARN_TAINT                     39
+#endif
+
+#ifndef WARN_THREADS
+#  define WARN_THREADS                   40
+#endif
+
+#ifndef WARN_UNINITIALIZED
+#  define WARN_UNINITIALIZED             41
+#endif
+
+#ifndef WARN_UNPACK
+#  define WARN_UNPACK                    42
+#endif
+
+#ifndef WARN_UNTIE
+#  define WARN_UNTIE                     43
+#endif
+
+#ifndef WARN_UTF8
+#  define WARN_UTF8                      44
+#endif
+
+#ifndef WARN_VOID
+#  define WARN_VOID                      45
+#endif
+
+#ifndef WARN_ASSERTIONS
+#  define WARN_ASSERTIONS                46
+#endif
+#ifndef packWARN
+#  define packWARN(a)                    (a)
+#endif
+
+#ifndef ckWARN
+#  ifdef G_WARN_ON
+#    define  ckWARN(a)                  (PL_dowarn & G_WARN_ON)
+#  else
+#    define  ckWARN(a)                  PL_dowarn
+#  endif
+#endif
+
+#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
+#if defined(NEED_warner)
+static void DPPP_(my_warner)(U32 err, const char *pat, ...);
+static
+#else
+extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
+#endif
+
+#if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
+
+#define Perl_warner DPPP_(my_warner)
+
+
+void
+DPPP_(my_warner)(U32 err, const char *pat, ...)
+{
+  SV *sv;
+  va_list args;
+
+  PERL_UNUSED_ARG(err);
+
+  va_start(args, pat);
+  sv = vnewSVpvf(pat, &args);
+  va_end(args);
+  sv_2mortal(sv);
+  warn("%s", SvPV_nolen(sv));
+}
+
+#define warner  Perl_warner
+
+#define Perl_warner_nocontext  Perl_warner
+
+#endif
+#endif
+
+#ifndef IVdf
+#  if IVSIZE == LONGSIZE
+#    define     IVdf      "ld"
+#    define     UVuf      "lu"
+#    define     UVof      "lo"
+#    define     UVxf      "lx"
+#    define     UVXf      "lX"
+#  elif IVSIZE == INTSIZE
+#    define   IVdf      "d"
+#    define   UVuf      "u"
+#    define   UVof      "o"
+#    define   UVxf      "x"
+#    define   UVXf      "X"
+#  else
+#    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
+
+#define D_PPP_MIN(a,b) (((a) <= (b)) ? (a) : (b))
+#ifndef sv_setuv
+#  define sv_setuv(sv, uv)               \
+               STMT_START {                         \
+                 UV TeMpUv = uv;                    \
+                 if (TeMpUv <= IV_MAX)              \
+                   sv_setiv(sv, TeMpUv);            \
+                 else                               \
+                   sv_setnv(sv, (double)TeMpUv);    \
+               } STMT_END
+#endif
+#ifndef newSVuv
+#  define newSVuv(uv)                    ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
+#endif
+
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#ifndef sv_2uv
+#  define sv_2uv(sv)                     ({ SV *_sv = (sv); (UV) (SvNOK(_sv) ? SvNV(_sv) : sv_2nv(_sv)); })
+#endif
+
+#else
+#ifndef sv_2uv
+#  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
+#endif
+
+#endif
+#ifndef SvUVX
+#  define SvUVX(sv)                      ((UV)SvIVX(sv))
+#endif
+
+#ifndef SvUVXx
+#  define SvUVXx(sv)                     SvUVX(sv)
+#endif
+
+#ifndef SvUV
+#  define SvUV(sv)                       (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
+#endif
+
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#ifndef SvUVx
+#  define SvUVx(sv)                      ({ SV *_sv = (sv)); SvUV(_sv); })
+#endif
+
+#else
+#ifndef SvUVx
+#  define SvUVx(sv)                      ((PL_Sv = (sv)), SvUV(PL_Sv))
+#endif
+
+#endif
+
+/* Hint: sv_uv
+ * Always use the SvUVx() macro instead of sv_uv().
+ */
+#ifndef sv_uv
+#  define sv_uv(sv)                      SvUVx(sv)
+#endif
+
+#if !defined(SvUOK) && defined(SvIOK_UV)
+#  define SvUOK(sv) SvIOK_UV(sv)
+#endif
+#ifndef XST_mUV
+#  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )
+#endif
+
+#ifndef XSRETURN_UV
+#  define XSRETURN_UV(v)                 STMT_START { XST_mUV(0,v);  XSRETURN(1); } STMT_END
+#endif
+#ifndef PUSHu
+#  define PUSHu(u)                       STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG;  } STMT_END
+#endif
+
+#ifndef XPUSHu
+#  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
+#endif
+
+#if defined UTF8SKIP
+
+/* Don't use official version because it uses MIN, which may not be available */
+#undef UTF8_SAFE_SKIP
+#ifndef UTF8_SAFE_SKIP
+#  define UTF8_SAFE_SKIP(s, e)           (                                          \
+                                      ((((e) - (s)) <= 0)                       \
+                                      ? 0                                       \
+                                      : D_PPP_MIN(((e) - (s)), UTF8SKIP(s))))
+#endif
+
+#endif
+
+#if !defined(my_strnlen)
+#if defined(NEED_my_strnlen)
+static STRLEN DPPP_(my_my_strnlen)(const char *str, Size_t maxlen);
+static
+#else
+extern STRLEN DPPP_(my_my_strnlen)(const char *str, Size_t maxlen);
+#endif
+
+#if defined(NEED_my_strnlen) || defined(NEED_my_strnlen_GLOBAL)
+
+#define my_strnlen DPPP_(my_my_strnlen)
+#define Perl_my_strnlen DPPP_(my_my_strnlen)
+
+
+STRLEN
+DPPP_(my_my_strnlen)(const char *str, Size_t maxlen)
+{
+    const char *p = str;
+
+    while(maxlen-- && *p)
+        p++;
+
+    return p - str;
+}
+
+#endif
+#endif
+
+#if (PERL_BCDVERSION < 0x5031004)
+        /* Versions prior to this accepted things that are now considered
+         * malformations, and didn't return -1 on error with warnings enabled
+         * */
+#  undef utf8_to_uvchr_buf
+#endif
+
+/* This implementation brings modern, generally more restricted standards to
+ * utf8_to_uvchr_buf.  Some of these are security related, and clearly must
+ * be done.  But its arguable that the others need not, and hence should not.
+ * The reason they're here is that a module that intends to play with the
+ * latest perls should be able to work the same in all releases.  An example is
+ * that perl no longer accepts any UV for a code point, but limits them to
+ * IV_MAX or below.  This is for future internal use of the larger code points.
+ * If it turns out that some of these changes are breaking code that isn't
+ * intended to work with modern perls, the tighter restrictions could be
+ * relaxed.  khw thinks this is unlikely, but has been wrong in the past. */
+
+/* 5.6.0 is the first release with UTF-8, and we don't implement this function
+ * there due to its likely lack of still being in use, and the underlying
+ * implementation is very different from later ones, without the later
+ * safeguards, so would require extra work to deal with */
+#if (PERL_BCDVERSION >= 0x5006001) && ! defined(utf8_to_uvchr_buf)
+   /* Choose which underlying implementation to use.  At least one must be
+    * present or the perl is too early to handle this function */
+#  if defined(utf8n_to_uvchr) || defined(utf8_to_uv)
+#    if defined(utf8n_to_uvchr)   /* This is the preferred implementation */
+#      define D_PPP_utf8_to_uvchr_buf_callee utf8n_to_uvchr
+#    else     /* Must be at least 5.6.1 from #if above */
+#      define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags) utf8_to_uv((U8 *)(s), (curlen), (retlen), (flags))
+#    endif
+#  endif
+
+#  if defined(NEED_utf8_to_uvchr_buf)
+static UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen);
+static
+#else
+extern UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen);
+#endif
+
+#if defined(NEED_utf8_to_uvchr_buf) || defined(NEED_utf8_to_uvchr_buf_GLOBAL)
+
+#ifdef utf8_to_uvchr_buf
+#  undef utf8_to_uvchr_buf
+#endif
+#define utf8_to_uvchr_buf(a,b,c) DPPP_(my_utf8_to_uvchr_buf)(aTHX_ a,b,c)
+#define Perl_utf8_to_uvchr_buf DPPP_(my_utf8_to_uvchr_buf)
+
+
+UV
+DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
+{
+    UV ret;
+    STRLEN curlen;
+    bool overflows = 0;
+    const U8 *cur_s = s;
+    const bool do_warnings = ckWARN_d(WARN_UTF8);
+#    if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC)
+    STRLEN overflow_length = 0;
+#    endif
+
+    if (send > s) {
+        curlen = send - s;
+    }
+    else {
+        assert(0);  /* Modern perls die under this circumstance */
+        curlen = 0;
+        if (! do_warnings) {    /* Handle empty here if no warnings needed */
+            if (retlen) *retlen = 0;
+            return UNICODE_REPLACEMENT;
+        }
+    }
+
+#    if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC)
+
+    /* Perl did not properly detect overflow for much of its history on
+     * non-EBCDIC platforms, often returning an overlong value which may or may
+     * not have been tolerated in the call.  Also, earlier versions, when they
+     * did detect overflow, may have disallowed it completely.  Modern ones can
+     * replace it with the REPLACEMENT CHARACTER, depending on calling
+     * parameters.  Therefore detect it ourselves in  releases it was
+     * problematic in. */
+
+    if (curlen > 0 && UNLIKELY(*s >= 0xFE)) {
+
+        /* First, on a 32-bit machine the first byte being at least \xFE
+         * automatically is overflow, as it indicates something requiring more
+         * than 31 bits */
+        if (sizeof(ret) < 8) {
+            overflows = 1;
+            overflow_length = 7;
+        }
+        else {
+            const U8 highest[] =    /* 2*63-1 */
+                        "\xFF\x80\x87\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF";
+            const U8 *cur_h = highest;
+
+            for (cur_s = s; cur_s < send; cur_s++, cur_h++) {
+                if (UNLIKELY(*cur_s == *cur_h)) {
+                    continue;
+                }
+
+                /* If this byte is larger than the corresponding highest UTF-8
+                 * byte, the sequence overflows; otherwise the byte is less
+                 * than (as we handled the equality case above), and so the
+                 * sequence doesn't overflow */
+                overflows = *cur_s > *cur_h;
+                break;
+
+            }
+
+            /* Here, either we set the bool and broke out of the loop, or got
+             * to the end and all bytes are the same which indicates it doesn't
+             * overflow.  If it did overflow, it would be this number of bytes
+             * */
+            overflow_length = 13;
+        }
+    }
+
+    if (UNLIKELY(overflows)) {
+        ret = 0;
+
+        if (! do_warnings && retlen) {
+            *retlen = overflow_length;
+        }
+    }
+    else
+
+#    endif  /* < 5.26 */
+
+        /* Here, we are either in a release that properly detects overflow, or
+         * we have checked for overflow and the next statement is executing as
+         * part of the above conditional where we know we don't have overflow.
+         *
+         * The modern versions allow anything that evaluates to a legal UV, but
+         * not overlongs nor an empty input */
+        ret = D_PPP_utf8_to_uvchr_buf_callee(
+                s, curlen, retlen,   (UTF8_ALLOW_ANYUV
+                                  & ~(UTF8_ALLOW_LONG|UTF8_ALLOW_EMPTY)));
+
+#    if (PERL_BCDVERSION >= 0x5026000) && (PERL_BCDVERSION < 0x5028000)
+
+    /* But actually, more modern versions restrict the UV to being no more than
+     * what * an IV can hold, so it could, so it could still have gotten it
+     * wrong about overflowing. */
+    if (UNLIKELY(ret > IV_MAX)) {
+        overflows = 1;
+    }
+
+#    endif
+
+    if (UNLIKELY(overflows)) {
+        if (! do_warnings) {
+            if (retlen) {
+                *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s));
+                *retlen = D_PPP_MIN(*retlen, curlen);
+            }
+            return UNICODE_REPLACEMENT;
+        }
+        else {
+
+            /* We use the error message in use from 5.8-5.26 */
+            Perl_warner(aTHX_ packWARN(WARN_UTF8),
+                "Malformed UTF-8 character (overflow at 0x%" UVxf
+                ", byte 0x%02x, after start byte 0x%02x)",
+                ret, *cur_s, *s);
+            if (retlen) {
+                *retlen = (STRLEN) -1;
+            }
+            return 0;
+        }
+    }
+
+    /* Here, did not overflow, but if it failed for some other reason, and
+     * warnings are off, to emulate the behavior of the real utf8_to_uvchr(),
+     * try again, allowing anything.  (Note a return of 0 is ok if the input
+     * was '\0') */
+    if (UNLIKELY(ret == 0 && (curlen == 0 || *s != '\0'))) {
+
+        /* If curlen is 0, we already handled the case where warnings are
+         * disabled, so this 'if' will be true, and so later on, we know that
+         * 's' is dereferencible */
+        if (do_warnings) {
+            *retlen = (STRLEN) -1;
+        }
+        else {
+            ret = D_PPP_utf8_to_uvchr_buf_callee(
+                                            s, curlen, retlen, UTF8_ALLOW_ANY);
+            /* Override with the REPLACEMENT character, as that is what the
+             * modern version of this function returns */
+            ret = UNICODE_REPLACEMENT;
+
+#    if (PERL_BCDVERSION < 0x5016000)
+
+            /* Versions earlier than this don't necessarily return the proper
+             * length.  It should not extend past the end of string, nor past
+             * what the first byte indicates the length is, nor past the
+             * continuation characters */
+            if (retlen && *retlen >= 0) {
+                unsigned int i = 1;
+
+                *retlen = D_PPP_MIN(*retlen, curlen);
+                *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s));
+                do {
+                    if (s[i] < 0x80 || s[i] > 0xBF) {
+                        *retlen = i;
+                        break;
+                    }
+                } while (++i < *retlen);
+            }
+
+#    endif
+
+        }
+    }
+
+    return ret;
+}
+
+#  endif
+#endif
+
+#if defined(UTF8SKIP) && defined(utf8_to_uvchr_buf)
+#undef utf8_to_uvchr /* Always redefine this unsafe function so that it refuses
+                        to read past a NUL, making it much less likely to read
+                        off the end of the buffer.  A NUL indicates the start
+                        of the next character anyway.  If the input isn't
+                        NUL-terminated, the function remains unsafe, as it
+                        always has been. */
+#ifndef utf8_to_uvchr
+#  define utf8_to_uvchr(s, lp)           \
+    ((*(s) == '\0')                                                             \
+    ? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */        \
+    : utf8_to_uvchr_buf(s, (s) + my_strnlen((char *) (s), UTF8SKIP(s)), (lp)))
+#endif
+
+#endif
+
+#ifdef HAS_MEMCMP
+#ifndef memNE
+#  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))
+#endif
+
+#ifndef memEQ
+#  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))
+#endif
+
+#else
+#ifndef memNE
+#  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))
+#endif
+
+#ifndef memEQ
+#  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))
+#endif
+
+#endif
+#ifndef memEQs
+#  define memEQs(s1, l, s2)              \
+                   (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1)))
+#endif
+
+#ifndef memNEs
+#  define memNEs(s1, l, s2)              !memEQs(s1, l, s2)
+#endif
+#ifndef MoveD
+#  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))
+#endif
+
+#ifndef CopyD
+#  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
+#endif
+
+#ifdef HAS_MEMSET
+#ifndef ZeroD
+#  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))
+#endif
+
+#else
+#ifndef ZeroD
+#  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)), d)
+#endif
+
+#endif
+#ifndef PoisonWith
+#  define PoisonWith(d,n,t,b)            (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
+#endif
+
+#ifndef PoisonNew
+#  define PoisonNew(d,n,t)               PoisonWith(d,n,t,0xAB)
+#endif
+
+#ifndef PoisonFree
+#  define PoisonFree(d,n,t)              PoisonWith(d,n,t,0xEF)
+#endif
+
+#ifndef Poison
+#  define Poison(d,n,t)                  PoisonFree(d,n,t)
+#endif
+#ifndef Newx
+#  define Newx(v,n,t)                    New(0,v,n,t)
+#endif
+
+#ifndef Newxc
+#  define Newxc(v,n,t,c)                 Newc(0,v,n,t,c)
+#endif
+
+#ifndef Newxz
+#  define Newxz(v,n,t)                   Newz(0,v,n,t)
+#endif
+
+#ifdef NEED_mess_sv
+#define NEED_mess
+#endif
+
+#ifdef NEED_mess
+#define NEED_mess_nocontext
+#define NEED_vmess
+#endif
+
+#ifndef croak_sv
+#if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) )
+#  if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) )
+#    define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv)                    \
+        STMT_START {                                           \
+            SV *_errsv = ERRSV;                                \
+            SvFLAGS(_errsv) = (SvFLAGS(_errsv) & ~SVf_UTF8) |  \
+                              (SvFLAGS(sv) & SVf_UTF8);        \
+        } STMT_END
+#  else
+#    define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) STMT_START {} STMT_END
+#  endif
+#  define croak_sv(sv)                         \
+    STMT_START {                               \
+        SV *_sv = (sv);                        \
+        if (SvROK(_sv)) {                      \
+            sv_setsv(ERRSV, _sv);              \
+            croak(NULL);                       \
+        } else {                               \
+            D_PPP_FIX_UTF8_ERRSV_FOR_SV(_sv);  \
+            croak("%" SVf, SVfARG(_sv));       \
+        }                                      \
+    } STMT_END
+#elif (PERL_BCDVERSION >= 0x5004000)
+#  define croak_sv(sv) croak("%" SVf, SVfARG(sv))
+#else
+#  define croak_sv(sv) croak("%s", SvPV_nolen(sv))
+#endif
+#endif
+
+#ifndef die_sv
+#if defined(NEED_die_sv)
+static OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+static
+#else
+extern OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+#endif
+
+#if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL)
+
+#ifdef die_sv
+#  undef die_sv
+#endif
+#define die_sv(a) DPPP_(my_die_sv)(aTHX_ a)
+#define Perl_die_sv DPPP_(my_die_sv)
+
+OP *
+DPPP_(my_die_sv)(pTHX_ SV *sv)
+{
+    croak_sv(sv);
+    return (OP *)NULL;
+}
+#endif
+#endif
+
+#ifndef warn_sv
+#if (PERL_BCDVERSION >= 0x5004000)
+#  define warn_sv(sv) warn("%" SVf, SVfARG(sv))
+#else
+#  define warn_sv(sv) warn("%s", SvPV_nolen(sv))
+#endif
+#endif
+
+#ifndef vmess
+#if defined(NEED_vmess)
+static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+static
+#else
+extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+#endif
+
+#if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL)
+
+#ifdef vmess
+#  undef vmess
+#endif
+#define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b)
+#define Perl_vmess DPPP_(my_vmess)
+
+SV*
+DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args)
+{
+    mess(pat, args);
+    return PL_mess_sv;
+}
+#endif
+#endif
+
+#if (PERL_BCDVERSION < 0x5006000)
+#undef mess
+#endif
+
+#if !defined(mess_nocontext) && !defined(Perl_mess_nocontext)
+#if defined(NEED_mess_nocontext)
+static SV* DPPP_(my_mess_nocontext)(const char* pat, ...);
+static
+#else
+extern SV* DPPP_(my_mess_nocontext)(const char* pat, ...);
+#endif
+
+#if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL)
+
+#define mess_nocontext DPPP_(my_mess_nocontext)
+#define Perl_mess_nocontext DPPP_(my_mess_nocontext)
+
+SV*
+DPPP_(my_mess_nocontext)(const char* pat, ...)
+{
+    dTHX;
+    SV *sv;
+    va_list args;
+    va_start(args, pat);
+    sv = vmess(pat, &args);
+    va_end(args);
+    return sv;
+}
+#endif
+#endif
+
+#ifndef mess
+#if defined(NEED_mess)
+static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+static
+#else
+extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+#endif
+
+#if defined(NEED_mess) || defined(NEED_mess_GLOBAL)
+
+#define Perl_mess DPPP_(my_mess)
+
+SV*
+DPPP_(my_mess)(pTHX_ const char* pat, ...)
+{
+    SV *sv;
+    va_list args;
+    va_start(args, pat);
+    sv = vmess(pat, &args);
+    va_end(args);
+    return sv;
+}
+#ifdef mess_nocontext
+#define mess mess_nocontext
+#else
+#define mess Perl_mess_nocontext
+#endif
+#endif
+#endif
+
+#ifndef mess_sv
+#if defined(NEED_mess_sv)
+static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+static
+#else
+extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+#endif
+
+#if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL)
+
+#ifdef mess_sv
+#  undef mess_sv
+#endif
+#define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b)
+#define Perl_mess_sv DPPP_(my_mess_sv)
+
+SV *
+DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume)
+{
+    SV *tmp;
+    SV *ret;
+
+    if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') {
+        if (consume)
+            return basemsg;
+        ret = mess("");
+        SvSetSV_nosteal(ret, basemsg);
+        return ret;
+    }
+
+    if (consume) {
+        sv_catsv(basemsg, mess(""));
+        return basemsg;
+    }
+
+    ret = mess("");
+    tmp = newSVsv(ret);
+    SvSetSV_nosteal(ret, basemsg);
+    sv_catsv(ret, tmp);
+    sv_dec(tmp);
+    return ret;
+}
+#endif
+#endif
+
+#ifndef warn_nocontext
+#define warn_nocontext warn
+#endif
+
+#ifndef croak_nocontext
+#define croak_nocontext croak
+#endif
+
+#ifndef croak_no_modify
+#define croak_no_modify() croak_nocontext("%s", PL_no_modify)
+#define Perl_croak_no_modify() croak_no_modify()
+#endif
+
+#ifndef croak_memory_wrap
+#if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) )
+#  define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap)
+#else
+#  define croak_memory_wrap() croak_nocontext("panic: memory wrap")
+#endif
+#endif
+
+#ifndef croak_xs_usage
+#if defined(NEED_croak_xs_usage)
+static void DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params);
+static
+#else
+extern void DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params);
+#endif
+
+#if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL)
+
+#define croak_xs_usage DPPP_(my_croak_xs_usage)
+#define Perl_croak_xs_usage DPPP_(my_croak_xs_usage)
+
+
+#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
+#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)
+#endif
+
+void
+DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params)
+{
+    dTHX;
+    const GV *const gv = CvGV(cv);
+
+    PERL_ARGS_ASSERT_CROAK_XS_USAGE;
+
+    if (gv) {
+        const char *const gvname = GvNAME(gv);
+        const HV *const stash = GvSTASH(gv);
+        const char *const hvname = stash ? HvNAME(stash) : NULL;
+
+        if (hvname)
+            croak("Usage: %s::%s(%s)", hvname, gvname, params);
+        else
+            croak("Usage: %s(%s)", gvname, params);
+    } else {
+        /* Pants. I don't think that it should be possible to get here. */
+        croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
+    }
+}
+#endif
+#endif
+
+#ifndef PERL_SIGNALS_UNSAFE_FLAG
+
+#define PERL_SIGNALS_UNSAFE_FLAG 0x0001
+
+#if (PERL_BCDVERSION < 0x5008000)
+#  define D_PPP_PERL_SIGNALS_INIT   PERL_SIGNALS_UNSAFE_FLAG
+#else
+#  define D_PPP_PERL_SIGNALS_INIT   0
+#endif
+
+#if defined(NEED_PL_signals)
+static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
+#elif defined(NEED_PL_signals_GLOBAL)
+U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
+#else
+extern U32 DPPP_(my_PL_signals);
+#endif
+#define PL_signals DPPP_(my_PL_signals)
+
+#endif
+
+/* Hint: PL_ppaddr
+ * Calling an op via PL_ppaddr requires passing a context argument
+ * for threaded builds. Since the context argument is different for
+ * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
+ * automatically be defined as the correct argument.
+ */
+
+#if (PERL_BCDVERSION <= 0x5005005)
+/* Replace: 1 */
+#  define PL_ppaddr                 ppaddr
+#  define PL_no_modify              no_modify
+/* Replace: 0 */
+#endif
+
+#if (PERL_BCDVERSION <= 0x5004005)
+/* Replace: 1 */
+#  define PL_DBsignal               DBsignal
+#  define PL_DBsingle               DBsingle
+#  define PL_DBsub                  DBsub
 #  define PL_DBtrace                DBtrace
 #  define PL_Sv                     Sv
 #  define PL_bufend                 bufend
@@ -5106,6 +5660,7 @@ SV*
 DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
 {
     dSP;
+    SV* errsv;
     SV* sv = newSVpv(p, 0);
 
     PUSHMARK(sp);
@@ -5116,8 +5671,11 @@ DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
     sv = POPs;
     PUTBACK;
 
-    if (croak_on_error && SvTRUEx(ERRSV))
-        croak_sv(ERRSV);
+    if (croak_on_error) {
+        errsv = ERRSV;
+        if (SvTRUE(errsv))
+            croak_sv(errsv);
+    }
 
     return sv;
 }
@@ -5234,28 +5792,10 @@ DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
 #endif
 
 #ifndef newRV_noinc
-#if defined(NEED_newRV_noinc)
-static SV * DPPP_(my_newRV_noinc)(SV *sv);
-static
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#  define newRV_noinc(sv) ({ SV *_sv = (SV *)newRV((sv)); SvREFCNT_dec((sv)); _sv; })
 #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;
-}
+#  define newRV_noinc(sv) ((PL_Sv = (SV *)newRV((sv))), SvREFCNT_dec((sv)), PL_Sv)
 #endif
 #endif
 
@@ -5415,47 +5955,15 @@ DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
 #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
+#define aMY_CXT_
+#define _aMY_CXT
+
+#endif /* START_MY_CXT */
+
+#ifndef MY_CXT_CLONE
+#define MY_CXT_CLONE    NOOP
+#endif
+
 #endif
 
 #ifndef SvREFCNT_inc
@@ -5505,383 +6013,85 @@ DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
 #  ifdef PERL_USE_GCC_BRACE_GROUPS
 #    define SvREFCNT_inc_void(sv)               \
       ({                                        \
-          SV * const _sv = (SV*)(sv);   \
-          if (_sv)                      \
-              (void)(SvREFCNT(_sv)++);  \
-      })
-#  else
-#    define SvREFCNT_inc_void(sv) \
-          (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
-#  endif
-#endif
-#ifndef SvREFCNT_inc_simple_void
-#  define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
-#endif
-
-#ifndef SvREFCNT_inc_simple_NN
-#  define SvREFCNT_inc_simple_NN(sv)     (++SvREFCNT(sv), (SV*)(sv))
-#endif
-
-#ifndef SvREFCNT_inc_void_NN
-#  define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT((SV*)(sv)))
-#endif
-
-#ifndef SvREFCNT_inc_simple_void_NN
-#  define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
-#endif
-
-#ifndef newSV_type
-
-#if defined(NEED_newSV_type)
-static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
-static
-#else
-extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
-#endif
-
-#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)
-
-#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)
-
-
-SV*
-DPPP_(my_newSV_type)(pTHX_ svtype const t)
-{
-  SV* const sv = newSV(0);
-  sv_upgrade(sv, t);
-  return sv;
-}
-
-#endif
-
-#endif
-
-#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
-#endif
-
-#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 SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
-#endif
-
-#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_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)
-
-
-SV *
-DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
-{
-  SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len);
-  SvFLAGS(sv) |= (flags & SVf_UTF8);
-  return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
-}
-
-#endif
-
-#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
-
-/* 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
-
-#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 char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
-#endif
-
-#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_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)
-
-
-char *
-DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
-{
-  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
-
-#else
-
-#  define SvPVbyte          SvPV
-#  define sv_2pvbyte        sv_2pv
-
-#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
-#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
-
-#ifndef SV_SMAGIC
-#  define SV_SMAGIC                      0
-#endif
-
-#ifndef SV_HAS_TRAILING_NUL
-#  define SV_HAS_TRAILING_NUL            0
-#endif
-
-#ifndef SV_COW_SHARED_HASH_KEYS
-#  define SV_COW_SHARED_HASH_KEYS        0
-#endif
-
-#if (PERL_BCDVERSION < 0x5007002)
-
-#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);
-#endif
-
-#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
-
-#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)
-
-
-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);
-}
-
-#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);
-#endif
-
-#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 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)
-
-
-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
-
-#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 SvPV_const
-#  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)
-#endif
-
-#ifndef SvPV_mutable
-#  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)
-#endif
-#ifndef SvPV_flags
-#  define SvPV_flags(sv, lp, flags)      \
-                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-                  ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
-#endif
-#ifndef SvPV_flags_const
-#  define SvPV_flags_const(sv, lp, flags) \
-                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-                  ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
-                  (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
-#endif
-#ifndef SvPV_flags_const_nolen
-#  define SvPV_flags_const_nolen(sv, flags) \
-                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-                  ? SvPVX_const(sv) : \
-                  (const char*) sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
-#endif
-#ifndef SvPV_flags_mutable
-#  define SvPV_flags_mutable(sv, lp, flags) \
-                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-                  ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
-                  sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
+          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 SvPV_force
-#  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)
+#ifndef SvREFCNT_inc_simple_void
+#  define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
 #endif
 
-#ifndef SvPV_force_nolen
-#  define SvPV_force_nolen(sv)           SvPV_force_flags_nolen(sv, SV_GMAGIC)
+#ifndef SvREFCNT_inc_simple_NN
+#  define SvREFCNT_inc_simple_NN(sv)     (++SvREFCNT(sv), (SV*)(sv))
 #endif
 
-#ifndef SvPV_force_mutable
-#  define SvPV_force_mutable(sv, lp)     SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
+#ifndef SvREFCNT_inc_void_NN
+#  define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT((SV*)(sv)))
 #endif
 
-#ifndef SvPV_force_nomg
-#  define SvPV_force_nomg(sv, lp)        SvPV_force_flags(sv, lp, 0)
+#ifndef SvREFCNT_inc_simple_void_NN
+#  define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
 #endif
 
-#ifndef SvPV_force_nomg_nolen
-#  define SvPV_force_nomg_nolen(sv)      SvPV_force_flags_nolen(sv, 0)
-#endif
-#ifndef SvPV_force_flags
-#  define SvPV_force_flags(sv, lp, flags) \
-                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
-                 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
+#ifndef newSV_type
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#  define newSV_type(t) ({ SV *_sv = newSV(0); sv_upgrade(_sv, (t)); _sv; })
+#else
+#  define newSV_type(t) ((PL_Sv = newSV(0)), sv_upgrade(PL_Sv, (t)), PL_Sv)
 #endif
-#ifndef SvPV_force_flags_nolen
-#  define SvPV_force_flags_nolen(sv, flags) \
-                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
-                 ? SvPVX(sv) : sv_pvn_force_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags))
 #endif
-#ifndef SvPV_force_flags_mutable
-#  define SvPV_force_flags_mutable(sv, lp, flags) \
-                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
-                 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
-                  : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
+
+#if (PERL_BCDVERSION < 0x5006000)
+# define D_PPP_CONSTPV_ARG(x)  ((char *) (x))
+#else
+# define D_PPP_CONSTPV_ARG(x)  (x)
 #endif
-#ifndef SvPV_nolen
-#  define SvPV_nolen(sv)                 \
-                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-                  ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
+#ifndef newSVpvn
+#  define newSVpvn(data,len)             ((data)                                              \
+                                    ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
+                                    : newSV(0))
 #endif
-#ifndef SvPV_nolen_const
-#  define SvPV_nolen_const(sv)           \
-                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-                  ? SvPVX_const(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
+#ifndef newSVpvn_utf8
+#  define newSVpvn_utf8(s, len, u)       newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
 #endif
-#ifndef SvPV_nomg
-#  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)
+#ifndef SVf_UTF8
+#  define SVf_UTF8                       0
 #endif
 
-#ifndef SvPV_nomg_const
-#  define SvPV_nomg_const(sv, lp)        SvPV_flags_const(sv, lp, 0)
+#ifndef newSVpvn_flags
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+# define newSVpvn_flags(s, len, flags) ({ SV *_sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len)); SvFLAGS(_sv) |= ((flags) & SVf_UTF8); ((flags) & SVs_TEMP) ? sv_2mortal(_sv) : _sv; })
+#else
+# define newSVpvn_flags(s, len, flags) ((PL_Sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len))), SvFLAGS(PL_Sv) |= ((flags) & SVf_UTF8), (((flags) & SVs_TEMP) ? sv_2mortal(PL_Sv) : PL_Sv))
+#endif
 #endif
 
-#ifndef SvPV_nomg_const_nolen
-#  define SvPV_nomg_const_nolen(sv)      SvPV_flags_const_nolen(sv, 0)
+#if ( (PERL_BCDVERSION >= 0x5007003) && (PERL_BCDVERSION < 0x5008007) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009002) )
+#undef sv_setsv_flags
+#define SV_NOSTEAL 16
+#define sv_setsv_flags(dstr, sstr, flags)                                \
+  STMT_START {                                                           \
+    if (((flags) & SV_NOSTEAL) && (SvFLAGS((sstr)) & SVs_TEMP)) {        \
+      SvTEMP_off((sstr));                                                \
+      Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL);  \
+      SvTEMP_on((sstr));                                                 \
+    } else {                                                             \
+      Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL);  \
+    }                                                                    \
+  } STMT_END
 #endif
 
-#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))
+#if !defined(newSVsv_nomg) && defined(SV_NOSTEAL)
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#  define newSVsv_nomg(sv) ({ SV *_sv = newSV(0); sv_setsv_flags(_sv, (sv), SV_NOSTEAL); _sv; })
+#else
+#  define newSVsv_nomg(sv) ((PL_Sv = newSV(0)), sv_setsv_flags(PL_Sv, (sv), SV_NOSTEAL), PL_Sv)
 #endif
-#ifndef SvPV_renew
-#  define SvPV_renew(sv,n)               STMT_START { SvLEN_set(sv, n); \
-                 SvPV_set((sv), (char *) saferealloc(          \
-                       (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
-               } STMT_END
 #endif
 #ifndef SvMAGIC_set
 #  define SvMAGIC_set(sv, val)           \
@@ -5931,195 +6141,13 @@ DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
                 (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
 #endif
 
-#else
-#ifndef SvUV_set
-#  define SvUV_set(sv, val)              \
-                STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
-                (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
-#endif
-
-#endif
-
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
-#if defined(NEED_vnewSVpvf)
-static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
-static
-#else
-extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
-#endif
-
-#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
-
-#ifdef vnewSVpvf
-#  undef vnewSVpvf
-#endif
-#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
-#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
-
-
-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;
-}
-
-#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
-#else
-extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
-#endif
-
-#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
-
-#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);
-}
-
-#endif
-#endif
-
-#ifdef PERL_IMPLICIT_CONTEXT
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
-#if defined(NEED_sv_catpvf_mg_nocontext)
-static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
-static
-#else
-extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
-#endif
-
-#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)
-
-
-void
-DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
-{
-  dTHX;
-  va_list args;
-  va_start(args, pat);
-  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
-  SvSETMAGIC(sv);
-  va_end(args);
-}
-
-#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
-#endif
-
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
-#  define sv_vcatpvf_mg(sv, pat, args)                                     \
-   STMT_START {                                                            \
-     sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
-     SvSETMAGIC(sv);                                                       \
-   } STMT_END
-#endif
-
-#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
-
-#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
-
-#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
-
-
-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
-#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, ...);
-#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
-#endif
-#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
-#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
+#else
+#ifndef SvUV_set
+#  define SvUV_set(sv, val)              \
+                STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
+                (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
+#endif
+
 #endif
 
 /* Hint: newSVpvn_share
@@ -6175,32 +6203,15 @@ DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
 #  define HvNAMELEN_get(hv)              (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)
 #endif
 
-#ifndef gv_fetchpvn_flags
-#if defined(NEED_gv_fetchpvn_flags)
-static GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types);
-static
-#else
-extern GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types);
+#if (PERL_BCDVERSION >= 0x5009002) && (PERL_BCDVERSION <= 0x5009003) /* 5.9.2 and 5.9.3 ignore the length param */
+#undef gv_fetchpvn_flags
 #endif
-
-#if defined(NEED_gv_fetchpvn_flags) || defined(NEED_gv_fetchpvn_flags_GLOBAL)
-
-#ifdef gv_fetchpvn_flags
-#  undef gv_fetchpvn_flags
+#ifndef GV_NOADD_MASK
+#  define GV_NOADD_MASK                  0xE0
 #endif
-#define gv_fetchpvn_flags(a,b,c,d) DPPP_(my_gv_fetchpvn_flags)(aTHX_ a,b,c,d)
-#define Perl_gv_fetchpvn_flags DPPP_(my_gv_fetchpvn_flags)
-
-
-GV*
-DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types) {
-       char *namepv = savepvn(name, len);
-       GV* stash = gv_fetchpv(namepv, TRUE, SVt_PVHV);
-       Safefree(namepv);
-       return stash;
-}
 
-#endif
+#ifndef gv_fetchpvn_flags
+#  define gv_fetchpvn_flags(name, len, flags, sv_type) gv_fetchpv(SvPVX(sv_2mortal(newSVpvn((name), (len)))), ((flags) & GV_NOADD_MASK) ? FALSE : TRUE, (I32)(sv_type))
 #endif
 #ifndef GvSVn
 #  define GvSVn(gv)                      GvSV(gv)
@@ -6220,239 +6231,6 @@ DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int 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 WARN_ALL
-#  define WARN_ALL                       0
-#endif
-
-#ifndef WARN_CLOSURE
-#  define WARN_CLOSURE                   1
-#endif
-
-#ifndef WARN_DEPRECATED
-#  define WARN_DEPRECATED                2
-#endif
-
-#ifndef WARN_EXITING
-#  define WARN_EXITING                   3
-#endif
-
-#ifndef WARN_GLOB
-#  define WARN_GLOB                      4
-#endif
-
-#ifndef WARN_IO
-#  define WARN_IO                        5
-#endif
-
-#ifndef WARN_CLOSED
-#  define WARN_CLOSED                    6
-#endif
-
-#ifndef WARN_EXEC
-#  define WARN_EXEC                      7
-#endif
-
-#ifndef WARN_LAYER
-#  define WARN_LAYER                     8
-#endif
-
-#ifndef WARN_NEWLINE
-#  define WARN_NEWLINE                   9
-#endif
-
-#ifndef WARN_PIPE
-#  define WARN_PIPE                      10
-#endif
-
-#ifndef WARN_UNOPENED
-#  define WARN_UNOPENED                  11
-#endif
-
-#ifndef WARN_MISC
-#  define WARN_MISC                      12
-#endif
-
-#ifndef WARN_NUMERIC
-#  define WARN_NUMERIC                   13
-#endif
-
-#ifndef WARN_ONCE
-#  define WARN_ONCE                      14
-#endif
-
-#ifndef WARN_OVERFLOW
-#  define WARN_OVERFLOW                  15
-#endif
-
-#ifndef WARN_PACK
-#  define WARN_PACK                      16
-#endif
-
-#ifndef WARN_PORTABLE
-#  define WARN_PORTABLE                  17
-#endif
-
-#ifndef WARN_RECURSION
-#  define WARN_RECURSION                 18
-#endif
-
-#ifndef WARN_REDEFINE
-#  define WARN_REDEFINE                  19
-#endif
-
-#ifndef WARN_REGEXP
-#  define WARN_REGEXP                    20
-#endif
-
-#ifndef WARN_SEVERE
-#  define WARN_SEVERE                    21
-#endif
-
-#ifndef WARN_DEBUGGING
-#  define WARN_DEBUGGING                 22
-#endif
-
-#ifndef WARN_INPLACE
-#  define WARN_INPLACE                   23
-#endif
-
-#ifndef WARN_INTERNAL
-#  define WARN_INTERNAL                  24
-#endif
-
-#ifndef WARN_MALLOC
-#  define WARN_MALLOC                    25
-#endif
-
-#ifndef WARN_SIGNAL
-#  define WARN_SIGNAL                    26
-#endif
-
-#ifndef WARN_SUBSTR
-#  define WARN_SUBSTR                    27
-#endif
-
-#ifndef WARN_SYNTAX
-#  define WARN_SYNTAX                    28
-#endif
-
-#ifndef WARN_AMBIGUOUS
-#  define WARN_AMBIGUOUS                 29
-#endif
-
-#ifndef WARN_BAREWORD
-#  define WARN_BAREWORD                  30
-#endif
-
-#ifndef WARN_DIGIT
-#  define WARN_DIGIT                     31
-#endif
-
-#ifndef WARN_PARENTHESIS
-#  define WARN_PARENTHESIS               32
-#endif
-
-#ifndef WARN_PRECEDENCE
-#  define WARN_PRECEDENCE                33
-#endif
-
-#ifndef WARN_PRINTF
-#  define WARN_PRINTF                    34
-#endif
-
-#ifndef WARN_PROTOTYPE
-#  define WARN_PROTOTYPE                 35
-#endif
-
-#ifndef WARN_QW
-#  define WARN_QW                        36
-#endif
-
-#ifndef WARN_RESERVED
-#  define WARN_RESERVED                  37
-#endif
-
-#ifndef WARN_SEMICOLON
-#  define WARN_SEMICOLON                 38
-#endif
-
-#ifndef WARN_TAINT
-#  define WARN_TAINT                     39
-#endif
-
-#ifndef WARN_THREADS
-#  define WARN_THREADS                   40
-#endif
-
-#ifndef WARN_UNINITIALIZED
-#  define WARN_UNINITIALIZED             41
-#endif
-
-#ifndef WARN_UNPACK
-#  define WARN_UNPACK                    42
-#endif
-
-#ifndef WARN_UNTIE
-#  define WARN_UNTIE                     43
-#endif
-
-#ifndef WARN_UTF8
-#  define WARN_UTF8                      44
-#endif
-
-#ifndef WARN_VOID
-#  define WARN_VOID                      45
-#endif
-
-#ifndef WARN_ASSERTIONS
-#  define WARN_ASSERTIONS                46
-#endif
-#ifndef packWARN
-#  define packWARN(a)                    (a)
-#endif
-
-#ifndef ckWARN
-#  ifdef G_WARN_ON
-#    define  ckWARN(a)                  (PL_dowarn & G_WARN_ON)
-#  else
-#    define  ckWARN(a)                  PL_dowarn
-#  endif
-#endif
-
-#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
-#if defined(NEED_warner)
-static void DPPP_(my_warner)(U32 err, const char *pat, ...);
-static
-#else
-extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
-#endif
-
-#if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
-
-#define Perl_warner DPPP_(my_warner)
-
-
-void
-DPPP_(my_warner)(U32 err, const char *pat, ...)
-{
-  SV *sv;
-  va_list args;
-
-  PERL_UNUSED_ARG(err);
-
-  va_start(args, pat);
-  sv = vnewSVpvf(pat, &args);
-  va_end(args);
-  sv_2mortal(sv);
-  warn("%s", SvPV_nolen(sv));
-}
-
-#define warner  Perl_warner
-
-#define Perl_warner_nocontext  Perl_warner
-
-#endif
-#endif
 
 /* 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
@@ -7562,10 +7340,10 @@ DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *resul
 
 #if !defined(my_snprintf)
 #if defined(NEED_my_snprintf)
-static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
+static int DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...);
 static
 #else
-extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
+extern int DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...);
 #endif
 
 #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
@@ -7597,10 +7375,10 @@ DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
 
 #if !defined(my_sprintf)
 #if defined(NEED_my_sprintf)
-static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
+static int DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...);
 static
 #else
-extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
+extern int DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...);
 #endif
 
 #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
@@ -7640,10 +7418,10 @@ DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)
 
 #if !defined(my_strlcat)
 #if defined(NEED_my_strlcat)
-static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
+static Size_t DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size);
 static
 #else
-extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
+extern Size_t DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size);
 #endif
 
 #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
@@ -7671,10 +7449,10 @@ DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
 
 #if !defined(my_strlcpy)
 #if defined(NEED_my_strlcpy)
-static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
+static Size_t DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size);
 static
 #else
-extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
+extern Size_t DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size);
 #endif
 
 #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
@@ -7788,7 +7566,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;
@@ -7798,15 +7576,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;