share/ppport.h

00001 #if 0
00002 <<'SKIP';
00003 #endif
00004 /*
00005 ----------------------------------------------------------------------
00006 
00007     ppport.h -- Perl/Pollution/Portability Version 3.17
00008 
00009     Automatically created by Devel::PPPort running under perl 5.010000.
00010 
00011     Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
00012     includes in parts/inc/ instead.
00013 
00014     Use 'perldoc ppport.h' to view the documentation below.
00015 
00016 ----------------------------------------------------------------------
00017 
00018 SKIP
00019 
00020 =pod
00021 
00022 =head1 NAME
00023 
00024 ppport.h - Perl/Pollution/Portability version 3.17
00025 
00026 =head1 SYNOPSIS
00027 
00028   perl ppport.h [options] [source files]
00029 
00030   Searches current directory for files if no [source files] are given
00031 
00032   --help                      show short help
00033 
00034   --version                   show version
00035 
00036   --patch=file                write one patch file with changes
00037   --copy=suffix               write changed copies with suffix
00038   --diff=program              use diff program and options
00039 
00040   --compat-version=version    provide compatibility with Perl version
00041   --cplusplus                 accept C++ comments
00042 
00043   --quiet                     don't output anything except fatal errors
00044   --nodiag                    don't show diagnostics
00045   --nohints                   don't show hints
00046   --nochanges                 don't suggest changes
00047   --nofilter                  don't filter input files
00048 
00049   --strip                     strip all script and doc functionality from
00050                               ppport.h
00051 
00052   --list-provided             list provided API
00053   --list-unsupported          list unsupported API
00054   --api-info=name             show Perl API portability information
00055 
00056 =head1 COMPATIBILITY
00057 
00058 This version of F<ppport.h> is designed to support operation with Perl
00059 installations back to 5.003, and has been tested up to 5.10.0.
00060 
00061 =head1 OPTIONS
00062 
00063 =head2 --help
00064 
00065 Display a brief usage summary.
00066 
00067 =head2 --version
00068 
00069 Display the version of F<ppport.h>.
00070 
00071 =head2 --patch=I<file>
00072 
00073 If this option is given, a single patch file will be created if
00074 any changes are suggested. This requires a working diff program
00075 to be installed on your system.
00076 
00077 =head2 --copy=I<suffix>
00078 
00079 If this option is given, a copy of each file will be saved with
00080 the given suffix that contains the suggested changes. This does
00081 not require any external programs. Note that this does not
00082 automagially add a dot between the original filename and the
00083 suffix. If you want the dot, you have to include it in the option
00084 argument.
00085 
00086 If neither C<--patch> or C<--copy> are given, the default is to
00087 simply print the diffs for each file. This requires either
00088 C<Text::Diff> or a C<diff> program to be installed.
00089 
00090 =head2 --diff=I<program>
00091 
00092 Manually set the diff program and options to use. The default
00093 is to use C<Text::Diff>, when installed, and output unified
00094 context diffs.
00095 
00096 =head2 --compat-version=I<version>
00097 
00098 Tell F<ppport.h> to check for compatibility with the given
00099 Perl version. The default is to check for compatibility with Perl
00100 version 5.003. You can use this option to reduce the output
00101 of F<ppport.h> if you intend to be backward compatible only
00102 down to a certain Perl version.
00103 
00104 =head2 --cplusplus
00105 
00106 Usually, F<ppport.h> will detect C++ style comments and
00107 replace them with C style comments for portability reasons.
00108 Using this option instructs F<ppport.h> to leave C++
00109 comments untouched.
00110 
00111 =head2 --quiet
00112 
00113 Be quiet. Don't print anything except fatal errors.
00114 
00115 =head2 --nodiag
00116 
00117 Don't output any diagnostic messages. Only portability
00118 alerts will be printed.
00119 
00120 =head2 --nohints
00121 
00122 Don't output any hints. Hints often contain useful portability
00123 notes. Warnings will still be displayed.
00124 
00125 =head2 --nochanges
00126 
00127 Don't suggest any changes. Only give diagnostic output and hints
00128 unless these are also deactivated.
00129 
00130 =head2 --nofilter
00131 
00132 Don't filter the list of input files. By default, files not looking
00133 like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped.
00134 
00135 =head2 --strip
00136 
00137 Strip all script and documentation functionality from F<ppport.h>.
00138 This reduces the size of F<ppport.h> dramatically and may be useful
00139 if you want to include F<ppport.h> in smaller modules without
00140 increasing their distribution size too much.
00141 
00142 The stripped F<ppport.h> will have a C<--unstrip> option that allows
00143 you to undo the stripping, but only if an appropriate C<Devel::PPPort>
00144 module is installed.
00145 
00146 =head2 --list-provided
00147 
00148 Lists the API elements for which compatibility is provided by
00149 F<ppport.h>. Also lists if it must be explicitly requested,
00150 if it has dependencies, and if there are hints or warnings for it.
00151 
00152 =head2 --list-unsupported
00153 
00154 Lists the API elements that are known not to be supported by
00155 F<ppport.h> and below which version of Perl they probably
00156 won't be available or work.
00157 
00158 =head2 --api-info=I<name>
00159 
00160 Show portability information for API elements matching I<name>.
00161 If I<name> is surrounded by slashes, it is interpreted as a regular
00162 expression.
00163 
00164 =head1 DESCRIPTION
00165 
00166 In order for a Perl extension (XS) module to be as portable as possible
00167 across differing versions of Perl itself, certain steps need to be taken.
00168 
00169 =over 4
00170 
00171 =item *
00172 
00173 Including this header is the first major one. This alone will give you
00174 access to a large part of the Perl API that hasn't been available in
00175 earlier Perl releases. Use
00176 
00177     perl ppport.h --list-provided
00178 
00179 to see which API elements are provided by ppport.h.
00180 
00181 =item *
00182 
00183 You should avoid using deprecated parts of the API. For example, using
00184 global Perl variables without the C<PL_> prefix is deprecated. Also,
00185 some API functions used to have a C<perl_> prefix. Using this form is
00186 also deprecated. You can safely use the supported API, as F<ppport.h>
00187 will provide wrappers for older Perl versions.
00188 
00189 =item *
00190 
00191 If you use one of a few functions or variables that were not present in
00192 earlier versions of Perl, and that can't be provided using a macro, you
00193 have to explicitly request support for these functions by adding one or
00194 more C<#define>s in your source code before the inclusion of F<ppport.h>.
00195 
00196 These functions or variables will be marked C<explicit> in the list shown
00197 by C<--list-provided>.
00198 
00199 Depending on whether you module has a single or multiple files that
00200 use such functions or variables, you want either C<static> or global
00201 variants.
00202 
00203 For a C<static> function or variable (used only in a single source
00204 file), use:
00205 
00206     #define NEED_function
00207     #define NEED_variable
00208 
00209 For a global function or variable (used in multiple source files),
00210 use:
00211 
00212     #define NEED_function_GLOBAL
00213     #define NEED_variable_GLOBAL
00214 
00215 Note that you mustn't have more than one global request for the
00216 same function or variable in your project.
00217 
00218     Function / Variable       Static Request               Global Request
00219     -----------------------------------------------------------------------------------------
00220     PL_parser                 NEED_PL_parser               NEED_PL_parser_GLOBAL
00221     PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL
00222     eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL
00223     grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL
00224     grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL
00225     grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL
00226     grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL
00227     grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL
00228     load_module()             NEED_load_module             NEED_load_module_GLOBAL
00229     my_snprintf()             NEED_my_snprintf             NEED_my_snprintf_GLOBAL
00230     my_sprintf()              NEED_my_sprintf              NEED_my_sprintf_GLOBAL
00231     my_strlcat()              NEED_my_strlcat              NEED_my_strlcat_GLOBAL
00232     my_strlcpy()              NEED_my_strlcpy              NEED_my_strlcpy_GLOBAL
00233     newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
00234     newRV_noinc()             NEED_newRV_noinc             NEED_newRV_noinc_GLOBAL
00235     newSVpvn_flags()          NEED_newSVpvn_flags          NEED_newSVpvn_flags_GLOBAL
00236     newSVpvn_share()          NEED_newSVpvn_share          NEED_newSVpvn_share_GLOBAL
00237     pv_display()              NEED_pv_display              NEED_pv_display_GLOBAL
00238     pv_escape()               NEED_pv_escape               NEED_pv_escape_GLOBAL
00239     pv_pretty()               NEED_pv_pretty               NEED_pv_pretty_GLOBAL
00240     sv_2pv_flags()            NEED_sv_2pv_flags            NEED_sv_2pv_flags_GLOBAL
00241     sv_2pvbyte()              NEED_sv_2pvbyte              NEED_sv_2pvbyte_GLOBAL
00242     sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
00243     sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
00244     sv_pvn_force_flags()      NEED_sv_pvn_force_flags      NEED_sv_pvn_force_flags_GLOBAL
00245     sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
00246     sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL
00247     vload_module()            NEED_vload_module            NEED_vload_module_GLOBAL
00248     vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL
00249     warner()                  NEED_warner                  NEED_warner_GLOBAL
00250 
00251 To avoid namespace conflicts, you can change the namespace of the
00252 explicitly exported functions / variables using the C<DPPP_NAMESPACE>
00253 macro. Just C<#define> the macro before including C<ppport.h>:
00254 
00255     #define DPPP_NAMESPACE MyOwnNamespace_
00256     #include "ppport.h"
00257 
00258 The default namespace is C<DPPP_>.
00259 
00260 =back
00261 
00262 The good thing is that most of the above can be checked by running
00263 F<ppport.h> on your source code. See the next section for
00264 details.
00265 
00266 =head1 EXAMPLES
00267 
00268 To verify whether F<ppport.h> is needed for your module, whether you
00269 should make any changes to your code, and whether any special defines
00270 should be used, F<ppport.h> can be run as a Perl script to check your
00271 source code. Simply say:
00272 
00273     perl ppport.h
00274 
00275 The result will usually be a list of patches suggesting changes
00276 that should at least be acceptable, if not necessarily the most
00277 efficient solution, or a fix for all possible problems.
00278 
00279 If you know that your XS module uses features only available in
00280 newer Perl releases, if you're aware that it uses C++ comments,
00281 and if you want all suggestions as a single patch file, you could
00282 use something like this:
00283 
00284     perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff
00285 
00286 If you only want your code to be scanned without any suggestions
00287 for changes, use:
00288 
00289     perl ppport.h --nochanges
00290 
00291 You can specify a different C<diff> program or options, using
00292 the C<--diff> option:
00293 
00294     perl ppport.h --diff='diff -C 10'
00295 
00296 This would output context diffs with 10 lines of context.
00297 
00298 If you want to create patched copies of your files instead, use:
00299 
00300     perl ppport.h --copy=.new
00301 
00302 To display portability information for the C<newSVpvn> function,
00303 use:
00304 
00305     perl ppport.h --api-info=newSVpvn
00306 
00307 Since the argument to C<--api-info> can be a regular expression,
00308 you can use
00309 
00310     perl ppport.h --api-info=/_nomg$/
00311 
00312 to display portability information for all C<_nomg> functions or
00313 
00314     perl ppport.h --api-info=/./
00315 
00316 to display information for all known API elements.
00317 
00318 =head1 BUGS
00319 
00320 If this version of F<ppport.h> is causing failure during
00321 the compilation of this module, please check if newer versions
00322 of either this module or C<Devel::PPPort> are available on CPAN
00323 before sending a bug report.
00324 
00325 If F<ppport.h> was generated using the latest version of
00326 C<Devel::PPPort> and is causing failure of this module, please
00327 file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>.
00328 
00329 Please include the following information:
00330 
00331 =over 4
00332 
00333 =item 1.
00334 
00335 The complete output from running "perl -V"
00336 
00337 =item 2.
00338 
00339 This file.
00340 
00341 =item 3.
00342 
00343 The name and version of the module you were trying to build.
00344 
00345 =item 4.
00346 
00347 A full log of the build that failed.
00348 
00349 =item 5.
00350 
00351 Any other information that you think could be relevant.
00352 
00353 =back
00354 
00355 For the latest version of this code, please get the C<Devel::PPPort>
00356 module from CPAN.
00357 
00358 =head1 COPYRIGHT
00359 
00360 Version 3.x, Copyright (c) 2004-2009, Marcus Holland-Moritz.
00361 
00362 Version 2.x, Copyright (C) 2001, Paul Marquess.
00363 
00364 Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
00365 
00366 This program is free software; you can redistribute it and/or
00367 modify it under the same terms as Perl itself.
00368 
00369 =head1 SEE ALSO
00370 
00371 See L<Devel::PPPort>.
00372 
00373 =cut
00374 
00375 use strict;
00376 
00377 # Disable broken TRIE-optimization
00378 BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }
00379 
00380 my $VERSION = 3.17;
00381 
00382 my %opt = (
00383   quiet     => 0,
00384   diag      => 1,
00385   hints     => 1,
00386   changes   => 1,
00387   cplusplus => 0,
00388   filter    => 1,
00389   strip     => 0,
00390   version   => 0,
00391 );
00392 
00393 my($ppport) = $0 =~ /([\w.]+)$/;
00394 my $LF = '(?:\r\n|[\r\n])';   # line feed
00395 my $HS = "[ \t]";             # horizontal whitespace
00396 
00397 # Never use C comments in this file!
00398 my $ccs  = '/'.'*';
00399 my $cce  = '*'.'/';
00400 my $rccs = quotemeta $ccs;
00401 my $rcce = quotemeta $cce;
00402 
00403 eval {
00404   require Getopt::Long;
00405   Getopt::Long::GetOptions(\%opt, qw(
00406     help quiet diag! filter! hints! changes! cplusplus strip version
00407     patch=s copy=s diff=s compat-version=s
00408     list-provided list-unsupported api-info=s
00409   )) or usage();
00410 };
00411 
00412 if ($@ and grep /^-/, @ARGV) {
00413   usage() if "@ARGV" =~ /^--?h(?:elp)?$/;
00414   die "Getopt::Long not found. Please don't use any options.\n";
00415 }
00416 
00417 if ($opt{version}) {
00418   print "This is $0 $VERSION.\n";
00419   exit 0;
00420 }
00421 
00422 usage() if $opt{help};
00423 strip() if $opt{strip};
00424 
00425 if (exists $opt{'compat-version'}) {
00426   my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };
00427   if ($@) {
00428     die "Invalid version number format: '$opt{'compat-version'}'\n";
00429   }
00430   die "Only Perl 5 is supported\n" if $r != 5;
00431   die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;
00432   $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;
00433 }
00434 else {
00435   $opt{'compat-version'} = 5;
00436 }
00437 
00438 my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
00439                 ? ( $1 => {
00440                       ($2                  ? ( base     => $2 ) : ()),
00441                       ($3                  ? ( todo     => $3 ) : ()),
00442                       (index($4, 'v') >= 0 ? ( varargs  => 1  ) : ()),
00443                       (index($4, 'p') >= 0 ? ( provided => 1  ) : ()),
00444                       (index($4, 'n') >= 0 ? ( nothxarg => 1  ) : ()),
00445                     } )
00446                 : die "invalid spec: $_" } qw(
00447 AvFILLp|5.004050||p
00448 AvFILL|||
00449 CLASS|||n
00450 CPERLscope|5.005000||p
00451 CX_CURPAD_SAVE|||
00452 CX_CURPAD_SV|||
00453 CopFILEAV|5.006000||p
00454 CopFILEGV_set|5.006000||p
00455 CopFILEGV|5.006000||p
00456 CopFILESV|5.006000||p
00457 CopFILE_set|5.006000||p
00458 CopFILE|5.006000||p
00459 CopSTASHPV_set|5.006000||p
00460 CopSTASHPV|5.006000||p
00461 CopSTASH_eq|5.006000||p
00462 CopSTASH_set|5.006000||p
00463 CopSTASH|5.006000||p
00464 CopyD|5.009002||p
00465 Copy|||
00466 CvPADLIST|||
00467 CvSTASH|||
00468 CvWEAKOUTSIDE|||
00469 DEFSV_set|5.011000||p
00470 DEFSV|5.004050||p
00471 END_EXTERN_C|5.005000||p
00472 ENTER|||
00473 ERRSV|5.004050||p
00474 EXTEND|||
00475 EXTERN_C|5.005000||p
00476 F0convert|||n
00477 FREETMPS|||
00478 GIMME_V||5.004000|n
00479 GIMME|||n
00480 GROK_NUMERIC_RADIX|5.007002||p
00481 G_ARRAY|||
00482 G_DISCARD|||
00483 G_EVAL|||
00484 G_METHOD|5.006001||p
00485 G_NOARGS|||
00486 G_SCALAR|||
00487 G_VOID||5.004000|
00488 GetVars|||
00489 GvSV|||
00490 Gv_AMupdate|||
00491 HEf_SVKEY||5.004000|
00492 HeHASH||5.004000|
00493 HeKEY||5.004000|
00494 HeKLEN||5.004000|
00495 HePV||5.004000|
00496 HeSVKEY_force||5.004000|
00497 HeSVKEY_set||5.004000|
00498 HeSVKEY||5.004000|
00499 HeUTF8||5.011000|
00500 HeVAL||5.004000|
00501 HvNAME|||
00502 INT2PTR|5.006000||p
00503 IN_LOCALE_COMPILETIME|5.007002||p
00504 IN_LOCALE_RUNTIME|5.007002||p
00505 IN_LOCALE|5.007002||p
00506 IN_PERL_COMPILETIME|5.008001||p
00507 IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p
00508 IS_NUMBER_INFINITY|5.007002||p
00509 IS_NUMBER_IN_UV|5.007002||p
00510 IS_NUMBER_NAN|5.007003||p
00511 IS_NUMBER_NEG|5.007002||p
00512 IS_NUMBER_NOT_INT|5.007002||p
00513 IVSIZE|5.006000||p
00514 IVTYPE|5.006000||p
00515 IVdf|5.006000||p
00516 LEAVE|||
00517 LVRET|||
00518 MARK|||
00519 MULTICALL||5.011000|
00520 MY_CXT_CLONE|5.009002||p
00521 MY_CXT_INIT|5.007003||p
00522 MY_CXT|5.007003||p
00523 MoveD|5.009002||p
00524 Move|||
00525 NOOP|5.005000||p
00526 NUM2PTR|5.006000||p
00527 NVTYPE|5.006000||p
00528 NVef|5.006001||p
00529 NVff|5.006001||p
00530 NVgf|5.006001||p
00531 Newxc|5.009003||p
00532 Newxz|5.009003||p
00533 Newx|5.009003||p
00534 Nullav|||
00535 Nullch|||
00536 Nullcv|||
00537 Nullhv|||
00538 Nullsv|||
00539 ORIGMARK|||
00540 PAD_BASE_SV|||
00541 PAD_CLONE_VARS|||
00542 PAD_COMPNAME_FLAGS|||
00543 PAD_COMPNAME_GEN_set|||
00544 PAD_COMPNAME_GEN|||
00545 PAD_COMPNAME_OURSTASH|||
00546 PAD_COMPNAME_PV|||
00547 PAD_COMPNAME_TYPE|||
00548 PAD_DUP|||
00549 PAD_RESTORE_LOCAL|||
00550 PAD_SAVE_LOCAL|||
00551 PAD_SAVE_SETNULLPAD|||
00552 PAD_SETSV|||
00553 PAD_SET_CUR_NOSAVE|||
00554 PAD_SET_CUR|||
00555 PAD_SVl|||
00556 PAD_SV|||
00557 PERLIO_FUNCS_CAST|5.009003||p
00558 PERLIO_FUNCS_DECL|5.009003||p
00559 PERL_ABS|5.008001||p
00560 PERL_BCDVERSION|5.011000||p
00561 PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p
00562 PERL_HASH|5.004000||p
00563 PERL_INT_MAX|5.004000||p
00564 PERL_INT_MIN|5.004000||p
00565 PERL_LONG_MAX|5.004000||p
00566 PERL_LONG_MIN|5.004000||p
00567 PERL_MAGIC_arylen|5.007002||p
00568 PERL_MAGIC_backref|5.007002||p
00569 PERL_MAGIC_bm|5.007002||p
00570 PERL_MAGIC_collxfrm|5.007002||p
00571 PERL_MAGIC_dbfile|5.007002||p
00572 PERL_MAGIC_dbline|5.007002||p
00573 PERL_MAGIC_defelem|5.007002||p
00574 PERL_MAGIC_envelem|5.007002||p
00575 PERL_MAGIC_env|5.007002||p
00576 PERL_MAGIC_ext|5.007002||p
00577 PERL_MAGIC_fm|5.007002||p
00578 PERL_MAGIC_glob|5.011000||p
00579 PERL_MAGIC_isaelem|5.007002||p
00580 PERL_MAGIC_isa|5.007002||p
00581 PERL_MAGIC_mutex|5.011000||p
00582 PERL_MAGIC_nkeys|5.007002||p
00583 PERL_MAGIC_overload_elem|5.007002||p
00584 PERL_MAGIC_overload_table|5.007002||p
00585 PERL_MAGIC_overload|5.007002||p
00586 PERL_MAGIC_pos|5.007002||p
00587 PERL_MAGIC_qr|5.007002||p
00588 PERL_MAGIC_regdata|5.007002||p
00589 PERL_MAGIC_regdatum|5.007002||p
00590 PERL_MAGIC_regex_global|5.007002||p
00591 PERL_MAGIC_shared_scalar|5.007003||p
00592 PERL_MAGIC_shared|5.007003||p
00593 PERL_MAGIC_sigelem|5.007002||p
00594 PERL_MAGIC_sig|5.007002||p
00595 PERL_MAGIC_substr|5.007002||p
00596 PERL_MAGIC_sv|5.007002||p
00597 PERL_MAGIC_taint|5.007002||p
00598 PERL_MAGIC_tiedelem|5.007002||p
00599 PERL_MAGIC_tiedscalar|5.007002||p
00600 PERL_MAGIC_tied|5.007002||p
00601 PERL_MAGIC_utf8|5.008001||p
00602 PERL_MAGIC_uvar_elem|5.007003||p
00603 PERL_MAGIC_uvar|5.007002||p
00604 PERL_MAGIC_vec|5.007002||p
00605 PERL_MAGIC_vstring|5.008001||p
00606 PERL_PV_ESCAPE_ALL|5.009004||p
00607 PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p
00608 PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p
00609 PERL_PV_ESCAPE_NOCLEAR|5.009004||p
00610 PERL_PV_ESCAPE_QUOTE|5.009004||p
00611 PERL_PV_ESCAPE_RE|5.009005||p
00612 PERL_PV_ESCAPE_UNI_DETECT|5.009004||p
00613 PERL_PV_ESCAPE_UNI|5.009004||p
00614 PERL_PV_PRETTY_DUMP|5.009004||p
00615 PERL_PV_PRETTY_ELLIPSES|5.010000||p
00616 PERL_PV_PRETTY_LTGT|5.009004||p
00617 PERL_PV_PRETTY_NOCLEAR|5.010000||p
00618 PERL_PV_PRETTY_QUOTE|5.009004||p
00619 PERL_PV_PRETTY_REGPROP|5.009004||p
00620 PERL_QUAD_MAX|5.004000||p
00621 PERL_QUAD_MIN|5.004000||p
00622 PERL_REVISION|5.006000||p
00623 PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p
00624 PERL_SCAN_DISALLOW_PREFIX|5.007003||p
00625 PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p
00626 PERL_SCAN_SILENT_ILLDIGIT|5.008001||p
00627 PERL_SHORT_MAX|5.004000||p
00628 PERL_SHORT_MIN|5.004000||p
00629 PERL_SIGNALS_UNSAFE_FLAG|5.008001||p
00630 PERL_SUBVERSION|5.006000||p
00631 PERL_UCHAR_MAX|5.004000||p
00632 PERL_UCHAR_MIN|5.004000||p
00633 PERL_UINT_MAX|5.004000||p
00634 PERL_UINT_MIN|5.004000||p
00635 PERL_ULONG_MAX|5.004000||p
00636 PERL_ULONG_MIN|5.004000||p
00637 PERL_UNUSED_ARG|5.009003||p
00638 PERL_UNUSED_CONTEXT|5.009004||p
00639 PERL_UNUSED_DECL|5.007002||p
00640 PERL_UNUSED_VAR|5.007002||p
00641 PERL_UQUAD_MAX|5.004000||p
00642 PERL_UQUAD_MIN|5.004000||p
00643 PERL_USE_GCC_BRACE_GROUPS|5.009004||p
00644 PERL_USHORT_MAX|5.004000||p
00645 PERL_USHORT_MIN|5.004000||p
00646 PERL_VERSION|5.006000||p
00647 PL_DBsignal|5.005000||p
00648 PL_DBsingle|||pn
00649 PL_DBsub|||pn
00650 PL_DBtrace|||pn
00651 PL_Sv|5.005000||p
00652 PL_bufend|5.011000||p
00653 PL_bufptr|5.011000||p
00654 PL_compiling|5.004050||p
00655 PL_copline|5.011000||p
00656 PL_curcop|5.004050||p
00657 PL_curstash|5.004050||p
00658 PL_debstash|5.004050||p
00659 PL_defgv|5.004050||p
00660 PL_diehook|5.004050||p
00661 PL_dirty|5.004050||p
00662 PL_dowarn|||pn
00663 PL_errgv|5.004050||p
00664 PL_expect|5.011000||p
00665 PL_hexdigit|5.005000||p
00666 PL_hints|5.005000||p
00667 PL_last_in_gv|||n
00668 PL_laststatval|5.005000||p
00669 PL_lex_state|5.011000||p
00670 PL_lex_stuff|5.011000||p
00671 PL_linestr|5.011000||p
00672 PL_modglobal||5.005000|n
00673 PL_na|5.004050||pn
00674 PL_no_modify|5.006000||p
00675 PL_ofsgv|||n
00676 PL_parser|5.009005||p
00677 PL_perl_destruct_level|5.004050||p
00678 PL_perldb|5.004050||p
00679 PL_ppaddr|5.006000||p
00680 PL_rsfp_filters|5.004050||p
00681 PL_rsfp|5.004050||p
00682 PL_rs|||n
00683 PL_signals|5.008001||p
00684 PL_stack_base|5.004050||p
00685 PL_stack_sp|5.004050||p
00686 PL_statcache|5.005000||p
00687 PL_stdingv|5.004050||p
00688 PL_sv_arenaroot|5.004050||p
00689 PL_sv_no|5.004050||pn
00690 PL_sv_undef|5.004050||pn
00691 PL_sv_yes|5.004050||pn
00692 PL_tainted|5.004050||p
00693 PL_tainting|5.004050||p
00694 PL_tokenbuf|5.011000||p
00695 POP_MULTICALL||5.011000|
00696 POPi|||n
00697 POPl|||n
00698 POPn|||n
00699 POPpbytex||5.007001|n
00700 POPpx||5.005030|n
00701 POPp|||n
00702 POPs|||n
00703 PTR2IV|5.006000||p
00704 PTR2NV|5.006000||p
00705 PTR2UV|5.006000||p
00706 PTR2nat|5.009003||p
00707 PTR2ul|5.007001||p
00708 PTRV|5.006000||p
00709 PUSHMARK|||
00710 PUSH_MULTICALL||5.011000|
00711 PUSHi|||
00712 PUSHmortal|5.009002||p
00713 PUSHn|||
00714 PUSHp|||
00715 PUSHs|||
00716 PUSHu|5.004000||p
00717 PUTBACK|||
00718 PerlIO_clearerr||5.007003|
00719 PerlIO_close||5.007003|
00720 PerlIO_context_layers||5.009004|
00721 PerlIO_eof||5.007003|
00722 PerlIO_error||5.007003|
00723 PerlIO_fileno||5.007003|
00724 PerlIO_fill||5.007003|
00725 PerlIO_flush||5.007003|
00726 PerlIO_get_base||5.007003|
00727 PerlIO_get_bufsiz||5.007003|
00728 PerlIO_get_cnt||5.007003|
00729 PerlIO_get_ptr||5.007003|
00730 PerlIO_read||5.007003|
00731 PerlIO_seek||5.007003|
00732 PerlIO_set_cnt||5.007003|
00733 PerlIO_set_ptrcnt||5.007003|
00734 PerlIO_setlinebuf||5.007003|
00735 PerlIO_stderr||5.007003|
00736 PerlIO_stdin||5.007003|
00737 PerlIO_stdout||5.007003|
00738 PerlIO_tell||5.007003|
00739 PerlIO_unread||5.007003|
00740 PerlIO_write||5.007003|
00741 Perl_signbit||5.009005|n
00742 PoisonFree|5.009004||p
00743 PoisonNew|5.009004||p
00744 PoisonWith|5.009004||p
00745 Poison|5.008000||p
00746 RETVAL|||n
00747 Renewc|||
00748 Renew|||
00749 SAVECLEARSV|||
00750 SAVECOMPPAD|||
00751 SAVEPADSV|||
00752 SAVETMPS|||
00753 SAVE_DEFSV|5.004050||p
00754 SPAGAIN|||
00755 SP|||
00756 START_EXTERN_C|5.005000||p
00757 START_MY_CXT|5.007003||p
00758 STMT_END|||p
00759 STMT_START|||p
00760 STR_WITH_LEN|5.009003||p
00761 ST|||
00762 SV_CONST_RETURN|5.009003||p
00763 SV_COW_DROP_PV|5.008001||p
00764 SV_COW_SHARED_HASH_KEYS|5.009005||p
00765 SV_GMAGIC|5.007002||p
00766 SV_HAS_TRAILING_NUL|5.009004||p
00767 SV_IMMEDIATE_UNREF|5.007001||p
00768 SV_MUTABLE_RETURN|5.009003||p
00769 SV_NOSTEAL|5.009002||p
00770 SV_SMAGIC|5.009003||p
00771 SV_UTF8_NO_ENCODING|5.008001||p
00772 SVf_UTF8|5.006000||p
00773 SVf|5.006000||p
00774 SVt_IV|||
00775 SVt_NV|||
00776 SVt_PVAV|||
00777 SVt_PVCV|||
00778 SVt_PVHV|||
00779 SVt_PVMG|||
00780 SVt_PV|||
00781 Safefree|||
00782 Slab_Alloc|||
00783 Slab_Free|||
00784 Slab_to_rw|||
00785 StructCopy|||
00786 SvCUR_set|||
00787 SvCUR|||
00788 SvEND|||
00789 SvGAMAGIC||5.006001|
00790 SvGETMAGIC|5.004050||p
00791 SvGROW|||
00792 SvIOK_UV||5.006000|
00793 SvIOK_notUV||5.006000|
00794 SvIOK_off|||
00795 SvIOK_only_UV||5.006000|
00796 SvIOK_only|||
00797 SvIOK_on|||
00798 SvIOKp|||
00799 SvIOK|||
00800 SvIVX|||
00801 SvIV_nomg|5.009001||p
00802 SvIV_set|||
00803 SvIVx|||
00804 SvIV|||
00805 SvIsCOW_shared_hash||5.008003|
00806 SvIsCOW||5.008003|
00807 SvLEN_set|||
00808 SvLEN|||
00809 SvLOCK||5.007003|
00810 SvMAGIC_set|5.009003||p
00811 SvNIOK_off|||
00812 SvNIOKp|||
00813 SvNIOK|||
00814 SvNOK_off|||
00815 SvNOK_only|||
00816 SvNOK_on|||
00817 SvNOKp|||
00818 SvNOK|||
00819 SvNVX|||
00820 SvNV_set|||
00821 SvNVx|||
00822 SvNV|||
00823 SvOK|||
00824 SvOOK_offset||5.011000|
00825 SvOOK|||
00826 SvPOK_off|||
00827 SvPOK_only_UTF8||5.006000|
00828 SvPOK_only|||
00829 SvPOK_on|||
00830 SvPOKp|||
00831 SvPOK|||
00832 SvPVX_const|5.009003||p
00833 SvPVX_mutable|5.009003||p
00834 SvPVX|||
00835 SvPV_const|5.009003||p
00836 SvPV_flags_const_nolen|5.009003||p
00837 SvPV_flags_const|5.009003||p
00838 SvPV_flags_mutable|5.009003||p
00839 SvPV_flags|5.007002||p
00840 SvPV_force_flags_mutable|5.009003||p
00841 SvPV_force_flags_nolen|5.009003||p
00842 SvPV_force_flags|5.007002||p
00843 SvPV_force_mutable|5.009003||p
00844 SvPV_force_nolen|5.009003||p
00845 SvPV_force_nomg_nolen|5.009003||p
00846 SvPV_force_nomg|5.007002||p
00847 SvPV_force|||p
00848 SvPV_mutable|5.009003||p
00849 SvPV_nolen_const|5.009003||p
00850 SvPV_nolen|5.006000||p
00851 SvPV_nomg_const_nolen|5.009003||p
00852 SvPV_nomg_const|5.009003||p
00853 SvPV_nomg|5.007002||p
00854 SvPV_renew|5.009003||p
00855 SvPV_set|||
00856 SvPVbyte_force||5.009002|
00857 SvPVbyte_nolen||5.006000|
00858 SvPVbytex_force||5.006000|
00859 SvPVbytex||5.006000|
00860 SvPVbyte|5.006000||p
00861 SvPVutf8_force||5.006000|
00862 SvPVutf8_nolen||5.006000|
00863 SvPVutf8x_force||5.006000|
00864 SvPVutf8x||5.006000|
00865 SvPVutf8||5.006000|
00866 SvPVx|||
00867 SvPV|||
00868 SvREFCNT_dec|||
00869 SvREFCNT_inc_NN|5.009004||p
00870 SvREFCNT_inc_simple_NN|5.009004||p
00871 SvREFCNT_inc_simple_void_NN|5.009004||p
00872 SvREFCNT_inc_simple_void|5.009004||p
00873 SvREFCNT_inc_simple|5.009004||p
00874 SvREFCNT_inc_void_NN|5.009004||p
00875 SvREFCNT_inc_void|5.009004||p
00876 SvREFCNT_inc|||p
00877 SvREFCNT|||
00878 SvROK_off|||
00879 SvROK_on|||
00880 SvROK|||
00881 SvRV_set|5.009003||p
00882 SvRV|||
00883 SvRXOK||5.009005|
00884 SvRX||5.009005|
00885 SvSETMAGIC|||
00886 SvSHARED_HASH|5.009003||p
00887 SvSHARE||5.007003|
00888 SvSTASH_set|5.009003||p
00889 SvSTASH|||
00890 SvSetMagicSV_nosteal||5.004000|
00891 SvSetMagicSV||5.004000|
00892 SvSetSV_nosteal||5.004000|
00893 SvSetSV|||
00894 SvTAINTED_off||5.004000|
00895 SvTAINTED_on||5.004000|
00896 SvTAINTED||5.004000|
00897 SvTAINT|||
00898 SvTRUE|||
00899 SvTYPE|||
00900 SvUNLOCK||5.007003|
00901 SvUOK|5.007001|5.006000|p
00902 SvUPGRADE|||
00903 SvUTF8_off||5.006000|
00904 SvUTF8_on||5.006000|
00905 SvUTF8||5.006000|
00906 SvUVXx|5.004000||p
00907 SvUVX|5.004000||p
00908 SvUV_nomg|5.009001||p
00909 SvUV_set|5.009003||p
00910 SvUVx|5.004000||p
00911 SvUV|5.004000||p
00912 SvVOK||5.008001|
00913 SvVSTRING_mg|5.009004||p
00914 THIS|||n
00915 UNDERBAR|5.009002||p
00916 UTF8_MAXBYTES|5.009002||p
00917 UVSIZE|5.006000||p
00918 UVTYPE|5.006000||p
00919 UVXf|5.007001||p
00920 UVof|5.006000||p
00921 UVuf|5.006000||p
00922 UVxf|5.006000||p
00923 WARN_ALL|5.006000||p
00924 WARN_AMBIGUOUS|5.006000||p
00925 WARN_ASSERTIONS|5.011000||p
00926 WARN_BAREWORD|5.006000||p
00927 WARN_CLOSED|5.006000||p
00928 WARN_CLOSURE|5.006000||p
00929 WARN_DEBUGGING|5.006000||p
00930 WARN_DEPRECATED|5.006000||p
00931 WARN_DIGIT|5.006000||p
00932 WARN_EXEC|5.006000||p
00933 WARN_EXITING|5.006000||p
00934 WARN_GLOB|5.006000||p
00935 WARN_INPLACE|5.006000||p
00936 WARN_INTERNAL|5.006000||p
00937 WARN_IO|5.006000||p
00938 WARN_LAYER|5.008000||p
00939 WARN_MALLOC|5.006000||p
00940 WARN_MISC|5.006000||p
00941 WARN_NEWLINE|5.006000||p
00942 WARN_NUMERIC|5.006000||p
00943 WARN_ONCE|5.006000||p
00944 WARN_OVERFLOW|5.006000||p
00945 WARN_PACK|5.006000||p
00946 WARN_PARENTHESIS|5.006000||p
00947 WARN_PIPE|5.006000||p
00948 WARN_PORTABLE|5.006000||p
00949 WARN_PRECEDENCE|5.006000||p
00950 WARN_PRINTF|5.006000||p
00951 WARN_PROTOTYPE|5.006000||p
00952 WARN_QW|5.006000||p
00953 WARN_RECURSION|5.006000||p
00954 WARN_REDEFINE|5.006000||p
00955 WARN_REGEXP|5.006000||p
00956 WARN_RESERVED|5.006000||p
00957 WARN_SEMICOLON|5.006000||p
00958 WARN_SEVERE|5.006000||p
00959 WARN_SIGNAL|5.006000||p
00960 WARN_SUBSTR|5.006000||p
00961 WARN_SYNTAX|5.006000||p
00962 WARN_TAINT|5.006000||p
00963 WARN_THREADS|5.008000||p
00964 WARN_UNINITIALIZED|5.006000||p
00965 WARN_UNOPENED|5.006000||p
00966 WARN_UNPACK|5.006000||p
00967 WARN_UNTIE|5.006000||p
00968 WARN_UTF8|5.006000||p
00969 WARN_VOID|5.006000||p
00970 XCPT_CATCH|5.009002||p
00971 XCPT_RETHROW|5.009002||p
00972 XCPT_TRY_END|5.009002||p
00973 XCPT_TRY_START|5.009002||p
00974 XPUSHi|||
00975 XPUSHmortal|5.009002||p
00976 XPUSHn|||
00977 XPUSHp|||
00978 XPUSHs|||
00979 XPUSHu|5.004000||p
00980 XSRETURN_EMPTY|||
00981 XSRETURN_IV|||
00982 XSRETURN_NO|||
00983 XSRETURN_NV|||
00984 XSRETURN_PV|||
00985 XSRETURN_UNDEF|||
00986 XSRETURN_UV|5.008001||p
00987 XSRETURN_YES|||
00988 XSRETURN|||p
00989 XST_mIV|||
00990 XST_mNO|||
00991 XST_mNV|||
00992 XST_mPV|||
00993 XST_mUNDEF|||
00994 XST_mUV|5.008001||p
00995 XST_mYES|||
00996 XS_VERSION_BOOTCHECK|||
00997 XS_VERSION|||
00998 XSprePUSH|5.006000||p
00999 XS|||
01000 ZeroD|5.009002||p
01001 Zero|||
01002 _aMY_CXT|5.007003||p
01003 _pMY_CXT|5.007003||p
01004 aMY_CXT_|5.007003||p
01005 aMY_CXT|5.007003||p
01006 aTHXR_|5.011000||p
01007 aTHXR|5.011000||p
01008 aTHX_|5.006000||p
01009 aTHX|5.006000||p
01010 add_data|||n
01011 addmad|||
01012 allocmy|||
01013 amagic_call|||
01014 amagic_cmp_locale|||
01015 amagic_cmp|||
01016 amagic_i_ncmp|||
01017 amagic_ncmp|||
01018 any_dup|||
01019 ao|||
01020 append_elem|||
01021 append_list|||
01022 append_madprops|||
01023 apply_attrs_my|||
01024 apply_attrs_string||5.006001|
01025 apply_attrs|||
01026 apply|||
01027 atfork_lock||5.007003|n
01028 atfork_unlock||5.007003|n
01029 av_arylen_p||5.009003|
01030 av_clear|||
01031 av_create_and_push||5.009005|
01032 av_create_and_unshift_one||5.009005|
01033 av_delete||5.006000|
01034 av_exists||5.006000|
01035 av_extend|||
01036 av_fetch|||
01037 av_fill|||
01038 av_iter_p||5.011000|
01039 av_len|||
01040 av_make|||
01041 av_pop|||
01042 av_push|||
01043 av_reify|||
01044 av_shift|||
01045 av_store|||
01046 av_undef|||
01047 av_unshift|||
01048 ax|||n
01049 bad_type|||
01050 bind_match|||
01051 block_end|||
01052 block_gimme||5.004000|
01053 block_start|||
01054 boolSV|5.004000||p
01055 boot_core_PerlIO|||
01056 boot_core_UNIVERSAL|||
01057 boot_core_mro|||
01058 boot_core_xsutils|||
01059 bytes_from_utf8||5.007001|
01060 bytes_to_uni|||n
01061 bytes_to_utf8||5.006001|
01062 call_argv|5.006000||p
01063 call_atexit||5.006000|
01064 call_list||5.004000|
01065 call_method|5.006000||p
01066 call_pv|5.006000||p
01067 call_sv|5.006000||p
01068 calloc||5.007002|n
01069 cando|||
01070 cast_i32||5.006000|
01071 cast_iv||5.006000|
01072 cast_ulong||5.006000|
01073 cast_uv||5.006000|
01074 check_type_and_open|||
01075 check_uni|||
01076 checkcomma|||
01077 checkposixcc|||
01078 ckWARN|5.006000||p
01079 ck_anoncode|||
01080 ck_bitop|||
01081 ck_concat|||
01082 ck_defined|||
01083 ck_delete|||
01084 ck_die|||
01085 ck_each|||
01086 ck_eof|||
01087 ck_eval|||
01088 ck_exec|||
01089 ck_exists|||
01090 ck_exit|||
01091 ck_ftst|||
01092 ck_fun|||
01093 ck_glob|||
01094 ck_grep|||
01095 ck_index|||
01096 ck_join|||
01097 ck_lfun|||
01098 ck_listiob|||
01099 ck_match|||
01100 ck_method|||
01101 ck_null|||
01102 ck_open|||
01103 ck_readline|||
01104 ck_repeat|||
01105 ck_require|||
01106 ck_return|||
01107 ck_rfun|||
01108 ck_rvconst|||
01109 ck_sassign|||
01110 ck_select|||
01111 ck_shift|||
01112 ck_sort|||
01113 ck_spair|||
01114 ck_split|||
01115 ck_subr|||
01116 ck_substr|||
01117 ck_svconst|||
01118 ck_trunc|||
01119 ck_unpack|||
01120 ckwarn_d||5.009003|
01121 ckwarn||5.009003|
01122 cl_and|||n
01123 cl_anything|||n
01124 cl_init_zero|||n
01125 cl_init|||n
01126 cl_is_anything|||n
01127 cl_or|||n
01128 clear_placeholders|||
01129 closest_cop|||
01130 convert|||
01131 cop_free|||
01132 cr_textfilter|||
01133 create_eval_scope|||
01134 croak_nocontext|||vn
01135 croak_xs_usage||5.011000|
01136 croak|||v
01137 csighandler||5.009003|n
01138 curmad|||
01139 custom_op_desc||5.007003|
01140 custom_op_name||5.007003|
01141 cv_ckproto_len|||
01142 cv_clone|||
01143 cv_const_sv||5.004000|
01144 cv_dump|||
01145 cv_undef|||
01146 cx_dump||5.005000|
01147 cx_dup|||
01148 cxinc|||
01149 dAXMARK|5.009003||p
01150 dAX|5.007002||p
01151 dITEMS|5.007002||p
01152 dMARK|||
01153 dMULTICALL||5.009003|
01154 dMY_CXT_SV|5.007003||p
01155 dMY_CXT|5.007003||p
01156 dNOOP|5.006000||p
01157 dORIGMARK|||
01158 dSP|||
01159 dTHR|5.004050||p
01160 dTHXR|5.011000||p
01161 dTHXa|5.006000||p
01162 dTHXoa|5.006000||p
01163 dTHX|5.006000||p
01164 dUNDERBAR|5.009002||p
01165 dVAR|5.009003||p
01166 dXCPT|5.009002||p
01167 dXSARGS|||
01168 dXSI32|||
01169 dXSTARG|5.006000||p
01170 deb_curcv|||
01171 deb_nocontext|||vn
01172 deb_stack_all|||
01173 deb_stack_n|||
01174 debop||5.005000|
01175 debprofdump||5.005000|
01176 debprof|||
01177 debstackptrs||5.007003|
01178 debstack||5.007003|
01179 debug_start_match|||
01180 deb||5.007003|v
01181 del_sv|||
01182 delete_eval_scope|||
01183 delimcpy||5.004000|
01184 deprecate_old|||
01185 deprecate|||
01186 despatch_signals||5.007001|
01187 destroy_matcher|||
01188 die_nocontext|||vn
01189 die_where|||
01190 die|||v
01191 dirp_dup|||
01192 div128|||
01193 djSP|||
01194 do_aexec5|||
01195 do_aexec|||
01196 do_aspawn|||
01197 do_binmode||5.004050|
01198 do_chomp|||
01199 do_chop|||
01200 do_close|||
01201 do_dump_pad|||
01202 do_eof|||
01203 do_exec3|||
01204 do_execfree|||
01205 do_exec|||
01206 do_gv_dump||5.006000|
01207 do_gvgv_dump||5.006000|
01208 do_hv_dump||5.006000|
01209 do_ipcctl|||
01210 do_ipcget|||
01211 do_join|||
01212 do_kv|||
01213 do_magic_dump||5.006000|
01214 do_msgrcv|||
01215 do_msgsnd|||
01216 do_oddball|||
01217 do_op_dump||5.006000|
01218 do_op_xmldump|||
01219 do_open9||5.006000|
01220 do_openn||5.007001|
01221 do_open||5.004000|
01222 do_pmop_dump||5.006000|
01223 do_pmop_xmldump|||
01224 do_print|||
01225 do_readline|||
01226 do_seek|||
01227 do_semop|||
01228 do_shmio|||
01229 do_smartmatch|||
01230 do_spawn_nowait|||
01231 do_spawn|||
01232 do_sprintf|||
01233 do_sv_dump||5.006000|
01234 do_sysseek|||
01235 do_tell|||
01236 do_trans_complex_utf8|||
01237 do_trans_complex|||
01238 do_trans_count_utf8|||
01239 do_trans_count|||
01240 do_trans_simple_utf8|||
01241 do_trans_simple|||
01242 do_trans|||
01243 do_vecget|||
01244 do_vecset|||
01245 do_vop|||
01246 docatch|||
01247 doeval|||
01248 dofile|||
01249 dofindlabel|||
01250 doform|||
01251 doing_taint||5.008001|n
01252 dooneliner|||
01253 doopen_pm|||
01254 doparseform|||
01255 dopoptoeval|||
01256 dopoptogiven|||
01257 dopoptolabel|||
01258 dopoptoloop|||
01259 dopoptosub_at|||
01260 dopoptowhen|||
01261 doref||5.009003|
01262 dounwind|||
01263 dowantarray|||
01264 dump_all||5.006000|
01265 dump_eval||5.006000|
01266 dump_exec_pos|||
01267 dump_fds|||
01268 dump_form||5.006000|
01269 dump_indent||5.006000|v
01270 dump_mstats|||
01271 dump_packsubs||5.006000|
01272 dump_sub||5.006000|
01273 dump_sv_child|||
01274 dump_trie_interim_list|||
01275 dump_trie_interim_table|||
01276 dump_trie|||
01277 dump_vindent||5.006000|
01278 dumpuntil|||
01279 dup_attrlist|||
01280 emulate_cop_io|||
01281 eval_pv|5.006000||p
01282 eval_sv|5.006000||p
01283 exec_failed|||
01284 expect_number|||
01285 fbm_compile||5.005000|
01286 fbm_instr||5.005000|
01287 feature_is_enabled|||
01288 fetch_cop_label||5.011000|
01289 filter_add|||
01290 filter_del|||
01291 filter_gets|||
01292 filter_read|||
01293 find_and_forget_pmops|||
01294 find_array_subscript|||
01295 find_beginning|||
01296 find_byclass|||
01297 find_hash_subscript|||
01298 find_in_my_stash|||
01299 find_runcv||5.008001|
01300 find_rundefsvoffset||5.009002|
01301 find_script|||
01302 find_uninit_var|||
01303 first_symbol|||n
01304 fold_constants|||
01305 forbid_setid|||
01306 force_ident|||
01307 force_list|||
01308 force_next|||
01309 force_version|||
01310 force_word|||
01311 forget_pmop|||
01312 form_nocontext|||vn
01313 form||5.004000|v
01314 fp_dup|||
01315 fprintf_nocontext|||vn
01316 free_global_struct|||
01317 free_tied_hv_pool|||
01318 free_tmps|||
01319 gen_constant_list|||
01320 get_arena|||
01321 get_aux_mg|||
01322 get_av|5.006000||p
01323 get_context||5.006000|n
01324 get_cvn_flags||5.009005|
01325 get_cv|5.006000||p
01326 get_db_sub|||
01327 get_debug_opts|||
01328 get_hash_seed|||
01329 get_hv|5.006000||p
01330 get_isa_hash|||
01331 get_mstats|||
01332 get_no_modify|||
01333 get_num|||
01334 get_op_descs||5.005000|
01335 get_op_names||5.005000|
01336 get_opargs|||
01337 get_ppaddr||5.006000|
01338 get_re_arg|||
01339 get_sv|5.006000||p
01340 get_vtbl||5.005030|
01341 getcwd_sv||5.007002|
01342 getenv_len|||
01343 glob_2number|||
01344 glob_2pv|||
01345 glob_assign_glob|||
01346 glob_assign_ref|||
01347 gp_dup|||
01348 gp_free|||
01349 gp_ref|||
01350 grok_bin|5.007003||p
01351 grok_hex|5.007003||p
01352 grok_number|5.007002||p
01353 grok_numeric_radix|5.007002||p
01354 grok_oct|5.007003||p
01355 group_end|||
01356 gv_AVadd|||
01357 gv_HVadd|||
01358 gv_IOadd|||
01359 gv_SVadd|||
01360 gv_autoload4||5.004000|
01361 gv_check|||
01362 gv_const_sv||5.009003|
01363 gv_dump||5.006000|
01364 gv_efullname3||5.004000|
01365 gv_efullname4||5.006001|
01366 gv_efullname|||
01367 gv_ename|||
01368 gv_fetchfile_flags||5.009005|
01369 gv_fetchfile|||
01370 gv_fetchmeth_autoload||5.007003|
01371 gv_fetchmethod_autoload||5.004000|
01372 gv_fetchmethod_flags||5.011000|
01373 gv_fetchmethod|||
01374 gv_fetchmeth|||
01375 gv_fetchpvn_flags||5.009002|
01376 gv_fetchpv|||
01377 gv_fetchsv||5.009002|
01378 gv_fullname3||5.004000|
01379 gv_fullname4||5.006001|
01380 gv_fullname|||
01381 gv_get_super_pkg|||
01382 gv_handler||5.007001|
01383 gv_init_sv|||
01384 gv_init|||
01385 gv_name_set||5.009004|
01386 gv_stashpvn|5.004000||p
01387 gv_stashpvs||5.009003|
01388 gv_stashpv|||
01389 gv_stashsv|||
01390 he_dup|||
01391 hek_dup|||
01392 hfreeentries|||
01393 hsplit|||
01394 hv_assert||5.011000|
01395 hv_auxinit|||n
01396 hv_backreferences_p|||
01397 hv_clear_placeholders||5.009001|
01398 hv_clear|||
01399 hv_common_key_len||5.010000|
01400 hv_common||5.010000|
01401 hv_copy_hints_hv|||
01402 hv_delayfree_ent||5.004000|
01403 hv_delete_common|||
01404 hv_delete_ent||5.004000|
01405 hv_delete|||
01406 hv_eiter_p||5.009003|
01407 hv_eiter_set||5.009003|
01408 hv_exists_ent||5.004000|
01409 hv_exists|||
01410 hv_fetch_ent||5.004000|
01411 hv_fetchs|5.009003||p
01412 hv_fetch|||
01413 hv_free_ent||5.004000|
01414 hv_iterinit|||
01415 hv_iterkeysv||5.004000|
01416 hv_iterkey|||
01417 hv_iternext_flags||5.008000|
01418 hv_iternextsv|||
01419 hv_iternext|||
01420 hv_iterval|||
01421 hv_kill_backrefs|||
01422 hv_ksplit||5.004000|
01423 hv_magic_check|||n
01424 hv_magic|||
01425 hv_name_set||5.009003|
01426 hv_notallowed|||
01427 hv_placeholders_get||5.009003|
01428 hv_placeholders_p||5.009003|
01429 hv_placeholders_set||5.009003|
01430 hv_riter_p||5.009003|
01431 hv_riter_set||5.009003|
01432 hv_scalar||5.009001|
01433 hv_store_ent||5.004000|
01434 hv_store_flags||5.008000|
01435 hv_stores|5.009004||p
01436 hv_store|||
01437 hv_undef|||
01438 ibcmp_locale||5.004000|
01439 ibcmp_utf8||5.007003|
01440 ibcmp|||
01441 incline|||
01442 incpush_if_exists|||
01443 incpush_use_sep|||
01444 incpush|||
01445 ingroup|||
01446 init_argv_symbols|||
01447 init_debugger|||
01448 init_global_struct|||
01449 init_i18nl10n||5.006000|
01450 init_i18nl14n||5.006000|
01451 init_ids|||
01452 init_interp|||
01453 init_main_stash|||
01454 init_perllib|||
01455 init_postdump_symbols|||
01456 init_predump_symbols|||
01457 init_stacks||5.005000|
01458 init_tm||5.007002|
01459 instr|||
01460 intro_my|||
01461 intuit_method|||
01462 intuit_more|||
01463 invert|||
01464 io_close|||
01465 isALNUMC|5.006000||p
01466 isALNUM|||
01467 isALPHA|||
01468 isASCII|5.006000||p
01469 isBLANK|5.006001||p
01470 isCNTRL|5.006000||p
01471 isDIGIT|||
01472 isGRAPH|5.006000||p
01473 isLOWER|||
01474 isPRINT|5.004000||p
01475 isPSXSPC|5.006001||p
01476 isPUNCT|5.006000||p
01477 isSPACE|||
01478 isUPPER|||
01479 isXDIGIT|5.006000||p
01480 is_an_int|||
01481 is_gv_magical_sv|||
01482 is_handle_constructor|||n
01483 is_list_assignment|||
01484 is_lvalue_sub||5.007001|
01485 is_uni_alnum_lc||5.006000|
01486 is_uni_alnumc_lc||5.006000|
01487 is_uni_alnumc||5.006000|
01488 is_uni_alnum||5.006000|
01489 is_uni_alpha_lc||5.006000|
01490 is_uni_alpha||5.006000|
01491 is_uni_ascii_lc||5.006000|
01492 is_uni_ascii||5.006000|
01493 is_uni_cntrl_lc||5.006000|
01494 is_uni_cntrl||5.006000|
01495 is_uni_digit_lc||5.006000|
01496 is_uni_digit||5.006000|
01497 is_uni_graph_lc||5.006000|
01498 is_uni_graph||5.006000|
01499 is_uni_idfirst_lc||5.006000|
01500 is_uni_idfirst||5.006000|
01501 is_uni_lower_lc||5.006000|
01502 is_uni_lower||5.006000|
01503 is_uni_print_lc||5.006000|
01504 is_uni_print||5.006000|
01505 is_uni_punct_lc||5.006000|
01506 is_uni_punct||5.006000|
01507 is_uni_space_lc||5.006000|
01508 is_uni_space||5.006000|
01509 is_uni_upper_lc||5.006000|
01510 is_uni_upper||5.006000|
01511 is_uni_xdigit_lc||5.006000|
01512 is_uni_xdigit||5.006000|
01513 is_utf8_alnumc||5.006000|
01514 is_utf8_alnum||5.006000|
01515 is_utf8_alpha||5.006000|
01516 is_utf8_ascii||5.006000|
01517 is_utf8_char_slow|||n
01518 is_utf8_char||5.006000|
01519 is_utf8_cntrl||5.006000|
01520 is_utf8_common|||
01521 is_utf8_digit||5.006000|
01522 is_utf8_graph||5.006000|
01523 is_utf8_idcont||5.008000|
01524 is_utf8_idfirst||5.006000|
01525 is_utf8_lower||5.006000|
01526 is_utf8_mark||5.006000|
01527 is_utf8_print||5.006000|
01528 is_utf8_punct||5.006000|
01529 is_utf8_space||5.006000|
01530 is_utf8_string_loclen||5.009003|
01531 is_utf8_string_loc||5.008001|
01532 is_utf8_string||5.006001|
01533 is_utf8_upper||5.006000|
01534 is_utf8_xdigit||5.006000|
01535 isa_lookup|||
01536 items|||n
01537 ix|||n
01538 jmaybe|||
01539 join_exact|||
01540 keyword|||
01541 leave_scope|||
01542 lex_end|||
01543 lex_start|||
01544 linklist|||
01545 listkids|||
01546 list|||
01547 load_module_nocontext|||vn
01548 load_module|5.006000||pv
01549 localize|||
01550 looks_like_bool|||
01551 looks_like_number|||
01552 lop|||
01553 mPUSHi|5.009002||p
01554 mPUSHn|5.009002||p
01555 mPUSHp|5.009002||p
01556 mPUSHs|5.011000||p
01557 mPUSHu|5.009002||p
01558 mXPUSHi|5.009002||p
01559 mXPUSHn|5.009002||p
01560 mXPUSHp|5.009002||p
01561 mXPUSHs|5.011000||p
01562 mXPUSHu|5.009002||p
01563 mad_free|||
01564 madlex|||
01565 madparse|||
01566 magic_clear_all_env|||
01567 magic_clearenv|||
01568 magic_clearhint|||
01569 magic_clearisa|||
01570 magic_clearpack|||
01571 magic_clearsig|||
01572 magic_dump||5.006000|
01573 magic_existspack|||
01574 magic_freearylen_p|||
01575 magic_freeovrld|||
01576 magic_getarylen|||
01577 magic_getdefelem|||
01578 magic_getnkeys|||
01579 magic_getpack|||
01580 magic_getpos|||
01581 magic_getsig|||
01582 magic_getsubstr|||
01583 magic_gettaint|||
01584 magic_getuvar|||
01585 magic_getvec|||
01586 magic_get|||
01587 magic_killbackrefs|||
01588 magic_len|||
01589 magic_methcall|||
01590 magic_methpack|||
01591 magic_nextpack|||
01592 magic_regdata_cnt|||
01593 magic_regdatum_get|||
01594 magic_regdatum_set|||
01595 magic_scalarpack|||
01596 magic_set_all_env|||
01597 magic_setamagic|||
01598 magic_setarylen|||
01599 magic_setcollxfrm|||
01600 magic_setdbline|||
01601 magic_setdefelem|||
01602 magic_setenv|||
01603 magic_sethint|||
01604 magic_setisa|||
01605 magic_setmglob|||
01606 magic_setnkeys|||
01607 magic_setpack|||
01608 magic_setpos|||
01609 magic_setregexp|||
01610 magic_setsig|||
01611 magic_setsubstr|||
01612 magic_settaint|||
01613 magic_setutf8|||
01614 magic_setuvar|||
01615 magic_setvec|||
01616 magic_set|||
01617 magic_sizepack|||
01618 magic_wipepack|||
01619 make_matcher|||
01620 make_trie_failtable|||
01621 make_trie|||
01622 malloc_good_size|||n
01623 malloced_size|||n
01624 malloc||5.007002|n
01625 markstack_grow|||
01626 matcher_matches_sv|||
01627 measure_struct|||
01628 memEQ|5.004000||p
01629 memNE|5.004000||p
01630 mem_collxfrm|||
01631 mem_log_common|||n
01632 mess_alloc|||
01633 mess_nocontext|||vn
01634 mess||5.006000|v
01635 method_common|||
01636 mfree||5.007002|n
01637 mg_clear|||
01638 mg_copy|||
01639 mg_dup|||
01640 mg_find|||
01641 mg_free|||
01642 mg_get|||
01643 mg_length||5.005000|
01644 mg_localize|||
01645 mg_magical|||
01646 mg_set|||
01647 mg_size||5.005000|
01648 mini_mktime||5.007002|
01649 missingterm|||
01650 mode_from_discipline|||
01651 modkids|||
01652 mod|||
01653 more_bodies|||
01654 more_sv|||
01655 moreswitches|||
01656 mro_get_from_name||5.011000|
01657 mro_get_linear_isa_dfs|||
01658 mro_get_linear_isa||5.009005|
01659 mro_get_private_data||5.011000|
01660 mro_isa_changed_in|||
01661 mro_meta_dup|||
01662 mro_meta_init|||
01663 mro_method_changed_in||5.009005|
01664 mro_register||5.011000|
01665 mro_set_mro||5.011000|
01666 mro_set_private_data||5.011000|
01667 mul128|||
01668 mulexp10|||n
01669 my_atof2||5.007002|
01670 my_atof||5.006000|
01671 my_attrs|||
01672 my_bcopy|||n
01673 my_betoh16|||n
01674 my_betoh32|||n
01675 my_betoh64|||n
01676 my_betohi|||n
01677 my_betohl|||n
01678 my_betohs|||n
01679 my_bzero|||n
01680 my_chsize|||
01681 my_clearenv|||
01682 my_cxt_index|||
01683 my_cxt_init|||
01684 my_dirfd||5.009005|
01685 my_exit_jump|||
01686 my_exit|||
01687 my_failure_exit||5.004000|
01688 my_fflush_all||5.006000|
01689 my_fork||5.007003|n
01690 my_htobe16|||n
01691 my_htobe32|||n
01692 my_htobe64|||n
01693 my_htobei|||n
01694 my_htobel|||n
01695 my_htobes|||n
01696 my_htole16|||n
01697 my_htole32|||n
01698 my_htole64|||n
01699 my_htolei|||n
01700 my_htolel|||n
01701 my_htoles|||n
01702 my_htonl|||
01703 my_kid|||
01704 my_letoh16|||n
01705 my_letoh32|||n
01706 my_letoh64|||n
01707 my_letohi|||n
01708 my_letohl|||n
01709 my_letohs|||n
01710 my_lstat|||
01711 my_memcmp||5.004000|n
01712 my_memset|||n
01713 my_ntohl|||
01714 my_pclose||5.004000|
01715 my_popen_list||5.007001|
01716 my_popen||5.004000|
01717 my_setenv|||
01718 my_snprintf|5.009004||pvn
01719 my_socketpair||5.007003|n
01720 my_sprintf|5.009003||pvn
01721 my_stat|||
01722 my_strftime||5.007002|
01723 my_strlcat|5.009004||pn
01724 my_strlcpy|5.009004||pn
01725 my_swabn|||n
01726 my_swap|||
01727 my_unexec|||
01728 my_vsnprintf||5.009004|n
01729 need_utf8|||n
01730 newANONATTRSUB||5.006000|
01731 newANONHASH|||
01732 newANONLIST|||
01733 newANONSUB|||
01734 newASSIGNOP|||
01735 newATTRSUB||5.006000|
01736 newAVREF|||
01737 newAV|||
01738 newBINOP|||
01739 newCONDOP|||
01740 newCONSTSUB|5.004050||p
01741 newCVREF|||
01742 newDEFSVOP|||
01743 newFORM|||
01744 newFOROP|||
01745 newGIVENOP||5.009003|
01746 newGIVWHENOP|||
01747 newGP|||
01748 newGVOP|||
01749 newGVREF|||
01750 newGVgen|||
01751 newHVREF|||
01752 newHVhv||5.005000|
01753 newHV|||
01754 newIO|||
01755 newLISTOP|||
01756 newLOGOP|||
01757 newLOOPEX|||
01758 newLOOPOP|||
01759 newMADPROP|||
01760 newMADsv|||
01761 newMYSUB|||
01762 newNULLLIST|||
01763 newOP|||
01764 newPADOP|||
01765 newPMOP|||
01766 newPROG|||
01767 newPVOP|||
01768 newRANGE|||
01769 newRV_inc|5.004000||p
01770 newRV_noinc|5.004000||p
01771 newRV|||
01772 newSLICEOP|||
01773 newSTATEOP|||
01774 newSUB|||
01775 newSVOP|||
01776 newSVREF|||
01777 newSV_type||5.009005|
01778 newSVhek||5.009003|
01779 newSViv|||
01780 newSVnv|||
01781 newSVpvf_nocontext|||vn
01782 newSVpvf||5.004000|v
01783 newSVpvn_flags|5.011000||p
01784 newSVpvn_share|5.007001||p
01785 newSVpvn_utf8|5.011000||p
01786 newSVpvn|5.004050||p
01787 newSVpvs_flags|5.011000||p
01788 newSVpvs_share||5.009003|
01789 newSVpvs|5.009003||p
01790 newSVpv|||
01791 newSVrv|||
01792 newSVsv|||
01793 newSVuv|5.006000||p
01794 newSV|||
01795 newTOKEN|||
01796 newUNOP|||
01797 newWHENOP||5.009003|
01798 newWHILEOP||5.009003|
01799 newXS_flags||5.009004|
01800 newXSproto||5.006000|
01801 newXS||5.006000|
01802 new_collate||5.006000|
01803 new_constant|||
01804 new_ctype||5.006000|
01805 new_he|||
01806 new_logop|||
01807 new_numeric||5.006000|
01808 new_stackinfo||5.005000|
01809 new_version||5.009000|
01810 new_warnings_bitfield|||
01811 next_symbol|||
01812 nextargv|||
01813 nextchar|||
01814 ninstr|||
01815 no_bareword_allowed|||
01816 no_fh_allowed|||
01817 no_op|||
01818 not_a_number|||
01819 nothreadhook||5.008000|
01820 nuke_stacks|||
01821 num_overflow|||n
01822 offer_nice_chunk|||
01823 oopsAV|||
01824 oopsHV|||
01825 op_clear|||
01826 op_const_sv|||
01827 op_dump||5.006000|
01828 op_free|||
01829 op_getmad_weak|||
01830 op_getmad|||
01831 op_null||5.007002|
01832 op_refcnt_dec|||
01833 op_refcnt_inc|||
01834 op_refcnt_lock||5.009002|
01835 op_refcnt_unlock||5.009002|
01836 op_xmldump|||
01837 open_script|||
01838 pMY_CXT_|5.007003||p
01839 pMY_CXT|5.007003||p
01840 pTHX_|5.006000||p
01841 pTHX|5.006000||p
01842 packWARN|5.007003||p
01843 pack_cat||5.007003|
01844 pack_rec|||
01845 package|||
01846 packlist||5.008001|
01847 pad_add_anon|||
01848 pad_add_name|||
01849 pad_alloc|||
01850 pad_block_start|||
01851 pad_check_dup|||
01852 pad_compname_type|||
01853 pad_findlex|||
01854 pad_findmy|||
01855 pad_fixup_inner_anons|||
01856 pad_free|||
01857 pad_leavemy|||
01858 pad_new|||
01859 pad_peg|||n
01860 pad_push|||
01861 pad_reset|||
01862 pad_setsv|||
01863 pad_sv||5.011000|
01864 pad_swipe|||
01865 pad_tidy|||
01866 pad_undef|||
01867 parse_body|||
01868 parse_unicode_opts|||
01869 parser_dup|||
01870 parser_free|||
01871 path_is_absolute|||n
01872 peep|||
01873 pending_Slabs_to_ro|||
01874 perl_alloc_using|||n
01875 perl_alloc|||n
01876 perl_clone_using|||n
01877 perl_clone|||n
01878 perl_construct|||n
01879 perl_destruct||5.007003|n
01880 perl_free|||n
01881 perl_parse||5.006000|n
01882 perl_run|||n
01883 pidgone|||
01884 pm_description|||
01885 pmflag|||
01886 pmop_dump||5.006000|
01887 pmop_xmldump|||
01888 pmruntime|||
01889 pmtrans|||
01890 pop_scope|||
01891 pregcomp||5.009005|
01892 pregexec|||
01893 pregfree2||5.011000|
01894 pregfree|||
01895 prepend_elem|||
01896 prepend_madprops|||
01897 printbuf|||
01898 printf_nocontext|||vn
01899 process_special_blocks|||
01900 ptr_table_clear||5.009005|
01901 ptr_table_fetch||5.009005|
01902 ptr_table_find|||n
01903 ptr_table_free||5.009005|
01904 ptr_table_new||5.009005|
01905 ptr_table_split||5.009005|
01906 ptr_table_store||5.009005|
01907 push_scope|||
01908 put_byte|||
01909 pv_display|5.006000||p
01910 pv_escape|5.009004||p
01911 pv_pretty|5.009004||p
01912 pv_uni_display||5.007003|
01913 qerror|||
01914 qsortsvu|||
01915 re_compile||5.009005|
01916 re_croak2|||
01917 re_dup_guts|||
01918 re_intuit_start||5.009005|
01919 re_intuit_string||5.006000|
01920 readpipe_override|||
01921 realloc||5.007002|n
01922 reentrant_free|||
01923 reentrant_init|||
01924 reentrant_retry|||vn
01925 reentrant_size|||
01926 ref_array_or_hash|||
01927 refcounted_he_chain_2hv|||
01928 refcounted_he_fetch|||
01929 refcounted_he_free|||
01930 refcounted_he_new_common|||
01931 refcounted_he_new|||
01932 refcounted_he_value|||
01933 refkids|||
01934 refto|||
01935 ref||5.011000|
01936 reg_check_named_buff_matched|||
01937 reg_named_buff_all||5.009005|
01938 reg_named_buff_exists||5.009005|
01939 reg_named_buff_fetch||5.009005|
01940 reg_named_buff_firstkey||5.009005|
01941 reg_named_buff_iter|||
01942 reg_named_buff_nextkey||5.009005|
01943 reg_named_buff_scalar||5.009005|
01944 reg_named_buff|||
01945 reg_namedseq|||
01946 reg_node|||
01947 reg_numbered_buff_fetch|||
01948 reg_numbered_buff_length|||
01949 reg_numbered_buff_store|||
01950 reg_qr_package|||
01951 reg_recode|||
01952 reg_scan_name|||
01953 reg_skipcomment|||
01954 reg_temp_copy|||
01955 reganode|||
01956 regatom|||
01957 regbranch|||
01958 regclass_swash||5.009004|
01959 regclass|||
01960 regcppop|||
01961 regcppush|||
01962 regcurly|||n
01963 regdump_extflags|||
01964 regdump||5.005000|
01965 regdupe_internal|||
01966 regexec_flags||5.005000|
01967 regfree_internal||5.009005|
01968 reghop3|||n
01969 reghop4|||n
01970 reghopmaybe3|||n
01971 reginclass|||
01972 reginitcolors||5.006000|
01973 reginsert|||
01974 regmatch|||
01975 regnext||5.005000|
01976 regpiece|||
01977 regpposixcc|||
01978 regprop|||
01979 regrepeat|||
01980 regtail_study|||
01981 regtail|||
01982 regtry|||
01983 reguni|||
01984 regwhite|||n
01985 reg|||
01986 repeatcpy|||
01987 report_evil_fh|||
01988 report_uninit|||
01989 require_pv||5.006000|
01990 require_tie_mod|||
01991 restore_magic|||
01992 rninstr|||
01993 rsignal_restore|||
01994 rsignal_save|||
01995 rsignal_state||5.004000|
01996 rsignal||5.004000|
01997 run_body|||
01998 run_user_filter|||
01999 runops_debug||5.005000|
02000 runops_standard||5.005000|
02001 rvpv_dup|||
02002 rxres_free|||
02003 rxres_restore|||
02004 rxres_save|||
02005 safesyscalloc||5.006000|n
02006 safesysfree||5.006000|n
02007 safesysmalloc||5.006000|n
02008 safesysrealloc||5.006000|n
02009 same_dirent|||
02010 save_I16||5.004000|
02011 save_I32|||
02012 save_I8||5.006000|
02013 save_adelete||5.011000|
02014 save_aelem||5.004050|
02015 save_alloc||5.006000|
02016 save_aptr|||
02017 save_ary|||
02018 save_bool||5.008001|
02019 save_clearsv|||
02020 save_delete|||
02021 save_destructor_x||5.006000|
02022 save_destructor||5.006000|
02023 save_freeop|||
02024 save_freepv|||
02025 save_freesv|||
02026 save_generic_pvref||5.006001|
02027 save_generic_svref||5.005030|
02028 save_gp||5.004000|
02029 save_hash|||
02030 save_hek_flags|||n
02031 save_helem_flags||5.011000|
02032 save_helem||5.004050|
02033 save_hints|||
02034 save_hptr|||
02035 save_int|||
02036 save_item|||
02037 save_iv||5.005000|
02038 save_lines|||
02039 save_list|||
02040 save_long|||
02041 save_magic|||
02042 save_mortalizesv||5.007001|
02043 save_nogv|||
02044 save_op|||
02045 save_padsv_and_mortalize||5.011000|
02046 save_pptr|||
02047 save_pushi32ptr|||
02048 save_pushptri32ptr|||
02049 save_pushptrptr|||
02050 save_pushptr||5.011000|
02051 save_re_context||5.006000|
02052 save_scalar_at|||
02053 save_scalar|||
02054 save_set_svflags||5.009000|
02055 save_shared_pvref||5.007003|
02056 save_sptr|||
02057 save_svref|||
02058 save_vptr||5.006000|
02059 savepvn|||
02060 savepvs||5.009003|
02061 savepv|||
02062 savesharedpvn||5.009005|
02063 savesharedpv||5.007003|
02064 savestack_grow_cnt||5.008001|
02065 savestack_grow|||
02066 savesvpv||5.009002|
02067 sawparens|||
02068 scalar_mod_type|||n
02069 scalarboolean|||
02070 scalarkids|||
02071 scalarseq|||
02072 scalarvoid|||
02073 scalar|||
02074 scan_bin||5.006000|
02075 scan_commit|||
02076 scan_const|||
02077 scan_formline|||
02078 scan_heredoc|||
02079 scan_hex|||
02080 scan_ident|||
02081 scan_inputsymbol|||
02082 scan_num||5.007001|
02083 scan_oct|||
02084 scan_pat|||
02085 scan_str|||
02086 scan_subst|||
02087 scan_trans|||
02088 scan_version||5.009001|
02089 scan_vstring||5.009005|
02090 scan_word|||
02091 scope|||
02092 screaminstr||5.005000|
02093 search_const|||
02094 seed||5.008001|
02095 sequence_num|||
02096 sequence_tail|||
02097 sequence|||
02098 set_context||5.006000|n
02099 set_numeric_local||5.006000|
02100 set_numeric_radix||5.006000|
02101 set_numeric_standard||5.006000|
02102 setdefout|||
02103 share_hek_flags|||
02104 share_hek||5.004000|
02105 si_dup|||
02106 sighandler|||n
02107 simplify_sort|||
02108 skipspace0|||
02109 skipspace1|||
02110 skipspace2|||
02111 skipspace|||
02112 softref2xv|||
02113 sortcv_stacked|||
02114 sortcv_xsub|||
02115 sortcv|||
02116 sortsv_flags||5.009003|
02117 sortsv||5.007003|
02118 space_join_names_mortal|||
02119 ss_dup|||
02120 stack_grow|||
02121 start_force|||
02122 start_glob|||
02123 start_subparse||5.004000|
02124 stashpv_hvname_match||5.011000|
02125 stdize_locale|||
02126 store_cop_label|||
02127 strEQ|||
02128 strGE|||
02129 strGT|||
02130 strLE|||
02131 strLT|||
02132 strNE|||
02133 str_to_version||5.006000|
02134 strip_return|||
02135 strnEQ|||
02136 strnNE|||
02137 study_chunk|||
02138 sub_crush_depth|||
02139 sublex_done|||
02140 sublex_push|||
02141 sublex_start|||
02142 sv_2bool|||
02143 sv_2cv|||
02144 sv_2io|||
02145 sv_2iuv_common|||
02146 sv_2iuv_non_preserve|||
02147 sv_2iv_flags||5.009001|
02148 sv_2iv|||
02149 sv_2mortal|||
02150 sv_2num|||
02151 sv_2nv|||
02152 sv_2pv_flags|5.007002||p
02153 sv_2pv_nolen|5.006000||p
02154 sv_2pvbyte_nolen|5.006000||p
02155 sv_2pvbyte|5.006000||p
02156 sv_2pvutf8_nolen||5.006000|
02157 sv_2pvutf8||5.006000|
02158 sv_2pv|||
02159 sv_2uv_flags||5.009001|
02160 sv_2uv|5.004000||p
02161 sv_add_arena|||
02162 sv_add_backref|||
02163 sv_backoff|||
02164 sv_bless|||
02165 sv_cat_decode||5.008001|
02166 sv_catpv_mg|5.004050||p
02167 sv_catpvf_mg_nocontext|||pvn
02168 sv_catpvf_mg|5.006000|5.004000|pv
02169 sv_catpvf_nocontext|||vn
02170 sv_catpvf||5.004000|v
02171 sv_catpvn_flags||5.007002|
02172 sv_catpvn_mg|5.004050||p
02173 sv_catpvn_nomg|5.007002||p
02174 sv_catpvn|||
02175 sv_catpvs|5.009003||p
02176 sv_catpv|||
02177 sv_catsv_flags||5.007002|
02178 sv_catsv_mg|5.004050||p
02179 sv_catsv_nomg|5.007002||p
02180 sv_catsv|||
02181 sv_catxmlpvn|||
02182 sv_catxmlsv|||
02183 sv_chop|||
02184 sv_clean_all|||
02185 sv_clean_objs|||
02186 sv_clear|||
02187 sv_cmp_locale||5.004000|
02188 sv_cmp|||
02189 sv_collxfrm|||
02190 sv_compile_2op||5.008001|
02191 sv_copypv||5.007003|
02192 sv_dec|||
02193 sv_del_backref|||
02194 sv_derived_from||5.004000|
02195 sv_destroyable||5.010000|
02196 sv_does||5.009004|
02197 sv_dump|||
02198 sv_dup|||
02199 sv_eq|||
02200 sv_exp_grow|||
02201 sv_force_normal_flags||5.007001|
02202 sv_force_normal||5.006000|
02203 sv_free2|||
02204 sv_free_arenas|||
02205 sv_free|||
02206 sv_gets||5.004000|
02207 sv_grow|||
02208 sv_i_ncmp|||
02209 sv_inc|||
02210 sv_insert_flags||5.011000|
02211 sv_insert|||
02212 sv_isa|||
02213 sv_isobject|||
02214 sv_iv||5.005000|
02215 sv_kill_backrefs|||
02216 sv_len_utf8||5.006000|
02217 sv_len|||
02218 sv_magic_portable|5.011000|5.004000|p
02219 sv_magicext||5.007003|
02220 sv_magic|||
02221 sv_mortalcopy|||
02222 sv_ncmp|||
02223 sv_newmortal|||
02224 sv_newref|||
02225 sv_nolocking||5.007003|
02226 sv_nosharing||5.007003|
02227 sv_nounlocking|||
02228 sv_nv||5.005000|
02229 sv_peek||5.005000|
02230 sv_pos_b2u_midway|||
02231 sv_pos_b2u||5.006000|
02232 sv_pos_u2b_cached|||
02233 sv_pos_u2b_forwards|||n
02234 sv_pos_u2b_midway|||n
02235 sv_pos_u2b||5.006000|
02236 sv_pvbyten_force||5.006000|
02237 sv_pvbyten||5.006000|
02238 sv_pvbyte||5.006000|
02239 sv_pvn_force_flags|5.007002||p
02240 sv_pvn_force|||
02241 sv_pvn_nomg|5.007003|5.005000|p
02242 sv_pvn||5.005000|
02243 sv_pvutf8n_force||5.006000|
02244 sv_pvutf8n||5.006000|
02245 sv_pvutf8||5.006000|
02246 sv_pv||5.006000|
02247 sv_recode_to_utf8||5.007003|
02248 sv_reftype|||
02249 sv_release_COW|||
02250 sv_replace|||
02251 sv_report_used|||
02252 sv_reset|||
02253 sv_rvweaken||5.006000|
02254 sv_setiv_mg|5.004050||p
02255 sv_setiv|||
02256 sv_setnv_mg|5.006000||p
02257 sv_setnv|||
02258 sv_setpv_mg|5.004050||p
02259 sv_setpvf_mg_nocontext|||pvn
02260 sv_setpvf_mg|5.006000|5.004000|pv
02261 sv_setpvf_nocontext|||vn
02262 sv_setpvf||5.004000|v
02263 sv_setpviv_mg||5.008001|
02264 sv_setpviv||5.008001|
02265 sv_setpvn_mg|5.004050||p
02266 sv_setpvn|||
02267 sv_setpvs|5.009004||p
02268 sv_setpv|||
02269 sv_setref_iv|||
02270 sv_setref_nv|||
02271 sv_setref_pvn|||
02272 sv_setref_pv|||
02273 sv_setref_uv||5.007001|
02274 sv_setsv_cow|||
02275 sv_setsv_flags||5.007002|
02276 sv_setsv_mg|5.004050||p
02277 sv_setsv_nomg|5.007002||p
02278 sv_setsv|||
02279 sv_setuv_mg|5.004050||p
02280 sv_setuv|5.004000||p
02281 sv_tainted||5.004000|
02282 sv_taint||5.004000|
02283 sv_true||5.005000|
02284 sv_unglob|||
02285 sv_uni_display||5.007003|
02286 sv_unmagic|||
02287 sv_unref_flags||5.007001|
02288 sv_unref|||
02289 sv_untaint||5.004000|
02290 sv_upgrade|||
02291 sv_usepvn_flags||5.009004|
02292 sv_usepvn_mg|5.004050||p
02293 sv_usepvn|||
02294 sv_utf8_decode||5.006000|
02295 sv_utf8_downgrade||5.006000|
02296 sv_utf8_encode||5.006000|
02297 sv_utf8_upgrade_flags_grow||5.011000|
02298 sv_utf8_upgrade_flags||5.007002|
02299 sv_utf8_upgrade_nomg||5.007002|
02300 sv_utf8_upgrade||5.007001|
02301 sv_uv|5.005000||p
02302 sv_vcatpvf_mg|5.006000|5.004000|p
02303 sv_vcatpvfn||5.004000|
02304 sv_vcatpvf|5.006000|5.004000|p
02305 sv_vsetpvf_mg|5.006000|5.004000|p
02306 sv_vsetpvfn||5.004000|
02307 sv_vsetpvf|5.006000|5.004000|p
02308 sv_xmlpeek|||
02309 svtype|||
02310 swallow_bom|||
02311 swap_match_buff|||
02312 swash_fetch||5.007002|
02313 swash_get|||
02314 swash_init||5.006000|
02315 sys_init3||5.010000|n
02316 sys_init||5.010000|n
02317 sys_intern_clear|||
02318 sys_intern_dup|||
02319 sys_intern_init|||
02320 sys_term||5.010000|n
02321 taint_env|||
02322 taint_proper|||
02323 tmps_grow||5.006000|
02324 toLOWER|||
02325 toUPPER|||
02326 to_byte_substr|||
02327 to_uni_fold||5.007003|
02328 to_uni_lower_lc||5.006000|
02329 to_uni_lower||5.007003|
02330 to_uni_title_lc||5.006000|
02331 to_uni_title||5.007003|
02332 to_uni_upper_lc||5.006000|
02333 to_uni_upper||5.007003|
02334 to_utf8_case||5.007003|
02335 to_utf8_fold||5.007003|
02336 to_utf8_lower||5.007003|
02337 to_utf8_substr|||
02338 to_utf8_title||5.007003|
02339 to_utf8_upper||5.007003|
02340 token_free|||
02341 token_getmad|||
02342 tokenize_use|||
02343 tokeq|||
02344 tokereport|||
02345 too_few_arguments|||
02346 too_many_arguments|||
02347 uiv_2buf|||n
02348 unlnk|||
02349 unpack_rec|||
02350 unpack_str||5.007003|
02351 unpackstring||5.008001|
02352 unshare_hek_or_pvn|||
02353 unshare_hek|||
02354 unsharepvn||5.004000|
02355 unwind_handler_stack|||
02356 update_debugger_info|||
02357 upg_version||5.009005|
02358 usage|||
02359 utf16_to_utf8_reversed||5.006001|
02360 utf16_to_utf8||5.006001|
02361 utf8_distance||5.006000|
02362 utf8_hop||5.006000|
02363 utf8_length||5.007001|
02364 utf8_mg_pos_cache_update|||
02365 utf8_to_bytes||5.006001|
02366 utf8_to_uvchr||5.007001|
02367 utf8_to_uvuni||5.007001|
02368 utf8n_to_uvchr|||
02369 utf8n_to_uvuni||5.007001|
02370 utilize|||
02371 uvchr_to_utf8_flags||5.007003|
02372 uvchr_to_utf8|||
02373 uvuni_to_utf8_flags||5.007003|
02374 uvuni_to_utf8||5.007001|
02375 validate_suid|||
02376 varname|||
02377 vcmp||5.009000|
02378 vcroak||5.006000|
02379 vdeb||5.007003|
02380 vdie_common|||
02381 vdie_croak_common|||
02382 vdie|||
02383 vform||5.006000|
02384 visit|||
02385 vivify_defelem|||
02386 vivify_ref|||
02387 vload_module|5.006000||p
02388 vmess||5.006000|
02389 vnewSVpvf|5.006000|5.004000|p
02390 vnormal||5.009002|
02391 vnumify||5.009000|
02392 vstringify||5.009000|
02393 vverify||5.009003|
02394 vwarner||5.006000|
02395 vwarn||5.006000|
02396 wait4pid|||
02397 warn_nocontext|||vn
02398 warner_nocontext|||vn
02399 warner|5.006000|5.004000|pv
02400 warn|||v
02401 watch|||
02402 whichsig|||
02403 write_no_mem|||
02404 write_to_stderr|||
02405 xmldump_all|||
02406 xmldump_attr|||
02407 xmldump_eval|||
02408 xmldump_form|||
02409 xmldump_indent|||v
02410 xmldump_packsubs|||
02411 xmldump_sub|||
02412 xmldump_vindent|||
02413 yyerror|||
02414 yylex|||
02415 yyparse|||
02416 yywarn|||
02417 );
02418 
02419 if (exists $opt{'list-unsupported'}) {
02420   my $f;
02421   for $f (sort { lc $a cmp lc $b } keys %API) {
02422     next unless $API{$f}{todo};
02423     print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";
02424   }
02425   exit 0;
02426 }
02427 
02428 # Scan for possible replacement candidates
02429 
02430 my(%replace, %need, %hints, %warnings, %depends);
02431 my $replace = 0;
02432 my($hint, $define, $function);
02433 
02434 sub find_api
02435 {
02436   my $code = shift;
02437   $code =~ s{
02438     / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
02439   | "[^"\\]*(?:\\.[^"\\]*)*"
02440   | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx;
02441   grep { exists $API{$_} } $code =~ /(\w+)/mg;
02442 }
02443 
02444 while (<DATA>) {
02445   if ($hint) {
02446     my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;
02447     if (m{^\s*\*\s(.*?)\s*$}) {
02448       for (@{$hint->[1]}) {
02449         $h->{$_} ||= '';  # suppress warning with older perls
02450         $h->{$_} .= "$1\n";
02451       }
02452     }
02453     else { undef $hint }
02454   }
02455 
02456   $hint = [$1, [split /,?\s+/, $2]]
02457       if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$};
02458 
02459   if ($define) {
02460     if ($define->[1] =~ /\\$/) {
02461       $define->[1] .= $_;
02462     }
02463     else {
02464       if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {
02465         my @n = find_api($define->[1]);
02466         push @{$depends{$define->[0]}}, @n if @n
02467       }
02468       undef $define;
02469     }
02470   }
02471 
02472   $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)};
02473 
02474   if ($function) {
02475     if (/^}/) {
02476       if (exists $API{$function->[0]}) {
02477         my @n = find_api($function->[1]);
02478         push @{$depends{$function->[0]}}, @n if @n
02479       }
02480       undef $function;
02481     }
02482     else {
02483       $function->[1] .= $_;
02484     }
02485   }
02486 
02487   $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};
02488 
02489   $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
02490   $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
02491   $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
02492   $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};
02493 
02494   if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
02495     my @deps = map { s/\s+//g; $_ } split /,/, $3;
02496     my $d;
02497     for $d (map { s/\s+//g; $_ } split /,/, $1) {
02498       push @{$depends{$d}}, @deps;
02499     }
02500   }
02501 
02502   $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
02503 }
02504 
02505 for (values %depends) {
02506   my %s;
02507   $_ = [sort grep !$s{$_}++, @$_];
02508 }
02509 
02510 if (exists $opt{'api-info'}) {
02511   my $f;
02512   my $count = 0;
02513   my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";
02514   for $f (sort { lc $a cmp lc $b } keys %API) {
02515     next unless $f =~ /$match/;
02516     print "\n=== $f ===\n\n";
02517     my $info = 0;
02518     if ($API{$f}{base} || $API{$f}{todo}) {
02519       my $base = format_version($API{$f}{base} || $API{$f}{todo});
02520       print "Supported at least starting from perl-$base.\n";
02521       $info++;
02522     }
02523     if ($API{$f}{provided}) {
02524       my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003";
02525       print "Support by $ppport provided back to perl-$todo.\n";
02526       print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
02527       print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
02528       print "\n$hints{$f}" if exists $hints{$f};
02529       print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};
02530       $info++;
02531     }
02532     print "No portability information available.\n" unless $info;
02533     $count++;
02534   }
02535   $count or print "Found no API matching '$opt{'api-info'}'.";
02536   print "\n";
02537   exit 0;
02538 }
02539 
02540 if (exists $opt{'list-provided'}) {
02541   my $f;
02542   for $f (sort { lc $a cmp lc $b } keys %API) {
02543     next unless $API{$f}{provided};
02544     my @flags;
02545     push @flags, 'explicit' if exists $need{$f};
02546     push @flags, 'depend'   if exists $depends{$f};
02547     push @flags, 'hint'     if exists $hints{$f};
02548     push @flags, 'warning'  if exists $warnings{$f};
02549     my $flags = @flags ? '  ['.join(', ', @flags).']' : '';
02550     print "$f$flags\n";
02551   }
02552   exit 0;
02553 }
02554 
02555 my @files;
02556 my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
02557 my $srcext = join '|', map { quotemeta $_ } @srcext;
02558 
02559 if (@ARGV) {
02560   my %seen;
02561   for (@ARGV) {
02562     if (-e) {
02563       if (-f) {
02564         push @files, $_ unless $seen{$_}++;
02565       }
02566       else { warn "'$_' is not a file.\n" }
02567     }
02568     else {
02569       my @new = grep { -f } glob $_
02570           or warn "'$_' does not exist.\n";
02571       push @files, grep { !$seen{$_}++ } @new;
02572     }
02573   }
02574 }
02575 else {
02576   eval {
02577     require File::Find;
02578     File::Find::find(sub {
02579       $File::Find::name =~ /($srcext)$/i
02580           and push @files, $File::Find::name;
02581     }, '.');
02582   };
02583   if ($@) {
02584     @files = map { glob "*$_" } @srcext;
02585   }
02586 }
02587 
02588 if (!@ARGV || $opt{filter}) {
02589   my(@in, @out);
02590   my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
02591   for (@files) {
02592     my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;
02593     push @{ $out ? \@out : \@in }, $_;
02594   }
02595   if (@ARGV && @out) {
02596     warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
02597   }
02598   @files = @in;
02599 }
02600 
02601 die "No input files given!\n" unless @files;
02602 
02603 my(%files, %global, %revreplace);
02604 %revreplace = reverse %replace;
02605 my $filename;
02606 my $patch_opened = 0;
02607 
02608 for $filename (@files) {
02609   unless (open IN, "<$filename") {
02610     warn "Unable to read from $filename: $!\n";
02611     next;
02612   }
02613 
02614   info("Scanning $filename ...");
02615 
02616   my $c = do { local $/; <IN> };
02617   close IN;
02618 
02619   my %file = (orig => $c, changes => 0);
02620 
02621   # Temporarily remove C/XS comments and strings from the code
02622   my @ccom;
02623 
02624   $c =~ s{
02625     ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]*
02626     | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* )
02627   | ( ^$HS*\#[^\r\n]*
02628     | "[^"\\]*(?:\\.[^"\\]*)*"
02629     | '[^'\\]*(?:\\.[^'\\]*)*'
02630     | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) )
02631   }{ defined $2 and push @ccom, $2;
02632      defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;
02633 
02634   $file{ccom} = \@ccom;
02635   $file{code} = $c;
02636   $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m;
02637 
02638   my $func;
02639 
02640   for $func (keys %API) {
02641     my $match = $func;
02642     $match .= "|$revreplace{$func}" if exists $revreplace{$func};
02643     if ($c =~ /\b(?:Perl_)?($match)\b/) {
02644       $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
02645       $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
02646       if (exists $API{$func}{provided}) {
02647         $file{uses_provided}{$func}++;
02648         if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {
02649           $file{uses}{$func}++;
02650           my @deps = rec_depend($func);
02651           if (@deps) {
02652             $file{uses_deps}{$func} = \@deps;
02653             for (@deps) {
02654               $file{uses}{$_} = 0 unless exists $file{uses}{$_};
02655             }
02656           }
02657           for ($func, @deps) {
02658             $file{needs}{$_} = 'static' if exists $need{$_};
02659           }
02660         }
02661       }
02662       if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) {
02663         if ($c =~ /\b$func\b/) {
02664           $file{uses_todo}{$func}++;
02665         }
02666       }
02667     }
02668   }
02669 
02670   while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {
02671     if (exists $need{$2}) {
02672       $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
02673     }
02674     else { warning("Possibly wrong #define $1 in $filename") }
02675   }
02676 
02677   for (qw(uses needs uses_todo needed_global needed_static)) {
02678     for $func (keys %{$file{$_}}) {
02679       push @{$global{$_}{$func}}, $filename;
02680     }
02681   }
02682 
02683   $files{$filename} = \%file;
02684 }
02685 
02686 # Globally resolve NEED_'s
02687 my $need;
02688 for $need (keys %{$global{needs}}) {
02689   if (@{$global{needs}{$need}} > 1) {
02690     my @targets = @{$global{needs}{$need}};
02691     my @t = grep $files{$_}{needed_global}{$need}, @targets;
02692     @targets = @t if @t;
02693     @t = grep /\.xs$/i, @targets;
02694     @targets = @t if @t;
02695     my $target = shift @targets;
02696     $files{$target}{needs}{$need} = 'global';
02697     for (@{$global{needs}{$need}}) {
02698       $files{$_}{needs}{$need} = 'extern' if $_ ne $target;
02699     }
02700   }
02701 }
02702 
02703 for $filename (@files) {
02704   exists $files{$filename} or next;
02705 
02706   info("=== Analyzing $filename ===");
02707 
02708   my %file = %{$files{$filename}};
02709   my $func;
02710   my $c = $file{code};
02711   my $warnings = 0;
02712 
02713   for $func (sort keys %{$file{uses_Perl}}) {
02714     if ($API{$func}{varargs}) {
02715       unless ($API{$func}{nothxarg}) {
02716         my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
02717                               { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
02718         if ($changes) {
02719           warning("Doesn't pass interpreter argument aTHX to Perl_$func");
02720           $file{changes} += $changes;
02721         }
02722       }
02723     }
02724     else {
02725       warning("Uses Perl_$func instead of $func");
02726       $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}
02727                                 {$func$1(}g);
02728     }
02729   }
02730 
02731   for $func (sort keys %{$file{uses_replace}}) {
02732     warning("Uses $func instead of $replace{$func}");
02733     $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
02734   }
02735 
02736   for $func (sort keys %{$file{uses_provided}}) {
02737     if ($file{uses}{$func}) {
02738       if (exists $file{uses_deps}{$func}) {
02739         diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
02740       }
02741       else {
02742         diag("Uses $func");
02743       }
02744     }
02745     $warnings += hint($func);
02746   }
02747 
02748   unless ($opt{quiet}) {
02749     for $func (sort keys %{$file{uses_todo}}) {
02750       print "*** WARNING: Uses $func, which may not be portable below perl ",
02751             format_version($API{$func}{todo}), ", even with '$ppport'\n";
02752       $warnings++;
02753     }
02754   }
02755 
02756   for $func (sort keys %{$file{needed_static}}) {
02757     my $message = '';
02758     if (not exists $file{uses}{$func}) {
02759       $message = "No need to define NEED_$func if $func is never used";
02760     }
02761     elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {
02762       $message = "No need to define NEED_$func when already needed globally";
02763     }
02764     if ($message) {
02765       diag($message);
02766       $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
02767     }
02768   }
02769 
02770   for $func (sort keys %{$file{needed_global}}) {
02771     my $message = '';
02772     if (not exists $global{uses}{$func}) {
02773       $message = "No need to define NEED_${func}_GLOBAL if $func is never used";
02774     }
02775     elsif (exists $file{needs}{$func}) {
02776       if ($file{needs}{$func} eq 'extern') {
02777         $message = "No need to define NEED_${func}_GLOBAL when already needed globally";
02778       }
02779       elsif ($file{needs}{$func} eq 'static') {
02780         $message = "No need to define NEED_${func}_GLOBAL when only used in this file";
02781       }
02782     }
02783     if ($message) {
02784       diag($message);
02785       $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
02786     }
02787   }
02788 
02789   $file{needs_inc_ppport} = keys %{$file{uses}};
02790 
02791   if ($file{needs_inc_ppport}) {
02792     my $pp = '';
02793 
02794     for $func (sort keys %{$file{needs}}) {
02795       my $type = $file{needs}{$func};
02796       next if $type eq 'extern';
02797       my $suffix = $type eq 'global' ? '_GLOBAL' : '';
02798       unless (exists $file{"needed_$type"}{$func}) {
02799         if ($type eq 'global') {
02800           diag("Files [@{$global{needs}{$func}}] need $func, adding global request");
02801         }
02802         else {
02803           diag("File needs $func, adding static request");
02804         }
02805         $pp .= "#define NEED_$func$suffix\n";
02806       }
02807     }
02808 
02809     if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {
02810       $pp = '';
02811       $file{changes}++;
02812     }
02813 
02814     unless ($file{has_inc_ppport}) {
02815       diag("Needs to include '$ppport'");
02816       $pp .= qq(#include "$ppport"\n)
02817     }
02818 
02819     if ($pp) {
02820       $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)
02821                      || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)
02822                      || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)
02823                      || ($c =~ s/^/$pp/);
02824     }
02825   }
02826   else {
02827     if ($file{has_inc_ppport}) {
02828       diag("No need to include '$ppport'");
02829       $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
02830     }
02831   }
02832 
02833   # put back in our C comments
02834   my $ix;
02835   my $cppc = 0;
02836   my @ccom = @{$file{ccom}};
02837   for $ix (0 .. $#ccom) {
02838     if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
02839       $cppc++;
02840       $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;
02841     }
02842     else {
02843       $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;
02844     }
02845   }
02846 
02847   if ($cppc) {
02848     my $s = $cppc != 1 ? 's' : '';
02849     warning("Uses $cppc C++ style comment$s, which is not portable");
02850   }
02851 
02852   my $s = $warnings != 1 ? 's' : '';
02853   my $warn = $warnings ? " ($warnings warning$s)" : '';
02854   info("Analysis completed$warn");
02855 
02856   if ($file{changes}) {
02857     if (exists $opt{copy}) {
02858       my $newfile = "$filename$opt{copy}";
02859       if (-e $newfile) {
02860         error("'$newfile' already exists, refusing to write copy of '$filename'");
02861       }
02862       else {
02863         local *F;
02864         if (open F, ">$newfile") {
02865           info("Writing copy of '$filename' with changes to '$newfile'");
02866           print F $c;
02867           close F;
02868         }
02869         else {
02870           error("Cannot open '$newfile' for writing: $!");
02871         }
02872       }
02873     }
02874     elsif (exists $opt{patch} || $opt{changes}) {
02875       if (exists $opt{patch}) {
02876         unless ($patch_opened) {
02877           if (open PATCH, ">$opt{patch}") {
02878             $patch_opened = 1;
02879           }
02880           else {
02881             error("Cannot open '$opt{patch}' for writing: $!");
02882             delete $opt{patch};
02883             $opt{changes} = 1;
02884             goto fallback;
02885           }
02886         }
02887         mydiff(\*PATCH, $filename, $c);
02888       }
02889       else {
02890 fallback:
02891         info("Suggested changes:");
02892         mydiff(\*STDOUT, $filename, $c);
02893       }
02894     }
02895     else {
02896       my $s = $file{changes} == 1 ? '' : 's';
02897       info("$file{changes} potentially required change$s detected");
02898     }
02899   }
02900   else {
02901     info("Looks good");
02902   }
02903 }
02904 
02905 close PATCH if $patch_opened;
02906 
02907 exit 0;
02908 
02909 
02910 sub try_use { eval "use @_;"; return $@ eq '' }
02911 
02912 sub mydiff
02913 {
02914   local *F = shift;
02915   my($file, $str) = @_;
02916   my $diff;
02917 
02918   if (exists $opt{diff}) {
02919     $diff = run_diff($opt{diff}, $file, $str);
02920   }
02921 
02922   if (!defined $diff and try_use('Text::Diff')) {
02923     $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
02924     $diff = <<HEADER . $diff;
02925 --- $file
02926 +++ $file.patched
02927 HEADER
02928   }
02929 
02930   if (!defined $diff) {
02931     $diff = run_diff('diff -u', $file, $str);
02932   }
02933 
02934   if (!defined $diff) {
02935     $diff = run_diff('diff', $file, $str);
02936   }
02937 
02938   if (!defined $diff) {
02939     error("Cannot generate a diff. Please install Text::Diff or use --copy.");
02940     return;
02941   }
02942 
02943   print F $diff;
02944 }
02945 
02946 sub run_diff
02947 {
02948   my($prog, $file, $str) = @_;
02949   my $tmp = 'dppptemp';
02950   my $suf = 'aaa';
02951   my $diff = '';
02952   local *F;
02953 
02954   while (-e "$tmp.$suf") { $suf++ }
02955   $tmp = "$tmp.$suf";
02956 
02957   if (open F, ">$tmp") {
02958     print F $str;
02959     close F;
02960 
02961     if (open F, "$prog $file $tmp |") {
02962       while (<F>) {
02963         s/\Q$tmp\E/$file.patched/;
02964         $diff .= $_;
02965       }
02966       close F;
02967       unlink $tmp;
02968       return $diff;
02969     }
02970 
02971     unlink $tmp;
02972   }
02973   else {
02974     error("Cannot open '$tmp' for writing: $!");
02975   }
02976 
02977   return undef;
02978 }
02979 
02980 sub rec_depend
02981 {
02982   my($func, $seen) = @_;
02983   return () unless exists $depends{$func};
02984   $seen = {%{$seen||{}}};
02985   return () if $seen->{$func}++;
02986   my %s;
02987   grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
02988 }
02989 
02990 sub parse_version
02991 {
02992   my $ver = shift;
02993 
02994   if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {
02995     return ($1, $2, $3);
02996   }
02997   elsif ($ver !~ /^\d+\.[\d_]+$/) {
02998     die "cannot parse version '$ver'\n";
02999   }
03000 
03001   $ver =~ s/_//g;
03002   $ver =~ s/$/000000/;
03003 
03004   my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
03005 
03006   $v = int $v;
03007   $s = int $s;
03008 
03009   if ($r < 5 || ($r == 5 && $v < 6)) {
03010     if ($s % 10) {
03011       die "cannot parse version '$ver'\n";
03012     }
03013   }
03014 
03015   return ($r, $v, $s);
03016 }
03017 
03018 sub format_version
03019 {
03020   my $ver = shift;
03021 
03022   $ver =~ s/$/000000/;
03023   my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
03024 
03025   $v = int $v;
03026   $s = int $s;
03027 
03028   if ($r < 5 || ($r == 5 && $v < 6)) {
03029     if ($s % 10) {
03030       die "invalid version '$ver'\n";
03031     }
03032     $s /= 10;
03033 
03034     $ver = sprintf "%d.%03d", $r, $v;
03035     $s > 0 and $ver .= sprintf "_%02d", $s;
03036 
03037     return $ver;
03038   }
03039 
03040   return sprintf "%d.%d.%d", $r, $v, $s;
03041 }
03042 
03043 sub info
03044 {
03045   $opt{quiet} and return;
03046   print @_, "\n";
03047 }
03048 
03049 sub diag
03050 {
03051   $opt{quiet} and return;
03052   $opt{diag} and print @_, "\n";
03053 }
03054 
03055 sub warning
03056 {
03057   $opt{quiet} and return;
03058   print "*** ", @_, "\n";
03059 }
03060 
03061 sub error
03062 {
03063   print "*** ERROR: ", @_, "\n";
03064 }
03065 
03066 my %given_hints;
03067 my %given_warnings;
03068 sub hint
03069 {
03070   $opt{quiet} and return;
03071   my $func = shift;
03072   my $rv = 0;
03073   if (exists $warnings{$func} && !$given_warnings{$func}++) {
03074     my $warn = $warnings{$func};
03075     $warn =~ s!^!*** !mg;
03076     print "*** WARNING: $func\n", $warn;
03077     $rv++;
03078   }
03079   if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {
03080     my $hint = $hints{$func};
03081     $hint =~ s/^/   /mg;
03082     print "   --- hint for $func ---\n", $hint;
03083   }
03084   $rv;
03085 }
03086 
03087 sub usage
03088 {
03089   my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
03090   my %M = ( 'I' => '*' );
03091   $usage =~ s/^\s*perl\s+\S+/$^X $0/;
03092   $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;
03093 
03094   print <<ENDUSAGE;
03095 
03096 Usage: $usage
03097 
03098 See perldoc $0 for details.
03099 
03100 ENDUSAGE
03101 
03102   exit 2;
03103 }
03104 
03105 sub strip
03106 {
03107   my $self = do { local(@ARGV,$/)=($0); <> };
03108   my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;
03109   $copy =~ s/^(?=\S+)/    /gms;
03110   $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;
03111   $self =~ s/^SKIP.*(?=^__DATA__)/SKIP
03112 if (\@ARGV && \$ARGV[0] eq '--unstrip') {
03113   eval { require Devel::PPPort };
03114   \$@ and die "Cannot require Devel::PPPort, please install.\\n";
03115   if (eval \$Devel::PPPort::VERSION < $VERSION) {
03116     die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
03117       . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
03118       . "Please install a newer version, or --unstrip will not work.\\n";
03119   }
03120   Devel::PPPort::WriteFile(\$0);
03121   exit 0;
03122 }
03123 print <<END;
03124 
03125 Sorry, but this is a stripped version of \$0.
03126 
03127 To be able to use its original script and doc functionality,
03128 please try to regenerate this file using:
03129 
03130   \$^X \$0 --unstrip
03131 
03132 END
03133 /ms;
03134   my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms;
03135   $c =~ s{
03136     / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
03137   | ( "[^"\\]*(?:\\.[^"\\]*)*"
03138     | '[^'\\]*(?:\\.[^'\\]*)*' )
03139   | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex;
03140   $c =~ s!\s+$!!mg;
03141   $c =~ s!^$LF!!mg;
03142   $c =~ s!^\s*#\s*!#!mg;
03143   $c =~ s!^\s+!!mg;
03144 
03145   open OUT, ">$0" or die "cannot strip $0: $!\n";
03146   print OUT "$pl$c\n";
03147 
03148   exit 0;
03149 }
03150 
03151 __DATA__
03152 */
03153 
03154 #ifndef _P_P_PORTABILITY_H_
03155 #define _P_P_PORTABILITY_H_
03156 
03157 #ifndef DPPP_NAMESPACE
03158 #  define DPPP_NAMESPACE DPPP_
03159 #endif
03160 
03161 #define DPPP_CAT2(x,y) CAT2(x,y)
03162 #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)
03163 
03164 #ifndef PERL_REVISION
03165 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
03166 #    define PERL_PATCHLEVEL_H_IMPLICIT
03167 #    include <patchlevel.h>
03168 #  endif
03169 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
03170 #    include <could_not_find_Perl_patchlevel.h>
03171 #  endif
03172 #  ifndef PERL_REVISION
03173 #    define PERL_REVISION       (5)
03174      /* Replace: 1 */
03175 #    define PERL_VERSION        PATCHLEVEL
03176 #    define PERL_SUBVERSION     SUBVERSION
03177      /* Replace PERL_PATCHLEVEL with PERL_VERSION */
03178      /* Replace: 0 */
03179 #  endif
03180 #endif
03181 
03182 #define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
03183 #define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))
03184 
03185 /* It is very unlikely that anyone will try to use this with Perl 6
03186    (or greater), but who knows.
03187  */
03188 #if PERL_REVISION != 5
03189 #  error ppport.h only works with Perl version 5
03190 #endif /* PERL_REVISION != 5 */
03191 #ifndef dTHR
03192 #  define dTHR                           dNOOP
03193 #endif
03194 #ifndef dTHX
03195 #  define dTHX                           dNOOP
03196 #endif
03197 
03198 #ifndef dTHXa
03199 #  define dTHXa(x)                       dNOOP
03200 #endif
03201 #ifndef pTHX
03202 #  define pTHX                           void
03203 #endif
03204 
03205 #ifndef pTHX_
03206 #  define pTHX_
03207 #endif
03208 
03209 #ifndef aTHX
03210 #  define aTHX
03211 #endif
03212 
03213 #ifndef aTHX_
03214 #  define aTHX_
03215 #endif
03216 
03217 #if (PERL_BCDVERSION < 0x5006000)
03218 #  ifdef USE_THREADS
03219 #    define aTHXR  thr
03220 #    define aTHXR_ thr,
03221 #  else
03222 #    define aTHXR
03223 #    define aTHXR_
03224 #  endif
03225 #  define dTHXR  dTHR
03226 #else
03227 #  define aTHXR  aTHX
03228 #  define aTHXR_ aTHX_
03229 #  define dTHXR  dTHX
03230 #endif
03231 #ifndef dTHXoa
03232 #  define dTHXoa(x)                      dTHXa(x)
03233 #endif
03234 
03235 #ifdef I_LIMITS
03236 #  include <limits.h>
03237 #endif
03238 
03239 #ifndef PERL_UCHAR_MIN
03240 #  define PERL_UCHAR_MIN ((unsigned char)0)
03241 #endif
03242 
03243 #ifndef PERL_UCHAR_MAX
03244 #  ifdef UCHAR_MAX
03245 #    define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
03246 #  else
03247 #    ifdef MAXUCHAR
03248 #      define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)
03249 #    else
03250 #      define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)
03251 #    endif
03252 #  endif
03253 #endif
03254 
03255 #ifndef PERL_USHORT_MIN
03256 #  define PERL_USHORT_MIN ((unsigned short)0)
03257 #endif
03258 
03259 #ifndef PERL_USHORT_MAX
03260 #  ifdef USHORT_MAX
03261 #    define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)
03262 #  else
03263 #    ifdef MAXUSHORT
03264 #      define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)
03265 #    else
03266 #      ifdef USHRT_MAX
03267 #        define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
03268 #      else
03269 #        define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)
03270 #      endif
03271 #    endif
03272 #  endif
03273 #endif
03274 
03275 #ifndef PERL_SHORT_MAX
03276 #  ifdef SHORT_MAX
03277 #    define PERL_SHORT_MAX ((short)SHORT_MAX)
03278 #  else
03279 #    ifdef MAXSHORT    /* Often used in <values.h> */
03280 #      define PERL_SHORT_MAX ((short)MAXSHORT)
03281 #    else
03282 #      ifdef SHRT_MAX
03283 #        define PERL_SHORT_MAX ((short)SHRT_MAX)
03284 #      else
03285 #        define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))
03286 #      endif
03287 #    endif
03288 #  endif
03289 #endif
03290 
03291 #ifndef PERL_SHORT_MIN
03292 #  ifdef SHORT_MIN
03293 #    define PERL_SHORT_MIN ((short)SHORT_MIN)
03294 #  else
03295 #    ifdef MINSHORT
03296 #      define PERL_SHORT_MIN ((short)MINSHORT)
03297 #    else
03298 #      ifdef SHRT_MIN
03299 #        define PERL_SHORT_MIN ((short)SHRT_MIN)
03300 #      else
03301 #        define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))
03302 #      endif
03303 #    endif
03304 #  endif
03305 #endif
03306 
03307 #ifndef PERL_UINT_MAX
03308 #  ifdef UINT_MAX
03309 #    define PERL_UINT_MAX ((unsigned int)UINT_MAX)
03310 #  else
03311 #    ifdef MAXUINT
03312 #      define PERL_UINT_MAX ((unsigned int)MAXUINT)
03313 #    else
03314 #      define PERL_UINT_MAX (~(unsigned int)0)
03315 #    endif
03316 #  endif
03317 #endif
03318 
03319 #ifndef PERL_UINT_MIN
03320 #  define PERL_UINT_MIN ((unsigned int)0)
03321 #endif
03322 
03323 #ifndef PERL_INT_MAX
03324 #  ifdef INT_MAX
03325 #    define PERL_INT_MAX ((int)INT_MAX)
03326 #  else
03327 #    ifdef MAXINT    /* Often used in <values.h> */
03328 #      define PERL_INT_MAX ((int)MAXINT)
03329 #    else
03330 #      define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))
03331 #    endif
03332 #  endif
03333 #endif
03334 
03335 #ifndef PERL_INT_MIN
03336 #  ifdef INT_MIN
03337 #    define PERL_INT_MIN ((int)INT_MIN)
03338 #  else
03339 #    ifdef MININT
03340 #      define PERL_INT_MIN ((int)MININT)
03341 #    else
03342 #      define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))
03343 #    endif
03344 #  endif
03345 #endif
03346 
03347 #ifndef PERL_ULONG_MAX
03348 #  ifdef ULONG_MAX
03349 #    define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
03350 #  else
03351 #    ifdef MAXULONG
03352 #      define PERL_ULONG_MAX ((unsigned long)MAXULONG)
03353 #    else
03354 #      define PERL_ULONG_MAX (~(unsigned long)0)
03355 #    endif
03356 #  endif
03357 #endif
03358 
03359 #ifndef PERL_ULONG_MIN
03360 #  define PERL_ULONG_MIN ((unsigned long)0L)
03361 #endif
03362 
03363 #ifndef PERL_LONG_MAX
03364 #  ifdef LONG_MAX
03365 #    define PERL_LONG_MAX ((long)LONG_MAX)
03366 #  else
03367 #    ifdef MAXLONG
03368 #      define PERL_LONG_MAX ((long)MAXLONG)
03369 #    else
03370 #      define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))
03371 #    endif
03372 #  endif
03373 #endif
03374 
03375 #ifndef PERL_LONG_MIN
03376 #  ifdef LONG_MIN
03377 #    define PERL_LONG_MIN ((long)LONG_MIN)
03378 #  else
03379 #    ifdef MINLONG
03380 #      define PERL_LONG_MIN ((long)MINLONG)
03381 #    else
03382 #      define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))
03383 #    endif
03384 #  endif
03385 #endif
03386 
03387 #if defined(HAS_QUAD) && (defined(convex) || defined(uts))
03388 #  ifndef PERL_UQUAD_MAX
03389 #    ifdef ULONGLONG_MAX
03390 #      define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)
03391 #    else
03392 #      ifdef MAXULONGLONG
03393 #        define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)
03394 #      else
03395 #        define PERL_UQUAD_MAX (~(unsigned long long)0)
03396 #      endif
03397 #    endif
03398 #  endif
03399 
03400 #  ifndef PERL_UQUAD_MIN
03401 #    define PERL_UQUAD_MIN ((unsigned long long)0L)
03402 #  endif
03403 
03404 #  ifndef PERL_QUAD_MAX
03405 #    ifdef LONGLONG_MAX
03406 #      define PERL_QUAD_MAX ((long long)LONGLONG_MAX)
03407 #    else
03408 #      ifdef MAXLONGLONG
03409 #        define PERL_QUAD_MAX ((long long)MAXLONGLONG)
03410 #      else
03411 #        define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))
03412 #      endif
03413 #    endif
03414 #  endif
03415 
03416 #  ifndef PERL_QUAD_MIN
03417 #    ifdef LONGLONG_MIN
03418 #      define PERL_QUAD_MIN ((long long)LONGLONG_MIN)
03419 #    else
03420 #      ifdef MINLONGLONG
03421 #        define PERL_QUAD_MIN ((long long)MINLONGLONG)
03422 #      else
03423 #        define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
03424 #      endif
03425 #    endif
03426 #  endif
03427 #endif
03428 
03429 /* This is based on code from 5.003 perl.h */
03430 #ifdef HAS_QUAD
03431 #  ifdef cray
03432 #ifndef IVTYPE
03433 #  define IVTYPE                         int
03434 #endif
03435 
03436 #ifndef IV_MIN
03437 #  define IV_MIN                         PERL_INT_MIN
03438 #endif
03439 
03440 #ifndef IV_MAX
03441 #  define IV_MAX                         PERL_INT_MAX
03442 #endif
03443 
03444 #ifndef UV_MIN
03445 #  define UV_MIN                         PERL_UINT_MIN
03446 #endif
03447 
03448 #ifndef UV_MAX
03449 #  define UV_MAX                         PERL_UINT_MAX
03450 #endif
03451 
03452 #    ifdef INTSIZE
03453 #ifndef IVSIZE
03454 #  define IVSIZE                         INTSIZE
03455 #endif
03456 
03457 #    endif
03458 #  else
03459 #    if defined(convex) || defined(uts)
03460 #ifndef IVTYPE
03461 #  define IVTYPE                         long long
03462 #endif
03463 
03464 #ifndef IV_MIN
03465 #  define IV_MIN                         PERL_QUAD_MIN
03466 #endif
03467 
03468 #ifndef IV_MAX
03469 #  define IV_MAX                         PERL_QUAD_MAX
03470 #endif
03471 
03472 #ifndef UV_MIN
03473 #  define UV_MIN                         PERL_UQUAD_MIN
03474 #endif
03475 
03476 #ifndef UV_MAX
03477 #  define UV_MAX                         PERL_UQUAD_MAX
03478 #endif
03479 
03480 #      ifdef LONGLONGSIZE
03481 #ifndef IVSIZE
03482 #  define IVSIZE                         LONGLONGSIZE
03483 #endif
03484 
03485 #      endif
03486 #    else
03487 #ifndef IVTYPE
03488 #  define IVTYPE                         long
03489 #endif
03490 
03491 #ifndef IV_MIN
03492 #  define IV_MIN                         PERL_LONG_MIN
03493 #endif
03494 
03495 #ifndef IV_MAX
03496 #  define IV_MAX                         PERL_LONG_MAX
03497 #endif
03498 
03499 #ifndef UV_MIN
03500 #  define UV_MIN                         PERL_ULONG_MIN
03501 #endif
03502 
03503 #ifndef UV_MAX
03504 #  define UV_MAX                         PERL_ULONG_MAX
03505 #endif
03506 
03507 #      ifdef LONGSIZE
03508 #ifndef IVSIZE
03509 #  define IVSIZE                         LONGSIZE
03510 #endif
03511 
03512 #      endif
03513 #    endif
03514 #  endif
03515 #ifndef IVSIZE
03516 #  define IVSIZE                         8
03517 #endif
03518 
03519 #ifndef PERL_QUAD_MIN
03520 #  define PERL_QUAD_MIN                  IV_MIN
03521 #endif
03522 
03523 #ifndef PERL_QUAD_MAX
03524 #  define PERL_QUAD_MAX                  IV_MAX
03525 #endif
03526 
03527 #ifndef PERL_UQUAD_MIN
03528 #  define PERL_UQUAD_MIN                 UV_MIN
03529 #endif
03530 
03531 #ifndef PERL_UQUAD_MAX
03532 #  define PERL_UQUAD_MAX                 UV_MAX
03533 #endif
03534 
03535 #else
03536 #ifndef IVTYPE
03537 #  define IVTYPE                         long
03538 #endif
03539 
03540 #ifndef IV_MIN
03541 #  define IV_MIN                         PERL_LONG_MIN
03542 #endif
03543 
03544 #ifndef IV_MAX
03545 #  define IV_MAX                         PERL_LONG_MAX
03546 #endif
03547 
03548 #ifndef UV_MIN
03549 #  define UV_MIN                         PERL_ULONG_MIN
03550 #endif
03551 
03552 #ifndef UV_MAX
03553 #  define UV_MAX                         PERL_ULONG_MAX
03554 #endif
03555 
03556 #endif
03557 
03558 #ifndef IVSIZE
03559 #  ifdef LONGSIZE
03560 #    define IVSIZE LONGSIZE
03561 #  else
03562 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
03563 #  endif
03564 #endif
03565 #ifndef UVTYPE
03566 #  define UVTYPE                         unsigned IVTYPE
03567 #endif
03568 
03569 #ifndef UVSIZE
03570 #  define UVSIZE                         IVSIZE
03571 #endif
03572 #ifndef sv_setuv
03573 #  define sv_setuv(sv, uv)               \
03574                STMT_START {                         \
03575                  UV TeMpUv = uv;                    \
03576                  if (TeMpUv <= IV_MAX)              \
03577                    sv_setiv(sv, TeMpUv);            \
03578                  else                               \
03579                    sv_setnv(sv, (double)TeMpUv);    \
03580                } STMT_END
03581 #endif
03582 #ifndef newSVuv
03583 #  define newSVuv(uv)                    ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
03584 #endif
03585 #ifndef sv_2uv
03586 #  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
03587 #endif
03588 
03589 #ifndef SvUVX
03590 #  define SvUVX(sv)                      ((UV)SvIVX(sv))
03591 #endif
03592 
03593 #ifndef SvUVXx
03594 #  define SvUVXx(sv)                     SvUVX(sv)
03595 #endif
03596 
03597 #ifndef SvUV
03598 #  define SvUV(sv)                       (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
03599 #endif
03600 
03601 #ifndef SvUVx
03602 #  define SvUVx(sv)                      ((PL_Sv = (sv)), SvUV(PL_Sv))
03603 #endif
03604 
03605 /* Hint: sv_uv
03606  * Always use the SvUVx() macro instead of sv_uv().
03607  */
03608 #ifndef sv_uv
03609 #  define sv_uv(sv)                      SvUVx(sv)
03610 #endif
03611 
03612 #if !defined(SvUOK) && defined(SvIOK_UV)
03613 #  define SvUOK(sv) SvIOK_UV(sv)
03614 #endif
03615 #ifndef XST_mUV
03616 #  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )
03617 #endif
03618 
03619 #ifndef XSRETURN_UV
03620 #  define XSRETURN_UV(v)                 STMT_START { XST_mUV(0,v);  XSRETURN(1); } STMT_END
03621 #endif
03622 #ifndef PUSHu
03623 #  define PUSHu(u)                       STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG;  } STMT_END
03624 #endif
03625 
03626 #ifndef XPUSHu
03627 #  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
03628 #endif
03629 
03630 #ifdef HAS_MEMCMP
03631 #ifndef memNE
03632 #  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))
03633 #endif
03634 
03635 #ifndef memEQ
03636 #  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))
03637 #endif
03638 
03639 #else
03640 #ifndef memNE
03641 #  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))
03642 #endif
03643 
03644 #ifndef memEQ
03645 #  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))
03646 #endif
03647 
03648 #endif
03649 #ifndef MoveD
03650 #  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))
03651 #endif
03652 
03653 #ifndef CopyD
03654 #  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
03655 #endif
03656 
03657 #ifdef HAS_MEMSET
03658 #ifndef ZeroD
03659 #  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))
03660 #endif
03661 
03662 #else
03663 #ifndef ZeroD
03664 #  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)), d)
03665 #endif
03666 
03667 #endif
03668 #ifndef PoisonWith
03669 #  define PoisonWith(d,n,t,b)            (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
03670 #endif
03671 
03672 #ifndef PoisonNew
03673 #  define PoisonNew(d,n,t)               PoisonWith(d,n,t,0xAB)
03674 #endif
03675 
03676 #ifndef PoisonFree
03677 #  define PoisonFree(d,n,t)              PoisonWith(d,n,t,0xEF)
03678 #endif
03679 
03680 #ifndef Poison
03681 #  define Poison(d,n,t)                  PoisonFree(d,n,t)
03682 #endif
03683 #ifndef Newx
03684 #  define Newx(v,n,t)                    New(0,v,n,t)
03685 #endif
03686 
03687 #ifndef Newxc
03688 #  define Newxc(v,n,t,c)                 Newc(0,v,n,t,c)
03689 #endif
03690 
03691 #ifndef Newxz
03692 #  define Newxz(v,n,t)                   Newz(0,v,n,t)
03693 #endif
03694 
03695 #ifndef PERL_UNUSED_DECL
03696 #  ifdef HASATTRIBUTE
03697 #    if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
03698 #      define PERL_UNUSED_DECL
03699 #    else
03700 #      define PERL_UNUSED_DECL __attribute__((unused))
03701 #    endif
03702 #  else
03703 #    define PERL_UNUSED_DECL
03704 #  endif
03705 #endif
03706 
03707 #ifndef PERL_UNUSED_ARG
03708 #  if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
03709 #    include <note.h>
03710 #    define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
03711 #  else
03712 #    define PERL_UNUSED_ARG(x) ((void)x)
03713 #  endif
03714 #endif
03715 
03716 #ifndef PERL_UNUSED_VAR
03717 #  define PERL_UNUSED_VAR(x) ((void)x)
03718 #endif
03719 
03720 #ifndef PERL_UNUSED_CONTEXT
03721 #  ifdef USE_ITHREADS
03722 #    define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
03723 #  else
03724 #    define PERL_UNUSED_CONTEXT
03725 #  endif
03726 #endif
03727 #ifndef NOOP
03728 #  define NOOP                           /*EMPTY*/(void)0
03729 #endif
03730 
03731 #ifndef dNOOP
03732 #  define dNOOP                          extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL
03733 #endif
03734 
03735 #ifndef NVTYPE
03736 #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
03737 #    define NVTYPE long double
03738 #  else
03739 #    define NVTYPE double
03740 #  endif
03741 typedef NVTYPE NV;
03742 #endif
03743 
03744 #ifndef INT2PTR
03745 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
03746 #    define PTRV                  UV
03747 #    define INT2PTR(any,d)        (any)(d)
03748 #  else
03749 #    if PTRSIZE == LONGSIZE
03750 #      define PTRV                unsigned long
03751 #    else
03752 #      define PTRV                unsigned
03753 #    endif
03754 #    define INT2PTR(any,d)        (any)(PTRV)(d)
03755 #  endif
03756 #endif
03757 
03758 #ifndef PTR2ul
03759 #  if PTRSIZE == LONGSIZE
03760 #    define PTR2ul(p)     (unsigned long)(p)
03761 #  else
03762 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
03763 #  endif
03764 #endif
03765 #ifndef PTR2nat
03766 #  define PTR2nat(p)                     (PTRV)(p)
03767 #endif
03768 
03769 #ifndef NUM2PTR
03770 #  define NUM2PTR(any,d)                 (any)PTR2nat(d)
03771 #endif
03772 
03773 #ifndef PTR2IV
03774 #  define PTR2IV(p)                      INT2PTR(IV,p)
03775 #endif
03776 
03777 #ifndef PTR2UV
03778 #  define PTR2UV(p)                      INT2PTR(UV,p)
03779 #endif
03780 
03781 #ifndef PTR2NV
03782 #  define PTR2NV(p)                      NUM2PTR(NV,p)
03783 #endif
03784 
03785 #undef START_EXTERN_C
03786 #undef END_EXTERN_C
03787 #undef EXTERN_C
03788 #ifdef __cplusplus
03789 #  define START_EXTERN_C extern "C" {
03790 #  define END_EXTERN_C }
03791 #  define EXTERN_C extern "C"
03792 #else
03793 #  define START_EXTERN_C
03794 #  define END_EXTERN_C
03795 #  define EXTERN_C extern
03796 #endif
03797 
03798 #if defined(PERL_GCC_PEDANTIC)
03799 #  ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
03800 #    define PERL_GCC_BRACE_GROUPS_FORBIDDEN
03801 #  endif
03802 #endif
03803 
03804 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
03805 #  ifndef PERL_USE_GCC_BRACE_GROUPS
03806 #    define PERL_USE_GCC_BRACE_GROUPS
03807 #  endif
03808 #endif
03809 
03810 #undef STMT_START
03811 #undef STMT_END
03812 #ifdef PERL_USE_GCC_BRACE_GROUPS
03813 #  define STMT_START    (void)( /* gcc supports ``({ STATEMENTS; })'' */
03814 #  define STMT_END      )
03815 #else
03816 #  if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)
03817 #    define STMT_START  if (1)
03818 #    define STMT_END    else (void)0
03819 #  else
03820 #    define STMT_START  do
03821 #    define STMT_END    while (0)
03822 #  endif
03823 #endif
03824 #ifndef boolSV
03825 #  define boolSV(b)                      ((b) ? &PL_sv_yes : &PL_sv_no)
03826 #endif
03827 
03828 /* DEFSV appears first in 5.004_56 */
03829 #ifndef DEFSV
03830 #  define DEFSV                          GvSV(PL_defgv)
03831 #endif
03832 
03833 #ifndef SAVE_DEFSV
03834 #  define SAVE_DEFSV                     SAVESPTR(GvSV(PL_defgv))
03835 #endif
03836 
03837 #ifndef DEFSV_set
03838 #  define DEFSV_set(sv)                  (DEFSV = (sv))
03839 #endif
03840 
03841 /* Older perls (<=5.003) lack AvFILLp */
03842 #ifndef AvFILLp
03843 #  define AvFILLp                        AvFILL
03844 #endif
03845 #ifndef ERRSV
03846 #  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 PERL_ABS
#  define PERL_ABS(x)                    ((x) < 0 ? -(x) : (x))
#endif
#ifndef dVAR
#  define dVAR                           dNOOP
#endif
#ifndef SVf
#  define SVf                            "_"
03847 #endif
03848 #ifndef UTF8_MAXBYTES
03849 #  define UTF8_MAXBYTES                  UTF8_MAXLEN
03850 #endif
03851 #ifndef CPERLscope
03852 #  define CPERLscope(x)                  x
03853 #endif
03854 #ifndef PERL_HASH
03855 #  define PERL_HASH(hash,str,len)        \
03856      STMT_START { \
03857         const char *s_PeRlHaSh = str; \
03858         I32 i_PeRlHaSh = len; \
03859         U32 hash_PeRlHaSh = 0; \
03860         while (i_PeRlHaSh--) \
03861             hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \
03862         (hash) = hash_PeRlHaSh; \
03863     } STMT_END
03864 #endif
03865 
03866 #ifndef PERLIO_FUNCS_DECL
03867 # ifdef PERLIO_FUNCS_CONST
03868 #  define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
03869 #  define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
03870 # else
03871 #  define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs
03872 #  define PERLIO_FUNCS_CAST(funcs) (funcs)
03873 # endif
03874 #endif
03875 
03876 /* provide these typedefs for older perls */
03877 #if (PERL_BCDVERSION < 0x5009003)
03878 
03879 # ifdef ARGSproto
03880 typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto);
03881 # else
03882 typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
03883 # endif
03884 
03885 typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
03886 
03887 #endif
03888 #ifndef isPSXSPC
03889 #  define isPSXSPC(c)                    (isSPACE(c) || (c) == '\v')
03890 #endif
03891 
03892 #ifndef isBLANK
03893 #  define isBLANK(c)                     ((c) == ' ' || (c) == '\t')
03894 #endif
03895 
03896 #ifdef EBCDIC
03897 #ifndef isALNUMC
03898 #  define isALNUMC(c)                    isalnum(c)
03899 #endif
03900 
03901 #ifndef isASCII
03902 #  define isASCII(c)                     isascii(c)
03903 #endif
03904 
03905 #ifndef isCNTRL
03906 #  define isCNTRL(c)                     iscntrl(c)
03907 #endif
03908 
03909 #ifndef isGRAPH
03910 #  define isGRAPH(c)                     isgraph(c)
03911 #endif
03912 
03913 #ifndef isPRINT
03914 #  define isPRINT(c)                     isprint(c)
03915 #endif
03916 
03917 #ifndef isPUNCT
03918 #  define isPUNCT(c)                     ispunct(c)
03919 #endif
03920 
03921 #ifndef isXDIGIT
03922 #  define isXDIGIT(c)                    isxdigit(c)
03923 #endif
03924 
03925 #else
03926 # if (PERL_BCDVERSION < 0x5010000)
03927 /* Hint: isPRINT
03928  * The implementation in older perl versions includes all of the
03929  * isSPACE() characters, which is wrong. The version provided by
03930  * Devel::PPPort always overrides a present buggy version.
03931  */
03932 #  undef isPRINT
03933 # endif
03934 #ifndef isALNUMC
03935 #  define isALNUMC(c)                    (isALPHA(c) || isDIGIT(c))
03936 #endif
03937 
03938 #ifndef isASCII
03939 #  define isASCII(c)                     ((c) <= 127)
03940 #endif
03941 
03942 #ifndef isCNTRL
03943 #  define isCNTRL(c)                     ((c) < ' ' || (c) == 127)
03944 #endif
03945 
03946 #ifndef isGRAPH
03947 #  define isGRAPH(c)                     (isALNUM(c) || isPUNCT(c))
03948 #endif
03949 
03950 #ifndef isPRINT
03951 #  define isPRINT(c)                     (((c) >= 32 && (c) < 127))
03952 #endif
03953 
03954 #ifndef isPUNCT
03955 #  define isPUNCT(c)                     (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64)  || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
03956 #endif
03957 
03958 #ifndef isXDIGIT
03959 #  define isXDIGIT(c)                    (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
03960 #endif
03961 
03962 #endif
03963 
03964 #ifndef PERL_SIGNALS_UNSAFE_FLAG
03965 
03966 #define PERL_SIGNALS_UNSAFE_FLAG 0x0001
03967 
03968 #if (PERL_BCDVERSION < 0x5008000)
03969 #  define D_PPP_PERL_SIGNALS_INIT   PERL_SIGNALS_UNSAFE_FLAG
03970 #else
03971 #  define D_PPP_PERL_SIGNALS_INIT   0
03972 #endif
03973 
03974 #if defined(NEED_PL_signals)
03975 static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
03976 #elif defined(NEED_PL_signals_GLOBAL)
03977 U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
03978 #else
03979 extern U32 DPPP_(my_PL_signals);
03980 #endif
03981 #define PL_signals DPPP_(my_PL_signals)
03982 
03983 #endif
03984 
03985 /* Hint: PL_ppaddr
03986  * Calling an op via PL_ppaddr requires passing a context argument
03987  * for threaded builds. Since the context argument is different for
03988  * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
03989  * automatically be defined as the correct argument.
03990  */
03991 
03992 #if (PERL_BCDVERSION <= 0x5005005)
03993 /* Replace: 1 */
03994 #  define PL_ppaddr                 ppaddr
03995 #  define PL_no_modify              no_modify
03996 /* Replace: 0 */
03997 #endif
03998 
03999 #if (PERL_BCDVERSION <= 0x5004005)
04000 /* Replace: 1 */
04001 #  define PL_DBsignal               DBsignal
04002 #  define PL_DBsingle               DBsingle
04003 #  define PL_DBsub                  DBsub
04004 #  define PL_DBtrace                DBtrace
04005 #  define PL_Sv                     Sv
04006 #  define PL_bufend                 bufend
04007 #  define PL_bufptr                 bufptr
04008 #  define PL_compiling              compiling
04009 #  define PL_copline                copline
04010 #  define PL_curcop                 curcop
04011 #  define PL_curstash               curstash
04012 #  define PL_debstash               debstash
04013 #  define PL_defgv                  defgv
04014 #  define PL_diehook                diehook
04015 #  define PL_dirty                  dirty
04016 #  define PL_dowarn                 dowarn
04017 #  define PL_errgv                  errgv
04018 #  define PL_expect                 expect
04019 #  define PL_hexdigit               hexdigit
04020 #  define PL_hints                  hints
04021 #  define PL_laststatval            laststatval
04022 #  define PL_lex_state              lex_state
04023 #  define PL_lex_stuff              lex_stuff
04024 #  define PL_linestr                linestr
04025 #  define PL_na                     na
04026 #  define PL_perl_destruct_level    perl_destruct_level
04027 #  define PL_perldb                 perldb
04028 #  define PL_rsfp_filters           rsfp_filters
04029 #  define PL_rsfp                   rsfp
04030 #  define PL_stack_base             stack_base
04031 #  define PL_stack_sp               stack_sp
04032 #  define PL_statcache              statcache
04033 #  define PL_stdingv                stdingv
04034 #  define PL_sv_arenaroot           sv_arenaroot
04035 #  define PL_sv_no                  sv_no
04036 #  define PL_sv_undef               sv_undef
04037 #  define PL_sv_yes                 sv_yes
04038 #  define PL_tainted                tainted
04039 #  define PL_tainting               tainting
04040 #  define PL_tokenbuf               tokenbuf
04041 /* Replace: 0 */
04042 #endif
04043 
04044 /* Warning: PL_parser
04045  * For perl versions earlier than 5.9.5, this is an always
04046  * non-NULL dummy. Also, it cannot be dereferenced. Don't
04047  * use it if you can avoid is and unless you absolutely know
04048  * what you're doing.
04049  * If you always check that PL_parser is non-NULL, you can
04050  * define DPPP_PL_parser_NO_DUMMY to avoid the creation of
04051  * a dummy parser structure.
04052  */
04053 
04054 #if (PERL_BCDVERSION >= 0x5009005)
04055 # ifdef DPPP_PL_parser_NO_DUMMY
04056 #  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
04057                 (croak("panic: PL_parser == NULL in %s:%d", \
04058                        __FILE__, __LINE__), (yy_parser *) NULL))->var)
04059 # else
04060 #  ifdef DPPP_PL_parser_NO_DUMMY_WARNING
04061 #   define D_PPP_parser_dummy_warning(var)
04062 #  else
04063 #   define D_PPP_parser_dummy_warning(var) \
04064              warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
04065 #  endif
04066 #  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
04067                 (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
04068 #if defined(NEED_PL_parser)
04069 static yy_parser DPPP_(dummy_PL_parser);
04070 #elif defined(NEED_PL_parser_GLOBAL)
04071 yy_parser DPPP_(dummy_PL_parser);
04072 #else
04073 extern yy_parser DPPP_(dummy_PL_parser);
04074 #endif
04075 
04076 # endif
04077 
04078 /* 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 */
04079 /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
04080  * Do not use this variable unless you know exactly what you're
04081  * doint. It is internal to the perl parser and may change or even
04082  * be removed in the future. As of perl 5.9.5, you have to check
04083  * for (PL_parser != NULL) for this variable to have any effect.
04084  * An always non-NULL PL_parser dummy is provided for earlier
04085  * perl versions.
04086  * If PL_parser is NULL when you try to access this variable, a
04087  * dummy is being accessed instead and a warning is issued unless
04088  * you define DPPP_PL_parser_NO_DUMMY_WARNING.
04089  * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
04090  * this variable will croak with a panic message.
04091  */
04092 
04093 # define PL_expect         D_PPP_my_PL_parser_var(expect)
04094 # define PL_copline        D_PPP_my_PL_parser_var(copline)
04095 # define PL_rsfp           D_PPP_my_PL_parser_var(rsfp)
04096 # define PL_rsfp_filters   D_PPP_my_PL_parser_var(rsfp_filters)
04097 # define PL_linestr        D_PPP_my_PL_parser_var(linestr)
04098 # define PL_bufptr         D_PPP_my_PL_parser_var(bufptr)
04099 # define PL_bufend         D_PPP_my_PL_parser_var(bufend)
04100 # define PL_lex_state      D_PPP_my_PL_parser_var(lex_state)
04101 # define PL_lex_stuff      D_PPP_my_PL_parser_var(lex_stuff)
04102 # define PL_tokenbuf       D_PPP_my_PL_parser_var(tokenbuf)
04103 
04104 #else
04105 
04106 /* ensure that PL_parser != NULL and cannot be dereferenced */
04107 # define PL_parser         ((void *) 1)
04108 
04109 #endif
04110 #ifndef mPUSHs
04111 #  define mPUSHs(s)                      PUSHs(sv_2mortal(s))
04112 #endif
04113 
04114 #ifndef PUSHmortal
04115 #  define PUSHmortal                     PUSHs(sv_newmortal())
04116 #endif
04117 
04118 #ifndef mPUSHp
04119 #  define mPUSHp(p,l)                    sv_setpvn(PUSHmortal, (p), (l))
04120 #endif
04121 
04122 #ifndef mPUSHn
04123 #  define mPUSHn(n)                      sv_setnv(PUSHmortal, (NV)(n))
04124 #endif
04125 
04126 #ifndef mPUSHi
04127 #  define mPUSHi(i)                      sv_setiv(PUSHmortal, (IV)(i))
04128 #endif
04129 
04130 #ifndef mPUSHu
04131 #  define mPUSHu(u)                      sv_setuv(PUSHmortal, (UV)(u))
04132 #endif
04133 #ifndef mXPUSHs
04134 #  define mXPUSHs(s)                     XPUSHs(sv_2mortal(s))
04135 #endif
04136 
04137 #ifndef XPUSHmortal
04138 #  define XPUSHmortal                    XPUSHs(sv_newmortal())
04139 #endif
04140 
04141 #ifndef mXPUSHp
04142 #  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
04143 #endif
04144 
04145 #ifndef mXPUSHn
04146 #  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
04147 #endif
04148 
04149 #ifndef mXPUSHi
04150 #  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
04151 #endif
04152 
04153 #ifndef mXPUSHu
04154 #  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
04155 #endif
04156 
04157 /* Replace: 1 */
04158 #ifndef call_sv
04159 #  define call_sv                        perl_call_sv
04160 #endif
04161 
04162 #ifndef call_pv
04163 #  define call_pv                        perl_call_pv
04164 #endif
04165 
04166 #ifndef call_argv
04167 #  define call_argv                      perl_call_argv
04168 #endif
04169 
04170 #ifndef call_method
04171 #  define call_method                    perl_call_method
04172 #endif
04173 #ifndef eval_sv
04174 #  define eval_sv                        perl_eval_sv
04175 #endif
04176 
04177 /* Replace: 0 */
04178 #ifndef PERL_LOADMOD_DENY
04179 #  define PERL_LOADMOD_DENY              0x1
04180 #endif
04181 
04182 #ifndef PERL_LOADMOD_NOIMPORT
04183 #  define PERL_LOADMOD_NOIMPORT          0x2
04184 #endif
04185 
04186 #ifndef PERL_LOADMOD_IMPORT_OPS
04187 #  define PERL_LOADMOD_IMPORT_OPS        0x4
04188 #endif
04189 
04190 #ifndef G_METHOD
04191 # define G_METHOD               64
04192 # ifdef call_sv
04193 #  undef call_sv
04194 # endif
04195 # if (PERL_BCDVERSION < 0x5006000)
04196 #  define call_sv(sv, flags)  ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
04197                                 (flags) & ~G_METHOD) : perl_call_sv(sv, flags))
04198 # else
04199 #  define call_sv(sv, flags)  ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
04200                                 (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
04201 # endif
04202 #endif
04203 
04204 /* Replace perl_eval_pv with eval_pv */
04205 
04206 #ifndef eval_pv
04207 #if defined(NEED_eval_pv)
04208 static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
04209 static
04210 #else
04211 extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
04212 #endif
04213 
04214 #ifdef eval_pv
04215 #  undef eval_pv
04216 #endif
04217 #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
04218 #define Perl_eval_pv DPPP_(my_eval_pv)
04219 
04220 #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
04221 
04222 SV*
04223 DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
04224 {
04225     dSP;
04226     SV* sv = newSVpv(p, 0);
04227 
04228     PUSHMARK(sp);
04229     eval_sv(sv, G_SCALAR);
04230     SvREFCNT_dec(sv);
04231 
04232     SPAGAIN;
04233     sv = POPs;
04234     PUTBACK;
04235 
04236     if (croak_on_error && SvTRUE(GvSV(errgv)))
04237         croak(SvPVx(GvSV(errgv), na));
04238 
04239     return sv;
04240 }
04241 
04242 #endif
04243 #endif
04244 
04245 #ifndef vload_module
04246 #if defined(NEED_vload_module)
04247 static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
04248 static
04249 #else
04250 extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
04251 #endif
04252 
04253 #ifdef vload_module
04254 #  undef vload_module
04255 #endif
04256 #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
04257 #define Perl_vload_module DPPP_(my_vload_module)
04258 
04259 #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
04260 
04261 void
04262 DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
04263 {
04264     dTHR;
04265     dVAR;
04266     OP *veop, *imop;
04267 
04268     OP * const modname = newSVOP(OP_CONST, 0, name);
04269     /* 5.005 has a somewhat hacky force_normal that doesn't croak on
04270        SvREADONLY() if PL_compling is true. Current perls take care in
04271        ck_require() to correctly turn off SvREADONLY before calling
04272        force_normal_flags(). This seems a better fix than fudging PL_compling
04273      */
04274     SvREADONLY_off(((SVOP*)modname)->op_sv);
04275     modname->op_private |= OPpCONST_BARE;
04276     if (ver) {
04277         veop = newSVOP(OP_CONST, 0, ver);
04278     }
04279     else
04280         veop = NULL;
04281     if (flags & PERL_LOADMOD_NOIMPORT) {
04282         imop = sawparens(newNULLLIST());
04283     }
04284     else if (flags & PERL_LOADMOD_IMPORT_OPS) {
04285         imop = va_arg(*args, OP*);
04286     }
04287     else {
04288         SV *sv;
04289         imop = NULL;
04290         sv = va_arg(*args, SV*);
04291         while (sv) {
04292             imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
04293             sv = va_arg(*args, SV*);
04294         }
04295     }
04296     {
04297         const line_t ocopline = PL_copline;
04298         COP * const ocurcop = PL_curcop;
04299         const int oexpect = PL_expect;
04300 
04301 #if (PERL_BCDVERSION >= 0x5004000)
04302         utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
04303                 veop, modname, imop);
04304 #else
04305         utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
04306                 modname, imop);
04307 #endif
04308         PL_expect = oexpect;
04309         PL_copline = ocopline;
04310         PL_curcop = ocurcop;
04311     }
04312 }
04313 
04314 #endif
04315 #endif
04316 
04317 #ifndef load_module
04318 #if defined(NEED_load_module)
04319 static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
04320 static
04321 #else
04322 extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
04323 #endif
04324 
04325 #ifdef load_module
04326 #  undef load_module
04327 #endif
04328 #define load_module DPPP_(my_load_module)
04329 #define Perl_load_module DPPP_(my_load_module)
04330 
04331 #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
04332 
04333 void
04334 DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
04335 {
04336     va_list args;
04337     va_start(args, ver);
04338     vload_module(flags, name, ver, &args);
04339     va_end(args);
04340 }
04341 
04342 #endif
04343 #endif
04344 #ifndef newRV_inc
04345 #  define newRV_inc(sv)                  newRV(sv)   /* Replace */
04346 #endif
04347 
04348 #ifndef newRV_noinc
04349 #if defined(NEED_newRV_noinc)
04350 static SV * DPPP_(my_newRV_noinc)(SV *sv);
04351 static
04352 #else
04353 extern SV * DPPP_(my_newRV_noinc)(SV *sv);
04354 #endif
04355 
04356 #ifdef newRV_noinc
04357 #  undef newRV_noinc
04358 #endif
04359 #define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
04360 #define Perl_newRV_noinc DPPP_(my_newRV_noinc)
04361 
04362 #if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
04363 SV *
04364 DPPP_(my_newRV_noinc)(SV *sv)
04365 {
04366   SV *rv = (SV *)newRV(sv);
04367   SvREFCNT_dec(sv);
04368   return rv;
04369 }
04370 #endif
04371 #endif
04372 
04373 /* Hint: newCONSTSUB
04374  * Returns a CV* as of perl-5.7.1. This return value is not supported
04375  * by Devel::PPPort.
04376  */
04377 
04378 /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
04379 #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
04380 #if defined(NEED_newCONSTSUB)
04381 static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
04382 static
04383 #else
04384 extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
04385 #endif
04386 
04387 #ifdef newCONSTSUB
04388 #  undef newCONSTSUB
04389 #endif
04390 #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
04391 #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
04392 
04393 #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
04394 
04395 /* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
04396 /* (There's no PL_parser in perl < 5.005, so this is completely safe)     */
04397 #define D_PPP_PL_copline PL_copline
04398 
04399 void
04400 DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
04401 {
04402         U32 oldhints = PL_hints;
04403         HV *old_cop_stash = PL_curcop->cop_stash;
04404         HV *old_curstash = PL_curstash;
04405         line_t oldline = PL_curcop->cop_line;
04406         PL_curcop->cop_line = D_PPP_PL_copline;
04407 
04408         PL_hints &= ~HINT_BLOCK_SCOPE;
04409         if (stash)
04410                 PL_curstash = PL_curcop->cop_stash = stash;
04411 
04412         newSUB(
04413 
04414 #if   (PERL_BCDVERSION < 0x5003022)
04415                 start_subparse(),
04416 #elif (PERL_BCDVERSION == 0x5003022)
04417                 start_subparse(0),
04418 #else  /* 5.003_23  onwards */
04419                 start_subparse(FALSE, 0),
04420 #endif
04421 
04422                 newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
04423                 newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */
04424                 newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
04425         );
04426 
04427         PL_hints = oldhints;
04428         PL_curcop->cop_stash = old_cop_stash;
04429         PL_curstash = old_curstash;
04430         PL_curcop->cop_line = oldline;
04431 }
04432 #endif
04433 #endif
04434 
04435 /*
04436  * Boilerplate macros for initializing and accessing interpreter-local
04437  * data from C.  All statics in extensions should be reworked to use
04438  * this, if you want to make the extension thread-safe.  See ext/re/re.xs
04439  * for an example of the use of these macros.
04440  *
04441  * Code that uses these macros is responsible for the following:
04442  * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
04443  * 2. Declare a typedef named my_cxt_t that is a structure that contains
04444  *    all the data that needs to be interpreter-local.
04445  * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
04446  * 4. Use the MY_CXT_INIT macro such that it is called exactly once
04447  *    (typically put in the BOOT: section).
04448  * 5. Use the members of the my_cxt_t structure everywhere as
04449  *    MY_CXT.member.
04450  * 6. Use the dMY_CXT macro (a declaration) in all the functions that
04451  *    access MY_CXT.
04452  */
04453 
04454 #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
04455     defined(PERL_CAPI)    || defined(PERL_IMPLICIT_CONTEXT)
04456 
04457 #ifndef START_MY_CXT
04458 
04459 /* This must appear in all extensions that define a my_cxt_t structure,
04460  * right after the definition (i.e. at file scope).  The non-threads
04461  * case below uses it to declare the data as static. */
04462 #define START_MY_CXT
04463 
04464 #if (PERL_BCDVERSION < 0x5004068)
04465 /* Fetches the SV that keeps the per-interpreter data. */
04466 #define dMY_CXT_SV \
04467         SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
04468 #else /* >= perl5.004_68 */
04469 #define dMY_CXT_SV \
04470         SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY,             \
04471                                   sizeof(MY_CXT_KEY)-1, TRUE)
04472 #endif /* < perl5.004_68 */
04473 
04474 /* This declaration should be used within all functions that use the
04475  * interpreter-local data. */
04476 #define dMY_CXT \
04477         dMY_CXT_SV;                                                     \
04478         my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
04479 
04480 /* Creates and zeroes the per-interpreter data.
04481  * (We allocate my_cxtp in a Perl SV so that it will be released when
04482  * the interpreter goes away.) */
04483 #define MY_CXT_INIT \
04484         dMY_CXT_SV;                                                     \
04485         /* newSV() allocates one more than needed */                    \
04486         my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
04487         Zero(my_cxtp, 1, my_cxt_t);                                     \
04488         sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
04489 
04490 /* This macro must be used to access members of the my_cxt_t structure.
04491  * e.g. MYCXT.some_data */
04492 #define MY_CXT          (*my_cxtp)
04493 
04494 /* Judicious use of these macros can reduce the number of times dMY_CXT
04495  * is used.  Use is similar to pTHX, aTHX etc. */
04496 #define pMY_CXT         my_cxt_t *my_cxtp
04497 #define pMY_CXT_        pMY_CXT,
04498 #define _pMY_CXT        ,pMY_CXT
04499 #define aMY_CXT         my_cxtp
04500 #define aMY_CXT_        aMY_CXT,
04501 #define _aMY_CXT        ,aMY_CXT
04502 
04503 #endif /* START_MY_CXT */
04504 
04505 #ifndef MY_CXT_CLONE
04506 /* Clones the per-interpreter data. */
04507 #define MY_CXT_CLONE \
04508         dMY_CXT_SV;                                                     \
04509         my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
04510         Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
04511         sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
04512 #endif
04513 
04514 #else /* single interpreter */
04515 
04516 #ifndef START_MY_CXT
04517 
04518 #define START_MY_CXT    static my_cxt_t my_cxt;
04519 #define dMY_CXT_SV      dNOOP
04520 #define dMY_CXT         dNOOP
04521 #define MY_CXT_INIT     NOOP
04522 #define MY_CXT          my_cxt
04523 
04524 #define pMY_CXT         void
04525 #define pMY_CXT_
04526 #define _pMY_CXT
04527 #define aMY_CXT
04528 #define aMY_CXT_
04529 #define _aMY_CXT
04530 
04531 #endif /* START_MY_CXT */
04532 
04533 #ifndef MY_CXT_CLONE
04534 #define MY_CXT_CLONE    NOOP
04535 #endif
04536 
04537 #endif
04538 
04539 #ifndef IVdf
04540 #  if IVSIZE == LONGSIZE
04541 #    define     IVdf      "ld"
04542 #    define     UVuf      "lu"
04543 #    define     UVof      "lo"
04544 #    define     UVxf      "lx"
04545 #    define     UVXf      "lX"
04546 #  else
04547 #    if IVSIZE == INTSIZE
04548 #      define   IVdf      "d"
04549 #      define   UVuf      "u"
04550 #      define   UVof      "o"
04551 #      define   UVxf      "x"
04552 #      define   UVXf      "X"
04553 #    endif
04554 #  endif
04555 #endif
04556 
04557 #ifndef NVef
04558 #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
04559       defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
04560             /* Not very likely, but let's try anyway. */
04561 #    define NVef          PERL_PRIeldbl
04562 #    define NVff          PERL_PRIfldbl
04563 #    define NVgf          PERL_PRIgldbl
04564 #  else
04565 #    define NVef          "e"
04566 #    define NVff          "f"
04567 #    define NVgf          "g"
04568 #  endif
04569 #endif
04570 
04571 #ifndef SvREFCNT_inc
04572 #  ifdef PERL_USE_GCC_BRACE_GROUPS
04573 #    define SvREFCNT_inc(sv)            \
04574       ({                                \
04575           SV * const _sv = (SV*)(sv);   \
04576           if (_sv)                      \
04577                (SvREFCNT(_sv))++;       \
04578           _sv;                          \
04579       })
04580 #  else
04581 #    define SvREFCNT_inc(sv)    \
04582           ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
04583 #  endif
04584 #endif
04585 
04586 #ifndef SvREFCNT_inc_simple
04587 #  ifdef PERL_USE_GCC_BRACE_GROUPS
04588 #    define SvREFCNT_inc_simple(sv)     \
04589       ({                                        \
04590           if (sv)                               \
04591                (SvREFCNT(sv))++;                \
04592           (SV *)(sv);                           \
04593       })
04594 #  else
04595 #    define SvREFCNT_inc_simple(sv) \
04596           ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
04597 #  endif
04598 #endif
04599 
04600 #ifndef SvREFCNT_inc_NN
04601 #  ifdef PERL_USE_GCC_BRACE_GROUPS
04602 #    define SvREFCNT_inc_NN(sv)         \
04603       ({                                        \
04604           SV * const _sv = (SV*)(sv);   \
04605           SvREFCNT(_sv)++;              \
04606           _sv;                          \
04607       })
04608 #  else
04609 #    define SvREFCNT_inc_NN(sv) \
04610           (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
04611 #  endif
04612 #endif
04613 
04614 #ifndef SvREFCNT_inc_void
04615 #  ifdef PERL_USE_GCC_BRACE_GROUPS
04616 #    define SvREFCNT_inc_void(sv)               \
04617       ({                                        \
04618           SV * const _sv = (SV*)(sv);   \
04619           if (_sv)                      \
04620               (void)(SvREFCNT(_sv)++);  \
04621       })
04622 #  else
04623 #    define SvREFCNT_inc_void(sv) \
04624           (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
04625 #  endif
04626 #endif
04627 #ifndef SvREFCNT_inc_simple_void
04628 #  define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
04629 #endif
04630 
04631 #ifndef SvREFCNT_inc_simple_NN
04632 #  define SvREFCNT_inc_simple_NN(sv)     (++SvREFCNT(sv), (SV*)(sv))
04633 #endif
04634 
04635 #ifndef SvREFCNT_inc_void_NN
04636 #  define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT((SV*)(sv)))
04637 #endif
04638 
04639 #ifndef SvREFCNT_inc_simple_void_NN
04640 #  define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
04641 #endif
04642 
04643 #if (PERL_BCDVERSION < 0x5006000)
04644 # define D_PPP_CONSTPV_ARG(x)  ((char *) (x))
04645 #else
04646 # define D_PPP_CONSTPV_ARG(x)  (x)
04647 #endif
04648 #ifndef newSVpvn
04649 #  define newSVpvn(data,len)             ((data)                                              \
04650                                     ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
04651                                     : newSV(0))
04652 #endif
04653 #ifndef newSVpvn_utf8
04654 #  define newSVpvn_utf8(s, len, u)       newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
04655 #endif
04656 #ifndef SVf_UTF8
04657 #  define SVf_UTF8                       0
04658 #endif
04659 
04660 #ifndef newSVpvn_flags
04661 
04662 #if defined(NEED_newSVpvn_flags)
04663 static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
04664 static
04665 #else
04666 extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
04667 #endif
04668 
04669 #ifdef newSVpvn_flags
04670 #  undef newSVpvn_flags
04671 #endif
04672 #define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
04673 #define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
04674 
04675 #if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
04676 
04677 SV *
04678 DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
04679 {
04680   SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len);
04681   SvFLAGS(sv) |= (flags & SVf_UTF8);
04682   return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
04683 }
04684 
04685 #endif
04686 
04687 #endif
04688 
04689 /* Backwards compatibility stuff... :-( */
04690 #if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen)
04691 #  define NEED_sv_2pv_flags
04692 #endif
04693 #if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL)
04694 #  define NEED_sv_2pv_flags_GLOBAL
04695 #endif
04696 
04697 /* Hint: sv_2pv_nolen
04698  * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
04699  */
04700 #ifndef sv_2pv_nolen
04701 #  define sv_2pv_nolen(sv)               SvPV_nolen(sv)
04702 #endif
04703 
04704 #ifdef SvPVbyte
04705 
04706 /* Hint: SvPVbyte
04707  * Does not work in perl-5.6.1, ppport.h implements a version
04708  * borrowed from perl-5.7.3.
04709  */
04710 
04711 #if (PERL_BCDVERSION < 0x5007000)
04712 
04713 #if defined(NEED_sv_2pvbyte)
04714 static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
04715 static
04716 #else
04717 extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
04718 #endif
04719 
04720 #ifdef sv_2pvbyte
04721 #  undef sv_2pvbyte
04722 #endif
04723 #define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
04724 #define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)
04725 
04726 #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
04727 
04728 char *
04729 DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
04730 {
04731   sv_utf8_downgrade(sv,0);
04732   return SvPV(sv,*lp);
04733 }
04734 
04735 #endif
04736 
04737 /* Hint: sv_2pvbyte
04738  * Use the SvPVbyte() macro instead of sv_2pvbyte().
04739  */
04740 
04741 #undef SvPVbyte
04742 
04743 #define SvPVbyte(sv, lp)                                                \
04744         ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)                \
04745          ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
04746 
04747 #endif
04748 
04749 #else
04750 
04751 #  define SvPVbyte          SvPV
04752 #  define sv_2pvbyte        sv_2pv
04753 
04754 #endif
04755 #ifndef sv_2pvbyte_nolen
04756 #  define sv_2pvbyte_nolen(sv)           sv_2pv_nolen(sv)
04757 #endif
04758 
04759 /* Hint: sv_pvn
04760  * Always use the SvPV() macro instead of sv_pvn().
04761  */
04762 
04763 /* Hint: sv_pvn_force
04764  * Always use the SvPV_force() macro instead of sv_pvn_force().
04765  */
04766 
04767 /* If these are undefined, they're not handled by the core anyway */
04768 #ifndef SV_IMMEDIATE_UNREF
04769 #  define SV_IMMEDIATE_UNREF             0
04770 #endif
04771 
04772 #ifndef SV_GMAGIC
04773 #  define SV_GMAGIC                      0
04774 #endif
04775 
04776 #ifndef SV_COW_DROP_PV
04777 #  define SV_COW_DROP_PV                 0
04778 #endif
04779 
04780 #ifndef SV_UTF8_NO_ENCODING
04781 #  define SV_UTF8_NO_ENCODING            0
04782 #endif
04783 
04784 #ifndef SV_NOSTEAL
04785 #  define SV_NOSTEAL                     0
04786 #endif
04787 
04788 #ifndef SV_CONST_RETURN
04789 #  define SV_CONST_RETURN                0
04790 #endif
04791 
04792 #ifndef SV_MUTABLE_RETURN
04793 #  define SV_MUTABLE_RETURN              0
04794 #endif
04795 
04796 #ifndef SV_SMAGIC
04797 #  define SV_SMAGIC                      0
04798 #endif
04799 
04800 #ifndef SV_HAS_TRAILING_NUL
04801 #  define SV_HAS_TRAILING_NUL            0
04802 #endif
04803 
04804 #ifndef SV_COW_SHARED_HASH_KEYS
04805 #  define SV_COW_SHARED_HASH_KEYS        0
04806 #endif
04807 
04808 #if (PERL_BCDVERSION < 0x5007002)
04809 
04810 #if defined(NEED_sv_2pv_flags)
04811 static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
04812 static
04813 #else
04814 extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
04815 #endif
04816 
04817 #ifdef sv_2pv_flags
04818 #  undef sv_2pv_flags
04819 #endif
04820 #define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
04821 #define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
04822 
04823 #if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
04824 
04825 char *
04826 DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
04827 {
04828   STRLEN n_a = (STRLEN) flags;
04829   return sv_2pv(sv, lp ? lp : &n_a);
04830 }
04831 
04832 #endif
04833 
04834 #if defined(NEED_sv_pvn_force_flags)
04835 static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
04836 static
04837 #else
04838 extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
04839 #endif
04840 
04841 #ifdef sv_pvn_force_flags
04842 #  undef sv_pvn_force_flags
04843 #endif
04844 #define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
04845 #define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
04846 
04847 #if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
04848 
04849 char *
04850 DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
04851 {
04852   STRLEN n_a = (STRLEN) flags;
04853   return sv_pvn_force(sv, lp ? lp : &n_a);
04854 }
04855 
04856 #endif
04857 
04858 #endif
04859 
04860 #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
04861 # define DPPP_SVPV_NOLEN_LP_ARG &PL_na
04862 #else
04863 # define DPPP_SVPV_NOLEN_LP_ARG 0
04864 #endif
04865 #ifndef SvPV_const
04866 #  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)
04867 #endif
04868 
04869 #ifndef SvPV_mutable
04870 #  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)
04871 #endif
04872 #ifndef SvPV_flags
04873 #  define SvPV_flags(sv, lp, flags)      \
04874                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
04875                   ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
04876 #endif
04877 #ifndef SvPV_flags_const
04878 #  define SvPV_flags_const(sv, lp, flags) \
04879                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
04880                   ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
04881                   (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
04882 #endif
04883 #ifndef SvPV_flags_const_nolen
04884 #  define SvPV_flags_const_nolen(sv, flags) \
04885                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
04886                   ? SvPVX_const(sv) : \
04887                   (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
04888 #endif
04889 #ifndef SvPV_flags_mutable
04890 #  define SvPV_flags_mutable(sv, lp, flags) \
04891                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
04892                   ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
04893                   sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
04894 #endif
04895 #ifndef SvPV_force
04896 #  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)
04897 #endif
04898 
04899 #ifndef SvPV_force_nolen
04900 #  define SvPV_force_nolen(sv)           SvPV_force_flags_nolen(sv, SV_GMAGIC)
04901 #endif
04902 
04903 #ifndef SvPV_force_mutable
04904 #  define SvPV_force_mutable(sv, lp)     SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
04905 #endif
04906 
04907 #ifndef SvPV_force_nomg
04908 #  define SvPV_force_nomg(sv, lp)        SvPV_force_flags(sv, lp, 0)
04909 #endif
04910 
04911 #ifndef SvPV_force_nomg_nolen
04912 #  define SvPV_force_nomg_nolen(sv)      SvPV_force_flags_nolen(sv, 0)
04913 #endif
04914 #ifndef SvPV_force_flags
04915 #  define SvPV_force_flags(sv, lp, flags) \
04916                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
04917                  ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
04918 #endif
04919 #ifndef SvPV_force_flags_nolen
04920 #  define SvPV_force_flags_nolen(sv, flags) \
04921                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
04922                  ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
04923 #endif
04924 #ifndef SvPV_force_flags_mutable
04925 #  define SvPV_force_flags_mutable(sv, lp, flags) \
04926                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
04927                  ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
04928                   : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
04929 #endif
04930 #ifndef SvPV_nolen
04931 #  define SvPV_nolen(sv)                 \
04932                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
04933                   ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
04934 #endif
04935 #ifndef SvPV_nolen_const
04936 #  define SvPV_nolen_const(sv)           \
04937                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
04938                   ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
04939 #endif
04940 #ifndef SvPV_nomg
04941 #  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)
04942 #endif
04943 
04944 #ifndef SvPV_nomg_const
04945 #  define SvPV_nomg_const(sv, lp)        SvPV_flags_const(sv, lp, 0)
04946 #endif
04947 
04948 #ifndef SvPV_nomg_const_nolen
04949 #  define SvPV_nomg_const_nolen(sv)      SvPV_flags_const_nolen(sv, 0)
04950 #endif
04951 #ifndef SvPV_renew
04952 #  define SvPV_renew(sv,n)               STMT_START { SvLEN_set(sv, n); \
04953                  SvPV_set((sv), (char *) saferealloc(          \
04954                        (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
04955                } STMT_END
04956 #endif
04957 #ifndef SvMAGIC_set
04958 #  define SvMAGIC_set(sv, val)           \
04959                 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
04960                 (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
04961 #endif
04962 
04963 #if (PERL_BCDVERSION < 0x5009003)
04964 #ifndef SvPVX_const
04965 #  define SvPVX_const(sv)                ((const char*) (0 + SvPVX(sv)))
04966 #endif
04967 
04968 #ifndef SvPVX_mutable
04969 #  define SvPVX_mutable(sv)              (0 + SvPVX(sv))
04970 #endif
04971 #ifndef SvRV_set
04972 #  define SvRV_set(sv, val)              \
04973                 STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
04974                 (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
04975 #endif
04976 
04977 #else
04978 #ifndef SvPVX_const
04979 #  define SvPVX_const(sv)                ((const char*)((sv)->sv_u.svu_pv))
04980 #endif
04981 
04982 #ifndef SvPVX_mutable
04983 #  define SvPVX_mutable(sv)              ((sv)->sv_u.svu_pv)
04984 #endif
04985 #ifndef SvRV_set
04986 #  define SvRV_set(sv, val)              \
04987                 STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
04988                 ((sv)->sv_u.svu_rv = (val)); } STMT_END
04989 #endif
04990 
04991 #endif
04992 #ifndef SvSTASH_set
04993 #  define SvSTASH_set(sv, val)           \
04994                 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
04995                 (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
04996 #endif
04997 
04998 #if (PERL_BCDVERSION < 0x5004000)
04999 #ifndef SvUV_set
05000 #  define SvUV_set(sv, val)              \
05001                 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
05002                 (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
05003 #endif
05004 
05005 #else
05006 #ifndef SvUV_set
05007 #  define SvUV_set(sv, val)              \
05008                 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
05009                 (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
05010 #endif
05011 
05012 #endif
05013 
05014 #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
05015 #if defined(NEED_vnewSVpvf)
05016 static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
05017 static
05018 #else
05019 extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
05020 #endif
05021 
05022 #ifdef vnewSVpvf
05023 #  undef vnewSVpvf
05024 #endif
05025 #define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
05026 #define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
05027 
05028 #if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
05029 
05030 SV *
05031 DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
05032 {
05033   register SV *sv = newSV(0);
05034   sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
05035   return sv;
05036 }
05037 
05038 #endif
05039 #endif
05040 
05041 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
05042 #  define sv_vcatpvf(sv, pat, args)  sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
05043 #endif
05044 
05045 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
05046 #  define sv_vsetpvf(sv, pat, args)  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
05047 #endif
05048 
05049 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
05050 #if defined(NEED_sv_catpvf_mg)
05051 static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
05052 static
05053 #else
05054 extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
05055 #endif
05056 
05057 #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
05058 
05059 #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
05060 
05061 void
05062 DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
05063 {
05064   va_list args;
05065   va_start(args, pat);
05066   sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
05067   SvSETMAGIC(sv);
05068   va_end(args);
05069 }
05070 
05071 #endif
05072 #endif
05073 
05074 #ifdef PERL_IMPLICIT_CONTEXT
05075 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
05076 #if defined(NEED_sv_catpvf_mg_nocontext)
05077 static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
05078 static
05079 #else
05080 extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
05081 #endif
05082 
05083 #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
05084 #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
05085 
05086 #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
05087 
05088 void
05089 DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
05090 {
05091   dTHX;
05092   va_list args;
05093   va_start(args, pat);
05094   sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
05095   SvSETMAGIC(sv);
05096   va_end(args);
05097 }
05098 
05099 #endif
05100 #endif
05101 #endif
05102 
05103 /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
05104 #ifndef sv_catpvf_mg
05105 #  ifdef PERL_IMPLICIT_CONTEXT
05106 #    define sv_catpvf_mg   Perl_sv_catpvf_mg_nocontext
05107 #  else
05108 #    define sv_catpvf_mg   Perl_sv_catpvf_mg
05109 #  endif
05110 #endif
05111 
05112 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
05113 #  define sv_vcatpvf_mg(sv, pat, args)                                     \
05114    STMT_START {                                                            \
05115      sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
05116      SvSETMAGIC(sv);                                                       \
05117    } STMT_END
05118 #endif
05119 
05120 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
05121 #if defined(NEED_sv_setpvf_mg)
05122 static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
05123 static
05124 #else
05125 extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
05126 #endif
05127 
05128 #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
05129 
05130 #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
05131 
05132 void
05133 DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
05134 {
05135   va_list args;
05136   va_start(args, pat);
05137   sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
05138   SvSETMAGIC(sv);
05139   va_end(args);
05140 }
05141 
05142 #endif
05143 #endif
05144 
05145 #ifdef PERL_IMPLICIT_CONTEXT
05146 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
05147 #if defined(NEED_sv_setpvf_mg_nocontext)
05148 static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
05149 static
05150 #else
05151 extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
05152 #endif
05153 
05154 #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
05155 #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
05156 
05157 #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
05158 
05159 void
05160 DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
05161 {
05162   dTHX;
05163   va_list args;
05164   va_start(args, pat);
05165   sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
05166   SvSETMAGIC(sv);
05167   va_end(args);
05168 }
05169 
05170 #endif
05171 #endif
05172 #endif
05173 
05174 /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
05175 #ifndef sv_setpvf_mg
05176 #  ifdef PERL_IMPLICIT_CONTEXT
05177 #    define sv_setpvf_mg   Perl_sv_setpvf_mg_nocontext
05178 #  else
05179 #    define sv_setpvf_mg   Perl_sv_setpvf_mg
05180 #  endif
05181 #endif
05182 
05183 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
05184 #  define sv_vsetpvf_mg(sv, pat, args)                                     \
05185    STMT_START {                                                            \
05186      sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
05187      SvSETMAGIC(sv);                                                       \
05188    } STMT_END
05189 #endif
05190 
05191 #ifndef newSVpvn_share
05192 
05193 #if defined(NEED_newSVpvn_share)
05194 static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
05195 static
05196 #else
05197 extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
05198 #endif
05199 
05200 #ifdef newSVpvn_share
05201 #  undef newSVpvn_share
05202 #endif
05203 #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
05204 #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
05205 
05206 #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
05207 
05208 SV *
05209 DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
05210 {
05211   SV *sv;
05212   if (len < 0)
05213     len = -len;
05214   if (!hash)
05215     PERL_HASH(hash, (char*) src, len);
05216   sv = newSVpvn((char *) src, len);
05217   sv_upgrade(sv, SVt_PVIV);
05218   SvIVX(sv) = hash;
05219   SvREADONLY_on(sv);
05220   SvPOK_on(sv);
05221   return sv;
05222 }
05223 
05224 #endif
05225 
05226 #endif
05227 #ifndef SvSHARED_HASH
05228 #  define SvSHARED_HASH(sv)              (0 + SvUVX(sv))
05229 #endif
05230 #ifndef WARN_ALL
05231 #  define WARN_ALL                       0
05232 #endif
05233 
05234 #ifndef WARN_CLOSURE
05235 #  define WARN_CLOSURE                   1
05236 #endif
05237 
05238 #ifndef WARN_DEPRECATED
05239 #  define WARN_DEPRECATED                2
05240 #endif
05241 
05242 #ifndef WARN_EXITING
05243 #  define WARN_EXITING                   3
05244 #endif
05245 
05246 #ifndef WARN_GLOB
05247 #  define WARN_GLOB                      4
05248 #endif
05249 
05250 #ifndef WARN_IO
05251 #  define WARN_IO                        5
05252 #endif
05253 
05254 #ifndef WARN_CLOSED
05255 #  define WARN_CLOSED                    6
05256 #endif
05257 
05258 #ifndef WARN_EXEC
05259 #  define WARN_EXEC                      7
05260 #endif
05261 
05262 #ifndef WARN_LAYER
05263 #  define WARN_LAYER                     8
05264 #endif
05265 
05266 #ifndef WARN_NEWLINE
05267 #  define WARN_NEWLINE                   9
05268 #endif
05269 
05270 #ifndef WARN_PIPE
05271 #  define WARN_PIPE                      10
05272 #endif
05273 
05274 #ifndef WARN_UNOPENED
05275 #  define WARN_UNOPENED                  11
05276 #endif
05277 
05278 #ifndef WARN_MISC
05279 #  define WARN_MISC                      12
05280 #endif
05281 
05282 #ifndef WARN_NUMERIC
05283 #  define WARN_NUMERIC                   13
05284 #endif
05285 
05286 #ifndef WARN_ONCE
05287 #  define WARN_ONCE                      14
05288 #endif
05289 
05290 #ifndef WARN_OVERFLOW
05291 #  define WARN_OVERFLOW                  15
05292 #endif
05293 
05294 #ifndef WARN_PACK
05295 #  define WARN_PACK                      16
05296 #endif
05297 
05298 #ifndef WARN_PORTABLE
05299 #  define WARN_PORTABLE                  17
05300 #endif
05301 
05302 #ifndef WARN_RECURSION
05303 #  define WARN_RECURSION                 18
05304 #endif
05305 
05306 #ifndef WARN_REDEFINE
05307 #  define WARN_REDEFINE                  19
05308 #endif
05309 
05310 #ifndef WARN_REGEXP
05311 #  define WARN_REGEXP                    20
05312 #endif
05313 
05314 #ifndef WARN_SEVERE
05315 #  define WARN_SEVERE                    21
05316 #endif
05317 
05318 #ifndef WARN_DEBUGGING
05319 #  define WARN_DEBUGGING                 22
05320 #endif
05321 
05322 #ifndef WARN_INPLACE
05323 #  define WARN_INPLACE                   23
05324 #endif
05325 
05326 #ifndef WARN_INTERNAL
05327 #  define WARN_INTERNAL                  24
05328 #endif
05329 
05330 #ifndef WARN_MALLOC
05331 #  define WARN_MALLOC                    25
05332 #endif
05333 
05334 #ifndef WARN_SIGNAL
05335 #  define WARN_SIGNAL                    26
05336 #endif
05337 
05338 #ifndef WARN_SUBSTR
05339 #  define WARN_SUBSTR                    27
05340 #endif
05341 
05342 #ifndef WARN_SYNTAX
05343 #  define WARN_SYNTAX                    28
05344 #endif
05345 
05346 #ifndef WARN_AMBIGUOUS
05347 #  define WARN_AMBIGUOUS                 29
05348 #endif
05349 
05350 #ifndef WARN_BAREWORD
05351 #  define WARN_BAREWORD                  30
05352 #endif
05353 
05354 #ifndef WARN_DIGIT
05355 #  define WARN_DIGIT                     31
05356 #endif
05357 
05358 #ifndef WARN_PARENTHESIS
05359 #  define WARN_PARENTHESIS               32
05360 #endif
05361 
05362 #ifndef WARN_PRECEDENCE
05363 #  define WARN_PRECEDENCE                33
05364 #endif
05365 
05366 #ifndef WARN_PRINTF
05367 #  define WARN_PRINTF                    34
05368 #endif
05369 
05370 #ifndef WARN_PROTOTYPE
05371 #  define WARN_PROTOTYPE                 35
05372 #endif
05373 
05374 #ifndef WARN_QW
05375 #  define WARN_QW                        36
05376 #endif
05377 
05378 #ifndef WARN_RESERVED
05379 #  define WARN_RESERVED                  37
05380 #endif
05381 
05382 #ifndef WARN_SEMICOLON
05383 #  define WARN_SEMICOLON                 38
05384 #endif
05385 
05386 #ifndef WARN_TAINT
05387 #  define WARN_TAINT                     39
05388 #endif
05389 
05390 #ifndef WARN_THREADS
05391 #  define WARN_THREADS                   40
05392 #endif
05393 
05394 #ifndef WARN_UNINITIALIZED
05395 #  define WARN_UNINITIALIZED             41
05396 #endif
05397 
05398 #ifndef WARN_UNPACK
05399 #  define WARN_UNPACK                    42
05400 #endif
05401 
05402 #ifndef WARN_UNTIE
05403 #  define WARN_UNTIE                     43
05404 #endif
05405 
05406 #ifndef WARN_UTF8
05407 #  define WARN_UTF8                      44
05408 #endif
05409 
05410 #ifndef WARN_VOID
05411 #  define WARN_VOID                      45
05412 #endif
05413 
05414 #ifndef WARN_ASSERTIONS
05415 #  define WARN_ASSERTIONS                46
05416 #endif
05417 #ifndef packWARN
05418 #  define packWARN(a)                    (a)
05419 #endif
05420 
05421 #ifndef ckWARN
05422 #  ifdef G_WARN_ON
05423 #    define  ckWARN(a)                  (PL_dowarn & G_WARN_ON)
05424 #  else
05425 #    define  ckWARN(a)                  PL_dowarn
05426 #  endif
05427 #endif
05428 
05429 #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
05430 #if defined(NEED_warner)
05431 static void DPPP_(my_warner)(U32 err, const char *pat, ...);
05432 static
05433 #else
05434 extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
05435 #endif
05436 
05437 #define Perl_warner DPPP_(my_warner)
05438 
05439 #if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
05440 
05441 void
05442 DPPP_(my_warner)(U32 err, const char *pat, ...)
05443 {
05444   SV *sv;
05445   va_list args;
05446 
05447   PERL_UNUSED_ARG(err);
05448 
05449   va_start(args, pat);
05450   sv = vnewSVpvf(pat, &args);
05451   va_end(args);
05452   sv_2mortal(sv);
05453   warn("%s", SvPV_nolen(sv));
05454 }
05455 
05456 #define warner  Perl_warner
05457 
05458 #define Perl_warner_nocontext  Perl_warner
05459 
05460 #endif
05461 #endif
05462 
05463 /* concatenating with "" ensures that only literal strings are accepted as argument
05464  * note that STR_WITH_LEN() can't be used as argument to macros or functions that
05465  * under some configurations might be macros
05466  */
05467 #ifndef STR_WITH_LEN
05468 #  define STR_WITH_LEN(s)                (s ""), (sizeof(s)-1)
05469 #endif
05470 #ifndef newSVpvs
05471 #  define newSVpvs(str)                  newSVpvn(str "", sizeof(str) - 1)
05472 #endif
05473 
05474 #ifndef newSVpvs_flags
05475 #  define newSVpvs_flags(str, flags)     newSVpvn_flags(str "", sizeof(str) - 1, flags)
05476 #endif
05477 
05478 #ifndef sv_catpvs
05479 #  define sv_catpvs(sv, str)             sv_catpvn(sv, str "", sizeof(str) - 1)
05480 #endif
05481 
05482 #ifndef sv_setpvs
05483 #  define sv_setpvs(sv, str)             sv_setpvn(sv, str "", sizeof(str) - 1)
05484 #endif
05485 
05486 #ifndef hv_fetchs
05487 #  define hv_fetchs(hv, key, lval)       hv_fetch(hv, key "", sizeof(key) - 1, lval)
05488 #endif
05489 
05490 #ifndef hv_stores
05491 #  define hv_stores(hv, key, val)        hv_store(hv, key "", sizeof(key) - 1, val, 0)
05492 #endif
05493 #ifndef SvGETMAGIC
05494 #  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
05495 #endif
05496 #ifndef PERL_MAGIC_sv
05497 #  define PERL_MAGIC_sv                  '\0'
05498 #endif
05499 
05500 #ifndef PERL_MAGIC_overload
05501 #  define PERL_MAGIC_overload            'A'
05502 #endif
05503 
05504 #ifndef PERL_MAGIC_overload_elem
05505 #  define PERL_MAGIC_overload_elem       'a'
05506 #endif
05507 
05508 #ifndef PERL_MAGIC_overload_table
05509 #  define PERL_MAGIC_overload_table      'c'
05510 #endif
05511 
05512 #ifndef PERL_MAGIC_bm
05513 #  define PERL_MAGIC_bm                  'B'
05514 #endif
05515 
05516 #ifndef PERL_MAGIC_regdata
05517 #  define PERL_MAGIC_regdata             'D'
05518 #endif
05519 
05520 #ifndef PERL_MAGIC_regdatum
05521 #  define PERL_MAGIC_regdatum            'd'
05522 #endif
05523 
05524 #ifndef PERL_MAGIC_env
05525 #  define PERL_MAGIC_env                 'E'
05526 #endif
05527 
05528 #ifndef PERL_MAGIC_envelem
05529 #  define PERL_MAGIC_envelem             'e'
05530 #endif
05531 
05532 #ifndef PERL_MAGIC_fm
05533 #  define PERL_MAGIC_fm                  'f'
05534 #endif
05535 
05536 #ifndef PERL_MAGIC_regex_global
05537 #  define PERL_MAGIC_regex_global        'g'
05538 #endif
05539 
05540 #ifndef PERL_MAGIC_isa
05541 #  define PERL_MAGIC_isa                 'I'
05542 #endif
05543 
05544 #ifndef PERL_MAGIC_isaelem
05545 #  define PERL_MAGIC_isaelem             'i'
05546 #endif
05547 
05548 #ifndef PERL_MAGIC_nkeys
05549 #  define PERL_MAGIC_nkeys               'k'
05550 #endif
05551 
05552 #ifndef PERL_MAGIC_dbfile
05553 #  define PERL_MAGIC_dbfile              'L'
05554 #endif
05555 
05556 #ifndef PERL_MAGIC_dbline
05557 #  define PERL_MAGIC_dbline              'l'
05558 #endif
05559 
05560 #ifndef PERL_MAGIC_mutex
05561 #  define PERL_MAGIC_mutex               'm'
05562 #endif
05563 
05564 #ifndef PERL_MAGIC_shared
05565 #  define PERL_MAGIC_shared              'N'
05566 #endif
05567 
05568 #ifndef PERL_MAGIC_shared_scalar
05569 #  define PERL_MAGIC_shared_scalar       'n'
05570 #endif
05571 
05572 #ifndef PERL_MAGIC_collxfrm
05573 #  define PERL_MAGIC_collxfrm            'o'
05574 #endif
05575 
05576 #ifndef PERL_MAGIC_tied
05577 #  define PERL_MAGIC_tied                'P'
05578 #endif
05579 
05580 #ifndef PERL_MAGIC_tiedelem
05581 #  define PERL_MAGIC_tiedelem            'p'
05582 #endif
05583 
05584 #ifndef PERL_MAGIC_tiedscalar
05585 #  define PERL_MAGIC_tiedscalar          'q'
05586 #endif
05587 
05588 #ifndef PERL_MAGIC_qr
05589 #  define PERL_MAGIC_qr                  'r'
05590 #endif
05591 
05592 #ifndef PERL_MAGIC_sig
05593 #  define PERL_MAGIC_sig                 'S'
05594 #endif
05595 
05596 #ifndef PERL_MAGIC_sigelem
05597 #  define PERL_MAGIC_sigelem             's'
05598 #endif
05599 
05600 #ifndef PERL_MAGIC_taint
05601 #  define PERL_MAGIC_taint               't'
05602 #endif
05603 
05604 #ifndef PERL_MAGIC_uvar
05605 #  define PERL_MAGIC_uvar                'U'
05606 #endif
05607 
05608 #ifndef PERL_MAGIC_uvar_elem
05609 #  define PERL_MAGIC_uvar_elem           'u'
05610 #endif
05611 
05612 #ifndef PERL_MAGIC_vstring
05613 #  define PERL_MAGIC_vstring             'V'
05614 #endif
05615 
05616 #ifndef PERL_MAGIC_vec
05617 #  define PERL_MAGIC_vec                 'v'
05618 #endif
05619 
05620 #ifndef PERL_MAGIC_utf8
05621 #  define PERL_MAGIC_utf8                'w'
05622 #endif
05623 
05624 #ifndef PERL_MAGIC_substr
05625 #  define PERL_MAGIC_substr              'x'
05626 #endif
05627 
05628 #ifndef PERL_MAGIC_defelem
05629 #  define PERL_MAGIC_defelem             'y'
05630 #endif
05631 
05632 #ifndef PERL_MAGIC_glob
05633 #  define PERL_MAGIC_glob                '*'
05634 #endif
05635 
05636 #ifndef PERL_MAGIC_arylen
05637 #  define PERL_MAGIC_arylen              '#'
05638 #endif
05639 
05640 #ifndef PERL_MAGIC_pos
05641 #  define PERL_MAGIC_pos                 '.'
05642 #endif
05643 
05644 #ifndef PERL_MAGIC_backref
05645 #  define PERL_MAGIC_backref             '<'
05646 #endif
05647 
05648 #ifndef PERL_MAGIC_ext
05649 #  define PERL_MAGIC_ext                 '~'
05650 #endif
05651 
05652 /* That's the best we can do... */
05653 #ifndef sv_catpvn_nomg
05654 #  define sv_catpvn_nomg                 sv_catpvn
05655 #endif
05656 
05657 #ifndef sv_catsv_nomg
05658 #  define sv_catsv_nomg                  sv_catsv
05659 #endif
05660 
05661 #ifndef sv_setsv_nomg
05662 #  define sv_setsv_nomg                  sv_setsv
05663 #endif
05664 
05665 #ifndef sv_pvn_nomg
05666 #  define sv_pvn_nomg                    sv_pvn
05667 #endif
05668 
05669 #ifndef SvIV_nomg
05670 #  define SvIV_nomg                      SvIV
05671 #endif
05672 
05673 #ifndef SvUV_nomg
05674 #  define SvUV_nomg                      SvUV
05675 #endif
05676 
05677 #ifndef sv_catpv_mg
05678 #  define sv_catpv_mg(sv, ptr)          \
05679    STMT_START {                         \
05680      SV *TeMpSv = sv;                   \
05681      sv_catpv(TeMpSv,ptr);              \
05682      SvSETMAGIC(TeMpSv);                \
05683    } STMT_END
05684 #endif
05685 
05686 #ifndef sv_catpvn_mg
05687 #  define sv_catpvn_mg(sv, ptr, len)    \
05688    STMT_START {                         \
05689      SV *TeMpSv = sv;                   \
05690      sv_catpvn(TeMpSv,ptr,len);         \
05691      SvSETMAGIC(TeMpSv);                \
05692    } STMT_END
05693 #endif
05694 
05695 #ifndef sv_catsv_mg
05696 #  define sv_catsv_mg(dsv, ssv)         \
05697    STMT_START {                         \
05698      SV *TeMpSv = dsv;                  \
05699      sv_catsv(TeMpSv,ssv);              \
05700      SvSETMAGIC(TeMpSv);                \
05701    } STMT_END
05702 #endif
05703 
05704 #ifndef sv_setiv_mg
05705 #  define sv_setiv_mg(sv, i)            \
05706    STMT_START {                         \
05707      SV *TeMpSv = sv;                   \
05708      sv_setiv(TeMpSv,i);                \
05709      SvSETMAGIC(TeMpSv);                \
05710    } STMT_END
05711 #endif
05712 
05713 #ifndef sv_setnv_mg
05714 #  define sv_setnv_mg(sv, num)          \
05715    STMT_START {                         \
05716      SV *TeMpSv = sv;                   \
05717      sv_setnv(TeMpSv,num);              \
05718      SvSETMAGIC(TeMpSv);                \
05719    } STMT_END
05720 #endif
05721 
05722 #ifndef sv_setpv_mg
05723 #  define sv_setpv_mg(sv, ptr)          \
05724    STMT_START {                         \
05725      SV *TeMpSv = sv;                   \
05726      sv_setpv(TeMpSv,ptr);              \
05727      SvSETMAGIC(TeMpSv);                \
05728    } STMT_END
05729 #endif
05730 
05731 #ifndef sv_setpvn_mg
05732 #  define sv_setpvn_mg(sv, ptr, len)    \
05733    STMT_START {                         \
05734      SV *TeMpSv = sv;                   \
05735      sv_setpvn(TeMpSv,ptr,len);         \
05736      SvSETMAGIC(TeMpSv);                \
05737    } STMT_END
05738 #endif
05739 
05740 #ifndef sv_setsv_mg
05741 #  define sv_setsv_mg(dsv, ssv)         \
05742    STMT_START {                         \
05743      SV *TeMpSv = dsv;                  \
05744      sv_setsv(TeMpSv,ssv);              \
05745      SvSETMAGIC(TeMpSv);                \
05746    } STMT_END
05747 #endif
05748 
05749 #ifndef sv_setuv_mg
05750 #  define sv_setuv_mg(sv, i)            \
05751    STMT_START {                         \
05752      SV *TeMpSv = sv;                   \
05753      sv_setuv(TeMpSv,i);                \
05754      SvSETMAGIC(TeMpSv);                \
05755    } STMT_END
05756 #endif
05757 
05758 #ifndef sv_usepvn_mg
05759 #  define sv_usepvn_mg(sv, ptr, len)    \
05760    STMT_START {                         \
05761      SV *TeMpSv = sv;                   \
05762      sv_usepvn(TeMpSv,ptr,len);         \
05763      SvSETMAGIC(TeMpSv);                \
05764    } STMT_END
05765 #endif
05766 #ifndef SvVSTRING_mg
05767 #  define SvVSTRING_mg(sv)               (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
05768 #endif
05769 
05770 /* Hint: sv_magic_portable
05771  * This is a compatibility function that is only available with
05772  * Devel::PPPort. It is NOT in the perl core.
05773  * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
05774  * it is being passed a name pointer with namlen == 0. In that
05775  * case, perl 5.8.0 and later store the pointer, not a copy of it.
05776  * The compatibility can be provided back to perl 5.004. With
05777  * earlier versions, the code will not compile.
05778  */
05779 
05780 #if (PERL_BCDVERSION < 0x5004000)
05781 
05782   /* code that uses sv_magic_portable will not compile */
05783 
05784 #elif (PERL_BCDVERSION < 0x5008000)
05785 
05786 #  define sv_magic_portable(sv, obj, how, name, namlen)     \
05787    STMT_START {                                             \
05788      SV *SvMp_sv = (sv);                                    \
05789      char *SvMp_name = (char *) (name);                     \
05790      I32 SvMp_namlen = (namlen);                            \
05791      if (SvMp_name && SvMp_namlen == 0)                     \
05792      {                                                      \
05793        MAGIC *mg;                                           \
05794        sv_magic(SvMp_sv, obj, how, 0, 0);                   \
05795        mg = SvMAGIC(SvMp_sv);                               \
05796        mg->mg_len = -42; /* XXX: this is the tricky part */ \
05797        mg->mg_ptr = SvMp_name;                              \
05798      }                                                      \
05799      else                                                   \
05800      {                                                      \
05801        sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
05802      }                                                      \
05803    } STMT_END
05804 
05805 #else
05806 
05807 #  define sv_magic_portable(a, b, c, d, e)  sv_magic(a, b, c, d, e)
05808 
05809 #endif
05810 
05811 #ifdef USE_ITHREADS
05812 #ifndef CopFILE
05813 #  define CopFILE(c)                     ((c)->cop_file)
05814 #endif
05815 
05816 #ifndef CopFILEGV
05817 #  define CopFILEGV(c)                   (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)
05818 #endif
05819 
05820 #ifndef CopFILE_set
05821 #  define CopFILE_set(c,pv)              ((c)->cop_file = savepv(pv))
05822 #endif
05823 
05824 #ifndef CopFILESV
05825 #  define CopFILESV(c)                   (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
05826 #endif
05827 
05828 #ifndef CopFILEAV
05829 #  define CopFILEAV(c)                   (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
05830 #endif
05831 
05832 #ifndef CopSTASHPV
05833 #  define CopSTASHPV(c)                  ((c)->cop_stashpv)
05834 #endif
05835 
05836 #ifndef CopSTASHPV_set
05837 #  define CopSTASHPV_set(c,pv)           ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))
05838 #endif
05839 
05840 #ifndef CopSTASH
05841 #  define CopSTASH(c)                    (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
05842 #endif
05843 
05844 #ifndef CopSTASH_set
05845 #  define CopSTASH_set(c,hv)             CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)
05846 #endif
05847 
05848 #ifndef CopSTASH_eq
05849 #  define CopSTASH_eq(c,hv)              ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
05850                                         || (CopSTASHPV(c) && HvNAME(hv) \
05851                                         && strEQ(CopSTASHPV(c), HvNAME(hv)))))
05852 #endif
05853 
05854 #else
05855 #ifndef CopFILEGV
05856 #  define CopFILEGV(c)                   ((c)->cop_filegv)
05857 #endif
05858 
05859 #ifndef CopFILEGV_set
05860 #  define CopFILEGV_set(c,gv)            ((c)->cop_fileg