LILiK
/
openwrt-packages-dist

--- a/Expat/Expat.xs+++ b/Expat/Expat.xs@@ -20,17 +20,7 @@ #include "patchlevel.h"
 #include "encoding.h"
 --/* Version 5.005_5x (Development version for 5.006) doesn't like sv_...
-   anymore, but 5.004 doesn't know about PL_sv..-   Don't want to push up required version just for this. */--#if PATCHLEVEL < 5-#define PL_sv_undef	sv_undef-#define PL_sv_no	sv_no-#define PL_sv_yes	sv_yes-#define PL_na		na-#endif+#include "ppport.h"  #define BUFSIZE 32768
 --- /dev/null+++ b/Expat/ppport.h@@ -0,0 +1,7452 @@+#if 0+<<'SKIP';+#endif+/*
+----------------------------------------------------------------------++    ppport.h -- Perl/Pollution/Portability Version 3.21++    Automatically created by Devel::PPPort running under perl 5.020002.++    Do NOT edit this file directly! -- Edit PPPort_pm.PL and the+    includes in parts/inc/ instead.++    Use 'perldoc ppport.h' to view the documentation below.++----------------------------------------------------------------------++SKIP++=pod++=head1 NAME++ppport.h - Perl/Pollution/Portability version 3.21++=head1 SYNOPSIS++  perl ppport.h [options] [source files]++  Searches current directory for files if no [source files] are given++  --help                      show short help++  --version                   show version++  --patch=file                write one patch file with changes+  --copy=suffix               write changed copies with suffix+  --diff=program              use diff program and options++  --compat-version=version    provide compatibility with Perl version+  --cplusplus                 accept C++ comments++  --quiet                     don't output anything except fatal errors+  --nodiag                    don't show diagnostics+  --nohints                   don't show hints+  --nochanges                 don't suggest changes+  --nofilter                  don't filter input files++  --strip                     strip all script and doc functionality from+                              ppport.h++  --list-provided             list provided API+  --list-unsupported          list unsupported API+  --api-info=name             show Perl API portability information++=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.11.5.++=head1 OPTIONS++=head2 --help++Display a brief usage summary.++=head2 --version++Display the version of F<ppport.h>.++=head2 --patch=I<file>++If this option is given, a single patch file will be created if+any changes are suggested. This requires a working diff program+to be installed on your system.++=head2 --copy=I<suffix>++If this option is given, a copy of each file will be saved with+the given suffix that contains the suggested changes. This does+not require any external programs. Note that this does not+automagially add a dot between the original filename and the+suffix. If you want the dot, you have to include it in the option+argument.++If neither C<--patch> or C<--copy> are given, the default is to+simply print the diffs for each file. This requires either+C<Text::Diff> or a C<diff> program to be installed.++=head2 --diff=I<program>++Manually set the diff program and options to use. The default+is to use C<Text::Diff>, when installed, and output unified+context diffs.++=head2 --compat-version=I<version>++Tell F<ppport.h> to check for compatibility with the given+Perl version. The default is to check for compatibility with Perl+version 5.003. You can use this option to reduce the output+of F<ppport.h> if you intend to be backward compatible only+down to a certain Perl version.++=head2 --cplusplus++Usually, F<ppport.h> will detect C++ style comments and+replace them with C style comments for portability reasons.+Using this option instructs F<ppport.h> to leave C+++comments untouched.++=head2 --quiet++Be quiet. Don't print anything except fatal errors.++=head2 --nodiag++Don't output any diagnostic messages. Only portability+alerts will be printed.++=head2 --nohints++Don't output any hints. Hints often contain useful portability+notes. Warnings will still be displayed.++=head2 --nochanges++Don't suggest any changes. Only give diagnostic output and hints+unless these are also deactivated.++=head2 --nofilter++Don't filter the list of input files. By default, files not looking+like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped.++=head2 --strip++Strip all script and documentation functionality from F<ppport.h>.+This reduces the size of F<ppport.h> dramatically and may be useful+if you want to include F<ppport.h> in smaller modules without+increasing their distribution size too much.++The stripped F<ppport.h> will have a C<--unstrip> option that allows+you to undo the stripping, but only if an appropriate C<Devel::PPPort>+module is installed.++=head2 --list-provided++Lists the API elements for which compatibility is provided by+F<ppport.h>. Also lists if it must be explicitly requested,+if it has dependencies, and if there are hints or warnings for it.++=head2 --list-unsupported++Lists the API elements that are known not to be supported by+F<ppport.h> and below which version of Perl they probably+won't be available or work.++=head2 --api-info=I<name>++Show portability information for API elements matching I<name>.+If I<name> is surrounded by slashes, it is interpreted as a regular+expression.++=head1 DESCRIPTION++In order for a Perl extension (XS) module to be as portable as possible+across differing versions of Perl itself, certain steps need to be taken.++=over 4++=item *++Including this header is the first major one. This alone will give you+access to a large part of the Perl API that hasn't been available in+earlier Perl releases. Use++    perl ppport.h --list-provided++to see which API elements are provided by ppport.h.++=item *++You should avoid using deprecated parts of the API. For example, using+global Perl variables without the C<PL_> prefix is deprecated. Also,+some API functions used to have a C<perl_> prefix. Using this form is+also deprecated. You can safely use the supported API, as F<ppport.h>+will provide wrappers for older Perl versions.++=item *++If you use one of a few functions or variables that were not present in+earlier versions of Perl, and that can't be provided using a macro, you+have to explicitly request support for these functions by adding one or+more C<#define>s in your source code before the inclusion of F<ppport.h>.++These functions or variables will be marked C<explicit> in the list shown+by C<--list-provided>.++Depending on whether you module has a single or multiple files that+use such functions or variables, you want either C<static> or global+variants.++For a C<static> function or variable (used only in a single source+file), use:++    #define NEED_function+    #define NEED_variable++For a global function or variable (used in multiple source files),+use:++    #define NEED_function_GLOBAL+    #define NEED_variable_GLOBAL++Note that you mustn't have more than one global request for the+same function or variable in your project.++    Function / Variable       Static Request               Global Request+    -----------------------------------------------------------------------------------------+    PL_parser                 NEED_PL_parser               NEED_PL_parser_GLOBAL+    PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL+    eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL+    grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL+    grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL+    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+    load_module()             NEED_load_module             NEED_load_module_GLOBAL+    my_snprintf()             NEED_my_snprintf             NEED_my_snprintf_GLOBAL+    my_sprintf()              NEED_my_sprintf              NEED_my_sprintf_GLOBAL+    my_strlcat()              NEED_my_strlcat              NEED_my_strlcat_GLOBAL+    my_strlcpy()              NEED_my_strlcpy              NEED_my_strlcpy_GLOBAL+    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+    vload_module()            NEED_vload_module            NEED_vload_module_GLOBAL+    vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL+    warner()                  NEED_warner                  NEED_warner_GLOBAL++To avoid namespace conflicts, you can change the namespace of the+explicitly exported functions / variables using the C<DPPP_NAMESPACE>+macro. Just C<#define> the macro before including C<ppport.h>:++    #define DPPP_NAMESPACE MyOwnNamespace_+    #include "ppport.h"++The default namespace is C<DPPP_>.++=back++The good thing is that most of the above can be checked by running+F<ppport.h> on your source code. See the next section for+details.++=head1 EXAMPLES++To verify whether F<ppport.h> is needed for your module, whether you+should make any changes to your code, and whether any special defines+should be used, F<ppport.h> can be run as a Perl script to check your+source code. Simply say:++    perl ppport.h++The result will usually be a list of patches suggesting changes+that should at least be acceptable, if not necessarily the most+efficient solution, or a fix for all possible problems.++If you know that your XS module uses features only available in+newer Perl releases, if you're aware that it uses C++ comments,+and if you want all suggestions as a single patch file, you could+use something like this:++    perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff++If you only want your code to be scanned without any suggestions+for changes, use:++    perl ppport.h --nochanges++You can specify a different C<diff> program or options, using+the C<--diff> option:++    perl ppport.h --diff='diff -C 10'++This would output context diffs with 10 lines of context.++If you want to create patched copies of your files instead, use:++    perl ppport.h --copy=.new++To display portability information for the C<newSVpvn> function,+use:++    perl ppport.h --api-info=newSVpvn++Since the argument to C<--api-info> can be a regular expression,+you can use++    perl ppport.h --api-info=/_nomg$/++to display portability information for all C<_nomg> functions or++    perl ppport.h --api-info=/./++to display information for all known API elements.++=head1 BUGS++If this version of F<ppport.h> is causing failure during+the compilation of this module, please check if newer versions+of either this module or C<Devel::PPPort> are available on CPAN+before sending a bug report.++If F<ppport.h> was generated using the latest version of+C<Devel::PPPort> and is causing failure of this module, please+file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>.
++Please include the following information:++=over 4++=item 1.++The complete output from running "perl -V"++=item 2.++This file.++=item 3.++The name and version of the module you were trying to build.++=item 4.++A full log of the build that failed.++=item 5.++Any other information that you think could be relevant.++=back++For the latest version of this code, please get the C<Devel::PPPort>+module from CPAN.++=head1 COPYRIGHT++Version 3.x, Copyright (c) 2004-2013, Marcus Holland-Moritz.++Version 2.x, Copyright (C) 2001, Paul Marquess.++Version 1.x, Copyright (C) 1999, Kenneth Albanowski.++This program is free software; you can redistribute it and/or+modify it under the same terms as Perl itself.++=head1 SEE ALSO++See L<Devel::PPPort>.++=cut++use strict;++# Disable broken TRIE-optimization+BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }++my $VERSION = 3.21;++my %opt = (+  quiet     => 0,+  diag      => 1,+  hints     => 1,+  changes   => 1,+  cplusplus => 0,+  filter    => 1,+  strip     => 0,+  version   => 0,+);++my($ppport) = $0 =~ /([\w.]+)$/;+my $LF = '(?:\r\n|[\r\n])';   # line feed+my $HS = "[ \t]";             # horizontal whitespace++# Never use C comments in this file!+my $ccs  = '/'.'*';+my $cce  = '*'.'/';+my $rccs = quotemeta $ccs;+my $rcce = quotemeta $cce;++eval {+  require Getopt::Long;+  Getopt::Long::GetOptions(\%opt, qw(+    help quiet diag! filter! hints! changes! cplusplus strip version+    patch=s copy=s diff=s compat-version=s+    list-provided list-unsupported api-info=s+  )) or usage();+};++if ($@ and grep /^-/, @ARGV) {+  usage() if "@ARGV" =~ /^--?h(?:elp)?$/;+  die "Getopt::Long not found. Please don't use any options.\n";+}++if ($opt{version}) {+  print "This is $0 $VERSION.\n";+  exit 0;+}++usage() if $opt{help};+strip() if $opt{strip};++if (exists $opt{'compat-version'}) {+  my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };+  if ($@) {+    die "Invalid version number format: '$opt{'compat-version'}'\n";+  }+  die "Only Perl 5 is supported\n" if $r != 5;+  die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;+  $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;+}+else {+  $opt{'compat-version'} = 5;+}++my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/+                ? ( $1 => {+                      ($2                  ? ( base     => $2 ) : ()),+                      ($3                  ? ( todo     => $3 ) : ()),+                      (index($4, 'v') >= 0 ? ( varargs  => 1  ) : ()),+                      (index($4, 'p') >= 0 ? ( provided => 1  ) : ()),+                      (index($4, 'n') >= 0 ? ( nothxarg => 1  ) : ()),+                    } )+                : die "invalid spec: $_" } qw(+AvFILLp|5.004050||p+AvFILL|||+BhkDISABLE||5.019003|+BhkENABLE||5.019003|+BhkENTRY_set||5.019003|+BhkENTRY|||+BhkFLAGS|||+CALL_BLOCK_HOOKS|||+CLASS|||n+CPERLscope|5.005000||p+CX_CURPAD_SAVE|||+CX_CURPAD_SV|||+CopFILEAV|5.006000||p+CopFILEGV_set|5.006000||p+CopFILEGV|5.006000||p+CopFILESV|5.006000||p+CopFILE_set|5.006000||p+CopFILE|5.006000||p+CopSTASHPV_set|5.006000||p+CopSTASHPV|5.006000||p+CopSTASH_eq|5.006000||p+CopSTASH_set|5.006000||p+CopSTASH|5.006000||p+CopyD|5.009002|5.004050|p+Copy||5.004050|+CvPADLIST||5.008001|+CvSTASH|||+CvWEAKOUTSIDE|||+DEFSV_set|5.010001||p+DEFSV|5.004050||p+END_EXTERN_C|5.005000||p+ENTER|||+ERRSV|5.004050||p+EXTEND|||+EXTERN_C|5.005000||p+F0convert|||n+FREETMPS|||+GIMME_V||5.004000|n+GIMME|||n+GROK_NUMERIC_RADIX|5.007002||p+G_ARRAY|||+G_DISCARD|||+G_EVAL|||+G_METHOD|5.006001||p+G_NOARGS|||+G_SCALAR|||+G_VOID||5.004000|+GetVars|||+GvAV|||+GvCV|||+GvHV|||+GvSVn|5.009003||p+GvSV|||+Gv_AMupdate||5.011000|+HEf_SVKEY||5.004000|+HeHASH||5.004000|+HeKEY||5.004000|+HeKLEN||5.004000|+HePV||5.004000|+HeSVKEY_force||5.004000|+HeSVKEY_set||5.004000|+HeSVKEY||5.004000|+HeUTF8||5.010001|+HeVAL||5.004000|+HvENAMELEN||5.015004|+HvENAMEUTF8||5.015004|+HvENAME||5.013007|+HvNAMELEN_get|5.009003||p+HvNAMELEN||5.015004|+HvNAMEUTF8||5.015004|+HvNAME_get|5.009003||p+HvNAME|||+INT2PTR|5.006000||p+IN_LOCALE_COMPILETIME|5.007002||p+IN_LOCALE_RUNTIME|5.007002||p+IN_LOCALE|5.007002||p+IN_PERL_COMPILETIME|5.008001||p+IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p+IS_NUMBER_INFINITY|5.007002||p+IS_NUMBER_IN_UV|5.007002||p+IS_NUMBER_NAN|5.007003||p+IS_NUMBER_NEG|5.007002||p+IS_NUMBER_NOT_INT|5.007002||p+IVSIZE|5.006000||p+IVTYPE|5.006000||p+IVdf|5.006000||p+LEAVE|||+LINKLIST||5.013006|+LVRET|||+MARK|||+MULTICALL||5.019003|+MY_CXT_CLONE|5.009002||p+MY_CXT_INIT|5.007003||p+MY_CXT|5.007003||p+MoveD|5.009002|5.004050|p+Move||5.004050|+NOOP|5.005000||p+NUM2PTR|5.006000||p+NVTYPE|5.006000||p+NVef|5.006001||p+NVff|5.006001||p+NVgf|5.006001||p+Newxc|5.009003||p+Newxz|5.009003||p+Newx|5.009003||p+Nullav|||+Nullch|||+Nullcv|||+Nullhv|||+Nullsv|||+OP_CLASS||5.013007|+OP_DESC||5.007003|+OP_NAME||5.007003|+ORIGMARK|||+PAD_BASE_SV|||+PAD_CLONE_VARS|||+PAD_COMPNAME_FLAGS|||+PAD_COMPNAME_GEN_set|||+PAD_COMPNAME_GEN|||+PAD_COMPNAME_OURSTASH|||+PAD_COMPNAME_PV|||+PAD_COMPNAME_TYPE|||+PAD_RESTORE_LOCAL|||+PAD_SAVE_LOCAL|||+PAD_SAVE_SETNULLPAD|||+PAD_SETSV|||+PAD_SET_CUR_NOSAVE|||+PAD_SET_CUR|||+PAD_SVl|||+PAD_SV|||+PERLIO_FUNCS_CAST|5.009003||p+PERLIO_FUNCS_DECL|5.009003||p+PERL_ABS|5.008001||p+PERL_BCDVERSION|5.019002||p+PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p+PERL_HASH|5.004000||p+PERL_INT_MAX|5.004000||p+PERL_INT_MIN|5.004000||p+PERL_LONG_MAX|5.004000||p+PERL_LONG_MIN|5.004000||p+PERL_MAGIC_arylen|5.007002||p+PERL_MAGIC_backref|5.007002||p+PERL_MAGIC_bm|5.007002||p+PERL_MAGIC_collxfrm|5.007002||p+PERL_MAGIC_dbfile|5.007002||p+PERL_MAGIC_dbline|5.007002||p+PERL_MAGIC_defelem|5.007002||p+PERL_MAGIC_envelem|5.007002||p+PERL_MAGIC_env|5.007002||p+PERL_MAGIC_ext|5.007002||p+PERL_MAGIC_fm|5.007002||p+PERL_MAGIC_glob|5.019002||p+PERL_MAGIC_isaelem|5.007002||p+PERL_MAGIC_isa|5.007002||p+PERL_MAGIC_mutex|5.019002||p+PERL_MAGIC_nkeys|5.007002||p+PERL_MAGIC_overload_elem|5.019002||p+PERL_MAGIC_overload_table|5.007002||p+PERL_MAGIC_overload|5.019002||p+PERL_MAGIC_pos|5.007002||p+PERL_MAGIC_qr|5.007002||p+PERL_MAGIC_regdata|5.007002||p+PERL_MAGIC_regdatum|5.007002||p+PERL_MAGIC_regex_global|5.007002||p+PERL_MAGIC_shared_scalar|5.007003||p+PERL_MAGIC_shared|5.007003||p+PERL_MAGIC_sigelem|5.007002||p+PERL_MAGIC_sig|5.007002||p+PERL_MAGIC_substr|5.007002||p+PERL_MAGIC_sv|5.007002||p+PERL_MAGIC_taint|5.007002||p+PERL_MAGIC_tiedelem|5.007002||p+PERL_MAGIC_tiedscalar|5.007002||p+PERL_MAGIC_tied|5.007002||p+PERL_MAGIC_utf8|5.008001||p+PERL_MAGIC_uvar_elem|5.007003||p+PERL_MAGIC_uvar|5.007002||p+PERL_MAGIC_vec|5.007002||p+PERL_MAGIC_vstring|5.008001||p+PERL_PV_ESCAPE_ALL|5.009004||p+PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p+PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p+PERL_PV_ESCAPE_NOCLEAR|5.009004||p+PERL_PV_ESCAPE_QUOTE|5.009004||p+PERL_PV_ESCAPE_RE|5.009005||p+PERL_PV_ESCAPE_UNI_DETECT|5.009004||p+PERL_PV_ESCAPE_UNI|5.009004||p+PERL_PV_PRETTY_DUMP|5.009004||p+PERL_PV_PRETTY_ELLIPSES|5.010000||p+PERL_PV_PRETTY_LTGT|5.009004||p+PERL_PV_PRETTY_NOCLEAR|5.010000||p+PERL_PV_PRETTY_QUOTE|5.009004||p+PERL_PV_PRETTY_REGPROP|5.009004||p+PERL_QUAD_MAX|5.004000||p+PERL_QUAD_MIN|5.004000||p+PERL_REVISION|5.006000||p+PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p+PERL_SCAN_DISALLOW_PREFIX|5.007003||p+PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p+PERL_SCAN_SILENT_ILLDIGIT|5.008001||p+PERL_SHORT_MAX|5.004000||p+PERL_SHORT_MIN|5.004000||p+PERL_SIGNALS_UNSAFE_FLAG|5.008001||p+PERL_SUBVERSION|5.006000||p+PERL_SYS_INIT3||5.010000|+PERL_SYS_INIT||5.010000|+PERL_SYS_TERM||5.019003|+PERL_UCHAR_MAX|5.004000||p+PERL_UCHAR_MIN|5.004000||p+PERL_UINT_MAX|5.004000||p+PERL_UINT_MIN|5.004000||p+PERL_ULONG_MAX|5.004000||p+PERL_ULONG_MIN|5.004000||p+PERL_UNUSED_ARG|5.009003||p+PERL_UNUSED_CONTEXT|5.009004||p+PERL_UNUSED_DECL|5.007002||p+PERL_UNUSED_VAR|5.007002||p+PERL_UQUAD_MAX|5.004000||p+PERL_UQUAD_MIN|5.004000||p+PERL_USE_GCC_BRACE_GROUPS|5.009004||p+PERL_USHORT_MAX|5.004000||p+PERL_USHORT_MIN|5.004000||p+PERL_VERSION|5.006000||p+PL_DBsignal|5.005000||p+PL_DBsingle|||pn+PL_DBsub|||pn+PL_DBtrace|||pn+PL_Sv|5.005000||p+PL_bufend|5.019002||p+PL_bufptr|5.019002||p+PL_check||5.006000|+PL_compiling|5.004050||p+PL_comppad_name||5.017004|+PL_comppad||5.008001|+PL_copline|5.019002||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_errgv|5.004050||p+PL_error_count|5.019002||p+PL_expect|5.019002||p+PL_hexdigit|5.005000||p+PL_hints|5.005000||p+PL_in_my_stash|5.019002||p+PL_in_my|5.019002||p+PL_keyword_plugin||5.011002|+PL_last_in_gv|||n+PL_laststatval|5.005000||p+PL_lex_state|5.019002||p+PL_lex_stuff|5.019002||p+PL_linestr|5.019002||p+PL_modglobal||5.005000|n+PL_na|5.004050||pn+PL_no_modify|5.006000||p+PL_ofsgv|||n+PL_opfreehook||5.011000|n+PL_parser|5.009005|5.009005|p+PL_peepp||5.007003|n+PL_perl_destruct_level|5.004050||p+PL_perldb|5.004050||p+PL_ppaddr|5.006000||p+PL_rpeepp||5.013005|n+PL_rsfp_filters|5.019002||p+PL_rsfp|5.019002||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_tainted|5.004050||p+PL_tainting|5.004050||p+PL_tokenbuf|5.019002||p+POP_MULTICALL||5.019003|+POPi|||n+POPl|||n+POPn|||n+POPpbytex||5.007001|n+POPpx||5.005030|n+POPp|||n+POPs|||n+PTR2IV|5.006000||p+PTR2NV|5.006000||p+PTR2UV|5.006000||p+PTR2nat|5.009003||p+PTR2ul|5.007001||p+PTRV|5.006000||p+PUSHMARK|||+PUSH_MULTICALL||5.019003|+PUSHi|||+PUSHmortal|5.009002||p+PUSHn|||+PUSHp|||+PUSHs|||+PUSHu|5.004000||p+PUTBACK|||+PadARRAY||5.019003|+PadMAX||5.019003|+PadlistARRAY||5.019003|+PadlistMAX||5.019003|+PadlistNAMESARRAY||5.019003|+PadlistNAMESMAX||5.019003|+PadlistNAMES||5.019003|+PadlistREFCNT||5.017004|+PadnameIsOUR|||+PadnameIsSTATE|||+PadnameLEN||5.019003|+PadnameOURSTASH|||+PadnameOUTER|||+PadnamePV||5.019003|+PadnameSV||5.019003|+PadnameTYPE|||+PadnameUTF8||5.019003|+PadnamelistARRAY||5.019003|+PadnamelistMAX||5.019003|+PerlIO_clearerr||5.007003|+PerlIO_close||5.007003|+PerlIO_context_layers||5.009004|+PerlIO_eof||5.007003|+PerlIO_error||5.007003|+PerlIO_fileno||5.007003|+PerlIO_fill||5.007003|+PerlIO_flush||5.007003|+PerlIO_get_base||5.007003|+PerlIO_get_bufsiz||5.007003|+PerlIO_get_cnt||5.007003|+PerlIO_get_ptr||5.007003|+PerlIO_read||5.007003|+PerlIO_seek||5.007003|+PerlIO_set_cnt||5.007003|+PerlIO_set_ptrcnt||5.007003|+PerlIO_setlinebuf||5.007003|+PerlIO_stderr||5.007003|+PerlIO_stdin||5.007003|+PerlIO_stdout||5.007003|+PerlIO_tell||5.007003|+PerlIO_unread||5.007003|+PerlIO_write||5.007003|+Perl_signbit||5.009005|n+PoisonFree|5.009004||p+PoisonNew|5.009004||p+PoisonWith|5.009004||p+Poison|5.008000||p+READ_XDIGIT||5.017006|+RETVAL|||n+Renewc|||+Renew|||+SAVECLEARSV|||+SAVECOMPPAD|||+SAVEPADSV|||+SAVETMPS|||+SAVE_DEFSV|5.004050||p+SPAGAIN|||+SP|||+START_EXTERN_C|5.005000||p+START_MY_CXT|5.007003||p+STMT_END|||p+STMT_START|||p+STR_WITH_LEN|5.009003||p+ST|||+SV_CONST_RETURN|5.009003||p+SV_COW_DROP_PV|5.008001||p+SV_COW_SHARED_HASH_KEYS|5.009005||p+SV_GMAGIC|5.007002||p+SV_HAS_TRAILING_NUL|5.009004||p+SV_IMMEDIATE_UNREF|5.007001||p+SV_MUTABLE_RETURN|5.009003||p+SV_NOSTEAL|5.009002||p+SV_SMAGIC|5.009003||p+SV_UTF8_NO_ENCODING|5.008001||p+SVfARG|5.009005||p+SVf_UTF8|5.006000||p+SVf|5.006000||p+SVt_INVLIST||5.019002|+SVt_IV|||+SVt_NULL|||+SVt_NV|||+SVt_PVAV|||+SVt_PVCV|||+SVt_PVFM|||+SVt_PVGV|||+SVt_PVHV|||+SVt_PVIO|||+SVt_PVIV|||+SVt_PVLV|||+SVt_PVMG|||+SVt_PVNV|||+SVt_PV|||+SVt_REGEXP||5.011000|+Safefree|||+Slab_Alloc|||+Slab_Free|||+Slab_to_ro|||+Slab_to_rw|||+StructCopy|||+SvCUR_set|||+SvCUR|||+SvEND|||+SvGAMAGIC||5.006001|+SvGETMAGIC|5.004050||p+SvGROW|||+SvIOK_UV||5.006000|+SvIOK_notUV||5.006000|+SvIOK_off|||+SvIOK_only_UV||5.006000|+SvIOK_only|||+SvIOK_on|||+SvIOKp|||+SvIOK|||+SvIVX|||+SvIV_nomg|5.009001||p+SvIV_set|||+SvIVx|||+SvIV|||+SvIsCOW_shared_hash||5.008003|+SvIsCOW||5.008003|+SvLEN_set|||+SvLEN|||+SvLOCK||5.007003|+SvMAGIC_set|5.009003||p+SvNIOK_off|||+SvNIOKp|||+SvNIOK|||+SvNOK_off|||+SvNOK_only|||+SvNOK_on|||+SvNOKp|||+SvNOK|||+SvNVX|||+SvNV_nomg||5.013002|+SvNV_set|||+SvNVx|||+SvNV|||+SvOK|||+SvOOK_offset||5.011000|+SvOOK|||+SvPOK_off|||+SvPOK_only_UTF8||5.006000|+SvPOK_only|||+SvPOK_on|||+SvPOKp|||+SvPOK|||+SvPVX_const|5.009003||p+SvPVX_mutable|5.009003||p+SvPVX|||+SvPV_const|5.009003||p+SvPV_flags_const_nolen|5.009003||p+SvPV_flags_const|5.009003||p+SvPV_flags_mutable|5.009003||p+SvPV_flags|5.007002||p+SvPV_force_flags_mutable|5.009003||p+SvPV_force_flags_nolen|5.009003||p+SvPV_force_flags|5.007002||p+SvPV_force_mutable|5.009003||p+SvPV_force_nolen|5.009003||p+SvPV_force_nomg_nolen|5.009003||p+SvPV_force_nomg|5.007002||p+SvPV_force|||p+SvPV_mutable|5.009003||p+SvPV_nolen_const|5.009003||p+SvPV_nolen|5.006000||p+SvPV_nomg_const_nolen|5.009003||p+SvPV_nomg_const|5.009003||p+SvPV_nomg_nolen|5.013007||p+SvPV_nomg|5.007002||p+SvPV_renew|5.009003||p+SvPV_set|||+SvPVbyte_force||5.009002|+SvPVbyte_nolen||5.006000|+SvPVbytex_force||5.006000|+SvPVbytex||5.006000|+SvPVbyte|5.006000||p+SvPVutf8_force||5.006000|+SvPVutf8_nolen||5.006000|+SvPVutf8x_force||5.006000|+SvPVutf8x||5.006000|+SvPVutf8||5.006000|+SvPVx|||+SvPV|||+SvREFCNT_dec_NN||5.017007|+SvREFCNT_dec|||+SvREFCNT_inc_NN|5.009004||p+SvREFCNT_inc_simple_NN|5.009004||p+SvREFCNT_inc_simple_void_NN|5.009004||p+SvREFCNT_inc_simple_void|5.009004||p+SvREFCNT_inc_simple|5.009004||p+SvREFCNT_inc_void_NN|5.009004||p+SvREFCNT_inc_void|5.009004||p+SvREFCNT_inc|||p+SvREFCNT|||+SvROK_off|||+SvROK_on|||+SvROK|||+SvRV_set|5.009003||p+SvRV|||+SvRXOK||5.009005|+SvRX||5.009005|+SvSETMAGIC|||+SvSHARED_HASH|5.009003||p+SvSHARE||5.007003|+SvSTASH_set|5.009003||p+SvSTASH|||+SvSetMagicSV_nosteal||5.004000|+SvSetMagicSV||5.004000|+SvSetSV_nosteal||5.004000|+SvSetSV|||+SvTAINTED_off||5.004000|+SvTAINTED_on||5.004000|+SvTAINTED||5.004000|+SvTAINT|||+SvTHINKFIRST|||+SvTRUE_nomg||5.013006|+SvTRUE|||+SvTYPE|||+SvUNLOCK||5.007003|+SvUOK|5.007001|5.006000|p+SvUPGRADE|||+SvUTF8_off||5.006000|+SvUTF8_on||5.006000|+SvUTF8||5.006000|+SvUVXx|5.004000||p+SvUVX|5.004000||p+SvUV_nomg|5.009001||p+SvUV_set|5.009003||p+SvUVx|5.004000||p+SvUV|5.004000||p+SvVOK||5.008001|+SvVSTRING_mg|5.009004||p+THIS|||n+UNDERBAR|5.009002||p+UTF8_MAXBYTES|5.009002||p+UVSIZE|5.006000||p+UVTYPE|5.006000||p+UVXf|5.007001||p+UVof|5.006000||p+UVuf|5.006000||p+UVxf|5.006000||p+WARN_ALL|5.006000||p+WARN_AMBIGUOUS|5.006000||p+WARN_ASSERTIONS|5.019002||p+WARN_BAREWORD|5.006000||p+WARN_CLOSED|5.006000||p+WARN_CLOSURE|5.006000||p+WARN_DEBUGGING|5.006000||p+WARN_DEPRECATED|5.006000||p+WARN_DIGIT|5.006000||p+WARN_EXEC|5.006000||p+WARN_EXITING|5.006000||p+WARN_GLOB|5.006000||p+WARN_INPLACE|5.006000||p+WARN_INTERNAL|5.006000||p+WARN_IO|5.006000||p+WARN_LAYER|5.008000||p+WARN_MALLOC|5.006000||p+WARN_MISC|5.006000||p+WARN_NEWLINE|5.006000||p+WARN_NUMERIC|5.006000||p+WARN_ONCE|5.006000||p+WARN_OVERFLOW|5.006000||p+WARN_PACK|5.006000||p+WARN_PARENTHESIS|5.006000||p+WARN_PIPE|5.006000||p+WARN_PORTABLE|5.006000||p+WARN_PRECEDENCE|5.006000||p+WARN_PRINTF|5.006000||p+WARN_PROTOTYPE|5.006000||p+WARN_QW|5.006000||p+WARN_RECURSION|5.006000||p+WARN_REDEFINE|5.006000||p+WARN_REGEXP|5.006000||p+WARN_RESERVED|5.006000||p+WARN_SEMICOLON|5.006000||p+WARN_SEVERE|5.006000||p+WARN_SIGNAL|5.006000||p+WARN_SUBSTR|5.006000||p+WARN_SYNTAX|5.006000||p+WARN_TAINT|5.006000||p+WARN_THREADS|5.008000||p+WARN_UNINITIALIZED|5.006000||p+WARN_UNOPENED|5.006000||p+WARN_UNPACK|5.006000||p+WARN_UNTIE|5.006000||p+WARN_UTF8|5.006000||p+WARN_VOID|5.006000||p+WIDEST_UTYPE|5.015004||p+XCPT_CATCH|5.009002||p+XCPT_RETHROW|5.009002|5.007001|p+XCPT_TRY_END|5.009002|5.004000|p+XCPT_TRY_START|5.009002|5.004000|p+XPUSHi|||+XPUSHmortal|5.009002||p+XPUSHn|||+XPUSHp|||+XPUSHs|||+XPUSHu|5.004000||p+XSPROTO|5.010000||p+XSRETURN_EMPTY|||+XSRETURN_IV|||+XSRETURN_NO|||+XSRETURN_NV|||+XSRETURN_PV|||+XSRETURN_UNDEF|||+XSRETURN_UV|5.008001||p+XSRETURN_YES|||+XSRETURN|||p+XST_mIV|||+XST_mNO|||+XST_mNV|||+XST_mPV|||+XST_mUNDEF|||+XST_mUV|5.008001||p+XST_mYES|||+XS_APIVERSION_BOOTCHECK||5.013004|+XS_EXTERNAL||5.019003|+XS_INTERNAL||5.019003|+XS_VERSION_BOOTCHECK|||+XS_VERSION|||+XSprePUSH|5.006000||p+XS|||+XopDISABLE||5.019003|+XopENABLE||5.019003|+XopENTRY_set||5.019003|+XopENTRY||5.019003|+XopFLAGS||5.013007|+ZeroD|5.009002||p+Zero|||+_aMY_CXT|5.007003||p+_add_range_to_invlist|||+_append_range_to_invlist|||+_core_swash_init|||+_get_swash_invlist|||+_invlist_array_init|||+_invlist_contains_cp|||+_invlist_contents|||+_invlist_dump|||+_invlist_intersection_maybe_complement_2nd|||+_invlist_intersection|||+_invlist_invert_prop|||+_invlist_invert|||+_invlist_len|||+_invlist_populate_swatch|||+_invlist_search|||+_invlist_subtract|||+_invlist_union_maybe_complement_2nd|||+_invlist_union|||+_is_uni_FOO||5.017008|+_is_uni_perl_idcont||5.017008|+_is_uni_perl_idstart||5.017007|+_is_utf8_FOO||5.017008|+_is_utf8_mark||5.017008|+_is_utf8_perl_idcont||5.017008|+_is_utf8_perl_idstart||5.017007|+_new_invlist_C_array|||+_new_invlist|||+_pMY_CXT|5.007003||p+_swash_inversion_hash|||+_swash_to_invlist|||+_to_fold_latin1|||+_to_uni_fold_flags||5.013011|+_to_upper_title_latin1|||+_to_utf8_fold_flags||5.015006|+_to_utf8_lower_flags||5.015006|+_to_utf8_title_flags||5.015006|+_to_utf8_upper_flags||5.015006|+aMY_CXT_|5.007003||p+aMY_CXT|5.007003||p+aTHXR_|5.019002||p+aTHXR|5.019002||p+aTHX_|5.006000||p+aTHX|5.006000||p+aassign_common_vars|||+add_cp_to_invlist|||+add_data|||n+add_utf16_textfilter|||+addmad|||+adjust_size_and_find_bucket|||n+adjust_stack_on_leave|||+alloc_maybe_populate_EXACT|||+alloccopstash|||+allocmy|||+amagic_call|||+amagic_cmp_locale|||+amagic_cmp|||+amagic_deref_call||5.013007|+amagic_i_ncmp|||+amagic_is_enabled|||+amagic_ncmp|||+anonymise_cv_maybe|||+any_dup|||+ao|||+append_madprops|||+apply_attrs_my|||+apply_attrs_string||5.006001|+apply_attrs|||+apply|||+assert_uft8_cache_coherent|||+atfork_lock||5.007003|n+atfork_unlock||5.007003|n+av_arylen_p||5.009003|+av_clear|||+av_create_and_push||5.009005|+av_create_and_unshift_one||5.009005|+av_delete||5.006000|+av_exists||5.006000|+av_extend_guts|||+av_extend|||+av_fetch|||+av_fill|||+av_iter_p||5.011000|+av_len|||+av_make|||+av_pop|||+av_push|||+av_reify|||+av_shift|||+av_store|||+av_tindex||5.017009|+av_top_index||5.017009|+av_undef|||+av_unshift|||+ax|||n+bad_type_gv|||+bad_type_pv|||+bind_match|||+block_end|||+block_gimme||5.004000|+block_start|||+blockhook_register||5.013003|+boolSV|5.004000||p+boot_core_PerlIO|||+boot_core_UNIVERSAL|||+boot_core_mro|||+bytes_cmp_utf8||5.013007|+bytes_from_utf8||5.007001|+bytes_to_uni|||n+bytes_to_utf8||5.006001|+call_argv|5.006000||p+call_atexit||5.006000|+call_list||5.004000|+call_method|5.006000||p+call_pv|5.006000||p+call_sv|5.006000||p+caller_cx||5.013005|+calloc||5.007002|n+cando|||+cast_i32||5.006000|+cast_iv||5.006000|+cast_ulong||5.006000|+cast_uv||5.006000|+check_locale_boundary_crossing|||+check_type_and_open|||+check_uni|||+check_utf8_print|||+checkcomma|||+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|+cl_and|||n+cl_anything|||n+cl_init|||n+cl_is_anything|||n+cl_or|||n+clear_placeholders|||+clone_params_del|||n+clone_params_new|||n+closest_cop|||+compute_EXACTish|||+convert|||+cop_fetch_label||5.015001|+cop_free|||+cop_hints_2hv||5.013007|+cop_hints_fetch_pvn||5.013007|+cop_hints_fetch_pvs||5.013007|+cop_hints_fetch_pv||5.013007|+cop_hints_fetch_sv||5.013007|+cop_store_label||5.015001|+cophh_2hv||5.013007|+cophh_copy||5.013007|+cophh_delete_pvn||5.013007|+cophh_delete_pvs||5.013007|+cophh_delete_pv||5.013007|+cophh_delete_sv||5.013007|+cophh_fetch_pvn||5.013007|+cophh_fetch_pvs||5.013007|+cophh_fetch_pv||5.013007|+cophh_fetch_sv||5.013007|+cophh_free||5.013007|+cophh_new_empty||5.019003|+cophh_store_pvn||5.013007|+cophh_store_pvs||5.013007|+cophh_store_pv||5.013007|+cophh_store_sv||5.013007|+core_prototype|||+core_regclass_swash|||+coresub_op|||+could_it_be_a_POSIX_class|||+cr_textfilter|||+create_eval_scope|||+croak_memory_wrap||5.019003|n+croak_no_mem|||n+croak_no_modify||5.013003|n+croak_nocontext|||vn+croak_popstack|||n+croak_sv||5.013001|+croak_xs_usage||5.010001|n+croak|||v+csighandler||5.009003|n+curmad|||+current_re_engine|||+curse|||+custom_op_desc||5.007003|+custom_op_name||5.007003|+custom_op_register||5.013007|+custom_op_xop||5.013007|+cv_ckproto_len_flags|||+cv_clone_into|||+cv_clone|||+cv_const_sv_or_av|||+cv_const_sv||5.004000|+cv_dump|||+cv_forget_slab|||+cv_get_call_checker||5.013006|+cv_set_call_checker||5.013006|+cv_undef|||+cvgv_set|||+cvstash_set|||+cx_dump||5.005000|+cx_dup|||+cxinc|||+dAXMARK|5.009003||p+dAX|5.007002||p+dITEMS|5.007002||p+dMARK|||+dMULTICALL||5.009003|+dMY_CXT_SV|5.007003||p+dMY_CXT|5.007003||p+dNOOP|5.006000||p+dORIGMARK|||+dSP|||+dTHR|5.004050||p+dTHXR|5.019002||p+dTHXa|5.006000||p+dTHXoa|5.006000||p+dTHX|5.006000||p+dUNDERBAR|5.009002||p+dVAR|5.009003||p+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|||+delete_eval_scope|||+delimcpy||5.004000|n+deprecate_commaless_var_list|||+despatch_signals||5.007001|+destroy_matcher|||+die_nocontext|||vn+die_sv||5.013001|+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_op_xmldump|||+do_open9||5.006000|+do_openn||5.007001|+do_open||5.004000|+do_pmop_dump||5.006000|+do_pmop_xmldump|||+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|||+dofile|||+dofindlabel|||+doform|||+doing_taint||5.008001|n+dooneliner|||+doopen_pm|||+doparseform|||+dopoptoeval|||+dopoptogiven|||+dopoptolabel|||+dopoptoloop|||+dopoptosub_at|||+dopoptowhen|||+doref||5.009003|+dounwind|||+dowantarray|||+dump_all_perl|||+dump_all||5.006000|+dump_eval||5.006000|+dump_exec_pos|||+dump_fds|||+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|||+emulate_cop_io|||+eval_pv|5.006000||p+eval_sv|5.006000||p+exec_failed|||+expect_number|||+fbm_compile||5.005000|+fbm_instr||5.005000|+feature_is_enabled|||+filter_add|||+filter_del|||+filter_gets|||+filter_read|||+finalize_optree|||+finalize_op|||+find_and_forget_pmops|||+find_array_subscript|||+find_beginning|||+find_byclass|||+find_hash_subscript|||+find_in_my_stash|||+find_lexical_cv|||+find_runcv_where|||+find_runcv||5.008001|+find_rundefsv2|||+find_rundefsvoffset||5.009002|+find_rundefsv||5.013002|+find_script|||+find_uninit_var|||+first_symbol|||n+foldEQ_latin1||5.013008|n+foldEQ_locale||5.013002|n+foldEQ_utf8_flags||5.013010|+foldEQ_utf8||5.013002|+foldEQ||5.013002|n+fold_constants|||+forbid_setid|||+force_ident_maybe_lex|||+force_ident|||+force_list|||+force_next|||+force_strict_version|||+force_version|||+force_word|||+forget_pmop|||+form_nocontext|||vn+form_short_octal_warning|||+form||5.004000|v+fp_dup|||+fprintf_nocontext|||vn+free_global_struct|||+free_tied_hv_pool|||+free_tmps|||+gen_constant_list|||+get_and_check_backslash_N_name|||+get_aux_mg|||+get_av|5.006000||p+get_context||5.006000|n+get_cvn_flags|5.009005||p+get_cvs|5.011000||p+get_cv|5.006000||p+get_db_sub|||+get_debug_opts|||+get_hash_seed|||+get_hv|5.006000||p+get_invlist_iter_addr|||+get_invlist_offset_addr|||+get_invlist_previous_index_addr|||+get_mstats|||+get_no_modify|||+get_num|||+get_op_descs||5.005000|+get_op_names||5.005000|+get_opargs|||+get_ppaddr||5.006000|+get_re_arg|||+get_sv|5.006000||p+get_vtbl||5.005030|+getcwd_sv||5.007002|+getenv_len|||+glob_2number|||+glob_assign_glob|||+glob_assign_ref|||+gp_dup|||+gp_free|||+gp_ref|||+grok_bin|5.007003||p+grok_bslash_N|||+grok_bslash_c|||+grok_bslash_o|||+grok_bslash_x|||+grok_hex|5.007003||p+grok_number|5.007002||p+grok_numeric_radix|5.007002||p+grok_oct|5.007003||p+group_end|||+gv_AVadd|||+gv_HVadd|||+gv_IOadd|||+gv_SVadd|||+gv_add_by_type||5.011000|+gv_autoload4||5.004000|+gv_autoload_pvn||5.015004|+gv_autoload_pv||5.015004|+gv_autoload_sv||5.015004|+gv_check|||+gv_const_sv||5.009003|+gv_dump||5.006000|+gv_efullname3||5.004000|+gv_efullname4||5.006001|+gv_efullname|||+gv_ename|||+gv_fetchfile_flags||5.009005|+gv_fetchfile|||+gv_fetchmeth_autoload||5.007003|+gv_fetchmeth_pv_autoload||5.015004|+gv_fetchmeth_pvn_autoload||5.015004|+gv_fetchmeth_pvn||5.015004|+gv_fetchmeth_pv||5.015004|+gv_fetchmeth_sv_autoload||5.015004|+gv_fetchmeth_sv||5.015004|+gv_fetchmethod_autoload||5.004000|+gv_fetchmethod_pv_flags||5.015004|+gv_fetchmethod_pvn_flags||5.015004|+gv_fetchmethod_sv_flags||5.015004|+gv_fetchmethod|||+gv_fetchmeth|||+gv_fetchpvn_flags|5.009002||p+gv_fetchpvs|5.009004||p+gv_fetchpv|||+gv_fetchsv|5.009002||p+gv_fullname3||5.004000|+gv_fullname4||5.006001|+gv_fullname|||+gv_handler||5.007001|+gv_init_pvn||5.015004|+gv_init_pv||5.015004|+gv_init_svtype|||+gv_init_sv||5.015004|+gv_init|||+gv_magicalize_isa|||+gv_name_set||5.009004|+gv_stashpvn|5.004000||p+gv_stashpvs|5.009003||p+gv_stashpv|||+gv_stashsv|||+gv_try_downgrade|||+handle_regex_sets|||+he_dup|||+hek_dup|||+hfree_next_entry|||+hfreeentries|||+hsplit|||+hv_assert|||+hv_auxinit|||+hv_backreferences_p|||+hv_clear_placeholders||5.009001|+hv_clear|||+hv_common_key_len||5.010000|+hv_common||5.010000|+hv_copy_hints_hv||5.009004|+hv_delayfree_ent||5.004000|+hv_delete_common|||+hv_delete_ent||5.004000|+hv_delete|||+hv_eiter_p||5.009003|+hv_eiter_set||5.009003|+hv_ename_add|||+hv_ename_delete|||+hv_exists_ent||5.004000|+hv_exists|||+hv_fetch_ent||5.004000|+hv_fetchs|5.009003||p+hv_fetch|||+hv_fill||5.013002|+hv_free_ent_ret|||+hv_free_ent||5.004000|+hv_iterinit|||+hv_iterkeysv||5.004000|+hv_iterkey|||+hv_iternext_flags||5.008000|+hv_iternextsv|||+hv_iternext|||+hv_iterval|||+hv_kill_backrefs|||+hv_ksplit||5.004000|+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.017011|+hv_riter_p||5.009003|+hv_riter_set||5.009003|+hv_scalar||5.009001|+hv_store_ent||5.004000|+hv_store_flags||5.008000|+hv_stores|5.009004||p+hv_store|||+hv_undef_flags|||+hv_undef|||+ibcmp_locale||5.004000|+ibcmp_utf8||5.007003|+ibcmp|||+incline|||+incpush_if_exists|||+incpush_use_sep|||+incpush|||+ingroup|||+init_argv_symbols|||+init_constants|||+init_dbargs|||+init_debugger|||+init_global_struct|||+init_i18nl10n||5.006000|+init_i18nl14n||5.006000|+init_ids|||+init_interp|||+init_main_stash|||+init_perllib|||+init_postdump_symbols|||+init_predump_symbols|||+init_stacks||5.005000|+init_tm||5.007002|+inplace_aassign|||+instr|||n+intro_my|||+intuit_method|||+intuit_more|||+invert|||+invlist_array|||+invlist_clone|||+invlist_extend|||+invlist_highest|||+invlist_is_iterating|||+invlist_iterfinish|||+invlist_iterinit|||+invlist_iternext|||+invlist_max|||+invlist_previous_index|||+invlist_set_len|||+invlist_set_previous_index|||+invlist_trim|||+invoke_exception_hook|||+io_close|||+isALNUMC|5.006000||p+isALNUM_lazy|||+isALPHANUMERIC||5.017008|+isALPHA|||+isASCII|5.006000|5.006000|p+isBLANK|5.006001||p+isCNTRL|5.006000|5.006000|p+isDIGIT|||+isFOO_lc|||+isFOO_utf8_lc|||+isGRAPH|5.006000||p+isGV_with_GP|5.009004||p+isIDCONT||5.017008|+isIDFIRST_lazy|||+isIDFIRST|||+isLOWER|||+isOCTAL||5.013005|+isPRINT|5.004000||p+isPSXSPC|5.006001||p+isPUNCT|5.006000||p+isSPACE|||+isUPPER|||+isWORDCHAR||5.013006|+isXDIGIT|5.006000||p+is_an_int|||+is_ascii_string||5.011000|n+is_cur_LC_category_utf8|||+is_handle_constructor|||n+is_list_assignment|||+is_lvalue_sub||5.007001|+is_uni_alnum_lc||5.006000|+is_uni_alnumc_lc||5.017007|+is_uni_alnumc||5.017007|+is_uni_alnum||5.006000|+is_uni_alpha_lc||5.006000|+is_uni_alpha||5.006000|+is_uni_ascii_lc||5.006000|+is_uni_ascii||5.006000|+is_uni_blank_lc||5.017002|+is_uni_blank||5.017002|+is_uni_cntrl_lc||5.006000|+is_uni_cntrl||5.006000|+is_uni_digit_lc||5.006000|+is_uni_digit||5.006000|+is_uni_graph_lc||5.006000|+is_uni_graph||5.006000|+is_uni_idfirst_lc||5.006000|+is_uni_idfirst||5.006000|+is_uni_lower_lc||5.006000|+is_uni_lower||5.006000|+is_uni_print_lc||5.006000|+is_uni_print||5.006000|+is_uni_punct_lc||5.006000|+is_uni_punct||5.006000|+is_uni_space_lc||5.006000|+is_uni_space||5.006000|+is_uni_upper_lc||5.006000|+is_uni_upper||5.006000|+is_uni_xdigit_lc||5.006000|+is_uni_xdigit||5.006000|+is_utf8_alnumc||5.017007|+is_utf8_alnum||5.006000|+is_utf8_alpha||5.006000|+is_utf8_ascii||5.006000|+is_utf8_blank||5.017002|+is_utf8_char_buf||5.015008|n+is_utf8_char_slow|||n+is_utf8_char||5.006000|n+is_utf8_cntrl||5.006000|+is_utf8_common|||+is_utf8_digit||5.006000|+is_utf8_graph||5.006000|+is_utf8_idcont||5.008000|+is_utf8_idfirst||5.006000|+is_utf8_lower||5.006000|+is_utf8_mark||5.006000|+is_utf8_perl_space||5.011001|+is_utf8_perl_word||5.011001|+is_utf8_posix_digit||5.011001|+is_utf8_print||5.006000|+is_utf8_punct||5.006000|+is_utf8_space||5.006000|+is_utf8_string_loclen||5.009003|n+is_utf8_string_loc||5.008001|n+is_utf8_string||5.006001|n+is_utf8_upper||5.006000|+is_utf8_xdigit||5.006000|+is_utf8_xidcont||5.013010|+is_utf8_xidfirst||5.013010|+isa_lookup|||+items|||n+ix|||n+jmaybe|||+join_exact|||+keyword_plugin_standard|||+keyword|||+leave_scope|||+lex_bufutf8||5.011002|+lex_discard_to||5.011002|+lex_grow_linestr||5.011002|+lex_next_chunk||5.011002|+lex_peek_unichar||5.011002|+lex_read_space||5.011002|+lex_read_to||5.011002|+lex_read_unichar||5.011002|+lex_start||5.009005|+lex_stuff_pvn||5.011002|+lex_stuff_pvs||5.013005|+lex_stuff_pv||5.013006|+lex_stuff_sv||5.011002|+lex_unstuff||5.011002|+listkids|||+list|||+load_module_nocontext|||vn+load_module|5.006000||pv+localize|||+looks_like_bool|||+looks_like_number|||+lop|||+mPUSHi|5.009002||p+mPUSHn|5.009002||p+mPUSHp|5.009002||p+mPUSHs|5.010001||p+mPUSHu|5.009002||p+mXPUSHi|5.009002||p+mXPUSHn|5.009002||p+mXPUSHp|5.009002||p+mXPUSHs|5.010001||p+mXPUSHu|5.009002||p+mad_free|||+madlex|||+madparse|||+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_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_setdefelem|||+magic_setenv|||+magic_sethint|||+magic_setisa|||+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_failtable|||+make_trie|||+malloc_good_size|||n+malloced_size|||n+malloc||5.007002|n+markstack_grow|||+matcher_matches_sv|||+mayberelocate|||+measure_struct|||+memEQs|5.009005||p+memEQ|5.004000||p+memNEs|5.009005||p+memNE|5.004000||p+mem_collxfrm|||+mem_log_common|||n+mess_alloc|||+mess_nocontext|||vn+mess_sv||5.013001|+mess||5.006000|v+method_common|||+mfree||5.007002|n+mg_clear|||+mg_copy|||+mg_dup|||+mg_find_mglob|||+mg_findext||5.013008|+mg_find|||+mg_free_type||5.013006|+mg_free|||+mg_get|||+mg_length||5.005000|+mg_localize|||+mg_magical|||+mg_set|||+mg_size||5.005000|+mini_mktime||5.007002|+minus_v|||+missingterm|||+mode_from_discipline|||+modkids|||+more_bodies|||+more_sv|||+moreswitches|||+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+my_atof2||5.007002|+my_atof||5.006000|+my_attrs|||+my_bcopy|||n+my_bzero|||n+my_chsize|||+my_clearenv|||+my_cxt_index|||+my_cxt_init|||+my_dirfd||5.009005|+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.019003|+my_memcmp|||n+my_memset||5.004000|n+my_pclose||5.004000|+my_popen_list||5.007001|+my_popen||5.004000|+my_setenv|||+my_snprintf|5.009004||pvn+my_socketpair||5.007003|n+my_sprintf|5.009003||pvn+my_stat_flags|||+my_stat||5.019003|+my_strftime||5.007002|+my_strlcat|5.009004||pn+my_strlcpy|5.009004||pn+my_unexec|||+my_vsnprintf||5.009004|n+need_utf8|||n+newANONATTRSUB||5.006000|+newANONHASH|||+newANONLIST|||+newANONSUB|||+newASSIGNOP|||+newATTRSUB_flags|||+newATTRSUB||5.006000|+newAVREF|||+newAV|||+newBINOP|||+newCONDOP|||+newCONSTSUB_flags||5.015006|+newCONSTSUB|5.004050||p+newCVREF|||+newDEFSVOP|||+newFORM|||+newFOROP||5.013007|+newGIVENOP||5.009003|+newGIVWHENOP|||+newGP|||+newGVOP|||+newGVREF|||+newGVgen_flags||5.015004|+newGVgen|||+newHVREF|||+newHVhv||5.005000|+newHV|||+newIO|||+newLISTOP|||+newLOGOP|||+newLOOPEX|||+newLOOPOP|||+newMADPROP|||+newMADsv|||+newMYSUB||5.017004|+newNULLLIST|||+newOP|||+newPADOP|||+newPMOP|||+newPROG|||+newPVOP|||+newRANGE|||+newRV_inc|5.004000||p+newRV_noinc|5.004000||p+newRV|||+newSLICEOP|||+newSTATEOP|||+newSTUB|||+newSUB|||+newSVOP|||+newSVREF|||+newSV_type|5.009005||p+newSVhek||5.009003|+newSViv|||+newSVnv|||+newSVpadname||5.017004|+newSVpv_share||5.013006|+newSVpvf_nocontext|||vn+newSVpvf||5.004000|v+newSVpvn_flags|5.010001||p+newSVpvn_share|5.007001||p+newSVpvn_utf8|5.010001||p+newSVpvn|5.004050||p+newSVpvs_flags|5.010001||p+newSVpvs_share|5.009003||p+newSVpvs|5.009003||p+newSVpv|||+newSVrv|||+newSVsv|||+newSVuv|5.006000||p+newSV|||+newTOKEN|||+newUNOP|||+newWHENOP||5.009003|+newWHILEOP||5.013007|+newXS_flags||5.009004|+newXS_len_flags|||+newXSproto||5.006000|+newXS||5.006000|+new_collate||5.006000|+new_constant|||+new_ctype||5.006000|+new_he|||+new_logop|||+new_numeric||5.006000|+new_stackinfo||5.005000|+new_version||5.009000|+new_warnings_bitfield|||+next_symbol|||+nextargv|||+nextchar|||+ninstr|||n+no_bareword_allowed|||+no_fh_allowed|||+no_op|||+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_const_sv|||+op_contextualize||5.013006|+op_dump||5.006000|+op_free|||+op_getmad_weak|||+op_getmad|||+op_integerize|||+op_linklist||5.013006|+op_lvalue_flags|||+op_lvalue||5.013007|+op_null||5.007002|+op_prepend_elem||5.013006|+op_refcnt_dec|||+op_refcnt_inc|||+op_refcnt_lock||5.009002|+op_refcnt_unlock||5.009002|+op_scope||5.013007|+op_std_init|||+op_unscope|||+op_xmldump|||+open_script|||+opslab_force_free|||+opslab_free_nopad|||+opslab_free|||+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_alloc_name|||+pad_alloc|||+pad_block_start|||+pad_check_dup|||+pad_compname_type||5.009003|+pad_findlex|||+pad_findmy_pvn||5.015001|+pad_findmy_pvs||5.015001|+pad_findmy_pv||5.015001|+pad_findmy_sv||5.015001|+pad_fixup_inner_anons|||+pad_free|||+pad_leavemy|||+pad_new||5.008001|+pad_peg|||n+pad_push|||+pad_reset|||+pad_setsv|||+pad_sv|||+pad_swipe|||+pad_tidy||5.008001|+padlist_dup|||+padlist_store|||+parse_arithexpr||5.013008|+parse_barestmt||5.013007|+parse_block||5.013007|+parse_body|||+parse_fullexpr||5.013008|+parse_fullstmt||5.013005|+parse_ident|||+parse_label||5.013007|+parse_listexpr||5.013008|+parse_lparen_question_flags|||+parse_stmtseq||5.013006|+parse_termexpr||5.013008|+parse_unicode_opts|||+parser_dup|||+parser_free_nexttoke_ops|||+parser_free|||+path_is_searchable|||n+peep|||+pending_ident|||+perl_alloc_using|||n+perl_alloc|||n+perl_clone_using|||n+perl_clone|||n+perl_construct|||n+perl_destruct||5.007003|n+perl_free|||n+perl_parse||5.006000|n+perl_run|||n+pidgone|||+pm_description|||+pmop_dump||5.006000|+pmop_xmldump|||+pmruntime|||+pmtrans|||+pop_scope|||+populate_isa|||v+pregcomp||5.009005|+pregexec|||+pregfree2||5.011000|+pregfree|||+prepend_madprops|||+prescan_version||5.011004|+printbuf|||+printf_nocontext|||vn+process_special_blocks|||+ptr_hash|||n+ptr_table_clear||5.009005|+ptr_table_fetch||5.009005|+ptr_table_find|||n+ptr_table_free||5.009005|+ptr_table_new||5.009005|+ptr_table_split||5.009005|+ptr_table_store||5.009005|+push_scope|||+put_byte|||+put_latin1_charclass_innards|||+pv_display|5.006000||p+pv_escape|5.009004||p+pv_pretty|5.009004||p+pv_uni_display||5.007003|+qerror|||+qsortsvu|||+re_compile||5.009005|+re_croak2|||+re_dup_guts|||+re_intuit_start||5.019001|+re_intuit_string||5.006000|+re_op_compile|||+readpipe_override|||+realloc||5.007002|n+reentrant_free||5.019003|+reentrant_init||5.019003|+reentrant_retry||5.019003|vn+reentrant_size||5.019003|+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.019003|+reg_check_named_buff_matched|||+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|||+reg_temp_copy|||+reganode|||+regatom|||+regbranch|||+regclass_swash||5.009004|+regclass|||+regcppop|||+regcppush|||+regcurly|||+regdump_extflags|||+regdump_intflags|||+regdump||5.005000|+regdupe_internal|||+regexec_flags||5.005000|+regfree_internal||5.009005|+reghop3|||n+reghop4|||n+reghopmaybe3|||n+reginclass|||+reginitcolors||5.006000|+reginsert|||+regmatch|||+regnext||5.005000|+regpatws|||n+regpiece|||+regpposixcc|||+regprop|||+regrepeat|||+regtail_study|||+regtail|||+regtry|||+reguni|||+regwhite|||n+reg|||+repeatcpy|||n+report_evil_fh|||+report_redefined_cv|||+report_uninit|||+report_wrongway_fh|||+require_pv||5.006000|+require_tie_mod|||+restore_magic|||+rninstr|||n+rpeep|||+rsignal_restore|||+rsignal_save|||+rsignal_state||5.004000|+rsignal||5.004000|+run_body|||+run_user_filter|||+runops_debug||5.005000|+runops_standard||5.005000|+rv2cv_op_cv||5.013006|+rvpv_dup|||+rxres_free|||+rxres_restore|||+rxres_save|||+safesyscalloc||5.006000|n+safesysfree||5.006000|n+safesysmalloc||5.006000|n+safesysrealloc||5.006000|n+same_dirent|||+save_I16||5.004000|+save_I32|||+save_I8||5.006000|+save_adelete||5.011000|+save_aelem_flags||5.011000|+save_aelem||5.004050|+save_alloc||5.006000|+save_aptr|||+save_ary|||+save_bool||5.008001|+save_clearsv|||+save_delete|||+save_destructor_x||5.006000|+save_destructor||5.006000|+save_freeop|||+save_freepv|||+save_freesv|||+save_generic_pvref||5.006001|+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|+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_svref|||+save_vptr||5.006000|+savepvn|||+savepvs||5.009003|+savepv|||+savesharedpvn||5.009005|+savesharedpvs||5.013006|+savesharedpv||5.007003|+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|||+screaminstr||5.005000|+search_const|||+seed||5.008001|+sequence_num|||+set_context||5.006000|n+set_numeric_local||5.006000|+set_numeric_radix||5.006000|+set_numeric_standard||5.006000|+setdefout|||+share_hek_flags|||+share_hek||5.004000|+si_dup|||+sighandler|||n+simplify_sort|||+skipspace0|||+skipspace1|||+skipspace2|||+skipspace_flags|||+softref2xv|||+sortcv_stacked|||+sortcv_xsub|||+sortcv|||+sortsv_flags||5.009003|+sortsv||5.007003|+space_join_names_mortal|||+ss_dup|||+stack_grow|||+start_force|||+start_glob|||+start_subparse||5.004000|+stdize_locale|||+strEQ|||+strGE|||+strGT|||+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|||+sv_2num|||+sv_2nv_flags||5.013001|+sv_2pv_flags|5.007002||p+sv_2pv_nolen|5.006000||p+sv_2pvbyte_nolen|5.006000||p+sv_2pvbyte|5.006000||p+sv_2pvutf8_nolen||5.006000|+sv_2pvutf8||5.006000|+sv_2pv|||+sv_2uv_flags||5.009001|+sv_2uv|5.004000||p+sv_add_arena|||+sv_add_backref|||+sv_backoff|||+sv_bless|||+sv_cat_decode||5.008001|+sv_catpv_flags||5.013006|+sv_catpv_mg|5.004050||p+sv_catpv_nomg||5.013006|+sv_catpvf_mg_nocontext|||pvn+sv_catpvf_mg|5.006000|5.004000|pv+sv_catpvf_nocontext|||vn+sv_catpvf||5.004000|v+sv_catpvn_flags||5.007002|+sv_catpvn_mg|5.004050||p+sv_catpvn_nomg|5.007002||p+sv_catpvn|||+sv_catpvs_flags||5.013006|+sv_catpvs_mg||5.013006|+sv_catpvs_nomg||5.013006|+sv_catpvs|5.009003||p+sv_catpv|||+sv_catsv_flags||5.007002|+sv_catsv_mg|5.004050||p+sv_catsv_nomg|5.007002||p+sv_catsv|||+sv_catxmlpvn|||+sv_catxmlpv|||+sv_catxmlsv|||+sv_chop|||+sv_clean_all|||+sv_clean_objs|||+sv_clear|||+sv_cmp_flags||5.013006|+sv_cmp_locale_flags||5.013006|+sv_cmp_locale||5.004000|+sv_cmp|||+sv_collxfrm_flags||5.013006|+sv_collxfrm|||+sv_copypv_flags||5.017002|+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_free2|||+sv_free_arenas|||+sv_free|||+sv_gets||5.004000|+sv_grow|||+sv_i_ncmp|||+sv_inc_nomg||5.013002|+sv_inc|||+sv_insert_flags||5.010001|+sv_insert|||+sv_isa|||+sv_isobject|||+sv_iv||5.005000|+sv_kill_backrefs|||+sv_len_utf8_nomg|||+sv_len_utf8||5.006000|+sv_len|||+sv_magic_portable|5.019003|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_peek||5.005000|+sv_pos_b2u_flags||5.019003|+sv_pos_b2u_midway|||+sv_pos_b2u||5.006000|+sv_pos_u2b_cached|||+sv_pos_u2b_flags||5.011005|+sv_pos_u2b_forwards|||n+sv_pos_u2b_midway|||n+sv_pos_u2b||5.006000|+sv_pvbyten_force||5.006000|+sv_pvbyten||5.006000|+sv_pvbyte||5.006000|+sv_pvn_force_flags|5.007002||p+sv_pvn_force|||+sv_pvn_nomg|5.007003|5.005000|p+sv_pvn||5.005000|+sv_pvutf8n_force||5.006000|+sv_pvutf8n||5.006000|+sv_pvutf8||5.006000|+sv_pv||5.006000|+sv_recode_to_utf8||5.007003|+sv_reftype|||+sv_ref|||+sv_release_COW|||+sv_replace|||+sv_report_used|||+sv_resetpvn|||+sv_reset|||+sv_rvweaken||5.006000|+sv_sethek|||+sv_setiv_mg|5.004050||p+sv_setiv|||+sv_setnv_mg|5.006000||p+sv_setnv|||+sv_setpv_mg|5.004050||p+sv_setpvf_mg_nocontext|||pvn+sv_setpvf_mg|5.006000|5.004000|pv+sv_setpvf_nocontext|||vn+sv_setpvf||5.004000|v+sv_setpviv_mg||5.008001|+sv_setpviv||5.008001|+sv_setpvn_mg|5.004050||p+sv_setpvn|||+sv_setpvs_mg||5.013006|+sv_setpvs|5.009004||p+sv_setpv|||+sv_setref_iv|||+sv_setref_nv|||+sv_setref_pvn|||+sv_setref_pvs||5.019003|+sv_setref_pv|||+sv_setref_uv||5.007001|+sv_setsv_cow|||+sv_setsv_flags||5.007002|+sv_setsv_mg|5.004050||p+sv_setsv_nomg|5.007002||p+sv_setsv|||+sv_setuv_mg|5.004050||p+sv_setuv|5.004000||p+sv_tainted||5.004000|+sv_taint||5.004000|+sv_true||5.005000|+sv_unglob|||+sv_uni_display||5.007003|+sv_unmagicext||5.013008|+sv_unmagic|||+sv_unref_flags||5.007001|+sv_unref|||+sv_untaint||5.004000|+sv_upgrade|||+sv_usepvn_flags||5.009004|+sv_usepvn_mg|5.004050||p+sv_usepvn|||+sv_utf8_decode||5.006000|+sv_utf8_downgrade||5.006000|+sv_utf8_encode||5.006000|+sv_utf8_upgrade_flags_grow||5.011000|+sv_utf8_upgrade_flags||5.007002|+sv_utf8_upgrade_nomg||5.007002|+sv_utf8_upgrade||5.007001|+sv_uv|5.005000||p+sv_vcatpvf_mg|5.006000|5.004000|p+sv_vcatpvfn_flags||5.017002|+sv_vcatpvfn||5.004000|+sv_vcatpvf|5.006000|5.004000|p+sv_vsetpvf_mg|5.006000|5.004000|p+sv_vsetpvfn||5.004000|+sv_vsetpvf|5.006000|5.004000|p+sv_xmlpeek|||+svtype|||+swallow_bom|||+swash_fetch||5.007002|+swash_init||5.006000|+swatch_get|||+sys_init3||5.010000|n+sys_init||5.010000|n+sys_intern_clear|||+sys_intern_dup|||+sys_intern_init|||+sys_term||5.010000|n+taint_env|||+taint_proper|||+tied_method|||v+tmps_grow||5.006000|+toFOLD_uni||5.007003|+toFOLD_utf8||5.019001|+toFOLD||5.019001|+toLOWER_L1||5.019001|+toLOWER_LC||5.004000|+toLOWER_uni||5.007003|+toLOWER_utf8||5.015007|+toLOWER|||+toTITLE_uni||5.007003|+toTITLE_utf8||5.015007|+toTITLE||5.019001|+toUPPER_uni||5.007003|+toUPPER_utf8||5.015007|+toUPPER||5.004000|+to_byte_substr|||+to_lower_latin1|||+to_uni_fold||5.007003|+to_uni_lower_lc||5.006000|+to_uni_lower||5.007003|+to_uni_title_lc||5.006000|+to_uni_title||5.007003|+to_uni_upper_lc||5.006000|+to_uni_upper||5.007003|+to_utf8_case||5.007003|+to_utf8_fold||5.015007|+to_utf8_lower||5.015007|+to_utf8_substr|||+to_utf8_title||5.015007|+to_utf8_upper||5.015007|+token_free|||+token_getmad|||+tokenize_use|||+tokeq|||+tokereport|||+too_few_arguments_pv|||+too_few_arguments_sv|||+too_many_arguments_pv|||+too_many_arguments_sv|||+translate_substr_offsets|||+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.004000|+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||5.006000|+utf8_length||5.007001|+utf8_mg_len_cache_update|||+utf8_mg_pos_cache_update|||+utf8_to_bytes||5.006001|+utf8_to_uvchr_buf||5.015009|+utf8_to_uvchr||5.007001|+utf8_to_uvuni_buf||5.015009|+utf8_to_uvuni||5.007001|+utf8n_to_uvchr|||+utf8n_to_uvuni||5.007001|+utilize|||+uvchr_to_utf8_flags||5.007003|+uvchr_to_utf8|||+uvuni_to_utf8_flags||5.007003|+uvuni_to_utf8||5.007001|+valid_utf8_to_uvchr|||+valid_utf8_to_uvuni||5.015009|+validate_proto|||+validate_suid|||+varname|||+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|+vnewSVpvf|5.006000|5.004000|p+vnormal||5.009002|+vnumify||5.009000|+vstringify||5.009000|+vverify||5.009003|+vwarner||5.006000|+vwarn||5.006000|+wait4pid|||+warn_nocontext|||vn+warn_sv||5.013001|+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|||+xmldump_all_perl|||+xmldump_all|||+xmldump_attr|||+xmldump_eval|||+xmldump_form|||+xmldump_indent|||v+xmldump_packsubs_perl|||+xmldump_packsubs|||+xmldump_sub_perl|||+xmldump_sub|||+xmldump_vindent|||+xs_apiversion_bootcheck|||+xs_version_bootcheck|||+yyerror_pvn|||+yyerror_pv|||+yyerror|||+yylex|||+yyparse|||+yyunlex|||+yywarn|||+);++if (exists $opt{'list-unsupported'}) {+  my $f;+  for $f (sort { lc $a cmp lc $b } keys %API) {+    next unless $API{$f}{todo};+    print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";+  }+  exit 0;+}++# Scan for possible replacement candidates++my(%replace, %need, %hints, %warnings, %depends);+my $replace = 0;+my($hint, $define, $function);++sub find_api+{+  my $code = shift;+  $code =~ s{+    / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)+  | "[^"\\]*(?:\\.[^"\\]*)*"+  | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx;+  grep { exists $API{$_} } $code =~ /(\w+)/mg;+}++while (<DATA>) {+  if ($hint) {+    my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;+    if (m{^\s*\*\s(.*?)\s*$}) {+      for (@{$hint->[1]}) {+        $h->{$_} ||= '';  # suppress warning with older perls+        $h->{$_} .= "$1\n";+      }+    }+    else { undef $hint }+  }++  $hint = [$1, [split /,?\s+/, $2]]+      if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$};++  if ($define) {+    if ($define->[1] =~ /\\$/) {+      $define->[1] .= $_;+    }+    else {+      if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {+        my @n = find_api($define->[1]);+        push @{$depends{$define->[0]}}, @n if @n+      }+      undef $define;+    }+  }++  $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)};++  if ($function) {+    if (/^}/) {+      if (exists $API{$function->[0]}) {+        my @n = find_api($function->[1]);+        push @{$depends{$function->[0]}}, @n if @n+      }+      undef $function;+    }+    else {+      $function->[1] .= $_;+    }+  }++  $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};++  $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};+  $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};+  $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};+  $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};++  if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {+    my @deps = map { s/\s+//g; $_ } split /,/, $3;
+    my $d;+    for $d (map { s/\s+//g; $_ } split /,/, $1) {
+      push @{$depends{$d}}, @deps;+    }+  }++  $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};+}++for (values %depends) {+  my %s;+  $_ = [sort grep !$s{$_}++, @$_];+}++if (exists $opt{'api-info'}) {+  my $f;+  my $count = 0;+  my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";+  for $f (sort { lc $a cmp lc $b } keys %API) {+    next unless $f =~ /$match/;+    print "\n=== $f ===\n\n";+    my $info = 0;+    if ($API{$f}{base} || $API{$f}{todo}) {+      my $base = format_version($API{$f}{base} || $API{$f}{todo});+      print "Supported at least starting from perl-$base.\n";+      $info++;+    }+    if ($API{$f}{provided}) {+      my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003";+      print "Support by $ppport provided back to perl-$todo.\n";+      print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};+      print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};+      print "\n$hints{$f}" if exists $hints{$f};+      print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};+      $info++;+    }+    print "No portability information available.\n" unless $info;+    $count++;+  }+  $count or print "Found no API matching '$opt{'api-info'}'.";+  print "\n";+  exit 0;+}++if (exists $opt{'list-provided'}) {+  my $f;+  for $f (sort { lc $a cmp lc $b } keys %API) {+    next unless $API{$f}{provided};+    my @flags;+    push @flags, 'explicit' if exists $need{$f};+    push @flags, 'depend'   if exists $depends{$f};+    push @flags, 'hint'     if exists $hints{$f};+    push @flags, 'warning'  if exists $warnings{$f};+    my $flags = @flags ? '  ['.join(', ', @flags).']' : '';+    print "$f$flags\n";+  }+  exit 0;+}++my @files;+my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );+my $srcext = join '|', map { quotemeta $_ } @srcext;++if (@ARGV) {+  my %seen;+  for (@ARGV) {+    if (-e) {+      if (-f) {+        push @files, $_ unless $seen{$_}++;+      }+      else { warn "'$_' is not a file.\n" }+    }+    else {+      my @new = grep { -f } glob $_+          or warn "'$_' does not exist.\n";+      push @files, grep { !$seen{$_}++ } @new;+    }+  }+}+else {+  eval {+    require File::Find;+    File::Find::find(sub {+      $File::Find::name =~ /($srcext)$/i+          and push @files, $File::Find::name;+    }, '.');+  };+  if ($@) {+    @files = map { glob "*$_" } @srcext;+  }+}++if (!@ARGV || $opt{filter}) {+  my(@in, @out);+  my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;+  for (@files) {+    my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;+    push @{ $out ? \@out : \@in }, $_;+  }+  if (@ARGV && @out) {+    warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);+  }+  @files = @in;+}++die "No input files given!\n" unless @files;++my(%files, %global, %revreplace);+%revreplace = reverse %replace;+my $filename;+my $patch_opened = 0;++for $filename (@files) {+  unless (open IN, "<$filename") {+    warn "Unable to read from $filename: $!\n";+    next;+  }++  info("Scanning $filename ...");++  my $c = do { local $/; <IN> };+  close IN;++  my %file = (orig => $c, changes => 0);++  # Temporarily remove C/XS comments and strings from the code+  my @ccom;++  $c =~ s{+    ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]*+    | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* )+  | ( ^$HS*\#[^\r\n]*+    | "[^"\\]*(?:\\.[^"\\]*)*"+    | '[^'\\]*(?:\\.[^'\\]*)*'+    | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) )+  }{ defined $2 and push @ccom, $2;+     defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;++  $file{ccom} = \@ccom;+  $file{code} = $c;+  $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m;++  my $func;++  for $func (keys %API) {+    my $match = $func;+    $match .= "|$revreplace{$func}" if exists $revreplace{$func};+    if ($c =~ /\b(?:Perl_)?($match)\b/) {+      $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};+      $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;+      if (exists $API{$func}{provided}) {+        $file{uses_provided}{$func}++;+        if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {+          $file{uses}{$func}++;+          my @deps = rec_depend($func);+          if (@deps) {+            $file{uses_deps}{$func} = \@deps;+            for (@deps) {+              $file{uses}{$_} = 0 unless exists $file{uses}{$_};+            }+          }+          for ($func, @deps) {+            $file{needs}{$_} = 'static' if exists $need{$_};+          }+        }+      }+      if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) {+        if ($c =~ /\b$func\b/) {+          $file{uses_todo}{$func}++;+        }+      }+    }+  }++  while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {+    if (exists $need{$2}) {+      $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;+    }+    else { warning("Possibly wrong #define $1 in $filename") }+  }++  for (qw(uses needs uses_todo needed_global needed_static)) {+    for $func (keys %{$file{$_}}) {+      push @{$global{$_}{$func}}, $filename;+    }+  }++  $files{$filename} = \%file;+}++# Globally resolve NEED_'s+my $need;+for $need (keys %{$global{needs}}) {+  if (@{$global{needs}{$need}} > 1) {+    my @targets = @{$global{needs}{$need}};+    my @t = grep $files{$_}{needed_global}{$need}, @targets;+    @targets = @t if @t;+    @t = grep /\.xs$/i, @targets;+    @targets = @t if @t;+    my $target = shift @targets;+    $files{$target}{needs}{$need} = 'global';+    for (@{$global{needs}{$need}}) {+      $files{$_}{needs}{$need} = 'extern' if $_ ne $target;+    }+  }+}++for $filename (@files) {+  exists $files{$filename} or next;++  info("=== Analyzing $filename ===");++  my %file = %{$files{$filename}};+  my $func;+  my $c = $file{code};+  my $warnings = 0;++  for $func (sort keys %{$file{uses_Perl}}) {+    if ($API{$func}{varargs}) {+      unless ($API{$func}{nothxarg}) {+        my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}+                              { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);+        if ($changes) {+          warning("Doesn't pass interpreter argument aTHX to Perl_$func");+          $file{changes} += $changes;+        }+      }+    }+    else {+      warning("Uses Perl_$func instead of $func");+      $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}+                                {$func$1(}g);+    }+  }++  for $func (sort keys %{$file{uses_replace}}) {+    warning("Uses $func instead of $replace{$func}");+    $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);+  }++  for $func (sort keys %{$file{uses_provided}}) {+    if ($file{uses}{$func}) {+      if (exists $file{uses_deps}{$func}) {+        diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));+      }+      else {+        diag("Uses $func");+      }+    }+    $warnings += hint($func);+  }++  unless ($opt{quiet}) {+    for $func (sort keys %{$file{uses_todo}}) {+      print "*** WARNING: Uses $func, which may not be portable below perl ",+            format_version($API{$func}{todo}), ", even with '$ppport'\n";+      $warnings++;+    }+  }++  for $func (sort keys %{$file{needed_static}}) {+    my $message = '';+    if (not exists $file{uses}{$func}) {+      $message = "No need to define NEED_$func if $func is never used";+    }+    elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {+      $message = "No need to define NEED_$func when already needed globally";+    }+    if ($message) {+      diag($message);+      $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
+    }+  }++  for $func (sort keys %{$file{needed_global}}) {+    my $message = '';+    if (not exists $global{uses}{$func}) {+      $message = "No need to define NEED_${func}_GLOBAL if $func is never used";+    }+    elsif (exists $file{needs}{$func}) {+      if ($file{needs}{$func} eq 'extern') {+        $message = "No need to define NEED_${func}_GLOBAL when already needed globally";+      }+      elsif ($file{needs}{$func} eq 'static') {+        $message = "No need to define NEED_${func}_GLOBAL when only used in this file";+      }+    }+    if ($message) {+      diag($message);+      $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
+    }+  }++  $file{needs_inc_ppport} = keys %{$file{uses}};++  if ($file{needs_inc_ppport}) {+    my $pp = '';++    for $func (sort keys %{$file{needs}}) {+      my $type = $file{needs}{$func};+      next if $type eq 'extern';+      my $suffix = $type eq 'global' ? '_GLOBAL' : '';+      unless (exists $file{"needed_$type"}{$func}) {+        if ($type eq 'global') {+          diag("Files [@{$global{needs}{$func}}] need $func, adding global request");+        }+        else {+          diag("File needs $func, adding static request");+        }+        $pp .= "#define NEED_$func$suffix\n";+      }+    }++    if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {+      $pp = '';+      $file{changes}++;+    }++    unless ($file{has_inc_ppport}) {+      diag("Needs to include '$ppport'");+      $pp .= qq(#include "$ppport"\n)+    }++    if ($pp) {+      $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)+                     || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)+                     || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)+                     || ($c =~ s/^/$pp/);+    }+  }+  else {+    if ($file{has_inc_ppport}) {+      diag("No need to include '$ppport'");+      $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
+    }+  }++  # put back in our C comments+  my $ix;+  my $cppc = 0;+  my @ccom = @{$file{ccom}};+  for $ix (0 .. $#ccom) {+    if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
+      $cppc++;+      $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;+    }+    else {+      $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;+    }+  }++  if ($cppc) {+    my $s = $cppc != 1 ? 's' : '';+    warning("Uses $cppc C++ style comment$s, which is not portable");+  }++  my $s = $warnings != 1 ? 's' : '';+  my $warn = $warnings ? " ($warnings warning$s)" : '';+  info("Analysis completed$warn");++  if ($file{changes}) {+    if (exists $opt{copy}) {+      my $newfile = "$filename$opt{copy}";+      if (-e $newfile) {+        error("'$newfile' already exists, refusing to write copy of '$filename'");+      }+      else {+        local *F;+        if (open F, ">$newfile") {+          info("Writing copy of '$filename' with changes to '$newfile'");+          print F $c;+          close F;+        }+        else {+          error("Cannot open '$newfile' for writing: $!");+        }+      }+    }+    elsif (exists $opt{patch} || $opt{changes}) {+      if (exists $opt{patch}) {+        unless ($patch_opened) {+          if (open PATCH, ">$opt{patch}") {+            $patch_opened = 1;+          }+          else {+            error("Cannot open '$opt{patch}' for writing: $!");+            delete $opt{patch};+            $opt{changes} = 1;+            goto fallback;+          }+        }+        mydiff(\*PATCH, $filename, $c);+      }+      else {+fallback:+        info("Suggested changes:");+        mydiff(\*STDOUT, $filename, $c);+      }+    }+    else {+      my $s = $file{changes} == 1 ? '' : 's';+      info("$file{changes} potentially required change$s detected");+    }+  }+  else {+    info("Looks good");+  }+}++close PATCH if $patch_opened;++exit 0;+++sub try_use { eval "use @_;"; return $@ eq '' }++sub mydiff+{+  local *F = shift;+  my($file, $str) = @_;+  my $diff;++  if (exists $opt{diff}) {+    $diff = run_diff($opt{diff}, $file, $str);+  }++  if (!defined $diff and try_use('Text::Diff')) {+    $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });+    $diff = <<HEADER . $diff;+--- $file++++ $file.patched+HEADER+  }++  if (!defined $diff) {+    $diff = run_diff('diff -u', $file, $str);+  }++  if (!defined $diff) {+    $diff = run_diff('diff', $file, $str);+  }++  if (!defined $diff) {+    error("Cannot generate a diff. Please install Text::Diff or use --copy.");+    return;+  }++  print F $diff;+}++sub run_diff+{+  my($prog, $file, $str) = @_;+  my $tmp = 'dppptemp';+  my $suf = 'aaa';+  my $diff = '';+  local *F;++  while (-e "$tmp.$suf") { $suf++ }+  $tmp = "$tmp.$suf";++  if (open F, ">$tmp") {+    print F $str;+    close F;++    if (open F, "$prog $file $tmp |") {+      while (<F>) {+        s/\Q$tmp\E/$file.patched/;+        $diff .= $_;+      }+      close F;+      unlink $tmp;+      return $diff;+    }++    unlink $tmp;+  }+  else {+    error("Cannot open '$tmp' for writing: $!");+  }++  return undef;+}++sub rec_depend+{+  my($func, $seen) = @_;+  return () unless exists $depends{$func};+  $seen = {%{$seen||{}}};+  return () if $seen->{$func}++;+  my %s;+  grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};+}++sub parse_version+{+  my $ver = shift;++  if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {+    return ($1, $2, $3);+  }+  elsif ($ver !~ /^\d+\.[\d_]+$/) {+    die "cannot parse version '$ver'\n";+  }++  $ver =~ s/_//g;
+  $ver =~ s/$/000000/;++  my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;++  $v = int $v;+  $s = int $s;++  if ($r < 5 || ($r == 5 && $v < 6)) {+    if ($s % 10) {+      die "cannot parse version '$ver'\n";+    }+  }++  return ($r, $v, $s);+}++sub format_version+{+  my $ver = shift;++  $ver =~ s/$/000000/;+  my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;++  $v = int $v;+  $s = int $s;++  if ($r < 5 || ($r == 5 && $v < 6)) {+    if ($s % 10) {+      die "invalid version '$ver'\n";+    }+    $s /= 10;++    $ver = sprintf "%d.%03d", $r, $v;+    $s > 0 and $ver .= sprintf "_%02d", $s;++    return $ver;+  }++  return sprintf "%d.%d.%d", $r, $v, $s;+}++sub info+{+  $opt{quiet} and return;+  print @_, "\n";+}++sub diag+{+  $opt{quiet} and return;+  $opt{diag} and print @_, "\n";+}++sub warning+{+  $opt{quiet} and return;+  print "*** ", @_, "\n";+}++sub error+{+  print "*** ERROR: ", @_, "\n";+}++my %given_hints;+my %given_warnings;+sub hint+{+  $opt{quiet} and return;+  my $func = shift;+  my $rv = 0;+  if (exists $warnings{$func} && !$given_warnings{$func}++) {+    my $warn = $warnings{$func};+    $warn =~ s!^!*** !mg;+    print "*** WARNING: $func\n", $warn;+    $rv++;+  }+  if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {+    my $hint = $hints{$func};+    $hint =~ s/^/   /mg;+    print "   --- hint for $func ---\n", $hint;+  }+  $rv;+}++sub usage+{+  my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;+  my %M = ( 'I' => '*' );+  $usage =~ s/^\s*perl\s+\S+/$^X $0/;+  $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;++  print <<ENDUSAGE;++Usage: $usage++See perldoc $0 for details.++ENDUSAGE++  exit 2;+}++sub strip+{+  my $self = do { local(@ARGV,$/)=($0); <> };+  my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;+  $copy =~ s/^(?=\S+)/    /gms;+  $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;+  $self =~ s/^SKIP.*(?=^__DATA__)/SKIP+if (\@ARGV && \$ARGV[0] eq '--unstrip') {+  eval { require Devel::PPPort };+  \$@ and die "Cannot require Devel::PPPort, please install.\\n";+  if (eval \$Devel::PPPort::VERSION < $VERSION) {+    die "$0 was originally generated with Devel::PPPort $VERSION.\\n"+      . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"+      . "Please install a newer version, or --unstrip will not work.\\n";+  }+  Devel::PPPort::WriteFile(\$0);+  exit 0;+}+print <<END;++Sorry, but this is a stripped version of \$0.++To be able to use its original script and doc functionality,+please try to regenerate this file using:++  \$^X \$0 --unstrip++END+/ms;+  my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms;+  $c =~ s{+    / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)+  | ( "[^"\\]*(?:\\.[^"\\]*)*"+    | '[^'\\]*(?:\\.[^'\\]*)*' )+  | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex;+  $c =~ s!\s+$!!mg;+  $c =~ s!^$LF!!mg;+  $c =~ s!^\s*#\s*!#!mg;+  $c =~ s!^\s+!!mg;++  open OUT, ">$0" or die "cannot strip $0: $!\n";+  print OUT "$pl$c\n";++  exit 0;+}++__DATA__+*/++#ifndef _P_P_PORTABILITY_H_+#define _P_P_PORTABILITY_H_++#ifndef DPPP_NAMESPACE+#  define DPPP_NAMESPACE DPPP_+#endif++#define DPPP_CAT2(x,y) CAT2(x,y)+#define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)++#ifndef PERL_REVISION+#  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))+#    define PERL_PATCHLEVEL_H_IMPLICIT+#    include <patchlevel.h>+#  endif+#  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))+#    include <could_not_find_Perl_patchlevel.h>+#  endif+#  ifndef PERL_REVISION+#    define PERL_REVISION       (5)+     /* Replace: 1 */+#    define PERL_VERSION        PATCHLEVEL+#    define PERL_SUBVERSION     SUBVERSION+     /* Replace PERL_PATCHLEVEL with PERL_VERSION */+     /* Replace: 0 */+#  endif+#endif++#define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))+#define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))++/* It is very unlikely that anyone will try to use this with Perl 6
+   (or greater), but who knows.+ */+#if PERL_REVISION != 5+#  error ppport.h only works with Perl version 5+#endif /* PERL_REVISION != 5 */+#ifndef dTHR+#  define dTHR                           dNOOP+#endif+#ifndef dTHX+#  define dTHX                           dNOOP+#endif++#ifndef dTHXa+#  define dTHXa(x)                       dNOOP+#endif+#ifndef pTHX+#  define pTHX                           void+#endif++#ifndef pTHX_+#  define pTHX_+#endif++#ifndef aTHX+#  define aTHX+#endif++#ifndef aTHX_+#  define aTHX_+#endif++#if (PERL_BCDVERSION < 0x5006000)+#  ifdef USE_THREADS+#    define aTHXR  thr+#    define aTHXR_ thr,+#  else+#    define aTHXR+#    define aTHXR_+#  endif+#  define dTHXR  dTHR+#else+#  define aTHXR  aTHX+#  define aTHXR_ aTHX_+#  define dTHXR  dTHX+#endif+#ifndef dTHXoa+#  define dTHXoa(x)                      dTHXa(x)+#endif++#ifdef I_LIMITS+#  include <limits.h>+#endif++#ifndef PERL_UCHAR_MIN+#  define PERL_UCHAR_MIN ((unsigned char)0)+#endif++#ifndef PERL_UCHAR_MAX+#  ifdef UCHAR_MAX+#    define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)+#  else+#    ifdef MAXUCHAR+#      define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)+#    else+#      define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)+#    endif+#  endif+#endif++#ifndef PERL_USHORT_MIN+#  define PERL_USHORT_MIN ((unsigned short)0)+#endif++#ifndef PERL_USHORT_MAX+#  ifdef USHORT_MAX+#    define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)+#  else+#    ifdef MAXUSHORT+#      define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)+#    else+#      ifdef USHRT_MAX+#        define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)+#      else+#        define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)+#      endif+#    endif+#  endif+#endif++#ifndef PERL_SHORT_MAX+#  ifdef SHORT_MAX+#    define PERL_SHORT_MAX ((short)SHORT_MAX)+#  else+#    ifdef MAXSHORT    /* Often used in <values.h> */+#      define PERL_SHORT_MAX ((short)MAXSHORT)+#    else+#      ifdef SHRT_MAX+#        define PERL_SHORT_MAX ((short)SHRT_MAX)+#      else+#        define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))+#      endif+#    endif+#  endif+#endif++#ifndef PERL_SHORT_MIN+#  ifdef SHORT_MIN+#    define PERL_SHORT_MIN ((short)SHORT_MIN)+#  else+#    ifdef MINSHORT+#      define PERL_SHORT_MIN ((short)MINSHORT)+#    else+#      ifdef SHRT_MIN+#        define PERL_SHORT_MIN ((short)SHRT_MIN)+#      else+#        define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))+#      endif+#    endif+#  endif+#endif++#ifndef PERL_UINT_MAX+#  ifdef UINT_MAX+#    define PERL_UINT_MAX ((unsigned int)UINT_MAX)+#  else+#    ifdef MAXUINT+#      define PERL_UINT_MAX ((unsigned int)MAXUINT)+#    else+#      define PERL_UINT_MAX (~(unsigned int)0)+#    endif+#  endif+#endif++#ifndef PERL_UINT_MIN+#  define PERL_UINT_MIN ((unsigned int)0)+#endif++#ifndef PERL_INT_MAX+#  ifdef INT_MAX+#    define PERL_INT_MAX ((int)INT_MAX)+#  else+#    ifdef MAXINT    /* Often used in <values.h> */+#      define PERL_INT_MAX ((int)MAXINT)+#    else+#      define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))+#    endif+#  endif+#endif++#ifndef PERL_INT_MIN+#  ifdef INT_MIN+#    define PERL_INT_MIN ((int)INT_MIN)+#  else+#    ifdef MININT+#      define PERL_INT_MIN ((int)MININT)+#    else+#      define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))+#    endif+#  endif+#endif++#ifndef PERL_ULONG_MAX+#  ifdef ULONG_MAX+#    define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)+#  else+#    ifdef MAXULONG+#      define PERL_ULONG_MAX ((unsigned long)MAXULONG)+#    else+#      define PERL_ULONG_MAX (~(unsigned long)0)+#    endif+#  endif+#endif++#ifndef PERL_ULONG_MIN+#  define PERL_ULONG_MIN ((unsigned long)0L)+#endif++#ifndef PERL_LONG_MAX+#  ifdef LONG_MAX+#    define PERL_LONG_MAX ((long)LONG_MAX)+#  else+#    ifdef MAXLONG+#      define PERL_LONG_MAX ((long)MAXLONG)+#    else+#      define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))+#    endif+#  endif+#endif++#ifndef PERL_LONG_MIN+#  ifdef LONG_MIN+#    define PERL_LONG_MIN ((long)LONG_MIN)+#  else+#    ifdef MINLONG+#      define PERL_LONG_MIN ((long)MINLONG)+#    else+#      define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))+#    endif+#  endif+#endif++#if defined(HAS_QUAD) && (defined(convex) || defined(uts))+#  ifndef PERL_UQUAD_MAX+#    ifdef ULONGLONG_MAX+#      define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)+#    else+#      ifdef MAXULONGLONG+#        define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)+#      else+#        define PERL_UQUAD_MAX (~(unsigned long long)0)+#      endif+#    endif+#  endif++#  ifndef PERL_UQUAD_MIN+#    define PERL_UQUAD_MIN ((unsigned long long)0L)+#  endif++#  ifndef PERL_QUAD_MAX+#    ifdef LONGLONG_MAX+#      define PERL_QUAD_MAX ((long long)LONGLONG_MAX)+#    else+#      ifdef MAXLONGLONG+#        define PERL_QUAD_MAX ((long long)MAXLONGLONG)+#      else+#        define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))+#      endif+#    endif+#  endif++#  ifndef PERL_QUAD_MIN+#    ifdef LONGLONG_MIN+#      define PERL_QUAD_MIN ((long long)LONGLONG_MIN)+#    else+#      ifdef MINLONGLONG+#        define PERL_QUAD_MIN ((long long)MINLONGLONG)+#      else+#        define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))+#      endif+#    endif+#  endif+#endif++/* This is based on code from 5.003 perl.h */+#ifdef HAS_QUAD+#  ifdef cray+#ifndef IVTYPE+#  define IVTYPE                         int+#endif++#ifndef IV_MIN+#  define IV_MIN                         PERL_INT_MIN+#endif++#ifndef IV_MAX+#  define IV_MAX                         PERL_INT_MAX+#endif++#ifndef UV_MIN+#  define UV_MIN                         PERL_UINT_MIN+#endif++#ifndef UV_MAX+#  define UV_MAX                         PERL_UINT_MAX+#endif++#    ifdef INTSIZE+#ifndef IVSIZE+#  define IVSIZE                         INTSIZE+#endif++#    endif+#  else+#    if defined(convex) || defined(uts)+#ifndef IVTYPE+#  define IVTYPE                         long long+#endif++#ifndef IV_MIN+#  define IV_MIN                         PERL_QUAD_MIN+#endif++#ifndef IV_MAX+#  define IV_MAX                         PERL_QUAD_MAX+#endif++#ifndef UV_MIN+#  define UV_MIN                         PERL_UQUAD_MIN+#endif++#ifndef UV_MAX+#  define UV_MAX                         PERL_UQUAD_MAX+#endif++#      ifdef LONGLONGSIZE+#ifndef IVSIZE+#  define IVSIZE                         LONGLONGSIZE+#endif++#      endif+#    else+#ifndef IVTYPE+#  define IVTYPE                         long+#endif++#ifndef IV_MIN+#  define IV_MIN                         PERL_LONG_MIN+#endif++#ifndef IV_MAX+#  define IV_MAX                         PERL_LONG_MAX+#endif++#ifndef UV_MIN+#  define UV_MIN                         PERL_ULONG_MIN+#endif++#ifndef UV_MAX+#  define UV_MAX                         PERL_ULONG_MAX+#endif++#      ifdef LONGSIZE+#ifndef IVSIZE+#  define IVSIZE                         LONGSIZE+#endif++#      endif+#    endif+#  endif+#ifndef IVSIZE+#  define IVSIZE                         8+#endif++#ifndef LONGSIZE+#  define LONGSIZE                       8+#endif++#ifndef PERL_QUAD_MIN+#  define PERL_QUAD_MIN                  IV_MIN+#endif++#ifndef PERL_QUAD_MAX+#  define PERL_QUAD_MAX                  IV_MAX+#endif++#ifndef PERL_UQUAD_MIN+#  define PERL_UQUAD_MIN                 UV_MIN+#endif++#ifndef PERL_UQUAD_MAX+#  define PERL_UQUAD_MAX                 UV_MAX+#endif++#else+#ifndef IVTYPE+#  define IVTYPE                         long+#endif++#ifndef LONGSIZE+#  define LONGSIZE                       4+#endif++#ifndef IV_MIN+#  define IV_MIN                         PERL_LONG_MIN+#endif++#ifndef IV_MAX+#  define IV_MAX                         PERL_LONG_MAX+#endif++#ifndef UV_MIN+#  define UV_MIN                         PERL_ULONG_MIN+#endif++#ifndef UV_MAX+#  define UV_MAX                         PERL_ULONG_MAX+#endif++#endif++#ifndef IVSIZE+#  ifdef LONGSIZE+#    define IVSIZE LONGSIZE+#  else+#    define IVSIZE 4 /* A bold guess, but the best we can make. */+#  endif+#endif+#ifndef UVTYPE+#  define UVTYPE                         unsigned IVTYPE+#endif++#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_UNUSED_DECL+#  ifdef HASATTRIBUTE+#    if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)+#      define PERL_UNUSED_DECL+#    else+#      define PERL_UNUSED_DECL __attribute__((unused))+#    endif+#  else+#    define PERL_UNUSED_DECL+#  endif+#endif++#ifndef PERL_UNUSED_ARG+#  if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */+#    include <note.h>+#    define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))+#  else+#    define PERL_UNUSED_ARG(x) ((void)x)+#  endif+#endif++#ifndef PERL_UNUSED_VAR+#  define PERL_UNUSED_VAR(x) ((void)x)+#endif++#ifndef PERL_UNUSED_CONTEXT+#  ifdef USE_ITHREADS+#    define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)+#  else+#    define PERL_UNUSED_CONTEXT+#  endif+#endif+#ifndef NOOP+#  define NOOP                           /*EMPTY*/(void)0+#endif++#ifndef dNOOP+#  define dNOOP                          extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL+#endif++#ifndef NVTYPE+#  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)+#    define NVTYPE long double+#  else+#    define NVTYPE double+#  endif+typedef NVTYPE NV;+#endif++#ifndef INT2PTR+#  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)+#    define PTRV                  UV+#    define INT2PTR(any,d)        (any)(d)+#  else+#    if PTRSIZE == LONGSIZE+#      define PTRV                unsigned long+#    else+#      define PTRV                unsigned+#    endif+#    define INT2PTR(any,d)        (any)(PTRV)(d)+#  endif+#endif++#ifndef PTR2ul+#  if PTRSIZE == LONGSIZE+#    define PTR2ul(p)     (unsigned long)(p)+#  else+#    define PTR2ul(p)     INT2PTR(unsigned long,p)+#  endif+#endif+#ifndef PTR2nat+#  define PTR2nat(p)                     (PTRV)(p)+#endif++#ifndef NUM2PTR+#  define NUM2PTR(any,d)                 (any)PTR2nat(d)+#endif++#ifndef PTR2IV+#  define PTR2IV(p)                      INT2PTR(IV,p)+#endif++#ifndef PTR2UV+#  define PTR2UV(p)                      INT2PTR(UV,p)+#endif++#ifndef PTR2NV+#  define PTR2NV(p)                      NUM2PTR(NV,p)+#endif++#undef START_EXTERN_C+#undef END_EXTERN_C+#undef EXTERN_C+#ifdef __cplusplus+#  define START_EXTERN_C extern "C" {+#  define END_EXTERN_C }+#  define EXTERN_C extern "C"+#else+#  define START_EXTERN_C+#  define END_EXTERN_C+#  define EXTERN_C extern+#endif++#if defined(PERL_GCC_PEDANTIC)+#  ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN+#    define PERL_GCC_BRACE_GROUPS_FORBIDDEN+#  endif+#endif++#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)+#  ifndef PERL_USE_GCC_BRACE_GROUPS+#    define PERL_USE_GCC_BRACE_GROUPS+#  endif+#endif++#undef STMT_START+#undef STMT_END+#ifdef PERL_USE_GCC_BRACE_GROUPS+#  define STMT_START    (void)( /* gcc supports ``({ STATEMENTS; })'' */+#  define STMT_END      )+#else+#  if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)+#    define STMT_START  if (1)+#    define STMT_END    else (void)0+#  else+#    define STMT_START  do+#    define STMT_END    while (0)+#  endif+#endif+#ifndef boolSV+#  define boolSV(b)                      ((b) ? &PL_sv_yes : &PL_sv_no)+#endif++/* DEFSV appears first in 5.004_56 */+#ifndef DEFSV+#  define DEFSV                          GvSV(PL_defgv)+#endif++#ifndef SAVE_DEFSV+#  define SAVE_DEFSV                     SAVESPTR(GvSV(PL_defgv))+#endif++#ifndef DEFSV_set+#  define DEFSV_set(sv)                  (DEFSV = (sv))+#endif++/* Older perls (<=5.003) lack AvFILLp */+#ifndef AvFILLp+#  define AvFILLp                        AvFILL+#endif+#ifndef ERRSV+#  define ERRSV                          get_sv("@",FALSE)+#endif++/* Hint: gv_stashpvn
+ * This function's backport doesn't support the length parameter, but+ * rather ignores it. Portability can only be ensured if the length+ * parameter is used for speed reasons, but the length can always be+ * correctly computed from the string argument.+ */+#ifndef gv_stashpvn+#  define gv_stashpvn(str,len,create)    gv_stashpv(str,create)+#endif++/* Replace: 1 */+#ifndef get_cv+#  define get_cv                         perl_get_cv+#endif++#ifndef get_sv+#  define get_sv                         perl_get_sv+#endif++#ifndef get_av+#  define get_av                         perl_get_av+#endif++#ifndef get_hv+#  define get_hv                         perl_get_hv+#endif++/* Replace: 0 */+#ifndef dUNDERBAR+#  define dUNDERBAR                      dNOOP+#endif++#ifndef UNDERBAR+#  define UNDERBAR                       DEFSV+#endif+#ifndef dAX+#  define dAX                            I32 ax = MARK - PL_stack_base + 1+#endif++#ifndef dITEMS+#  define dITEMS                         I32 items = SP - MARK+#endif+#ifndef dXSTARG+#  define dXSTARG                        SV * targ = sv_newmortal()+#endif+#ifndef dAXMARK+#  define dAXMARK                        I32 ax = POPMARK; \+                               register SV ** const mark = PL_stack_base + ax+++#endif+#ifndef XSprePUSH+#  define XSprePUSH                      (sp = PL_stack_base + ax - 1)+#endif++#if (PERL_BCDVERSION < 0x5005000)+#  undef XSRETURN+#  define XSRETURN(off)                                   \+      STMT_START {                                        \+          PL_stack_sp = PL_stack_base + ax + ((off) - 1); \+          return;                                         \+      } STMT_END+#endif+#ifndef XSPROTO+#  define XSPROTO(name)                  void name(pTHX_ CV* cv)+#endif++#ifndef SVfARG+#  define SVfARG(p)                      ((void*)(p))+#endif+#ifndef PERL_ABS+#  define PERL_ABS(x)                    ((x) < 0 ? -(x) : (x))+#endif+#ifndef dVAR+#  define dVAR                           dNOOP+#endif+#ifndef SVf+#  define SVf                            "_"+#endif+#ifndef UTF8_MAXBYTES+#  define UTF8_MAXBYTES                  UTF8_MAXLEN+#endif+#ifndef CPERLscope+#  define CPERLscope(x)                  x+#endif+#ifndef PERL_HASH+#  define PERL_HASH(hash,str,len)        \+     STMT_START { \+        const char *s_PeRlHaSh = str; \+        I32 i_PeRlHaSh = len; \+        U32 hash_PeRlHaSh = 0; \+        while (i_PeRlHaSh--) \+            hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \+        (hash) = hash_PeRlHaSh; \+    } STMT_END+#endif++#ifndef PERLIO_FUNCS_DECL+# ifdef PERLIO_FUNCS_CONST+#  define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs+#  define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)+# else+#  define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs+#  define PERLIO_FUNCS_CAST(funcs) (funcs)+# endif+#endif++/* provide these typedefs for older perls */+#if (PERL_BCDVERSION < 0x5009003)++# ifdef ARGSproto+typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto);+# else+typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);+# endif++typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);++#endif+#ifndef isPSXSPC+#  define isPSXSPC(c)                    (isSPACE(c) || (c) == '\v')+#endif++#ifndef isBLANK+#  define isBLANK(c)                     ((c) == ' ' || (c) == '\t')+#endif++#ifdef EBCDIC+#ifndef isALNUMC+#  define isALNUMC(c)                    isalnum(c)+#endif++#ifndef isASCII+#  define isASCII(c)                     isascii(c)+#endif++#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++#ifndef isXDIGIT+#  define isXDIGIT(c)                    isxdigit(c)+#endif++#else+# if (PERL_BCDVERSION < 0x5010000)+/* Hint: isPRINT
+ * The implementation in older perl versions includes all of the+ * isSPACE() characters, which is wrong. The version provided by+ * Devel::PPPort always overrides a present buggy version.+ */+#  undef isPRINT+# endif++#ifdef HAS_QUAD+# define WIDEST_UTYPE U64TYPE+#else+# define WIDEST_UTYPE U32+#endif+#ifndef isALNUMC+#  define isALNUMC(c)                    (isALPHA(c) || isDIGIT(c))+#endif++#ifndef isASCII+#  define isASCII(c)                     ((WIDEST_UTYPE) (c) <= 127)+#endif++#ifndef isCNTRL+#  define isCNTRL(c)                     ((WIDEST_UTYPE) (c) < ' ' || (c) == 127)+#endif++#ifndef isGRAPH+#  define isGRAPH(c)                     (isALNUM(c) || isPUNCT(c))+#endif++#ifndef isPRINT+#  define isPRINT(c)                     (((c) >= 32 && (c) < 127))+#endif++#ifndef isPUNCT+#  define isPUNCT(c)                     (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64)  || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))+#endif++#ifndef isXDIGIT+#  define isXDIGIT(c)                    (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))+#endif++#endif++#ifndef PERL_SIGNALS_UNSAFE_FLAG++#define PERL_SIGNALS_UNSAFE_FLAG 0x0001++#if (PERL_BCDVERSION < 0x5008000)+#  define D_PPP_PERL_SIGNALS_INIT   PERL_SIGNALS_UNSAFE_FLAG+#else+#  define D_PPP_PERL_SIGNALS_INIT   0+#endif++#if defined(NEED_PL_signals)+static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;+#elif defined(NEED_PL_signals_GLOBAL)+U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;+#else+extern U32 DPPP_(my_PL_signals);+#endif+#define PL_signals DPPP_(my_PL_signals)++#endif++/* Hint: PL_ppaddr
+ * Calling an op via PL_ppaddr requires passing a context argument+ * for threaded builds. Since the context argument is different for+ * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will+ * automatically be defined as the correct argument.+ */++#if (PERL_BCDVERSION <= 0x5005005)+/* Replace: 1 */+#  define PL_ppaddr                 ppaddr+#  define PL_no_modify              no_modify+/* Replace: 0 */+#endif++#if (PERL_BCDVERSION <= 0x5004005)+/* Replace: 1 */+#  define PL_DBsignal               DBsignal+#  define PL_DBsingle               DBsingle+#  define PL_DBsub                  DBsub+#  define PL_DBtrace                DBtrace+#  define PL_Sv                     Sv+#  define PL_bufend                 bufend+#  define PL_bufptr                 bufptr+#  define PL_compiling              compiling+#  define PL_copline                copline+#  define PL_curcop                 curcop+#  define PL_curstash               curstash+#  define PL_debstash               debstash+#  define PL_defgv                  defgv+#  define PL_diehook                diehook+#  define PL_dirty                  dirty+#  define PL_dowarn                 dowarn+#  define PL_errgv                  errgv+#  define PL_error_count            error_count+#  define PL_expect                 expect+#  define PL_hexdigit               hexdigit+#  define PL_hints                  hints+#  define PL_in_my                  in_my+#  define PL_laststatval            laststatval+#  define PL_lex_state              lex_state+#  define PL_lex_stuff              lex_stuff+#  define PL_linestr                linestr+#  define PL_na                     na+#  define PL_perl_destruct_level    perl_destruct_level+#  define PL_perldb                 perldb+#  define PL_rsfp_filters           rsfp_filters+#  define PL_rsfp                   rsfp+#  define PL_stack_base             stack_base+#  define PL_stack_sp               stack_sp+#  define PL_statcache              statcache+#  define PL_stdingv                stdingv+#  define PL_sv_arenaroot           sv_arenaroot+#  define PL_sv_no                  sv_no+#  define PL_sv_undef               sv_undef+#  define PL_sv_yes                 sv_yes+#  define PL_tainted                tainted+#  define PL_tainting               tainting+#  define PL_tokenbuf               tokenbuf+/* Replace: 0 */+#endif++/* Warning: PL_parser
+ * For perl versions earlier than 5.9.5, this is an always+ * non-NULL dummy. Also, it cannot be dereferenced. Don't+ * use it if you can avoid is and unless you absolutely know+ * what you're doing.+ * If you always check that PL_parser is non-NULL, you can+ * define DPPP_PL_parser_NO_DUMMY to avoid the creation of+ * a dummy parser structure.+ */++#if (PERL_BCDVERSION >= 0x5009005)+# ifdef DPPP_PL_parser_NO_DUMMY+#  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \+                (croak("panic: PL_parser == NULL in %s:%d", \+                       __FILE__, __LINE__), (yy_parser *) NULL))->var)+# else+#  ifdef DPPP_PL_parser_NO_DUMMY_WARNING+#   define D_PPP_parser_dummy_warning(var)+#  else+#   define D_PPP_parser_dummy_warning(var) \+             warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),+#  endif+#  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \+                (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)+#if defined(NEED_PL_parser)+static yy_parser DPPP_(dummy_PL_parser);+#elif defined(NEED_PL_parser_GLOBAL)+yy_parser DPPP_(dummy_PL_parser);+#else+extern yy_parser DPPP_(dummy_PL_parser);+#endif++# endif++/* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */+/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
+ * Do not use this variable unless you know exactly what you're+ * doint. It is internal to the perl parser and may change or even+ * be removed in the future. As of perl 5.9.5, you have to check+ * for (PL_parser != NULL) for this variable to have any effect.+ * An always non-NULL PL_parser dummy is provided for earlier+ * perl versions.+ * If PL_parser is NULL when you try to access this variable, a+ * dummy is being accessed instead and a warning is issued unless+ * you define DPPP_PL_parser_NO_DUMMY_WARNING.+ * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access+ * this variable will croak with a panic message.+ */++# define PL_expect         D_PPP_my_PL_parser_var(expect)+# define PL_copline        D_PPP_my_PL_parser_var(copline)+# define PL_rsfp           D_PPP_my_PL_parser_var(rsfp)+# define PL_rsfp_filters   D_PPP_my_PL_parser_var(rsfp_filters)+# define PL_linestr        D_PPP_my_PL_parser_var(linestr)+# define PL_bufptr         D_PPP_my_PL_parser_var(bufptr)+# define PL_bufend         D_PPP_my_PL_parser_var(bufend)+# define PL_lex_state      D_PPP_my_PL_parser_var(lex_state)+# define PL_lex_stuff      D_PPP_my_PL_parser_var(lex_stuff)+# define PL_tokenbuf       D_PPP_my_PL_parser_var(tokenbuf)+# define PL_in_my          D_PPP_my_PL_parser_var(in_my)+# define PL_in_my_stash    D_PPP_my_PL_parser_var(in_my_stash)+# define PL_error_count    D_PPP_my_PL_parser_var(error_count)+++#else++/* ensure that PL_parser != NULL and cannot be dereferenced */+# define PL_parser         ((void *) 1)++#endif+#ifndef mPUSHs+#  define mPUSHs(s)                      PUSHs(sv_2mortal(s))+#endif++#ifndef PUSHmortal+#  define PUSHmortal                     PUSHs(sv_newmortal())+#endif++#ifndef mPUSHp+#  define mPUSHp(p,l)                    sv_setpvn(PUSHmortal, (p), (l))+#endif++#ifndef mPUSHn+#  define mPUSHn(n)                      sv_setnv(PUSHmortal, (NV)(n))+#endif++#ifndef mPUSHi+#  define mPUSHi(i)                      sv_setiv(PUSHmortal, (IV)(i))+#endif++#ifndef mPUSHu+#  define mPUSHu(u)                      sv_setuv(PUSHmortal, (UV)(u))+#endif+#ifndef mXPUSHs+#  define mXPUSHs(s)                     XPUSHs(sv_2mortal(s))+#endif++#ifndef XPUSHmortal+#  define XPUSHmortal                    XPUSHs(sv_newmortal())+#endif++#ifndef mXPUSHp+#  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END+#endif++#ifndef mXPUSHn+#  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END+#endif++#ifndef mXPUSHi+#  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END+#endif++#ifndef mXPUSHu+#  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END+#endif++/* Replace: 1 */+#ifndef call_sv+#  define call_sv                        perl_call_sv+#endif++#ifndef call_pv+#  define call_pv                        perl_call_pv+#endif++#ifndef call_argv+#  define call_argv                      perl_call_argv+#endif++#ifndef call_method+#  define call_method                    perl_call_method+#endif+#ifndef eval_sv+#  define eval_sv                        perl_eval_sv+#endif++/* Replace: 0 */+#ifndef PERL_LOADMOD_DENY+#  define PERL_LOADMOD_DENY              0x1+#endif++#ifndef PERL_LOADMOD_NOIMPORT+#  define PERL_LOADMOD_NOIMPORT          0x2+#endif++#ifndef PERL_LOADMOD_IMPORT_OPS+#  define PERL_LOADMOD_IMPORT_OPS        0x4+#endif++#ifndef G_METHOD+# define G_METHOD               64+# ifdef call_sv+#  undef call_sv+# endif+# if (PERL_BCDVERSION < 0x5006000)+#  define call_sv(sv, flags)  ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \+                                (flags) & ~G_METHOD) : perl_call_sv(sv, flags))+# else+#  define call_sv(sv, flags)  ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \+                                (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))+# endif+#endif++/* Replace perl_eval_pv with eval_pv */++#ifndef eval_pv+#if defined(NEED_eval_pv)+static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);+static+#else+extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);+#endif++#ifdef eval_pv+#  undef eval_pv+#endif+#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)+#define Perl_eval_pv DPPP_(my_eval_pv)++#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)++SV*+DPPP_(my_eval_pv)(char *p, I32 croak_on_error)+{+    dSP;+    SV* sv = newSVpv(p, 0);++    PUSHMARK(sp);+    eval_sv(sv, G_SCALAR);+    SvREFCNT_dec(sv);++    SPAGAIN;+    sv = POPs;+    PUTBACK;++    if (croak_on_error && SvTRUE(GvSV(errgv)))+        croak(SvPVx(GvSV(errgv), na));++    return sv;+}++#endif+#endif++#ifndef vload_module+#if defined(NEED_vload_module)+static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);+static+#else+extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);+#endif++#ifdef vload_module+#  undef vload_module+#endif+#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)+#define Perl_vload_module DPPP_(my_vload_module)++#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)++void+DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)+{+    dTHR;+    dVAR;+    OP *veop, *imop;++    OP * const modname = newSVOP(OP_CONST, 0, name);+    /* 5.005 has a somewhat hacky force_normal that doesn't croak on
+       SvREADONLY() if PL_compling is true. Current perls take care in+       ck_require() to correctly turn off SvREADONLY before calling+       force_normal_flags(). This seems a better fix than fudging PL_compling+     */+    SvREADONLY_off(((SVOP*)modname)->op_sv);+    modname->op_private |= OPpCONST_BARE;+    if (ver) {+        veop = newSVOP(OP_CONST, 0, ver);+    }+    else+        veop = NULL;+    if (flags & PERL_LOADMOD_NOIMPORT) {+        imop = sawparens(newNULLLIST());+    }+    else if (flags & PERL_LOADMOD_IMPORT_OPS) {+        imop = va_arg(*args, OP*);+    }+    else {+        SV *sv;+        imop = NULL;+        sv = va_arg(*args, SV*);+        while (sv) {+            imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));+            sv = va_arg(*args, SV*);+        }+    }+    {+        const line_t ocopline = PL_copline;+        COP * const ocurcop = PL_curcop;+        const int oexpect = PL_expect;++#if (PERL_BCDVERSION >= 0x5004000)+        utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),+                veop, modname, imop);+#else+        utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),+                modname, imop);+#endif+        PL_expect = oexpect;+        PL_copline = ocopline;+        PL_curcop = ocurcop;+    }+}++#endif+#endif++#ifndef load_module+#if defined(NEED_load_module)+static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);+static+#else+extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);+#endif++#ifdef load_module+#  undef load_module+#endif+#define load_module DPPP_(my_load_module)+#define Perl_load_module DPPP_(my_load_module)++#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)++void+DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)+{+    va_list args;+    va_start(args, ver);+    vload_module(flags, name, ver, &args);+    va_end(args);+}++#endif+#endif+#ifndef newRV_inc+#  define newRV_inc(sv)                  newRV(sv)   /* Replace */+#endif++#ifndef newRV_noinc+#if defined(NEED_newRV_noinc)+static SV * DPPP_(my_newRV_noinc)(SV *sv);+static+#else+extern SV * DPPP_(my_newRV_noinc)(SV *sv);+#endif++#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)++#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)+SV *+DPPP_(my_newRV_noinc)(SV *sv)+{+  SV *rv = (SV *)newRV(sv);+  SvREFCNT_dec(sv);+  return rv;+}+#endif+#endif++/* Hint: newCONSTSUB
+ * Returns a CV* as of perl-5.7.1. This return value is not supported+ * by Devel::PPPort.+ */++/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */+#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)+#if defined(NEED_newCONSTSUB)+static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);+static+#else+extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);+#endif++#ifdef newCONSTSUB+#  undef newCONSTSUB+#endif+#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)+#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)++#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)++/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */+/* (There's no PL_parser in perl < 5.005, so this is completely safe)     */+#define D_PPP_PL_copline PL_copline++void+DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)+{+        U32 oldhints = PL_hints;+        HV *old_cop_stash = PL_curcop->cop_stash;+        HV *old_curstash = PL_curstash;+        line_t oldline = PL_curcop->cop_line;+        PL_curcop->cop_line = D_PPP_PL_copline;++        PL_hints &= ~HINT_BLOCK_SCOPE;+        if (stash)+                PL_curstash = PL_curcop->cop_stash = stash;++        newSUB(++#if   (PERL_BCDVERSION < 0x5003022)+                start_subparse(),+#elif (PERL_BCDVERSION == 0x5003022)+                start_subparse(0),+#else  /* 5.003_23  onwards */+                start_subparse(FALSE, 0),+#endif++                newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),+                newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */+                newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))+        );++        PL_hints = oldhints;+        PL_curcop->cop_stash = old_cop_stash;+        PL_curstash = old_curstash;+        PL_curcop->cop_line = oldline;+}+#endif+#endif++/*
+ * Boilerplate macros for initializing and accessing interpreter-local+ * data from C.  All statics in extensions should be reworked to use+ * this, if you want to make the extension thread-safe.  See ext/re/re.xs+ * for an example of the use of these macros.+ *+ * Code that uses these macros is responsible for the following:+ * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"+ * 2. Declare a typedef named my_cxt_t that is a structure that contains+ *    all the data that needs to be interpreter-local.+ * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.+ * 4. Use the MY_CXT_INIT macro such that it is called exactly once+ *    (typically put in the BOOT: section).+ * 5. Use the members of the my_cxt_t structure everywhere as+ *    MY_CXT.member.+ * 6. Use the dMY_CXT macro (a declaration) in all the functions that+ *    access MY_CXT.+ */++#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \+    defined(PERL_CAPI)    || defined(PERL_IMPLICIT_CONTEXT)++#ifndef START_MY_CXT++/* This must appear in all extensions that define a my_cxt_t structure,
+ * right after the definition (i.e. at file scope).  The non-threads+ * case below uses it to declare the data as static. */+#define START_MY_CXT++#if (PERL_BCDVERSION < 0x5004068)+/* Fetches the SV that keeps the per-interpreter data. */+#define dMY_CXT_SV \+        SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)+#else /* >= perl5.004_68 */+#define dMY_CXT_SV \+        SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY,             \+                                  sizeof(MY_CXT_KEY)-1, TRUE)+#endif /* < perl5.004_68 */++/* This declaration should be used within all functions that use the
+ * interpreter-local data. */+#define dMY_CXT \+        dMY_CXT_SV;                                                     \+        my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))++/* Creates and zeroes the per-interpreter data.
+ * (We allocate my_cxtp in a Perl SV so that it will be released when+ * the interpreter goes away.) */+#define MY_CXT_INIT \+        dMY_CXT_SV;                                                     \+        /* newSV() allocates one more than needed */                    \+        my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\+        Zero(my_cxtp, 1, my_cxt_t);                                     \+        sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))++/* This macro must be used to access members of the my_cxt_t structure.
+ * e.g. MYCXT.some_data */+#define MY_CXT          (*my_cxtp)++/* Judicious use of these macros can reduce the number of times dMY_CXT
+ * is used.  Use is similar to pTHX, aTHX etc. */+#define pMY_CXT         my_cxt_t *my_cxtp+#define pMY_CXT_        pMY_CXT,+#define _pMY_CXT        ,pMY_CXT+#define aMY_CXT         my_cxtp+#define aMY_CXT_        aMY_CXT,+#define _aMY_CXT        ,aMY_CXT++#endif /* START_MY_CXT */++#ifndef MY_CXT_CLONE+/* Clones the per-interpreter data. */+#define MY_CXT_CLONE \+        dMY_CXT_SV;                                                     \+        my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\+        Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\+        sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))+#endif++#else /* single interpreter */++#ifndef START_MY_CXT++#define START_MY_CXT    static my_cxt_t my_cxt;+#define dMY_CXT_SV      dNOOP+#define dMY_CXT         dNOOP+#define MY_CXT_INIT     NOOP+#define MY_CXT          my_cxt++#define pMY_CXT         void+#define pMY_CXT_+#define _pMY_CXT+#define aMY_CXT+#define aMY_CXT_+#define _aMY_CXT++#endif /* START_MY_CXT */++#ifndef MY_CXT_CLONE+#define MY_CXT_CLONE    NOOP+#endif++#endif++#ifndef IVdf+#  if IVSIZE == LONGSIZE+#    define     IVdf      "ld"+#    define     UVuf      "lu"+#    define     UVof      "lo"+#    define     UVxf      "lx"+#    define     UVXf      "lX"+#  elif IVSIZE == INTSIZE+#    define   IVdf      "d"+#    define   UVuf      "u"+#    define   UVof      "o"+#    define   UVxf      "x"+#    define   UVXf      "X"+#  else+#    error "cannot define IV/UV formats"+#  endif+#endif++#ifndef NVef+#  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \+      defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)+            /* Not very likely, but let's try anyway. */+#    define NVef          PERL_PRIeldbl+#    define NVff          PERL_PRIfldbl+#    define NVgf          PERL_PRIgldbl+#  else+#    define NVef          "e"+#    define NVff          "f"+#    define NVgf          "g"+#  endif+#endif++#ifndef SvREFCNT_inc+#  ifdef PERL_USE_GCC_BRACE_GROUPS+#    define SvREFCNT_inc(sv)            \+      ({                                \+          SV * const _sv = (SV*)(sv);   \+          if (_sv)                      \+               (SvREFCNT(_sv))++;       \+          _sv;                          \+      })+#  else+#    define SvREFCNT_inc(sv)    \+          ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)+#  endif+#endif++#ifndef SvREFCNT_inc_simple+#  ifdef PERL_USE_GCC_BRACE_GROUPS+#    define SvREFCNT_inc_simple(sv)     \+      ({                                        \+          if (sv)                               \+               (SvREFCNT(sv))++;                \+          (SV *)(sv);                           \+      })+#  else+#    define SvREFCNT_inc_simple(sv) \+          ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)+#  endif+#endif++#ifndef SvREFCNT_inc_NN+#  ifdef PERL_USE_GCC_BRACE_GROUPS+#    define SvREFCNT_inc_NN(sv)         \+      ({                                        \+          SV * const _sv = (SV*)(sv);   \+          SvREFCNT(_sv)++;              \+          _sv;                          \+      })+#  else+#    define SvREFCNT_inc_NN(sv) \+          (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)+#  endif+#endif++#ifndef SvREFCNT_inc_void+#  ifdef PERL_USE_GCC_BRACE_GROUPS+#    define SvREFCNT_inc_void(sv)               \+      ({                                        \+          SV * const _sv = (SV*)(sv);   \+          if (_sv)                      \+              (void)(SvREFCNT(_sv)++);  \+      })+#  else+#    define SvREFCNT_inc_void(sv) \+          (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)+#  endif+#endif+#ifndef 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++#ifdef newSV_type+#  undef newSV_type+#endif+#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a)+#define Perl_newSV_type DPPP_(my_newSV_type)++#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)++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++#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)++#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)++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++#ifdef sv_2pvbyte+#  undef sv_2pvbyte+#endif+#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)+#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)++#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)++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++#ifdef sv_2pv_flags+#  undef sv_2pv_flags+#endif+#define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)+#define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)++#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)++char *+DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)+{+  STRLEN n_a = (STRLEN) flags;+  return sv_2pv(sv, lp ? lp : &n_a);+}++#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++#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)++#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)++char *+DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)+{+  STRLEN n_a = (STRLEN) flags;+  return sv_pvn_force(sv, lp ? lp : &n_a);+}++#endif++#endif++#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )+# define DPPP_SVPV_NOLEN_LP_ARG &PL_na+#else+# define DPPP_SVPV_NOLEN_LP_ARG 0+#endif+#ifndef SvPV_const+#  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)+#endif++#ifndef SvPV_mutable+#  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)+#endif+#ifndef SvPV_flags+#  define SvPV_flags(sv, lp, flags)      \+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \+                  ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))+#endif+#ifndef SvPV_flags_const+#  define SvPV_flags_const(sv, lp, flags) \+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \+                  ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \+                  (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))+#endif+#ifndef SvPV_flags_const_nolen+#  define SvPV_flags_const_nolen(sv, flags) \+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \+                  ? SvPVX_const(sv) : \+                  (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))+#endif+#ifndef SvPV_flags_mutable+#  define SvPV_flags_mutable(sv, lp, flags) \+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \+                  ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \+                  sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))+#endif+#ifndef SvPV_force+#  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)+#endif++#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, DPPP_SVPV_NOLEN_LP_ARG, flags))+#endif+#ifndef SvPV_force_flags_mutable+#  define SvPV_force_flags_mutable(sv, lp, flags) \+                 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \+                 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \+                  : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))+#endif+#ifndef SvPV_nolen+#  define SvPV_nolen(sv)                 \+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \+                  ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))+#endif+#ifndef SvPV_nolen_const+#  define SvPV_nolen_const(sv)           \+                 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \+                  ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))+#endif+#ifndef SvPV_nomg+#  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)+#endif++#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, DPPP_SVPV_NOLEN_LP_ARG, 0))+#endif+#ifndef SvPV_renew+#  define SvPV_renew(sv,n)               STMT_START { SvLEN_set(sv, n); \+                 SvPV_set((sv), (char *) saferealloc(          \+                       (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \+               } STMT_END+#endif+#ifndef SvMAGIC_set+#  define SvMAGIC_set(sv, val)           \+                STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \+                (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END+#endif++#if (PERL_BCDVERSION < 0x5009003)+#ifndef SvPVX_const+#  define SvPVX_const(sv)                ((const char*) (0 + SvPVX(sv)))+#endif++#ifndef SvPVX_mutable+#  define SvPVX_mutable(sv)              (0 + SvPVX(sv))+#endif+#ifndef SvRV_set+#  define SvRV_set(sv, val)              \+                STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \+                (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END+#endif++#else+#ifndef SvPVX_const+#  define SvPVX_const(sv)                ((const char*)((sv)->sv_u.svu_pv))+#endif++#ifndef SvPVX_mutable+#  define SvPVX_mutable(sv)              ((sv)->sv_u.svu_pv)+#endif+#ifndef SvRV_set+#  define SvRV_set(sv, val)              \+                STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \+                ((sv)->sv_u.svu_rv = (val)); } STMT_END+#endif++#endif+#ifndef SvSTASH_set+#  define SvSTASH_set(sv, val)           \+                STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \+                (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END+#endif++#if (PERL_BCDVERSION < 0x5004000)+#ifndef SvUV_set+#  define SvUV_set(sv, val)              \+                STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \+                (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END+#endif++#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++#ifdef vnewSVpvf+#  undef vnewSVpvf+#endif+#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)+#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)++#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)++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++#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)++#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)++void+DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)+{+  va_list args;+  va_start(args, pat);+  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));+  SvSETMAGIC(sv);+  va_end(args);+}++#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++#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)+#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)++#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)++void+DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)+{+  dTHX;+  va_list args;+  va_start(args, pat);+  sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));+  SvSETMAGIC(sv);+  va_end(args);+}++#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++#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)++#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)++void+DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)+{+  va_list args;+  va_start(args, pat);+  sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));+  SvSETMAGIC(sv);+  va_end(args);+}++#endif+#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++#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)+#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)++#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)++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: newSVpvn_share
+ * The SVs created by this function only mimic the behaviour of+ * shared PVs without really being shared. Only use if you know+ * what you're doing.+ */++#ifndef newSVpvn_share++#if defined(NEED_newSVpvn_share)+static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);+static+#else+extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);+#endif++#ifdef newSVpvn_share+#  undef newSVpvn_share+#endif+#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)+#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)++#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)++SV *+DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)+{+  SV *sv;+  if (len < 0)+    len = -len;+  if (!hash)+    PERL_HASH(hash, (char*) src, len);+  sv = newSVpvn((char *) src, len);+  sv_upgrade(sv, SVt_PVIV);+  SvIVX(sv) = hash;+  SvREADONLY_on(sv);+  SvPOK_on(sv);+  return sv;+}++#endif++#endif+#ifndef SvSHARED_HASH+#  define SvSHARED_HASH(sv)              (0 + SvUVX(sv))+#endif+#ifndef HvNAME_get+#  define HvNAME_get(hv)                 HvNAME(hv)+#endif+#ifndef HvNAMELEN_get+#  define HvNAMELEN_get(hv)              (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)+#endif+#ifndef GvSVn+#  define GvSVn(gv)                      GvSV(gv)+#endif++#ifndef isGV_with_GP+#  define isGV_with_GP(gv)               isGV(gv)+#endif++#ifndef gv_fetchpvn_flags+#  define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt)+#endif++#ifndef gv_fetchsv+#  define gv_fetchsv(name, flags, svt)   gv_fetchpv(SvPV_nolen_const(name), flags, svt)+#endif+#ifndef get_cvn_flags+#  define get_cvn_flags(name, namelen, flags) get_cv(name, flags)+#endif+#ifndef 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++#define Perl_warner DPPP_(my_warner)++#if defined(NEED_warner) || defined(NEED_warner_GLOBAL)++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+ * under some configurations might be macros+ */+#ifndef STR_WITH_LEN+#  define STR_WITH_LEN(s)                (s ""), (sizeof(s)-1)+#endif+#ifndef newSVpvs+#  define newSVpvs(str)                  newSVpvn(str "", sizeof(str) - 1)+#endif++#ifndef newSVpvs_flags+#  define newSVpvs_flags(str, flags)     newSVpvn_flags(str "", sizeof(str) - 1, flags)+#endif++#ifndef newSVpvs_share+#  define newSVpvs_share(str)            newSVpvn_share(str "", sizeof(str) - 1, 0)+#endif++#ifndef sv_catpvs+#  define sv_catpvs(sv, str)             sv_catpvn(sv, str "", sizeof(str) - 1)+#endif++#ifndef sv_setpvs+#  define sv_setpvs(sv, str)             sv_setpvn(sv, str "", sizeof(str) - 1)+#endif++#ifndef hv_fetchs+#  define hv_fetchs(hv, key, lval)       hv_fetch(hv, key "", sizeof(key) - 1, lval)+#endif++#ifndef hv_stores+#  define hv_stores(hv, key, val)        hv_store(hv, key "", sizeof(key) - 1, val, 0)+#endif+#ifndef gv_fetchpvs+#  define gv_fetchpvs(name, flags, svt)  gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)+#endif++#ifndef gv_stashpvs+#  define gv_stashpvs(name, flags)       gv_stashpvn(name "", sizeof(name) - 1, flags)+#endif+#ifndef get_cvs+#  define get_cvs(name, flags)           get_cvn_flags(name "", sizeof(name)-1, flags)+#endif+#ifndef SvGETMAGIC+#  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END+#endif+#ifndef PERL_MAGIC_sv+#  define PERL_MAGIC_sv                  '\0'+#endif++#ifndef PERL_MAGIC_overload+#  define PERL_MAGIC_overload            'A'+#endif++#ifndef PERL_MAGIC_overload_elem+#  define PERL_MAGIC_overload_elem       'a'+#endif++#ifndef PERL_MAGIC_overload_table+#  define PERL_MAGIC_overload_table      'c'+#endif++#ifndef PERL_MAGIC_bm+#  define PERL_MAGIC_bm                  'B'+#endif++#ifndef PERL_MAGIC_regdata+#  define PERL_MAGIC_regdata             'D'+#endif++#ifndef PERL_MAGIC_regdatum+#  define PERL_MAGIC_regdatum            'd'+#endif++#ifndef PERL_MAGIC_env+#  define PERL_MAGIC_env                 'E'+#endif++#ifndef PERL_MAGIC_envelem+#  define PERL_MAGIC_envelem             'e'+#endif++#ifndef PERL_MAGIC_fm+#  define PERL_MAGIC_fm                  'f'+#endif++#ifndef PERL_MAGIC_regex_global+#  define PERL_MAGIC_regex_global        'g'+#endif++#ifndef PERL_MAGIC_isa+#  define PERL_MAGIC_isa                 'I'+#endif++#ifndef PERL_MAGIC_isaelem+#  define PERL_MAGIC_isaelem             'i'+#endif++#ifndef PERL_MAGIC_nkeys+#  define PERL_MAGIC_nkeys               'k'+#endif++#ifndef PERL_MAGIC_dbfile+#  define PERL_MAGIC_dbfile              'L'+#endif++#ifndef PERL_MAGIC_dbline+#  define PERL_MAGIC_dbline              'l'+#endif++#ifndef PERL_MAGIC_mutex+#  define PERL_MAGIC_mutex               'm'+#endif++#ifndef PERL_MAGIC_shared+#  define PERL_MAGIC_shared              'N'+#endif++#ifndef PERL_MAGIC_shared_scalar+#  define PERL_MAGIC_shared_scalar       'n'+#endif++#ifndef PERL_MAGIC_collxfrm+#  define PERL_MAGIC_collxfrm            'o'+#endif++#ifndef PERL_MAGIC_tied+#  define PERL_MAGIC_tied                'P'+#endif++#ifndef PERL_MAGIC_tiedelem+#  define PERL_MAGIC_tiedelem            'p'+#endif++#ifndef PERL_MAGIC_tiedscalar+#  define PERL_MAGIC_tiedscalar          'q'+#endif++#ifndef PERL_MAGIC_qr+#  define PERL_MAGIC_qr                  'r'+#endif++#ifndef PERL_MAGIC_sig+#  define PERL_MAGIC_sig                 'S'+#endif++#ifndef PERL_MAGIC_sigelem+#  define PERL_MAGIC_sigelem             's'+#endif++#ifndef PERL_MAGIC_taint+#  define PERL_MAGIC_taint               't'+#endif++#ifndef PERL_MAGIC_uvar+#  define PERL_MAGIC_uvar                'U'+#endif++#ifndef PERL_MAGIC_uvar_elem+#  define PERL_MAGIC_uvar_elem           'u'+#endif++#ifndef PERL_MAGIC_vstring+#  define PERL_MAGIC_vstring             'V'+#endif++#ifndef PERL_MAGIC_vec+#  define PERL_MAGIC_vec                 'v'+#endif++#ifndef PERL_MAGIC_utf8+#  define PERL_MAGIC_utf8                'w'+#endif++#ifndef PERL_MAGIC_substr+#  define PERL_MAGIC_substr              'x'+#endif++#ifndef PERL_MAGIC_defelem+#  define PERL_MAGIC_defelem             'y'+#endif++#ifndef PERL_MAGIC_glob+#  define PERL_MAGIC_glob                '*'+#endif++#ifndef PERL_MAGIC_arylen+#  define PERL_MAGIC_arylen              '#'+#endif++#ifndef PERL_MAGIC_pos+#  define PERL_MAGIC_pos                 '.'+#endif++#ifndef PERL_MAGIC_backref+#  define PERL_MAGIC_backref             '<'+#endif++#ifndef PERL_MAGIC_ext+#  define PERL_MAGIC_ext                 '~'+#endif++/* That's the best we can do... */+#ifndef sv_catpvn_nomg+#  define sv_catpvn_nomg                 sv_catpvn+#endif++#ifndef sv_catsv_nomg+#  define sv_catsv_nomg                  sv_catsv+#endif++#ifndef sv_setsv_nomg+#  define sv_setsv_nomg                  sv_setsv+#endif++#ifndef sv_pvn_nomg+#  define sv_pvn_nomg                    sv_pvn+#endif++#ifndef SvIV_nomg+#  define SvIV_nomg                      SvIV+#endif++#ifndef SvUV_nomg+#  define SvUV_nomg                      SvUV+#endif++#ifndef sv_catpv_mg+#  define sv_catpv_mg(sv, ptr)          \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_catpv(TeMpSv,ptr);              \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_catpvn_mg+#  define sv_catpvn_mg(sv, ptr, len)    \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_catpvn(TeMpSv,ptr,len);         \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_catsv_mg+#  define sv_catsv_mg(dsv, ssv)         \+   STMT_START {                         \+     SV *TeMpSv = dsv;                  \+     sv_catsv(TeMpSv,ssv);              \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_setiv_mg+#  define sv_setiv_mg(sv, i)            \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_setiv(TeMpSv,i);                \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_setnv_mg+#  define sv_setnv_mg(sv, num)          \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_setnv(TeMpSv,num);              \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_setpv_mg+#  define sv_setpv_mg(sv, ptr)          \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_setpv(TeMpSv,ptr);              \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_setpvn_mg+#  define sv_setpvn_mg(sv, ptr, len)    \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_setpvn(TeMpSv,ptr,len);         \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_setsv_mg+#  define sv_setsv_mg(dsv, ssv)         \+   STMT_START {                         \+     SV *TeMpSv = dsv;                  \+     sv_setsv(TeMpSv,ssv);              \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_setuv_mg+#  define sv_setuv_mg(sv, i)            \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_setuv(TeMpSv,i);                \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif++#ifndef sv_usepvn_mg+#  define sv_usepvn_mg(sv, ptr, len)    \+   STMT_START {                         \+     SV *TeMpSv = sv;                   \+     sv_usepvn(TeMpSv,ptr,len);         \+     SvSETMAGIC(TeMpSv);                \+   } STMT_END+#endif+#ifndef SvVSTRING_mg+#  define SvVSTRING_mg(sv)               (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)+#endif++/* Hint: sv_magic_portable
+ * This is a compatibility function that is only available with+ * Devel::PPPort. It is NOT in the perl core.+ * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when+ * it is being passed a name pointer with namlen == 0. In that+ * case, perl 5.8.0 and later store the pointer, not a copy of it.+ * The compatibility can be provided back to perl 5.004. With+ * earlier versions, the code will not compile.+ */++#if (PERL_BCDVERSION < 0x5004000)++  /* code that uses sv_magic_portable will not compile */++#elif (PERL_BCDVERSION < 0x5008000)++#  define sv_magic_portable(sv, obj, how, name, namlen)     \+   STMT_START {                                             \+     SV *SvMp_sv = (sv);                                    \+     char *SvMp_name = (char *) (name);                     \+     I32 SvMp_namlen = (namlen);                            \+     if (SvMp_name && SvMp_namlen == 0)                     \+     {                                                      \+       MAGIC *mg;                                           \+       sv_magic(SvMp_sv, obj, how, 0, 0);                   \+       mg = SvMAGIC(SvMp_sv);                               \+       mg->mg_len = -42; /* XXX: this is the tricky part */ \+       mg->mg_ptr = SvMp_name;                              \+     }                                                      \+     else                                                   \+     {                                                      \+       sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \+     }                                                      \+   } STMT_END++#else++#  define sv_magic_portable(a, b, c, d, e)  sv_magic(a, b, c, d, e)++#endif++#ifdef USE_ITHREADS+#ifndef CopFILE+#  define CopFILE(c)                     ((c)->cop_file)+#endif++#ifndef CopFILEGV+#  define CopFILEGV(c)                   (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)+#endif++#ifndef CopFILE_set+#  define CopFILE_set(c,pv)              ((c)->cop_file = savepv(pv))+#endif++#ifndef CopFILESV+#  define CopFILESV(c)                   (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)+#endif++#ifndef CopFILEAV+#  define CopFILEAV(c)                   (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)+#endif++#ifndef CopSTASHPV+#  define CopSTASHPV(c)                  ((c)->cop_stashpv)+#endif++#ifndef CopSTASHPV_set+#  define CopSTASHPV_set(c,pv)           ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))+#endif++#ifndef CopSTASH+#  define CopSTASH(c)                    (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)+#endif++#ifndef CopSTASH_set+#  define CopSTASH_set(c,hv)             CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)+#endif++#ifndef CopSTASH_eq+#  define CopSTASH_eq(c,hv)              ((hv) && (CopSTASHPV(c) == HvNAME(hv) \+                                        || (CopSTASHPV(c) && HvNAME(hv) \+                                        && strEQ(CopSTASHPV(c), HvNAME(hv)))))+#endif++#else+#ifndef CopFILEGV+#  define CopFILEGV(c)                   ((c)->cop_filegv)+#endif++#ifndef CopFILEGV_set+#  define CopFILEGV_set(c,gv)            ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))+#endif++#ifndef CopFILE_set+#  define CopFILE_set(c,pv)              CopFILEGV_set((c), gv_fetchfile(pv))+#endif++#ifndef CopFILESV+#  define CopFILESV(c)                   (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)+#endif++#ifndef CopFILEAV+#  define CopFILEAV(c)                   (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)+#endif++#ifndef CopFILE+#  define CopFILE(c)                     (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)+#endif++#ifndef CopSTASH+#  define CopSTASH(c)                    ((c)->cop_stash)+#endif++#ifndef CopSTASH_set+#  define CopSTASH_set(c,hv)             ((c)->cop_stash = (hv))+#endif++#ifndef CopSTASHPV+#  define CopSTASHPV(c)                  (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)+#endif++#ifndef CopSTASHPV_set+#  define CopSTASHPV_set(c,pv)           CopSTASH_set((c), gv_stashpv(pv,GV_ADD))+#endif++#ifndef CopSTASH_eq+#  define CopSTASH_eq(c,hv)              (CopSTASH(c) == (hv))+#endif++#endif /* USE_ITHREADS */+#ifndef IN_PERL_COMPILETIME+#  define IN_PERL_COMPILETIME            (PL_curcop == &PL_compiling)+#endif++#ifndef IN_LOCALE_RUNTIME+#  define IN_LOCALE_RUNTIME              (PL_curcop->op_private & HINT_LOCALE)+#endif++#ifndef IN_LOCALE_COMPILETIME+#  define IN_LOCALE_COMPILETIME          (PL_hints & HINT_LOCALE)+#endif++#ifndef IN_LOCALE+#  define IN_LOCALE                      (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)+#endif+#ifndef IS_NUMBER_IN_UV+#  define IS_NUMBER_IN_UV                0x01+#endif++#ifndef IS_NUMBER_GREATER_THAN_UV_MAX+#  define IS_NUMBER_GREATER_THAN_UV_MAX  0x02+#endif++#ifndef IS_NUMBER_NOT_INT+#  define IS_NUMBER_NOT_INT              0x04+#endif++#ifndef IS_NUMBER_NEG+#  define IS_NUMBER_NEG                  0x08+#endif++#ifndef IS_NUMBER_INFINITY+#  define IS_NUMBER_INFINITY             0x10+#endif++#ifndef IS_NUMBER_NAN+#  define IS_NUMBER_NAN                  0x20+#endif+#ifndef GROK_NUMERIC_RADIX+#  define GROK_NUMERIC_RADIX(sp, send)   grok_numeric_radix(sp, send)+#endif+#ifndef PERL_SCAN_GREATER_THAN_UV_MAX+#  define PERL_SCAN_GREATER_THAN_UV_MAX  0x02+#endif++#ifndef PERL_SCAN_SILENT_ILLDIGIT+#  define PERL_SCAN_SILENT_ILLDIGIT      0x04+#endif++#ifndef PERL_SCAN_ALLOW_UNDERSCORES+#  define PERL_SCAN_ALLOW_UNDERSCORES    0x01+#endif++#ifndef PERL_SCAN_DISALLOW_PREFIX+#  define PERL_SCAN_DISALLOW_PREFIX      0x02+#endif++#ifndef grok_numeric_radix+#if defined(NEED_grok_numeric_radix)+static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);+static+#else+extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);+#endif++#ifdef grok_numeric_radix+#  undef grok_numeric_radix+#endif+#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)+#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)++#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)+bool+DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)+{+#ifdef USE_LOCALE_NUMERIC+#ifdef PL_numeric_radix_sv+    if (PL_numeric_radix_sv && IN_LOCALE) {+        STRLEN len;+        char* radix = SvPV(PL_numeric_radix_sv, len);+        if (*sp + len <= send && memEQ(*sp, radix, len)) {+            *sp += len;+            return TRUE;+        }+    }+#else+    /* older perls don't have PL_numeric_radix_sv so the radix
+     * must manually be requested from locale.h+     */+#include <locale.h>+    dTHR;  /* needed for older threaded perls */+    struct lconv *lc = localeconv();+    char *radix = lc->decimal_point;+    if (radix && IN_LOCALE) {+        STRLEN len = strlen(radix);+        if (*sp + len <= send && memEQ(*sp, radix, len)) {+            *sp += len;+            return TRUE;+        }+    }+#endif+#endif /* USE_LOCALE_NUMERIC */+    /* always try "." if numeric radix didn't match because
+     * we may have data from different locales mixed */+    if (*sp < send && **sp == '.') {+        ++*sp;+        return TRUE;+    }+    return FALSE;+}+#endif+#endif++#ifndef grok_number+#if defined(NEED_grok_number)+static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);+static+#else+extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);+#endif++#ifdef grok_number+#  undef grok_number+#endif+#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)+#define Perl_grok_number DPPP_(my_grok_number)++#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)+int+DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)+{+  const char *s = pv;+  const char *send = pv + len;+  const UV max_div_10 = UV_MAX / 10;+  const char max_mod_10 = UV_MAX % 10;+  int numtype = 0;+  int sawinf = 0;+  int sawnan = 0;++  while (s < send && isSPACE(*s))+    s++;+  if (s == send) {+    return 0;+  } else if (*s == '-') {+    s++;+    numtype = IS_NUMBER_NEG;+  }+  else if (*s == '+')+  s++;++  if (s == send)+    return 0;++  /* next must be digit or the radix separator or beginning of infinity */+  if (isDIGIT(*s)) {+    /* UVs are at least 32 bits, so the first 9 decimal digits cannot
+       overflow.  */+    UV value = *s - '0';+    /* This construction seems to be more optimiser friendly.
+       (without it gcc does the isDIGIT test and the *s - '0' separately)+       With it gcc on arm is managing 6 instructions (6 cycles) per digit.+       In theory the optimiser could deduce how far to unroll the loop+       before checking for overflow.  */+    if (++s < send) {+      int digit = *s - '0';+      if (digit >= 0 && digit <= 9) {+        value = value * 10 + digit;+        if (++s < send) {+          digit = *s - '0';+          if (digit >= 0 && digit <= 9) {+            value = value * 10 + digit;+            if (++s < send) {+              digit = *s - '0';+              if (digit >= 0 && digit <= 9) {+                value = value * 10 + digit;+                if (++s < send) {+                  digit = *s - '0';+                  if (digit >= 0 && digit <= 9) {+                    value = value * 10 + digit;+                    if (++s < send) {+                      digit = *s - '0';+                      if (digit >= 0 && digit <= 9) {+                        value = value * 10 + digit;+                        if (++s < send) {+                          digit = *s - '0';+                          if (digit >= 0 && digit <= 9) {+                            value = value * 10 + digit;+                            if (++s < send) {+                              digit = *s - '0';+                              if (digit >= 0 && digit <= 9) {+                                value = value * 10 + digit;+                                if (++s < send) {+                                  digit = *s - '0';+                                  if (digit >= 0 && digit <= 9) {+                                    value = value * 10 + digit;+                                    if (++s < send) {+                                      /* Now got 9 digits, so need to check
+                                         each time for overflow.  */+                                      digit = *s - '0';+                                      while (digit >= 0 && digit <= 9+                                             && (value < max_div_10+                                                 || (value == max_div_10+                                                     && digit <= max_mod_10))) {+                                        value = value * 10 + digit;+                                        if (++s < send)+                                          digit = *s - '0';+                                        else+                                          break;+                                      }+                                      if (digit >= 0 && digit <= 9+                                          && (s < send)) {+                                        /* value overflowed.
+                                           skip the remaining digits, don't+                                           worry about setting *valuep.  */+                                        do {+                                          s++;+                                        } while (s < send && isDIGIT(*s));+                                        numtype |=+                                          IS_NUMBER_GREATER_THAN_UV_MAX;+                                        goto skip_value;+                                      }+                                    }+                                  }+                                }+                              }+                            }+                          }+                        }+                      }+                    }+                  }+                }+              }+            }+          }+        }+      }+    }+    numtype |= IS_NUMBER_IN_UV;+    if (valuep)+      *valuep = value;++  skip_value:+    if (GROK_NUMERIC_RADIX(&s, send)) {+      numtype |= IS_NUMBER_NOT_INT;+      while (s < send && isDIGIT(*s))  /* optional digits after the radix */+        s++;+    }+  }+  else if (GROK_NUMERIC_RADIX(&s, send)) {+    numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */+    /* no digits before the radix means we need digits after it */+    if (s < send && isDIGIT(*s)) {+      do {+        s++;+      } while (s < send && isDIGIT(*s));+      if (valuep) {+        /* integer approximation is valid - it's 0.  */+        *valuep = 0;+      }+    }+    else+      return 0;+  } else if (*s == 'I' || *s == 'i') {+    s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;+    s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;+    s++; if (s < send && (*s == 'I' || *s == 'i')) {+      s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;+      s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;+      s++; if (s == send || (*s != 'T' && *s != 't')) return 0;+      s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;+      s++;+    }+    sawinf = 1;+  } else if (*s == 'N' || *s == 'n') {+    /* XXX TODO: There are signaling NaNs and quiet NaNs. */+    s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;+    s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;+    s++;+    sawnan = 1;+  } else+    return 0;++  if (sawinf) {+    numtype &= IS_NUMBER_NEG; /* Keep track of sign  */+    numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;+  } else if (sawnan) {+    numtype &= IS_NUMBER_NEG; /* Keep track of sign  */+    numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;+  } else if (s < send) {+    /* we can have an optional exponent part */+    if (*s == 'e' || *s == 'E') {+      /* The only flag we keep is sign.  Blow away any "it's UV"  */+      numtype &= IS_NUMBER_NEG;+      numtype |= IS_NUMBER_NOT_INT;+      s++;+      if (s < send && (*s == '-' || *s == '+'))+        s++;+      if (s < send && isDIGIT(*s)) {+        do {+          s++;+        } while (s < send && isDIGIT(*s));+      }+      else+      return 0;+    }+  }+  while (s < send && isSPACE(*s))+    s++;+  if (s >= send)+    return numtype;+  if (len == 10 && memEQ(pv, "0 but true", 10)) {+    if (valuep)+      *valuep = 0;+    return IS_NUMBER_IN_UV;+  }+  return 0;+}+#endif+#endif++/*
+ * The grok_* routines have been modified to use warn() instead of+ * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit,+ * which is why the stack variable has been renamed to 'xdigit'.+ */++#ifndef grok_bin+#if defined(NEED_grok_bin)+static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);+static+#else+extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);+#endif++#ifdef grok_bin+#  undef grok_bin+#endif+#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)+#define Perl_grok_bin DPPP_(my_grok_bin)++#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)+UV+DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)+{+    const char *s = start;+    STRLEN len = *len_p;+    UV value = 0;+    NV value_nv = 0;++    const UV max_div_2 = UV_MAX / 2;+    bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;+    bool overflowed = FALSE;++    if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {+        /* strip off leading b or 0b.
+           for compatibility silently suffer "b" and "0b" as valid binary+           numbers. */+        if (len >= 1) {+            if (s[0] == 'b') {+                s++;+                len--;+            }+            else if (len >= 2 && s[0] == '0' && s[1] == 'b') {+                s+=2;+                len-=2;+            }+        }+    }++    for (; len-- && *s; s++) {+        char bit = *s;+        if (bit == '0' || bit == '1') {+            /* Write it in this wonky order with a goto to attempt to get the
+               compiler to make the common case integer-only loop pretty tight.+               With gcc seems to be much straighter code than old scan_bin.  */+          redo:+            if (!overflowed) {+                if (value <= max_div_2) {+                    value = (value << 1) | (bit - '0');+                    continue;+                }+                /* Bah. We're just overflowed.  */+                warn("Integer overflow in binary number");+                overflowed = TRUE;+                value_nv = (NV) value;+            }+            value_nv *= 2.0;+            /* If an NV has not enough bits in its mantissa to
+             * represent a UV this summing of small low-order numbers+             * is a waste of time (because the NV cannot preserve+             * the low-order bits anyway): we could just remember when+             * did we overflow and in the end just multiply value_nv by the+             * right amount. */+            value_nv += (NV)(bit - '0');+            continue;+        }+        if (bit == '_' && len && allow_underscores && (bit = s[1])+            && (bit == '0' || bit == '1'))+            {+                --len;+                ++s;+                goto redo;+            }+        if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))+            warn("Illegal binary digit '%c' ignored", *s);+        break;+    }++    if (   ( overflowed && value_nv > 4294967295.0)+#if UVSIZE > 4+        || (!overflowed && value > 0xffffffff  )+#endif+        ) {+        warn("Binary number > 0b11111111111111111111111111111111 non-portable");+    }+    *len_p = s - start;+    if (!overflowed) {+        *flags = 0;+        return value;+    }+    *flags = PERL_SCAN_GREATER_THAN_UV_MAX;+    if (result)+        *result = value_nv;+    return UV_MAX;+}+#endif+#endif++#ifndef grok_hex+#if defined(NEED_grok_hex)+static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);+static+#else+extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);+#endif++#ifdef grok_hex+#  undef grok_hex+#endif+#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)+#define Perl_grok_hex DPPP_(my_grok_hex)++#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)+UV+DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)+{+    const char *s = start;+    STRLEN len = *len_p;+    UV value = 0;+    NV value_nv = 0;++    const UV max_div_16 = UV_MAX / 16;+    bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;+    bool overflowed = FALSE;+    const char *xdigit;++    if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {+        /* strip off leading x or 0x.
+           for compatibility silently suffer "x" and "0x" as valid hex numbers.+        */+        if (len >= 1) {+            if (s[0] == 'x') {+                s++;+                len--;+            }+            else if (len >= 2 && s[0] == '0' && s[1] == 'x') {+                s+=2;+                len-=2;+            }+        }+    }++    for (; len-- && *s; s++) {+        xdigit = strchr((char *) PL_hexdigit, *s);+        if (xdigit) {+            /* Write it in this wonky order with a goto to attempt to get the
+               compiler to make the common case integer-only loop pretty tight.+               With gcc seems to be much straighter code than old scan_hex.  */+          redo:+            if (!overflowed) {+                if (value <= max_div_16) {+                    value = (value << 4) | ((xdigit - PL_hexdigit) & 15);+                    continue;+                }+                warn("Integer overflow in hexadecimal number");+                overflowed = TRUE;+                value_nv = (NV) value;+            }+            value_nv *= 16.0;+            /* If an NV has not enough bits in its mantissa to
+             * represent a UV this summing of small low-order numbers+             * is a waste of time (because the NV cannot preserve+             * the low-order bits anyway): we could just remember when+             * did we overflow and in the end just multiply value_nv by the+             * right amount of 16-tuples. */+            value_nv += (NV)((xdigit - PL_hexdigit) & 15);+            continue;+        }+        if (*s == '_' && len && allow_underscores && s[1]+                && (xdigit = strchr((char *) PL_hexdigit, s[1])))+            {+                --len;+                ++s;+                goto redo;+            }+        if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))+            warn("Illegal hexadecimal digit '%c' ignored", *s);+        break;+    }++    if (   ( overflowed && value_nv > 4294967295.0)+#if UVSIZE > 4+        || (!overflowed && value > 0xffffffff  )+#endif+        ) {+        warn("Hexadecimal number > 0xffffffff non-portable");+    }+    *len_p = s - start;+    if (!overflowed) {+        *flags = 0;+        return value;+    }+    *flags = PERL_SCAN_GREATER_THAN_UV_MAX;+    if (result)+        *result = value_nv;+    return UV_MAX;+}+#endif+#endif++#ifndef grok_oct+#if defined(NEED_grok_oct)+static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);+static+#else+extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);+#endif++#ifdef grok_oct+#  undef grok_oct+#endif+#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)+#define Perl_grok_oct DPPP_(my_grok_oct)++#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)+UV+DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)+{+    const char *s = start;+    STRLEN len = *len_p;+    UV value = 0;+    NV value_nv = 0;++    const UV max_div_8 = UV_MAX / 8;+    bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;+    bool overflowed = FALSE;++    for (; len-- && *s; s++) {+         /* gcc 2.95 optimiser not smart enough to figure that this subtraction
+            out front allows slicker code.  */+        int digit = *s - '0';+        if (digit >= 0 && digit <= 7) {+            /* Write it in this wonky order with a goto to attempt to get the
+               compiler to make the common case integer-only loop pretty tight.+            */+          redo:+            if (!overflowed) {+                if (value <= max_div_8) {+                    value = (value << 3) | digit;+                    continue;+                }+                /* Bah. We're just overflowed.  */+                warn("Integer overflow in octal number");+                overflowed = TRUE;+                value_nv = (NV) value;+            }+            value_nv *= 8.0;+            /* If an NV has not enough bits in its mantissa to
+             * represent a UV this summing of small low-order numbers+             * is a waste of time (because the NV cannot preserve+             * the low-order bits anyway): we could just remember when+             * did we overflow and in the end just multiply value_nv by the+             * right amount of 8-tuples. */+            value_nv += (NV)digit;+            continue;+        }+        if (digit == ('_' - '0') && len && allow_underscores+            && (digit = s[1] - '0') && (digit >= 0 && digit <= 7))+            {+                --len;+                ++s;+                goto redo;+            }+        /* Allow \octal to work the DWIM way (that is, stop scanning
+         * as soon as non-octal characters are seen, complain only iff+         * someone seems to want to use the digits eight and nine). */+        if (digit == 8 || digit == 9) {+            if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))+                warn("Illegal octal digit '%c' ignored", *s);+        }+        break;+    }++    if (   ( overflowed && value_nv > 4294967295.0)+#if UVSIZE > 4+        || (!overflowed && value > 0xffffffff  )+#endif+        ) {+        warn("Octal number > 037777777777 non-portable");+    }+    *len_p = s - start;+    if (!overflowed) {+        *flags = 0;+        return value;+    }+    *flags = PERL_SCAN_GREATER_THAN_UV_MAX;+    if (result)+        *result = value_nv;+    return UV_MAX;+}+#endif+#endif++#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+#else+extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);+#endif++#define my_snprintf DPPP_(my_my_snprintf)+#define Perl_my_snprintf DPPP_(my_my_snprintf)++#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)++int+DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)+{+    dTHX;+    int retval;+    va_list ap;+    va_start(ap, format);+#ifdef HAS_VSNPRINTF+    retval = vsnprintf(buffer, len, format, ap);+#else+    retval = vsprintf(buffer, format, ap);+#endif+    va_end(ap);+    if (retval < 0 || (len > 0 && (Size_t)retval >= len))+        Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");+    return retval;+}++#endif+#endif++#if !defined(my_sprintf)+#if defined(NEED_my_sprintf)+static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);+static+#else+extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);+#endif++#define my_sprintf DPPP_(my_my_sprintf)+#define Perl_my_sprintf DPPP_(my_my_sprintf)++#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)++int+DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)+{+    va_list args;+    va_start(args, pat);+    vsprintf(buffer, pat, args);+    va_end(args);+    return strlen(buffer);+}++#endif+#endif++#ifdef NO_XSLOCKS+#  ifdef dJMPENV+#    define dXCPT             dJMPENV; int rEtV = 0+#    define XCPT_TRY_START    JMPENV_PUSH(rEtV); if (rEtV == 0)+#    define XCPT_TRY_END      JMPENV_POP;+#    define XCPT_CATCH        if (rEtV != 0)+#    define XCPT_RETHROW      JMPENV_JUMP(rEtV)+#  else+#    define dXCPT             Sigjmp_buf oldTOP; int rEtV = 0+#    define XCPT_TRY_START    Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0)+#    define XCPT_TRY_END      Copy(oldTOP, top_env, 1, Sigjmp_buf);+#    define XCPT_CATCH        if (rEtV != 0)+#    define XCPT_RETHROW      Siglongjmp(top_env, rEtV)+#  endif+#endif++#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+#else+extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);+#endif++#define my_strlcat DPPP_(my_my_strlcat)+#define Perl_my_strlcat DPPP_(my_my_strlcat)++#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)++Size_t+DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)+{+    Size_t used, length, copy;++    used = strlen(dst);+    length = strlen(src);+    if (size > 0 && used < size - 1) {+        copy = (length >= size - used) ? size - used - 1 : length;+        memcpy(dst + used, src, copy);+        dst[used + copy] = '\0';+    }+    return used + length;+}+#endif+#endif++#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+#else+extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);+#endif++#define my_strlcpy DPPP_(my_my_strlcpy)+#define Perl_my_strlcpy DPPP_(my_my_strlcpy)++#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)++Size_t+DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)+{+    Size_t length, copy;++    length = strlen(src);+    if (size > 0) {+        copy = (length >= size) ? size - 1 : length;+        memcpy(dst, src, copy);+        dst[copy] = '\0';+    }+    return length;+}++#endif+#endif+#ifndef PERL_PV_ESCAPE_QUOTE+#  define PERL_PV_ESCAPE_QUOTE           0x0001+#endif++#ifndef PERL_PV_PRETTY_QUOTE+#  define PERL_PV_PRETTY_QUOTE           PERL_PV_ESCAPE_QUOTE+#endif++#ifndef PERL_PV_PRETTY_ELLIPSES+#  define PERL_PV_PRETTY_ELLIPSES        0x0002+#endif++#ifndef PERL_PV_PRETTY_LTGT+#  define PERL_PV_PRETTY_LTGT            0x0004+#endif++#ifndef PERL_PV_ESCAPE_FIRSTCHAR+#  define PERL_PV_ESCAPE_FIRSTCHAR       0x0008+#endif++#ifndef PERL_PV_ESCAPE_UNI+#  define PERL_PV_ESCAPE_UNI             0x0100+#endif++#ifndef PERL_PV_ESCAPE_UNI_DETECT+#  define PERL_PV_ESCAPE_UNI_DETECT      0x0200+#endif++#ifndef PERL_PV_ESCAPE_ALL+#  define PERL_PV_ESCAPE_ALL             0x1000+#endif++#ifndef PERL_PV_ESCAPE_NOBACKSLASH+#  define PERL_PV_ESCAPE_NOBACKSLASH     0x2000+#endif++#ifndef PERL_PV_ESCAPE_NOCLEAR+#  define PERL_PV_ESCAPE_NOCLEAR         0x4000+#endif++#ifndef PERL_PV_ESCAPE_RE+#  define PERL_PV_ESCAPE_RE              0x8000+#endif++#ifndef PERL_PV_PRETTY_NOCLEAR+#  define PERL_PV_PRETTY_NOCLEAR         PERL_PV_ESCAPE_NOCLEAR+#endif+#ifndef PERL_PV_PRETTY_DUMP+#  define PERL_PV_PRETTY_DUMP            PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE+#endif++#ifndef PERL_PV_PRETTY_REGPROP+#  define PERL_PV_PRETTY_REGPROP         PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE+#endif++/* Hint: pv_escape
+ * Note that unicode functionality is only backported to+ * those perl versions that support it. For older perl+ * versions, the implementation will fall back to bytes.+ */++#ifndef pv_escape+#if defined(NEED_pv_escape)+static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);+static+#else+extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);+#endif++#ifdef pv_escape+#  undef pv_escape+#endif+#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)+#define Perl_pv_escape DPPP_(my_pv_escape)++#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)++char *+DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,+  const STRLEN count, const STRLEN max,+  STRLEN * const escaped, const U32 flags)+{+    const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\';+    const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc;+    char octbuf[32] = "%123456789ABCDF";+    STRLEN wrote = 0;+    STRLEN chsize = 0;+    STRLEN readsize = 1;+#if defined(is_utf8_string) && defined(utf8_to_uvchr)+    bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0;+#endif+    const char *pv  = str;+    const char * const end = pv + count;+    octbuf[0] = esc;++    if (!(flags & PERL_PV_ESCAPE_NOCLEAR))+        sv_setpvs(dsv, "");++#if defined(is_utf8_string) && defined(utf8_to_uvchr)+    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) :+#endif+                             (U8)*pv;+        const U8 c = (U8)u & 0xFF;++        if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) {+            if (flags & PERL_PV_ESCAPE_FIRSTCHAR)+                chsize = my_snprintf(octbuf, sizeof octbuf,+                                      "%"UVxf, u);+            else+                chsize = my_snprintf(octbuf, sizeof octbuf,+                                      "%cx{%"UVxf"}", esc, u);+        } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {+            chsize = 1;+        } else {+            if (c == dq || c == esc || !isPRINT(c)) {+                chsize = 2;+                switch (c) {+                case '\\' : /* fallthrough */+                case '%'  : if (c == esc)+                                octbuf[1] = esc;+                            else+                                chsize = 1;+                            break;+                case '\v' : octbuf[1] = 'v'; break;+                case '\t' : octbuf[1] = 't'; break;+                case '\r' : octbuf[1] = 'r'; break;+                case '\n' : octbuf[1] = 'n'; break;+                case '\f' : octbuf[1] = 'f'; break;+                case '"'  : if (dq == '"')+                                octbuf[1] = '"';+                            else+                                chsize = 1;+                            break;+                default:    chsize = my_snprintf(octbuf, sizeof octbuf,+                                pv < end && isDIGIT((U8)*(pv+readsize))+                                ? "%c%03o" : "%c%o", esc, c);+                }+            } else {+                chsize = 1;+            }+        }+        if (max && wrote + chsize > max) {+            break;+        } else if (chsize > 1) {+            sv_catpvn(dsv, octbuf, chsize);+            wrote += chsize;+        } else {+            char tmp[2];+            my_snprintf(tmp, sizeof tmp, "%c", c);+            sv_catpvn(dsv, tmp, 1);+            wrote++;+        }+        if (flags & PERL_PV_ESCAPE_FIRSTCHAR)+            break;+    }+    if (escaped != NULL)+        *escaped= pv - str;+    return SvPVX(dsv);+}++#endif+#endif++#ifndef pv_pretty+#if defined(NEED_pv_pretty)+static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);+static+#else+extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);+#endif++#ifdef pv_pretty+#  undef pv_pretty+#endif+#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)+#define Perl_pv_pretty DPPP_(my_pv_pretty)++#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)++char *+DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,+  const STRLEN max, char const * const start_color, char const * const end_color,+  const U32 flags)+{+    const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';+    STRLEN escaped;++    if (!(flags & PERL_PV_PRETTY_NOCLEAR))+        sv_setpvs(dsv, "");++    if (dq == '"')+        sv_catpvs(dsv, "\"");+    else if (flags & PERL_PV_PRETTY_LTGT)+        sv_catpvs(dsv, "<");++    if (start_color != NULL)+        sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color));++    pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR);++    if (end_color != NULL)+        sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color));++    if (dq == '"')+        sv_catpvs(dsv, "\"");+    else if (flags & PERL_PV_PRETTY_LTGT)+        sv_catpvs(dsv, ">");++    if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count)+        sv_catpvs(dsv, "...");++    return SvPVX(dsv);+}++#endif+#endif++#ifndef pv_display+#if defined(NEED_pv_display)+static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);+static+#else+extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);+#endif++#ifdef pv_display+#  undef pv_display+#endif+#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)+#define Perl_pv_display DPPP_(my_pv_display)++#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)++char *+DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)+{+    pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);+    if (len > cur && pv[cur] == '\0')+        sv_catpvs(dsv, "\\0");+    return SvPVX(dsv);+}++#endif+#endif++#endif /* _P_P_PORTABILITY_H_ */++/* End of File ppport.h */