ppport.h

   1 #if 0
   2 <<'SKIP';
   3 #endif
   4 /*
   5 ----------------------------------------------------------------------
   6
   7     ppport.h -- Perl/Pollution/Portability Version 3.19
   8
   9     Automatically created by Devel::PPPort running under perl 5.010001.
  10
  11     Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
  12     includes in parts/inc/ instead.
  13
  14     Use 'perldoc ppport.h' to view the documentation below.
  15
  16 ----------------------------------------------------------------------
  17
  18 SKIP
  19
  20 =pod
  21
  22 =head1 NAME
  23
  24 ppport.h - Perl/Pollution/Portability version 3.19
  25
  26 =head1 SYNOPSIS
  27
  28   perl ppport.h [options] [source files]
  29
  30   Searches current directory for files if no [source files] are given
  31
  32   --help                      show short help
  33
  34   --version                   show version
  35
  36   --patch=file                write one patch file with changes
  37   --copy=suffix               write changed copies with suffix
  38   --diff=program              use diff program and options
  39
  40   --compat-version=version    provide compatibility with Perl version
  41   --cplusplus                 accept C++ comments
  42
  43   --quiet                     don't output anything except fatal errors
  44   --nodiag                    don't show diagnostics
  45   --nohints                   don't show hints
  46   --nochanges                 don't suggest changes
  47   --nofilter                  don't filter input files
  48
  49   --strip                     strip all script and doc functionality from
  50                               ppport.h
  51
  52   --list-provided             list provided API
  53   --list-unsupported          list unsupported API
  54   --api-info=name             show Perl API portability information
  55
  56 =head1 COMPATIBILITY
  57
  58 This version of F<ppport.h> is designed to support operation with Perl
  59 installations back to 5.003, and has been tested up to 5.10.0.
  60
  61 =head1 OPTIONS
  62
  63 =head2 --help
  64
  65 Display a brief usage summary.
  66
  67 =head2 --version
  68
  69 Display the version of F<ppport.h>.
  70
  71 =head2 --patch=I<file>
  72
  73 If this option is given, a single patch file will be created if
  74 any changes are suggested. This requires a working diff program
  75 to be installed on your system.
  76
  77 =head2 --copy=I<suffix>
  78
  79 If this option is given, a copy of each file will be saved with
  80 the given suffix that contains the suggested changes. This does
  81 not require any external programs. Note that this does not
  82 automagially add a dot between the original filename and the
  83 suffix. If you want the dot, you have to include it in the option
  84 argument.
  85
  86 If neither C<--patch> or C<--copy> are given, the default is to
  87 simply print the diffs for each file. This requires either
  88 C<Text::Diff> or a C<diff> program to be installed.
  89
  90 =head2 --diff=I<program>
  91
  92 Manually set the diff program and options to use. The default
  93 is to use C<Text::Diff>, when installed, and output unified
  94 context diffs.
  95
  96 =head2 --compat-version=I<version>
  97
  98 Tell F<ppport.h> to check for compatibility with the given
  99 Perl version. The default is to check for compatibility with Perl
 100 version 5.003. You can use this option to reduce the output
 101 of F<ppport.h> if you intend to be backward compatible only
 102 down to a certain Perl version.
 103
 104 =head2 --cplusplus
 105
 106 Usually, F<ppport.h> will detect C++ style comments and
 107 replace them with C style comments for portability reasons.
 108 Using this option instructs F<ppport.h> to leave C++
 109 comments untouched.
 110
 111 =head2 --quiet
 112
 113 Be quiet. Don't print anything except fatal errors.
 114
 115 =head2 --nodiag
 116
 117 Don't output any diagnostic messages. Only portability
 118 alerts will be printed.
 119
 120 =head2 --nohints
 121
 122 Don't output any hints. Hints often contain useful portability
 123 notes. Warnings will still be displayed.
 124
 125 =head2 --nochanges
 126
 127 Don't suggest any changes. Only give diagnostic output and hints
 128 unless these are also deactivated.
 129
 130 =head2 --nofilter
 131
 132 Don't filter the list of input files. By default, files not looking
 133 like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped.
 134
 135 =head2 --strip
 136
 137 Strip all script and documentation functionality from F<ppport.h>.
 138 This reduces the size of F<ppport.h> dramatically and may be useful
 139 if you want to include F<ppport.h> in smaller modules without
 140 increasing their distribution size too much.
 141
 142 The stripped F<ppport.h> will have a C<--unstrip> option that allows
 143 you to undo the stripping, but only if an appropriate C<Devel::PPPort>
 144 module is installed.
 145
 146 =head2 --list-provided
 147
 148 Lists the API elements for which compatibility is provided by
 149 F<ppport.h>. Also lists if it must be explicitly requested,
 150 if it has dependencies, and if there are hints or warnings for it.
 151
 152 =head2 --list-unsupported
 153
 154 Lists the API elements that are known not to be supported by
 155 F<ppport.h> and below which version of Perl they probably
 156 won't be available or work.
 157
 158 =head2 --api-info=I<name>
 159
 160 Show portability information for API elements matching I<name>.
 161 If I<name> is surrounded by slashes, it is interpreted as a regular
 162 expression.
 163
 164 =head1 DESCRIPTION
 165
 166 In order for a Perl extension (XS) module to be as portable as possible
 167 across differing versions of Perl itself, certain steps need to be taken.
 168
 169 =over 4
 170
 171 =item *
 172
 173 Including this header is the first major one. This alone will give you
 174 access to a large part of the Perl API that hasn't been available in
 175 earlier Perl releases. Use
 176
 177     perl ppport.h --list-provided
 178
 179 to see which API elements are provided by ppport.h.
 180
 181 =item *
 182
 183 You should avoid using deprecated parts of the API. For example, using
 184 global Perl variables without the C<PL_> prefix is deprecated. Also,
 185 some API functions used to have a C<perl_> prefix. Using this form is
 186 also deprecated. You can safely use the supported API, as F<ppport.h>
 187 will provide wrappers for older Perl versions.
 188
 189 =item *
 190
 191 If you use one of a few functions or variables that were not present in
 192 earlier versions of Perl, and that can't be provided using a macro, you
 193 have to explicitly request support for these functions by adding one or
 194 more C<#define>s in your source code before the inclusion of F<ppport.h>.
 195
 196 These functions or variables will be marked C<explicit> in the list shown
 197 by C<--list-provided>.
 198
 199 Depending on whether you module has a single or multiple files that
 200 use such functions or variables, you want either C<static> or global
 201 variants.
 202
 203 For a C<static> function or variable (used only in a single source
 204 file), use:
 205
 206     #define NEED_function
 207     #define NEED_variable
 208
 209 For a global function or variable (used in multiple source files),
 210 use:
 211
 212     #define NEED_function_GLOBAL
 213     #define NEED_variable_GLOBAL
 214
 215 Note that you mustn't have more than one global request for the
 216 same function or variable in your project.
 217
 218     Function / Variable       Static Request               Global Request
 219     -----------------------------------------------------------------------------------------
 220     PL_parser                 NEED_PL_parser               NEED_PL_parser_GLOBAL
 221     PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL
 222     eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL
 223     grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL
 224     grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL
 225     grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL
 226     grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL
 227     grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL
 228     load_module()             NEED_load_module             NEED_load_module_GLOBAL
 229     my_snprintf()             NEED_my_snprintf             NEED_my_snprintf_GLOBAL
 230     my_sprintf()              NEED_my_sprintf              NEED_my_sprintf_GLOBAL
 231     my_strlcat()              NEED_my_strlcat              NEED_my_strlcat_GLOBAL
 232     my_strlcpy()              NEED_my_strlcpy              NEED_my_strlcpy_GLOBAL
 233     newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
 234     newRV_noinc()             NEED_newRV_noinc             NEED_newRV_noinc_GLOBAL
 235     newSV_type()              NEED_newSV_type              NEED_newSV_type_GLOBAL
 236     newSVpvn_flags()          NEED_newSVpvn_flags          NEED_newSVpvn_flags_GLOBAL
 237     newSVpvn_share()          NEED_newSVpvn_share          NEED_newSVpvn_share_GLOBAL
 238     pv_display()              NEED_pv_display              NEED_pv_display_GLOBAL
 239     pv_escape()               NEED_pv_escape               NEED_pv_escape_GLOBAL
 240     pv_pretty()               NEED_pv_pretty               NEED_pv_pretty_GLOBAL
 241     sv_2pv_flags()            NEED_sv_2pv_flags            NEED_sv_2pv_flags_GLOBAL
 242     sv_2pvbyte()              NEED_sv_2pvbyte              NEED_sv_2pvbyte_GLOBAL
 243     sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
 244     sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
 245     sv_pvn_force_flags()      NEED_sv_pvn_force_flags      NEED_sv_pvn_force_flags_GLOBAL
 246     sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
 247     sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL
 248     vload_module()            NEED_vload_module            NEED_vload_module_GLOBAL
 249     vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL
 250     warner()                  NEED_warner                  NEED_warner_GLOBAL
 251
 252 To avoid namespace conflicts, you can change the namespace of the
 253 explicitly exported functions / variables using the C<DPPP_NAMESPACE>
 254 macro. Just C<#define> the macro before including C<ppport.h>:
 255
 256     #define DPPP_NAMESPACE MyOwnNamespace_
 257     #include "ppport.h"
 258
 259 The default namespace is C<DPPP_>.
 260
 261 =back
 262
 263 The good thing is that most of the above can be checked by running
 264 F<ppport.h> on your source code. See the next section for
 265 details.
 266
 267 =head1 EXAMPLES
 268
 269 To verify whether F<ppport.h> is needed for your module, whether you
 270 should make any changes to your code, and whether any special defines
 271 should be used, F<ppport.h> can be run as a Perl script to check your
 272 source code. Simply say:
 273
 274     perl ppport.h
 275
 276 The result will usually be a list of patches suggesting changes
 277 that should at least be acceptable, if not necessarily the most
 278 efficient solution, or a fix for all possible problems.
 279
 280 If you know that your XS module uses features only available in
 281 newer Perl releases, if you're aware that it uses C++ comments,
 282 and if you want all suggestions as a single patch file, you could
 283 use something like this:
 284
 285     perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff
 286
 287 If you only want your code to be scanned without any suggestions
 288 for changes, use:
 289
 290     perl ppport.h --nochanges
 291
 292 You can specify a different C<diff> program or options, using
 293 the C<--diff> option:
 294
 295     perl ppport.h --diff='diff -C 10'
 296
 297 This would output context diffs with 10 lines of context.
 298
 299 If you want to create patched copies of your files instead, use:
 300
 301     perl ppport.h --copy=.new
 302
 303 To display portability information for the C<newSVpvn> function,
 304 use:
 305
 306     perl ppport.h --api-info=newSVpvn
 307
 308 Since the argument to C<--api-info> can be a regular expression,
 309 you can use
 310
 311     perl ppport.h --api-info=/_nomg$/
 312
 313 to display portability information for all C<_nomg> functions or
 314
 315     perl ppport.h --api-info=/./
 316
 317 to display information for all known API elements.
 318
 319 =head1 BUGS
 320
 321 If this version of F<ppport.h> is causing failure during
 322 the compilation of this module, please check if newer versions
 323 of either this module or C<Devel::PPPort> are available on CPAN
 324 before sending a bug report.
 325
 326 If F<ppport.h> was generated using the latest version of
 327 C<Devel::PPPort> and is causing failure of this module, please
 328 file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>.
 329
 330 Please include the following information:
 331
 332 =over 4
 333
 334 =item 1.
 335
 336 The complete output from running "perl -V"
 337
 338 =item 2.
 339
 340 This file.
 341
 342 =item 3.
 343
 344 The name and version of the module you were trying to build.
 345
 346 =item 4.
 347
 348 A full log of the build that failed.
 349
 350 =item 5.
 351
 352 Any other information that you think could be relevant.
 353
 354 =back
 355
 356 For the latest version of this code, please get the C<Devel::PPPort>
 357 module from CPAN.
 358
 359 =head1 COPYRIGHT
 360
 361 Version 3.x, Copyright (c) 2004-2009, Marcus Holland-Moritz.
 362
 363 Version 2.x, Copyright (C) 2001, Paul Marquess.
 364
 365 Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
 366
 367 This program is free software; you can redistribute it and/or
 368 modify it under the same terms as Perl itself.
 369
 370 =head1 SEE ALSO
 371
 372 See L<Devel::PPPort>.
 373
 374 =cut
 375
 376 use strict;
 377
 378 # Disable broken TRIE-optimization
 379 BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }
 380
 381 my $VERSION = 3.19;
 382
 383 my %opt = (
 384   quiet     => 0,
 385   diag      => 1,
 386   hints     => 1,
 387   changes   => 1,
 388   cplusplus => 0,
 389   filter    => 1,
 390   strip     => 0,
 391   version   => 0,
 392 );
 393
 394 my($ppport) = $0 =~ /([\w.]+)$/;
 395 my $LF = '(?:\r\n|[\r\n])';   # line feed
 396 my $HS = "[ \t]";             # horizontal whitespace
 397
 398 # Never use C comments in this file!
 399 my $ccs  = '/'.'*';
 400 my $cce  = '*'.'/';
 401 my $rccs = quotemeta $ccs;
 402 my $rcce = quotemeta $cce;
 403
 404 eval {
 405   require Getopt::Long;
 406   Getopt::Long::GetOptions(\%opt, qw(
 407     help quiet diag! filter! hints! changes! cplusplus strip version
 408     patch=s copy=s diff=s compat-version=s
 409     list-provided list-unsupported api-info=s
 410   )) or usage();
 411 };
 412
 413 if ($@ and grep /^-/, @ARGV) {
 414   usage() if "@ARGV" =~ /^--?h(?:elp)?$/;
 415   die "Getopt::Long not found. Please don't use any options.\n";
 416 }
 417
 418 if ($opt{version}) {
 419   print "This is $0 $VERSION.\n";
 420   exit 0;
 421 }
 422
 423 usage() if $opt{help};
 424 strip() if $opt{strip};
 425
 426 if (exists $opt{'compat-version'}) {
 427   my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };
 428   if ($@) {
 429     die "Invalid version number format: '$opt{'compat-version'}'\n";
 430   }
 431   die "Only Perl 5 is supported\n" if $r != 5;
 432   die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;
 433   $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;
 434 }
 435 else {
 436   $opt{'compat-version'} = 5;
 437 }
 438
 439 my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
 440                 ? ( $1 => {
 441                       ($2                  ? ( base     => $2 ) : ()),
 442                       ($3                  ? ( todo     => $3 ) : ()),
 443                       (index($4, 'v') >= 0 ? ( varargs  => 1  ) : ()),
 444                       (index($4, 'p') >= 0 ? ( provided => 1  ) : ()),
 445                       (index($4, 'n') >= 0 ? ( nothxarg => 1  ) : ()),
 446                     } )
 447                 : die "invalid spec: $_" } qw(
 448 AvFILLp|5.004050||p
 449 AvFILL|||
 450 CLASS|||n
 451 CPERLscope|5.005000||p
 452 CX_CURPAD_SAVE|||
 453 CX_CURPAD_SV|||
 454 CopFILEAV|5.006000||p
 455 CopFILEGV_set|5.006000||p
 456 CopFILEGV|5.006000||p
 457 CopFILESV|5.006000||p
 458 CopFILE_set|5.006000||p
 459 CopFILE|5.006000||p
 460 CopSTASHPV_set|5.006000||p
 461 CopSTASHPV|5.006000||p
 462 CopSTASH_eq|5.006000||p
 463 CopSTASH_set|5.006000||p
 464 CopSTASH|5.006000||p
 465 CopyD|5.009002||p
 466 Copy|||
 467 CvPADLIST|||
 468 CvSTASH|||
 469 CvWEAKOUTSIDE|||
 470 DEFSV_set|5.011000||p
 471 DEFSV|5.004050||p
 472 END_EXTERN_C|5.005000||p
 473 ENTER|||
 474 ERRSV|5.004050||p
 475 EXTEND|||
 476 EXTERN_C|5.005000||p
 477 F0convert|||n
 478 FREETMPS|||
 479 GIMME_V||5.004000|n
 480 GIMME|||n
 481 GROK_NUMERIC_RADIX|5.007002||p
 482 G_ARRAY|||
 483 G_DISCARD|||
 484 G_EVAL|||
 485 G_METHOD|5.006001||p
 486 G_NOARGS|||
 487 G_SCALAR|||
 488 G_VOID||5.004000|
 489 GetVars|||
 490 GvSVn|5.009003||p
 491 GvSV|||
 492 Gv_AMupdate|||
 493 HEf_SVKEY||5.004000|
 494 HeHASH||5.004000|
 495 HeKEY||5.004000|
 496 HeKLEN||5.004000|
 497 HePV||5.004000|
 498 HeSVKEY_force||5.004000|
 499 HeSVKEY_set||5.004000|
 500 HeSVKEY||5.004000|
 501 HeUTF8||5.011000|
 502 HeVAL||5.004000|
 503 HvNAMELEN_get|5.009003||p
 504 HvNAME_get|5.009003||p
 505 HvNAME|||
 506 INT2PTR|5.006000||p
 507 IN_LOCALE_COMPILETIME|5.007002||p
 508 IN_LOCALE_RUNTIME|5.007002||p
 509 IN_LOCALE|5.007002||p
 510 IN_PERL_COMPILETIME|5.008001||p
 511 IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p
 512 IS_NUMBER_INFINITY|5.007002||p
 513 IS_NUMBER_IN_UV|5.007002||p
 514 IS_NUMBER_NAN|5.007003||p
 515 IS_NUMBER_NEG|5.007002||p
 516 IS_NUMBER_NOT_INT|5.007002||p
 517 IVSIZE|5.006000||p
 518 IVTYPE|5.006000||p
 519 IVdf|5.006000||p
 520 LEAVE|||
 521 LVRET|||
 522 MARK|||
 523 MULTICALL||5.011000|
 524 MY_CXT_CLONE|5.009002||p
 525 MY_CXT_INIT|5.007003||p
 526 MY_CXT|5.007003||p
 527 MoveD|5.009002||p
 528 Move|||
 529 NOOP|5.005000||p
 530 NUM2PTR|5.006000||p
 531 NVTYPE|5.006000||p
 532 NVef|5.006001||p
 533 NVff|5.006001||p
 534 NVgf|5.006001||p
 535 Newxc|5.009003||p
 536 Newxz|5.009003||p
 537 Newx|5.009003||p
 538 Nullav|||
 539 Nullch|||
 540 Nullcv|||
 541 Nullhv|||
 542 Nullsv|||
 543 ORIGMARK|||
 544 PAD_BASE_SV|||
 545 PAD_CLONE_VARS|||
 546 PAD_COMPNAME_FLAGS|||
 547 PAD_COMPNAME_GEN_set|||
 548 PAD_COMPNAME_GEN|||
 549 PAD_COMPNAME_OURSTASH|||
 550 PAD_COMPNAME_PV|||
 551 PAD_COMPNAME_TYPE|||
 552 PAD_DUP|||
 553 PAD_RESTORE_LOCAL|||
 554 PAD_SAVE_LOCAL|||
 555 PAD_SAVE_SETNULLPAD|||
 556 PAD_SETSV|||
 557 PAD_SET_CUR_NOSAVE|||
 558 PAD_SET_CUR|||
 559 PAD_SVl|||
 560 PAD_SV|||
 561 PERLIO_FUNCS_CAST|5.009003||p
 562 PERLIO_FUNCS_DECL|5.009003||p
 563 PERL_ABS|5.008001||p
 564 PERL_BCDVERSION|5.011000||p
 565 PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p
 566 PERL_HASH|5.004000||p
 567 PERL_INT_MAX|5.004000||p
 568 PERL_INT_MIN|5.004000||p
 569 PERL_LONG_MAX|5.004000||p
 570 PERL_LONG_MIN|5.004000||p
 571 PERL_MAGIC_arylen|5.007002||p
 572 PERL_MAGIC_backref|5.007002||p
 573 PERL_MAGIC_bm|5.007002||p
 574 PERL_MAGIC_collxfrm|5.007002||p
 575 PERL_MAGIC_dbfile|5.007002||p
 576 PERL_MAGIC_dbline|5.007002||p
 577 PERL_MAGIC_defelem|5.007002||p
 578 PERL_MAGIC_envelem|5.007002||p
 579 PERL_MAGIC_env|5.007002||p
 580 PERL_MAGIC_ext|5.007002||p
 581 PERL_MAGIC_fm|5.007002||p
 582 PERL_MAGIC_glob|5.011000||p
 583 PERL_MAGIC_isaelem|5.007002||p
 584 PERL_MAGIC_isa|5.007002||p
 585 PERL_MAGIC_mutex|5.011000||p
 586 PERL_MAGIC_nkeys|5.007002||p
 587 PERL_MAGIC_overload_elem|5.007002||p
 588 PERL_MAGIC_overload_table|5.007002||p
 589 PERL_MAGIC_overload|5.007002||p
 590 PERL_MAGIC_pos|5.007002||p
 591 PERL_MAGIC_qr|5.007002||p
 592 PERL_MAGIC_regdata|5.007002||p
 593 PERL_MAGIC_regdatum|5.007002||p
 594 PERL_MAGIC_regex_global|5.007002||p
 595 PERL_MAGIC_shared_scalar|5.007003||p
 596 PERL_MAGIC_shared|5.007003||p
 597 PERL_MAGIC_sigelem|5.007002||p
 598 PERL_MAGIC_sig|5.007002||p
 599 PERL_MAGIC_substr|5.007002||p
 600 PERL_MAGIC_sv|5.007002||p
 601 PERL_MAGIC_taint|5.007002||p
 602 PERL_MAGIC_tiedelem|5.007002||p
 603 PERL_MAGIC_tiedscalar|5.007002||p
 604 PERL_MAGIC_tied|5.007002||p
 605 PERL_MAGIC_utf8|5.008001||p
 606 PERL_MAGIC_uvar_elem|5.007003||p
 607 PERL_MAGIC_uvar|5.007002||p
 608 PERL_MAGIC_vec|5.007002||p
 609 PERL_MAGIC_vstring|5.008001||p
 610 PERL_PV_ESCAPE_ALL|5.009004||p
 611 PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p
 612 PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p
 613 PERL_PV_ESCAPE_NOCLEAR|5.009004||p
 614 PERL_PV_ESCAPE_QUOTE|5.009004||p
 615 PERL_PV_ESCAPE_RE|5.009005||p
 616 PERL_PV_ESCAPE_UNI_DETECT|5.009004||p
 617 PERL_PV_ESCAPE_UNI|5.009004||p
 618 PERL_PV_PRETTY_DUMP|5.009004||p
 619 PERL_PV_PRETTY_ELLIPSES|5.010000||p
 620 PERL_PV_PRETTY_LTGT|5.009004||p
 621 PERL_PV_PRETTY_NOCLEAR|5.010000||p
 622 PERL_PV_PRETTY_QUOTE|5.009004||p
 623 PERL_PV_PRETTY_REGPROP|5.009004||p
 624 PERL_QUAD_MAX|5.004000||p
 625 PERL_QUAD_MIN|5.004000||p
 626 PERL_REVISION|5.006000||p
 627 PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p
 628 PERL_SCAN_DISALLOW_PREFIX|5.007003||p
 629 PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p
 630 PERL_SCAN_SILENT_ILLDIGIT|5.008001||p
 631 PERL_SHORT_MAX|5.004000||p
 632 PERL_SHORT_MIN|5.004000||p
 633 PERL_SIGNALS_UNSAFE_FLAG|5.008001||p
 634 PERL_SUBVERSION|5.006000||p
 635 PERL_SYS_INIT3||5.006000|
 636 PERL_SYS_INIT|||
 637 PERL_SYS_TERM||5.011000|
 638 PERL_UCHAR_MAX|5.004000||p
 639 PERL_UCHAR_MIN|5.004000||p
 640 PERL_UINT_MAX|5.004000||p
 641 PERL_UINT_MIN|5.004000||p
 642 PERL_ULONG_MAX|5.004000||p
 643 PERL_ULONG_MIN|5.004000||p
 644 PERL_UNUSED_ARG|5.009003||p
 645 PERL_UNUSED_CONTEXT|5.009004||p
 646 PERL_UNUSED_DECL|5.007002||p
 647 PERL_UNUSED_VAR|5.007002||p
 648 PERL_UQUAD_MAX|5.004000||p
 649 PERL_UQUAD_MIN|5.004000||p
 650 PERL_USE_GCC_BRACE_GROUPS|5.009004||p
 651 PERL_USHORT_MAX|5.004000||p
 652 PERL_USHORT_MIN|5.004000||p
 653 PERL_VERSION|5.006000||p
 654 PL_DBsignal|5.005000||p
 655 PL_DBsingle|||pn
 656 PL_DBsub|||pn
 657 PL_DBtrace|||pn
 658 PL_Sv|5.005000||p
 659 PL_bufend|5.011000||p
 660 PL_bufptr|5.011000||p
 661 PL_compiling|5.004050||p
 662 PL_copline|5.011000||p
 663 PL_curcop|5.004050||p
 664 PL_curstash|5.004050||p
 665 PL_debstash|5.004050||p
 666 PL_defgv|5.004050||p
 667 PL_diehook|5.004050||p
 668 PL_dirty|5.004050||p
 669 PL_dowarn|||pn
 670 PL_errgv|5.004050||p
 671 PL_error_count|5.011000||p
 672 PL_expect|5.011000||p
 673 PL_hexdigit|5.005000||p
 674 PL_hints|5.005000||p
 675 PL_in_my_stash|5.011000||p
 676 PL_in_my|5.011000||p
 677 PL_last_in_gv|||n
 678 PL_laststatval|5.005000||p
 679 PL_lex_state|5.011000||p
 680 PL_lex_stuff|5.011000||p
 681 PL_linestr|5.011000||p
 682 PL_modglobal||5.005000|n
 683 PL_na|5.004050||pn
 684 PL_no_modify|5.006000||p
 685 PL_ofsgv|||n
 686 PL_parser|5.009005||p
 687 PL_perl_destruct_level|5.004050||p
 688 PL_perldb|5.004050||p
 689 PL_ppaddr|5.006000||p
 690 PL_rsfp_filters|5.004050||p
 691 PL_rsfp|5.004050||p
 692 PL_rs|||n
 693 PL_signals|5.008001||p
 694 PL_stack_base|5.004050||p
 695 PL_stack_sp|5.004050||p
 696 PL_statcache|5.005000||p
 697 PL_stdingv|5.004050||p
 698 PL_sv_arenaroot|5.004050||p
 699 PL_sv_no|5.004050||pn
 700 PL_sv_undef|5.004050||pn
 701 PL_sv_yes|5.004050||pn
 702 PL_tainted|5.004050||p
 703 PL_tainting|5.004050||p
 704 PL_tokenbuf|5.011000||p
 705 POP_MULTICALL||5.011000|
 706 POPi|||n
 707 POPl|||n
 708 POPn|||n
 709 POPpbytex||5.007001|n
 710 POPpx||5.005030|n
 711 POPp|||n
 712 POPs|||n
 713 PTR2IV|5.006000||p
 714 PTR2NV|5.006000||p
 715 PTR2UV|5.006000||p
 716 PTR2nat|5.009003||p
 717 PTR2ul|5.007001||p
 718 PTRV|5.006000||p
 719 PUSHMARK|||
 720 PUSH_MULTICALL||5.011000|
 721 PUSHi|||
 722 PUSHmortal|5.009002||p
 723 PUSHn|||
 724 PUSHp|||
 725 PUSHs|||
 726 PUSHu|5.004000||p
 727 PUTBACK|||
 728 PerlIO_clearerr||5.007003|
 729 PerlIO_close||5.007003|
 730 PerlIO_context_layers||5.009004|
 731 PerlIO_eof||5.007003|
 732 PerlIO_error||5.007003|
 733 PerlIO_fileno||5.007003|
 734 PerlIO_fill||5.007003|
 735 PerlIO_flush||5.007003|
 736 PerlIO_get_base||5.007003|
 737 PerlIO_get_bufsiz||5.007003|
 738 PerlIO_get_cnt||5.007003|
 739 PerlIO_get_ptr||5.007003|
 740 PerlIO_read||5.007003|
 741 PerlIO_seek||5.007003|
 742 PerlIO_set_cnt||5.007003|
 743 PerlIO_set_ptrcnt||5.007003|
 744 PerlIO_setlinebuf||5.007003|
 745 PerlIO_stderr||5.007003|
 746 PerlIO_stdin||5.007003|
 747 PerlIO_stdout||5.007003|
 748 PerlIO_tell||5.007003|
 749 PerlIO_unread||5.007003|
 750 PerlIO_write||5.007003|
 751 Perl_signbit||5.009005|n
 752 PoisonFree|5.009004||p
 753 PoisonNew|5.009004||p
 754 PoisonWith|5.009004||p
 755 Poison|5.008000||p
 756 RETVAL|||n
 757 Renewc|||
 758 Renew|||
 759 SAVECLEARSV|||
 760 SAVECOMPPAD|||
 761 SAVEPADSV|||
 762 SAVETMPS|||
 763 SAVE_DEFSV|5.004050||p
 764 SPAGAIN|||
 765 SP|||
 766 START_EXTERN_C|5.005000||p
 767 START_MY_CXT|5.007003||p
 768 STMT_END|||p
 769 STMT_START|||p
 770 STR_WITH_LEN|5.009003||p
 771 ST|||
 772 SV_CONST_RETURN|5.009003||p
 773 SV_COW_DROP_PV|5.008001||p
 774 SV_COW_SHARED_HASH_KEYS|5.009005||p
 775 SV_GMAGIC|5.007002||p
 776 SV_HAS_TRAILING_NUL|5.009004||p
 777 SV_IMMEDIATE_UNREF|5.007001||p
 778 SV_MUTABLE_RETURN|5.009003||p
 779 SV_NOSTEAL|5.009002||p
 780 SV_SMAGIC|5.009003||p
 781 SV_UTF8_NO_ENCODING|5.008001||p
 782 SVfARG|5.009005||p
 783 SVf_UTF8|5.006000||p
 784 SVf|5.006000||p
 785 SVt_IV|||
 786 SVt_NV|||
 787 SVt_PVAV|||
 788 SVt_PVCV|||
 789 SVt_PVHV|||
 790 SVt_PVMG|||
 791 SVt_PV|||
 792 Safefree|||
 793 Slab_Alloc|||
 794 Slab_Free|||
 795 Slab_to_rw|||
 796 StructCopy|||
 797 SvCUR_set|||
 798 SvCUR|||
 799 SvEND|||
 800 SvGAMAGIC||5.006001|
 801 SvGETMAGIC|5.004050||p
 802 SvGROW|||
 803 SvIOK_UV||5.006000|
 804 SvIOK_notUV||5.006000|
 805 SvIOK_off|||
 806 SvIOK_only_UV||5.006000|
 807 SvIOK_only|||
 808 SvIOK_on|||
 809 SvIOKp|||
 810 SvIOK|||
 811 SvIVX|||
 812 SvIV_nomg|5.009001||p
 813 SvIV_set|||
 814 SvIVx|||
 815 SvIV|||
 816 SvIsCOW_shared_hash||5.008003|
 817 SvIsCOW||5.008003|
 818 SvLEN_set|||
 819 SvLEN|||
 820 SvLOCK||5.007003|
 821 SvMAGIC_set|5.009003||p
 822 SvNIOK_off|||
 823 SvNIOKp|||
 824 SvNIOK|||
 825 SvNOK_off|||
 826 SvNOK_only|||
 827 SvNOK_on|||
 828 SvNOKp|||
 829 SvNOK|||
 830 SvNVX|||
 831 SvNV_set|||
 832 SvNVx|||
 833 SvNV|||
 834 SvOK|||
 835 SvOOK_offset||5.011000|
 836 SvOOK|||
 837 SvPOK_off|||
 838 SvPOK_only_UTF8||5.006000|
 839 SvPOK_only|||
 840 SvPOK_on|||
 841 SvPOKp|||
 842 SvPOK|||
 843 SvPVX_const|5.009003||p
 844 SvPVX_mutable|5.009003||p
 845 SvPVX|||
 846 SvPV_const|5.009003||p
 847 SvPV_flags_const_nolen|5.009003||p
 848 SvPV_flags_const|5.009003||p
 849 SvPV_flags_mutable|5.009003||p
 850 SvPV_flags|5.007002||p
 851 SvPV_force_flags_mutable|5.009003||p
 852 SvPV_force_flags_nolen|5.009003||p
 853 SvPV_force_flags|5.007002||p
 854 SvPV_force_mutable|5.009003||p
 855 SvPV_force_nolen|5.009003||p
 856 SvPV_force_nomg_nolen|5.009003||p
 857 SvPV_force_nomg|5.007002||p
 858 SvPV_force|||p
 859 SvPV_mutable|5.009003||p
 860 SvPV_nolen_const|5.009003||p
 861 SvPV_nolen|5.006000||p
 862 SvPV_nomg_const_nolen|5.009003||p
 863 SvPV_nomg_const|5.009003||p
 864 SvPV_nomg|5.007002||p
 865 SvPV_renew|5.009003||p
 866 SvPV_set|||
 867 SvPVbyte_force||5.009002|
 868 SvPVbyte_nolen||5.006000|
 869 SvPVbytex_force||5.006000|
 870 SvPVbytex||5.006000|
 871 SvPVbyte|5.006000||p
 872 SvPVutf8_force||5.006000|
 873 SvPVutf8_nolen||5.006000|
 874 SvPVutf8x_force||5.006000|
 875 SvPVutf8x||5.006000|
 876 SvPVutf8||5.006000|
 877 SvPVx|||
 878 SvPV|||
 879 SvREFCNT_dec|||
 880 SvREFCNT_inc_NN|5.009004||p
 881 SvREFCNT_inc_simple_NN|5.009004||p
 882 SvREFCNT_inc_simple_void_NN|5.009004||p
 883 SvREFCNT_inc_simple_void|5.009004||p
 884 SvREFCNT_inc_simple|5.009004||p
 885 SvREFCNT_inc_void_NN|5.009004||p
 886 SvREFCNT_inc_void|5.009004||p
 887 SvREFCNT_inc|||p
 888 SvREFCNT|||
 889 SvROK_off|||
 890 SvROK_on|||
 891 SvROK|||
 892 SvRV_set|5.009003||p
 893 SvRV|||
 894 SvRXOK||5.009005|
 895 SvRX||5.009005|
 896 SvSETMAGIC|||
 897 SvSHARED_HASH|5.009003||p
 898 SvSHARE||5.007003|
 899 SvSTASH_set|5.009003||p
 900 SvSTASH|||
 901 SvSetMagicSV_nosteal||5.004000|
 902 SvSetMagicSV||5.004000|
 903 SvSetSV_nosteal||5.004000|
 904 SvSetSV|||
 905 SvTAINTED_off||5.004000|
 906 SvTAINTED_on||5.004000|
 907 SvTAINTED||5.004000|
 908 SvTAINT|||
 909 SvTRUE|||
 910 SvTYPE|||
 911 SvUNLOCK||5.007003|
 912 SvUOK|5.007001|5.006000|p
 913 SvUPGRADE|||
 914 SvUTF8_off||5.006000|
 915 SvUTF8_on||5.006000|
 916 SvUTF8||5.006000|
 917 SvUVXx|5.004000||p
 918 SvUVX|5.004000||p
 919 SvUV_nomg|5.009001||p
 920 SvUV_set|5.009003||p
 921 SvUVx|5.004000||p
 922 SvUV|5.004000||p
 923 SvVOK||5.008001|
 924 SvVSTRING_mg|5.009004||p
 925 THIS|||n
 926 UNDERBAR|5.009002||p
 927 UTF8_MAXBYTES|5.009002||p
 928 UVSIZE|5.006000||p
 929 UVTYPE|5.006000||p
 930 UVXf|5.007001||p
 931 UVof|5.006000||p
 932 UVuf|5.006000||p
 933 UVxf|5.006000||p
 934 WARN_ALL|5.006000||p
 935 WARN_AMBIGUOUS|5.006000||p
 936 WARN_ASSERTIONS|5.011000||p
 937 WARN_BAREWORD|5.006000||p
 938 WARN_CLOSED|5.006000||p
 939 WARN_CLOSURE|5.006000||p
 940 WARN_DEBUGGING|5.006000||p
 941 WARN_DEPRECATED|5.006000||p
 942 WARN_DIGIT|5.006000||p
 943 WARN_EXEC|5.006000||p
 944 WARN_EXITING|5.006000||p
 945 WARN_GLOB|5.006000||p
 946 WARN_INPLACE|5.006000||p
 947 WARN_INTERNAL|5.006000||p
 948 WARN_IO|5.006000||p
 949 WARN_LAYER|5.008000||p
 950 WARN_MALLOC|5.006000||p
 951 WARN_MISC|5.006000||p
 952 WARN_NEWLINE|5.006000||p
 953 WARN_NUMERIC|5.006000||p
 954 WARN_ONCE|5.006000||p
 955 WARN_OVERFLOW|5.006000||p
 956 WARN_PACK|5.006000||p
 957 WARN_PARENTHESIS|5.006000||p
 958 WARN_PIPE|5.006000||p
 959 WARN_PORTABLE|5.006000||p
 960 WARN_PRECEDENCE|5.006000||p
 961 WARN_PRINTF|5.006000||p
 962 WARN_PROTOTYPE|5.006000||p
 963 WARN_QW|5.006000||p
 964 WARN_RECURSION|5.006000||p
 965 WARN_REDEFINE|5.006000||p
 966 WARN_REGEXP|5.006000||p
 967 WARN_RESERVED|5.006000||p
 968 WARN_SEMICOLON|5.006000||p
 969 WARN_SEVERE|5.006000||p
 970 WARN_SIGNAL|5.006000||p
 971 WARN_SUBSTR|5.006000||p
 972 WARN_SYNTAX|5.006000||p
 973 WARN_TAINT|5.006000||p
 974 WARN_THREADS|5.008000||p
 975 WARN_UNINITIALIZED|5.006000||p
 976 WARN_UNOPENED|5.006000||p
 977 WARN_UNPACK|5.006000||p
 978 WARN_UNTIE|5.006000||p
 979 WARN_UTF8|5.006000||p
 980 WARN_VOID|5.006000||p
 981 XCPT_CATCH|5.009002||p
 982 XCPT_RETHROW|5.009002||p
 983 XCPT_TRY_END|5.009002||p
 984 XCPT_TRY_START|5.009002||p
 985 XPUSHi|||
 986 XPUSHmortal|5.009002||p
 987 XPUSHn|||
 988 XPUSHp|||
 989 XPUSHs|||
 990 XPUSHu|5.004000||p
 991 XSPROTO|5.010000||p
 992 XSRETURN_EMPTY|||
 993 XSRETURN_IV|||
 994 XSRETURN_NO|||
 995 XSRETURN_NV|||
 996 XSRETURN_PV|||
 997 XSRETURN_UNDEF|||
 998 XSRETURN_UV|5.008001||p
 999 XSRETURN_YES|||
1000 XSRETURN|||p
1001 XST_mIV|||
1002 XST_mNO|||
1003 XST_mNV|||
1004 XST_mPV|||
1005 XST_mUNDEF|||
1006 XST_mUV|5.008001||p
1007 XST_mYES|||
1008 XS_VERSION_BOOTCHECK|||
1009 XS_VERSION|||
1010 XSprePUSH|5.006000||p
1011 XS|||
1012 ZeroD|5.009002||p
1013 Zero|||
1014 _aMY_CXT|5.007003||p
1015 _pMY_CXT|5.007003||p
1016 aMY_CXT_|5.007003||p
1017 aMY_CXT|5.007003||p
1018 aTHXR_|5.011000||p
1019 aTHXR|5.011000||p
1020 aTHX_|5.006000||p
1021 aTHX|5.006000||p
1022 add_data|||n
1023 addmad|||
1024 allocmy|||
1025 amagic_call|||
1026 amagic_cmp_locale|||
1027 amagic_cmp|||
1028 amagic_i_ncmp|||
1029 amagic_ncmp|||
1030 any_dup|||
1031 ao|||
1032 append_elem|||
1033 append_list|||
1034 append_madprops|||
1035 apply_attrs_my|||
1036 apply_attrs_string||5.006001|
1037 apply_attrs|||
1038 apply|||
1039 atfork_lock||5.007003|n
1040 atfork_unlock||5.007003|n
1041 av_arylen_p||5.009003|
1042 av_clear|||
1043 av_create_and_push||5.009005|
1044 av_create_and_unshift_one||5.009005|
1045 av_delete||5.006000|
1046 av_exists||5.006000|
1047 av_extend|||
1048 av_fetch|||
1049 av_fill|||
1050 av_iter_p||5.011000|
1051 av_len|||
1052 av_make|||
1053 av_pop|||
1054 av_push|||
1055 av_reify|||
1056 av_shift|||
1057 av_store|||
1058 av_undef|||
1059 av_unshift|||
1060 ax|||n
1061 bad_type|||
1062 bind_match|||
1063 block_end|||
1064 block_gimme||5.004000|
1065 block_start|||
1066 boolSV|5.004000||p
1067 boot_core_PerlIO|||
1068 boot_core_UNIVERSAL|||
1069 boot_core_mro|||
1070 bytes_from_utf8||5.007001|
1071 bytes_to_uni|||n
1072 bytes_to_utf8||5.006001|
1073 call_argv|5.006000||p
1074 call_atexit||5.006000|
1075 call_list||5.004000|
1076 call_method|5.006000||p
1077 call_pv|5.006000||p
1078 call_sv|5.006000||p
1079 calloc||5.007002|n
1080 cando|||
1081 cast_i32||5.006000|
1082 cast_iv||5.006000|
1083 cast_ulong||5.006000|
1084 cast_uv||5.006000|
1085 check_type_and_open|||
1086 check_uni|||
1087 checkcomma|||
1088 checkposixcc|||
1089 ckWARN|5.006000||p
1090 ck_anoncode|||
1091 ck_bitop|||
1092 ck_concat|||
1093 ck_defined|||
1094 ck_delete|||
1095 ck_die|||
1096 ck_each|||
1097 ck_eof|||
1098 ck_eval|||
1099 ck_exec|||
1100 ck_exists|||
1101 ck_exit|||
1102 ck_ftst|||
1103 ck_fun|||
1104 ck_glob|||
1105 ck_grep|||
1106 ck_index|||
1107 ck_join|||
1108 ck_lfun|||
1109 ck_listiob|||
1110 ck_match|||
1111 ck_method|||
1112 ck_null|||
1113 ck_open|||
1114 ck_readline|||
1115 ck_repeat|||
1116 ck_require|||
1117 ck_return|||
1118 ck_rfun|||
1119 ck_rvconst|||
1120 ck_sassign|||
1121 ck_select|||
1122 ck_shift|||
1123 ck_sort|||
1124 ck_spair|||
1125 ck_split|||
1126 ck_subr|||
1127 ck_substr|||
1128 ck_svconst|||
1129 ck_trunc|||
1130 ck_unpack|||
1131 ckwarn_d||5.009003|
1132 ckwarn||5.009003|
1133 cl_and|||n
1134 cl_anything|||n
1135 cl_init_zero|||n
1136 cl_init|||n
1137 cl_is_anything|||n
1138 cl_or|||n
1139 clear_placeholders|||
1140 closest_cop|||
1141 convert|||
1142 cop_free|||
1143 cr_textfilter|||
1144 create_eval_scope|||
1145 croak_nocontext|||vn
1146 croak_xs_usage||5.011000|
1147 croak|||v
1148 csighandler||5.009003|n
1149 curmad|||
1150 custom_op_desc||5.007003|
1151 custom_op_name||5.007003|
1152 cv_ckproto_len|||
1153 cv_clone|||
1154 cv_const_sv||5.004000|
1155 cv_dump|||
1156 cv_undef|||
1157 cx_dump||5.005000|
1158 cx_dup|||
1159 cxinc|||
1160 dAXMARK|5.009003||p
1161 dAX|5.007002||p
1162 dITEMS|5.007002||p
1163 dMARK|||
1164 dMULTICALL||5.009003|
1165 dMY_CXT_SV|5.007003||p
1166 dMY_CXT|5.007003||p
1167 dNOOP|5.006000||p
1168 dORIGMARK|||
1169 dSP|||
1170 dTHR|5.004050||p
1171 dTHXR|5.011000||p
1172 dTHXa|5.006000||p
1173 dTHXoa|5.006000||p
1174 dTHX|5.006000||p
1175 dUNDERBAR|5.009002||p
1176 dVAR|5.009003||p
1177 dXCPT|5.009002||p
1178 dXSARGS|||
1179 dXSI32|||
1180 dXSTARG|5.006000||p
1181 deb_curcv|||
1182 deb_nocontext|||vn
1183 deb_stack_all|||
1184 deb_stack_n|||
1185 debop||5.005000|
1186 debprofdump||5.005000|
1187 debprof|||
1188 debstackptrs||5.007003|
1189 debstack||5.007003|
1190 debug_start_match|||
1191 deb||5.007003|v
1192 del_sv|||
1193 delete_eval_scope|||
1194 delimcpy||5.004000|
1195 deprecate_old|||
1196 deprecate|||
1197 despatch_signals||5.007001|
1198 destroy_matcher|||
1199 die_nocontext|||vn
1200 die_where|||
1201 die|||v
1202 dirp_dup|||
1203 div128|||
1204 djSP|||
1205 do_aexec5|||
1206 do_aexec|||
1207 do_aspawn|||
1208 do_binmode||5.004050|
1209 do_chomp|||
1210 do_chop|||
1211 do_close|||
1212 do_dump_pad|||
1213 do_eof|||
1214 do_exec3|||
1215 do_execfree|||
1216 do_exec|||
1217 do_gv_dump||5.006000|
1218 do_gvgv_dump||5.006000|
1219 do_hv_dump||5.006000|
1220 do_ipcctl|||
1221 do_ipcget|||
1222 do_join|||
1223 do_kv|||
1224 do_magic_dump||5.006000|
1225 do_msgrcv|||
1226 do_msgsnd|||
1227 do_oddball|||
1228 do_op_dump||5.006000|
1229 do_op_xmldump|||
1230 do_open9||5.006000|
1231 do_openn||5.007001|
1232 do_open||5.004000|
1233 do_pmop_dump||5.006000|
1234 do_pmop_xmldump|||
1235 do_print|||
1236 do_readline|||
1237 do_seek|||
1238 do_semop|||
1239 do_shmio|||
1240 do_smartmatch|||
1241 do_spawn_nowait|||
1242 do_spawn|||
1243 do_sprintf|||
1244 do_sv_dump||5.006000|
1245 do_sysseek|||
1246 do_tell|||
1247 do_trans_complex_utf8|||
1248 do_trans_complex|||
1249 do_trans_count_utf8|||
1250 do_trans_count|||
1251 do_trans_simple_utf8|||
1252 do_trans_simple|||
1253 do_trans|||
1254 do_vecget|||
1255 do_vecset|||
1256 do_vop|||
1257 docatch|||
1258 doeval|||
1259 dofile|||
1260 dofindlabel|||
1261 doform|||
1262 doing_taint||5.008001|n
1263 dooneliner|||
1264 doopen_pm|||
1265 doparseform|||
1266 dopoptoeval|||
1267 dopoptogiven|||
1268 dopoptolabel|||
1269 dopoptoloop|||
1270 dopoptosub_at|||
1271 dopoptowhen|||
1272 doref||5.009003|
1273 dounwind|||
1274 dowantarray|||
1275 dump_all||5.006000|
1276 dump_eval||5.006000|
1277 dump_exec_pos|||
1278 dump_fds|||
1279 dump_form||5.006000|
1280 dump_indent||5.006000|v
1281 dump_mstats|||
1282 dump_packsubs||5.006000|
1283 dump_sub||5.006000|
1284 dump_sv_child|||
1285 dump_trie_interim_list|||
1286 dump_trie_interim_table|||
1287 dump_trie|||
1288 dump_vindent||5.006000|
1289 dumpuntil|||
1290 dup_attrlist|||
1291 emulate_cop_io|||
1292 eval_pv|5.006000||p
1293 eval_sv|5.006000||p
1294 exec_failed|||
1295 expect_number|||
1296 fbm_compile||5.005000|
1297 fbm_instr||5.005000|
1298 feature_is_enabled|||
1299 fetch_cop_label||5.011000|
1300 filter_add|||
1301 filter_del|||
1302 filter_gets|||
1303 filter_read|||
1304 find_and_forget_pmops|||
1305 find_array_subscript|||
1306 find_beginning|||
1307 find_byclass|||
1308 find_hash_subscript|||
1309 find_in_my_stash|||
1310 find_runcv||5.008001|
1311 find_rundefsvoffset||5.009002|
1312 find_script|||
1313 find_uninit_var|||
1314 first_symbol|||n
1315 fold_constants|||
1316 forbid_setid|||
1317 force_ident|||
1318 force_list|||
1319 force_next|||
1320 force_version|||
1321 force_word|||
1322 forget_pmop|||
1323 form_nocontext|||vn
1324 form||5.004000|v
1325 fp_dup|||
1326 fprintf_nocontext|||vn
1327 free_global_struct|||
1328 free_tied_hv_pool|||
1329 free_tmps|||
1330 gen_constant_list|||
1331 get_arena|||
1332 get_aux_mg|||
1333 get_av|5.006000||p
1334 get_context||5.006000|n
1335 get_cvn_flags||5.009005|
1336 get_cv|5.006000||p
1337 get_db_sub|||
1338 get_debug_opts|||
1339 get_hash_seed|||
1340 get_hv|5.006000||p
1341 get_isa_hash|||
1342 get_mstats|||
1343 get_no_modify|||
1344 get_num|||
1345 get_op_descs||5.005000|
1346 get_op_names||5.005000|
1347 get_opargs|||
1348 get_ppaddr||5.006000|
1349 get_re_arg|||
1350 get_sv|5.006000||p
1351 get_vtbl||5.005030|
1352 getcwd_sv||5.007002|
1353 getenv_len|||
1354 glob_2number|||
1355 glob_assign_glob|||
1356 glob_assign_ref|||
1357 gp_dup|||
1358 gp_free|||
1359 gp_ref|||
1360 grok_bin|5.007003||p
1361 grok_hex|5.007003||p
1362 grok_number|5.007002||p
1363 grok_numeric_radix|5.007002||p
1364 grok_oct|5.007003||p
1365 group_end|||
1366 gv_AVadd|||
1367 gv_HVadd|||
1368 gv_IOadd|||
1369 gv_SVadd|||
1370 gv_autoload4||5.004000|
1371 gv_check|||
1372 gv_const_sv||5.009003|
1373 gv_dump||5.006000|
1374 gv_efullname3||5.004000|
1375 gv_efullname4||5.006001|
1376 gv_efullname|||
1377 gv_ename|||
1378 gv_fetchfile_flags||5.009005|
1379 gv_fetchfile|||
1380 gv_fetchmeth_autoload||5.007003|
1381 gv_fetchmethod_autoload||5.004000|
1382 gv_fetchmethod_flags||5.011000|
1383 gv_fetchmethod|||
1384 gv_fetchmeth|||
1385 gv_fetchpvn_flags|5.009002||p
1386 gv_fetchpvs|5.009004||p
1387 gv_fetchpv|||
1388 gv_fetchsv||5.009002|
1389 gv_fullname3||5.004000|
1390 gv_fullname4||5.006001|
1391 gv_fullname|||
1392 gv_get_super_pkg|||
1393 gv_handler||5.007001|
1394 gv_init_sv|||
1395 gv_init|||
1396 gv_name_set||5.009004|
1397 gv_stashpvn|5.004000||p
1398 gv_stashpvs|5.009003||p
1399 gv_stashpv|||
1400 gv_stashsv|||
1401 he_dup|||
1402 hek_dup|||
1403 hfreeentries|||
1404 hsplit|||
1405 hv_assert||5.011000|
1406 hv_auxinit|||n
1407 hv_backreferences_p|||
1408 hv_clear_placeholders||5.009001|
1409 hv_clear|||
1410 hv_common_key_len||5.010000|
1411 hv_common||5.010000|
1412 hv_copy_hints_hv|||
1413 hv_delayfree_ent||5.004000|
1414 hv_delete_common|||
1415 hv_delete_ent||5.004000|
1416 hv_delete|||
1417 hv_eiter_p||5.009003|
1418 hv_eiter_set||5.009003|
1419 hv_exists_ent||5.004000|
1420 hv_exists|||
1421 hv_fetch_ent||5.004000|
1422 hv_fetchs|5.009003||p
1423 hv_fetch|||
1424 hv_free_ent||5.004000|
1425 hv_iterinit|||
1426 hv_iterkeysv||5.004000|
1427 hv_iterkey|||
1428 hv_iternext_flags||5.008000|
1429 hv_iternextsv|||
1430 hv_iternext|||
1431 hv_iterval|||
1432 hv_kill_backrefs|||
1433 hv_ksplit||5.004000|
1434 hv_magic_check|||n
1435 hv_magic|||
1436 hv_name_set||5.009003|
1437 hv_notallowed|||
1438 hv_placeholders_get||5.009003|
1439 hv_placeholders_p||5.009003|
1440 hv_placeholders_set||5.009003|
1441 hv_riter_p||5.009003|
1442 hv_riter_set||5.009003|
1443 hv_scalar||5.009001|
1444 hv_store_ent||5.004000|
1445 hv_store_flags||5.008000|
1446 hv_stores|5.009004||p
1447 hv_store|||
1448 hv_undef|||
1449 ibcmp_locale||5.004000|
1450 ibcmp_utf8||5.007003|
1451 ibcmp|||
1452 incline|||
1453 incpush_if_exists|||
1454 incpush_use_sep|||
1455 incpush|||
1456 ingroup|||
1457 init_argv_symbols|||
1458 init_debugger|||
1459 init_global_struct|||
1460 init_i18nl10n||5.006000|
1461 init_i18nl14n||5.006000|
1462 init_ids|||
1463 init_interp|||
1464 init_main_stash|||
1465 init_perllib|||
1466 init_postdump_symbols|||
1467 init_predump_symbols|||
1468 init_stacks||5.005000|
1469 init_tm||5.007002|
1470 instr|||
1471 intro_my|||
1472 intuit_method|||
1473 intuit_more|||
1474 invert|||
1475 io_close|||
1476 isALNUMC|5.006000||p
1477 isALNUM|||
1478 isALPHA|||
1479 isASCII|5.006000||p
1480 isBLANK|5.006001||p
1481 isCNTRL|5.006000||p
1482 isDIGIT|||
1483 isGRAPH|5.006000||p
1484 isGV_with_GP|5.009004||p
1485 isLOWER|||
1486 isPRINT|5.004000||p
1487 isPSXSPC|5.006001||p
1488 isPUNCT|5.006000||p
1489 isSPACE|||
1490 isUPPER|||
1491 isXDIGIT|5.006000||p
1492 is_an_int|||
1493 is_gv_magical_sv|||
1494 is_handle_constructor|||n
1495 is_list_assignment|||
1496 is_lvalue_sub||5.007001|
1497 is_uni_alnum_lc||5.006000|
1498 is_uni_alnumc_lc||5.006000|
1499 is_uni_alnumc||5.006000|
1500 is_uni_alnum||5.006000|
1501 is_uni_alpha_lc||5.006000|
1502 is_uni_alpha||5.006000|
1503 is_uni_ascii_lc||5.006000|
1504 is_uni_ascii||5.006000|
1505 is_uni_cntrl_lc||5.006000|
1506 is_uni_cntrl||5.006000|
1507 is_uni_digit_lc||5.006000|
1508 is_uni_digit||5.006000|
1509 is_uni_graph_lc||5.006000|
1510 is_uni_graph||5.006000|
1511 is_uni_idfirst_lc||5.006000|
1512 is_uni_idfirst||5.006000|
1513 is_uni_lower_lc||5.006000|
1514 is_uni_lower||5.006000|
1515 is_uni_print_lc||5.006000|
1516 is_uni_print||5.006000|
1517 is_uni_punct_lc||5.006000|
1518 is_uni_punct||5.006000|
1519 is_uni_space_lc||5.006000|
1520 is_uni_space||5.006000|
1521 is_uni_upper_lc||5.006000|
1522 is_uni_upper||5.006000|
1523 is_uni_xdigit_lc||5.006000|
1524 is_uni_xdigit||5.006000|
1525 is_utf8_alnumc||5.006000|
1526 is_utf8_alnum||5.006000|
1527 is_utf8_alpha||5.006000|
1528 is_utf8_ascii||5.006000|
1529 is_utf8_char_slow|||n
1530 is_utf8_char||5.006000|
1531 is_utf8_cntrl||5.006000|
1532 is_utf8_common|||
1533 is_utf8_digit||5.006000|
1534 is_utf8_graph||5.006000|
1535 is_utf8_idcont||5.008000|
1536 is_utf8_idfirst||5.006000|
1537 is_utf8_lower||5.006000|
1538 is_utf8_mark||5.006000|
1539 is_utf8_print||5.006000|
1540 is_utf8_punct||5.006000|
1541 is_utf8_space||5.006000|
1542 is_utf8_string_loclen||5.009003|
1543 is_utf8_string_loc||5.008001|
1544 is_utf8_string||5.006001|
1545 is_utf8_upper||5.006000|
1546 is_utf8_xdigit||5.006000|
1547 isa_lookup|||
1548 items|||n
1549 ix|||n
1550 jmaybe|||
1551 join_exact|||
1552 keyword|||
1553 leave_scope|||
1554 lex_end|||
1555 lex_start|||
1556 linklist|||
1557 listkids|||
1558 list|||
1559 load_module_nocontext|||vn
1560 load_module|5.006000||pv
1561 localize|||
1562 looks_like_bool|||
1563 looks_like_number|||
1564 lop|||
1565 mPUSHi|5.009002||p
1566 mPUSHn|5.009002||p
1567 mPUSHp|5.009002||p
1568 mPUSHs|5.011000||p
1569 mPUSHu|5.009002||p
1570 mXPUSHi|5.009002||p
1571 mXPUSHn|5.009002||p
1572 mXPUSHp|5.009002||p
1573 mXPUSHs|5.011000||p
1574 mXPUSHu|5.009002||p
1575 mad_free|||
1576 madlex|||
1577 madparse|||
1578 magic_clear_all_env|||
1579 magic_clearenv|||
1580 magic_clearhint|||
1581 magic_clearisa|||
1582 magic_clearpack|||
1583 magic_clearsig|||
1584 magic_dump||5.006000|
1585 magic_existspack|||
1586 magic_freearylen_p|||
1587 magic_freeovrld|||
1588 magic_getarylen|||
1589 magic_getdefelem|||
1590 magic_getnkeys|||
1591 magic_getpack|||
1592 magic_getpos|||
1593 magic_getsig|||
1594 magic_getsubstr|||
1595 magic_gettaint|||
1596 magic_getuvar|||
1597 magic_getvec|||
1598 magic_get|||
1599 magic_killbackrefs|||
1600 magic_len|||
1601 magic_methcall|||
1602 magic_methpack|||
1603 magic_nextpack|||
1604 magic_regdata_cnt|||
1605 magic_regdatum_get|||
1606 magic_regdatum_set|||
1607 magic_scalarpack|||
1608 magic_set_all_env|||
1609 magic_setamagic|||
1610 magic_setarylen|||
1611 magic_setcollxfrm|||
1612 magic_setdbline|||
1613 magic_setdefelem|||
1614 magic_setenv|||
1615 magic_sethint|||
1616 magic_setisa|||
1617 magic_setmglob|||
1618 magic_setnkeys|||
1619 magic_setpack|||
1620 magic_setpos|||
1621 magic_setregexp|||
1622 magic_setsig|||
1623 magic_setsubstr|||
1624 magic_settaint|||
1625 magic_setutf8|||
1626 magic_setuvar|||
1627 magic_setvec|||
1628 magic_set|||
1629 magic_sizepack|||
1630 magic_wipepack|||
1631 make_matcher|||
1632 make_trie_failtable|||
1633 make_trie|||
1634 malloc_good_size|||n
1635 malloced_size|||n
1636 malloc||5.007002|n
1637 markstack_grow|||
1638 matcher_matches_sv|||
1639 measure_struct|||
1640 memEQ|5.004000||p
1641 memNE|5.004000||p
1642 mem_collxfrm|||
1643 mem_log_common|||n
1644 mess_alloc|||
1645 mess_nocontext|||vn
1646 mess||5.006000|v
1647 method_common|||
1648 mfree||5.007002|n
1649 mg_clear|||
1650 mg_copy|||
1651 mg_dup|||
1652 mg_find|||
1653 mg_free|||
1654 mg_get|||
1655 mg_length||5.005000|
1656 mg_localize|||
1657 mg_magical|||
1658 mg_set|||
1659 mg_size||5.005000|
1660 mini_mktime||5.007002|
1661 missingterm|||
1662 mode_from_discipline|||
1663 modkids|||
1664 mod|||
1665 more_bodies|||
1666 more_sv|||
1667 moreswitches|||
1668 mro_get_from_name||5.011000|
1669 mro_get_linear_isa_dfs|||
1670 mro_get_linear_isa||5.009005|
1671 mro_get_private_data||5.011000|
1672 mro_isa_changed_in|||
1673 mro_meta_dup|||
1674 mro_meta_init|||
1675 mro_method_changed_in||5.009005|
1676 mro_register||5.011000|
1677 mro_set_mro||5.011000|
1678 mro_set_private_data||5.011000|
1679 mul128|||
1680 mulexp10|||n
1681 my_atof2||5.007002|
1682 my_atof||5.006000|
1683 my_attrs|||
1684 my_bcopy|||n
1685 my_betoh16|||n
1686 my_betoh32|||n
1687 my_betoh64|||n
1688 my_betohi|||n
1689 my_betohl|||n
1690 my_betohs|||n
1691 my_bzero|||n
1692 my_chsize|||
1693 my_clearenv|||
1694 my_cxt_index|||
1695 my_cxt_init|||
1696 my_dirfd||5.009005|
1697 my_exit_jump|||
1698 my_exit|||
1699 my_failure_exit||5.004000|
1700 my_fflush_all||5.006000|
1701 my_fork||5.007003|n
1702 my_htobe16|||n
1703 my_htobe32|||n
1704 my_htobe64|||n
1705 my_htobei|||n
1706 my_htobel|||n
1707 my_htobes|||n
1708 my_htole16|||n
1709 my_htole32|||n
1710 my_htole64|||n
1711 my_htolei|||n
1712 my_htolel|||n
1713 my_htoles|||n
1714 my_htonl|||
1715 my_kid|||
1716 my_letoh16|||n
1717 my_letoh32|||n
1718 my_letoh64|||n
1719 my_letohi|||n
1720 my_letohl|||n
1721 my_letohs|||n
1722 my_lstat|||
1723 my_memcmp||5.004000|n
1724 my_memset|||n
1725 my_ntohl|||
1726 my_pclose||5.004000|
1727 my_popen_list||5.007001|
1728 my_popen||5.004000|
1729 my_setenv|||
1730 my_snprintf|5.009004||pvn
1731 my_socketpair||5.007003|n
1732 my_sprintf|5.009003||pvn
1733 my_stat|||
1734 my_strftime||5.007002|
1735 my_strlcat|5.009004||pn
1736 my_strlcpy|5.009004||pn
1737 my_swabn|||n
1738 my_swap|||
1739 my_unexec|||
1740 my_vsnprintf||5.009004|n
1741 need_utf8|||n
1742 newANONATTRSUB||5.006000|
1743 newANONHASH|||
1744 newANONLIST|||
1745 newANONSUB|||
1746 newASSIGNOP|||
1747 newATTRSUB||5.006000|
1748 newAVREF|||
1749 newAV|||
1750 newBINOP|||
1751 newCONDOP|||
1752 newCONSTSUB|5.004050||p
1753 newCVREF|||
1754 newDEFSVOP|||
1755 newFORM|||
1756 newFOROP|||
1757 newGIVENOP||5.009003|
1758 newGIVWHENOP|||
1759 newGP|||
1760 newGVOP|||
1761 newGVREF|||
1762 newGVgen|||
1763 newHVREF|||
1764 newHVhv||5.005000|
1765 newHV|||
1766 newIO|||
1767 newLISTOP|||
1768 newLOGOP|||
1769 newLOOPEX|||
1770 newLOOPOP|||
1771 newMADPROP|||
1772 newMADsv|||
1773 newMYSUB|||
1774 newNULLLIST|||
1775 newOP|||
1776 newPADOP|||
1777 newPMOP|||
1778 newPROG|||
1779 newPVOP|||
1780 newRANGE|||
1781 newRV_inc|5.004000||p
1782 newRV_noinc|5.004000||p
1783 newRV|||
1784 newSLICEOP|||
1785 newSTATEOP|||
1786 newSUB|||
1787 newSVOP|||
1788 newSVREF|||
1789 newSV_type|5.009005||p
1790 newSVhek||5.009003|
1791 newSViv|||
1792 newSVnv|||
1793 newSVpvf_nocontext|||vn
1794 newSVpvf||5.004000|v
1795 newSVpvn_flags|5.011000||p
1796 newSVpvn_share|5.007001||p
1797 newSVpvn_utf8|5.011000||p
1798 newSVpvn|5.004050||p
1799 newSVpvs_flags|5.011000||p
1800 newSVpvs_share||5.009003|
1801 newSVpvs|5.009003||p
1802 newSVpv|||
1803 newSVrv|||
1804 newSVsv|||
1805 newSVuv|5.006000||p
1806 newSV|||
1807 newTOKEN|||
1808 newUNOP|||
1809 newWHENOP||5.009003|
1810 newWHILEOP||5.009003|
1811 newXS_flags||5.009004|
1812 newXSproto||5.006000|
1813 newXS||5.006000|
1814 new_collate||5.006000|
1815 new_constant|||
1816 new_ctype||5.006000|
1817 new_he|||
1818 new_logop|||
1819 new_numeric||5.006000|
1820 new_stackinfo||5.005000|
1821 new_version||5.009000|
1822 new_warnings_bitfield|||
1823 next_symbol|||
1824 nextargv|||
1825 nextchar|||
1826 ninstr|||
1827 no_bareword_allowed|||
1828 no_fh_allowed|||
1829 no_op|||
1830 not_a_number|||
1831 nothreadhook||5.008000|
1832 nuke_stacks|||
1833 num_overflow|||n
1834 offer_nice_chunk|||
1835 oopsAV|||
1836 oopsHV|||
1837 op_clear|||
1838 op_const_sv|||
1839 op_dump||5.006000|
1840 op_free|||
1841 op_getmad_weak|||
1842 op_getmad|||
1843 op_null||5.007002|
1844 op_refcnt_dec|||
1845 op_refcnt_inc|||
1846 op_refcnt_lock||5.009002|
1847 op_refcnt_unlock||5.009002|
1848 op_xmldump|||
1849 open_script|||
1850 pMY_CXT_|5.007003||p
1851 pMY_CXT|5.007003||p
1852 pTHX_|5.006000||p
1853 pTHX|5.006000||p
1854 packWARN|5.007003||p
1855 pack_cat||5.007003|
1856 pack_rec|||
1857 package|||
1858 packlist||5.008001|
1859 pad_add_anon|||
1860 pad_add_name|||
1861 pad_alloc|||
1862 pad_block_start|||
1863 pad_check_dup|||
1864 pad_compname_type|||
1865 pad_findlex|||
1866 pad_findmy|||
1867 pad_fixup_inner_anons|||
1868 pad_free|||
1869 pad_leavemy|||
1870 pad_new|||
1871 pad_peg|||n
1872 pad_push|||
1873 pad_reset|||
1874 pad_setsv|||
1875 pad_sv||5.011000|
1876 pad_swipe|||
1877 pad_tidy|||
1878 pad_undef|||
1879 parse_body|||
1880 parse_unicode_opts|||
1881 parser_dup|||
1882 parser_free|||
1883 path_is_absolute|||n
1884 peep|||
1885 pending_Slabs_to_ro|||
1886 perl_alloc_using|||n
1887 perl_alloc|||n
1888 perl_clone_using|||n
1889 perl_clone|||n
1890 perl_construct|||n
1891 perl_destruct||5.007003|n
1892 perl_free|||n
1893 perl_parse||5.006000|n
1894 perl_run|||n
1895 pidgone|||
1896 pm_description|||
1897 pmflag|||
1898 pmop_dump||5.006000|
1899 pmop_xmldump|||
1900 pmruntime|||
1901 pmtrans|||
1902 pop_scope|||
1903 pregcomp||5.009005|
1904 pregexec|||
1905 pregfree2||5.011000|
1906 pregfree|||
1907 prepend_elem|||
1908 prepend_madprops|||
1909 printbuf|||
1910 printf_nocontext|||vn
1911 process_special_blocks|||
1912 ptr_table_clear||5.009005|
1913 ptr_table_fetch||5.009005|
1914 ptr_table_find|||n
1915 ptr_table_free||5.009005|
1916 ptr_table_new||5.009005|
1917 ptr_table_split||5.009005|
1918 ptr_table_store||5.009005|
1919 push_scope|||
1920 put_byte|||
1921 pv_display|5.006000||p
1922 pv_escape|5.009004||p
1923 pv_pretty|5.009004||p
1924 pv_uni_display||5.007003|
1925 qerror|||
1926 qsortsvu|||
1927 re_compile||5.009005|
1928 re_croak2|||
1929 re_dup_guts|||
1930 re_intuit_start||5.009005|
1931 re_intuit_string||5.006000|
1932 readpipe_override|||
1933 realloc||5.007002|n
1934 reentrant_free|||
1935 reentrant_init|||
1936 reentrant_retry|||vn
1937 reentrant_size|||
1938 ref_array_or_hash|||
1939 refcounted_he_chain_2hv|||
1940 refcounted_he_fetch|||
1941 refcounted_he_free|||
1942 refcounted_he_new_common|||
1943 refcounted_he_new|||
1944 refcounted_he_value|||
1945 refkids|||
1946 refto|||
1947 ref||5.011000|
1948 reg_check_named_buff_matched|||
1949 reg_named_buff_all||5.009005|
1950 reg_named_buff_exists||5.009005|
1951 reg_named_buff_fetch||5.009005|
1952 reg_named_buff_firstkey||5.009005|
1953 reg_named_buff_iter|||
1954 reg_named_buff_nextkey||5.009005|
1955 reg_named_buff_scalar||5.009005|
1956 reg_named_buff|||
1957 reg_namedseq|||
1958 reg_node|||
1959 reg_numbered_buff_fetch|||
1960 reg_numbered_buff_length|||
1961 reg_numbered_buff_store|||
1962 reg_qr_package|||
1963 reg_recode|||
1964 reg_scan_name|||
1965 reg_skipcomment|||
1966 reg_temp_copy|||
1967 reganode|||
1968 regatom|||
1969 regbranch|||
1970 regclass_swash||5.009004|
1971 regclass|||
1972 regcppop|||
1973 regcppush|||
1974 regcurly|||n
1975 regdump_extflags|||
1976 regdump||5.005000|
1977 regdupe_internal|||
1978 regexec_flags||5.005000|
1979 regfree_internal||5.009005|
1980 reghop3|||n
1981 reghop4|||n
1982 reghopmaybe3|||n
1983 reginclass|||
1984 reginitcolors||5.006000|
1985 reginsert|||
1986 regmatch|||
1987 regnext||5.005000|
1988 regpiece|||
1989 regpposixcc|||
1990 regprop|||
1991 regrepeat|||
1992 regtail_study|||
1993 regtail|||
1994 regtry|||
1995 reguni|||
1996 regwhite|||n
1997 reg|||
1998 repeatcpy|||
1999 report_evil_fh|||
2000 report_uninit|||
2001 require_pv||5.006000|
2002 require_tie_mod|||
2003 restore_magic|||
2004 rninstr|||
2005 rsignal_restore|||
2006 rsignal_save|||
2007 rsignal_state||5.004000|
2008 rsignal||5.004000|
2009 run_body|||
2010 run_user_filter|||
2011 runops_debug||5.005000|
2012 runops_standard||5.005000|
2013 rvpv_dup|||
2014 rxres_free|||
2015 rxres_restore|||
2016 rxres_save|||
2017 safesyscalloc||5.006000|n
2018 safesysfree||5.006000|n
2019 safesysmalloc||5.006000|n
2020 safesysrealloc||5.006000|n
2021 same_dirent|||
2022 save_I16||5.004000|
2023 save_I32|||
2024 save_I8||5.006000|
2025 save_adelete||5.011000|
2026 save_aelem||5.004050|
2027 save_alloc||5.006000|
2028 save_aptr|||
2029 save_ary|||
2030 save_bool||5.008001|
2031 save_clearsv|||
2032 save_delete|||
2033 save_destructor_x||5.006000|
2034 save_destructor||5.006000|
2035 save_freeop|||
2036 save_freepv|||
2037 save_freesv|||
2038 save_generic_pvref||5.006001|
2039 save_generic_svref||5.005030|
2040 save_gp||5.004000|
2041 save_hash|||
2042 save_hek_flags|||n
2043 save_helem_flags||5.011000|
2044 save_helem||5.004050|
2045 save_hints|||
2046 save_hptr|||
2047 save_int|||
2048 save_item|||
2049 save_iv||5.005000|
2050 save_lines|||
2051 save_list|||
2052 save_long|||
2053 save_magic|||
2054 save_mortalizesv||5.007001|
2055 save_nogv|||
2056 save_op|||
2057 save_padsv_and_mortalize||5.011000|
2058 save_pptr|||
2059 save_pushi32ptr|||
2060 save_pushptri32ptr|||
2061 save_pushptrptr|||
2062 save_pushptr||5.011000|
2063 save_re_context||5.006000|
2064 save_scalar_at|||
2065 save_scalar|||
2066 save_set_svflags||5.009000|
2067 save_shared_pvref||5.007003|
2068 save_sptr|||
2069 save_svref|||
2070 save_vptr||5.006000|
2071 savepvn|||
2072 savepvs||5.009003|
2073 savepv|||
2074 savesharedpvn||5.009005|
2075 savesharedpv||5.007003|
2076 savestack_grow_cnt||5.008001|
2077 savestack_grow|||
2078 savesvpv||5.009002|
2079 sawparens|||
2080 scalar_mod_type|||n
2081 scalarboolean|||
2082 scalarkids|||
2083 scalarseq|||
2084 scalarvoid|||
2085 scalar|||
2086 scan_bin||5.006000|
2087 scan_commit|||
2088 scan_const|||
2089 scan_formline|||
2090 scan_heredoc|||
2091 scan_hex|||
2092 scan_ident|||
2093 scan_inputsymbol|||
2094 scan_num||5.007001|
2095 scan_oct|||
2096 scan_pat|||
2097 scan_str|||
2098 scan_subst|||
2099 scan_trans|||
2100 scan_version||5.009001|
2101 scan_vstring||5.009005|
2102 scan_word|||
2103 scope|||
2104 screaminstr||5.005000|
2105 search_const|||
2106 seed||5.008001|
2107 sequence_num|||
2108 sequence_tail|||
2109 sequence|||
2110 set_context||5.006000|n
2111 set_numeric_local||5.006000|
2112 set_numeric_radix||5.006000|
2113 set_numeric_standard||5.006000|
2114 setdefout|||
2115 share_hek_flags|||
2116 share_hek||5.004000|
2117 si_dup|||
2118 sighandler|||n
2119 simplify_sort|||
2120 skipspace0|||
2121 skipspace1|||
2122 skipspace2|||
2123 skipspace|||
2124 softref2xv|||
2125 sortcv_stacked|||
2126 sortcv_xsub|||
2127 sortcv|||
2128 sortsv_flags||5.009003|
2129 sortsv||5.007003|
2130 space_join_names_mortal|||
2131 ss_dup|||
2132 stack_grow|||
2133 start_force|||
2134 start_glob|||
2135 start_subparse||5.004000|
2136 stashpv_hvname_match||5.011000|
2137 stdize_locale|||
2138 store_cop_label|||
2139 strEQ|||
2140 strGE|||
2141 strGT|||
2142 strLE|||
2143 strLT|||
2144 strNE|||
2145 str_to_version||5.006000|
2146 strip_return|||
2147 strnEQ|||
2148 strnNE|||
2149 study_chunk|||
2150 sub_crush_depth|||
2151 sublex_done|||
2152 sublex_push|||
2153 sublex_start|||
2154 sv_2bool|||
2155 sv_2cv|||
2156 sv_2io|||
2157 sv_2iuv_common|||
2158 sv_2iuv_non_preserve|||
2159 sv_2iv_flags||5.009001|
2160 sv_2iv|||
2161 sv_2mortal|||
2162 sv_2num|||
2163 sv_2nv|||
2164 sv_2pv_flags|5.007002||p
2165 sv_2pv_nolen|5.006000||p
2166 sv_2pvbyte_nolen|5.006000||p
2167 sv_2pvbyte|5.006000||p
2168 sv_2pvutf8_nolen||5.006000|
2169 sv_2pvutf8||5.006000|
2170 sv_2pv|||
2171 sv_2uv_flags||5.009001|
2172 sv_2uv|5.004000||p
2173 sv_add_arena|||
2174 sv_add_backref|||
2175 sv_backoff|||
2176 sv_bless|||
2177 sv_cat_decode||5.008001|
2178 sv_catpv_mg|5.004050||p
2179 sv_catpvf_mg_nocontext|||pvn
2180 sv_catpvf_mg|5.006000|5.004000|pv
2181 sv_catpvf_nocontext|||vn
2182 sv_catpvf||5.004000|v
2183 sv_catpvn_flags||5.007002|
2184 sv_catpvn_mg|5.004050||p
2185 sv_catpvn_nomg|5.007002||p
2186 sv_catpvn|||
2187 sv_catpvs|5.009003||p
2188 sv_catpv|||
2189 sv_catsv_flags||5.007002|
2190 sv_catsv_mg|5.004050||p
2191 sv_catsv_nomg|5.007002||p
2192 sv_catsv|||
2193 sv_catxmlpvn|||
2194 sv_catxmlsv|||
2195 sv_chop|||
2196 sv_clean_all|||
2197 sv_clean_objs|||
2198 sv_clear|||
2199 sv_cmp_locale||5.004000|
2200 sv_cmp|||
2201 sv_collxfrm|||
2202 sv_compile_2op||5.008001|
2203 sv_copypv||5.007003|
2204 sv_dec|||
2205 sv_del_backref|||
2206 sv_derived_from||5.004000|
2207 sv_destroyable||5.010000|
2208 sv_does||5.009004|
2209 sv_dump|||
2210 sv_dup_inc_multiple|||
2211 sv_dup|||
2212 sv_eq|||
2213 sv_exp_grow|||
2214 sv_force_normal_flags||5.007001|
2215 sv_force_normal||5.006000|
2216 sv_free2|||
2217 sv_free_arenas|||
2218 sv_free|||
2219 sv_gets||5.004000|
2220 sv_grow|||
2221 sv_i_ncmp|||
2222 sv_inc|||
2223 sv_insert_flags||5.011000|
2224 sv_insert|||
2225 sv_isa|||
2226 sv_isobject|||
2227 sv_iv||5.005000|
2228 sv_kill_backrefs|||
2229 sv_len_utf8||5.006000|
2230 sv_len|||
2231 sv_magic_portable|5.011000|5.004000|p
2232 sv_magicext||5.007003|
2233 sv_magic|||
2234 sv_mortalcopy|||
2235 sv_ncmp|||
2236 sv_newmortal|||
2237 sv_newref|||
2238 sv_nolocking||5.007003|
2239 sv_nosharing||5.007003|
2240 sv_nounlocking|||
2241 sv_nv||5.005000|
2242 sv_peek||5.005000|
2243 sv_pos_b2u_midway|||
2244 sv_pos_b2u||5.006000|
2245 sv_pos_u2b_cached|||
2246 sv_pos_u2b_forwards|||n
2247 sv_pos_u2b_midway|||n
2248 sv_pos_u2b||5.006000|
2249 sv_pvbyten_force||5.006000|
2250 sv_pvbyten||5.006000|
2251 sv_pvbyte||5.006000|
2252 sv_pvn_force_flags|5.007002||p
2253 sv_pvn_force|||
2254 sv_pvn_nomg|5.007003|5.005000|p
2255 sv_pvn||5.005000|
2256 sv_pvutf8n_force||5.006000|
2257 sv_pvutf8n||5.006000|
2258 sv_pvutf8||5.006000|
2259 sv_pv||5.006000|
2260 sv_recode_to_utf8||5.007003|
2261 sv_reftype|||
2262 sv_release_COW|||
2263 sv_replace|||
2264 sv_report_used|||
2265 sv_reset|||
2266 sv_rvweaken||5.006000|
2267 sv_setiv_mg|5.004050||p
2268 sv_setiv|||
2269 sv_setnv_mg|5.006000||p
2270 sv_setnv|||
2271 sv_setpv_mg|5.004050||p
2272 sv_setpvf_mg_nocontext|||pvn
2273 sv_setpvf_mg|5.006000|5.004000|pv
2274 sv_setpvf_nocontext|||vn
2275 sv_setpvf||5.004000|v
2276 sv_setpviv_mg||5.008001|
2277 sv_setpviv||5.008001|
2278 sv_setpvn_mg|5.004050||p
2279 sv_setpvn|||
2280 sv_setpvs|5.009004||p
2281 sv_setpv|||
2282 sv_setref_iv|||
2283 sv_setref_nv|||
2284 sv_setref_pvn|||
2285 sv_setref_pv|||
2286 sv_setref_uv||5.007001|
2287 sv_setsv_cow|||
2288 sv_setsv_flags||5.007002|
2289 sv_setsv_mg|5.004050||p
2290 sv_setsv_nomg|5.007002||p
2291 sv_setsv|||
2292 sv_setuv_mg|5.004050||p
2293 sv_setuv|5.004000||p
2294 sv_tainted||5.004000|
2295 sv_taint||5.004000|
2296 sv_true||5.005000|
2297 sv_unglob|||
2298 sv_uni_display||5.007003|
2299 sv_unmagic|||
2300 sv_unref_flags||5.007001|
2301 sv_unref|||
2302 sv_untaint||5.004000|
2303 sv_upgrade|||
2304 sv_usepvn_flags||5.009004|
2305 sv_usepvn_mg|5.004050||p
2306 sv_usepvn|||
2307 sv_utf8_decode||5.006000|
2308 sv_utf8_downgrade||5.006000|
2309 sv_utf8_encode||5.006000|
2310 sv_utf8_upgrade_flags_grow||5.011000|
2311 sv_utf8_upgrade_flags||5.007002|
2312 sv_utf8_upgrade_nomg||5.007002|
2313 sv_utf8_upgrade||5.007001|
2314 sv_uv|5.005000||p
2315 sv_vcatpvf_mg|5.006000|5.004000|p
2316 sv_vcatpvfn||5.004000|
2317 sv_vcatpvf|5.006000|5.004000|p
2318 sv_vsetpvf_mg|5.006000|5.004000|p
2319 sv_vsetpvfn||5.004000|
2320 sv_vsetpvf|5.006000|5.004000|p
2321 sv_xmlpeek|||
2322 svtype|||
2323 swallow_bom|||
2324 swap_match_buff|||
2325 swash_fetch||5.007002|
2326 swash_get|||
2327 swash_init||5.006000|
2328 sys_init3||5.010000|n
2329 sys_init||5.010000|n
2330 sys_intern_clear|||
2331 sys_intern_dup|||
2332 sys_intern_init|||
2333 sys_term||5.010000|n
2334 taint_env|||
2335 taint_proper|||
2336 tmps_grow||5.006000|
2337 toLOWER|||
2338 toUPPER|||
2339 to_byte_substr|||
2340 to_uni_fold||5.007003|
2341 to_uni_lower_lc||5.006000|
2342 to_uni_lower||5.007003|
2343 to_uni_title_lc||5.006000|
2344 to_uni_title||5.007003|
2345 to_uni_upper_lc||5.006000|
2346 to_uni_upper||5.007003|
2347 to_utf8_case||5.007003|
2348 to_utf8_fold||5.007003|
2349 to_utf8_lower||5.007003|
2350 to_utf8_substr|||
2351 to_utf8_title||5.007003|
2352 to_utf8_upper||5.007003|
2353 token_free|||
2354 token_getmad|||
2355 tokenize_use|||
2356 tokeq|||
2357 tokereport|||
2358 too_few_arguments|||
2359 too_many_arguments|||
2360 uiv_2buf|||n
2361 unlnk|||
2362 unpack_rec|||
2363 unpack_str||5.007003|
2364 unpackstring||5.008001|
2365 unshare_hek_or_pvn|||
2366 unshare_hek|||
2367 unsharepvn||5.004000|
2368 unwind_handler_stack|||
2369 update_debugger_info|||
2370 upg_version||5.009005|
2371 usage|||
2372 utf16_to_utf8_reversed||5.006001|
2373 utf16_to_utf8||5.006001|
2374 utf8_distance||5.006000|
2375 utf8_hop||5.006000|
2376 utf8_length||5.007001|
2377 utf8_mg_pos_cache_update|||
2378 utf8_to_bytes||5.006001|
2379 utf8_to_uvchr||5.007001|
2380 utf8_to_uvuni||5.007001|
2381 utf8n_to_uvchr|||
2382 utf8n_to_uvuni||5.007001|
2383 utilize|||
2384 uvchr_to_utf8_flags||5.007003|
2385 uvchr_to_utf8|||
2386 uvuni_to_utf8_flags||5.007003|
2387 uvuni_to_utf8||5.007001|
2388 validate_suid|||
2389 varname|||
2390 vcmp||5.009000|
2391 vcroak||5.006000|
2392 vdeb||5.007003|
2393 vdie_common|||
2394 vdie_croak_common|||
2395 vdie|||
2396 vform||5.006000|
2397 visit|||
2398 vivify_defelem|||
2399 vivify_ref|||
2400 vload_module|5.006000||p
2401 vmess||5.006000|
2402 vnewSVpvf|5.006000|5.004000|p
2403 vnormal||5.009002|
2404 vnumify||5.009000|
2405 vstringify||5.009000|
2406 vverify||5.009003|
2407 vwarner||5.006000|
2408 vwarn||5.006000|
2409 wait4pid|||
2410 warn_nocontext|||vn
2411 warner_nocontext|||vn
2412 warner|5.006000|5.004000|pv
2413 warn|||v
2414 watch|||
2415 whichsig|||
2416 write_no_mem|||
2417 write_to_stderr|||
2418 xmldump_all|||
2419 xmldump_attr|||
2420 xmldump_eval|||
2421 xmldump_form|||
2422 xmldump_indent|||v
2423 xmldump_packsubs|||
2424 xmldump_sub|||
2425 xmldump_vindent|||
2426 yyerror|||
2427 yylex|||
2428 yyparse|||
2429 yywarn|||
2430 );
2431
2432 if (exists $opt{'list-unsupported'}) {
2433   my $f;
2434   for $f (sort { lc $a cmp lc $b } keys %API) {
2435     next unless $API{$f}{todo};
2436     print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";
2437   }
2438   exit 0;
2439 }
2440
2441 # Scan for possible replacement candidates
2442
2443 my(%replace, %need, %hints, %warnings, %depends);
2444 my $replace = 0;
2445 my($hint, $define, $function);
2446
2447 sub find_api
2448 {
2449   my $code = shift;
2450   $code =~ s{
2451     / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
2452   | "[^"\\]*(?:\\.[^"\\]*)*"
2453   | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx;
2454   grep { exists $API{$_} } $code =~ /(\w+)/mg;
2455 }
2456
2457 while (<DATA>) {
2458   if ($hint) {
2459     my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;
2460     if (m{^\s*\*\s(.*?)\s*$}) {
2461       for (@{$hint->[1]}) {
2462         $h->{$_} ||= '';  # suppress warning with older perls
2463         $h->{$_} .= "$1\n";
2464       }
2465     }
2466     else { undef $hint }
2467   }
2468
2469   $hint = [$1, [split /,?\s+/, $2]]
2470       if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$};
2471
2472   if ($define) {
2473     if ($define->[1] =~ /\\$/) {
2474       $define->[1] .= $_;
2475     }
2476     else {
2477       if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {
2478         my @n = find_api($define->[1]);
2479         push @{$depends{$define->[0]}}, @n if @n
2480       }
2481       undef $define;
2482     }
2483   }
2484
2485   $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)};
2486
2487   if ($function) {
2488     if (/^}/) {
2489       if (exists $API{$function->[0]}) {
2490         my @n = find_api($function->[1]);
2491         push @{$depends{$function->[0]}}, @n if @n
2492       }
2493       undef $function;
2494     }
2495     else {
2496       $function->[1] .= $_;
2497     }
2498   }
2499
2500   $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};
2501
2502   $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
2503   $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
2504   $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
2505   $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};
2506
2507   if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
2508     my @deps = map { s/\s+//g; $_ } split /,/, $3;
2509     my $d;
2510     for $d (map { s/\s+//g; $_ } split /,/, $1) {
2511       push @{$depends{$d}}, @deps;
2512     }
2513   }
2514
2515   $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
2516 }
2517
2518 for (values %depends) {
2519   my %s;
2520   $_ = [sort grep !$s{$_}++, @$_];
2521 }
2522
2523 if (exists $opt{'api-info'}) {
2524   my $f;
2525   my $count = 0;
2526   my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";
2527   for $f (sort { lc $a cmp lc $b } keys %API) {
2528     next unless $f =~ /$match/;
2529     print "\n=== $f ===\n\n";
2530     my $info = 0;
2531     if ($API{$f}{base} || $API{$f}{todo}) {
2532       my $base = format_version($API{$f}{base} || $API{$f}{todo});
2533       print "Supported at least starting from perl-$base.\n";
2534       $info++;
2535     }
2536     if ($API{$f}{provided}) {
2537       my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003";
2538       print "Support by $ppport provided back to perl-$todo.\n";
2539       print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
2540       print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
2541       print "\n$hints{$f}" if exists $hints{$f};
2542       print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};
2543       $info++;
2544     }
2545     print "No portability information available.\n" unless $info;
2546     $count++;
2547   }
2548   $count or print "Found no API matching '$opt{'api-info'}'.";
2549   print "\n";
2550   exit 0;
2551 }
2552
2553 if (exists $opt{'list-provided'}) {
2554   my $f;
2555   for $f (sort { lc $a cmp lc $b } keys %API) {
2556     next unless $API{$f}{provided};
2557     my @flags;
2558     push @flags, 'explicit' if exists $need{$f};
2559     push @flags, 'depend'   if exists $depends{$f};
2560     push @flags, 'hint'     if exists $hints{$f};
2561     push @flags, 'warning'  if exists $warnings{$f};
2562     my $flags = @flags ? '  ['.join(', ', @flags).']' : '';
2563     print "$f$flags\n";
2564   }
2565   exit 0;
2566 }
2567
2568 my @files;
2569 my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
2570 my $srcext = join '|', map { quotemeta $_ } @srcext;
2571
2572 if (@ARGV) {
2573   my %seen;
2574   for (@ARGV) {
2575     if (-e) {
2576       if (-f) {
2577         push @files, $_ unless $seen{$_}++;
2578       }
2579       else { warn "'$_' is not a file.\n" }
2580     }
2581     else {
2582       my @new = grep { -f } glob $_
2583           or warn "'$_' does not exist.\n";
2584       push @files, grep { !$seen{$_}++ } @new;
2585     }
2586   }
2587 }
2588 else {
2589   eval {
2590     require File::Find;
2591     File::Find::find(sub {
2592       $File::Find::name =~ /($srcext)$/i
2593           and push @files, $File::Find::name;
2594     }, '.');
2595   };
2596   if ($@) {
2597     @files = map { glob "*$_" } @srcext;
2598   }
2599 }
2600
2601 if (!@ARGV || $opt{filter}) {
2602   my(@in, @out);
2603   my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
2604   for (@files) {
2605     my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;
2606     push @{ $out ? \@out : \@in }, $_;
2607   }
2608   if (@ARGV && @out) {
2609     warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
2610   }
2611   @files = @in;
2612 }
2613
2614 die "No input files given!\n" unless @files;
2615
2616 my(%files, %global, %revreplace);
2617 %revreplace = reverse %replace;
2618 my $filename;
2619 my $patch_opened = 0;
2620
2621 for $filename (@files) {
2622   unless (open IN, "<$filename") {
2623     warn "Unable to read from $filename: $!\n";
2624     next;
2625   }
2626
2627   info("Scanning $filename ...");
2628
2629   my $c = do { local $/; <IN> };
2630   close IN;
2631
2632   my %file = (orig => $c, changes => 0);
2633
2634   # Temporarily remove C/XS comments and strings from the code
2635   my @ccom;
2636
2637   $c =~ s{
2638     ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]*
2639     | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* )
2640   | ( ^$HS*\#[^\r\n]*
2641     | "[^"\\]*(?:\\.[^"\\]*)*"
2642     | '[^'\\]*(?:\\.[^'\\]*)*'
2643     | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) )
2644   }{ defined $2 and push @ccom, $2;
2645      defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;
2646
2647   $file{ccom} = \@ccom;
2648   $file{code} = $c;
2649   $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m;
2650
2651   my $func;
2652
2653   for $func (keys %API) {
2654     my $match = $func;
2655     $match .= "|$revreplace{$func}" if exists $revreplace{$func};
2656     if ($c =~ /\b(?:Perl_)?($match)\b/) {
2657       $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
2658       $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
2659       if (exists $API{$func}{provided}) {
2660         $file{uses_provided}{$func}++;
2661         if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {
2662           $file{uses}{$func}++;
2663           my @deps = rec_depend($func);
2664           if (@deps) {
2665             $file{uses_deps}{$func} = \@deps;
2666             for (@deps) {
2667               $file{uses}{$_} = 0 unless exists $file{uses}{$_};
2668             }
2669           }
2670           for ($func, @deps) {
2671             $file{needs}{$_} = 'static' if exists $need{$_};
2672           }
2673         }
2674       }
2675       if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) {
2676         if ($c =~ /\b$func\b/) {
2677           $file{uses_todo}{$func}++;
2678         }
2679       }
2680     }
2681   }
2682
2683   while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {
2684     if (exists $need{$2}) {
2685       $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
2686     }
2687     else { warning("Possibly wrong #define $1 in $filename") }
2688   }
2689
2690   for (qw(uses needs uses_todo needed_global needed_static)) {
2691     for $func (keys %{$file{$_}}) {
2692       push @{$global{$_}{$func}}, $filename;
2693     }
2694   }
2695
2696   $files{$filename} = \%file;
2697 }
2698
2699 # Globally resolve NEED_'s
2700 my $need;
2701 for $need (keys %{$global{needs}}) {
2702   if (@{$global{needs}{$need}} > 1) {
2703     my @targets = @{$global{needs}{$need}};
2704     my @t = grep $files{$_}{needed_global}{$need}, @targets;
2705     @targets = @t if @t;
2706     @t = grep /\.xs$/i, @targets;
2707     @targets = @t if @t;
2708     my $target = shift @targets;
2709     $files{$target}{needs}{$need} = 'global';
2710     for (@{$global{needs}{$need}}) {
2711       $files{$_}{needs}{$need} = 'extern' if $_ ne $target;
2712     }
2713   }
2714 }
2715
2716 for $filename (@files) {
2717   exists $files{$filename} or next;
2718
2719   info("=== Analyzing $filename ===");
2720
2721   my %file = %{$files{$filename}};
2722   my $func;
2723   my $c = $file{code};
2724   my $warnings = 0;
2725
2726   for $func (sort keys %{$file{uses_Perl}}) {
2727     if ($API{$func}{varargs}) {
2728       unless ($API{$func}{nothxarg}) {
2729         my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
2730                               { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
2731         if ($changes) {
2732           warning("Doesn't pass interpreter argument aTHX to Perl_$func");
2733           $file{changes} += $changes;
2734         }
2735       }
2736     }
2737     else {
2738       warning("Uses Perl_$func instead of $func");
2739       $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}
2740                                 {$func$1(}g);
2741     }
2742   }
2743
2744   for $func (sort keys %{$file{uses_replace}}) {
2745     warning("Uses $func instead of $replace{$func}");
2746     $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
2747   }
2748
2749   for $func (sort keys %{$file{uses_provided}}) {
2750     if ($file{uses}{$func}) {
2751       if (exists $file{uses_deps}{$func}) {
2752         diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
2753       }
2754       else {
2755         diag("Uses $func");
2756       }
2757     }
2758     $warnings += hint($func);
2759   }
2760
2761   unless ($opt{quiet}) {
2762     for $func (sort keys %{$file{uses_todo}}) {
2763       print "*** WARNING: Uses $func, which may not be portable below perl ",
2764             format_version($API{$func}{todo}), ", even with '$ppport'\n";
2765       $warnings++;
2766     }
2767   }
2768
2769   for $func (sort keys %{$file{needed_static}}) {
2770     my $message = '';
2771     if (not exists $file{uses}{$func}) {
2772       $message = "No need to define NEED_$func if $func is never used";
2773     }
2774     elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {
2775       $message = "No need to define NEED_$func when already needed globally";
2776     }
2777     if ($message) {
2778       diag($message);
2779       $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
2780     }
2781   }
2782
2783   for $func (sort keys %{$file{needed_global}}) {
2784     my $message = '';
2785     if (not exists $global{uses}{$func}) {
2786       $message = "No need to define NEED_${func}_GLOBAL if $func is never used";
2787     }
2788     elsif (exists $file{needs}{$func}) {
2789       if ($file{needs}{$func} eq 'extern') {
2790         $message = "No need to define NEED_${func}_GLOBAL when already needed globally";
2791       }
2792       elsif ($file{needs}{$func} eq 'static') {
2793         $message = "No need to define NEED_${func}_GLOBAL when only used in this file";
2794       }
2795     }
2796     if ($message) {
2797       diag($message);
2798       $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
2799     }
2800   }
2801
2802   $file{needs_inc_ppport} = keys %{$file{uses}};
2803
2804   if ($file{needs_inc_ppport}) {
2805     my $pp = '';
2806
2807     for $func (sort keys %{$file{needs}}) {
2808       my $type = $file{needs}{$func};
2809       next if $type eq 'extern';
2810       my $suffix = $type eq 'global' ? '_GLOBAL' : '';
2811       unless (exists $file{"needed_$type"}{$func}) {
2812         if ($type eq 'global') {
2813           diag("Files [@{$global{needs}{$func}}] need $func, adding global request");
2814         }
2815         else {
2816           diag("File needs $func, adding static request");
2817         }
2818         $pp .= "#define NEED_$func$suffix\n";
2819       }
2820     }
2821
2822     if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {
2823       $pp = '';
2824       $file{changes}++;
2825     }
2826
2827     unless ($file{has_inc_ppport}) {
2828       diag("Needs to include '$ppport'");
2829       $pp .= qq(#include "$ppport"\n)
2830     }
2831
2832     if ($pp) {
2833       $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)
2834                      || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)
2835                      || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)
2836                      || ($c =~ s/^/$pp/);
2837     }
2838   }
2839   else {
2840     if ($file{has_inc_ppport}) {
2841       diag("No need to include '$ppport'");
2842       $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
2843     }
2844   }
2845
2846   # put back in our C comments
2847   my $ix;
2848   my $cppc = 0;
2849   my @ccom = @{$file{ccom}};
2850   for $ix (0 .. $#ccom) {
2851     if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
2852       $cppc++;
2853       $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;
2854     }
2855     else {
2856       $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;
2857     }
2858   }
2859
2860   if ($cppc) {
2861     my $s = $cppc != 1 ? 's' : '';
2862     warning("Uses $cppc C++ style comment$s, which is not portable");
2863   }
2864
2865   my $s = $warnings != 1 ? 's' : '';
2866   my $warn = $warnings ? " ($warnings warning$s)" : '';
2867   info("Analysis completed$warn");
2868
2869   if ($file{changes}) {
2870     if (exists $opt{copy}) {
2871       my $newfile = "$filename$opt{copy}";
2872       if (-e $newfile) {
2873         error("'$newfile' already exists, refusing to write copy of '$filename'");
2874       }
2875       else {
2876         local *F;
2877         if (open F, ">$newfile") {
2878           info("Writing copy of '$filename' with changes to '$newfile'");
2879           print F $c;
2880           close F;
2881         }
2882         else {
2883           error("Cannot open '$newfile' for writing: $!");
2884         }
2885       }
2886     }
2887     elsif (exists $opt{patch} || $opt{changes}) {
2888       if (exists $opt{patch}) {
2889         unless ($patch_opened) {
2890           if (open PATCH, ">$opt{patch}") {
2891             $patch_opened = 1;
2892           }
2893           else {
2894             error("Cannot open '$opt{patch}' for writing: $!");
2895             delete $opt{patch};
2896             $opt{changes} = 1;
2897             goto fallback;
2898           }
2899         }
2900         mydiff(\*PATCH, $filename, $c);
2901       }
2902       else {
2903 fallback:
2904         info("Suggested changes:");
2905         mydiff(\*STDOUT, $filename, $c);
2906       }
2907     }
2908     else {
2909       my $s = $file{changes} == 1 ? '' : 's';
2910       info("$file{changes} potentially required change$s detected");
2911     }
2912   }
2913   else {
2914     info("Looks good");
2915   }
2916 }
2917
2918 close PATCH if $patch_opened;
2919
2920 exit 0;
2921
2922
2923 sub try_use { eval "use @_;"; return $@ eq '' }
2924
2925 sub mydiff
2926 {
2927   local *F = shift;
2928   my($file, $str) = @_;
2929   my $diff;
2930
2931   if (exists $opt{diff}) {
2932     $diff = run_diff($opt{diff}, $file, $str);
2933   }
2934
2935   if (!defined $diff and try_use('Text::Diff')) {
2936     $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
2937     $diff = <<HEADER . $diff;
2938 --- $file
2939 +++ $file.patched
2940 HEADER
2941   }
2942
2943   if (!defined $diff) {
2944     $diff = run_diff('diff -u', $file, $str);
2945   }
2946
2947   if (!defined $diff) {
2948     $diff = run_diff('diff', $file, $str);
2949   }
2950
2951   if (!defined $diff) {
2952     error("Cannot generate a diff. Please install Text::Diff or use --copy.");
2953     return;
2954   }
2955
2956   print F $diff;
2957 }
2958
2959 sub run_diff
2960 {
2961   my($prog, $file, $str) = @_;
2962   my $tmp = 'dppptemp';
2963   my $suf = 'aaa';
2964   my $diff = '';
2965   local *F;
2966
2967   while (-e "$tmp.$suf") { $suf++ }
2968   $tmp = "$tmp.$suf";
2969
2970   if (open F, ">$tmp") {
2971     print F $str;
2972     close F;
2973
2974     if (open F, "$prog $file $tmp |") {
2975       while (<F>) {
2976         s/\Q$tmp\E/$file.patched/;
2977         $diff .= $_;
2978       }
2979       close F;
2980       unlink $tmp;
2981       return $diff;
2982     }
2983
2984     unlink $tmp;
2985   }
2986   else {
2987     error("Cannot open '$tmp' for writing: $!");
2988   }
2989
2990   return undef;
2991 }
2992
2993 sub rec_depend
2994 {
2995   my($func, $seen) = @_;
2996   return () unless exists $depends{$func};
2997   $seen = {%{$seen||{}}};
2998   return () if $seen->{$func}++;
2999   my %s;
3000   grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
3001 }
3002
3003 sub parse_version
3004 {
3005   my $ver = shift;
3006
3007   if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {
3008     return ($1, $2, $3);
3009   }
3010   elsif ($ver !~ /^\d+\.[\d_]+$/) {
3011     die "cannot parse version '$ver'\n";
3012   }
3013
3014   $ver =~ s/_//g;
3015   $ver =~ s/$/000000/;
3016
3017   my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
3018
3019   $v = int $v;
3020   $s = int $s;
3021
3022   if ($r < 5 || ($r == 5 && $v < 6)) {
3023     if ($s % 10) {
3024       die "cannot parse version '$ver'\n";
3025     }
3026   }
3027
3028   return ($r, $v, $s);
3029 }
3030
3031 sub format_version
3032 {
3033   my $ver = shift;
3034
3035   $ver =~ s/$/000000/;
3036   my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
3037
3038   $v = int $v;
3039   $s = int $s;
3040
3041   if ($r < 5 || ($r == 5 && $v < 6)) {
3042     if ($s % 10) {
3043       die "invalid version '$ver'\n";
3044     }
3045     $s /= 10;
3046
3047     $ver = sprintf "%d.%03d", $r, $v;
3048     $s > 0 and $ver .= sprintf "_%02d", $s;
3049
3050     return $ver;
3051   }
3052
3053   return sprintf "%d.%d.%d", $r, $v, $s;
3054 }
3055
3056 sub info
3057 {
3058   $opt{quiet} and return;
3059   print @_, "\n";
3060 }
3061
3062 sub diag
3063 {
3064   $opt{quiet} and return;
3065   $opt{diag} and print @_, "\n";
3066 }
3067
3068 sub warning
3069 {
3070   $opt{quiet} and return;
3071   print "*** ", @_, "\n";
3072 }
3073
3074 sub error
3075 {
3076   print "*** ERROR: ", @_, "\n";
3077 }
3078
3079 my %given_hints;
3080 my %given_warnings;
3081 sub hint
3082 {
3083   $opt{quiet} and return;
3084   my $func = shift;
3085   my $rv = 0;
3086   if (exists $warnings{$func} && !$given_warnings{$func}++) {
3087     my $warn = $warnings{$func};
3088     $warn =~ s!^!*** !mg;
3089     print "*** WARNING: $func\n", $warn;
3090     $rv++;
3091   }
3092   if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {
3093     my $hint = $hints{$func};
3094     $hint =~ s/^/   /mg;
3095     print "   --- hint for $func ---\n", $hint;
3096   }
3097   $rv;
3098 }
3099
3100 sub usage
3101 {
3102   my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
3103   my %M = ( 'I' => '*' );
3104   $usage =~ s/^\s*perl\s+\S+/$^X $0/;
3105   $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;
3106
3107   print <<ENDUSAGE;
3108
3109 Usage: $usage
3110
3111 See perldoc $0 for details.
3112
3113 ENDUSAGE
3114
3115   exit 2;
3116 }
3117
3118 sub strip
3119 {
3120   my $self = do { local(@ARGV,$/)=($0); <> };
3121   my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;
3122   $copy =~ s/^(?=\S+)/    /gms;
3123   $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;
3124   $self =~ s/^SKIP.*(?=^__DATA__)/SKIP
3125 if (\@ARGV && \$ARGV[0] eq '--unstrip') {
3126   eval { require Devel::PPPort };
3127   \$@ and die "Cannot require Devel::PPPort, please install.\\n";
3128   if (eval \$Devel::PPPort::VERSION < $VERSION) {
3129     die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
3130       . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
3131       . "Please install a newer version, or --unstrip will not work.\\n";
3132   }
3133   Devel::PPPort::WriteFile(\$0);
3134   exit 0;
3135 }
3136 print <<END;
3137
3138 Sorry, but this is a stripped version of \$0.
3139
3140 To be able to use its original script and doc functionality,
3141 please try to regenerate this file using:
3142
3143   \$^X \$0 --unstrip
3144
3145 END
3146 /ms;
3147   my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms;
3148   $c =~ s{
3149     / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
3150   | ( "[^"\\]*(?:\\.[^"\\]*)*"
3151     | '[^'\\]*(?:\\.[^'\\]*)*' )
3152   | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex;
3153   $c =~ s!\s+$!!mg;
3154   $c =~ s!^$LF!!mg;
3155   $c =~ s!^\s*#\s*!#!mg;
3156   $c =~ s!^\s+!!mg;
3157
3158   open OUT, ">$0" or die "cannot strip $0: $!\n";
3159   print OUT "$pl$c\n";
3160
3161   exit 0;
3162 }
3163
3164 __DATA__
3165 */
3166
3167 #ifndef _P_P_PORTABILITY_H_
3168 #define _P_P_PORTABILITY_H_
3169
3170 #ifndef DPPP_NAMESPACE
3171 #  define DPPP_NAMESPACE DPPP_
3172 #endif
3173
3174 #define DPPP_CAT2(x,y) CAT2(x,y)
3175 #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)
3176
3177 #ifndef PERL_REVISION
3178 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
3179 #    define PERL_PATCHLEVEL_H_IMPLICIT
3180 #    include <patchlevel.h>
3181 #  endif
3182 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
3183 #    include <could_not_find_Perl_patchlevel.h>
3184 #  endif
3185 #  ifndef PERL_REVISION
3186 #    define PERL_REVISION       (5)
3187      /* Replace: 1 */
3188 #    define PERL_VERSION        PATCHLEVEL
3189 #    define PERL_SUBVERSION     SUBVERSION
3190      /* Replace PERL_PATCHLEVEL with PERL_VERSION */
3191      /* Replace: 0 */
3192 #  endif
3193 #endif
3194
3195 #define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
3196 #define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))
3197
3198 /* It is very unlikely that anyone will try to use this with Perl 6
3199    (or greater), but who knows.
3200  */
3201 #if PERL_REVISION != 5
3202 #  error ppport.h only works with Perl version 5
3203 #endif /* PERL_REVISION != 5 */
3204 #ifndef dTHR
3205 #  define dTHR                           dNOOP
3206 #endif
3207 #ifndef dTHX
3208 #  define dTHX                           dNOOP
3209 #endif
3210
3211 #ifndef dTHXa
3212 #  define dTHXa(x)                       dNOOP
3213 #endif
3214 #ifndef pTHX
3215 #  define pTHX                           void
3216 #endif
3217
3218 #ifndef pTHX_
3219 #  define pTHX_
3220 #endif
3221
3222 #ifndef aTHX
3223 #  define aTHX
3224 #endif
3225
3226 #ifndef aTHX_
3227 #  define aTHX_
3228 #endif
3229
3230 #if (PERL_BCDVERSION < 0x5006000)
3231 #  ifdef USE_THREADS
3232 #    define aTHXR  thr
3233 #    define aTHXR_ thr,
3234 #  else
3235 #    define aTHXR
3236 #    define aTHXR_
3237 #  endif
3238 #  define dTHXR  dTHR
3239 #else
3240 #  define aTHXR  aTHX
3241 #  define aTHXR_ aTHX_
3242 #  define dTHXR  dTHX
3243 #endif
3244 #ifndef dTHXoa
3245 #  define dTHXoa(x)                      dTHXa(x)
3246 #endif
3247
3248 #ifdef I_LIMITS
3249 #  include <limits.h>
3250 #endif
3251
3252 #ifndef PERL_UCHAR_MIN
3253 #  define PERL_UCHAR_MIN ((unsigned char)0)
3254 #endif
3255
3256 #ifndef PERL_UCHAR_MAX
3257 #  ifdef UCHAR_MAX
3258 #    define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
3259 #  else
3260 #    ifdef MAXUCHAR
3261 #      define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)
3262 #    else
3263 #      define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)
3264 #    endif
3265 #  endif
3266 #endif
3267
3268 #ifndef PERL_USHORT_MIN
3269 #  define PERL_USHORT_MIN ((unsigned short)0)
3270 #endif
3271
3272 #ifndef PERL_USHORT_MAX
3273 #  ifdef USHORT_MAX
3274 #    define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)
3275 #  else
3276 #    ifdef MAXUSHORT
3277 #      define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)
3278 #    else
3279 #      ifdef USHRT_MAX
3280 #        define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
3281 #      else
3282 #        define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)
3283 #      endif
3284 #    endif
3285 #  endif
3286 #endif
3287
3288 #ifndef PERL_SHORT_MAX
3289 #  ifdef SHORT_MAX
3290 #    define PERL_SHORT_MAX ((short)SHORT_MAX)
3291 #  else
3292 #    ifdef MAXSHORT    /* Often used in <values.h> */
3293 #      define PERL_SHORT_MAX ((short)MAXSHORT)
3294 #    else
3295 #      ifdef SHRT_MAX
3296 #        define PERL_SHORT_MAX ((short)SHRT_MAX)
3297 #      else
3298 #        define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))
3299 #      endif
3300 #    endif
3301 #  endif
3302 #endif
3303
3304 #ifndef PERL_SHORT_MIN
3305 #  ifdef SHORT_MIN
3306 #    define PERL_SHORT_MIN ((short)SHORT_MIN)
3307 #  else
3308 #    ifdef MINSHORT
3309 #      define PERL_SHORT_MIN ((short)MINSHORT)
3310 #    else
3311 #      ifdef SHRT_MIN
3312 #        define PERL_SHORT_MIN ((short)SHRT_MIN)
3313 #      else
3314 #        define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))
3315 #      endif
3316 #    endif
3317 #  endif
3318 #endif
3319
3320 #ifndef PERL_UINT_MAX
3321 #  ifdef UINT_MAX
3322 #    define PERL_UINT_MAX ((unsigned int)UINT_MAX)
3323 #  else
3324 #    ifdef MAXUINT
3325 #      define PERL_UINT_MAX ((unsigned int)MAXUINT)
3326 #    else
3327 #      define PERL_UINT_MAX (~(unsigned int)0)
3328 #    endif
3329 #  endif
3330 #endif
3331
3332 #ifndef PERL_UINT_MIN
3333 #  define PERL_UINT_MIN ((unsigned int)0)
3334 #endif
3335
3336 #ifndef PERL_INT_MAX
3337 #  ifdef INT_MAX
3338 #    define PERL_INT_MAX ((int)INT_MAX)
3339 #  else
3340 #    ifdef MAXINT    /* Often used in <values.h> */
3341 #      define PERL_INT_MAX ((int)MAXINT)
3342 #    else
3343 #      define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))
3344 #    endif
3345 #  endif
3346 #endif
3347
3348 #ifndef PERL_INT_MIN
3349 #  ifdef INT_MIN
3350 #    define PERL_INT_MIN ((int)INT_MIN)
3351 #  else
3352 #    ifdef MININT
3353 #      define PERL_INT_MIN ((int)MININT)
3354 #    else
3355 #      define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))
3356 #    endif
3357 #  endif
3358 #endif
3359
3360 #ifndef PERL_ULONG_MAX
3361 #  ifdef ULONG_MAX
3362 #    define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
3363 #  else
3364 #    ifdef MAXULONG
3365 #      define PERL_ULONG_MAX ((unsigned long)MAXULONG)
3366 #    else
3367 #      define PERL_ULONG_MAX (~(unsigned long)0)
3368 #    endif
3369 #  endif
3370 #endif
3371
3372 #ifndef PERL_ULONG_MIN
3373 #  define PERL_ULONG_MIN ((unsigned long)0L)
3374 #endif
3375
3376 #ifndef PERL_LONG_MAX
3377 #  ifdef LONG_MAX
3378 #    define PERL_LONG_MAX ((long)LONG_MAX)
3379 #  else
3380 #    ifdef MAXLONG
3381 #      define PERL_LONG_MAX ((long)MAXLONG)
3382 #    else
3383 #      define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))
3384 #    endif
3385 #  endif
3386 #endif
3387
3388 #ifndef PERL_LONG_MIN
3389 #  ifdef LONG_MIN
3390 #    define PERL_LONG_MIN ((long)LONG_MIN)
3391 #  else
3392 #    ifdef MINLONG
3393 #      define PERL_LONG_MIN ((long)MINLONG)
3394 #    else
3395 #      define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))
3396 #    endif
3397 #  endif
3398 #endif
3399
3400 #if defined(HAS_QUAD) && (defined(convex) || defined(uts))
3401 #  ifndef PERL_UQUAD_MAX
3402 #    ifdef ULONGLONG_MAX
3403 #      define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)
3404 #    else
3405 #      ifdef MAXULONGLONG
3406 #        define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)
3407 #      else
3408 #        define PERL_UQUAD_MAX (~(unsigned long long)0)
3409 #      endif
3410 #    endif
3411 #  endif
3412
3413 #  ifndef PERL_UQUAD_MIN
3414 #    define PERL_UQUAD_MIN ((unsigned long long)0L)
3415 #  endif
3416
3417 #  ifndef PERL_QUAD_MAX
3418 #    ifdef LONGLONG_MAX
3419 #      define PERL_QUAD_MAX ((long long)LONGLONG_MAX)
3420 #    else
3421 #      ifdef MAXLONGLONG
3422 #        define PERL_QUAD_MAX ((long long)MAXLONGLONG)
3423 #      else
3424 #        define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))
3425 #      endif
3426 #    endif
3427 #  endif
3428
3429 #  ifndef PERL_QUAD_MIN
3430 #    ifdef LONGLONG_MIN
3431 #      define PERL_QUAD_MIN ((long long)LONGLONG_MIN)
3432 #    else
3433 #      ifdef MINLONGLONG
3434 #        define PERL_QUAD_MIN ((long long)MINLONGLONG)
3435 #      else
3436 #        define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
3437 #      endif
3438 #    endif
3439 #  endif
3440 #endif
3441
3442 /* This is based on code from 5.003 perl.h */
3443 #ifdef HAS_QUAD
3444 #  ifdef cray
3445 #ifndef IVTYPE
3446 #  define IVTYPE                         int
3447 #endif
3448
3449 #ifndef IV_MIN
3450 #  define IV_MIN                         PERL_INT_MIN
3451 #endif
3452
3453 #ifndef IV_MAX
3454 #  define IV_MAX                         PERL_INT_MAX
3455 #endif
3456
3457 #ifndef UV_MIN
3458 #  define UV_MIN                         PERL_UINT_MIN
3459 #endif
3460
3461 #ifndef UV_MAX
3462 #  define UV_MAX                         PERL_UINT_MAX
3463 #endif
3464
3465 #    ifdef INTSIZE
3466 #ifndef IVSIZE
3467 #  define IVSIZE                         INTSIZE
3468 #endif
3469
3470 #    endif
3471 #  else
3472 #    if defined(convex) || defined(uts)
3473 #ifndef IVTYPE
3474 #  define IVTYPE                         long long
3475 #endif
3476
3477 #ifndef IV_MIN
3478 #  define IV_MIN                         PERL_QUAD_MIN
3479 #endif
3480
3481 #ifndef IV_MAX
3482 #  define IV_MAX                         PERL_QUAD_MAX
3483 #endif
3484
3485 #ifndef UV_MIN
3486 #  define UV_MIN                         PERL_UQUAD_MIN
3487 #endif
3488
3489 #ifndef UV_MAX
3490 #  define UV_MAX                         PERL_UQUAD_MAX
3491 #endif
3492
3493 #      ifdef LONGLONGSIZE
3494 #ifndef IVSIZE
3495 #  define IVSIZE                         LONGLONGSIZE
3496 #endif
3497
3498 #      endif
3499 #    else
3500 #ifndef IVTYPE
3501 #  define IVTYPE                         long
3502 #endif
3503
3504 #ifndef IV_MIN
3505 #  define IV_MIN                         PERL_LONG_MIN
3506 #endif
3507
3508 #ifndef IV_MAX
3509 #  define IV_MAX                         PERL_LONG_MAX
3510 #endif
3511
3512 #ifndef UV_MIN
3513 #  define UV_MIN                         PERL_ULONG_MIN
3514 #endif
3515
3516 #ifndef UV_MAX
3517 #  define UV_MAX                         PERL_ULONG_MAX
3518 #endif
3519
3520 #      ifdef LONGSIZE
3521 #ifndef IVSIZE
3522 #  define IVSIZE                         LONGSIZE
3523 #endif
3524
3525 #      endif
3526 #    endif
3527 #  endif
3528 #ifndef IVSIZE
3529 #  define IVSIZE                         8
3530 #endif
3531
3532 #ifndef PERL_QUAD_MIN
3533 #  define PERL_QUAD_MIN                  IV_MIN
3534 #endif
3535
3536 #ifndef PERL_QUAD_MAX
3537 #  define PERL_QUAD_MAX                  IV_MAX
3538 #endif
3539
3540 #ifndef PERL_UQUAD_MIN
3541 #  define PERL_UQUAD_MIN                 UV_MIN
3542 #endif
3543
3544 #ifndef PERL_UQUAD_MAX
3545 #  define PERL_UQUAD_MAX                 UV_MAX
3546 #endif
3547
3548 #else
3549 #ifndef IVTYPE
3550 #  define IVTYPE                         long
3551 #endif
3552
3553 #ifndef IV_MIN
3554 #  define IV_MIN                         PERL_LONG_MIN
3555 #endif
3556
3557 #ifndef IV_MAX
3558 #  define IV_MAX                         PERL_LONG_MAX
3559 #endif
3560
3561 #ifndef UV_MIN
3562 #  define UV_MIN                         PERL_ULONG_MIN
3563 #endif
3564
3565 #ifndef UV_MAX
3566 #  define UV_MAX                         PERL_ULONG_MAX
3567 #endif
3568
3569 #endif
3570
3571 #ifndef IVSIZE
3572 #  ifdef LONGSIZE
3573 #    define IVSIZE LONGSIZE
3574 #  else
3575 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
3576 #  endif
3577 #endif
3578 #ifndef UVTYPE
3579 #  define UVTYPE                         unsigned IVTYPE
3580 #endif
3581
3582 #ifndef UVSIZE
3583 #  define UVSIZE                         IVSIZE
3584 #endif
3585 #ifndef sv_setuv
3586 #  define sv_setuv(sv, uv)               \
3587                STMT_START {                         \
3588                  UV TeMpUv = uv;                    \
3589                  if (TeMpUv <= IV_MAX)              \
3590                    sv_setiv(sv, TeMpUv);            \
3591                  else                               \
3592                    sv_setnv(sv, (double)TeMpUv);    \
3593                } STMT_END
3594 #endif
3595 #ifndef newSVuv
3596 #  define newSVuv(uv)                    ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
3597 #endif
3598 #ifndef sv_2uv
3599 #  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
3600 #endif
3601
3602 #ifndef SvUVX
3603 #  define SvUVX(sv)                      ((UV)SvIVX(sv))
3604 #endif
3605
3606 #ifndef SvUVXx
3607 #  define SvUVXx(sv)                     SvUVX(sv)
3608 #endif
3609
3610 #ifndef SvUV
3611 #  define SvUV(sv)                       (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
3612 #endif
3613
3614 #ifndef SvUVx
3615 #  define SvUVx(sv)                      ((PL_Sv = (sv)), SvUV(PL_Sv))
3616 #endif
3617
3618 /* Hint: sv_uv
3619  * Always use the SvUVx() macro instead of sv_uv().
3620  */
3621 #ifndef sv_uv
3622 #  define sv_uv(sv)                      SvUVx(sv)
3623 #endif
3624
3625 #if !defined(SvUOK) && defined(SvIOK_UV)
3626 #  define SvUOK(sv) SvIOK_UV(sv)
3627 #endif
3628 #ifndef XST_mUV
3629 #  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )
3630 #endif
3631
3632 #ifndef XSRETURN_UV
3633 #  define XSRETURN_UV(v)                 STMT_START { XST_mUV(0,v);  XSRETURN(1); } STMT_END
3634 #endif
3635 #ifndef PUSHu
3636 #  define PUSHu(u)                       STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG;  } STMT_END
3637 #endif
3638
3639 #ifndef XPUSHu
3640 #  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
3641 #endif
3642
3643 #ifdef HAS_MEMCMP
3644 #ifndef memNE
3645 #  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))
3646 #endif
3647
3648 #ifndef memEQ
3649 #  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))
3650 #endif
3651
3652 #else
3653 #ifndef memNE
3654 #  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))
3655 #endif
3656
3657 #ifndef memEQ
3658 #  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))
3659 #endif
3660
3661 #endif
3662 #ifndef MoveD
3663 #  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))
3664 #endif
3665
3666 #ifndef CopyD
3667 #  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
3668 #endif
3669
3670 #ifdef HAS_MEMSET
3671 #ifndef ZeroD
3672 #  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))
3673 #endif
3674
3675 #else
3676 #ifndef ZeroD
3677 #  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)), d)
3678 #endif
3679
3680 #endif
3681 #ifndef PoisonWith
3682 #  define PoisonWith(d,n,t,b)            (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
3683 #endif
3684
3685 #ifndef PoisonNew
3686 #  define PoisonNew(d,n,t)               PoisonWith(d,n,t,0xAB)
3687 #endif
3688
3689 #ifndef PoisonFree
3690 #  define PoisonFree(d,n,t)              PoisonWith(d,n,t,0xEF)
3691 #endif
3692
3693 #ifndef Poison
3694 #  define Poison(d,n,t)                  PoisonFree(d,n,t)
3695 #endif
3696 #ifndef Newx
3697 #  define Newx(v,n,t)                    New(0,v,n,t)
3698 #endif
3699
3700 #ifndef Newxc
3701 #  define Newxc(v,n,t,c)                 Newc(0,v,n,t,c)
3702 #endif
3703
3704 #ifndef Newxz
3705 #  define Newxz(v,n,t)                   Newz(0,v,n,t)
3706 #endif
3707
3708 #ifndef PERL_UNUSED_DECL
3709 #  ifdef HASATTRIBUTE
3710 #    if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
3711 #      define PERL_UNUSED_DECL
3712 #    else
3713 #      define PERL_UNUSED_DECL __attribute__((unused))
3714 #    endif
3715 #  else
3716 #    define PERL_UNUSED_DECL
3717 #  endif
3718 #endif
3719
3720 #ifndef PERL_UNUSED_ARG
3721 #  if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
3722 #    include <note.h>
3723 #    define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
3724 #  else
3725 #    define PERL_UNUSED_ARG(x) ((void)x)
3726 #  endif
3727 #endif
3728
3729 #ifndef PERL_UNUSED_VAR
3730 #  define PERL_UNUSED_VAR(x) ((void)x)
3731 #endif
3732
3733 #ifndef PERL_UNUSED_CONTEXT
3734 #  ifdef USE_ITHREADS
3735 #    define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
3736 #  else
3737 #    define PERL_UNUSED_CONTEXT
3738 #  endif
3739 #endif
3740 #ifndef NOOP
3741 #  define NOOP                           /*EMPTY*/(void)0
3742 #endif
3743
3744 #ifndef dNOOP
3745 #  define dNOOP                          extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL
3746 #endif
3747
3748 #ifndef NVTYPE
3749 #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
3750 #    define NVTYPE long double
3751 #  else
3752 #    define NVTYPE double
3753 #  endif
3754 typedef NVTYPE NV;
3755 #endif
3756
3757 #ifndef INT2PTR
3758 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
3759 #    define PTRV                  UV
3760 #    define INT2PTR(any,d)        (any)(d)
3761 #  else
3762 #    if PTRSIZE == LONGSIZE
3763 #      define PTRV                unsigned long
3764 #    else
3765 #      define PTRV                unsigned
3766 #    endif
3767 #    define INT2PTR(any,d)        (any)(PTRV)(d)
3768 #  endif
3769 #endif
3770
3771 #ifndef PTR2ul
3772 #  if PTRSIZE == LONGSIZE
3773 #    define PTR2ul(p)     (unsigned long)(p)
3774 #  else
3775 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
3776 #  endif
3777 #endif
3778 #ifndef PTR2nat
3779 #  define PTR2nat(p)                     (PTRV)(p)
3780 #endif
3781
3782 #ifndef NUM2PTR
3783 #  define NUM2PTR(any,d)                 (any)PTR2nat(d)
3784 #endif
3785
3786 #ifndef PTR2IV
3787 #  define PTR2IV(p)                      INT2PTR(IV,p)
3788 #endif
3789
3790 #ifndef PTR2UV
3791 #  define PTR2UV(p)                      INT2PTR(UV,p)
3792 #endif
3793
3794 #ifndef PTR2NV
3795 #  define PTR2NV(p)                      NUM2PTR(NV,p)
3796 #endif
3797
3798 #undef START_EXTERN_C
3799 #undef END_EXTERN_C
3800 #undef EXTERN_C
3801 #ifdef __cplusplus
3802 #  define START_EXTERN_C extern "C" {
3803 #  define END_EXTERN_C }
3804 #  define EXTERN_C extern "C"
3805 #else
3806 #  define START_EXTERN_C
3807 #  define END_EXTERN_C
3808 #  define EXTERN_C extern
3809 #endif
3810
3811 #if defined(PERL_GCC_PEDANTIC)
3812 #  ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
3813 #    define PERL_GCC_BRACE_GROUPS_FORBIDDEN
3814 #  endif
3815 #endif
3816
3817 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
3818 #  ifndef PERL_USE_GCC_BRACE_GROUPS
3819 #    define PERL_USE_GCC_BRACE_GROUPS
3820 #  endif
3821 #endif
3822
3823 #undef STMT_START
3824 #undef STMT_END
3825 #ifdef PERL_USE_GCC_BRACE_GROUPS
3826 #  define STMT_START    (void)( /* gcc supports ``({ STATEMENTS; })'' */
3827 #  define STMT_END      )
3828 #else
3829 #  if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)
3830 #    define STMT_START  if (1)
3831 #    define STMT_END    else (void)0
3832 #  else
3833 #    define STMT_START  do
3834 #    define STMT_END    while (0)
3835 #  endif
3836 #endif
3837 #ifndef boolSV
3838 #  define boolSV(b)                      ((b) ? &PL_sv_yes : &PL_sv_no)
3839 #endif
3840
3841 /* DEFSV appears first in 5.004_56 */
3842 #ifndef DEFSV
3843 #  define DEFSV                          GvSV(PL_defgv)
3844 #endif
3845
3846 #ifndef SAVE_DEFSV
3847 #  define SAVE_DEFSV                     SAVESPTR(GvSV(PL_defgv))
3848 #endif
3849
3850 #ifndef DEFSV_set
3851 #  define DEFSV_set(sv)                  (DEFSV = (sv))
3852 #endif
3853
3854 /* Older perls (<=5.003) lack AvFILLp */
3855 #ifndef AvFILLp
3856 #  define AvFILLp                        AvFILL
3857 #endif
3858 #ifndef ERRSV
3859 #  define ERRSV                          get_sv("@",FALSE)
3860 #endif
3861
3862 /* Hint: gv_stashpvn
3863  * This function's backport doesn't support the length parameter, but
3864  * rather ignores it. Portability can only be ensured if the length
3865  * parameter is used for speed reasons, but the length can always be
3866  * correctly computed from the string argument.
3867  */
3868 #ifndef gv_stashpvn
3869 #  define gv_stashpvn(str,len,create)    gv_stashpv(str,create)
3870 #endif
3871
3872 /* Replace: 1 */
3873 #ifndef get_cv
3874 #  define get_cv                         perl_get_cv
3875 #endif
3876
3877 #ifndef get_sv
3878 #  define get_sv                         perl_get_sv
3879 #endif
3880
3881 #ifndef get_av
3882 #  define get_av                         perl_get_av
3883 #endif
3884
3885 #ifndef get_hv
3886 #  define get_hv                         perl_get_hv
3887 #endif
3888
3889 /* Replace: 0 */
3890 #ifndef dUNDERBAR
3891 #  define dUNDERBAR                      dNOOP
3892 #endif
3893
3894 #ifndef UNDERBAR
3895 #  define UNDERBAR                       DEFSV
3896 #endif
3897 #ifndef dAX
3898 #  define dAX                            I32 ax = MARK - PL_stack_base + 1
3899 #endif
3900
3901 #ifndef dITEMS
3902 #  define dITEMS                         I32 items = SP - MARK
3903 #endif
3904 #ifndef dXSTARG
3905 #  define dXSTARG                        SV * targ = sv_newmortal()
3906 #endif
3907 #ifndef dAXMARK
3908 #  define dAXMARK                        I32 ax = POPMARK; \
3909                                register SV ** const mark = PL_stack_base + ax++
3910 #endif
3911 #ifndef XSprePUSH
3912 #  define XSprePUSH                      (sp = PL_stack_base + ax - 1)
3913 #endif
3914
3915 #if (PERL_BCDVERSION < 0x5005000)
3916 #  undef XSRETURN
3917 #  define XSRETURN(off)                                   \
3918       STMT_START {                                        \
3919           PL_stack_sp = PL_stack_base + ax + ((off) - 1); \
3920           return;                                         \
3921       } STMT_END
3922 #endif
3923 #ifndef XSPROTO
3924 #  define XSPROTO(name)                  void name(pTHX_ CV* cv)
3925 #endif
3926
3927 #ifndef SVfARG
3928 #  define SVfARG(p)                      ((void*)(p))
3929 #endif
3930 #ifndef PERL_ABS
3931 #  define PERL_ABS(x)                    ((x) < 0 ? -(x) : (x))
3932 #endif
3933 #ifndef dVAR
3934 #  define dVAR                           dNOOP
3935 #endif
3936 #ifndef SVf
3937 #  define SVf                            "_"
3938 #endif
3939 #ifndef UTF8_MAXBYTES
3940 #  define UTF8_MAXBYTES                  UTF8_MAXLEN
3941 #endif
3942 #ifndef CPERLscope
3943 #  define CPERLscope(x)                  x
3944 #endif
3945 #ifndef PERL_HASH
3946 #  define PERL_HASH(hash,str,len)        \
3947      STMT_START { \
3948         const char *s_PeRlHaSh = str; \
3949         I32 i_PeRlHaSh = len; \
3950         U32 hash_PeRlHaSh = 0; \
3951         while (i_PeRlHaSh--) \
3952             hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \
3953         (hash) = hash_PeRlHaSh; \
3954     } STMT_END
3955 #endif
3956
3957 #ifndef PERLIO_FUNCS_DECL
3958 # ifdef PERLIO_FUNCS_CONST
3959 #  define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
3960 #  define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
3961 # else
3962 #  define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs
3963 #  define PERLIO_FUNCS_CAST(funcs) (funcs)
3964 # endif
3965 #endif
3966
3967 /* provide these typedefs for older perls */
3968 #if (PERL_BCDVERSION < 0x5009003)
3969
3970 # ifdef ARGSproto
3971 typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto);
3972 # else
3973 typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
3974 # endif
3975
3976 typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
3977
3978 #endif
3979 #ifndef isPSXSPC
3980 #  define isPSXSPC(c)                    (isSPACE(c) || (c) == '\v')
3981 #endif
3982
3983 #ifndef isBLANK
3984 #  define isBLANK(c)                     ((c) == ' ' || (c) == '\t')
3985 #endif
3986
3987 #ifdef EBCDIC
3988 #ifndef isALNUMC
3989 #  define isALNUMC(c)                    isalnum(c)
3990 #endif
3991
3992 #ifndef isASCII
3993 #  define isASCII(c)                     isascii(c)
3994 #endif
3995
3996 #ifndef isCNTRL
3997 #  define isCNTRL(c)                     iscntrl(c)
3998 #endif
3999
4000 #ifndef isGRAPH
4001 #  define isGRAPH(c)                     isgraph(c)
4002 #endif
4003
4004 #ifndef isPRINT
4005 #  define isPRINT(c)                     isprint(c)
4006 #endif
4007
4008 #ifndef isPUNCT
4009 #  define isPUNCT(c)                     ispunct(c)
4010 #endif
4011
4012 #ifndef isXDIGIT
4013 #  define isXDIGIT(c)                    isxdigit(c)
4014 #endif
4015
4016 #else
4017 # if (PERL_BCDVERSION < 0x5010000)
4018 /* Hint: isPRINT
4019  * The implementation in older perl versions includes all of the
4020  * isSPACE() characters, which is wrong. The version provided by
4021  * Devel::PPPort always overrides a present buggy version.
4022  */
4023 #  undef isPRINT
4024 # endif
4025 #ifndef isALNUMC
4026 #  define isALNUMC(c)                    (isALPHA(c) || isDIGIT(c))
4027 #endif
4028
4029 #ifndef isASCII
4030 #  define isASCII(c)                     ((c) <= 127)
4031 #endif
4032
4033 #ifndef isCNTRL
4034 #  define isCNTRL(c)                     ((c) < ' ' || (c) == 127)
4035 #endif
4036
4037 #ifndef isGRAPH
4038 #  define isGRAPH(c)                     (isALNUM(c) || isPUNCT(c))
4039 #endif
4040
4041 #ifndef isPRINT
4042 #  define isPRINT(c)                     (((c) >= 32 && (c) < 127))
4043 #endif
4044
4045 #ifndef isPUNCT
4046 #  define isPUNCT(c)                     (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64)  || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
4047 #endif
4048
4049 #ifndef isXDIGIT
4050 #  define isXDIGIT(c)                    (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
4051 #endif
4052
4053 #endif
4054
4055 #ifndef PERL_SIGNALS_UNSAFE_FLAG
4056
4057 #define PERL_SIGNALS_UNSAFE_FLAG 0x0001
4058
4059 #if (PERL_BCDVERSION < 0x5008000)
4060 #  define D_PPP_PERL_SIGNALS_INIT   PERL_SIGNALS_UNSAFE_FLAG
4061 #else
4062 #  define D_PPP_PERL_SIGNALS_INIT   0
4063 #endif
4064
4065 #if defined(NEED_PL_signals)
4066 static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
4067 #elif defined(NEED_PL_signals_GLOBAL)
4068 U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
4069 #else
4070 extern U32 DPPP_(my_PL_signals);
4071 #endif
4072 #define PL_signals DPPP_(my_PL_signals)
4073
4074 #endif
4075
4076 /* Hint: PL_ppaddr
4077  * Calling an op via PL_ppaddr requires passing a context argument
4078  * for threaded builds. Since the context argument is different for
4079  * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
4080  * automatically be defined as the correct argument.
4081  */
4082
4083 #if (PERL_BCDVERSION <= 0x5005005)
4084 /* Replace: 1 */
4085 #  define PL_ppaddr                 ppaddr
4086 #  define PL_no_modify              no_modify
4087 /* Replace: 0 */
4088 #endif
4089
4090 #if (PERL_BCDVERSION <= 0x5004005)
4091 /* Replace: 1 */
4092 #  define PL_DBsignal               DBsignal
4093 #  define PL_DBsingle               DBsingle
4094 #  define PL_DBsub                  DBsub
4095 #  define PL_DBtrace                DBtrace
4096 #  define PL_Sv                     Sv
4097 #  define PL_bufend                 bufend
4098 #  define PL_bufptr                 bufptr
4099 #  define PL_compiling              compiling
4100 #  define PL_copline                copline
4101 #  define PL_curcop                 curcop
4102 #  define PL_curstash               curstash
4103 #  define PL_debstash               debstash
4104 #  define PL_defgv                  defgv
4105 #  define PL_diehook                diehook
4106 #  define PL_dirty                  dirty
4107 #  define PL_dowarn                 dowarn
4108 #  define PL_errgv                  errgv
4109 #  define PL_error_count            error_count
4110 #  define PL_expect                 expect
4111 #  define PL_hexdigit               hexdigit
4112 #  define PL_hints                  hints
4113 #  define PL_in_my                  in_my
4114 #  define PL_laststatval            laststatval
4115 #  define PL_lex_state              lex_state
4116 #  define PL_lex_stuff              lex_stuff
4117 #  define PL_linestr                linestr
4118 #  define PL_na                     na
4119 #  define PL_perl_destruct_level    perl_destruct_level
4120 #  define PL_perldb                 perldb
4121 #  define PL_rsfp_filters           rsfp_filters
4122 #  define PL_rsfp                   rsfp
4123 #  define PL_stack_base             stack_base
4124 #  define PL_stack_sp               stack_sp
4125 #  define PL_statcache              statcache
4126 #  define PL_stdingv                stdingv
4127 #  define PL_sv_arenaroot           sv_arenaroot
4128 #  define PL_sv_no                  sv_no
4129 #  define PL_sv_undef               sv_undef
4130 #  define PL_sv_yes                 sv_yes
4131 #  define PL_tainted                tainted
4132 #  define PL_tainting               tainting
4133 #  define PL_tokenbuf               tokenbuf
4134 /* Replace: 0 */
4135 #endif
4136
4137 /* Warning: PL_parser
4138  * For perl versions earlier than 5.9.5, this is an always
4139  * non-NULL dummy. Also, it cannot be dereferenced. Don't
4140  * use it if you can avoid is and unless you absolutely know
4141  * what you're doing.
4142  * If you always check that PL_parser is non-NULL, you can
4143  * define DPPP_PL_parser_NO_DUMMY to avoid the creation of
4144  * a dummy parser structure.
4145  */
4146
4147 #if (PERL_BCDVERSION >= 0x5009005)
4148 # ifdef DPPP_PL_parser_NO_DUMMY
4149 #  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
4150                 (croak("panic: PL_parser == NULL in %s:%d", \
4151                        __FILE__, __LINE__), (yy_parser *) NULL))->var)
4152 # else
4153 #  ifdef DPPP_PL_parser_NO_DUMMY_WARNING
4154 #   define D_PPP_parser_dummy_warning(var)
4155 #  else
4156 #   define D_PPP_parser_dummy_warning(var) \
4157              warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
4158 #  endif
4159 #  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
4160                 (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
4161 #if defined(NEED_PL_parser)
4162 static yy_parser DPPP_(dummy_PL_parser);
4163 #elif defined(NEED_PL_parser_GLOBAL)
4164 yy_parser DPPP_(dummy_PL_parser);
4165 #else
4166 extern yy_parser DPPP_(dummy_PL_parser);
4167 #endif
4168
4169 # endif
4170
4171 /* 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 */
4172 /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
4173  * Do not use this variable unless you know exactly what you're
4174  * doint. It is internal to the perl parser and may change or even
4175  * be removed in the future. As of perl 5.9.5, you have to check
4176  * for (PL_parser != NULL) for this variable to have any effect.
4177  * An always non-NULL PL_parser dummy is provided for earlier
4178  * perl versions.
4179  * If PL_parser is NULL when you try to access this variable, a
4180  * dummy is being accessed instead and a warning is issued unless
4181  * you define DPPP_PL_parser_NO_DUMMY_WARNING.
4182  * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
4183  * this variable will croak with a panic message.
4184  */
4185
4186 # define PL_expect         D_PPP_my_PL_parser_var(expect)
4187 # define PL_copline        D_PPP_my_PL_parser_var(copline)
4188 # define PL_rsfp           D_PPP_my_PL_parser_var(rsfp)
4189 # define PL_rsfp_filters   D_PPP_my_PL_parser_var(rsfp_filters)
4190 # define PL_linestr        D_PPP_my_PL_parser_var(linestr)
4191 # define PL_bufptr         D_PPP_my_PL_parser_var(bufptr)
4192 # define PL_bufend         D_PPP_my_PL_parser_var(bufend)
4193 # define PL_lex_state      D_PPP_my_PL_parser_var(lex_state)
4194 # define PL_lex_stuff      D_PPP_my_PL_parser_var(lex_stuff)
4195 # define PL_tokenbuf       D_PPP_my_PL_parser_var(tokenbuf)
4196 # define PL_in_my          D_PPP_my_PL_parser_var(in_my)
4197 # define PL_in_my_stash    D_PPP_my_PL_parser_var(in_my_stash)
4198 # define PL_error_count    D_PPP_my_PL_parser_var(error_count)
4199
4200
4201 #else
4202
4203 /* ensure that PL_parser != NULL and cannot be dereferenced */
4204 # define PL_parser         ((void *) 1)
4205
4206 #endif
4207 #ifndef mPUSHs
4208 #  define mPUSHs(s)                      PUSHs(sv_2mortal(s))
4209 #endif
4210
4211 #ifndef PUSHmortal
4212 #  define PUSHmortal                     PUSHs(sv_newmortal())
4213 #endif
4214
4215 #ifndef mPUSHp
4216 #  define mPUSHp(p,l)                    sv_setpvn(PUSHmortal, (p), (l))
4217 #endif
4218
4219 #ifndef mPUSHn
4220 #  define mPUSHn(n)                      sv_setnv(PUSHmortal, (NV)(n))
4221 #endif
4222
4223 #ifndef mPUSHi
4224 #  define mPUSHi(i)                      sv_setiv(PUSHmortal, (IV)(i))
4225 #endif
4226
4227 #ifndef mPUSHu
4228 #  define mPUSHu(u)                      sv_setuv(PUSHmortal, (UV)(u))
4229 #endif
4230 #ifndef mXPUSHs
4231 #  define mXPUSHs(s)                     XPUSHs(sv_2mortal(s))
4232 #endif
4233
4234 #ifndef XPUSHmortal
4235 #  define XPUSHmortal                    XPUSHs(sv_newmortal())
4236 #endif
4237
4238 #ifndef mXPUSHp
4239 #  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
4240 #endif
4241
4242 #ifndef mXPUSHn
4243 #  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
4244 #endif
4245
4246 #ifndef mXPUSHi
4247 #  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
4248 #endif
4249
4250 #ifndef mXPUSHu
4251 #  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
4252 #endif
4253
4254 /* Replace: 1 */
4255 #ifndef call_sv
4256 #  define call_sv                        perl_call_sv
4257 #endif
4258
4259 #ifndef call_pv
4260 #  define call_pv                        perl_call_pv
4261 #endif
4262
4263 #ifndef call_argv
4264 #  define call_argv                      perl_call_argv
4265 #endif
4266
4267 #ifndef call_method
4268 #  define call_method                    perl_call_method
4269 #endif
4270 #ifndef eval_sv
4271 #  define eval_sv                        perl_eval_sv
4272 #endif
4273
4274 /* Replace: 0 */
4275 #ifndef PERL_LOADMOD_DENY
4276 #  define PERL_LOADMOD_DENY              0x1
4277 #endif
4278
4279 #ifndef PERL_LOADMOD_NOIMPORT
4280 #  define PERL_LOADMOD_NOIMPORT          0x2
4281 #endif
4282
4283 #ifndef PERL_LOADMOD_IMPORT_OPS
4284 #  define PERL_LOADMOD_IMPORT_OPS        0x4
4285 #endif
4286
4287 #ifndef G_METHOD
4288 # define G_METHOD               64
4289 # ifdef call_sv
4290 #  undef call_sv
4291 # endif
4292 # if (PERL_BCDVERSION < 0x5006000)
4293 #  define call_sv(sv, flags)  ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
4294                                 (flags) & ~G_METHOD) : perl_call_sv(sv, flags))
4295 # else
4296 #  define call_sv(sv, flags)  ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
4297                                 (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
4298 # endif
4299 #endif
4300
4301 /* Replace perl_eval_pv with eval_pv */
4302
4303 #ifndef eval_pv
4304 #if defined(NEED_eval_pv)
4305 static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
4306 static
4307 #else
4308 extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
4309 #endif
4310
4311 #ifdef eval_pv
4312 #  undef eval_pv
4313 #endif
4314 #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
4315 #define Perl_eval_pv DPPP_(my_eval_pv)
4316
4317 #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
4318
4319 SV*
4320 DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
4321 {
4322     dSP;
4323     SV* sv = newSVpv(p, 0);
4324
4325     PUSHMARK(sp);
4326     eval_sv(sv, G_SCALAR);
4327     SvREFCNT_dec(sv);
4328
4329     SPAGAIN;
4330     sv = POPs;
4331     PUTBACK;
4332
4333     if (croak_on_error && SvTRUE(GvSV(errgv)))
4334         croak(SvPVx(GvSV(errgv), na));
4335
4336     return sv;
4337 }
4338
4339 #endif
4340 #endif
4341
4342 #ifndef vload_module
4343 #if defined(NEED_vload_module)
4344 static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
4345 static
4346 #else
4347 extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
4348 #endif
4349
4350 #ifdef vload_module
4351 #  undef vload_module
4352 #endif
4353 #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
4354 #define Perl_vload_module DPPP_(my_vload_module)
4355
4356 #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
4357
4358 void
4359 DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
4360 {
4361     dTHR;
4362     dVAR;
4363     OP *veop, *imop;
4364
4365     OP * const modname = newSVOP(OP_CONST, 0, name);
4366     /* 5.005 has a somewhat hacky force_normal that doesn't croak on
4367        SvREADONLY() if PL_compling is true. Current perls take care in
4368        ck_require() to correctly turn off SvREADONLY before calling
4369        force_normal_flags(). This seems a better fix than fudging PL_compling
4370      */
4371     SvREADONLY_off(((SVOP*)modname)->op_sv);
4372     modname->op_private |= OPpCONST_BARE;
4373     if (ver) {
4374         veop = newSVOP(OP_CONST, 0, ver);
4375     }
4376     else
4377         veop = NULL;
4378     if (flags & PERL_LOADMOD_NOIMPORT) {
4379         imop = sawparens(newNULLLIST());
4380     }
4381     else if (flags & PERL_LOADMOD_IMPORT_OPS) {
4382         imop = va_arg(*args, OP*);
4383     }
4384     else {
4385         SV *sv;
4386         imop = NULL;
4387         sv = va_arg(*args, SV*);
4388         while (sv) {
4389             imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
4390             sv = va_arg(*args, SV*);
4391         }
4392     }
4393     {
4394         const line_t ocopline = PL_copline;
4395         COP * const ocurcop = PL_curcop;
4396         const int oexpect = PL_expect;
4397
4398 #if (PERL_BCDVERSION >= 0x5004000)
4399         utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
4400                 veop, modname, imop);
4401 #else
4402         utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
4403                 modname, imop);
4404 #endif
4405         PL_expect = oexpect;
4406         PL_copline = ocopline;
4407         PL_curcop = ocurcop;
4408     }
4409 }
4410
4411 #endif
4412 #endif
4413
4414 #ifndef load_module
4415 #if defined(NEED_load_module)
4416 static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
4417 static
4418 #else
4419 extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
4420 #endif
4421
4422 #ifdef load_module
4423 #  undef load_module
4424 #endif
4425 #define load_module DPPP_(my_load_module)
4426 #define Perl_load_module DPPP_(my_load_module)
4427
4428 #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
4429
4430 void
4431 DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
4432 {
4433     va_list args;
4434     va_start(args, ver);
4435     vload_module(flags, name, ver, &args);
4436     va_end(args);
4437 }
4438
4439 #endif
4440 #endif
4441 #ifndef newRV_inc
4442 #  define newRV_inc(sv)                  newRV(sv)   /* Replace */
4443 #endif
4444
4445 #ifndef newRV_noinc
4446 #if defined(NEED_newRV_noinc)
4447 static SV * DPPP_(my_newRV_noinc)(SV *sv);
4448 static
4449 #else
4450 extern SV * DPPP_(my_newRV_noinc)(SV *sv);
4451 #endif
4452
4453 #ifdef newRV_noinc
4454 #  undef newRV_noinc
4455 #endif
4456 #define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
4457 #define Perl_newRV_noinc DPPP_(my_newRV_noinc)
4458
4459 #if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
4460 SV *
4461 DPPP_(my_newRV_noinc)(SV *sv)
4462 {
4463   SV *rv = (SV *)newRV(sv);
4464   SvREFCNT_dec(sv);
4465   return rv;
4466 }
4467 #endif
4468 #endif
4469
4470 /* Hint: newCONSTSUB
4471  * Returns a CV* as of perl-5.7.1. This return value is not supported
4472  * by Devel::PPPort.
4473  */
4474
4475 /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
4476 #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
4477 #if defined(NEED_newCONSTSUB)
4478 static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
4479 static
4480 #else
4481 extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
4482 #endif
4483
4484 #ifdef newCONSTSUB
4485 #  undef newCONSTSUB
4486 #endif
4487 #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
4488 #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
4489
4490 #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
4491
4492 /* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
4493 /* (There's no PL_parser in perl < 5.005, so this is completely safe)     */
4494 #define D_PPP_PL_copline PL_copline
4495
4496 void
4497 DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
4498 {
4499         U32 oldhints = PL_hints;
4500         HV *old_cop_stash = PL_curcop->cop_stash;
4501         HV *old_curstash = PL_curstash;
4502         line_t oldline = PL_curcop->cop_line;
4503         PL_curcop->cop_line = D_PPP_PL_copline;
4504
4505         PL_hints &= ~HINT_BLOCK_SCOPE;
4506         if (stash)
4507                 PL_curstash = PL_curcop->cop_stash = stash;
4508
4509         newSUB(
4510
4511 #if   (PERL_BCDVERSION < 0x5003022)
4512                 start_subparse(),
4513 #elif (PERL_BCDVERSION == 0x5003022)
4514                 start_subparse(0),
4515 #else  /* 5.003_23  onwards */
4516                 start_subparse(FALSE, 0),
4517 #endif
4518
4519                 newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
4520                 newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */
4521                 newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4522         );
4523
4524         PL_hints = oldhints;
4525         PL_curcop->cop_stash = old_cop_stash;
4526         PL_curstash = old_curstash;
4527         PL_curcop->cop_line = oldline;
4528 }
4529 #endif
4530 #endif
4531
4532 /*
4533  * Boilerplate macros for initializing and accessing interpreter-local
4534  * data from C.  All statics in extensions should be reworked to use
4535  * this, if you want to make the extension thread-safe.  See ext/re/re.xs
4536  * for an example of the use of these macros.
4537  *
4538  * Code that uses these macros is responsible for the following:
4539  * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
4540  * 2. Declare a typedef named my_cxt_t that is a structure that contains
4541  *    all the data that needs to be interpreter-local.
4542  * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
4543  * 4. Use the MY_CXT_INIT macro such that it is called exactly once
4544  *    (typically put in the BOOT: section).
4545  * 5. Use the members of the my_cxt_t structure everywhere as
4546  *    MY_CXT.member.
4547  * 6. Use the dMY_CXT macro (a declaration) in all the functions that
4548  *    access MY_CXT.
4549  */
4550
4551 #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
4552     defined(PERL_CAPI)    || defined(PERL_IMPLICIT_CONTEXT)
4553
4554 #ifndef START_MY_CXT
4555
4556 /* This must appear in all extensions that define a my_cxt_t structure,
4557  * right after the definition (i.e. at file scope).  The non-threads
4558  * case below uses it to declare the data as static. */
4559 #define START_MY_CXT
4560
4561 #if (PERL_BCDVERSION < 0x5004068)
4562 /* Fetches the SV that keeps the per-interpreter data. */
4563 #define dMY_CXT_SV \
4564         SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
4565 #else /* >= perl5.004_68 */
4566 #define dMY_CXT_SV \
4567         SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY,             \
4568                                   sizeof(MY_CXT_KEY)-1, TRUE)
4569 #endif /* < perl5.004_68 */
4570
4571 /* This declaration should be used within all functions that use the
4572  * interpreter-local data. */
4573 #define dMY_CXT \
4574         dMY_CXT_SV;                                                     \
4575         my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
4576
4577 /* Creates and zeroes the per-interpreter data.
4578  * (We allocate my_cxtp in a Perl SV so that it will be released when
4579  * the interpreter goes away.) */
4580 #define MY_CXT_INIT \
4581         dMY_CXT_SV;                                                     \
4582         /* newSV() allocates one more than needed */                    \
4583         my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
4584         Zero(my_cxtp, 1, my_cxt_t);                                     \
4585         sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
4586
4587 /* This macro must be used to access members of the my_cxt_t structure.
4588  * e.g. MYCXT.some_data */
4589 #define MY_CXT          (*my_cxtp)
4590
4591 /* Judicious use of these macros can reduce the number of times dMY_CXT
4592  * is used.  Use is similar to pTHX, aTHX etc. */
4593 #define pMY_CXT         my_cxt_t *my_cxtp
4594 #define pMY_CXT_        pMY_CXT,
4595 #define _pMY_CXT        ,pMY_CXT
4596 #define aMY_CXT         my_cxtp
4597 #define aMY_CXT_        aMY_CXT,
4598 #define _aMY_CXT        ,aMY_CXT
4599
4600 #endif /* START_MY_CXT */
4601
4602 #ifndef MY_CXT_CLONE
4603 /* Clones the per-interpreter data. */
4604 #define MY_CXT_CLONE \
4605         dMY_CXT_SV;                                                     \
4606         my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
4607         Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
4608         sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
4609 #endif
4610
4611 #else /* single interpreter */
4612
4613 #ifndef START_MY_CXT
4614
4615 #define START_MY_CXT    static my_cxt_t my_cxt;
4616 #define dMY_CXT_SV      dNOOP
4617 #define dMY_CXT         dNOOP
4618 #define MY_CXT_INIT     NOOP
4619 #define MY_CXT          my_cxt
4620
4621 #define pMY_CXT         void
4622 #define pMY_CXT_
4623 #define _pMY_CXT
4624 #define aMY_CXT
4625 #define aMY_CXT_
4626 #define _aMY_CXT
4627
4628 #endif /* START_MY_CXT */
4629
4630 #ifndef MY_CXT_CLONE
4631 #define MY_CXT_CLONE    NOOP
4632 #endif
4633
4634 #endif
4635
4636 #ifndef IVdf
4637 #  if IVSIZE == LONGSIZE
4638 #    define     IVdf      "ld"
4639 #    define     UVuf      "lu"
4640 #    define     UVof      "lo"
4641 #    define     UVxf      "lx"
4642 #    define     UVXf      "lX"
4643 #  else
4644 #    if IVSIZE == INTSIZE
4645 #      define   IVdf      "d"
4646 #      define   UVuf      "u"
4647 #      define   UVof      "o"
4648 #      define   UVxf      "x"
4649 #      define   UVXf      "X"
4650 #    endif
4651 #  endif
4652 #endif
4653
4654 #ifndef NVef
4655 #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
4656       defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
4657             /* Not very likely, but let's try anyway. */
4658 #    define NVef          PERL_PRIeldbl
4659 #    define NVff          PERL_PRIfldbl
4660 #    define NVgf          PERL_PRIgldbl
4661 #  else
4662 #    define NVef          "e"
4663 #    define NVff          "f"
4664 #    define NVgf          "g"
4665 #  endif
4666 #endif
4667
4668 #ifndef SvREFCNT_inc
4669 #  ifdef PERL_USE_GCC_BRACE_GROUPS
4670 #    define SvREFCNT_inc(sv)            \
4671       ({                                \
4672           SV * const _sv = (SV*)(sv);   \
4673           if (_sv)                      \
4674                (SvREFCNT(_sv))++;       \
4675           _sv;                          \
4676       })
4677 #  else
4678 #    define SvREFCNT_inc(sv)    \
4679           ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
4680 #  endif
4681 #endif
4682
4683 #ifndef SvREFCNT_inc_simple
4684 #  ifdef PERL_USE_GCC_BRACE_GROUPS
4685 #    define SvREFCNT_inc_simple(sv)     \
4686       ({                                        \
4687           if (sv)                               \
4688                (SvREFCNT(sv))++;                \
4689           (SV *)(sv);                           \
4690       })
4691 #  else
4692 #    define SvREFCNT_inc_simple(sv) \
4693           ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
4694 #  endif
4695 #endif
4696
4697 #ifndef SvREFCNT_inc_NN
4698 #  ifdef PERL_USE_GCC_BRACE_GROUPS
4699 #    define SvREFCNT_inc_NN(sv)         \
4700       ({                                        \
4701           SV * const _sv = (SV*)(sv);   \
4702           SvREFCNT(_sv)++;              \
4703           _sv;                          \
4704       })
4705 #  else
4706 #    define SvREFCNT_inc_NN(sv) \
4707           (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
4708 #  endif
4709 #endif
4710
4711 #ifndef SvREFCNT_inc_void
4712 #  ifdef PERL_USE_GCC_BRACE_GROUPS
4713 #    define SvREFCNT_inc_void(sv)               \
4714       ({                                        \
4715           SV * const _sv = (SV*)(sv);   \
4716           if (_sv)                      \
4717               (void)(SvREFCNT(_sv)++);  \
4718       })
4719 #  else
4720 #    define SvREFCNT_inc_void(sv) \
4721           (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
4722 #  endif
4723 #endif
4724 #ifndef SvREFCNT_inc_simple_void
4725 #  define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
4726 #endif
4727
4728 #ifndef SvREFCNT_inc_simple_NN
4729 #  define SvREFCNT_inc_simple_NN(sv)     (++SvREFCNT(sv), (SV*)(sv))
4730 #endif
4731
4732 #ifndef SvREFCNT_inc_void_NN
4733 #  define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT((SV*)(sv)))
4734 #endif
4735
4736 #ifndef SvREFCNT_inc_simple_void_NN
4737 #  define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
4738 #endif
4739
4740 #ifndef newSV_type
4741
4742 #if defined(NEED_newSV_type)
4743 static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
4744 static
4745 #else
4746 extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
4747 #endif
4748
4749 #ifdef newSV_type
4750 #  undef newSV_type
4751 #endif
4752 #define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a)
4753 #define Perl_newSV_type DPPP_(my_newSV_type)
4754
4755 #if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)
4756
4757 SV*
4758 DPPP_(my_newSV_type)(pTHX_ svtype const t)
4759 {
4760   SV* const sv = newSV(0);
4761   sv_upgrade(sv, t);
4762   return sv;
4763 }
4764
4765 #endif
4766
4767 #endif
4768
4769 #if (PERL_BCDVERSION < 0x5006000)
4770 # define D_PPP_CONSTPV_ARG(x)  ((char *) (x))
4771 #else
4772 # define D_PPP_CONSTPV_ARG(x)  (x)
4773 #endif
4774 #ifndef newSVpvn
4775 #  define newSVpvn(data,len)             ((data)                                              \
4776                                     ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
4777                                     : newSV(0))
4778 #endif
4779 #ifndef newSVpvn_utf8
4780 #  define newSVpvn_utf8(s, len, u)       newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
4781 #endif
4782 #ifndef SVf_UTF8
4783 #  define SVf_UTF8                       0
4784 #endif
4785
4786 #ifndef newSVpvn_flags
4787
4788 #if defined(NEED_newSVpvn_flags)
4789 static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
4790 static
4791 #else
4792 extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
4793 #endif
4794
4795 #ifdef newSVpvn_flags
4796 #  undef newSVpvn_flags
4797 #endif
4798 #define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
4799 #define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
4800
4801 #if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
4802
4803 SV *
4804 DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
4805 {
4806   SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len);
4807   SvFLAGS(sv) |= (flags & SVf_UTF8);
4808   return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
4809 }
4810
4811 #endif
4812
4813 #endif
4814
4815 /* Backwards compatibility stuff... :-( */
4816 #if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen)
4817 #  define NEED_sv_2pv_flags
4818 #endif
4819 #if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL)
4820 #  define NEED_sv_2pv_flags_GLOBAL
4821 #endif
4822
4823 /* Hint: sv_2pv_nolen
4824  * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
4825  */
4826 #ifndef sv_2pv_nolen
4827 #  define sv_2pv_nolen(sv)               SvPV_nolen(sv)
4828 #endif
4829
4830 #ifdef SvPVbyte
4831
4832 /* Hint: SvPVbyte
4833  * Does not work in perl-5.6.1, ppport.h implements a version
4834  * borrowed from perl-5.7.3.
4835  */
4836
4837 #if (PERL_BCDVERSION < 0x5007000)
4838
4839 #if defined(NEED_sv_2pvbyte)
4840 static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
4841 static
4842 #else
4843 extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
4844 #endif
4845
4846 #ifdef sv_2pvbyte
4847 #  undef sv_2pvbyte
4848 #endif
4849 #define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
4850 #define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)
4851
4852 #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
4853
4854 char *
4855 DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
4856 {
4857   sv_utf8_downgrade(sv,0);
4858   return SvPV(sv,*lp);
4859 }
4860
4861 #endif
4862
4863 /* Hint: sv_2pvbyte
4864  * Use the SvPVbyte() macro instead of sv_2pvbyte().
4865  */
4866
4867 #undef SvPVbyte
4868
4869 #define SvPVbyte(sv, lp)                                                \
4870         ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)                \
4871          ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
4872
4873 #endif
4874
4875 #else
4876
4877 #  define SvPVbyte          SvPV
4878 #  define sv_2pvbyte        sv_2pv
4879
4880 #endif
4881 #ifndef sv_2pvbyte_nolen
4882 #  define sv_2pvbyte_nolen(sv)           sv_2pv_nolen(sv)
4883 #endif
4884
4885 /* Hint: sv_pvn
4886  * Always use the SvPV() macro instead of sv_pvn().
4887  */
4888
4889 /* Hint: sv_pvn_force
4890  * Always use the SvPV_force() macro instead of sv_pvn_force().
4891  */
4892
4893 /* If these are undefined, they're not handled by the core anyway */
4894 #ifndef SV_IMMEDIATE_UNREF
4895 #  define SV_IMMEDIATE_UNREF             0
4896 #endif
4897
4898 #ifndef SV_GMAGIC
4899 #  define SV_GMAGIC                      0
4900 #endif
4901
4902 #ifndef SV_COW_DROP_PV
4903 #  define SV_COW_DROP_PV                 0
4904 #endif
4905
4906 #ifndef SV_UTF8_NO_ENCODING
4907 #  define SV_UTF8_NO_ENCODING            0
4908 #endif
4909
4910 #ifndef SV_NOSTEAL
4911 #  define SV_NOSTEAL                     0
4912 #endif
4913
4914 #ifndef SV_CONST_RETURN
4915 #  define SV_CONST_RETURN                0
4916 #endif
4917
4918 #ifndef SV_MUTABLE_RETURN
4919 #  define SV_MUTABLE_RETURN              0
4920 #endif
4921
4922 #ifndef SV_SMAGIC
4923 #  define SV_SMAGIC                      0
4924 #endif
4925
4926 #ifndef SV_HAS_TRAILING_NUL
4927 #  define SV_HAS_TRAILING_NUL            0
4928 #endif
4929
4930 #ifndef SV_COW_SHARED_HASH_KEYS
4931 #  define SV_COW_SHARED_HASH_KEYS        0
4932 #endif
4933
4934 #if (PERL_BCDVERSION < 0x5007002)
4935
4936 #if defined(NEED_sv_2pv_flags)
4937 static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
4938 static
4939 #else
4940 extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
4941 #endif
4942
4943 #ifdef sv_2pv_flags
4944 #  undef sv_2pv_flags
4945 #endif
4946 #define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
4947 #define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
4948
4949 #if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
4950
4951 char *
4952 DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
4953 {
4954   STRLEN n_a = (STRLEN) flags;
4955   return sv_2pv(sv, lp ? lp : &n_a);
4956 }
4957
4958 #endif
4959
4960 #if defined(NEED_sv_pvn_force_flags)
4961 static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
4962 static
4963 #else
4964 extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
4965 #endif
4966
4967 #ifdef sv_pvn_force_flags
4968 #  undef sv_pvn_force_flags
4969 #endif
4970 #define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
4971 #define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
4972
4973 #if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
4974
4975 char *
4976 DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
4977 {
4978   STRLEN n_a = (STRLEN) flags;
4979   return sv_pvn_force(sv, lp ? lp : &n_a);
4980 }
4981
4982 #endif
4983
4984 #endif
4985
4986 #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
4987 # define DPPP_SVPV_NOLEN_LP_ARG &PL_na
4988 #else
4989 # define DPPP_SVPV_NOLEN_LP_ARG 0
4990 #endif
4991 #ifndef SvPV_const
4992 #  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)
4993 #endif
4994
4995 #ifndef SvPV_mutable
4996 #  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)
4997 #endif
4998 #ifndef SvPV_flags
4999 #  define SvPV_flags(sv, lp, flags)      \
5000                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5001                   ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
5002 #endif
5003 #ifndef SvPV_flags_const
5004 #  define SvPV_flags_const(sv, lp, flags) \
5005                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5006                   ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
5007                   (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
5008 #endif
5009 #ifndef SvPV_flags_const_nolen
5010 #  define SvPV_flags_const_nolen(sv, flags) \
5011                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5012                   ? SvPVX_const(sv) : \
5013                   (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
5014 #endif
5015 #ifndef SvPV_flags_mutable
5016 #  define SvPV_flags_mutable(sv, lp, flags) \
5017                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5018                   ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
5019                   sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
5020 #endif
5021 #ifndef SvPV_force
5022 #  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)
5023 #endif
5024
5025 #ifndef SvPV_force_nolen
5026 #  define SvPV_force_nolen(sv)           SvPV_force_flags_nolen(sv, SV_GMAGIC)
5027 #endif
5028
5029 #ifndef SvPV_force_mutable
5030 #  define SvPV_force_mutable(sv, lp)     SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
5031 #endif
5032
5033 #ifndef SvPV_force_nomg
5034 #  define SvPV_force_nomg(sv, lp)        SvPV_force_flags(sv, lp, 0)
5035 #endif
5036
5037 #ifndef SvPV_force_nomg_nolen
5038 #  define SvPV_force_nomg_nolen(sv)      SvPV_force_flags_nolen(sv, 0)
5039 #endif
5040 #ifndef SvPV_force_flags
5041 #  define SvPV_force_flags(sv, lp, flags) \
5042                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
5043                  ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
5044 #endif
5045 #ifndef SvPV_force_flags_nolen
5046 #  define SvPV_force_flags_nolen(sv, flags) \
5047                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
5048                  ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
5049 #endif
5050 #ifndef SvPV_force_flags_mutable
5051 #  define SvPV_force_flags_mutable(sv, lp, flags) \
5052                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
5053                  ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
5054                   : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
5055 #endif
5056 #ifndef SvPV_nolen
5057 #  define SvPV_nolen(sv)                 \
5058                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5059                   ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
5060 #endif
5061 #ifndef SvPV_nolen_const
5062 #  define SvPV_nolen_const(sv)           \
5063                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5064                   ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
5065 #endif
5066 #ifndef SvPV_nomg
5067 #  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)
5068 #endif
5069
5070 #ifndef SvPV_nomg_const
5071 #  define SvPV_nomg_const(sv, lp)        SvPV_flags_const(sv, lp, 0)
5072 #endif
5073
5074 #ifndef SvPV_nomg_const_nolen
5075 #  define SvPV_nomg_const_nolen(sv)      SvPV_flags_const_nolen(sv, 0)
5076 #endif
5077 #ifndef SvPV_renew
5078 #  define SvPV_renew(sv,n)               STMT_START { SvLEN_set(sv, n); \
5079                  SvPV_set((sv), (char *) saferealloc(          \
5080                        (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
5081                } STMT_END
5082 #endif
5083 #ifndef SvMAGIC_set
5084 #  define SvMAGIC_set(sv, val)           \
5085                 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
5086                 (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
5087 #endif
5088
5089 #if (PERL_BCDVERSION < 0x5009003)
5090 #ifndef SvPVX_const
5091 #  define SvPVX_const(sv)                ((const char*) (0 + SvPVX(sv)))
5092 #endif
5093
5094 #ifndef SvPVX_mutable
5095 #  define SvPVX_mutable(sv)              (0 + SvPVX(sv))
5096 #endif
5097 #ifndef SvRV_set
5098 #  define SvRV_set(sv, val)              \
5099                 STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
5100                 (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
5101 #endif
5102
5103 #else
5104 #ifndef SvPVX_const
5105 #  define SvPVX_const(sv)                ((const char*)((sv)->sv_u.svu_pv))
5106 #endif
5107
5108 #ifndef SvPVX_mutable
5109 #  define SvPVX_mutable(sv)              ((sv)->sv_u.svu_pv)
5110 #endif
5111 #ifndef SvRV_set
5112 #  define SvRV_set(sv, val)              \
5113                 STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
5114                 ((sv)->sv_u.svu_rv = (val)); } STMT_END
5115 #endif
5116
5117 #endif
5118 #ifndef SvSTASH_set
5119 #  define SvSTASH_set(sv, val)           \
5120                 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
5121                 (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
5122 #endif
5123
5124 #if (PERL_BCDVERSION < 0x5004000)
5125 #ifndef SvUV_set
5126 #  define SvUV_set(sv, val)              \
5127                 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
5128                 (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
5129 #endif
5130
5131 #else
5132 #ifndef SvUV_set
5133 #  define SvUV_set(sv, val)              \
5134                 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
5135                 (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
5136 #endif
5137
5138 #endif
5139
5140 #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
5141 #if defined(NEED_vnewSVpvf)
5142 static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
5143 static
5144 #else
5145 extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
5146 #endif
5147
5148 #ifdef vnewSVpvf
5149 #  undef vnewSVpvf
5150 #endif
5151 #define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
5152 #define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
5153
5154 #if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
5155
5156 SV *
5157 DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
5158 {
5159   register SV *sv = newSV(0);
5160   sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
5161   return sv;
5162 }
5163
5164 #endif
5165 #endif
5166
5167 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
5168 #  define sv_vcatpvf(sv, pat, args)  sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
5169 #endif
5170
5171 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
5172 #  define sv_vsetpvf(sv, pat, args)  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
5173 #endif
5174
5175 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
5176 #if defined(NEED_sv_catpvf_mg)
5177 static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5178 static
5179 #else
5180 extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5181 #endif
5182
5183 #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
5184
5185 #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
5186
5187 void
5188 DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
5189 {
5190   va_list args;
5191   va_start(args, pat);
5192   sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5193   SvSETMAGIC(sv);
5194   va_end(args);
5195 }
5196
5197 #endif
5198 #endif
5199
5200 #ifdef PERL_IMPLICIT_CONTEXT
5201 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
5202 #if defined(NEED_sv_catpvf_mg_nocontext)
5203 static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5204 static
5205 #else
5206 extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5207 #endif
5208
5209 #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
5210 #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
5211
5212 #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
5213
5214 void
5215 DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
5216 {
5217   dTHX;
5218   va_list args;
5219   va_start(args, pat);
5220   sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5221   SvSETMAGIC(sv);
5222   va_end(args);
5223 }
5224
5225 #endif
5226 #endif
5227 #endif
5228
5229 /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
5230 #ifndef sv_catpvf_mg
5231 #  ifdef PERL_IMPLICIT_CONTEXT
5232 #    define sv_catpvf_mg   Perl_sv_catpvf_mg_nocontext
5233 #  else
5234 #    define sv_catpvf_mg   Perl_sv_catpvf_mg
5235 #  endif
5236 #endif
5237
5238 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
5239 #  define sv_vcatpvf_mg(sv, pat, args)                                     \
5240    STMT_START {                                                            \
5241      sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
5242      SvSETMAGIC(sv);                                                       \
5243    } STMT_END
5244 #endif
5245
5246 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
5247 #if defined(NEED_sv_setpvf_mg)
5248 static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5249 static
5250 #else
5251 extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5252 #endif
5253
5254 #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
5255
5256 #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
5257
5258 void
5259 DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
5260 {
5261   va_list args;
5262   va_start(args, pat);
5263   sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5264   SvSETMAGIC(sv);
5265   va_end(args);
5266 }
5267
5268 #endif
5269 #endif
5270
5271 #ifdef PERL_IMPLICIT_CONTEXT
5272 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
5273 #if defined(NEED_sv_setpvf_mg_nocontext)
5274 static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5275 static
5276 #else
5277 extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5278 #endif
5279
5280 #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
5281 #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
5282
5283 #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
5284
5285 void
5286 DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
5287 {
5288   dTHX;
5289   va_list args;
5290   va_start(args, pat);
5291   sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5292   SvSETMAGIC(sv);
5293   va_end(args);
5294 }
5295
5296 #endif
5297 #endif
5298 #endif
5299
5300 /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
5301 #ifndef sv_setpvf_mg
5302 #  ifdef PERL_IMPLICIT_CONTEXT
5303 #    define sv_setpvf_mg   Perl_sv_setpvf_mg_nocontext
5304 #  else
5305 #    define sv_setpvf_mg   Perl_sv_setpvf_mg
5306 #  endif
5307 #endif
5308
5309 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
5310 #  define sv_vsetpvf_mg(sv, pat, args)                                     \
5311    STMT_START {                                                            \
5312      sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
5313      SvSETMAGIC(sv);                                                       \
5314    } STMT_END
5315 #endif
5316
5317 #ifndef newSVpvn_share
5318
5319 #if defined(NEED_newSVpvn_share)
5320 static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
5321 static
5322 #else
5323 extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
5324 #endif
5325
5326 #ifdef newSVpvn_share
5327 #  undef newSVpvn_share
5328 #endif
5329 #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
5330 #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
5331
5332 #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
5333
5334 SV *
5335 DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
5336 {
5337   SV *sv;
5338   if (len < 0)
5339     len = -len;
5340   if (!hash)
5341     PERL_HASH(hash, (char*) src, len);
5342   sv = newSVpvn((char *) src, len);
5343   sv_upgrade(sv, SVt_PVIV);
5344   SvIVX(sv) = hash;
5345   SvREADONLY_on(sv);
5346   SvPOK_on(sv);
5347   return sv;
5348 }
5349
5350 #endif
5351
5352 #endif
5353 #ifndef SvSHARED_HASH
5354 #  define SvSHARED_HASH(sv)              (0 + SvUVX(sv))
5355 #endif
5356 #ifndef HvNAME_get
5357 #  define HvNAME_get(hv)                 HvNAME(hv)
5358 #endif
5359 #ifndef HvNAMELEN_get
5360 #  define HvNAMELEN_get(hv)              (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)
5361 #endif
5362 #ifndef GvSVn
5363 #  define GvSVn(gv)                      GvSV(gv)
5364 #endif
5365
5366 #ifndef isGV_with_GP
5367 #  define isGV_with_GP(gv)               isGV(gv)
5368 #endif
5369 #ifndef WARN_ALL
5370 #  define WARN_ALL                       0
5371 #endif
5372
5373 #ifndef WARN_CLOSURE
5374 #  define WARN_CLOSURE                   1
5375 #endif
5376
5377 #ifndef WARN_DEPRECATED
5378 #  define WARN_DEPRECATED                2
5379 #endif
5380
5381 #ifndef WARN_EXITING
5382 #  define WARN_EXITING                   3
5383 #endif
5384
5385 #ifndef WARN_GLOB
5386 #  define WARN_GLOB                      4
5387 #endif
5388
5389 #ifndef WARN_IO
5390 #  define WARN_IO                        5
5391 #endif
5392
5393 #ifndef WARN_CLOSED
5394 #  define WARN_CLOSED                    6
5395 #endif
5396
5397 #ifndef WARN_EXEC
5398 #  define WARN_EXEC                      7
5399 #endif
5400
5401 #ifndef WARN_LAYER
5402 #  define WARN_LAYER                     8
5403 #endif
5404
5405 #ifndef WARN_NEWLINE
5406 #  define WARN_NEWLINE                   9
5407 #endif
5408
5409 #ifndef WARN_PIPE
5410 #  define WARN_PIPE                      10
5411 #endif
5412
5413 #ifndef WARN_UNOPENED
5414 #  define WARN_UNOPENED                  11
5415 #endif
5416
5417 #ifndef WARN_MISC
5418 #  define WARN_MISC                      12
5419 #endif
5420
5421 #ifndef WARN_NUMERIC
5422 #  define WARN_NUMERIC                   13
5423 #endif
5424
5425 #ifndef WARN_ONCE
5426 #  define WARN_ONCE                      14
5427 #endif
5428
5429 #ifndef WARN_OVERFLOW
5430 #  define WARN_OVERFLOW                  15
5431 #endif
5432
5433 #ifndef WARN_PACK
5434 #  define WARN_PACK                      16
5435 #endif
5436
5437 #ifndef WARN_PORTABLE
5438 #  define WARN_PORTABLE                  17
5439 #endif
5440
5441 #ifndef WARN_RECURSION
5442 #  define WARN_RECURSION                 18
5443 #endif
5444
5445 #ifndef WARN_REDEFINE
5446 #  define WARN_REDEFINE                  19
5447 #endif
5448
5449 #ifndef WARN_REGEXP
5450 #  define WARN_REGEXP                    20
5451 #endif
5452
5453 #ifndef WARN_SEVERE
5454 #  define WARN_SEVERE                    21
5455 #endif
5456
5457 #ifndef WARN_DEBUGGING
5458 #  define WARN_DEBUGGING                 22
5459 #endif
5460
5461 #ifndef WARN_INPLACE
5462 #  define WARN_INPLACE                   23
5463 #endif
5464
5465 #ifndef WARN_INTERNAL
5466 #  define WARN_INTERNAL                  24
5467 #endif
5468
5469 #ifndef WARN_MALLOC
5470 #  define WARN_MALLOC                    25
5471 #endif
5472
5473 #ifndef WARN_SIGNAL
5474 #  define WARN_SIGNAL                    26
5475 #endif
5476
5477 #ifndef WARN_SUBSTR
5478 #  define WARN_SUBSTR                    27
5479 #endif
5480
5481 #ifndef WARN_SYNTAX
5482 #  define WARN_SYNTAX                    28
5483 #endif
5484
5485 #ifndef WARN_AMBIGUOUS
5486 #  define WARN_AMBIGUOUS                 29
5487 #endif
5488
5489 #ifndef WARN_BAREWORD
5490 #  define WARN_BAREWORD                  30
5491 #endif
5492
5493 #ifndef WARN_DIGIT
5494 #  define WARN_DIGIT                     31
5495 #endif
5496
5497 #ifndef WARN_PARENTHESIS
5498 #  define WARN_PARENTHESIS               32
5499 #endif
5500
5501 #ifndef WARN_PRECEDENCE
5502 #  define WARN_PRECEDENCE                33
5503 #endif
5504
5505 #ifndef WARN_PRINTF
5506 #  define WARN_PRINTF                    34
5507 #endif
5508
5509 #ifndef WARN_PROTOTYPE
5510 #  define WARN_PROTOTYPE                 35
5511 #endif
5512
5513 #ifndef WARN_QW
5514 #  define WARN_QW                        36
5515 #endif
5516
5517 #ifndef WARN_RESERVED
5518 #  define WARN_RESERVED                  37
5519 #endif
5520
5521 #ifndef WARN_SEMICOLON
5522 #  define WARN_SEMICOLON                 38
5523 #endif
5524
5525 #ifndef WARN_TAINT
5526 #  define WARN_TAINT                     39
5527 #endif
5528
5529 #ifndef WARN_THREADS
5530 #  define WARN_THREADS                   40
5531 #endif
5532
5533 #ifndef WARN_UNINITIALIZED
5534 #  define WARN_UNINITIALIZED             41
5535 #endif
5536
5537 #ifndef WARN_UNPACK
5538 #  define WARN_UNPACK                    42
5539 #endif
5540
5541 #ifndef WARN_UNTIE
5542 #  define WARN_UNTIE                     43
5543 #endif
5544
5545 #ifndef WARN_UTF8
5546 #  define WARN_UTF8                      44
5547 #endif
5548
5549 #ifndef WARN_VOID
5550 #  define WARN_VOID                      45
5551 #endif
5552
5553 #ifndef WARN_ASSERTIONS
5554 #  define WARN_ASSERTIONS                46
5555 #endif
5556 #ifndef packWARN
5557 #  define packWARN(a)                    (a)
5558 #endif
5559
5560 #ifndef ckWARN
5561 #  ifdef G_WARN_ON
5562 #    define  ckWARN(a)                  (PL_dowarn & G_WARN_ON)
5563 #  else
5564 #    define  ckWARN(a)                  PL_dowarn
5565 #  endif
5566 #endif
5567
5568 #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
5569 #if defined(NEED_warner)
5570 static void DPPP_(my_warner)(U32 err, const char *pat, ...);
5571 static
5572 #else
5573 extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
5574 #endif
5575
5576 #define Perl_warner DPPP_(my_warner)
5577
5578 #if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
5579
5580 void
5581 DPPP_(my_warner)(U32 err, const char *pat, ...)
5582 {
5583   SV *sv;
5584   va_list args;
5585
5586   PERL_UNUSED_ARG(err);
5587
5588   va_start(args, pat);
5589   sv = vnewSVpvf(pat, &args);
5590   va_end(args);
5591   sv_2mortal(sv);
5592   warn("%s", SvPV_nolen(sv));
5593 }
5594
5595 #define warner  Perl_warner
5596
5597 #define Perl_warner_nocontext  Perl_warner
5598
5599 #endif
5600 #endif
5601
5602 /* concatenating with "" ensures that only literal strings are accepted as argument
5603  * note that STR_WITH_LEN() can't be used as argument to macros or functions that
5604  * under some configurations might be macros
5605  */
5606 #ifndef STR_WITH_LEN
5607 #  define STR_WITH_LEN(s)                (s ""), (sizeof(s)-1)
5608 #endif
5609 #ifndef newSVpvs
5610 #  define newSVpvs(str)                  newSVpvn(str "", sizeof(str) - 1)
5611 #endif
5612
5613 #ifndef newSVpvs_flags
5614 #  define newSVpvs_flags(str, flags)     newSVpvn_flags(str "", sizeof(str) - 1, flags)
5615 #endif
5616
5617 #ifndef sv_catpvs
5618 #  define sv_catpvs(sv, str)             sv_catpvn(sv, str "", sizeof(str) - 1)
5619 #endif
5620
5621 #ifndef sv_setpvs
5622 #  define sv_setpvs(sv, str)             sv_setpvn(sv, str "", sizeof(str) - 1)
5623 #endif
5624
5625 #ifndef hv_fetchs
5626 #  define hv_fetchs(hv, key, lval)       hv_fetch(hv, key "", sizeof(key) - 1, lval)
5627 #endif
5628
5629 #ifndef hv_stores
5630 #  define hv_stores(hv, key, val)        hv_store(hv, key "", sizeof(key) - 1, val, 0)
5631 #endif
5632 #ifndef gv_fetchpvn_flags
5633 #  define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt)
5634 #endif
5635
5636 #ifndef gv_fetchpvs
5637 #  define gv_fetchpvs(name, flags, svt)  gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)
5638 #endif
5639
5640 #ifndef gv_stashpvs
5641 #  define gv_stashpvs(name, flags)       gv_stashpvn(name "", sizeof(name) - 1, flags)
5642 #endif
5643 #ifndef SvGETMAGIC
5644 #  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
5645 #endif
5646 #ifndef PERL_MAGIC_sv
5647 #  define PERL_MAGIC_sv                  '\0'
5648 #endif
5649
5650 #ifndef PERL_MAGIC_overload
5651 #  define PERL_MAGIC_overload            'A'
5652 #endif
5653
5654 #ifndef PERL_MAGIC_overload_elem
5655 #  define PERL_MAGIC_overload_elem       'a'
5656 #endif
5657
5658 #ifndef PERL_MAGIC_overload_table
5659 #  define PERL_MAGIC_overload_table      'c'
5660 #endif
5661
5662 #ifndef PERL_MAGIC_bm
5663 #  define PERL_MAGIC_bm                  'B'
5664 #endif
5665
5666 #ifndef PERL_MAGIC_regdata
5667 #  define PERL_MAGIC_regdata             'D'
5668 #endif
5669
5670 #ifndef PERL_MAGIC_regdatum
5671 #  define PERL_MAGIC_regdatum            'd'
5672 #endif
5673
5674 #ifndef PERL_MAGIC_env
5675 #  define PERL_MAGIC_env                 'E'
5676 #endif
5677
5678 #ifndef PERL_MAGIC_envelem
5679 #  define PERL_MAGIC_envelem             'e'
5680 #endif
5681
5682 #ifndef PERL_MAGIC_fm
5683 #  define PERL_MAGIC_fm                  'f'
5684 #endif
5685
5686 #ifndef PERL_MAGIC_regex_global
5687 #  define PERL_MAGIC_regex_global        'g'
5688 #endif
5689
5690 #ifndef PERL_MAGIC_isa
5691 #  define PERL_MAGIC_isa                 'I'
5692 #endif
5693
5694 #ifndef PERL_MAGIC_isaelem
5695 #  define PERL_MAGIC_isaelem             'i'
5696 #endif
5697
5698 #ifndef PERL_MAGIC_nkeys
5699 #  define PERL_MAGIC_nkeys               'k'
5700 #endif
5701
5702 #ifndef PERL_MAGIC_dbfile
5703 #  define PERL_MAGIC_dbfile              'L'
5704 #endif
5705
5706 #ifndef PERL_MAGIC_dbline
5707 #  define PERL_MAGIC_dbline              'l'
5708 #endif
5709
5710 #ifndef PERL_MAGIC_mutex
5711 #  define PERL_MAGIC_mutex               'm'
5712 #endif
5713
5714 #ifndef PERL_MAGIC_shared
5715 #  define PERL_MAGIC_shared              'N'
5716 #endif
5717
5718 #ifndef PERL_MAGIC_shared_scalar
5719 #  define PERL_MAGIC_shared_scalar       'n'
5720 #endif
5721
5722 #ifndef PERL_MAGIC_collxfrm
5723 #  define PERL_MAGIC_collxfrm            'o'
5724 #endif
5725
5726 #ifndef PERL_MAGIC_tied
5727 #  define PERL_MAGIC_tied                'P'
5728 #endif
5729
5730 #ifndef PERL_MAGIC_tiedelem
5731 #  define PERL_MAGIC_tiedelem            'p'
5732 #endif
5733
5734 #ifndef PERL_MAGIC_tiedscalar
5735 #  define PERL_MAGIC_tiedscalar          'q'
5736 #endif
5737
5738 #ifndef PERL_MAGIC_qr
5739 #  define PERL_MAGIC_qr                  'r'
5740 #endif
5741
5742 #ifndef PERL_MAGIC_sig
5743 #  define PERL_MAGIC_sig                 'S'
5744 #endif
5745
5746 #ifndef PERL_MAGIC_sigelem
5747 #  define PERL_MAGIC_sigelem             's'
5748 #endif
5749
5750 #ifndef PERL_MAGIC_taint
5751 #  define PERL_MAGIC_taint               't'
5752 #endif
5753
5754 #ifndef PERL_MAGIC_uvar
5755 #  define PERL_MAGIC_uvar                'U'
5756 #endif
5757
5758 #ifndef PERL_MAGIC_uvar_elem
5759 #  define PERL_MAGIC_uvar_elem           'u'
5760 #endif
5761
5762 #ifndef PERL_MAGIC_vstring
5763 #  define PERL_MAGIC_vstring             'V'
5764 #endif
5765
5766 #ifndef PERL_MAGIC_vec
5767 #  define PERL_MAGIC_vec                 'v'
5768 #endif
5769
5770 #ifndef PERL_MAGIC_utf8
5771 #  define PERL_MAGIC_utf8                'w'
5772 #endif
5773
5774 #ifndef PERL_MAGIC_substr
5775 #  define PERL_MAGIC_substr              'x'
5776 #endif
5777
5778 #ifndef PERL_MAGIC_defelem
5779 #  define PERL_MAGIC_defelem             'y'
5780 #endif
5781
5782 #ifndef PERL_MAGIC_glob
5783 #  define PERL_MAGIC_glob                '*'
5784 #endif
5785
5786 #ifndef PERL_MAGIC_arylen
5787 #  define PERL_MAGIC_arylen              '#'
5788 #endif
5789
5790 #ifndef PERL_MAGIC_pos
5791 #  define PERL_MAGIC_pos                 '.'
5792 #endif
5793
5794 #ifndef PERL_MAGIC_backref
5795 #  define PERL_MAGIC_backref             '<'
5796 #endif
5797
5798 #ifndef PERL_MAGIC_ext
5799 #  define PERL_MAGIC_ext                 '~'
5800 #endif
5801
5802 /* That's the best we can do... */
5803 #ifndef sv_catpvn_nomg
5804 #  define sv_catpvn_nomg                 sv_catpvn
5805 #endif
5806
5807 #ifndef sv_catsv_nomg
5808 #  define sv_catsv_nomg                  sv_catsv
5809 #endif
5810
5811 #ifndef sv_setsv_nomg
5812 #  define sv_setsv_nomg                  sv_setsv
5813 #endif
5814
5815 #ifndef sv_pvn_nomg
5816 #  define sv_pvn_nomg                    sv_pvn
5817 #endif
5818
5819 #ifndef SvIV_nomg
5820 #  define SvIV_nomg                      SvIV
5821 #endif
5822
5823 #ifndef SvUV_nomg
5824 #  define SvUV_nomg                      SvUV
5825 #endif
5826
5827 #ifndef sv_catpv_mg
5828 #  define sv_catpv_mg(sv, ptr)          \
5829    STMT_START {                         \
5830      SV *TeMpSv = sv;                   \
5831      sv_catpv(TeMpSv,ptr);              \
5832      SvSETMAGIC(TeMpSv);                \
5833    } STMT_END
5834 #endif
5835
5836 #ifndef sv_catpvn_mg
5837 #  define sv_catpvn_mg(sv, ptr, len)    \
5838    STMT_START {                         \
5839      SV *TeMpSv = sv;                   \
5840      sv_catpvn(TeMpSv,ptr,len);         \
5841      SvSETMAGIC(TeMpSv);                \
5842    } STMT_END
5843 #endif
5844
5845 #ifndef sv_catsv_mg
5846 #  define sv_catsv_mg(dsv, ssv)         \
5847    STMT_START {                         \
5848      SV *TeMpSv = dsv;                  \
5849      sv_catsv(TeMpSv,ssv);              \
5850      SvSETMAGIC(TeMpSv);                \
5851    } STMT_END
5852 #endif
5853
5854 #ifndef sv_setiv_mg
5855 #  define sv_setiv_mg(sv, i)            \
5856    STMT_START {                         \
5857      SV *TeMpSv = sv;                   \
5858      sv_setiv(TeMpSv,i);                \
5859      SvSETMAGIC(TeMpSv);                \
5860    } STMT_END
5861 #endif
5862
5863 #ifndef sv_setnv_mg
5864 #  define sv_setnv_mg(sv, num)          \
5865    STMT_START {                         \
5866      SV *TeMpSv = sv;                   \
5867      sv_setnv(TeMpSv,num);              \
5868      SvSETMAGIC(TeMpSv);                \
5869    } STMT_END
5870 #endif
5871
5872 #ifndef sv_setpv_mg
5873 #  define sv_setpv_mg(sv, ptr)          \
5874    STMT_START {                         \
5875      SV *TeMpSv = sv;                   \
5876      sv_setpv(TeMpSv,ptr);              \
5877      SvSETMAGIC(TeMpSv);                \
5878    } STMT_END
5879 #endif
5880
5881 #ifndef sv_setpvn_mg
5882 #  define sv_setpvn_mg(sv, ptr, len)    \
5883    STMT_START {                         \
5884      SV *TeMpSv = sv;                   \
5885      sv_setpvn(TeMpSv,ptr,len);         \
5886      SvSETMAGIC(TeMpSv);                \
5887    } STMT_END
5888 #endif
5889
5890 #ifndef sv_setsv_mg
5891 #  define sv_setsv_mg(dsv, ssv)         \
5892    STMT_START {                         \
5893      SV *TeMpSv = dsv;                  \
5894      sv_setsv(TeMpSv,ssv);              \
5895      SvSETMAGIC(TeMpSv);                \
5896    } STMT_END
5897 #endif
5898
5899 #ifndef sv_setuv_mg
5900 #  define sv_setuv_mg(sv, i)            \
5901    STMT_START {                         \
5902      SV *TeMpSv = sv;                   \
5903      sv_setuv(TeMpSv,i);                \
5904      SvSETMAGIC(TeMpSv);                \
5905    } STMT_END
5906 #endif
5907
5908 #ifndef sv_usepvn_mg
5909 #  define sv_usepvn_mg(sv, ptr, len)    \
5910    STMT_START {                         \
5911      SV *TeMpSv = sv;                   \
5912      sv_usepvn(TeMpSv,ptr,len);         \
5913      SvSETMAGIC(TeMpSv);                \
5914    } STMT_END
5915 #endif
5916 #ifndef SvVSTRING_mg
5917 #  define SvVSTRING_mg(sv)               (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
5918 #endif
5919
5920 /* Hint: sv_magic_portable
5921  * This is a compatibility function that is only available with
5922  * Devel::PPPort. It is NOT in the perl core.
5923  * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
5924  * it is being passed a name pointer with namlen == 0. In that
5925  * case, perl 5.8.0 and later store the pointer, not a copy of it.
5926  * The compatibility can be provided back to perl 5.004. With
5927  * earlier versions, the code will not compile.
5928  */
5929
5930 #if (PERL_BCDVERSION < 0x5004000)
5931
5932   /* code that uses sv_magic_portable will not compile */
5933
5934 #elif (PERL_BCDVERSION < 0x5008000)
5935
5936 #  define sv_magic_portable(sv, obj, how, name, namlen)     \
5937    STMT_START {                                             \
5938      SV *SvMp_sv = (sv);                                    \
5939      char *SvMp_name = (char *) (name);                     \
5940      I32 SvMp_namlen = (namlen);                            \
5941      if (SvMp_name && SvMp_namlen == 0)                     \
5942      {                                                      \
5943        MAGIC *mg;                                           \
5944        sv_magic(SvMp_sv, obj, how, 0, 0);                   \
5945        mg = SvMAGIC(SvMp_sv);                               \
5946        mg->mg_len = -42; /* XXX: this is the tricky part */ \
5947        mg->mg_ptr = SvMp_name;                              \
5948      }                                                      \
5949      else                                                   \
5950      {                                                      \
5951        sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
5952      }                                                      \
5953    } STMT_END
5954
5955 #else
5956
5957 #  define sv_magic_portable(a, b, c, d, e)  sv_magic(a, b, c, d, e)
5958
5959 #endif
5960
5961 #ifdef USE_ITHREADS
5962 #ifndef CopFILE
5963 #  define CopFILE(c)                     ((c)->cop_file)
5964 #endif
5965
5966 #ifndef CopFILEGV
5967 #  define CopFILEGV(c)                   (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)
5968 #endif
5969
5970 #ifndef CopFILE_set
5971 #  define CopFILE_set(c,pv)              ((c)->cop_file = savepv(pv))
5972 #endif
5973
5974 #ifndef CopFILESV
5975 #  define CopFILESV(c)                   (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
5976 #endif
5977
5978 #ifndef CopFILEAV
5979 #  define CopFILEAV(c)                   (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
5980 #endif
5981
5982 #ifndef CopSTASHPV
5983 #  define CopSTASHPV(c)                  ((c)->cop_stashpv)
5984 #endif
5985
5986 #ifndef CopSTASHPV_set
5987 #  define CopSTASHPV_set(c,pv)           ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))
5988 #endif
5989
5990 #ifndef CopSTASH
5991 #  define CopSTASH(c)                    (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
5992 #endif
5993
5994 #ifndef CopSTASH_set
5995 #  define CopSTASH_set(c,hv)             CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)
5996 #endif
5997
5998 #ifndef CopSTASH_eq
5999 #  define CopSTASH_eq(c,hv)              ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
6000                                         || (CopSTASHPV(c) && HvNAME(hv) \
6001                                         && strEQ(CopSTASHPV(c), HvNAME(hv)))))
6002 #endif
6003
6004 #else
6005 #ifndef CopFILEGV
6006 #  define CopFILEGV(c)                   ((c)->cop_filegv)
6007 #endif
6008
6009 #ifndef CopFILEGV_set
6010 #  define CopFILEGV_set(c,gv)            ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))
6011 #endif
6012
6013 #ifndef CopFILE_set
6014 #  define CopFILE_set(c,pv)              CopFILEGV_set((c), gv_fetchfile(pv))
6015 #endif
6016
6017 #ifndef CopFILESV
6018 #  define CopFILESV(c)                   (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
6019 #endif
6020
6021 #ifndef CopFILEAV
6022 #  define CopFILEAV(c)                   (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)
6023 #endif
6024
6025 #ifndef CopFILE
6026 #  define CopFILE(c)                     (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)
6027 #endif
6028
6029 #ifndef CopSTASH
6030 #  define CopSTASH(c)                    ((c)->cop_stash)
6031 #endif
6032
6033 #ifndef CopSTASH_set
6034 #  define CopSTASH_set(c,hv)             ((c)->cop_stash = (hv))
6035 #endif
6036
6037 #ifndef CopSTASHPV
6038 #  define CopSTASHPV(c)                  (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)
6039 #endif
6040
6041 #ifndef CopSTASHPV_set
6042 #  define CopSTASHPV_set(c,pv)           CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
6043 #endif
6044
6045 #ifndef CopSTASH_eq
6046 #  define CopSTASH_eq(c,hv)              (CopSTASH(c) == (hv))
6047 #endif
6048
6049 #endif /* USE_ITHREADS */
6050 #ifndef IN_PERL_COMPILETIME
6051 #  define IN_PERL_COMPILETIME            (PL_curcop == &PL_compiling)
6052 #endif
6053
6054 #ifndef IN_LOCALE_RUNTIME
6055 #  define IN_LOCALE_RUNTIME              (PL_curcop->op_private & HINT_LOCALE)
6056 #endif
6057
6058 #ifndef IN_LOCALE_COMPILETIME
6059 #  define IN_LOCALE_COMPILETIME          (PL_hints & HINT_LOCALE)
6060 #endif
6061
6062 #ifndef IN_LOCALE
6063 #  define IN_LOCALE                      (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)
6064 #endif
6065 #ifndef IS_NUMBER_IN_UV
6066 #  define IS_NUMBER_IN_UV                0x01
6067 #endif
6068
6069 #ifndef IS_NUMBER_GREATER_THAN_UV_MAX
6070 #  define IS_NUMBER_GREATER_THAN_UV_MAX  0x02
6071 #endif
6072
6073 #ifndef IS_NUMBER_NOT_INT
6074 #  define IS_NUMBER_NOT_INT              0x04
6075 #endif
6076
6077 #ifndef IS_NUMBER_NEG
6078 #  define IS_NUMBER_NEG                  0x08
6079 #endif
6080
6081 #ifndef IS_NUMBER_INFINITY
6082 #  define IS_NUMBER_INFINITY             0x10
6083 #endif
6084
6085 #ifndef IS_NUMBER_NAN
6086 #  define IS_NUMBER_NAN                  0x20
6087 #endif
6088 #ifndef GROK_NUMERIC_RADIX
6089 #  define GROK_NUMERIC_RADIX(sp, send)   grok_numeric_radix(sp, send)
6090 #endif
6091 #ifndef PERL_SCAN_GREATER_THAN_UV_MAX
6092 #  define PERL_SCAN_GREATER_THAN_UV_MAX  0x02
6093 #endif
6094
6095 #ifndef PERL_SCAN_SILENT_ILLDIGIT
6096 #  define PERL_SCAN_SILENT_ILLDIGIT      0x04
6097 #endif
6098
6099 #ifndef PERL_SCAN_ALLOW_UNDERSCORES
6100 #  define PERL_SCAN_ALLOW_UNDERSCORES    0x01
6101 #endif
6102
6103 #ifndef PERL_SCAN_DISALLOW_PREFIX
6104 #  define PERL_SCAN_DISALLOW_PREFIX      0x02
6105 #endif
6106
6107 #ifndef grok_numeric_radix
6108 #if defined(NEED_grok_numeric_radix)
6109 static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
6110 static
6111 #else
6112 extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
6113 #endif
6114
6115 #ifdef grok_numeric_radix
6116 #  undef grok_numeric_radix
6117 #endif
6118 #define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
6119 #define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)
6120
6121 #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
6122 bool
6123 DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
6124 {
6125 #ifdef USE_LOCALE_NUMERIC
6126 #ifdef PL_numeric_radix_sv
6127     if (PL_numeric_radix_sv && IN_LOCALE) {
6128         STRLEN len;
6129         char* radix = SvPV(PL_numeric_radix_sv, len);
6130         if (*sp + len <= send && memEQ(*sp, radix, len)) {
6131             *sp += len;
6132             return TRUE;
6133         }
6134     }
6135 #else
6136     /* older perls don't have PL_numeric_radix_sv so the radix
6137      * must manually be requested from locale.h
6138      */
6139 #include <locale.h>
6140     dTHR;  /* needed for older threaded perls */
6141     struct lconv *lc = localeconv();
6142     char *radix = lc->decimal_point;
6143     if (radix && IN_LOCALE) {
6144         STRLEN len = strlen(radix);
6145         if (*sp + len <= send && memEQ(*sp, radix, len)) {
6146             *sp += len;
6147             return TRUE;
6148         }
6149     }
6150 #endif
6151 #endif /* USE_LOCALE_NUMERIC */
6152     /* always try "." if numeric radix didn't match because
6153      * we may have data from different locales mixed */
6154     if (*sp < send && **sp == '.') {
6155         ++*sp;
6156         return TRUE;
6157     }
6158     return FALSE;
6159 }
6160 #endif
6161 #endif
6162
6163 #ifndef grok_number
6164 #if defined(NEED_grok_number)
6165 static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
6166 static
6167 #else
6168 extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
6169 #endif
6170
6171 #ifdef grok_number
6172 #  undef grok_number
6173 #endif
6174 #define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
6175 #define Perl_grok_number DPPP_(my_grok_number)
6176
6177 #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
6178 int
6179 DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
6180 {
6181   const char *s = pv;
6182   const char *send = pv + len;
6183   const UV max_div_10 = UV_MAX / 10;
6184   const char max_mod_10 = UV_MAX % 10;
6185   int numtype = 0;
6186   int sawinf = 0;
6187   int sawnan = 0;
6188
6189   while (s < send && isSPACE(*s))
6190     s++;
6191   if (s == send) {
6192     return 0;
6193   } else if (*s == '-') {
6194     s++;
6195     numtype = IS_NUMBER_NEG;
6196   }
6197   else if (*s == '+')
6198   s++;
6199
6200   if (s == send)
6201     return 0;
6202
6203   /* next must be digit or the radix separator or beginning of infinity */
6204   if (isDIGIT(*s)) {
6205     /* UVs are at least 32 bits, so the first 9 decimal digits cannot
6206        overflow.  */
6207     UV value = *s - '0';
6208     /* This construction seems to be more optimiser friendly.
6209        (without it gcc does the isDIGIT test and the *s - '0' separately)
6210        With it gcc on arm is managing 6 instructions (6 cycles) per digit.
6211        In theory the optimiser could deduce how far to unroll the loop
6212        before checking for overflow.  */
6213     if (++s < send) {
6214       int digit = *s - '0';
6215       if (digit >= 0 && digit <= 9) {
6216         value = value * 10 + digit;
6217         if (++s < send) {
6218           digit = *s - '0';
6219           if (digit >= 0 && digit <= 9) {
6220             value = value * 10 + digit;
6221             if (++s < send) {
6222               digit = *s - '0';
6223               if (digit >= 0 && digit <= 9) {
6224                 value = value * 10 + digit;
6225                 if (++s < send) {
6226                   digit = *s - '0';
6227                   if (digit >= 0 && digit <= 9) {
6228                     value = value * 10 + digit;
6229                     if (++s < send) {
6230                       digit = *s - '0';
6231                       if (digit >= 0 && digit <= 9) {
6232                         value = value * 10 + digit;
6233                         if (++s < send) {
6234                           digit = *s - '0';
6235                           if (digit >= 0 && digit <= 9) {
6236                             value = value * 10 + digit;
6237                             if (++s < send) {
6238                               digit = *s - '0';
6239                               if (digit >= 0 && digit <= 9) {
6240                                 value = value * 10 + digit;
6241                                 if (++s < send) {
6242                                   digit = *s - '0';
6243                                   if (digit >= 0 && digit <= 9) {
6244                                     value = value * 10 + digit;
6245                                     if (++s < send) {
6246                                       /* Now got 9 digits, so need to check
6247                                          each time for overflow.  */
6248                                       digit = *s - '0';
6249                                       while (digit >= 0 && digit <= 9
6250                                              && (value < max_div_10
6251                                                  || (value == max_div_10
6252                                                      && digit <= max_mod_10))) {
6253                                         value = value * 10 + digit;
6254                                         if (++s < send)
6255                                           digit = *s - '0';
6256                                         else
6257                                           break;
6258                                       }
6259                                       if (digit >= 0 && digit <= 9
6260                                           && (s < send)) {
6261                                         /* value overflowed.
6262                                            skip the remaining digits, don't
6263                                            worry about setting *valuep.  */
6264                                         do {
6265                                           s++;
6266                                         } while (s < send && isDIGIT(*s));
6267                                         numtype |=
6268                                           IS_NUMBER_GREATER_THAN_UV_MAX;
6269                                         goto skip_value;
6270                                       }
6271                                     }
6272                                   }
6273                                 }
6274                               }
6275                             }
6276                           }
6277                         }
6278                       }
6279                     }
6280                   }
6281                 }
6282               }
6283             }
6284           }
6285         }
6286       }
6287     }
6288     numtype |= IS_NUMBER_IN_UV;
6289     if (valuep)
6290       *valuep = value;
6291
6292   skip_value:
6293     if (GROK_NUMERIC_RADIX(&s, send)) {
6294       numtype |= IS_NUMBER_NOT_INT;
6295       while (s < send && isDIGIT(*s))  /* optional digits after the radix */
6296         s++;
6297     }
6298   }
6299   else if (GROK_NUMERIC_RADIX(&s, send)) {
6300     numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */
6301     /* no digits before the radix means we need digits after it */
6302     if (s < send && isDIGIT(*s)) {
6303       do {
6304         s++;
6305       } while (s < send && isDIGIT(*s));
6306       if (valuep) {
6307         /* integer approximation is valid - it's 0.  */
6308         *valuep = 0;
6309       }
6310     }
6311     else
6312       return 0;
6313   } else if (*s == 'I' || *s == 'i') {
6314     s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
6315     s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
6316     s++; if (s < send && (*s == 'I' || *s == 'i')) {
6317       s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
6318       s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
6319       s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
6320       s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
6321       s++;
6322     }
6323     sawinf = 1;
6324   } else if (*s == 'N' || *s == 'n') {
6325     /* XXX TODO: There are signaling NaNs and quiet NaNs. */
6326     s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
6327     s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
6328     s++;
6329     sawnan = 1;
6330   } else
6331     return 0;
6332
6333   if (sawinf) {
6334     numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
6335     numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;
6336   } else if (sawnan) {
6337     numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
6338     numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;
6339   } else if (s < send) {
6340     /* we can have an optional exponent part */
6341     if (*s == 'e' || *s == 'E') {
6342       /* The only flag we keep is sign.  Blow away any "it's UV"  */
6343       numtype &= IS_NUMBER_NEG;
6344       numtype |= IS_NUMBER_NOT_INT;
6345       s++;
6346       if (s < send && (*s == '-' || *s == '+'))
6347         s++;
6348       if (s < send && isDIGIT(*s)) {
6349         do {
6350           s++;
6351         } while (s < send && isDIGIT(*s));
6352       }
6353       else
6354       return 0;
6355     }
6356   }
6357   while (s < send && isSPACE(*s))
6358     s++;
6359   if (s >= send)
6360     return numtype;
6361   if (len == 10 && memEQ(pv, "0 but true", 10)) {
6362     if (valuep)
6363       *valuep = 0;
6364     return IS_NUMBER_IN_UV;
6365   }
6366   return 0;
6367 }
6368 #endif
6369 #endif
6370
6371 /*
6372  * The grok_* routines have been modified to use warn() instead of
6373  * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit,
6374  * which is why the stack variable has been renamed to 'xdigit'.
6375  */
6376
6377 #ifndef grok_bin
6378 #if defined(NEED_grok_bin)
6379 static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6380 static
6381 #else
6382 extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6383 #endif
6384
6385 #ifdef grok_bin
6386 #  undef grok_bin
6387 #endif
6388 #define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
6389 #define Perl_grok_bin DPPP_(my_grok_bin)
6390
6391 #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
6392 UV
6393 DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6394 {
6395     const char *s = start;
6396     STRLEN len = *len_p;
6397     UV value = 0;
6398     NV value_nv = 0;
6399
6400     const UV max_div_2 = UV_MAX / 2;
6401     bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
6402     bool overflowed = FALSE;
6403
6404     if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
6405         /* strip off leading b or 0b.
6406            for compatibility silently suffer "b" and "0b" as valid binary
6407            numbers. */
6408         if (len >= 1) {
6409             if (s[0] == 'b') {
6410                 s++;
6411                 len--;
6412             }
6413             else if (len >= 2 && s[0] == '0' && s[1] == 'b') {
6414                 s+=2;
6415                 len-=2;
6416             }
6417         }
6418     }
6419
6420     for (; len-- && *s; s++) {
6421         char bit = *s;
6422         if (bit == '0' || bit == '1') {
6423             /* Write it in this wonky order with a goto to attempt to get the
6424                compiler to make the common case integer-only loop pretty tight.
6425                With gcc seems to be much straighter code than old scan_bin.  */
6426           redo:
6427             if (!overflowed) {
6428                 if (value <= max_div_2) {
6429                     value = (value << 1) | (bit - '0');
6430                     continue;
6431                 }
6432                 /* Bah. We're just overflowed.  */
6433                 warn("Integer overflow in binary number");
6434                 overflowed = TRUE;
6435                 value_nv = (NV) value;
6436             }
6437             value_nv *= 2.0;
6438             /* If an NV has not enough bits in its mantissa to
6439              * represent a UV this summing of small low-order numbers
6440              * is a waste of time (because the NV cannot preserve
6441              * the low-order bits anyway): we could just remember when
6442              * did we overflow and in the end just multiply value_nv by the
6443              * right amount. */
6444             value_nv += (NV)(bit - '0');
6445             continue;
6446         }
6447         if (bit == '_' && len && allow_underscores && (bit = s[1])
6448             && (bit == '0' || bit == '1'))
6449             {
6450                 --len;
6451                 ++s;
6452                 goto redo;
6453             }
6454         if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
6455             warn("Illegal binary digit '%c' ignored", *s);
6456         break;
6457     }
6458
6459     if (   ( overflowed && value_nv > 4294967295.0)
6460 #if UVSIZE > 4
6461         || (!overflowed && value > 0xffffffff  )
6462 #endif
6463         ) {
6464         warn("Binary number > 0b11111111111111111111111111111111 non-portable");
6465     }
6466     *len_p = s - start;
6467     if (!overflowed) {
6468         *flags = 0;
6469         return value;
6470     }
6471     *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
6472     if (result)
6473         *result = value_nv;
6474     return UV_MAX;
6475 }
6476 #endif
6477 #endif
6478
6479 #ifndef grok_hex
6480 #if defined(NEED_grok_hex)
6481 static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6482 static
6483 #else
6484 extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6485 #endif
6486
6487 #ifdef grok_hex
6488 #  undef grok_hex
6489 #endif
6490 #define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
6491 #define Perl_grok_hex DPPP_(my_grok_hex)
6492
6493 #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
6494 UV
6495 DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6496 {
6497     const char *s = start;
6498     STRLEN len = *len_p;
6499     UV value = 0;
6500     NV value_nv = 0;
6501
6502     const UV max_div_16 = UV_MAX / 16;
6503     bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
6504     bool overflowed = FALSE;
6505     const char *xdigit;
6506
6507     if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
6508         /* strip off leading x or 0x.
6509            for compatibility silently suffer "x" and "0x" as valid hex numbers.
6510         */
6511         if (len >= 1) {
6512             if (s[0] == 'x') {
6513                 s++;
6514                 len--;
6515             }
6516             else if (len >= 2 && s[0] == '0' && s[1] == 'x') {
6517                 s+=2;
6518                 len-=2;
6519             }
6520         }
6521     }
6522
6523     for (; len-- && *s; s++) {
6524         xdigit = strchr((char *) PL_hexdigit, *s);
6525         if (xdigit) {
6526             /* Write it in this wonky order with a goto to attempt to get the
6527                compiler to make the common case integer-only loop pretty tight.
6528                With gcc seems to be much straighter code than old scan_hex.  */
6529           redo:
6530             if (!overflowed) {
6531                 if (value <= max_div_16) {
6532                     value = (value << 4) | ((xdigit - PL_hexdigit) & 15);
6533                     continue;
6534                 }
6535                 warn("Integer overflow in hexadecimal number");
6536                 overflowed = TRUE;
6537                 value_nv = (NV) value;
6538             }
6539             value_nv *= 16.0;
6540             /* If an NV has not enough bits in its mantissa to
6541              * represent a UV this summing of small low-order numbers
6542              * is a waste of time (because the NV cannot preserve
6543              * the low-order bits anyway): we could just remember when
6544              * did we overflow and in the end just multiply value_nv by the
6545              * right amount of 16-tuples. */
6546             value_nv += (NV)((xdigit - PL_hexdigit) & 15);
6547             continue;
6548         }
6549         if (*s == '_' && len && allow_underscores && s[1]
6550                 && (xdigit = strchr((char *) PL_hexdigit, s[1])))
6551             {
6552                 --len;
6553                 ++s;
6554                 goto redo;
6555             }
6556         if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
6557             warn("Illegal hexadecimal digit '%c' ignored", *s);
6558         break;
6559     }
6560
6561     if (   ( overflowed && value_nv > 4294967295.0)
6562 #if UVSIZE > 4
6563         || (!overflowed && value > 0xffffffff  )
6564 #endif
6565         ) {
6566         warn("Hexadecimal number > 0xffffffff non-portable");
6567     }
6568     *len_p = s - start;
6569     if (!overflowed) {
6570         *flags = 0;
6571         return value;
6572     }
6573     *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
6574     if (result)
6575         *result = value_nv;
6576     return UV_MAX;
6577 }
6578 #endif
6579 #endif
6580
6581 #ifndef grok_oct
6582 #if defined(NEED_grok_oct)
6583 static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6584 static
6585 #else
6586 extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6587 #endif
6588
6589 #ifdef grok_oct
6590 #  undef grok_oct
6591 #endif
6592 #define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
6593 #define Perl_grok_oct DPPP_(my_grok_oct)
6594
6595 #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
6596 UV
6597 DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6598 {
6599     const char *s = start;
6600     STRLEN len = *len_p;
6601     UV value = 0;
6602     NV value_nv = 0;
6603
6604     const UV max_div_8 = UV_MAX / 8;
6605     bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
6606     bool overflowed = FALSE;
6607
6608     for (; len-- && *s; s++) {
6609          /* gcc 2.95 optimiser not smart enough to figure that this subtraction
6610             out front allows slicker code.  */
6611         int digit = *s - '0';
6612         if (digit >= 0 && digit <= 7) {
6613             /* Write it in this wonky order with a goto to attempt to get the
6614                compiler to make the common case integer-only loop pretty tight.
6615             */
6616           redo:
6617             if (!overflowed) {
6618                 if (value <= max_div_8) {
6619                     value = (value << 3) | digit;
6620                     continue;
6621                 }
6622                 /* Bah. We're just overflowed.  */
6623                 warn("Integer overflow in octal number");
6624                 overflowed = TRUE;
6625                 value_nv = (NV) value;
6626             }
6627             value_nv *= 8.0;
6628             /* If an NV has not enough bits in its mantissa to
6629              * represent a UV this summing of small low-order numbers
6630              * is a waste of time (because the NV cannot preserve
6631              * the low-order bits anyway): we could just remember when
6632              * did we overflow and in the end just multiply value_nv by the
6633              * right amount of 8-tuples. */
6634             value_nv += (NV)digit;
6635             continue;
6636         }
6637         if (digit == ('_' - '0') && len && allow_underscores
6638             && (digit = s[1] - '0') && (digit >= 0 && digit <= 7))
6639             {
6640                 --len;
6641                 ++s;
6642                 goto redo;
6643             }
6644         /* Allow \octal to work the DWIM way (that is, stop scanning
6645          * as soon as non-octal characters are seen, complain only iff
6646          * someone seems to want to use the digits eight and nine). */
6647         if (digit == 8 || digit == 9) {
6648             if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
6649                 warn("Illegal octal digit '%c' ignored", *s);
6650         }
6651         break;
6652     }
6653
6654     if (   ( overflowed && value_nv > 4294967295.0)
6655 #if UVSIZE > 4
6656         || (!overflowed && value > 0xffffffff  )
6657 #endif
6658         ) {
6659         warn("Octal number > 037777777777 non-portable");
6660     }
6661     *len_p = s - start;
6662     if (!overflowed) {
6663         *flags = 0;
6664         return value;
6665     }
6666     *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
6667     if (result)
6668         *result = value_nv;
6669     return UV_MAX;
6670 }
6671 #endif
6672 #endif
6673
6674 #if !defined(my_snprintf)
6675 #if defined(NEED_my_snprintf)
6676 static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
6677 static
6678 #else
6679 extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
6680 #endif
6681
6682 #define my_snprintf DPPP_(my_my_snprintf)
6683 #define Perl_my_snprintf DPPP_(my_my_snprintf)
6684
6685 #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
6686
6687 int
6688 DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
6689 {
6690     dTHX;
6691     int retval;
6692     va_list ap;
6693     va_start(ap, format);
6694 #ifdef HAS_VSNPRINTF
6695     retval = vsnprintf(buffer, len, format, ap);
6696 #else
6697     retval = vsprintf(buffer, format, ap);
6698 #endif
6699     va_end(ap);
6700     if (retval < 0 || (len > 0 && (Size_t)retval >= len))
6701         Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
6702     return retval;
6703 }
6704
6705 #endif
6706 #endif
6707
6708 #if !defined(my_sprintf)
6709 #if defined(NEED_my_sprintf)
6710 static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
6711 static
6712 #else
6713 extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
6714 #endif
6715
6716 #define my_sprintf DPPP_(my_my_sprintf)
6717 #define Perl_my_sprintf DPPP_(my_my_sprintf)
6718
6719 #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
6720
6721 int
6722 DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)
6723 {
6724     va_list args;
6725     va_start(args, pat);
6726     vsprintf(buffer, pat, args);
6727     va_end(args);
6728     return strlen(buffer);
6729 }
6730
6731 #endif
6732 #endif
6733
6734 #ifdef NO_XSLOCKS
6735 #  ifdef dJMPENV
6736 #    define dXCPT             dJMPENV; int rEtV = 0
6737 #    define XCPT_TRY_START    JMPENV_PUSH(rEtV); if (rEtV == 0)
6738 #    define XCPT_TRY_END      JMPENV_POP;
6739 #    define XCPT_CATCH        if (rEtV != 0)
6740 #    define XCPT_RETHROW      JMPENV_JUMP(rEtV)
6741 #  else
6742 #    define dXCPT             Sigjmp_buf oldTOP; int rEtV = 0
6743 #    define XCPT_TRY_START    Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0)
6744 #    define XCPT_TRY_END      Copy(oldTOP, top_env, 1, Sigjmp_buf);
6745 #    define XCPT_CATCH        if (rEtV != 0)
6746 #    define XCPT_RETHROW      Siglongjmp(top_env, rEtV)
6747 #  endif
6748 #endif
6749
6750 #if !defined(my_strlcat)
6751 #if defined(NEED_my_strlcat)
6752 static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
6753 static
6754 #else
6755 extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
6756 #endif
6757
6758 #define my_strlcat DPPP_(my_my_strlcat)
6759 #define Perl_my_strlcat DPPP_(my_my_strlcat)
6760
6761 #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
6762
6763 Size_t
6764 DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
6765 {
6766     Size_t used, length, copy;
6767
6768     used = strlen(dst);
6769     length = strlen(src);
6770     if (size > 0 && used < size - 1) {
6771         copy = (length >= size - used) ? size - used - 1 : length;
6772         memcpy(dst + used, src, copy);
6773         dst[used + copy] = '\0';
6774     }
6775     return used + length;
6776 }
6777 #endif
6778 #endif
6779
6780 #if !defined(my_strlcpy)
6781 #if defined(NEED_my_strlcpy)
6782 static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
6783 static
6784 #else
6785 extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
6786 #endif
6787
6788 #define my_strlcpy DPPP_(my_my_strlcpy)
6789 #define Perl_my_strlcpy DPPP_(my_my_strlcpy)
6790
6791 #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
6792
6793 Size_t
6794 DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)
6795 {
6796     Size_t length, copy;
6797
6798     length = strlen(src);
6799     if (size > 0) {
6800         copy = (length >= size) ? size - 1 : length;
6801         memcpy(dst, src, copy);
6802         dst[copy] = '\0';
6803     }
6804     return length;
6805 }
6806
6807 #endif
6808 #endif
6809 #ifndef PERL_PV_ESCAPE_QUOTE
6810 #  define PERL_PV_ESCAPE_QUOTE           0x0001
6811 #endif
6812
6813 #ifndef PERL_PV_PRETTY_QUOTE
6814 #  define PERL_PV_PRETTY_QUOTE           PERL_PV_ESCAPE_QUOTE
6815 #endif
6816
6817 #ifndef PERL_PV_PRETTY_ELLIPSES
6818 #  define PERL_PV_PRETTY_ELLIPSES        0x0002
6819 #endif
6820
6821 #ifndef PERL_PV_PRETTY_LTGT
6822 #  define PERL_PV_PRETTY_LTGT            0x0004
6823 #endif
6824
6825 #ifndef PERL_PV_ESCAPE_FIRSTCHAR
6826 #  define PERL_PV_ESCAPE_FIRSTCHAR       0x0008
6827 #endif
6828
6829 #ifndef PERL_PV_ESCAPE_UNI
6830 #  define PERL_PV_ESCAPE_UNI             0x0100
6831 #endif
6832
6833 #ifndef PERL_PV_ESCAPE_UNI_DETECT
6834 #  define PERL_PV_ESCAPE_UNI_DETECT      0x0200
6835 #endif
6836
6837 #ifndef PERL_PV_ESCAPE_ALL
6838 #  define PERL_PV_ESCAPE_ALL             0x1000
6839 #endif
6840
6841 #ifndef PERL_PV_ESCAPE_NOBACKSLASH
6842 #  define PERL_PV_ESCAPE_NOBACKSLASH     0x2000
6843 #endif
6844
6845 #ifndef PERL_PV_ESCAPE_NOCLEAR
6846 #  define PERL_PV_ESCAPE_NOCLEAR         0x4000
6847 #endif
6848
6849 #ifndef PERL_PV_ESCAPE_RE
6850 #  define PERL_PV_ESCAPE_RE              0x8000
6851 #endif
6852
6853 #ifndef PERL_PV_PRETTY_NOCLEAR
6854 #  define PERL_PV_PRETTY_NOCLEAR         PERL_PV_ESCAPE_NOCLEAR
6855 #endif
6856 #ifndef PERL_PV_PRETTY_DUMP
6857 #  define PERL_PV_PRETTY_DUMP            PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE
6858 #endif
6859
6860 #ifndef PERL_PV_PRETTY_REGPROP
6861 #  define PERL_PV_PRETTY_REGPROP         PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
6862 #endif
6863
6864 /* Hint: pv_escape
6865  * Note that unicode functionality is only backported to
6866  * those perl versions that support it. For older perl
6867  * versions, the implementation will fall back to bytes.
6868  */
6869
6870 #ifndef pv_escape
6871 #if defined(NEED_pv_escape)
6872 static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
6873 static
6874 #else
6875 extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
6876 #endif
6877
6878 #ifdef pv_escape
6879 #  undef pv_escape
6880 #endif
6881 #define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
6882 #define Perl_pv_escape DPPP_(my_pv_escape)
6883
6884 #if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
6885
6886 char *
6887 DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,
6888   const STRLEN count, const STRLEN max,
6889   STRLEN * const escaped, const U32 flags)
6890 {
6891     const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\';
6892     const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc;
6893     char octbuf[32] = "%123456789ABCDF";
6894     STRLEN wrote = 0;
6895     STRLEN chsize = 0;
6896     STRLEN readsize = 1;
6897 #if defined(is_utf8_string) && defined(utf8_to_uvchr)
6898     bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0;
6899 #endif
6900     const char *pv  = str;
6901     const char * const end = pv + count;
6902     octbuf[0] = esc;
6903
6904     if (!(flags & PERL_PV_ESCAPE_NOCLEAR))
6905         sv_setpvs(dsv, "");
6906
6907 #if defined(is_utf8_string) && defined(utf8_to_uvchr)
6908     if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
6909         isuni = 1;
6910 #endif
6911
6912     for (; pv < end && (!max || wrote < max) ; pv += readsize) {
6913         const UV u =
6914 #if defined(is_utf8_string) && defined(utf8_to_uvchr)
6915                      isuni ? utf8_to_uvchr((U8*)pv, &readsize) :
6916 #endif
6917                              (U8)*pv;
6918         const U8 c = (U8)u & 0xFF;
6919
6920         if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) {
6921             if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
6922                 chsize = my_snprintf(octbuf, sizeof octbuf,
6923                                       "%"UVxf, u);
6924             else
6925                 chsize = my_snprintf(octbuf, sizeof octbuf,
6926                                       "%cx{%"UVxf"}", esc, u);
6927         } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {
6928             chsize = 1;
6929         } else {
6930             if (c == dq || c == esc || !isPRINT(c)) {
6931                 chsize = 2;
6932                 switch (c) {
6933                 case '\\' : /* fallthrough */
6934                 case '%'  : if (c == esc)
6935                                 octbuf[1] = esc;
6936                             else
6937                                 chsize = 1;
6938                             break;
6939                 case '\v' : octbuf[1] = 'v'; break;
6940                 case '\t' : octbuf[1] = 't'; break;
6941                 case '\r' : octbuf[1] = 'r'; break;
6942                 case '\n' : octbuf[1] = 'n'; break;
6943                 case '\f' : octbuf[1] = 'f'; break;
6944                 case '"'  : if (dq == '"')
6945                                 octbuf[1] = '"';
6946                             else
6947                                 chsize = 1;
6948                             break;
6949                 default:    chsize = my_snprintf(octbuf, sizeof octbuf,
6950                                 pv < end && isDIGIT((U8)*(pv+readsize))
6951                                 ? "%c%03o" : "%c%o", esc, c);
6952                 }
6953             } else {
6954                 chsize = 1;
6955             }
6956         }
6957         if (max && wrote + chsize > max) {
6958             break;
6959         } else if (chsize > 1) {
6960             sv_catpvn(dsv, octbuf, chsize);
6961             wrote += chsize;
6962         } else {
6963             char tmp[2];
6964             my_snprintf(tmp, sizeof tmp, "%c", c);
6965             sv_catpvn(dsv, tmp, 1);
6966             wrote++;
6967         }
6968         if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
6969             break;
6970     }
6971     if (escaped != NULL)
6972         *escaped= pv - str;
6973     return SvPVX(dsv);
6974 }
6975
6976 #endif
6977 #endif
6978
6979 #ifndef pv_pretty
6980 #if defined(NEED_pv_pretty)
6981 static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
6982 static
6983 #else
6984 extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
6985 #endif
6986
6987 #ifdef pv_pretty
6988 #  undef pv_pretty
6989 #endif
6990 #define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)
6991 #define Perl_pv_pretty DPPP_(my_pv_pretty)
6992
6993 #if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
6994
6995 char *
6996 DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,
6997   const STRLEN max, char const * const start_color, char const * const end_color,
6998   const U32 flags)
6999 {
7000     const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
7001     STRLEN escaped;
7002
7003     if (!(flags & PERL_PV_PRETTY_NOCLEAR))
7004         sv_setpvs(dsv, "");
7005
7006     if (dq == '"')
7007         sv_catpvs(dsv, "\"");
7008     else if (flags & PERL_PV_PRETTY_LTGT)
7009         sv_catpvs(dsv, "<");
7010
7011     if (start_color != NULL)
7012         sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color));
7013
7014     pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR);
7015
7016     if (end_color != NULL)
7017         sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color));
7018
7019     if (dq == '"')
7020         sv_catpvs(dsv, "\"");
7021     else if (flags & PERL_PV_PRETTY_LTGT)
7022         sv_catpvs(dsv, ">");
7023
7024     if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count)
7025         sv_catpvs(dsv, "...");
7026
7027     return SvPVX(dsv);
7028 }
7029
7030 #endif
7031 #endif
7032
7033 #ifndef pv_display
7034 #if defined(NEED_pv_display)
7035 static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
7036 static
7037 #else
7038 extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
7039 #endif
7040
7041 #ifdef pv_display
7042 #  undef pv_display
7043 #endif
7044 #define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)
7045 #define Perl_pv_display DPPP_(my_pv_display)
7046
7047 #if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
7048
7049 char *
7050 DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
7051 {
7052     pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
7053     if (len > cur && pv[cur] == '\0')
7054         sv_catpvs(dsv, "\\0");
7055     return SvPVX(dsv);
7056 }
7057
7058 #endif
7059 #endif
7060
7061 #endif /* _P_P_PORTABILITY_H_ */
7062
7063 /* End of File ppport.h */